Virtual reality (VR) is an immersive and interactive medium that can create powerful experiences for users. However, VR also poses many challenges for performance design, as it requires high fidelity, low latency, and comfortable motion. In this article, we will share some tips to help you optimize your VR performance design and avoid common pitfalls.
One of the most important factors for VR performance is the frame rate, which should be at least 90 FPS for a smooth and realistic experience. To achieve this, you need to reduce the number of polygons and draw calls that your VR scene requires. A common technique to do this is to use level of detail (LOD) and occlusion culling. LOD means that you use different models with varying levels of detail depending on the distance from the camera, so that you only render the most detailed ones when they are close enough. Occlusion culling means that you only render the objects that are visible to the camera, and ignore the ones that are hidden behind other objects.
Frame Rate is King! Smooth VR = Happy Users. We devs gotta keep frame rates at 90 FPS or higher. The secret weapon? Reducing complexity! Techniques like Level of Detail (LOD) swap high-poly models for simpler ones further away. Occlusion culling hides objects behind others, saving precious processing power. By optimizing what gets rendered, we ensure a flawless VR experience!
VR is very sensitive to performance issues, since it will make the user uncomfortable. One of the first steps is to decide if the issue is on the CPU or GPU. If it is on the GPU you often are pushing heavy effects or a lot of geometry. To reduce the geometry, you can make LODs for your 3D models. This way you can load lower quality models when they are far away from the user. This will improve performance without affecting perceived quality. You can also use occlusion culling to avoid rendering unseen objects. In Unity you can use Umbra for baked culling, Unity 6's GPU occlusion, or a third party solution. Or you can write your own custom solution, which might perform even better!
When optimizing VR performance, you need to pay special attention to the quality and complexity of your shaders and textures. Shaders control how materials appear and behave in the VR scene, while textures are images applied to models. Both of these can have a major influence on GPU load and memory usage, so it’s important to optimize them carefully. To do this, you should use simple and efficient shaders that avoid unnecessary calculations, as well as texture compression and mipmaps to reduce size and resolution. Additionally, atlases and batching can be used to combine multiple textures into one, while normal maps and baked lighting can create realistic effects without extra geometry.
Shaders and textures can often hinder performance. Complex shaders add a lot of GPU utilization. To reduce this you can use mobile optimized or simpler shaders. If you have the skillset or time, you can also write a shader that does exactly and only what you need. To reduce lighting calculations in shaders, it is recommended to bake lighting. This will add the (often higher quality) lighting information to a texture. This way it does not have to be calculated every frame. On platforms that support it, using half precision could be an easy performance benefit. You want to reduce GPU bandwidth of your project as well. This often is taken hp by loading many textures at once. To improve this reduce texture size or use texture atlassing.
Something that was effective in our data visualization software was down-sampling our volumetric cubes before sending them to the GPU. This allowed us to set a strict limit on the size of cube that the GPU renders, which prevents the low FPS that leads to nausea. Although this was effective, we found that the volumetric rendering was asymmetrical. Looking down the x-axis scored higher FPS than looking down the y-axis, which itself had higher FPS than looking down the z-axis. It turns out we had more cache-hits with the x-axis and y-axis due to the 1-dimensional buffer in the 3D texture on the GPU. The solution we are implementing is to use the high memory GPUs to store three 3D textures for the same volumetric data, but rotated in x,y,z.
The best way to ensure that your VR performance design is optimal is to test and profile your VR app regularly and on different devices. Testing means that you run your VR app and check for any issues or errors that might affect the user experience, such as judder, stutter, or motion sickness. Profiling means that you use tools to measure and analyze the performance of your VR app, such as the frame rate, the CPU and GPU usage, the memory allocation, and the thermal throttling. By testing and profiling your VR app, you can identify and fix any bottlenecks or inefficiencies that might compromise your VR performance.
The most important thing to getting performance right is testing and profiling. Start to do this early in the development stage, and test on your target device. If you are using a standalone headset, make a build for that platform instead of testing via PC. This way you can get an accurate representation of performance. Use both engine tools, like the Unity profiler and frame debugger, on-device tools, like OVRMetrics, or 3rd party tools, like render doc or nsight. These will get you performance numbers and more information on what part of your game you need to optimize
Finally, you should also follow the VR design guidelines and best practices that are provided by the VR platforms and developers that you are targeting. These guidelines and best practices cover various aspects of VR design, such as user interface, interaction, locomotion, audio, and accessibility. By following these guidelines and best practices, you can ensure that your VR performance design is compatible and consistent with the expectations and preferences of your users and the capabilities and limitations of your VR devices.
Platforms often have their own performance guidelines. Meta has a page where they go over the recommended triangle count and draw call count, based on the complexity of your project. Reading through and understanding performance results can help you in your journey to make an optimized application.
It is good to stay up to date with the latest version of the tool you use. Tools often release new updates that improve performance. Even if these changes are small, they really can add up over time. Platforms also add new technologies, like late latching, phase sync, application spacewarp, (eye tracked) foveated rendering, and variable rate shading. I suggest to give them all a look! Some examples are Unreal Engine 5.3, which allowed Nanite to run in one pass, instead of once per eye. This massively boosted performance for high end VR applications. Unity also has released some new tricks in Unity 6. Here you can use GPU resident drawer and GPU occlusion culling to improve performance. This adds onto the performant native render pass.
Developers must focus on optimizing assets, ensuring that visuals are detailed yet efficient in resource usage. Implementing LOD systems, smart use of lighting, and effective culling techniques are critical for maintaining performance without sacrificing visual fidelity. Asynchronous Timewarp & reprojection can smooth out performance dips, enhancing user comfort. Spatial audio adds depth to the VR experience, while intuitive UI design ensures easy navigation. Rigorous testing across various hardware setups helps identify and rectify bottlenecks, ensuring a smooth experience for all users. Finally, prioritizing user comfort, especially in preventing motion sickness, is essential for a truly immersive VR experience.