MSDN Documentation

Understanding the Vertex Pipeline in DirectX

Welcome to this in-depth tutorial on the vertex pipeline, a fundamental component of DirectX graphics rendering. The vertex pipeline is responsible for transforming, lighting, and clipping 3D model data before it's passed to the pixel pipeline.

What is the Vertex Pipeline?

The vertex pipeline is a sequence of programmable and fixed-function stages that process individual vertices. Each vertex, representing a point in 3D space, goes through this pipeline, undergoing transformations and calculations to determine its final position and attributes on the screen. Understanding this pipeline is crucial for any DirectX developer aiming to create efficient and visually stunning graphics.

Key Stages of the Vertex Pipeline

The vertex pipeline can be broadly categorized into the following stages:

• Input Assembler: Reads vertex data from memory and organizes it into primitives (like triangles, lines, or points).
• Vertex Shader: The first programmable stage. It takes vertex data as input and outputs transformed vertex data. This is where world, view, and projection transformations are applied.
• Tessellation (Optional): Stages that dynamically add more detail to geometry by subdividing polygons.
• Geometry Shader (Optional): A programmable stage that can create or destroy primitives.
• Stream Output (Optional): Allows writing vertex data to a buffer for post-processing or reuse.
• Rasterizer: Takes the transformed primitives and figures out which pixels on the screen they cover.
• Output Merger: Combines the results from the pixel shader (which runs after rasterization) with depth, stencil, and color buffers.

The Vertex Shader: The Core of Transformation

The Vertex Shader is where most of the vertex processing happens. In DirectX, you typically write vertex shaders using High-Level Shading Language (HLSL).

A common task in a vertex shader is applying the model-view-projection (MVP) matrix:

struct VS_INPUT {
    float4 pos : POSITION;
    float3 normal : NORMAL;
};

struct VS_OUTPUT {
    float4 pos : SV_POSITION;
    float3 normal : NORMAL;
};

cbuffer TransformMatrix : register(b0) {
    matrix worldViewProjection;
};

VS_OUTPUT main(VS_INPUT input) {
    VS_OUTPUT output;
    output.pos = mul(input.pos, worldViewProjection);
    output.normal = input.normal; // Pass normal for later stages
    return output;
}
                    

In this example:

• VS_INPUT defines the data coming into the shader (vertex position and normal).
• VS_OUTPUT defines the data going out of the shader. SV_POSITION is a special semantic required for the final clip-space position.
• A constant buffer (TransformMatrix) holds the combined MVP matrix.
• The main function multiplies the input position by the MVP matrix to transform it into clip space.

Input Assembler and Primitives

Before vertices reach the vertex shader, the Input Assembler stages must correctly interpret the raw vertex data. This involves defining vertex layouts and specifying how to draw primitives (e.g., triangles for solid surfaces, lines for wireframes).

Next Steps

Now that you have a grasp of the vertex pipeline, you're ready to explore the next stage: the Pixel Pipeline. Continue to the Pixel Pipeline Tutorial to learn how individual pixels are colored and shaded.