Оптимизация производительности в Unity: советы и лучшие практики02.08.2024 09:45

7557ca145b8ce275b4dc0be34dade6eb.png

План статьи

  1. Введение

  2. Использование профайлера Unity

  3. Оптимизация скриптов

  4. Управление памятью

  5. Оптимизация рендеринга

  6. Оптимизация физики

  7. Заключение

Введение

Зачем важна оптимизация производительности?

Оптимизация производительности — один из ключевых аспектов разработки игр. Она позволяет создать проект, который будет работать плавно и стабильно на различных устройствах, от мощных игровых ПК до мобильных телефонов. Высокий FPS (кадры в секунду) не только улучшает пользовательский опыт, но и может стать решающим фактором в успехе вашей игры на рынке.

Краткий обзор методов оптимизации

Оптимизация производительности включает в себя несколько направлений, каждое из которых важно по-своему:

  • Использование профайлера Unity: Инструмент для анализа производительности, который помогает выявить узкие места.

  • Оптимизация скриптов: Уменьшение нагрузки от ваших C# скриптов путем улучшения логики и кэширования данных.

  • Управление памятью: Эффективное использование ресурсов и минимизация работы сборщика мусора.

  • Оптимизация рендеринга: Сокращение количества полигонов и использование уровней детализации (LOD).

  • Оптимизация физики: Снижение нагрузки на физический движок Unity.

В этой статье мы подробно рассмотрим каждое из этих направлений и приведем наглядные примеры кода, чтобы вы могли сразу применить полученные знания на практике.

Перейдем к рассмотрению каждого из этих пунктов более детально.

Использование профайлера Unity

Как запустить и использовать профайлер

Профайлер Unity — это мощный инструмент, который позволяет анализировать производительность вашего игрового проекта. Он помогает выявить узкие места и понять, какие части вашего кода или ресурсы занимают больше всего времени и памяти. Вот как можно запустить и использовать профайлер:

  1. Запуск профайлера:

    • Откройте Unity и запустите ваш проект.

    • Перейдите в меню Window > Analysis > Profiler.

    • В нижней части экрана откроется окно профайлера.

  2. Основные вкладки профайлера:

    • CPU Usage: Показывает, сколько времени тратится на выполнение различных частей кода.

    • GPU Usage: Отображает загрузку графического процессора.

    • Memory: Помогает отслеживать использование памяти и работу сборщика мусора.

    • Rendering: Анализирует производительность рендеринга, включая количество полигонов и использование материалов.

    • Physics: Показывает затраты времени на физические расчеты.

Анализ основных метрик

Теперь, когда мы знаем, как запустить профайлер, давайте рассмотрим, как анализировать основные метрики для улучшения производительности.

  1. CPU Usage:

    • Hierarchy View: Позволяет увидеть, какие функции и методы занимают больше всего времени. Это поможет вам определить, где именно нужно оптимизировать код.

    • Timeline View: Показывает выполнение задач по времени, что позволяет увидеть, какие операции выполняются параллельно.

  2. Memory:

    • Used Heap: Отображает использование оперативной памяти. Высокие значения могут указывать на утечки памяти или неэффективное управление ресурсами.

    • Garbage Collector: Частые срабатывания сборщика мусора могут вызвать фризы в игре. Старайтесь минимизировать работу сборщика, избегая частого создания и уничтожения объектов.

  3. Rendering:

    • Draw Calls: Количество вызовов отрисовки. Меньшее количество вызовов означает лучшую производительность.

    • SetPass Calls: Количество переключений материалов. Старайтесь минимизировать их, используя атласные текстуры и объединяя материалы.

Примеры кода

Приведем пример кода, который демонстрирует оптимизацию путем кэширования компонентов: 

// Пример плохого кода: частое обращение к GetComponent в методе Update
public class BadExample : MonoBehaviour
{
    void Update()
    {
        GetComponent().material.color = Color.red;
    }
}

// Пример хорошего кода: кэширование компонента в методе Start
public class GoodExample : MonoBehaviour
{
    private Renderer _renderer;

    void Start()
    {
        _renderer = GetComponent();
    }

    void Update()
    {
        _renderer.material.color = Color.red;
    }
}

Примечания к коду:

  • В первом примере каждый кадр вызывается метод GetComponent, что создает дополнительную нагрузку на CPU.

  • Во втором примере компонент кэшируется в переменную _renderer в методе Start, что уменьшает количество вызовов GetComponent и улучшает производительность.

