MSDN Documentation

DirectX Graphics Pipelines

The graphics pipeline is a series of programmable and fixed-function stages that transform 3D data into the 2D pixels displayed on the screen. Understanding the pipeline is fundamental to efficient and effective graphics programming with DirectX.

The Programmable Graphics Pipeline

Modern DirectX versions (DirectX 10 and later) heavily rely on a programmable graphics pipeline. This means that developers have direct control over key stages of the rendering process by writing custom shader programs. The typical programmable pipeline consists of the following core stages:

• Input Assembler (IA): Responsible for reading vertex data from buffers and assembling it into primitives (points, lines, triangles).
• Vertex Shader (VS): Processes each vertex individually, transforming its position from model space to clip space, and can also manipulate vertex attributes like color and texture coordinates.
• Hull Shader (HS) & Domain Shader (DS): Used in tessellation to dynamically generate more geometric detail from a coarse mesh.
• Geometry Shader (GS): Can create or destroy primitives, allowing for effects like generating billboards or expanding points into quads.
• Rasterizer (RA): Takes primitives defined by vertices and determines which pixels on the screen they cover. It also performs clipping and culling.
• Pixel Shader (PS) / Fragment Shader: Processes each individual pixel (or fragment) that the rasterizer identifies as part of a primitive. It determines the final color of the pixel, often by sampling textures and applying lighting calculations.
• Output Merger (OM): Writes the final pixel colors to the render target, performing depth and stencil tests, blending, and other operations.

Shaders are written in High-Level Shading Language (HLSL), which is then compiled into shader bytecode that the GPU can execute.

Fixed-Function Pipeline (Legacy)

Older versions of DirectX (prior to DirectX 10) featured a fixed-function pipeline. While less flexible, it provided a simpler, hardware-defined set of operations. Many of these functions are now handled by programmable shaders:

• Transformation and Lighting (T&L)
• Texturing
• Color Blending
• Alpha Test

While modern development focuses on the programmable pipeline, understanding the fixed-function pipeline can be helpful for maintaining legacy applications or comprehending older graphics concepts.

Shader Stages in Detail

Let's delve a bit deeper into the most common programmable shader stages:

Vertex Shader

The vertex shader is executed once for every vertex submitted to the pipeline. Its primary responsibilities include:

• Applying model, view, and projection transformations to vertex positions.
• Performing lighting calculations per vertex.
• Passing attributes (like color, texture coordinates, normals) to subsequent stages.

Example HLSL (simplified):

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

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

VS_OUTPUT main(VS_INPUT input) {
    VS_OUTPUT output;
    // Transform position to clip space
    output.position = mul(input.position, g_WorldViewProjection);
    // Pass color through
    output.color = input.color;
    return output;
}
                

Pixel Shader

The pixel shader is executed for every pixel that a primitive covers on the screen. It determines the final color of that pixel. Common tasks include:

• Sampling textures to get color information.
• Applying lighting and material properties.
• Performing alpha blending and transparency effects.

Example HLSL (simplified):

Texture2D    g_Texture;
SamplerState g_Sampler;

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

float4 main(PS_INPUT input) : SV_TARGET {
    // Sample texture and apply vertex color
    float4 texColor = g_Texture.Sample(g_Sampler, input.texCoord); // Assuming texCoord is passed from VS
    return texColor * input.color;
}