In this lesson, you will learn how to leverage Nanite’s programmable compute-based rasterizer to bypass traditional hardware limitations when rendering high-density geometry.
The Limitation of Fixed-Function Hardware
Standard hardware rasterizers (the fixed-function pipelines in your GPU) are incredibly efficient at handling thousands of polygons. However, they struggle when the geometry becomes "pixel-dense"—a scenario where you have multiple triangles covering a single pixel. This leads to massive overdraw and stalls in the primitive assembly stage, causing significant performance degradation regardless of how optimized your shaders are.
The Compute-Based Solution
Nanite solves this by utilizing a programmable, software-based rasterization pipeline. Instead of relying solely on the GPU’s fixed-function units, Nanite utilizes compute shaders to perform "Visibility Buffer" rendering. By processing geometry as clusters of triangles, Nanite can decide—at a compute level—which pixels are actually visible before hitting the expensive fragment shading stage.
In scenarios with extreme geometric complexity (e.g., millions of polygons in a small viewport), this approach is significantly faster than the hardware pipeline. It allows you to skip the fixed-function overhead and handle small, sub-pixel triangles much more efficiently.
Implementation Logic
When you enable Nanite on a mesh, you are essentially offloading the rasterization task to the compute pipeline. You can monitor this in the console using:
r.Nanite.ComputeRasterizer 1
When this is active, the engine processes geometry clusters using compute shaders rather than the standard triangle-to-pixel hardware path. This is especially vital when dealing with complex meshes that would otherwise overwhelm the hardware rasterizer. You don’t need to write the compute shaders yourself, but you must ensure your meshes are set to "Nanite" in the Static Mesh Editor to allow the engine to route them through this high-performance path.
By choosing compute-based rasterization for your dense assets, you effectively transform a potential bottleneck (geometric complexity) into a manageable stream of compute tasks that scale linearly with your screen resolution rather than your poly count.
Key Takeaway: Nanite’s programmable rasterizer shifts the burden from fixed-function hardware to compute shaders, allowing you to render virtually infinite geometry by processing clusters of triangles based on actual screen-space visibility.