DirectX Computational Graphics

This stage takes your raw vertex data (positions, normals, texture coordinates, colors, etc.) and assembles it into primitives like triangles, lines, or points, based on your defined topology.

• Processes vertex buffers and index buffers.
• Determines how geometric primitives are formed.

The Vertex Shader is your first programmable stage. It operates on each vertex individually, transforming its position from model space to clip space. This involves operations like model-view-projection transformations, lighting calculations, and passing per-vertex data to subsequent stages.

• Input: Per-vertex attributes (position, normal, UV, color).
• Output: Transformed vertex position in clip space, plus any user-defined data to be interpolated across the primitive (e.g., color, texture coordinates).
• Common operations: Matrix transformations (world, view, projection), per-vertex lighting.

Example Vertex Shader output structure:

struct VS_OUTPUT {
    float4 Position : SV_POSITION; // Clip-space position
    float4 Color    : COLOR;      // Interpolated color
    float2 TexCoord : TEXCOORD0;  // Interpolated texture coordinates
};

This optional stage can dynamically subdivide primitives, allowing for more detailed geometry to be generated on the GPU. It typically involves three sub-stages:

• Hull Shader (HS): Controls tessellation factors and generates patches.
• Tessellator (Tess): Generates new vertices within patches.
• Domain Shader (DS): Processes the newly generated vertices, applying transformations and potentially displacement mapping.

The Geometry Shader can process entire primitives (points, lines, triangles). It can discard primitives, generate new ones, or modify existing ones, offering flexibility for effects like generating fur or particle systems.

• Input: One or more primitives (points, lines, triangles).
• Output: Zero or more primitives.

The Rasterizer takes the geometric primitives (now in clip space) and determines which pixels on the screen are covered by them. It performs clipping against the view frustum and interpolates vertex attributes across the face of each primitive.

• Performs clipping.
• Performs perspective-correct interpolation of attributes (color, texture coordinates, etc.).
• Generates "fragments" (potential pixels to be colored).

The Pixel Shader (also known as Fragment Shader) is responsible for determining the final color of each pixel. It runs for every fragment generated by the rasterizer. This is where complex lighting, texturing, and material properties are applied.

• Receives interpolated vertex attributes.
• Performs texturing, lighting calculations, and other shading effects.
• Output: The final color (and potentially depth) for the pixel.

Example Pixel Shader output:

struct PS_OUTPUT {
    float4 Color : SV_Target; // Final RGBA color
};

The final stage. It combines the colors output by the Pixel Shader with the existing contents of the render target (frame buffer). This stage handles depth testing, stencil testing, and blending operations to produce the final image you see on the screen.

• Depth testing (Z-buffering).
• Stencil testing.
• Blending (transparency).
• Writes the final pixel color to the render target.