Performance recommendations for Unity

  • Article
  • 18 minutes to read

This article builds on the performance recommendations for mixed reality, but focuses on Unity-specific improvements.

We recently released an application called Quality Fundamentals that covers common functioning, design, and surroundings bug and solutions for HoloLens ii apps. This app is a great visual demo for the content that follows.

The most important first footstep when optimizing performance of mixed reality apps in Unity is to exist sure you're using the recommended environment settings for Unity. That commodity contains content with some of the most important scene configurations for building performant Mixed Reality apps. Some of these recommended settings are highlighted below, as well.

How to profile with Unity

Unity provides the Unity Profiler built-in, which is a cracking resource to gather valuable operation insights for your item app. Although you can run the profiler in-editor, these metrics don't stand for the true runtime environment so results should be used cautiously. We recommend that you remotely profile your awarding while running on-device for the most accurate and actionable insights.

Unity provides cracking documentation for:

  1. How to connect the Unity profiler to UWP applications remotely
  2. How to finer diagnose functioning bug with the Unity Profiler

GPU profiling

Unity profiler

With the Unity Profiler connected and after adding the GPU profiler (see Add together Profiler in superlative right corner), 1 can see how much fourth dimension is being spent on the CPU & GPU respectively in the middle of the profiler. This allows the developer to get a quick approximation if their application is CPU or GPU bounded.

Unity CPU vs GPU

Note

To utilize GPU profiling, you need to disable Graphics Jobs in the Unity Player Settings. Run into Unity's GPU Usage Profiler module for more details.

Unity frame debugger

Unity's Frame Debugger is also a powerful and insightful tool to use. Information technology will requite you a good overview of what the GPU is doing each frame. Things to wait out for are additional rendering targets and blit commands to copy between them as these are very expensive on HoloLens. Ideally, no off-screen render targets should be used on HoloLens. These are ordinarily added when enabling expensive rendering features (for example MSAA, HDR or full-screen furnishings like blossom) which should be avoided.

HoloLens frame rate overlay

The Device Portal Organisation Performance page has a good summary of CPU and GPU functioning of the device. You tin can enable Brandish frame rate counter in headset and Display frame rate graph in headset. These options will enable an FPS counter and graph, respectively, that volition give you immediate feedback in whatsoever running application on your device.

PIX

PIX tin be used to contour Unity applications also. There are as well detailed instructions on how to utilise and install PIX for HoloLens 2. In a development build, the aforementioned scopes that you run into in Unity's Frame Debugger volition be shown in PIX likewise and can be inspected and profiled in more than item.

Notation

Unity provides the power to hands modify the render target resolution of your application at runtime through the XRSettings.renderViewportScale property. The final image presented on-device has a stock-still resolution. The platform will sample the lower resolution output to build a college resolution image for rendering on displays.

                UnityEngine.XR.XRSettings.renderViewportScale = 0.7f;

CPU performance recommendations

The content below covers more in-depth performance practices, especially targeted for Unity & C# development.

Cache references

