How DirectX VRS Tier 1 and Tier 2 Optimize GPU Performance

DirectX Variable Rate Shading (VRS) is a modern rendering feature that boosts GPU performance by dynamically altering the pixel shading rate across different areas of a rendered frame. Instead of executing the pixel shader once for every single pixel on screen, VRS allows groups of adjacent pixels to share a single shader invocation, significantly reducing GPU workload without visibly degrading visual fidelity. This article details the core mechanics of VRS, breaks down the technical differences between Tier 1 and Tier 2 implementations, and explains how both tiers optimize rendering efficiency.

Understanding Variable Rate Shading

In traditional rendering, a GPU runs pixel shader calculations at a 1:1 ratio for every pixel on screen. While this ensures consistent precision, it creates unnecessary computational overhead in scenes where fine detail is obscured by high-speed motion, depth-of-field effects, heavy shadows, or low-contrast textures.

VRS solves this inefficiency by decoupling the rasterization resolution from the shading resolution. The GPU can group pixels into blocks—such as 1x2, 2x1, 2x2, 2x4, 4x2, or 4x4—and evaluate the pixel shader once for the entire block. The computed color value is then applied across all pixels within that block, drastically cutting the number of shader evaluations required to draw the frame.

DirectX VRS Tier 1: Per-Draw Call Optimization

DirectX VRS Tier 1 provides broad, coarse-grained control over shading rates on a per-draw-call basis.

• Mechanism: In Tier 1, developers specify the shading rate globally for an entire draw call. Every primitive rendered within that single call shares the same shading frequency.
• Optimization Strategy: Tier 1 is primarily used to optimize passes and geometry where detail is uniformly unimportant. Developers can aggressively lower the shading rate (e.g., 2x2 or 4x4) for distant background objects, heavily blurred transparent particle systems (like smoke, fog, or dust), or depth pre-passes.
• Limitations: Tier 1 cannot vary the shading rate within a single draw call. If an object is partially in shadow and partially under bright direct light, or if it spans from the foreground to the far background, developers must choose between shading the entire object at full quality or accepting potential visual degradation across the entire mesh.

DirectX VRS Tier 2: Granular and Screen-Space Optimization

DirectX VRS Tier 2 builds upon Tier 1 by introducing fine-grained spatial control, allowing shading rates to vary dynamically within the same draw call.

• Screen-Space Shading Rate Images: Tier 2 allows developers to supply a screen-space texture (a "shading rate image") where each texel dictates the shading rate for an underlying tile of screen pixels (typically 8x8 or 16x16 pixels). This enables games to analyze previous frames, motion vectors, luminance, or depth buffers to generate a per-tile shading map that selectively lowers precision in dark or fast-moving screen regions while preserving sharp edges.
• Per-Primitive Shading Rates: In addition to screen-space masking, Tier 2 allows the vertex or geometry shader to assign specific shading rates to individual triangles before rasterization.
• Combiners: Tier 2 introduces combiner operations (such as Min, Max, Passthrough, or Override) that automatically resolve conflicts when a per-draw-call rate, a per-primitive rate, and a screen-space shading rate image intersect. For example, a combiner can ensure the GPU always chooses the highest quality (Min rate) to prevent visual artifacts on high-contrast edges.

Performance Impact: Tier 1 vs. Tier 2

The key difference in performance optimization between the two tiers lies in precision and flexibility:

By reducing the sheer number of pixel shader invocations required per frame, DirectX VRS Tier 1 and Tier 2 alleviate memory bandwidth bottlenecks, reduce GPU thermal draw, and free up computational headroom. This allows game engines to maintain higher framerates, target higher display resolutions, or reallocate compute resources toward advanced visual effects like ray tracing.