Unity Game Engine Series Part 15: Performance Optimization

1. CPU Optimization

1.1 Unity Profiler Deep Dive

The Unity Profiler (Window → Analysis → Profiler) is your primary diagnostic tool. The CPU Usage module shows exactly how your frame time is distributed:

1.2 Common CPU Bottlenecks

// COMMON CPU HOGS — and their fixes

// --- 1. Update() Overhead ---
// BAD: Expensive logic every frame for hundreds of objects
public class EnemyAI_Bad : MonoBehaviour
{
    void Update()
    {
        // FindObjectOfType is O(n) across ALL objects — never use in Update!
        var player = FindObjectOfType<PlayerController>();
        float dist = Vector3.Distance(transform.position, player.transform.position);

        // GetComponent every frame — allocates and searches
        var health = GetComponent<HealthComponent>();

        // String concatenation in Update — creates garbage every frame
        gameObject.name = "Enemy_" + health.CurrentHealth.ToString();
    }
}

// GOOD: Cache references, use events, stagger updates
public class EnemyAI_Good : MonoBehaviour
{
    private Transform playerTransform;  // Cached reference
    private HealthComponent health;     // Cached component

    private void Awake()
    {
        health = GetComponent<HealthComponent>();  // Cache once
    }

    private void Start()
    {
        // Cache the player reference once
        playerTransform = ServiceLocator.Get<IPlayerService>().Transform;
    }

    private void Update()
    {
        // sqrMagnitude avoids the sqrt in Distance — 30% faster
        float sqrDist = (transform.position - playerTransform.position)
            .sqrMagnitude;

        // Only process AI if within range
        if (sqrDist > 400f) return; // 20 units squared
    }
}

// --- 2. LINQ Allocations ---
// BAD: LINQ allocates iterators, closures, temporary arrays
var closestEnemy_Bad = enemies
    .Where(e => e.IsAlive)
    .OrderBy(e => Vector3.Distance(e.Position, playerPos))
    .FirstOrDefault();

// GOOD: Manual loop — zero allocations
GameObject closestEnemy_Good = null;
float closestDist = float.MaxValue;
for (int i = 0; i < enemies.Count; i++)
{
    if (!enemies[i].IsAlive) continue;
    float dist = (enemies[i].Position - playerPos).sqrMagnitude;
    if (dist < closestDist)
    {
        closestDist = dist;
        closestEnemy_Good = enemies[i].gameObject;
    }
}

// --- 3. Physics Queries ---
// BAD: Physics.RaycastAll allocates a new array every call
var hits_Bad = Physics.RaycastAll(origin, direction, 100f);

// GOOD: Non-allocating version with pre-allocated buffer
private readonly RaycastHit[] hitBuffer = new RaycastHit[32];
int hitCount = Physics.RaycastNonAlloc(
    origin, direction, hitBuffer, 100f);
for (int i = 0; i < hitCount; i++)
{
    // Process hitBuffer[i]
}

// --- 4. String Operations ---
// BAD: String concatenation creates garbage
string display_Bad = "HP: " + health + "/" + maxHealth + " | Score: " + score;

// GOOD: StringBuilder for complex strings, or interpolation once
private readonly System.Text.StringBuilder sb =
    new System.Text.StringBuilder(64);
sb.Clear();
sb.Append("HP: ").Append(health).Append('/').Append(maxHealth)
  .Append(" | Score: ").Append(score);
string display_Good = sb.ToString();

2. GPU Optimization

GPU bottlenecks manifest as low frame rates even when CPU utilization is low. The Frame Debugger (Window → Analysis → Frame Debugger) lets you step through every draw call in a frame to understand exactly what the GPU is rendering.

2.1 Draw Calls & Batching

Every time the CPU tells the GPU to render something, that is a draw call. Each draw call has overhead: setting up the pipeline state, uploading data, issuing the command. The goal is to minimize draw calls while maintaining visual quality.

// GPU Instancing for rendering thousands of objects efficiently
using UnityEngine;

public class VegetationInstancer : MonoBehaviour
{
    [SerializeField] private Mesh grassMesh;
    [SerializeField] private Material grassMaterial; // GPU Instancing enabled
    [SerializeField] private int instanceCount = 10000;
    [SerializeField] private float spawnRadius = 100f;

    private Matrix4x4[][] batchMatrices;
    private MaterialPropertyBlock propertyBlock;

