Profiling Rendering Bottlenecks using GPU Visualizer

You will use the GPU visualizer to identify and resolve performance bottlenecks caused by shader complexity and high-density Nanite draw calls.

In this lesson, you will learn how to leverage the GPU Visualizer to pinpoint specific rendering bottlenecks caused by shader complexity and excessive Nanite draw calls in your large-scale worlds.

When your frame rate drops in a complex scene, the GPU Visualizer (Ctrl + Shift + , or command profilegpu) is your primary diagnostic tool. It provides a hierarchical breakdown of exactly what the GPU is processing on a specific frame.

Identifying Shader Complexity

When you open the visualizer, look for high-cost entries under the BasePass. If you see items with high timing values related to your materials, expand them to see if they are bottlenecked by Shader Complexity.

If a material is causing a massive hit, it is likely due to overly complex nodes or excessive texture sampling. You can confirm this in the viewport by switching the View Mode to Shader Complexity. Pixels that appear bright red indicate expensive shaders that are likely the culprits identified in the GPU Visualizer’s BasePass section.

Managing Nanite Draw Calls

With Nanite, we often assume performance is always optimal, but high-density Nanite clusters can still lead to "Nanite Raster" bottlenecks. In the GPU Visualizer, look for the NaniteEmitGBuffer or NaniteRaster sections.

If these bars are excessively long, you are likely hitting the limits of your GPU's rasterization throughput due to too many micro-polygons or overlapping Nanite instances. You can optimize this by:

Nanite Proxy/LOD settings: Reducing the Proxy Triangle Percent in your Nanite settings for background assets.
Culling: Using the console command r.Nanite.ViewDistanceScale to adjust the distance at which Nanite meshes transition or cull.

To verify if your draw calls are the issue, compare the DrawPrimitive count in the visualizer. If the count is high, focus on reducing the density of your foliage or world-partitioned actors that are currently rendered within the camera frustum.

Key Takeaway: Use the GPU Visualizer to differentiate between pixel-heavy shader costs and geometry-heavy Nanite rasterization, allowing you to target your optimizations precisely where the hardware is struggling.