We recommend caching references to all relevant components and GameObjects at initialization considering repeating office calls such as GetComponent<T>() and Camera.main are more expensive relative to the memory cost to store a pointer. . Camera.primary merely uses FindGameObjectsWithTag() underneath, which expensively searches your scene graph for a camera object with the "MainCamera" tag.

              using UnityEngine; using System.Collections;  public grade ExampleClass : MonoBehaviour {     individual Camera cam;     individual CustomComponent comp;      void Offset()      {         cam = Photographic camera.master;         comp = GetComponent<CustomComponent>();     }      void Update()     {         // Skillful         this.transform.position = cam.transform.position + cam.transform.forward * 10.0f;          // Bad         this.transform.position = Camera.chief.transform.position + Photographic camera.chief.transform.frontward * 10.0f;          // Expert         comp.DoSomethingAwesome();          // Bad         GetComponent<CustomComponent>().DoSomethingAwesome();     } }

Notation

Avert GetComponent(string)
When using GetComponent(), at that place are a handful of different overloads. It is important to always utilise the Type-based implementations and never the string-based searching overload. Searching by cord in your scene is significantly more than costly than searching by Type.
(Good) Component GetComponent(Type type)
(Good) T GetComponent<T>()
(Bad) Component GetComponent(string)>

Avoid expensive operations

  1. Avoid utilize of LINQ

    Although LINQ tin can be clean and easy to read and write, it generally requires more than computation and retentivity than if you lot wrote the algorithm manually.

                      // Example Lawmaking using Arrangement.Linq;  List<int> data = new List<int>(); data.Any(ten => 10 > ten);  var result = from x in information              where ten > 10              select x;

  2. Common Unity APIs

    Sure Unity APIs, although useful, tin be expensive to execute. Virtually of these involve searching your entire scene graph for some matching list of GameObjects. These operations can more often than not be avoided by caching references or implementing a manager component for the GameObjects to track the references at runtime.

                                          GameObject.SendMessage()     GameObject.BroadcastMessage()     UnityEngine.Object.Observe()     UnityEngine.Object.FindWithTag()     UnityEngine.Object.FindObjectOfType()     UnityEngine.Object.FindObjectsOfType()     UnityEngine.Object.FindGameObjectsWithTag()     UnityEngine.Object.FindGameObjectsWithTag()

Annotation

SendMessage() and BroadcastMessage() should exist eliminated at all costs. These functions tin be on the gild of 1000x slower than direct role calls.

  1. Beware of boxing

    Boxing is a core concept of the C# language and runtime. It'southward the process of wrapping value-typed variables such as char, int, bool, etc. into reference-typed variables. When a value-typed variable is "boxed", it'southward wrapped in a System.Object, which is stored on the managed heap. Memory is allocated and eventually when disposed must be candy by the garbage collector. These allocations and deallocations incur a performance toll and in many scenarios are unnecessary or can be hands replaced past a less expensive alternative.

    To avert boxing, be sure that the variables, fields, and backdrop in which yous store numeric types and structs (including Nullable<T>) are strongly typed as specific types such every bit int, float? or MyStruct, instead of using object. If putting these objects into a list, be sure to use a strongly typed list such equally List<int> rather than Listing<object> or ArrayList.

    Example of boxing in C# 

                      // boolean value blazon is boxed into object boxedMyVar on the heap bool myVar = true; object boxedMyVar = myVar;

Repeating lawmaking paths

Any repeating Unity callback functions (i.east Update) that are executed many times per second and/or frame should be written carefully. Any expensive operations hither will have huge and consistent bear on on performance.

  1. Empty callback functions

    Although the lawmaking below may seem innocent to exit in your application, especially since every Unity script car-initializes with an Update method, these empty callbacks can become expensive. Unity operates back and forth betwixt an unmanaged and managed code boundary, betwixt UnityEngine code and your application code. Context switching over this bridge is fairly expensive, even if there'due south nothing to execute. This becomes especially problematic if your app has 100s of GameObjects with components that have empty repeating Unity callbacks.

                      void Update() { }

Notation

Update() is the most common manifestation of this performance issue simply other repeating Unity callbacks, such as the following can be equally as bad, if non worse: FixedUpdate(), LateUpdate(), OnPostRender", OnPreRender(), OnRenderImage(), etc.

  1. Operations to favor running once per frame

    The post-obit Unity APIs are mutual operations for many Holographic Apps. Although non always possible, the results from these functions can usually exist computed once and the results reutilized across the application for a given frame.

    a) Information technology's adept practice to have a dedicated Singleton grade or service to handle your gaze Raycast into the scene and and then reuse this effect in all other scene components, instead of making repeated and identical Raycast operations by each component. Some applications may crave raycasts from unlike origins or against different LayerMasks.

                                          UnityEngine.Physics.Raycast()     UnityEngine.Physics.RaycastAll()

    b) Avoid GetComponent() operations in repeated Unity callbacks like Update() by caching references in Start() or Awake()

                                          UnityEngine.Object.GetComponent()

    c) Information technology'south expert exercise to instantiate all objects, if possible, at initialization and utilise object pooling to recycle and reuse GameObjects throughout runtime of your awarding

                                          UnityEngine.Object.Instantiate()

  2. Avoid interfaces and virtual constructs

    Invoking function calls through interfaces vs direct objects or calling virtual functions tin frequently be much more expensive than using direct constructs or straight function calls. If the virtual function or interface is unnecessary, and so it should be removed. However, the performance hit for these approaches is worth the trade-off if using them simplifies development collaboration, lawmaking readability, and code maintainability.

    Mostly, the recommendation is to non mark fields and functions as virtual unless in that location's a articulate expectation that this fellow member needs to be overwritten. Ane should exist peculiarly careful around high-frequency code paths that are called many times per frame or even once per frame such as an UpdateUI() method.

  3. Avoid passing structs by value

    Different classes, structs are value-types and when passed straight to a role, their contents are copied into a newly created instance. This copy adds CPU cost, likewise as additional memory on the stack. For small structs, the effect is minimal and thus acceptable. Even so, for functions repeatedly invoked every frame also as functions taking large structs, if possible change the function definition to pass past reference. Acquire more here

