Unity dots что это
Производительность по умолчанию
Новый высокопроизводительный многопоточный стек информационно-ориентированных технологий Unity (DOTS) позволяет использовать современные многоядерные процессоры на полную мощность. DOTS помогает разрабатывать богатые окружения, ускоряет разработку с помощью удобного в работе универсального кода на C#.
Мы переводим базовые системы Unity на стек информационно-ориентированных технологий. DOTS повышает производительность игр на многоядерных процессорах, не требуя разработки сложных алгоритмов для параллельных вычислений. Несмотря на то, что большинство пакетов Unity, относящихся к DOTS, в настоящее время находятся в статусе предварительной версии, некоторые из них могут сделать проект в критических для производительности аспектах значительно лучше.
DOTS — это удобная песочница для разработки безопасного многопоточного кода, повышающего производительность, оптимизирующего тепловыделение и энергопотребление мобильных устройств игроков. Кроме того, переход от объектно-ориентированного к информационно-ориентированному подходу упрощает вам многократное использование кода, а другим позволяет легче понять и дополнить его при необходимости.
Используйте мощь стека DOTS, не отказываясь от знакомых вам методов работы.
Новая функция Conversion Workflow позволяет преобразовать объекты GameObjects в экземпляры одним щелчком. А во время выполнения вы всегда можете использовать Entity Preview Inspector для визуализации процессов конвертации объектов GameObject в экземпляры. В итоге вы получите хорошо оптимизированные, удобные в использовании данные, необходимые для привычной работы с игровыми объектами.
Наша новая экспериментальная функция Unity Live Link также позволяет работать над контентом в режиме игры без создания новой сборки для каждого раза. Игру можно будет проверить на целевом устройстве в реальном времени, улучшая ее еще быстрее.
Megacity demo built on DOTS
Мы постоянно добавляем в стек новые пакеты, и со временем каждый из них будет проверен и готов к широкому применению. Мы настоятельно рекомендуем вам использовать предварительные версии пактов только для тестирования и на этапе подготовки к производству проекта.
Пакеты DOTS
Наш стек информационно-ориентированных технологий (DOTS) позволит использовать все возможности современных многоядерных процессоров без необходимости в сложных программных алгоритмах. DOTS находится в статусе предварительной версии, и мы постоянно добавляем новые пакеты в стек.
Придерживаясь курса переработки базовых систем Unity на основе DOTS, мы постоянно добавляем в стек новые функции. Предлагаем вам обзор важнейших пакетов DOTS, над которыми мы сейчас работаем.
Entity Component System (ECS) позволяет разрабатывать высокопроизводительный код C#, решающий только те задачи, которые вы ставите, а именно обработку данных и логики вашей игры.
ECS — это наш локомотив перехода от объектно-ориентированного подхода к информационно-ориентированному. ECS в Unity позволяет использовать систему задач C# и Burst Compiler, раскрывая весь потенциал современных многоядерных процессоров и их кеша.
Информационно-ориентированный подход также означает большие возможности по повторному использованию кода и облегчению его понимания и дополнения другими членами команды.
Информацию о разработке игрового процесса с помощью ECS смотрите в документации ECS. О вариантах подходов к программированию можно узнать из доклада «Возможности взаимодействий сущностей», представленного на Unite Copenhagen 2019. Мы также рекомендуем загрузить примеры Entity Component System с GitHub.
Пакет Entities также содержит инструмент Unity Live Link. Unity Live Link позволяет вносить изменения в редакторе, которые будут тут же отображаться на всех подключенных устройствах с запущенным приложением. Это позволяет получать информацию о производительности физического устройства напрямую.
Другой инструмент, Conversion Workflow, преобразует объекты GameObject в сущности одним щелчком, позволяя вам работать с DOTS, используя привычные вам GameObject.
Система задач C# использует преимущества многоядерных процессоров современных компьютеров. Система создана с целью помочь программистам C# в разработке безопасного, быстрого и параллелизуемого кода.
Использование многоядерных процессоров
Система задач C# раскрывает внутреннюю систему задач C++ Unity, позволяя скриптам C# выполняться в виде задач вместе с внутренними компонентами Unity.
Безопасная среда
Обеспечивает защиту от некоторых проблем многопоточных вычислений, например в условиях гонки.
Новая основанная на LLVM вычислительная технология бэкенд-компиляции превращает задачи C# в глубоко оптимизированный машинный код.
Лучшее от каждой платформы
Компилятор Burst оптимизирует сборку кода для целевой платформы.
Меньше ручного написания кода
С легкостью пользуйтесь преимуществами настроенного вручную ассемблерного кода на различных платформах.
Мы разработали новейший физический движок на основе технологий DOTS, благодаря которому вы сможете моделировать физику без ущерба производительности, совместимую с современными требованиями к сетевому обмену данными. Система Unity Physics еще находится в статусе предварительной версии и совместима с Unity 2019.1 и более поздними выпусками.
Для клиентов, которым необходимы крайне сложные физические вычисления, мы предлагаем Havok Physics для Unity. В основе решения используется ведущий в отрасли физический движок Havok Physics, работающий более чем в половине игр для нынешнего поколения консолей. Оно построено на основе платформы DOTS C#, как и Unity Physics, но обеспечивает функциональность, производительность, стабильность и надежность закрытого проприетарного движка Havok Physics, написанного на нативном C++.
Если вы планируете создать многопользовательскую игру в Unity, то для понимания наших достижений в этой области советуем ознакомиться с проектом DOTS Sample. Включенный в проект NetCode обеспечивает прогнозирование на стороне клиента, «авторитетный» сервер и интерполяцию, упрощая разработку шутера.
Узнайте о планах на развитие сетевых функций Unity из доклада на Unite Copenhagen 2019.
Основа готовящейся к выходу звуковой системы DOTS — DSPGraph (теперь в статусе предварительной версии). Наша новая низкоуровневая звуковая подсистема работает с компилятором Burst и полностью расширяется с использованием C#, что позволяет программистам и разработчикам звукового оформления создавать собственные звуковые системы.
Присоединяйтесь к обсуждению звуковой подсистемы DOTS на форуме, задавайте вопросы или делитесь своими требованиями к звуку.
Раннюю версию разрабатываемой системы анимации для DOTS можно увидеть в действии в проекте DOTS Sample. Этот пакет предлагает базовые функции анимации, включая смешивание, инверсную кинематику, слои и маски. Кроме того, мы работаем над добавлением новых возможностей.
С помощью Project Tiny, новой модульной среды выполнения Unity на основе DOTS, вы сможете создавать быстрые игры небольшого размера, легкие и производительные. Загрузите демо-проект Tiny Racing, чтобы узнать, над чем мы сейчас работаем. Он содержит предварительную версию возможностей 3D-рендеринга и позволяет подготовить сборки для iOS, Android, HTML5, Windows и Mac.
Доступны DOTS Sample и новые функции
Узнайте о новинках проектов на основе DOTS в Unity 2019.3, включая анимацию на базе DOTS, FPS NetCode, процесс перехода на новый стек, Unity Live Link и многое другое.
Вот краткий список ключевых новинок нашего стека информационно-ориентированных технологий (DOTS). Придерживаясь курса переработки базовых систем Unity на основе DOTS, мы постоянно добавляем в стек новые пакеты. Чтобы начать их использование, установите пакеты DOTS в Unity Package Manager.
На Unite Copenhagen 2019 мы рассказали о примере проекта на DOTS, открытом демонстрационном шутере от третьего лица, показывающем взаимодействие различных новых технологий DOTS (включая Unity Physics, NetCode, Hybrid Renderer и Conversion Workflow).
Пример проекта на DOTS — это простое окружение, демонстрирующее совместную работу пакетов DOTS в многопользовательском шутере на Unity 2019.3. Он планировался как проект для внутренних тестов, но мы решили дать пользователям возможность загрузить и изучить его. Проект опубликован на GitHub со всем исходным кодом и ассетами.
Новый пакет DOTS Conversion Workflow позволяет преобразовать объекты GameObject в экземпляры для DOTS в один щелчок, чтобы использовать возможности DOTS в рамках ваших привычных методов работы. Например, вы можете использовать объекты GameObject для быстрой итерации дизайна уровня, а затем просто конвертировать их в экземпляры во время работы приложения. Новый Entity Preview Inspector позволяет понять, как объекты GameObject превращаются в экземпляры DOTS.
Этот процесс позволяет с легкостью свести объекты GameObject и классические концепции разработки контента и получить эффективные и производительные данные для работы приложения. Таким образом, вы получаете лучшие свойства обоих подходов: быстрые, понятные методы разработки игровых окружений в редакторе и отлично оптимизированные для ECS эффективные данные приложения, обеспечивающие значительный прирост производительности.
Чтобы испытать на практике новые методы работы, установите пакеты Entities (предварительная версия) и DOTS Editor с помощью менеджера пакетов.
Новое средство Unity Live Link позволяет вносить изменения в редакторе, которые будут тут же отображаться на всех подключенных устройствах с запущенным приложением. Раньше для проверки изменений приходилось создавать исполняемый файл, собирать все ассеты и скрипты, а потом загружать приложение на устройство. Теперь все это можно забыть, ведь изменения применяются в реальном времени.
Поскольку скорость итерации — это ключевой элемент разработки игровых миров, то настройка и отладка алгоритмов взаимодействия пользователя с приложением и проверка игры на реальном целевом устройстве в реальном времени могут сыграть важнейшую роль. Unity Live Link дает возможность оценить производительность приложения на устройстве, позволяя исследовать влияние различных решений на производительность устройства напрямую, находя идеальный баланс между детализацией и производительностью.
Создав сборку Live Link, вы можете просто внести изменения в сцене в редакторе и сохранить сцену, а Unity сведет все изменения и отправит их на проигрыватель Live Link.
Чтобы испытать на практике Unity Live Link, установите пакет Entities (предварительная версия) с помощью менеджера пакетов.
Новая система анимации для проектов на базе DOTS предлагает базовые функции анимации, включая смешивание, инверсную кинематику, слои и маски. Кроме того, мы работаем над добавлением новых возможностей. Экспериментальную версию пакета в работе можно увидеть в составе проекта DOTS Sample.
После этого выпуска DOTS программистам больше не придется писать шаблонный код. Вы можете просто заменить компоненты собственной разработки на атрибут [GenerateAuthoringComponent], и замените объемные структуры IJobForEach и IJobForEachWithEntity на простую, но не менее производительную Entities.ForEach(), которая теперь использует компилятор Burst и систему задач C#.
Установите пакет Entities (предварительная версия) из менеджера пакетов, чтобы перейти на новые способы программирования на базе DOTS.
В примере проекта на DOTS для обнаружения столкновений и пространственных запросов используется новая физическая система без кэширования Unity Physics. Движок написан на C# / HPC#, он демонстрирует возможности компилятора Burst. Новый движок Physics позволяет быстро и точно определять столкновения для игроков, элементов окружения и снарядов, а также определять попадания. Unity Physics также отвечает за обработку контроллера персонажа, а также за точную и производительную систему постановки ног в примере проекта на DOTS.
FPS NetCode, использованный в примере проекта на DOTS, создан на основе нового стека и упрощает разработку сетевой игры с аналогичной архитектурой. Этот компонент обеспечивает прогнозирование на стороне клиента, управляющий сервер и интерполяцию благодаря оптимизированному сетевому протоколу передачи данных. Вводную информацию об FPS NetCode можно получить из доклада Тима Йоханссона на Unite.
Чтобы начать работу, установите пакеты Unity Transport и Unity NetCode из менеджера пакетов.
Мы также продолжаем работать над системой микширования и рендеринга звука для DOTS. Мы переработали DSPGraph — новую низкоуровневую подсистему звука — увеличив ее производительность и добавив возможность выполнения подграфов, не влияющих на выходные данные графа. Это означает возможность, например, подключить узел к середине звукового графа, который подсчитывает число ударов в минуту, но он не будет влиять на звуковой сигнал.
Присоединяйтесь к обсуждению звуковой подсистемы DOTS на форуме, задавайте вопросы или делитесь своими требованиями к звуку.
Unity DOTS
Unity уже довольно давно представили миру свой новый дата-ориентированный технлогический стек (Data-Oriented Technology Stack или сокращенно DOTS). Возможно, вы уже что-то слышали о нем. Именно о DOTS сегодня и пойдет речь. Мы рассмотрим, что же это такое, с чем его едят и попробуем написать простое приложение с его помощью.
Думаю, ни для кого не секрет, что с производительностью в Unity дела обстоят далеко не самым лучшим образом. Да и производительности как таковой никогда не бывает много. В Unity, естесственно, знают, как обстоят дела с производительностью в их собственном движке; и именно поэтому и был представлен DOTS. DOTS позволяет использовать всю мощь современных мультиядерных процессоров для получения высокопроизводительного кода относительно просто и безопасно. По заявлению разработчика, благодаря использованию DOTS вы не только получаете максимально доступную (на данный момент) в Unity производительность. Одновременно с этим упрощается разработка кода, последующие его чтения и даже переиспользование кода в других проектах. На самом деле, конечно же, не все так просто; и это не какая-то серебряная пуля, и все (как и обычно) зависит целиком и полностью от разработчика: как напишет так и будет).
Так что же из себя представляет DOTS?
DOTS включает в себя три основных компонента:
Job System
Job System позволяет довольно легко писать многопоточный код, используя в качестве языка программирования основной язык программирования в Unity, а именно C#.
Burst Compiler
Burst Compiler, как понятно из названия, представляет из себя компилятор некоторого подмножества языка C# (HPC#), основной целью которого является реализация высокооптимизированного нативного кода. Большим плюсом является использование в качестве языка разработки для Burst Compiler’а C#, т.к. он позволяет продолжить писать весь код на одном языке. Когда возникла идея реализовать Burst Compiler, языком разработки могли стать C/C++, некоторый собственный язык или подмножество языка C#. Но стоит учитывать, что это не тот самый C#, к которому все привыкли. Это довольно сильно ограниченный язык, в котором нет стандартной библиотеки (читай, прощай Linq, List, Dictionary и т.д.), запрещена операция выделения памяти (т.е. никаких классов, только структуры), нет виртуальных вызовов, нет рефлексии, отключен сборщик мусора и многое другое. Это жертвы, которые пришлось принести ради производительности.
Entity Component System
Entity Component System — это архитектурный паттерн, во главе которого стоят принципы композиции, а не наследования. И хотя по названию эта парадигма очень похожа на стандартную Unity парадигму (Component System), концептуально она довольно сильно от нее отличается. ECS в Unity, как это часто бывает, написана с учетом Data-Oriented Design. Отсюда пошло название DOTS; и это же является одной из причин высокой производительности. Несмотря на плюсы, которые предлагает ECS, есть и свои сложности, а именно: необходимость перестройки мышления (уход от классического ООП и компонентно-ориентированного программирования Unity). И хотя в этом ничего особо сложного нет, но какое-то время это все же займет.
Все три компонента подсистемы DOTS направлены на получение максимально возможной (на данный момент в Unity) производительности, при этом не обременяя разработчика, что не только не усложняет его жизнь, но и во многих аспектах делает ее проще. Чтобы продемонстировать всю мощь, которую можно получить используя DOTS, разработчики из Unity представили проект Megacity — футуристический город с летающими машинами, сотнями тысяч высокодетализированных игровых объектов и уникальных источников звуков. Так же доступен исходный код этого проекта.
Разработка под ECS значительно отличается от привычного в Unity компонентного подхода. В отличие от компонента поведения, который содержит и данные и логику работы с этими данными, в ECS данные и логика строго разделены. ECS состоит из трех основных частей: сущностей (Entity), компонентов (Component) и систем (System). Этот подход позволяет реализовать декомпозицию кода, т.е. явно отделить данные от поведения, что (в теории) благоприятно сказывается на качестве кода, скорости разработки, производительности (само собой) и переиспользуемости кода. Сущности чем-то похожи на стандартные игровые объекты в Unity — по своей сути они представляют собой объекты-контейнеры для компонентов. На каждую сущность можно навешивать разные компоненты. Причем, в отличие от игрового объекта, навесить несколько однотипных компонентов на одну сущность нельзя. Обычно это не большая проблема, т.к. можно создать столько сущностей, сколько требуется, и навесить по необходимому компоненту на каждую из них. Компоненты представляют собой блоки данных, и только данных. Как раз совокупности этих данных и определяют, что из себя будет представлять конкретная сущность. Системы — это классы для реализации некоторого поведения. Системы получают на вход список сущностей для обработки и выполняют с ними некоторые действия. Системы могут обрабатывать как все сущности, так и только те, что содержат определенные компоненты (что чаще всего и бывает). Четкое отделение данных от логики выполнения имеет свои преимущества. А именно: можно довольно легко менять логику выполнения (прямо на лету) путем добавления или удаления систем, изменения порядка выполнения или временного отключения систем, при этом не ломая данные. Так как сами данные отделены и представлены в виде компонентов, то с ними легко производить некоторые манипуляции, такие как сериализация и десериализация, пересылка по сети. Это никак не усложняет работу с ними, т.к. системам неважно, откуда данные взялись (сгенерированы другой системой, прочитаны с диска, переданы по сети). Все они обработаются одинаково и прозрачно. Таким образом, можно выделить следующие плюсы использования ECS при разработке:
Но так же можно выделить и некоторые минусы:
Еще до появления Unity ECS в Unity можно было использовать ECS подход с помощью фреймворков. Самыми популярными являются: Entitas, LeoECS, BrokenBricksECS и Svelto.ECS. Из этого списка нам приходилось работать только с Entitas, как пожалуй, с самым популярным сторонним решением. У этого решения есть свои плюсы и удобные возможности, которых у Unity ECS пока нет (а, возможно, никогда и не будет), например, реактивные системы. Реактивные системы — это такой подвид систем, которые позволяют обрабатывать только те сущности с заданными компонентами, данные которых поменялись с предыдущего запуска системы (довольно удобная возможность). Но, несмотря на то, что этот фреймворк является довольно производительным решением, в плане скорости тягаться с Unity ECS он, конечно, не может. Но зато (опять-таки, на данный момент) он является production ready решением.
Старый добрый Entity Component подход
Давайте для примера напишем небольшое приложения и посмотрим, как будет отличаться код этого приложения в EC стиле от ECS стиля. Визуально это будет выглядеть примерно так: 
У нас есть игровые объекты — герои (треугольники) и игровые объекты — цели (кружки). Цель героя — найти ближайшую цель и переместиться к ней. После чего цель уничтожается, и герой ищет следующую цель. Все предельно просто. Как раз самое то, чтобы рассмотреть отличия без каких-то нибыло усложнений.
Улучшаем ваш Unity проект. Гайд по ECS для MonoBehavior разработчиков
Пару лет назад компания Unity представила свой стек DOTS, на котором и построен проект Megacity. Это некий список технологий, которые в совокупности позволяют колдовать и ускорять ваш проект в десятки раз. В корне всей магии лежат 2 простых заклинания:
Если правильно управлять данными, процессору будет легче их обрабатывать, а если их легче будет обрабатывать, то игрокам будет легче жить.
Для того, чтобы Unity программистам удалось осуществить вышеописанные постулаты, компания выпустила дополнительные пакеты:
Дары смерти от Unity Technologies
А сердцем DOTS является:
На текущий момент DOTS выглядит скорее проклятьем Unity Technologies, чем волшебной палочкой. Стек до сих пор не вышел в официальный релиз. И неизвестно когда DOTS выйдет в официальный релиз. Сейчас это крайне нестабильная штука, которую точно не стоит использовать в Production проекте.
Поэтому, давайте попробуем применить подход Entity Component System (ECS) в своем проекте.
Производительность! Бесплатно и без регистрации
Из чего состоит ECS?
Рецепт ECS под соусом Leo
Поиск Гугл по рецептам приводит нас к самому вкусному результату:
Помимо этого, на данный момент Leo ECS самый популярный ECS фреймворк после Entitas
Другие ECS рецепты, которые могут вас заинтересовать
Вот мы и определились. Чистый C# и соус Leo.
ОБНОВЛЕНО! Насколько увеличится скорость?
Я провел классический эксперимент, создал 100 000 GameObject и двигал их по вектору Z на 0.1 значение.
Как видно из этих тестов, переход на ECS подарил в районе 20 FPS. Однако точно такой же тест от коллеги по цеху, запущенный на моем устройстве, демонстрирует увеличение производительности в 3 раза. Мне же не удалось достичь таких результатов.
Leo ECS еще один тест
После тщательного анализа исходного кода моего коллеги, я так и не нашел причины за счёт чего ему удалось увеличить скорость работы. Есть ощущение, что пакеты от DOTS, установленные на моей сборке, как-то замедляли весь процесс тестирования.
Нагрузка Update методов из Profiler
Однако я попробовал вынести работу в многопоток через Job System и получил буст производительности в 5-6 раз. При этом добавление атрибута от Burst никак не увеличила производительность. Видимо в моем коде нет как таковой логики чтобы ее Burstить.
Leo ECS + Job System
Превращаем GameObject в Entity
Если Leo ECS по умолчанию не конвертирует игровые объекты из Unity Engine, то как интегрировать его с этим движком? Можно ли как-нибудь очень-очень легко превращать наши игровые объекты в Entity, чтобы процесс готовки был простым и понятным.
UniLeo автоматически конвертирует ваши игровые объекты в Entity и позволяет настраивать компоненты прямо из инспектора.
Перейдем наконец-то к коду
Подключаем пакеты через Unity Package Manager
Добавьте ссылку в Packages/manifest.json
Не забываем пространство имен
То есть, если в проекте нужно управлять физикой, необходимо создать компонент с переменной RigidBody. Таким образом можно управлять абсолютно любым элементом игрового движка Unity.
Но в UniLeo можно создать класс-проводник, который должен наследоваться MonoProvider и его можно крепить к игровым объектам.
После того, как данный класс закреплен на игровом объекте, его можно предварительно настроить из редактора.
Отлично, теперь мы можем без лишних проблем настроить наш компонент прямо из редактора Unity.
Настало время написать первую систему. Для этого необходимо просто создать класс и реализовать один из готовых интерфейсов, чаще всего используются только:
IEcsInitSystem // Срабатывает 1 раз при инициализации
IEcsRunSystem // Срабтаывает на Update или Fixed Update метод
Пишем первую систему
Выбираем метод конвертации
После запуска игровой объект автоматически сконвертируется в Entity. Система начнет отрабатывать свои методы. Мы успешно интегрировали Leo ECS в наш проект. Поздравляю!
Наверное у вас еще остались вопросы, я попробую ответить на них.
Вопрос-Ответ
Вы можете порождать prefab любым известным вам способом, конвертация пройдет автоматически.
В ECS очень важно не нарушать порядок, при котором выполняются системы, асинхронное срабатывание может привести к большим проблемам в будущем.
Очень часто ивент-компоненты нужно очищать в конце кадра, для этого в LeoECS есть готовый механизм.
Но вы вполне можете использовать и пакеты от компании Unity, они дадут намного больше производительности, но интеграция с ними не так легка.
На хабре уже существует отличный пост про Job систему. Вам необходимо вызвать ее внутри ваших Run методов в LeoECS.
Пример работы с Job System есть выше, в разделе про тестирование.
Готовой интеграции для LeoECS с популярными сетевыми библиотеками на данный момент не существует, но передача данных осуществляется через ивенты, а как работать с ивентами я уже отвечал.
В любом случается, на данный момент вам придется самостоятельно придумать как лучше всего интегрировать то или иное решение с ECS.
Да, возможно сторонние ECS решения не такие быстрые, как подход DOTS, но они позволяют существенно увеличить производительность относительно классического MonoBehavior подхода. Теперь вы знаете с чего начать свой Megacity проект!