Graphics Pipelines

A graphics pipeline is a series of programmable stages that process geometry data and transform it into the pixels displayed on your screen. Understanding these stages is fundamental to efficient and powerful graphics rendering.

The Fixed-Function vs. Programmable Pipeline

Historically, graphics hardware featured many "fixed-function" units that performed specific tasks in a predefined order. Modern graphics APIs, like DirectX and Vulkan, emphasize programmable shaders. These are small programs that run on the GPU and give developers fine-grained control over each stage of the pipeline.

Core Stages of a Modern Graphics Pipeline

While the exact names and capabilities can vary between graphics APIs, the general flow of a modern programmable graphics pipeline includes the following key stages:

1. Input Assembler (IA)

This stage takes raw vertex data (positions, normals, texture coordinates, etc.) from application memory and organizes it into primitives (points, lines, triangles) that the rest of the pipeline can process.

2. Vertex Shader (VS)

The vertex shader operates on each vertex individually. Its primary role is to transform the vertex's position from model space to clip space (a normalized coordinate system). It can also pass per-vertex data (like color or texture coordinates) to subsequent stages.

Vertex Shader Example (HLSL-like syntax)


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;
    output.position = mul(input.position, worldViewProjectionMatrix);
    output.color = input.color;
    return output;
}

3. Hull Shader (HS) & Domain Shader (DS) (Tessellation)

These optional stages enable tessellation, a technique for dynamically subdividing geometry to add more detail. The Hull Shader controls the tessellation factor, and the Domain Shader generates new vertices based on the tessellation.

4. Geometry Shader (GS)

The geometry shader operates on entire primitives (points, lines, triangles). It can generate new primitives, discard existing ones, or modify existing primitives. This stage is less commonly used in performance-critical paths compared to vertex and pixel shaders.

5. Rasterizer (RS)

The rasterizer takes the primitives output by the previous stages and determines which pixels on the screen are covered by each primitive. It performs interpolation of vertex attributes (like color or texture coordinates) across the surface of the primitive.

6. Pixel Shader (PS) / Fragment Shader

The pixel shader (also known as a fragment shader) operates on each individual pixel (or fragment) generated by the rasterizer. Its main job is to determine the final color of the pixel, often by sampling textures, applying lighting calculations, and using interpolated data.

Pixel Shader Example (HLSL-like syntax)


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

float4 main(PS_INPUT input) : SV_TARGET {
    return input.color;
}

7. Output Merger (OM)

This final stage writes the pixel colors to the render target (the frame buffer). It also handles depth testing, stencil testing, and blending operations to correctly composite the final image.

Interoperability and API Differences

While the core concepts are similar, DirectX (Direct3D) and Vulkan have different naming conventions and specific features for their pipeline stages. Understanding these differences is crucial when working across platforms.

Resources