Использование профайлера Unity позволяет наглядно увидеть, какие аспекты вашего проекта нуждаются в оптимизации. Анализируя данные, предоставленные профайлером, вы сможете принимать обоснованные решения и улучшать производительность вашей игры.

Далее мы рассмотрим оптимизацию скриптов.

Оптимизация скриптов

Избегание ненужных обновлений

Один из основных способов оптимизации скриптов в Unity — это избегание ненужных обновлений. Методы Update, FixedUpdate и LateUpdate вызываются каждый кадр, что может сильно нагружать процессор, особенно если в них содержатся ресурсоемкие операции.

Пример плохого кода: 

public class BadUpdateExample : MonoBehaviour
{
    void Update()
    {
        // Проверка состояния каждый кадр
        if (Input.GetKeyDown(KeyCode.Space))
        {
            Jump();
        }
    }

    void Jump()
    {
        // Логика прыжка
    }
}

Пример хорошего кода: 

public class GoodUpdateExample : MonoBehaviour
{
    void Start()
    {
        // Подписка на событие один раз при запуске
        Input.GetKeyDown(KeyCode.Space) += Jump;
    }

    void Jump()
    {
        // Логика прыжка
    }
}

Примечания к коду:

  • В первом примере метод Update проверяет состояние клавиши каждый кадр, что неэффективно.

  • Во втором примере используется событие для выполнения действия только тогда, когда это необходимо, что уменьшает нагрузку на CPU.

Использование кэширования компонентов

Частое использование метода GetComponent может значительно снизить производительность, так как каждый вызов этого метода требует поиска компонента в иерархии объектов. Кэширование компонентов позволяет избежать этой проблемы.

Пример плохого кода: 

public class BadGetComponentExample : MonoBehaviour
{
    void Update()
    {
        GetComponent().material.color = Color.red;
    }
}

Пример хорошего кода: 

public class GoodGetComponentExample : MonoBehaviour
{
    private Renderer _renderer;

    void Start()
    {
        _renderer = GetComponent();
    }

    void Update()
    {
        _renderer.material.color = Color.red;
    }
}

Примечания к коду:

  • В первом примере каждый кадр вызывается метод GetComponent, что создает дополнительную нагрузку на CPU.

  • Во втором примере компонент кэшируется в переменную _renderer в методе Start, что уменьшает количество вызовов GetComponent и улучшает производительность.

Пример использования событий и делегатов: 

public class EventExample : MonoBehaviour
{
    public delegate void OnJumpAction();
    public static event OnJumpAction OnJump;

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space) && OnJump != null)
        {
            OnJump();
        }
    }
}

public class JumpHandler : MonoBehaviour
{
    void OnEnable()
    {
        EventExample.OnJump += HandleJump;
    }

    void OnDisable()
    {
        EventExample.OnJump -= HandleJump;
    }

    void HandleJump()
    {
        // Логика прыжка
    }
}

Примечания к коду:

  • Использование событий и делегатов позволяет эффективно управлять действиями, которые должны выполняться при наступлении определенных условий, что улучшает читаемость и поддержку кода.

Оптимизация скриптов в Unity включает множество методов и техник, которые могут существенно улучшить производительность вашего проекта. Важно анализировать каждую часть кода и применять лучшие практики, чтобы добиться наилучших результатов.

Управление памятью

Работа с текстурами и ресурсами

Эффективное управление памятью включает в себя оптимизацию работы с текстурами и ресурсами. Текстуры могут занимать значительное количество памяти, особенно в проектах с высокой детализацией графики.

Советы по оптимизации текстур:

  1. Размеры текстур:

    • Используйте текстуры с меньшими разрешениями, когда это возможно. Большие текстуры увеличивают объем памяти, необходимый для их хранения.

    • Используйте формат текстур сжатия, например, DXT (S3TC) для настольных приложений и ASTC/PVRTC для мобильных устройств.

  2. Mipmap:

    • Включайте Mipmap для текстур, которые используются на объектах, находящихся на различных расстояниях от камеры. Это помогает уменьшить нагрузку на память и повысить производительность.

  3. Atlas Textures:

Пример настройки текстуры в Unity: 

using UnityEngine;

