MSDN Documentation

1. Input Assembler

This is the first stage. It takes raw vertex data (positions, colors, texture coordinates, normals, etc.) from application memory and organizes it into geometric primitives like points, lines, and triangles. These primitives are then fed into the subsequent stages.

Key Responsibilities:

• Reading vertex and index buffers.
• Assembling vertices into primitives (points, lines, triangles).

2. Vertex Shader

The vertex shader is a programmable stage that operates on each vertex individually. Its primary role is to transform vertex positions from model space to clip space using projection matrices. It can also manipulate other vertex attributes like color, texture coordinates, and normals.

Key Responsibilities:

• Vertex transformation (model, view, projection).
• Passing vertex attributes to the next stage.
• Lighting calculations per vertex.

A typical vertex shader might look like this:

struct VS_INPUT {
    float4 position : POSITION;
    float4 color : COLOR;
};

struct VS_OUTPUT {
    float4 position : SV_POSITION;
    float4 color : COLOR;
};

VS_OUTPUT Main(VS_INPUT input) {
    VS_OUTPUT output;
    // Assume matrices are defined globally or passed as constants
    output.position = mul(input.position, worldViewProjectionMatrix);
    output.color = input.color;
    return output;
}
                

3. Hull Shader & Tessellation Shader (Optional)

These stages are part of the tessellation pipeline, which allows for dynamic subdivision of geometry to add finer detail. The Hull Shader controls the tessellation factor, and the Tessellation Shader generates new vertices based on control points.

4. Domain Shader (Optional)

Works in conjunction with tessellation, evaluating the generated primitives using displacement mapping or other techniques.

5. Geometry Shader (Optional)

This programmable stage operates on entire primitives (points, lines, triangles) generated by the previous stages. It can generate new primitives, discard primitives, or modify existing ones. It's often used for effects like particle systems or instancing.

Key Responsibilities:

• Generating new primitives.
• Discarding primitives.
• Stream output.

6. Rasterization

The rasterizer takes the geometric primitives (now in clip space) and determines which pixels on the screen they cover. It interpolates vertex attributes (like color and texture coordinates) across the surface of each primitive for each covered pixel.

Key Responsibilities:

• Clipping primitives against the view frustum.
• Triangle setup and traversal.
• Attribute interpolation (perspective-correct).

7. Pixel Shader (Fragment Shader)

The pixel shader is a programmable stage that executes for each pixel (or fragment) generated by the rasterizer. Its main job is to determine the final color of the pixel by sampling textures, performing lighting calculations, and applying various effects.

Key Responsibilities:

• Texture sampling.
• Complex lighting and shading calculations.
• Fog and other post-processing effects.
• Writing the final pixel color.

A basic pixel shader example:

float4 Main(float4 interpolatedColor : COLOR) : SV_TARGET {
    // Simple pass-through for interpolated color
    return interpolatedColor;
}
                

8. Output Merger

This is the final stage. It performs tests and operations before writing the final pixel color to the render target (the screen or a texture). This includes depth testing (z-buffering), stencil testing, and blending.

Key Responsibilities:

• Depth buffer tests.
• Stencil buffer tests.
• Alpha blending.
• Writing color to the render target.