Geometry Processing in DirectX

Understanding the Geometry Pipeline

The geometry processing stage is primarily handled by the Vertex Shader, and optionally by the Hull Shader, Tessellator, Domain Shader, and Geometry Shader. These programmable stages allow for complex manipulations of vertex data.

Vertex Shader

The Vertex Shader is the core of geometry processing. It receives input vertex data (position, color, texture coordinates, normals, etc.) and transforms it through a series of operations. The most fundamental transformation is the transformation from object space to clip space, which involves matrix multiplications (world, view, projection).

// Example Vertex Shader (Simplified)
struct VS_INPUT {
    float4 position : POSITION;
    float4 color : COLOR0;
};

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

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

VS_OUTPUT main(VS_INPUT input) {
    VS_OUTPUT output;
    output.position = mul(input.position, worldViewProjection);
    output.color = input.color;
    return output;
}

Tessellation Stages (Optional)

DirectX 11 introduced tessellation, allowing for dynamic subdivision of geometry at runtime. This enables the creation of more detailed surfaces from low-polygon models.

• Hull Shader: Generates tessellation factors and controls the subdivision pattern.
• Tessellator: Performs the actual subdivision based on tessellation factors.
• Domain Shader: Executes for each new vertex generated by the tessellator, allowing for per-vertex adjustments in position and other attributes.

Geometry Shader (Optional)

The Geometry Shader can take entire primitives (points, lines, triangles) as input and output new primitives. This is useful for tasks like generating fur, scattering objects, or creating complex particle systems directly on the GPU.

A common use case is generating multiple vertices from a single input vertex, such as creating billboards or extruding faces.

Vertex Data and Input Layout

Defining the structure of your vertex data is critical. This is done using the Input Layout, which tells the GPU how to interpret the bytes in your vertex buffer.

Each vertex attribute (position, normal, UVs, etc.) is given a semantic name (e.g., POSITION, NORMAL, TEXCOORD) which is used to connect the input data to the vertex shader.

Common Vertex Input Semantics

Semantic	Description	Example Data Type
POSITION	Vertex position in object space.	float4
NORMAL	Surface normal for lighting calculations.	float3 or float4
TEXCOORD	Texture coordinates. Can have multiple streams (TEXCOORD0, TEXCOORD1, ...).	float2, float3, float4
COLOR	Vertex color. Can have multiple streams (COLOR0, COLOR1, ...).	float4
TANGENT	Tangent vector for normal mapping.	float3

Transformations

Geometry processing involves several coordinate space transformations:

• Object Space: Vertices are defined relative to the model's local origin.
• World Space: Vertices are transformed into a common scene space.
• View Space (Camera Space): Vertices are transformed relative to the camera's position and orientation.
• Clip Space (Projection Space): Vertices are transformed into a normalized coordinate system suitable for clipping and projection.

These transformations are typically combined into a single World-View-Projection (WVP) matrix for efficiency.

Output of Geometry Processing

The output of the geometry processing stages is a set of vertices in Clip Space. These vertices are then subjected to clipping (discarding geometry outside the view frustum) and perspective division, resulting in vertices in Normalized Device Coordinates (NDC). This NDC space is then mapped to screen space by the viewport transform.