public class TextureOptimization : MonoBehaviour
{
    public Texture2D texture;

    void Start()
    {
        // Пример настройки текстуры для использования Mipmap и сжатия
        texture.filterMode = FilterMode.Bilinear;
        texture.anisoLevel = 4;
        texture.wrapMode = TextureWrapMode.Repeat;
    }
}

Примечания к коду:

Минимизация работы сборщика мусора

Сборщик мусора (Garbage Collector) в Unity автоматически управляет памятью, но частые его срабатывания могут вызывать лаги и задержки в игре. Чтобы минимизировать работу сборщика мусора, следуйте этим советам:

  1. Избегайте частого создания и уничтожения объектов:

    • Старайтесь переиспользовать объекты, вместо того чтобы создавать новые и уничтожать старые.

    • Используйте пулы объектов для управления часто создаваемыми и уничтожаемыми объектами.

  2. Используйте структуры данных с предсказуемым выделением памяти:

    • Избегайте использования коллекций, которые часто изменяют свой размер, таких как List. Вместо этого используйте массивы или Queue с заранее заданным размером.

  3. Кэширование объектов:

Пример использования пулов объектов: 

public class ObjectPooler : MonoBehaviour
{
    public static ObjectPooler Instance;
    public GameObject objectToPool;
    public int amountToPool;

    private List pooledObjects;

    void Awake()
    {
        Instance = this;
    }

    void Start()
    {
        pooledObjects = new List();
        for (int i = 0; i < amountToPool; i++)
        {
            GameObject obj = Instantiate(objectToPool);
            obj.SetActive(false);
            pooledObjects.Add(obj);
        }
    }

    public GameObject GetPooledObject()
    {
        foreach (var obj in pooledObjects)
        {
            if (!obj.activeInHierarchy)
            {
                return obj;
            }
        }

        GameObject newObj = Instantiate(objectToPool);
        newObj.SetActive(false);
        pooledObjects.Add(newObj);
        return newObj;
    }
}

Примечания к коду:

  • В данном примере создается пул объектов для переиспользования, что уменьшает количество выделений и освобождений памяти, минимизируя работу сборщика мусора.

  • Я уже писал статью по теме Паттернов, в том числе и про Object Polo

Управление памятью в Unity является важным аспектом оптимизации, который напрямую влияет на производительность игры. Применяя указанные выше методы и практики, вы сможете значительно снизить нагрузку на память и улучшить общую производительность вашего проекта.

Оптимизация рендеринга

Уменьшение количества полигонов

Уменьшение количества полигонов в сцене — это один из самых эффективных способов оптимизации рендеринга в Unity. Меньшее количество полигонов означает меньшую нагрузку на GPU, что особенно важно для мобильных устройств и VR-приложений.

Советы по уменьшению количества полигонов:

  1. Использование низкополигональных моделей:

    • Создавайте и используйте модели с минимальным количеством полигонов, которые по-прежнему обеспечивают удовлетворительное визуальное качество.

  2. Удаление невидимых полигонов:

    • Убедитесь, что модели не содержат полигонов, которые никогда не будут видны игроку, например, внутренних частей объектов.

  3. Использование нормалей и текстур:

Пример уменьшения количества полигонов: 

using UnityEngine;

public class LowPolyExample : MonoBehaviour
{
    public MeshFilter meshFilter;

    void Start()
    {
        // Применение упрощенной низкополигональной модели
        Mesh lowPolyMesh = new Mesh();
        // Установка вершин, нормалей и треугольников для низкополигональной модели
        // (Примерный код, не учитывающий реальную модель)
        lowPolyMesh.vertices = new Vector3[] { new Vector3(0, 0, 0), new Vector3(0, 1, 0), new Vector3(1, 0, 0) };
        lowPolyMesh.normals = new Vector3[] { Vector3.up, Vector3.up, Vector3.up };
        lowPolyMesh.triangles = new int[] { 0, 1, 2 };
        meshFilter.mesh = lowPolyMesh;
    }
}

Примечания к коду:

  • В данном примере создается простая низкополигональная модель, состоящая всего из одного треугольника. В реальном проекте вы можете импортировать низкополигональные модели из 3D-редакторов, таких как Blender или 3ds Max.

Использование уровней детализации (LOD)

