DirectX Computational Graphics Programming Guide

Hull Tessellation Shaders

Hull tessellation shaders are a powerful feature in modern graphics APIs like DirectX 11 and later, enabling dynamic level of detail (LOD) and complex surface generation directly on the GPU. They work in conjunction with Hull Shader Input and Domain Shaders to subdivide geometric primitives, creating smoother and more detailed surfaces from simpler base meshes.

The Tessellation Stages

Tessellation in DirectX is handled by two distinct shader stages: the Hull Shader (HS) and the Domain Shader (DS). These stages operate after the Vertex Shader and before the Geometry Shader (if present).

• Hull Shader (HS): This shader stage determines how a patch of geometry (like a triangle, quad, or even a higher-order primitive) will be subdivided. It outputs tessellation factors, which dictate the density of the subdivision, and can also output per-patch control data.
• Domain Shader (DS): This shader takes the tessellation factors from the Hull Shader and the control data, along with the original vertices of the primitive. It then computes the final vertices of the subdivided patches, effectively generating new geometric detail.

Hull Shader Functionality

The Hull Shader is responsible for two primary tasks:

1. Calculating Tessellation Factors: These factors control how many new vertices and primitives are generated. They can be dynamically calculated based on factors like camera distance, object complexity, or material properties. This is crucial for implementing adaptive tessellation.
2. Outputting Control Points: The Hull Shader can also output control points that are passed to the Domain Shader. These control points can represent coefficients for Bezier curves, NURBS surfaces, or other mathematical constructs used to define the shape of the tessellated surface.

Hull Shader Input and Output

Hull Shaders operate on entire patches of input primitives. The input to a hull shader typically consists of:

• Control Points: Vertices from the input primitive that will be used by the Domain Shader to reconstruct the surface.
• Tessellation Factors: Factors determining the level of subdivision.

The output of the Hull Shader stage is typically:

• Output Control Points: Control points that are passed to the Domain Shader.
• Tessellation Factors: The tessellation factors computed by the Hull Shader.

Example: Basic Tessellation Factors

Consider a simple scenario where we want to tessellate a triangle based on its distance from the camera. The Hull Shader might look something like this:

// Example Hull Shader (HLSL)

// Input patch structure
struct HS_INPUT_PATCH
{
    float4 position : POSITION;
    float2 texCoord : TEXCOORD;
};

// Output patch structure (control points passed to Domain Shader)
struct HS_OUTPUT_CONTROL_POINT
{
    float4 position : POSITION;
    float2 texCoord : TEXCOORD;
};

// Output hull shader patch structure (tessellation factors)
struct HS_OUTPUT_PATCH_CONSTANT
{
    float EdgeTessFactor[3] : SV_TessFactor;
    float InsideTessFactor : SV_InsideTessFactor;
};

// Constant buffers and textures would be declared here...

// Hull Shader Main Function
[domain("tri")] // Specifies the domain, e.g., "tri", "quad"
[partitioning("fractional_even")] // Tessellation partitioning scheme
[outputtopology("triangle_cw")] // Output topology
[patchconstantfunc("PatchConstantFunc")] // Function to calculate tessellation factors
[outputcontrolpoints(3)] // Number of output control points for a triangle
[inputcontrolpoints(3)] // Number of input control points for a triangle
HS_OUTPUT_CONTROL_POINT HSMain(InputPatch patch, uint id : SV_OutputControlPointID)
{
    HS_OUTPUT_CONTROL_POINT outCP;
    outCP.position = patch[id].position;
    outCP.texCoord = patch[id].texCoord;
    return outCP;
}

// Function to calculate tessellation factors
HS_OUTPUT_PATCH_CONSTANT PatchConstantFunc(InputPatch patch)
{
    HS_OUTPUT_PATCH_CONSTANT outConst;

    // Example: Calculate tessellation factors based on distance (simplified)
    // In a real scenario, you'd use camera position and object bounding box.
    float distance = length(patch[0].position.xyz); // Placeholder
    float tessFactor = saturate(10.0f / distance); // Basic LOD

    outConst.EdgeTessFactor[0] = tessFactor;
    outConst.EdgeTessFactor[1] = tessFactor;
    outConst.EdgeTessFactor[2] = tessFactor;
    outConst.InsideTessFactor = tessFactor; // For triangles, inside is often same as edges

    return outConst;
}
                

Domain Shader Functionality

The Domain Shader receives the tessellated parameters from the Hull Shader and generates the final vertices for the subdivided primitives. It interpolates the control points based on the tessellation factors and the domain coordinates (e.g., barycentric coordinates for triangles) to produce the final vertex positions.

Domain Shader Input and Output

The input to a Domain Shader typically includes:

• Tessellation Factors: From the Hull Shader.
• Control Points: From the Hull Shader.
• Domain Coordinates: Coordinates that specify the position within the tessellated patch (e.g., barycentric coordinates for triangles, UV coordinates for quads).

The output of the Domain Shader is usually:

• Final Vertex Position: The computed position of each vertex in the tessellated mesh.
• Other Vertex Attributes: Interpolated attributes like normals, texture coordinates, etc.

When to Use Tessellation

Hull tessellation shaders are particularly useful for:

• Dynamic Level of Detail (LOD): Automatically generating more detail for objects closer to the camera and less for distant ones, saving rendering resources.
• Smooth Surfaces: Creating smooth curves and surfaces (like terrain, character skin, or cloth) from low-polygon base meshes.
• Procedural Geometry Generation: Dynamically generating complex geometric patterns or structures.
• Displacement Mapping: Using height maps to displace vertices and add realistic surface detail.

Next Steps

To further your understanding, explore the Domain Shaders section to see how the output of the Hull Shader is processed. Understanding the interplay between these two stages is key to mastering tessellation in DirectX.