MSDN Documentation

The Output Merger Stage

The Output Merger (OM) stage is the final stage of the programmable graphics pipeline. It performs operations on pixels after they have been processed by the pixel shader. These operations determine which pixels are written to the render target(s) and the depth-stencil buffer.

The Output Merger stage is responsible for a variety of crucial tasks, including:

• Blending: Combining the output color of a pixel with the color already present in the render target.
• Depth Testing: Determining if a pixel is in front of or behind existing pixels based on depth values.
• Stencil Testing: Performing tests based on values in the stencil buffer, enabling effects like shadows and reflections.
• Color and Alpha Operations: Writing final pixel colors and alpha values to the render target.
• Multiple Render Targets (MRTs): Writing to more than one render target simultaneously.

Core Components and Operations

1. Blending

Blending allows for the realistic rendering of transparent or translucent objects. The output color from the pixel shader is combined with the existing color in the render target based on a user-defined blend function and factors.

The general formula for blending is:

OutputColor = (SourceColor * SourceFactor) BlendOp (DestColor * DestFactor)

Where:

• SourceColor is the color output by the pixel shader.
• DestColor is the color currently in the render target.
• SourceFactor and DestFactor are constants that determine how much influence the source and destination colors have. These can be based on the source alpha, destination alpha, constant blend factor, or even per-channel values.
• BlendOp is the operation to perform between the two components (e.g., Add, Subtract, Min, Max).

2. Depth Testing (Z-Buffering)

Depth testing is fundamental for correctly rendering 3D scenes, ensuring that objects closer to the viewer obscure objects farther away. Each pixel processed by the pipeline has a depth value (often referred to as the Z-value). The depth-stencil buffer stores the depth value of the pixel currently written to the render target at each screen coordinate.

When a new pixel arrives:

1. Its depth value is compared to the depth value stored in the depth-stencil buffer for that pixel's screen coordinate.
2. A depth comparison function (e.g., Less, Greater, Equal, Never, Always) is used to determine if the new pixel should replace the existing pixel.
3. If the test passes, the new pixel's color and depth are written to the render target and depth-stencil buffer, respectively.

3. Stencil Testing

The stencil buffer works in conjunction with the depth-stencil buffer and provides a more flexible mechanism for masking and performing conditional operations on pixels. It stores an 8-bit integer value for each pixel.

Stencil operations are controlled by:

• Stencil Comparison Function: Determines if the new pixel's stencil value passes a comparison against the stored stencil value.
• Stencil Fail Operation: What to do if the stencil test fails (e.g., keep the current stencil value, set it to zero, increment).
• Depth Buffer Fail Operation: What to do if the stencil test passes but the depth test fails.
• Stencil Pass Operation: What to do if both stencil and depth tests pass.

Stencil testing is often used for effects like:

• Shadow volumes: Extruding geometry to create shadow masks.
• Reflections: Masking areas where reflections should appear.
• Advanced rendering techniques: Enabling complex visual effects.

4. Multiple Render Targets (MRTs)

Modern graphics hardware supports rendering to multiple render targets simultaneously from a single pixel shader. This is known as Multiple Render Targets (MRTs). This capability is highly beneficial for techniques like deferred shading, where different attributes (e.g., color, normals, depth) can be rendered to separate textures in a single pass.

When using MRTs, the pixel shader must output data to multiple semantic streams, and the output merger stage must be configured to accept these multiple outputs.

Programmability and Fixed Functions

While some aspects of the Output Merger, such as basic blending and depth testing, can be configured using fixed-function states, more advanced blending logic, conditional operations, and the behavior of MRTs often involve programmable shaders that interact with the OM stage.

Output Merger State

The behavior of the Output Merger stage is controlled by a complex set of states that can be set by the application:

• Render Target Views (RTVs) and their corresponding Blend States.
• Depth-Stencil View (DSV) and its corresponding Depth-Stencil State.
• Sample Mask.
• Stencil Reference Value.

Understanding the Output Merger stage is critical for achieving accurate, visually appealing, and performant rendering in DirectX applications. It is where the final pixel colors are composed and committed to the frame buffer.