Уровни детализации (Level of Detail, LOD) позволяют динамически изменять количество полигонов моделей в зависимости от расстояния до камеры. Это позволяет уменьшить нагрузку на GPU при рендеринге объектов, находящихся вдали от камеры, без заметного снижения визуального качества.

Настройка LOD в Unity:

  1. Создание LOD-группы:

    • Выберите объект в сцене.

    • В инспекторе добавьте компонент LOD Group (Component > Rendering > LOD Group).

  2. Настройка уровней LOD:

    • Добавьте различные уровни LOD, каждый из которых использует модель с разным количеством полигонов.

    • Настройте проценты экрана для каждого уровня LOD, чтобы определить, когда каждая модель будет использоваться.

Пример настройки LOD-группы: 

using UnityEngine;

public class LODExample : MonoBehaviour
{
    public GameObject highPolyModel;
    public GameObject mediumPolyModel;
    public GameObject lowPolyModel;

    void Start()
    {
        LODGroup lodGroup = gameObject.AddComponent();

        LOD[] lods = new LOD[3];

        Renderer[] highPolyRenderers = highPolyModel.GetComponentsInChildren();
        Renderer[] mediumPolyRenderers = mediumPolyModel.GetComponentsInChildren();
        Renderer[] lowPolyRenderers = lowPolyModel.GetComponentsInChildren();

        lods[0] = new LOD(0.5f, highPolyRenderers);
        lods[1] = new LOD(0.3f, mediumPolyRenderers);
        lods[2] = new LOD(0.1f, lowPolyRenderers);

        lodGroup.SetLODs(lods);
        lodGroup.RecalculateBounds();
    }
}

Примечания к коду:

  • В данном примере создается LOD-группа для объекта, состоящего из трех уровней детализации: высокополигональной, средней и низкополигональной моделей. Каждый уровень LOD будет использоваться в зависимости от расстояния до камеры, что позволяет уменьшить количество полигонов, рендерящихся одновременно.

Примеры кода

Рассмотрим более сложные примеры, включающие оптимизацию различных аспектов рендеринга.

Пример использования атласов текстур: 

using UnityEngine;

public class TextureAtlasExample : MonoBehaviour
{
    public Material atlasMaterial;

    void Start()
    {
        // Применение атласной текстуры к материалу
        Renderer renderer = GetComponent();
        renderer.material = atlasMaterial;
    }
}

Примечания к коду:

  • Использование атласов текстур позволяет объединить несколько текстур в одну, что уменьшает количество вызовов рендеринга и улучшает производительность.

Оптимизация рендеринга в Unity включает в себя множество методов и техник, которые могут существенно улучшить производительность вашего проекта. Применяя указанные выше методы и практики, вы сможете значительно снизить нагрузку на GPU и улучшить общую производительность вашей игры.

Оптимизация физики

Управление количеством физических объектов

Физический движок Unity может стать узким местом производительности, если в сцене находится много физических объектов. Управление количеством физических объектов и оптимизация их поведения — ключевые шаги для улучшения производительности.

Советы по оптимизации физических объектов:

  1. Уменьшение количества объектов:

    • Убедитесь, что только те объекты, которые действительно нуждаются в физическом взаимодействии, имеют компоненты Rigidbody и Collider.

    • Используйте простые формы коллайдеров (например, BoxCollider или SphereCollider) вместо сложных MeshCollider.

  2. Деактивация физических объектов:

Пример управления количеством физических объектов: 

using UnityEngine;

public class PhysicsOptimization : MonoBehaviour
{
    public GameObject[] physicalObjects;

    void Update()
    {
        foreach (GameObject obj in physicalObjects)
        {
            if (IsVisible(obj))
            {
                obj.SetActive(true);
            }
            else
            {
                obj.SetActive(false);
            }
        }
    }

    bool IsVisible(GameObject obj)
    {
        Plane[] planes = GeometryUtility.CalculateFrustumPlanes(Camera.main);
        return GeometryUtility.TestPlanesAABB(planes, obj.GetComponent().bounds);
    }
}

Примечания к коду:

  • В данном примере физические объекты активируются только тогда, когда они находятся в поле зрения камеры. Это помогает снизить нагрузку на физический движок, деактивируя ненужные объекты.

Использование слоев и коллайдеров

Использование слоев и правильная настройка взаимодействий между коллайдерами позволяет значительно сократить количество физических вычислений.