Miscellaneous

  1. Physics

    a) Generally, the easiest way to improve physics is to limit the corporeality of time spent on Physics or the number of iterations per second. This will reduce simulation accurateness. Meet TimeManager in Unity

    b) The types of colliders in Unity have widely different performance characteristics. The order below lists the most performant colliders to to the lowest degree performant colliders from left to right. It's of import to avoid Mesh Colliders, which are essentially more expensive than the primitive colliders.

    Sphere < Sheathing < Box <<< Mesh (Convex) < Mesh (non-Convex)

    See Unity Physics Best Practices for more info

  2. Animations

    Disable idle animations by disabling the Animator component (disabling the game object won't have the same consequence). Avoid blueprint patterns where an animator sits in a loop setting a value to the aforementioned matter. There'south considerable overhead for this technique, with no result on the application. Learn more than here.

  3. Complex algorithms

    If your application is using complex algorithms such as inverse kinematics, path finding, etc, look to find a simpler arroyo or suit relevant settings for their performance

CPU-to-GPU performance recommendations

By and large, CPU-to-GPU performance comes down to the draw calls submitted to the graphics bill of fare. To improve operation, draw calls need to be strategically a) reduced or b) restructured for optimal results. Since draw calls themselves are resource-intensive, reducing them will reduce overall work required. Farther, state changes between draw calls require costly validation and translation steps in the graphics driver and thus, restructuring of your application's draw calls to limit state changes (i.e different materials, etc) can boost operation.

Unity has a peachy article that gives an overview and dives into batching draw calls for their platform.

  • Unity Draw Phone call Batching

Single pass instanced rendering

Single Laissez passer Instanced Rendering in Unity allows for depict calls for each eye to be reduced downward to one instanced draw call. Because of enshroud coherency between two describe calls, there's also some performance comeback on the GPU as well.

To enable this feature in your Unity Project

  1. Open up Player XR Settings (go to Edit > Project Settings > Player > XR Settings)
  2. Select Single Pass Instanced from the Stereo Rendering Method drop-down menu (Virtual Reality Supported checkbox must be checked)

Read the following manufactures from Unity for details with this rendering approach.

  • How to maximize AR and VR performance with avant-garde stereo rendering
  • Single Laissez passer Instancing

Note

One common event with Single Laissez passer Instanced Rendering occurs if developers already have existing custom shaders not written for instancing. After enabling this feature, developers may notice some GameObjects only render in one eye. This is considering the associated custom shaders do not have the advisable properties for instancing.

See Single Pass Stereo Rendering for HoloLens from Unity for how to address this problem

Static batching

Unity is able to batch many static objects to reduce draw calls to the GPU. Static Batching works for virtually Renderer objects in Unity that ane) share the same material and ii) are all marked as Static (Select an object in Unity and select the checkbox in the top right of the inspector). GameObjects marked as Static cannot be moved throughout your application's runtime. Thus, static batching can be difficult to leverage on HoloLens where nearly every object needs to be placed, moved, scaled, etc. For immersive headsets, static batching can dramatically reduce depict calls and thus meliorate performance.

Read Static Batching under Draw Call Batching in Unity for more details.

Dynamic batching

Since it'southward problematic to mark objects every bit Static for HoloLens development, dynamic batching can be a great tool to recoup for this lacking feature. Information technology can also be useful on immersive headsets, equally well. However, dynamic batching in Unity can be difficult to enable considering GameObjects must a) share the same Textile and b) meet a long listing of other criteria.

