GPU Driven Rendering

What is GPU Driven Rendering

GPU Driven Rendering is a modern rendering architecture that transfers tasks traditionally handled by the CPU, such as scene management and draw call generation, to the GPU. This reduces communication overhead between CPU and GPU and leverages the GPU's parallel computing capabilities, making it especially suitable for rendering large and complex scenes.

Bottlenecks of Traditional Rendering

In the traditional rendering pipeline, the CPU must perform the following operations for each object:

• Frustum Culling
• Occlusion Culling
• LOD selection
• Draw call generation

These operations can become CPU bottlenecks when dealing with massive numbers of objects, leading to underutilized GPU.

Core Technologies

GPU Culling

Using compute shaders to perform visibility tests in parallel on the GPU for objects or clusters, including frustum culling and depth-buffer-based occlusion culling. Results directly generate a list of visible instances without needing to be sent back to the CPU.

Indirect Drawing

Using indirect draw commands (such as `DrawIndirect`, `DispatchIndirect`) allows the GPU to read draw parameters from buffers without CPU involvement. Multiple draw calls can be packed into a single indirect draw buffer.

Persistent Buffers

Storing scene data (transformation matrices, bounding boxes, material indices, etc.) in GPU-accessible buffers for processing by compute shaders.

Cluster Rendering

Dividing the scene into spatial clusters, each containing a set of triangles or objects. Culling and LOD selection are performed on clusters in the GPU to reduce processing granularity.

Integration with Mesh Shader

Utilizing Mesh Shader's flexible geometry generation capabilities to dynamically generate or cull geometry on the GPU, further reducing CPU dependency.

Typical Workflow

1. Upload scene object data (such as transforms, bounding boxes) to GPU buffers.
2. Perform visibility tests in compute shaders, outputting visible instance indices to a buffer.
3. Use Multi Draw Indirect or other indirect draw commands, where the GPU reads parameters directly from buffers and renders.
4. Optional: Combine with Mesh Shader for finer primitive-level culling.

Advantages

• **Reduces CPU bottleneck**: Offloads repetitive work to the GPU, freeing the CPU for game logic, physics, etc.
• **Improves performance**: Reduces draw call preparation overhead, enabling rendering of more objects.
• **Better scalability**: GPU parallelism is well-suited for massive instances.
• **Works well with modern graphics APIs**: Leverages low-overhead features of DirectX 12 and Vulkan.

Challenges

• **High programming complexity**: Requires deep GPU programming knowledge, and debugging is difficult.
• **Hardware requirements**: Requires modern GPUs supporting compute shaders and indirect drawing.
• **Data management**: Requires careful design of GPU data structures to avoid memory waste.
• **Compatibility**: Older hardware may not support certain features, requiring traditional paths as fallback.

Application Examples

Many modern game engines (such as Unreal Engine 5's Nanite, Unity's DOTS rendering) adopt GPU Driven techniques. Nanite uses GPU-driven cluster culling and rasterization to render ultra-high-polygon scenes.

Practical Suggestions

• Start on a small scale and migrate gradually.
• Use GPU culling first for static objects, then for dynamic objects.
• Combine with Mesh Shader and Variable Rate Shading for further optimization.
• Use debugging tools (such as RenderDoc, NVIDIA Nsight) to analyze GPU workloads.