GPU culling - when?

I just learned that HDRP has GPU culling, so the cpu culling bottleneck isn't an SRP thing.
Which begs the question: why is culling done on the cpu in URP and when is it getting an upgrade?

 

1+ this would be amazing. Maybe the lower end platform support is the reason it isn't done yet?

 

GPU culling needs Compute support that is part of GL ES 3.1
here https://developer.android.com/about/dashboards/ you can see how many low end devices out of luck for now

 

%30.. not little.. so URP team keeps cpu culling as fallback

 

Where???

 

It would be cool. GPU frustum culling really amaing feature

 

was a month enough time to get the letter back?

 

The passenger pigeon needs a rest, be patient.

 

Huh, it doesn't? I just had to do a quick check at the github repository and found nothing about it.

AFAIK visibility culling is one of the things which are pretty much *not* scriptable in SRP, it's all done inside Unity's C++ black box and adding something like GPU occlusion queries cannot be done in an elegant way.

 

Wait what where did you read about this?

 

Bump

 

What are the benefits and drawbacks of doing GPU culling for meshes?

 

The benefit is it doesn't care if your scene is procedural or static, even movable and destructible objects can occlude others. There's no need for baking and storing potentially hundreds of megabytes of visibility data in RAM.

The draw back depends on how it's implemented. You do need to spend some extra GPU time to perform the occlusion tests, so it's only worth it if your scenes have a good ratio of occluded versus visible geometry. First person and 3rd person games where the scenes contain large occluders like buildings and mountains benefit greatly from this, while in top-down and side-scrolling games don't. Also, most implementations calculate occlusion against the previous frame's depth buffer, so there can be artifacts when occluded objects can take one frame to show up during fast camera movement.

Anyway, GPU occlusion culling is used in pretty much every console/PC AAA and AAA-loking game in the market. It's a must when you are pushing complex environments and high polygon counts. Heck, some games nowadays are going even further and doing frustum and occlusion culling at the triangle level via compute shaders, to reduce the load on the GPU's input assembly.

Umbra's pre-baked occlusion is simply not viable in games with large streaming worlds. You *can* use it, but you need to load all your scenes in the editor at once and bake the visibility data of the entire world into a "master scene" which needs to be loaded at all times.

 

I think the OP is talking about renderer occlusion culling, not light culling.

 

Anyway, renderer culling is not scriptable in SRP (just as it wasn't in BiRP).

You call ScriptableRenderContext.Cull() and it returns a CullingResults, which is an opaque class storing the culling results you then pass to ScriptableRenderContext.DrawRenderers(). It's not possible to produce, manipulate, or even view the list of renderers stored in the CullingResults. To implement any custom renderer-level culling, you need to go around enabling/disabling Renderers based on the results of your own culling criteria, like the results of "classic" GPU occlusion-queries.

The problem is that old-school occlusion queries have a lot of overhead and scale badly due to excessive fencing and extra CPU-GPU sync points. To avoid this, you need GPU-driven rendering, via draw indirect or execute indirect, where compute shaders determine which objects are visible and generate the instance counts (DX11/GL) or indirect command buffers (DX12, Vulkan, Metal) all on the GPU. Here's a good article explaining how to do it (and without temporal artifacts, too):

https://interplayoflight.wordpress.com/2017/11/15/experiments-in-gpu-based-occlusion-culling/

Neither URP nor HDRP employ GPU-driven rendering*. URP in particular avoids compute shaders as much as possible because mobile GPUs still suck at it.

*ECS's hybrid renderer is, however, designed around instanced rendering. Good luck using it in production.

 

Yeah that sounds like a summary.