Read Dynamic Batching under Depict Call Batching in Unity for the full list. About commonly, GameObjects become invalid to exist batched dynamically, because the associated mesh data can be no more than 300 vertices.

Other techniques

Batching can just occur if multiple GameObjects are able to share the aforementioned material. Typically, this will be blocked by the need for GameObjects to have a unique texture for their corresponding Fabric. It's common to combine Textures into 1 large Texture, a method known every bit Texture Atlasing.

Furthermore, it'southward preferable to combine meshes into ane GameObject where possible and reasonable. Each Renderer in Unity will have its associated depict call(s) versus submitting a combined mesh nether one Renderer.

Note

Modifying backdrop of Renderer.fabric at runtime will create a copy of the Textile and thus potentially pause batching. Use Renderer.sharedMaterial to modify shared fabric properties across GameObjects.

GPU performance recommendations

Larn more about optimizing graphics rendering in Unity

Bandwidth and make full rates

When rendering a frame on the GPU, an awarding is either bound past retentiveness bandwidth or make full rate.

  • Memory bandwidth is the rate of reads and writes the GPU tin can practice from memory
    • In Unity, change Texture Quality in Edit > Project Settings > Quality Settings.
  • Fill rate refers to the pixels that can be drawn per second by the GPU.
    • In Unity, utilise the XRSettings.renderViewportScale belongings.

Optimize depth buffer sharing

It's recommended to enable Depth buffer sharing under Player XR Settings to optimize for hologram stability. When enabling depth-based late-stage reprojection with this setting still, it'due south recommended to select xvi-bit depth format instead of 24-bit depth format. The 16-bit depth buffers will drastically reduce the bandwidth (and thus power) associated with depth buffer traffic. This can exist a big win both in power reduction and operation improvement. However, at that place are 2 possible negative outcomes past using 16-chip depth format.

Z-Fighting

The reduced depth range fidelity makes z-fighting more likely to occur with sixteen chip than 24-bit. To avert these artifacts, change the near/far prune planes of the Unity photographic camera to account for the lower precision. For HoloLens-based applications, a far clip plane of 50 m instead of the Unity default m chiliad tin more often than not eliminate any z-fighting.

Disabled Stencil Buffer

When Unity creates a Render Texture with 16-bit depth, there's no stencil buffer created. Selecting 24-bit depth format, per Unity documentation, will create a 24-fleck z-buffer, as well as an [8-flake stencil buffer] (https://docs.unity3d.com/Manual/SL-Stencil.html) (if 32-chip is applicative on a device, which is generally the case such every bit HoloLens).

Avoid total-screen effects

Techniques that operate on the full screen can be expensive since their lodge of magnitude is millions of operations every frame. It'southward recommended to avoid post-processing effects such every bit anti-aliasing, bloom, and more.

Optimal lighting settings

Existent-time Global Illumination in Unity can provide outstanding visual results but involves expensive lighting calculations. We recommended disabling existent-time Global Illumination for every Unity scene file via Window > Rendering > Lighting Settings > Uncheck Real-time Global Illumination.

Furthermore, it's recommended to disable all shadow casting as these also add expensive GPU passes onto a Unity scene. Shadows can be disable per calorie-free but can likewise exist controlled holistically via Quality settings.

Edit > Projection Settings, then select the Quality category > Select Depression Quality for the UWP Platform. One can also just set up the Shadows holding to Disable Shadows.

Nosotros recommended that you use baked lighting with your models in Unity.

Reduce poly count

Polygon count is reduced by either

  1. Removing objects from a scene
  2. Asset decimation, which reduces the number of polygons for a given mesh
  3. Implementing a Level of Detail (LOD) System into your awarding, which renders far away objects with lower-polygon version of the aforementioned geometry

Agreement shaders in Unity

An piece of cake approximation to compare shaders in performance is to place the average number of operations each executes at runtime. This can be done easily in Unity.

  1. Select your shader asset or select a textile, then in the top-right corner of the inspector window, select the gear icon followed past "Select Shader"

    Select shader in Unity

  2. With the shader asset selected, select the "Compile and show lawmaking" button nether the inspector window

    Compile Shader Code in Unity

  3. Afterward compiling, await for the statistics department in the results with the number of different operations for both the vertex and pixel shader (Note: pixel shaders are often also called fragment shaders)

    Unity Standard Shader Operations

