All content in this course uses:

Optimizing your VR/AR Experiences 

In this tutorial, you will learn how to optimize VR and AR experiences in Unity

Optimization is a key ingredient to ensuring comfort and safety in XR applications. With Virtual reality, especially, it’s important that your application maintain a high frame rate. If it’s either CPU or GPU bound, the frame rate may drop and push a user to the brink of motion sickness. 

One important metric is draw calls. To draw a GameObject on the screen, the engine has to issue a draw call to the graphics API. Draw calls are often resource-intensive, with the graphics API doing significant work for each one, causing performance overhead on the CPU side. This is mostly due to the state changes between the draw calls (such as switching to a different Material), which cause resource-intensive validation and translation steps in the graphics driver.

You’ll want to keep our draw calls and tri count as low as possible to reduce the computational load on the CPU and GPU. 

There are a few straightforward techniques to implement when optimizing our applications. This tutorial will cover some of the standard techniques and strategies for optimizing Unity applications. Those techniques are:

5. Rendering pass type: single-pass (vs. multi-pass)

Light baking reduces the computational expense of rendering the Scene. This technique, which helps the GPU, refers to the process of pre-calculating Scene illumination before run time. This means there is no run-time overhead for baked lights. Normally, Unity renders each object for every light that shines on it. So, if an object has five lights on it, Unity will render the object five times (when in view). This can spike the tri count and number of draw calls, slowing application performance. Baking your lights is an effective way to reduce the number of tris and draw calls, since these calculations are done prior to run time (

Another technique used to reduce the workload of the GPU is Occlusion Culling. Occlusion Culling keeps Unity from rendering objects out of view of the Camera GameObject. By default, Unity does not render objects outside of the viewing frustum. However, it will still render objects blocked by objects in the foreground, which leads to overdraw, or pixel overlap (pixels drawn twice, over each other). This pixel overlap is unnecessary work and should be avoided. You can avoid this by using Occlusion Culling to “cull” any objects covered by other objects (

Static batching improves both GPU and CPU performance. By making all stationary objects static, Unity combines stationary GameObjects into one big Mesh, rendering them faster. This reduces draw calls and physics calculations, as well. By tagging objects as static, Unity knows these objects will never move and therefore do not need to be included in physics calculations. If your application is CPU-bound, then marking more objects as static is a helpful technique.

) control the graphical quality of objects being rendered (menu: 

). These are out-of-the-box settings (pixel light count, light map resolution, etc.) that can either maximize graphical quality or maximize performance (

). The lower the graphical quality, the higher the performance. 

And finally, you can adjust the rendering methods. Currently, Unity supports three rendering methods for XR: 

Single-pass instanced is the most performant of the three, but is not available on all devices. 

Because Google VR has two Textures, one for each eye, Unity needs to render a Scene twice (

Unity attempts to avoid duplicating work required for each eye, such as shadows, which don’t need to be rendered twice. Multi-pass still renders most objects twice, but renders the Scene graph once. This creates more accurate lighting, but comes at a computational cost, since the two renderings do not share GPU work across Textures. This is the least efficient rendering path, but works on most devices. 

Single-pass, on the other hand, packs the two Textures into one big Texture (known as a double-wide Texture). It goes through the Scene graph only once, so it’s much faster on the CPU. However, it requires a lot of extra GPU state changes to accomplish this.

Single-pass instancing allows for even simpler integration and better performance. It reduces the CPU overhead, just like single-pass (lowering the number of draw calls), but also reduces the GPU overhead more than single-pass. The GPU is able to more efficiently process the draws, and you minimize state updates by not having to change the viewport between draws unlike with traditional single-pass.

You can read more about Single-pass instancing 

Optimizing your VR/AR Experiences

 in your Scene. This is how to include them in lighting calculations.

2. Change each of your Scene’s light modes to 

3. In the Lighting settings window, click 

4. A progress bar will appear in the Editor’s status bar, in the bottom-right corner.

5. When baking is complete, you can see all the baked lightmaps in the Global Maps and Object Maps tabs of the Lighting window.

6. Try adjusting the lightmap size for increased lighting accuracy. This will increase your bake time and build file size, but it will also increase lighting precision.

Setting Up Light Baking

1. Tag all objects occluding other objects as 

. The fastest way to do this is to multi-select the objects you want to be included in occlusion calculations and tag them appropriately. 

2. If rendering a window, you should tag the window as 

, since it does not occlude any objects behind it.

. This will bake your occlusion map so your Occlusion Culling works properly (

Setting up Occlusion Culling:

3. In the Hierarchy, select all non-moving objects (static objects) and tag them as 

. Note: the common practice is to toggle the checkbox, which toggles on all Static tags (

Setting Up Static Batching

3. Take a moment to explore the adjusted quality settings below the presets.

Setting Up Quality Settings

1. To enable single-pass or single-pass instanced, navigate to Project Settings.

Setting Up Each Rendering Pass Type

These five techniques can help reduce performance hiccups (and the possibility of making your users queasy) in your VR/AR projects without requiring you to modify existing Assets. While these techniques are crucial for VR/AR development, they are good to employ in mobile, console, and desktop applications as well. 

Unity Version 2019.4