DirectX Documentation

Geometry Shading

Geometry shaders are a programmable stage in the DirectX rendering pipeline that can take a primitive (a point, line, or triangle) as input and output one or more primitives. This allows for dynamic generation and manipulation of geometry on the GPU, opening up a wide range of visual effects and optimization possibilities.

Overview

Unlike vertex shaders, which process one vertex at a time, geometry shaders operate on entire primitives. They are invoked after the vertex shader and before the rasterizer. A single invocation of a geometry shader receives a primitive (and its associated vertices) and can emit:

• No primitives.
• One or more copies of the original primitive.
• Completely new primitives composed of new vertices.

Simplified flow of a primitive through the rendering pipeline with Geometry Shading.

Key Capabilities

• Primitive Generation: Create new geometry dynamically, such as extruding faces, generating billboards, or creating particle systems directly from existing geometry.
• Primitive Modification: Duplicate primitives, remove them, or change their topology.
• Tessellation (before DX11 Hull/Domain Shaders): In older versions of DirectX or specific contexts, geometry shaders could be used for basic tessellation effects.
• Level of Detail (LOD): Generate simplified or more detailed versions of geometry based on distance or other factors.

Input and Output

Geometry shaders can be configured to accept specific input primitive types, such as:

• Points
• Line Strips
• Triangles
• Line Lists
• Triangle Lists
• Triangle Strips

The output primitive type is specified when writing the shader and can be:

• Point List
• Line List
• Triangle List
• Line Strip
• Triangle Strip

A crucial aspect is the ability to emit vertices. Each emitted vertex can have its own set of attributes, including position, color, texture coordinates, and other custom data.

Example Snippet (HLSL)

Here's a conceptual example of a geometry shader that takes a triangle as input and outputs two triangles (effectively duplicating the original).

// Input primitive type: Triangle
// Output primitive type: Triangle List
[maxvertexcount(6)] // Max output vertices: 2 triangles * 3 vertices/triangle
void GS(triangleinput primitive[3] : SV_POSITION)
{
    // Emit the first triangle (original)
    for (int i = 0; i < 3; ++i)
    {
        AppendVertex(primitive[i]);
    }
    EndPrimitive();

    // Emit a second triangle (e.g., slightly offset or modified)
    for (int i = 0; i < 3; ++i)
    {
        // Example modification: offset in Y
        VertexOutput v;
        v.position = primitive[i].position;
        v.position.y += 0.1f; // Simple offset
        v.color = primitive[i].color;
        AppendVertex(v);
    }
    EndPrimitive();
}

Considerations

• Performance: Geometry shaders can be computationally expensive if not used judiciously. Generating large amounts of geometry can significantly impact performance.
• Complexity: Writing and debugging geometry shaders can be more complex than vertex or pixel shaders due to the primitive-level operations.
• Alternatives: For dynamic geometry generation, consider using compute shaders or tessellation stages (Hull/Domain Shaders in DX11+) where appropriate, as they might offer better performance or a more suitable programming model for certain tasks.

Use Cases

• Particle Systems: Generating quads (billboards) for particles from a single point.
• Instancing: Programmatically creating instances of geometry.
• Procedural Generation: Generating complex meshes on the fly.
• Shadow Volume Generation: Creating shadow volumes for deferred rendering techniques.

Geometry shaders provide a powerful tool for developers to extend the capabilities of the DirectX rendering pipeline, enabling advanced graphical techniques and optimizations.