    private void Start()
    {
        propertyBlock = new MaterialPropertyBlock();

        // Graphics.DrawMeshInstanced has a 1023 limit per call
        int batchCount = Mathf.CeilToInt(instanceCount / 1023f);
        batchMatrices = new Matrix4x4[batchCount][];

        for (int batch = 0; batch < batchCount; batch++)
        {
            int count = Mathf.Min(1023, instanceCount - batch * 1023);
            batchMatrices[batch] = new Matrix4x4[count];

            for (int i = 0; i < count; i++)
            {
                Vector3 pos = Random.insideUnitSphere * spawnRadius;
                pos.y = 0; // Ground level
                Quaternion rot = Quaternion.Euler(0, Random.Range(0, 360), 0);
                float scale = Random.Range(0.8f, 1.2f);

                batchMatrices[batch][i] = Matrix4x4.TRS(
                    pos, rot, Vector3.one * scale);
            }
        }
    }

    private void Update()
    {
        // Render all instances — potentially 10,000 meshes in ~10 draw calls
        for (int batch = 0; batch < batchMatrices.Length; batch++)
        {
            Graphics.DrawMeshInstanced(
                grassMesh, 0, grassMaterial,
                batchMatrices[batch], batchMatrices[batch].Length,
                propertyBlock);
        }
    }
}

2.2 Occlusion Culling & LOD

// Custom LOD distance control per layer
using UnityEngine;

public class CameraLODSetup : MonoBehaviour
{
    private Camera cam;

    private void Start()
    {
        cam = GetComponent<Camera>();

        // Set per-layer culling distances
        float[] distances = new float[32];
        distances[LayerMask.NameToLayer("SmallProps")] = 50f;   // Small items cull at 50m
        distances[LayerMask.NameToLayer("Vegetation")] = 100f;  // Trees cull at 100m
        distances[LayerMask.NameToLayer("Buildings")] = 500f;   // Buildings cull at 500m
        // Layer 0 (Default) stays at camera.farClipPlane

        cam.layerCullDistances = distances;
        cam.layerCullSpherical = true; // Spherical culling (better for open world)
    }
}

3. Memory Management

