The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Reducing Draw Calls

Next ►
►

In this section, we will explore techniques to reduce draw calls in Unity, which is crucial for optimizing the performance of your game. Draw calls are commands sent to the GPU to render objects on the screen. Reducing the number of draw calls can significantly improve the frame rate and overall performance of your game, especially on lower-end devices.

Key Concepts

  1. Draw Calls: A draw call is a command that tells the GPU to draw a set of vertices. Each draw call has overhead, so reducing the number of draw calls can improve performance.
  2. Batches: Unity combines multiple objects into a single draw call using batching techniques. There are two types of batching:
    • Static Batching: Combines static (non-moving) objects.
    • Dynamic Batching: Combines small, dynamic (moving) objects.
  3. Instancing: A technique to render multiple copies of the same mesh with a single draw call.
  4. Level of Detail (LOD): Reducing the complexity of objects that are far from the camera.

Techniques to Reduce Draw Calls

  1. Static Batching

Static batching is used for objects that do not move. By marking objects as static, Unity can combine them into fewer draw calls.

Steps to Enable Static Batching:

  1. Select the objects you want to batch.
  2. In the Inspector, check the "Static" checkbox.
// Example: Marking an object as static in code
gameObject.isStatic = true;

  1. Dynamic Batching

Dynamic batching is used for small, dynamic objects. Unity automatically batches these objects if they meet certain criteria (e.g., fewer than 900 vertex attributes).

Tips for Effective Dynamic Batching:

  • Use fewer materials and textures.
  • Keep vertex count low.

  1. GPU Instancing

GPU instancing allows you to render multiple instances of the same mesh with a single draw call. This is particularly useful for objects like trees, rocks, or enemies.

Steps to Enable GPU Instancing:

  1. Create a material that supports instancing.
  2. Check the "Enable GPU Instancing" checkbox in the material settings.
// Example: Enabling GPU instancing in code
Material material = new Material(Shader.Find("Standard"));
material.enableInstancing = true;

  1. Combining Meshes

Combining multiple meshes into a single mesh can reduce draw calls. This is useful for objects that are always together, like a group of rocks or a building.

Example: Combining Meshes in Code:

using UnityEngine;

public class MeshCombiner : MonoBehaviour
{
    void Start()
    {
        MeshFilter[] meshFilters = GetComponentsInChildren<MeshFilter>();
        CombineInstance[] combine = new CombineInstance[meshFilters.Length];

        for (int i = 0; i < meshFilters.Length; i++)
        {
            combine[i].mesh = meshFilters[i].sharedMesh;
            combine[i].transform = meshFilters[i].transform.localToWorldMatrix;
            meshFilters[i].gameObject.SetActive(false);
        }

        MeshFilter mf = gameObject.AddComponent<MeshFilter>();
        mf.mesh = new Mesh();
        mf.mesh.CombineMeshes(combine);
        gameObject.SetActive(true);
    }
}

  1. Level of Detail (LOD)

Using LOD allows you to use simpler models for objects that are far from the camera, reducing the number of vertices and draw calls.

Steps to Implement LOD:

  1. Create multiple versions of your model with different levels of detail.
  2. Add an LOD Group component to your object.
  3. Assign the different LOD models to the LOD Group.
// Example: Setting up LOD in code
LODGroup lodGroup = gameObject.AddComponent<LODGroup>();
LOD[] lods = new LOD[2];
lods[0] = new LOD(0.5f, new Renderer[] { highDetailRenderer });
lods[1] = new LOD(0.1f, new Renderer[] { lowDetailRenderer });
lodGroup.SetLODs(lods);
lodGroup.RecalculateBounds();

Practical Exercise

Exercise: Optimize a Scene by Reducing Draw Calls

  1. Create a scene with multiple static objects (e.g., buildings, trees).
  2. Enable static batching for these objects.
  3. Add several dynamic objects (e.g., moving characters) and ensure they are small enough for dynamic batching.
  4. Create a group of identical objects (e.g., rocks) and enable GPU instancing for their material.
  5. Combine multiple meshes into a single mesh using the provided script.
  6. Implement LOD for a complex object.

Solution:

  1. Select all static objects and check the "Static" checkbox in the Inspector.
  2. Ensure dynamic objects are small and use the same material.
  3. Create a material for the identical objects and enable GPU instancing.
  4. Attach the MeshCombiner script to a parent object containing the meshes to combine.
  5. Add an LOD Group component to the complex object and assign different LOD models.

Common Mistakes and Tips

  • Mistake: Not marking static objects as static.
    • Tip: Always mark non-moving objects as static to enable static batching.
  • Mistake: Using too many materials and textures.
    • Tip: Use texture atlases and fewer materials to improve batching.
  • Mistake: Ignoring LOD for distant objects.
    • Tip: Implement LOD to reduce the complexity of distant objects.

Conclusion

Reducing draw calls is essential for optimizing the performance of your Unity game. By using techniques such as static and dynamic batching, GPU instancing, mesh combining, and LOD, you can significantly improve the frame rate and ensure a smoother gaming experience. Practice these techniques in your projects to see the performance benefits firsthand.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved