In this lesson, you will learn how to pinpoint rendering bottlenecks by breaking down the frame execution sequence using the GPU Visualizer.
When your frame rate drops, it is rarely obvious whether the issue lies in complex geometry, heavy pixel shaders, or shadow calculations. The GPU Visualizer is your primary diagnostic tool for "seeing" exactly how the GPU spends its time during a single frame.
Accessing the Visualizer
To open the tool, open your console (press the backtick key ~) and type profilegpu. This command captures a snapshot of the current frame and opens a window displaying a hierarchical list of every draw call and compute pass performed.
Reading the Hierarchy
The visualizer presents data in a top-down tree. The top entries represent the major rendering passes (like BasePass, ShadowDepths, or LumenScene), while the indented children show the specific operations within those passes.
- Color Coding: Look for bars that are exceptionally long. If you expand a section and see a massive time cost (measured in milliseconds) attached to a specific pass, you have found your bottleneck.
- Draw Call Bottlenecks: If you see hundreds of small entries under
BasePass, you are likely "Draw Call Bound," meaning the CPU is spending too much time telling the GPU what to draw. - Shader Complexity: If a specific pass like
TranslucencyorShadowDepthsis spiking, check the individual draw calls. If one mesh is taking significantly longer than others, it may have an overly complex material or excessive overdraw.
Practical Workflow
If you notice the ShadowDepths pass taking 5ms, drill down into that hierarchy. If you see high costs for specific meshes, you know exactly which assets need optimization (such as reducing polygon count or simplifying material expressions).
By understanding the sequence—from G-Buffer generation to final post-processing—you can decide whether to optimize your scene's complexity, adjust your Nanite settings, or refine your shadow map resolution.
Key Takeaway: The GPU Visualizer allows you to isolate specific rendering passes and draw calls, transforming vague performance drops into actionable targets for optimization.