April 21 2020
By Rubén Torres Bonet
April 21, 2020
Is your game rendering more geometry than your GPU can handle? Here, let me show you a few steps to check if your geometry is causing a performance bottleneck on your players’ GPU.
In this blog post, I’ll share with you:
Remember last week?
Following our plan, today’s topic is about a specific GPU Performance Pillar…
We are about to cover the famous performance area of Geometry Complexity.
The Game Guru’s Performance Pillars – GPU Performance
Why is geometry complexity important for you?
Well, you know games…
Sometimes they’re happy.
Sometimes they’re screaming “this lame game doesn’t run 144 fps, gimme my money back“.
But those comments don’t necessarily help you find your performance bottlenecks, do they?
Those you have to find yourself.
Performance bottlenecks come in different sizes and colors, depending on the current scene and on the hardware of your players.
It’s your responsibility to find the exact origin of your performance bottlenecks.
And geometry complexity is one of these potential bottlenecks… one that severely affects your GPU 😉
Once you finish reading this post, you’ll be able to answer these two questions:
We all want astonishing visuals in our games.
And geometry is the basic foundation for all the visuals of your game, no matter your style.
It doesn’t matter if you’re developing a 3d game or a 2d game.
It’s all vertices and triangles, i.e. geometry.
Each vertex is a point in (object) space.
And each vertex has often more data to it than just the position, such as UV0, UV1, colors and the such.
More vertex attributes means more you require more memory bandwidth. That, in turn, means less frame-rate and more power drain.
Warmer hands in winter, that’s it.
Geometry complexity is basically the amount of vertices and triangles you’re pushing to your GPU. That includes attributes.
So, what happens when we push too much geometry to the GPU?
If you’re pushing too many vertices, then you’re overwhelming your GPU’s vertex shading units.
And your Render Thread.
And your memory.
And your battery.
And your wallet
Pushing too many vertices will slow down your game, as you’re forcing your GPU to fetch shitloads of data (memory bandwidth) that you then have to process (arithmetic operations).
Overdo it and it’ll require more time than 144 fps allows, resulting in wasted players’ crocodile tears.
Now, if you keep your timings under control, you’ll keep your players happy. And your boss.
This is why specializing on game performance is so important nowadays.
For your players… and for you.
So, how would you go about finding if your game is vertex-bound?
Let’s say your game is running at 20 FPS and your boss is breathing down your neck.
You don’t like that sensation, you’re about to take action to fix this problem for good.
You have a hunch that your vertex count is causing this, but you want to confirm it.
What do you do?
→ Just drastically reduce the vertex count and see if that massively increases your framerate.
That sounds reasonable… But it’s easier said than done.
Luckily, we have great tools to help out.
Before we get into the tools, let me say this…
The ideal approach involves doing one extra step before all of this.
Ideally, we’d want to simplify the rest of the game first to make sure our bottleneck is indeed coming from the vertex stage.
That means, temporarily getting rid of the cost of different stages:
If you get rid of all other expensive parts and your game is still not performing, then you can be sure it’s due to complexity.
Otherwise, you can’t be 100% sure, because the bottleneck could come from another place.
Let’s see an example.
Here’s a profiler capture showing a geometry bottleneck (zoom if necessary):
Almost no CPU overhead.
The main and render threads are just sitting idle, waiting for the GPU to finish.
So, ideally, here’s what you have to do:
If your frame-rate increases substantially with simpler geometry, then you have a winner.
Now the tricky part…
How to simplify your geometry?
The traditional way is having an artist who simplifies the models’ geometry for you in the original 3d modeling software.
While that’s the method that gives you the best visuals, that’s also the most expensive, especially for testing bottlenecks.
You know what it takes to find an artist (or time for it) if you’re an indie developer: money, tears and blood.
Sometimes, good&done is better than perfect&late.
That said, let me show you one of my favorite tools…
Give a warm welcome to Simplygon, the latest addition to the official Gamedev Guru’s Essential Tools List.
Here’s How Simplygon Will Conquer Your Heart
High-poly mesh in, low-poly mesh out.
As simple as that.
Here’s an example:
From 6 million vertices to about 2k vertices in under 2 minutes.
Heck, it even creates the normals for you.
Sure, there are no words to say how ugly is the simplified mesh. But the original mesh was dreadful, anyway 😉
Jokes apart, I used very aggressive settings.
Here are the steps:
Simplygon “Simple” Workflow
As a side note: for Unity performance analysis, we don’t need it pretty meshes
We just need meshes with similar shapes, while featuring a drastically reduced number of vertices.
That’s because we don’t want to alter the shape of the models to avoid adding more testing variables.
Once you have a simpler mesh, you have two options to make change your meshes in your scene:
I took another profile after I switched to the simpler version of the mesh and…
Profiling Session With Simple Geometry Showing No Bottlenecks
That was indeed our bottleneck.
Sure, you lose quality, but remember…
You can combat quality loss by complicating your fragment shaders with normal maps, parallax mapping, etc..
For the more advanced users, here’re a few ideas for you:
This post is part of the Unity Performance Pillars series and is based on the Unity Performance Checklist.
Get your Unity Performance Checklist now to boost your game performance so you avoid nasty 1-star reviews.
Next week, I’ll show you a few tricks regarding memory optimization.
So make sure you read the memory section of the checklist ahead!