🌐 Website: www.gameoptim.com
We observed unusually high GPU vertex processing cost and would like to understand the cause and possible solutions.
From GameOptim’s GOT Online report, the total triangle count of a large open-world scene is approximately 360,000. However, the effectively visible region in the current frame only accounts for around 40,000 triangles.
A:
This is a typical case caused by large-scale mesh merging, which reduces the effectiveness of CPU-side culling.
When multiple small meshes that span large spatial distances are merged into a single oversized mesh, Unity’s CPU visibility culling operates at the Renderer level, using a single bounding box for the entire object. As long as this bounding box intersects with the camera frustum, the entire mesh may be sent into the GPU rendering pipeline.
In this project, there is a clear presence of oversized mesh assets. According to the mesh resource breakdown in the report, one mesh reaches approximately 11MB in size and contains about 210,000 vertices. Combined with scene layout characteristics, this strongly suggests large-scale cross-region mesh merging.
This approach significantly degrades CPU-side culling efficiency. Even if only a small portion of the mesh is visible on screen, a large amount of irrelevant geometry can still be submitted to the GPU pipeline.
Although modern GPUs perform hardware-level culling and may discard some invisible triangles in later stages, the cost has already been paid at earlier stages, including:
- Vertex processing overhead
- Pipeline scheduling overhead
- Memory transfer and bandwidth cost
As a result, both GPU workload and memory bandwidth pressure increase.
Solution
We do not recommend manually merging large numbers of spatially distant objects into a single oversized mesh.
Instead, it is preferable to use Unity’s built-in rendering optimization mechanisms:
- Static Batching
- GPU Instancing
- SRP Batcher
When applying batching, spatial locality must be carefully controlled. Avoid merging objects that span large distances or different visibility regions into a single Renderer.
A more appropriate approach is to maintain reasonable mesh granularity, allowing the engine to perform effective CPU-side culling. This enables early rejection of invisible objects before they enter the GPU pipeline, reducing unnecessary draw submission and GPU workload.
Key Takeaway
Reducing Draw Calls does not necessarily improve GPU performance.
If batching is applied blindly across large spatial ranges, resulting in oversized bounding volumes, CPU culling efficiency is reduced. This can lead to more invisible geometry being processed by the GPU pipeline.
In such cases, the final outcome is often:
Draw Calls decrease, but GPU pressure increases.
Top comments (0)