Unity uses two memory systems: managed memory (C# heap, handled by the garbage collector) and native memory (C++ engine internals, textures, meshes, audio). Understanding both is critical for avoiding memory-related performance issues.

3.1 Garbage Collection Strategies

3.2 Zero-Allocation Patterns

// Zero-allocation patterns for hot paths

// --- 1. Struct vs Class ---
// Classes allocate on heap (GC pressure). Structs allocate on stack (free).
// Use structs for small, short-lived data passed by value.

// BAD: Class creates garbage when temporary
public class DamageInfo_Bad
{
    public float Damage;
    public Vector3 HitPoint;
    public GameObject Source;
}

// GOOD: Struct — zero heap allocation
public struct DamageInfo
{
    public float Damage;
    public Vector3 HitPoint;
    public GameObject Source;
}

// --- 2. ArrayPool for temporary arrays ---
using System.Buffers;

public class EnemyScanner : MonoBehaviour
{
    public void ScanArea()
    {
        // Rent a pre-allocated array from the pool
        var buffer = ArrayPool<Collider>.Shared.Rent(64);

        try
        {
            int count = Physics.OverlapSphereNonAlloc(
                transform.position, 20f, buffer);

            for (int i = 0; i < count; i++)
            {
                // Process buffer[i]
            }
        }
        finally
        {
            // Return to pool — critical! Do not forget
            ArrayPool<Collider>.Shared.Return(buffer);
        }
    }
}

// --- 3. NativeCollections (DOTS) for large datasets ---
using Unity.Collections;

public class PathfindingJob : MonoBehaviour
{
    private NativeArray<float3> waypoints;

    private void Start()
    {
        // NativeArray bypasses GC — allocated in native memory
        waypoints = new NativeArray<float3>(1000, Allocator.Persistent);
    }

    private void OnDestroy()
    {
        // MUST dispose manually — no GC to clean up native memory
        if (waypoints.IsCreated)
            waypoints.Dispose();
    }
}

// --- 4. Avoiding closures / lambda allocations ---
// BAD: Lambda captures `minHealth`, creating a closure object
float minHealth = 50f;
var healthyEnemies_Bad = enemies.FindAll(e => e.Health > minHealth);

// GOOD: Manual loop — no allocation
private readonly List<Enemy> tempList = new List<Enemy>();
public List<Enemy> GetHealthyEnemies(List<Enemy> enemies, float minHP)
{
    tempList.Clear();
    for (int i = 0; i < enemies.Count; i++)
    {
        if (enemies[i].Health > minHP)
            tempList.Add(enemies[i]);
    }
    return tempList;
}

4. Object Pooling

Object pooling is the single most impactful optimization pattern for games that create and destroy objects frequently — bullets, particles, enemies, UI elements. Instead of Instantiate() and Destroy() (which trigger memory allocation and GC), you pre-create objects, deactivate them when "destroyed," and reactivate them when needed.

4.1 Generic Pool Implementation

// GenericPool.cs — A reusable, generic object pool
using System.Collections.Generic;
using UnityEngine;

public class GenericPool<T> where T : Component
{
    private readonly T prefab;
    private readonly Transform parent;
    private readonly Queue<T> available = new Queue<T>();
    private readonly HashSet<T> inUse = new HashSet<T>();
    private readonly int maxSize;

    public int CountActive => inUse.Count;
    public int CountInactive => available.Count;

    public GenericPool(T prefab, Transform parent, int preWarm = 10,
        int maxSize = 100)
    {
        this.prefab = prefab;
        this.parent = parent;
        this.maxSize = maxSize;

        // Pre-warm the pool
        for (int i = 0; i < preWarm; i++)
        {
            T obj = CreateNew();
            obj.gameObject.SetActive(false);
            available.Enqueue(obj);
        }
    }

    private T CreateNew()
    {
        T obj = Object.Instantiate(prefab, parent);
        return obj;
    }

    /// <summary>
    /// Get an object from the pool. Creates a new one if empty.
    /// </summary>
    public T Get(Vector3 position, Quaternion rotation)
    {
        T obj;

        if (available.Count > 0)
        {
            obj = available.Dequeue();
        }
        else if (inUse.Count < maxSize)
        {
            obj = CreateNew();
        }
        else
        {
            Debug.LogWarning($"Pool for {prefab.name} exhausted " +
                $"({maxSize} objects). Consider increasing maxSize.");
            return null;
        }

        obj.transform.SetPositionAndRotation(position, rotation);
        obj.gameObject.SetActive(true);
        inUse.Add(obj);

        // Call IPoolable.OnSpawn if implemented
        if (obj is IPoolable poolable)
            poolable.OnSpawn();

        return obj;
    }

    /// <summary>
    /// Return an object to the pool.
    /// </summary>
    public void Release(T obj)
    {
        if (!inUse.Contains(obj))
        {
            Debug.LogWarning("Trying to release object not owned by this pool.");
            return;
        }

        // Call IPoolable.OnDespawn if implemented
        if (obj is IPoolable poolable)
            poolable.OnDespawn();

        obj.gameObject.SetActive(false);
        inUse.Remove(obj);
        available.Enqueue(obj);
    }
}

// IPoolable interface for reset logic
public interface IPoolable
{
    void OnSpawn();   // Called when retrieved from pool
    void OnDespawn(); // Called when returned to pool
}

// Example: Bullet with pooling support
public class Bullet : MonoBehaviour, IPoolable
{
    [SerializeField] private float speed = 50f;
    [SerializeField] private float lifetime = 3f;
    private float timer;

    public void OnSpawn()
    {
        timer = lifetime;
        // Reset any state
    }

    public void OnDespawn()
    {
        // Clean up trails, particles, etc.
    }

    private void Update()
    {
        transform.Translate(Vector3.forward * speed * Time.deltaTime);
        timer -= Time.deltaTime;

        if (timer <= 0)
        {
            // Return to pool instead of Destroy
            BulletManager.Instance.ReturnBullet(this);
        }
    }
}

4.2 Unity's Built-in ObjectPool<T>

// Using Unity's built-in ObjectPool<T> (Unity 2021+)
using UnityEngine;
using UnityEngine.Pool;

public class ProjectileSpawner : MonoBehaviour
{
    [SerializeField] private Projectile prefab;
    private ObjectPool<Projectile> pool;

    private void Awake()
    {
        pool = new ObjectPool<Projectile>(
            createFunc: () => Instantiate(prefab),
            actionOnGet: proj => {
                proj.gameObject.SetActive(true);
                proj.Init(pool); // Pass pool reference for self-return
            },
            actionOnRelease: proj => proj.gameObject.SetActive(false),
            actionOnDestroy: proj => Destroy(proj.gameObject),
            collectionCheck: true,  // Warn on double-release
            defaultCapacity: 20,
            maxSize: 200
        );
    }

    public Projectile SpawnProjectile(Vector3 pos, Quaternion rot)
    {
        var proj = pool.Get();
        proj.transform.SetPositionAndRotation(pos, rot);
        return proj;
    }
}

// Projectile returns itself to the pool
public class Projectile : MonoBehaviour
{
    private IObjectPool<Projectile> ownerPool;

    public void Init(IObjectPool<Projectile> pool)
    {
        ownerPool = pool;
    }

    private void OnCollisionEnter(Collision other)
    {
        // Apply damage, spawn effects...
        ownerPool.Release(this); // Return to pool instead of Destroy
    }
}

5. Asset Optimization

5.1 Texture & Mesh Optimization

5.2 Addressables & Asset Bundles

// Addressables for on-demand asset loading
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

public class LevelAssetLoader : MonoBehaviour
{
    // Addressable asset reference — assigned in Inspector
    [SerializeField] private AssetReference levelPrefabRef;
    private AsyncOperationHandle<GameObject> loadHandle;

    public async void LoadLevel()
    {
        // Load asynchronously — no memory spike
        loadHandle = Addressables.InstantiateAsync(levelPrefabRef);
        GameObject level = await loadHandle.Task;

        if (loadHandle.Status == AsyncOperationStatus.Succeeded)
        {
            Debug.Log($"Level loaded: {level.name}");
        }
    }

    public void UnloadLevel()
    {
        // Release the loaded asset — frees memory
        if (loadHandle.IsValid())
        {
            Addressables.ReleaseInstance(loadHandle);
        }
    }

    // Preload assets during loading screen
    public async void PreloadCombatAssets()
    {
        // Download/load multiple assets in parallel
        var swordHandle = Addressables.LoadAssetAsync<GameObject>("Sword_01");
        var shieldHandle = Addressables.LoadAssetAsync<GameObject>("Shield_01");
        var effectHandle = Addressables.LoadAssetAsync<GameObject>("HitEffect");

        await System.Threading.Tasks.Task.WhenAll(
            swordHandle.Task, shieldHandle.Task, effectHandle.Task);

        Debug.Log("All combat assets preloaded!");
    }
}

6. Profiling Workflow

6.1 Target Frame Budgets

6.2 Platform-Specific Profiling

// Custom Profiler Markers for your own systems
using Unity.Profiling;
using UnityEngine;

public class AIManager : MonoBehaviour
{
    // Custom profiler markers show up in the Profiler timeline
    static readonly ProfilerMarker s_AIUpdate =
        new ProfilerMarker("AIManager.UpdateAllAI");
    static readonly ProfilerMarker s_Pathfinding =
        new ProfilerMarker("AIManager.Pathfinding");
    static readonly ProfilerMarker s_DecisionMaking =
        new ProfilerMarker("AIManager.DecisionMaking");

    private void Update()
    {
        // Wrap in profiler marker to see timing in Profiler
        using (s_AIUpdate.Auto())
        {
            UpdatePathfinding();
            UpdateDecisions();
        }
    }

    private void UpdatePathfinding()
    {
        using (s_Pathfinding.Auto())
        {
            // Pathfinding logic here
            // This will appear as a child of AIManager.UpdateAllAI
        }
    }

    private void UpdateDecisions()
    {
        using (s_DecisionMaking.Auto())
        {
            // Decision tree / FSM logic here
        }
    }
}

// Runtime FPS counter for development builds
public class FPSCounter : MonoBehaviour
{
    private float deltaTime;
    private float updateInterval = 0.5f;
    private float timer;
    private float currentFPS;

    private void Update()
    {
        deltaTime += (Time.unscaledDeltaTime - deltaTime) * 0.1f;
        timer += Time.unscaledDeltaTime;

        if (timer >= updateInterval)
        {
            currentFPS = 1.0f / deltaTime;
            timer = 0;
        }
    }

    #if DEVELOPMENT_BUILD || UNITY_EDITOR
    private void OnGUI()
    {
        int fps = Mathf.RoundToInt(currentFPS);
        float ms = deltaTime * 1000f;
        string text = $"{fps} FPS ({ms:F1} ms)";

        Color color = fps >= 55 ? Color.green :
                      fps >= 30 ? Color.yellow : Color.red;

        GUI.color = color;
        GUI.Label(new Rect(10, 10, 200, 30), text,
            new GUIStyle { fontSize = 18, fontStyle = FontStyle.Bold,
                normal = new GUIStyleState { textColor = color } });
    }
    #endif
}

Exercises & Self-Assessment

Conclusion & Next Steps

You now have professional-level knowledge of Unity performance optimization. Here are the key takeaways from Part 15:

• Measure first, optimize second — the Unity Profiler and Frame Debugger are your most important tools; never guess where bottlenecks are
• CPU optimization starts with eliminating per-frame allocations, caching references, using NonAlloc physics queries, and avoiding LINQ in hot paths
• GPU optimization focuses on reducing draw calls through batching, GPU instancing, LOD systems, and occlusion culling
• Memory management requires understanding managed vs. native memory, minimizing GC pressure with structs and pools, and using the Memory Profiler to find leaks
• Object pooling is the single most impactful pattern for games that create/destroy objects frequently
• Asset optimization — correct texture compression per platform, mesh LOD, and Addressables for on-demand loading — determines your memory footprint
• Profile on target hardware — Editor profiling is misleading; always validate on the actual device