Настройка слоев и взаимодействий:

  1. Создание слоев:

    • Перейдите в меню Edit > Project Settings > Tags and Layers.

    • Создайте новые слои для различных типов физических объектов, например, Player, Enemies, Environment.

  2. Настройка взаимодействий слоев:

    • Перейдите в меню Edit > Project Settings > Physics.

    • В разделе Layer Collision Matrix отключите взаимодействие между слоями, которые не должны взаимодействовать друг с другом.

Пример использования слоев и коллайдеров: 

using UnityEngine;

public class LayerOptimization : MonoBehaviour
{
    private void Start()
    {
        // Установка слоя для объекта
        gameObject.layer = LayerMask.NameToLayer("Player");

        // Игнорирование столкновений между слоями Player и Environment
        Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Player"), LayerMask.NameToLayer("Environment"));
    }
}

Примечания к коду:

  • В данном примере объекту назначается слой Player, и настраивается игнорирование столкновений между слоями Player и Environment, что сокращает количество ненужных физических взаимодействий.

Примеры кода

Рассмотрим дополнительные примеры, включающие оптимизацию различных аспектов физики.

Пример использования простых коллайдеров: 

using UnityEngine;

public class SimpleColliders : MonoBehaviour
{
    private void Start()
    {
        // Замена сложного MeshCollider на простой BoxCollider
        MeshCollider meshCollider = GetComponent();

        if (meshCollider != null)
        {
            Destroy(meshCollider);
            gameObject.AddComponent();
        }
    }
}

Примечания к коду:

  • В данном примере сложный MeshCollider заменяется на простой BoxCollider, что уменьшает количество вычислений, необходимых для обработки физических взаимодействий.

Пример использования Triggers для оптимизации взаимодействий: 

using UnityEngine;

public class TriggerOptimization : MonoBehaviour
{
    private void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            // Логика при входе игрока в триггер
        }
    }
}

Примечания к коду:

  • В данном примере используется триггер для обработки взаимодействий, что позволяет уменьшить количество физических расчетов и улучшить производительность.

Оптимизация физики в Unity включает множество методов и техник, которые могут существенно улучшить производительность вашего проекта. Применяя указанные выше методы и практики, вы сможете значительно снизить нагрузку на физический движок и улучшить общую производительность вашей игры.

Заключение

Оптимизация производительности в Unity — это сложный, но крайне важный процесс, который напрямую влияет на успех вашего игрового проекта. В этой статье мы рассмотрели ключевые методы оптимизации, включая использование профайлера Unity, оптимизацию скриптов, управление памятью, улучшение рендеринга и оптимизацию физики. Вот краткое резюме каждого из рассмотренных аспектов:

  1. Использование профайлера Unity:

    • Профайлер помогает выявить узкие места в производительности.

    • Анализ метрик CPU, Memory и Rendering позволяет определить области для улучшения.

  2. Оптимизация скриптов:

    • Избегайте ненужных обновлений и используйте кэширование компонентов.

    • Применяйте пулы объектов и события для уменьшения нагрузки на CPU.

  3. Управление памятью:

    • Оптимизируйте использование текстур и ресурсов.

    • Минимизируйте работу сборщика мусора, избегая частого создания и уничтожения объектов.

  4. Оптимизация рендеринга:

    • Уменьшайте количество полигонов и используйте уровни детализации (LOD).

    • Объединяйте текстуры в атласы для уменьшения количества вызовов рендеринга.

  5. Оптимизация физики:

    • Управляйте количеством физических объектов и используйте слои для настройки взаимодействий.

    • Применяйте простые коллайдеры и триггеры для снижения нагрузки на физический движок.

Дополнительные ресурсы для изучения

Если вы хотите углубить свои знания по оптимизации производительности в Unity, вот несколько полезных ресурсов:

  • Документация Unity: Optimization Guide

  • Курсы и туториалы на платформах, таких как Coursera, Udemy, и Pluralsight.

  • Форумы и сообщества: Unity Forums, Stack Overflow, и Reddit.

Оптимизация производительности требует времени и усилий, но результаты стоят того. Применяя рассмотренные в статье методы и техники, вы сможете создать игру, которая будет работать плавно и стабильно на различных устройствах, обеспечивая лучший пользовательский опыт. Удачи в ваших проектах и продолжайте учиться и совершенствоваться в искусстве оптимизации!

© Habrahabr.ru