Rasterization

Rasterization is a fundamental process in computer graphics that transforms geometric primitives (like triangles) into a set of pixels on a screen. It's the bridge between the mathematical representation of objects and their visual representation. In DirectX, the rasterizer stage is responsible for determining which pixels are covered by a primitive and interpolating vertex attributes across those pixels.

The Rasterization Process

The rasterizer stage takes the primitives that have been processed by the geometry shader (or directly from the vertex shader if the geometry shader is not used) and determines which pixels on the render target are affected. For each pixel that is determined to be covered by a primitive, the rasterizer generates a pixel shader invocation.

The core steps involved in rasterizing a triangle include:

Clipping: Primitives are clipped against the viewing frustum and the viewport. Any parts of the primitive that lie outside these boundaries are discarded or modified.
Triangle Setup: For each triangle, the rasterizer determines its screen-space bounding box. This helps in efficiently iterating over potential pixels.
Edge Function Evaluation: The rasterizer uses edge functions (often barycentric coordinates) to determine if a pixel's center lies inside the triangle. For a pixel at coordinates (x, y), three edge functions are evaluated, one for each edge of the triangle. If all three edge functions have the same sign (or are zero), the pixel is considered inside the triangle.
Attribute Interpolation: Once a pixel is determined to be inside a triangle, its vertex attributes (such as color, texture coordinates, normals) are interpolated across the triangle using barycentric coordinates. This interpolated data is then passed to the pixel shader.

Key Concepts in Rasterization

Edge Functions and Barycentric Coordinates

Barycentric coordinates provide a way to represent any point inside a triangle as a weighted average of its vertices. If a triangle has vertices $V_0, V_1, V_2$ and a point P inside it, P can be expressed as:

$$ P = \alpha V_0 + \beta V_1 + \gamma V_2 $$

where $\alpha + \beta + \gamma = 1$ and $\alpha, \beta, \gamma \ge 0$. These coefficients $\alpha, \beta, \gamma$ are the barycentric coordinates. The rasterizer effectively calculates these coefficients for each pixel to determine coverage and interpolate attributes.

Polygon Fill Mode

DirectX allows you to control how polygons are filled. Common fill modes include:

D3D11_FILL_SOLID: Fills the entire polygon. This is the default.
D3D11_FILL_WIREFRAME: Renders only the edges of the polygon.

This is configured through the D3D11_RASTERIZER_DESC structure.

Culling

Culling is a performance optimization technique to discard primitives that will not be visible to the camera. Back-face culling, for example, discards triangles whose front face is pointing away from the viewer. DirectX supports different culling modes:

D3D11_CULL_NONE: No culling is performed.
D3D11_CULL_FRONT: Front-facing triangles are culled.
D3D11_CULL_BACK: Back-facing triangles are culled. This is the default and most common setting.

The culling mode is also set in the D3D11_RASTERIZER_DESC structure.

Scissor Rectangles

Scissor rectangles define rectangular regions on the screen. Pixels outside these rectangles are discarded before the pixel shader stage. This is useful for optimizing rendering by only processing pixels within a specific area of interest.

Depth Bias

Depth bias is a technique used to prevent rendering artifacts like Z-fighting, which occurs when two polygons have very similar depth values and flicker on screen. Depth bias adds a small constant value to the depth of a primitive during rasterization.

Note: Rasterization is an inherently hardware-dependent process. The exact implementation details can vary between different graphics hardware. However, the conceptual steps and the outcomes are standardized by APIs like DirectX.

Important: The efficiency of rasterization is crucial for real-time graphics performance. Understanding how it works helps in optimizing geometry and shaders.

Rasterizer State in DirectX

The behavior of the rasterizer stage is controlled by a rasterizer state object. This object is created from a D3D11_RASTERIZER_DESC structure, which specifies parameters like fill mode, culling mode, depth bias, scissor enable, and multisample antialiasing.

D3D11_RASTERIZER_DESC rsDesc;
rsDesc.FillMode = D3D11_FILL_SOLID;
rsDesc.CullMode = D3D11_CULL_BACK;
rsDesc.FrontCounterClockwise = FALSE; // Typically FALSE for clockwise winding order
rsDesc.DepthBias = 0;
rsDesc.SlopeScaledDepthBias = 0.0f;
rsDesc.DepthBiasClamp = 0.0f;
rsDesc.DepthClipEnable = TRUE; // Clip primitives against the near and far planes
rsDesc.ScissorEnable = FALSE; // Enable scissor test
rsDesc.MultisampleEnable = FALSE; // Enable multisampling
rsDesc.AntialiasedLineEnable = FALSE;

ID3D11RasterizerState* pRasterizerState;
// Assume pDevice is a valid ID3D11Device pointer
HRESULT hr = pDevice->CreateRasterizerState(&rsDesc, &pRasterizerState);

if (SUCCEEDED(hr)) {
    // Bind the rasterizer state to the pipeline
    pImmediateContext->RSSetState(pRasterizerState);
    // Release the state when no longer needed
    pRasterizerState->Release();
}

Once created, the rasterizer state object is bound to the pipeline using the ID3D11DeviceContext::RSSetState method.

Antialiasing

Rasterization can lead to "jaggies" or aliasing artifacts, especially on diagonal lines and object edges. DirectX provides support for various antialiasing techniques, such as multisample antialiasing (MSAA), which is enabled by setting MultisampleEnable to TRUE in the D3D11_RASTERIZER_DESC and configuring the output merger stage appropriately.