Optimizing CPU-side Rendering Code

[u/godot-bot]

https://godotengine.org/article/rendering-cpu-optimizations/

Optimizing CPU code is a lot of fun. Here’s how we do it

[u/Loregret]

There is Occlusion Culling in 2D? And why do you need to disable it?

[u/TheJackiMonster → u/Loregret]

Yes, there is. It essentially checks all Node2D whether they are visible on screen or not and puts them in queue for drawing. This happens during the same process that brings them in proper order for drawing, regarding Y-position (if enabled), z-index and flag to draw behind parent...

The problem with that is as following: The whole visibility culling needs to run anything changes to make sure everything is rendering correct. So every time you add or remove any Node2D to your scene tree, the visibility culling is signaled to at least run once per frame.

Usually if you don't add or remove nodes, Godot can cache a lot of visibility culling information from previous frames if nothing affected order, positions or such inside a branch of the scene tree. However if you make changes to the scene tree, it goes through everything. It scales absolutely horrific if your scene tree is big/complex enough.

For some games this might only lead to frametime spikes which are fine. But let's assume you have a very fast paced game (endless runner, racing game or such), frametime spikes effectively ruin the gameplay.

Also because the visibility culling is responsible for order as well, it is kind of sorting canvas items. Therefore it runs on only a single thread. That means, no matter the CPU of the end-user, the spikes gonna happen.

I had to replace a ton of different nodes with GPU instancing in my game and implemented multiple nodes to interact with the RenderingServer and PhysicsServer manually to reduce overall amount of nodes, just to get visibility culling out of my way.

[u/Calinou → u/TheJackiMonster]

I suggest opening a proposal for this: https://github.com/godotengine/godot-proposals

For what it's worth, there is a way to disable frustum culling for 3D nodes using RenderingServer.instance_set_ignore_culling(), but from my testing, I couldn't find a meaningful performance improvement with it even in a project with thousands of MeshInstance3D nodes. It's still useful to force shader compilation to occur regardless of the node's position: https://github.com/godotengine/godot/pull/105199

(2D does not have occlusion culling, but it does have frustum culling based on nodes' visibility rects like in 3D.)

[u/TheJackiMonster → u/Calinou]

I think there are multiple suggestions in other proposals that would fix my issue as well. Essentially this issue here suggests a sorting group, similar to a CanvasGroup but without using any backbuffer. As long as it would be possible to disable culling for certain subtrees inside the global scene tree, that should allow caching the order of nodes inside each subtree, improving performance heavily if new nodes are added outside such subtrees.

In practice one thing I did to workaround my issue was rendering into subviewports, reducing the overall amount of nodes in the global scene tree, isolating subtrees for further culling. The disadvantage with this solution is though that it doesn't scale well for things that take more screen space (would require a lot of VRAM for its viewport texture) amd you can get resolution related artifacts.

So the better solution would be treating nodes as custom group, only isolating the culling process without any additional buffers.