Optimize pixel shaders

Looking at the compiled statistic results using the method higher up, the fragment shader will generally execute more operations than the vertex shader, on average. The fragment shader, also known as the pixel shader, is executed per pixel on the screen output while the vertex shader is only executed per-vertex of all meshes being drawn to the screen.

Thus, not only do fragment shaders have more instructions than vertex shaders because of all the lighting calculations, fragment shaders are nearly always executed on a larger dataset. For example, if the screen output is a 2k by 2k epitome, so the fragment shader tin become executed 2,000*two,000 = iv,000,000 times. If rendering two eyes, this number doubles since there are ii screens. If a mixed reality application has multiple passes, full-screen mail service-processing effects, or rendering multiple meshes to the same pixel, this number will increment dramatically.

Therefore, reducing the number of operations in the fragment shader can generally give far greater functioning gains over optimizations in the vertex shader.

Unity Standard shader alternatives

Instead of using a physically based rendering (PBR) or some other high-quality shader, expect at utilizing a more performant and cheaper shader. The Mixed Reality Toolkit provides the MRTK standard shader that has been optimized for mixed reality projects.

Unity as well provides an unlit, vertex lit, lengthened, and other simplified shader options that are faster compared to the Unity Standard shader. See Usage and Operation of Built-in Shaders for more detailed information.

Shader preloading

Apply Shader preloading and other tricks to optimize shader load time. In particular, shader preloading ways yous won't see whatever hitches due to runtime shader compilation.

Limit overdraw

In Unity, one can display overdraw for their scene, past toggling the draw mode menu in the tiptop-left corner of the Scene view and selecting Overdraw.

Generally, overdraw can be mitigated past culling objects ahead of time earlier they're sent to the GPU. Unity provides details on implementing Occlusion Alternative for their engine.

Retentivity recommendations

Excessive retentiveness resource allotment & deallocation operations can take adverse furnishings on your holographic application, resulting in inconsistent functioning, frozen frames, and other detrimental beliefs. Information technology'southward particularly important to understand memory considerations when developing in Unity since memory management is controlled by the garbage collector.

Garbage drove

Holographic apps will lose processing compute fourth dimension to the garbage collector (GC) when the GC is activated to clarify objects that are no longer in scope during execution and their memory needs to be released, so information technology can be fabricated available for reuse. Constant allocations and de-allocations will generally require the garbage collector to run more oft, thus hurting operation and user experience.

Unity has provided an excellent folio that explains in detail how the garbage collector works and tips to write more efficient lawmaking in regards to memory management.

  • Optimizing garbage collection in Unity games

1 of the most common practices that leads to excessive garbage collection isn't caching references to components and classes in Unity evolution. Any references should be captured during First() or Awake() and reused in subsequently functions such as Update() or LateUpdate().

Other quick tips:

  • Use the StringBuilder C# class to dynamically build complex strings at runtime
  • Remove calls to Debug.Log() when no longer needed, as they still execute in all build versions of an app
  • If your holographic app by and large requires lots of memory, consider calling System.GC.Collect() during loading phases such as when presenting a loading or transition screen

Object pooling

Object pooling is a popular technique for reducing the price of continuous object allocation and deallocations. This is done by allocating a large pool of identical objects and reusing inactive, bachelor instances from this pool instead of constantly spawning and destroying objects over fourth dimension. Object pools are great for reuseable components that have variable lifetime during an app.

  • Object Pooling Tutorial in Unity

Startup functioning

Consider starting your app with a smaller scene, then using SceneManager.LoadSceneAsync to load the balance of the scene. This allows your app to become to an interactive land as fast equally possible. There may exist a big CPU spike while the new scene is existence activated and that whatsoever rendered content might stutter or hitch. Ane way to work effectually this is to ready the AsyncOperation.allowSceneActivation belongings to "false" on the scene beingness loaded, wait for the scene to load, articulate the screen to black, so gear up it back to "true" to complete the scene activation.

Remember that while the startup scene is loading, the holographic splash screen volition be displayed to the user.

See besides

  • Optimizing graphics rendering in Unity games
  • Optimizing garbage drove in Unity games
  • Physics Best Practices [Unity]
  • Optimizing Scripts [Unity]