Обучение Unreal Engine: от основ до создания игры

Курс знакомит с Unreal Engine и ключевыми инструментами разработки игр: редактором, Blueprints, базовым C++, ассетами, UI, освещением и оптимизацией. В итоге вы соберёте небольшой играбельный прототип и подготовите проект к сборке и публикации.

1. Установка Unreal Engine и навигация в редакторе

Установка Unreal Engine и навигация в редакторе

Эта статья поможет вам установить Unreal Engine (UE) и уверенно ориентироваться в редакторе: где что находится, как перемещаться по сцене и какие настройки сделать сразу, чтобы работать быстрее. Это база, без которой дальше будет сложно создавать уровни, настраивать материалы и писать логику на Blueprints или C++.

Что подготовить перед установкой

Учётная запись и доступ

Для установки через официальный лаунчер вам понадобится учётная запись Epic Games.

* Скачать лаунчер: Epic Games Launcher

Место на диске и производительность

Unreal Engine занимает много места, а проекты быстро растут из-за ассетов, кешей и собранных данных. Также редактор активно использует видеокарту.

Официальные требования и рекомендации меняются от версии к версии, поэтому ориентируйтесь на актуальную страницу документации:

* Hardware and Software Specifications for Unreal Engine

Ниже — практичная памятка, что важно проверить, прежде чем нажимать Install:

| Что проверить | Почему это важно | Практический совет | |---|---|---| | Свободное место на SSD | Установка движка и кеши компиляции могут занимать десятки гигабайт | Держите запас под движок и проекты, лучше ставить на SSD | | Видеокарта и драйвер | Редактор — это 3D-приложение, слабая GPU даст тормоза | Обновите драйвер до актуального с сайта производителя | | ОЗУ | Много вкладок, ассетов и шейдеров быстро съедают память | Закрывайте лишние приложения во время сборки шейдеров | | Интернет | Первая установка и обновления могут быть крупными | Если связь нестабильна, ставьте в свободное время |

Установка Unreal Engine через Epic Games Launcher

Это самый простой и рекомендуемый путь для новичков.

  • Установите и запустите Epic Games Launcher.
  • Войдите в аккаунт Epic Games.
  • Откройте раздел Unreal Engine (обычно слева).
  • Перейдите во вкладку Library.
  • Нажмите Install Engine.
  • Выберите версию UE.
  • Выберите папку установки и дождитесь завершения.

    • Что полезно знать на этом этапе:

    * Можно поставить несколько версий UE параллельно (например, для разных проектов). * Если установка прервалась, обычно помогает Verify (проверка файлов) в лаунчере для установленной версии.

    Установка из исходников (когда это нужно)

    Большинству начинающих это не требуется. Сборка из исходников полезна, если вы:

    * хотите модифицировать движок; * используете специфические патчи; * работаете с ветками, которых нет в лаунчере.

    Исходники доступны на GitHub (доступ привязывается к вашему аккаунту Epic):

    * EpicGames/UnrealEngine на GitHub

    Создание первого проекта

    После установки запустите Unreal Engine из лаунчера.

  • Нажмите Games (или другой шаблон, если вы точно знаете, что вам нужно).
  • Выберите шаблон (для старта обычно подходит Blank).
  • Выберите, на чём будете делать логику:
    • * Blueprint — визуальные скрипты, лучший старт для большинства новичков. * C++ — код, требует настроенной среды разработки.
  • Выберите качество и платформу (можно оставить по умолчанию).
  • Если хотите стартовые ассеты, включите Starter Content.
  • Выберите папку проекта и создайте проект.

    • Важно: движок и проекты — разные вещи.

    * Движок устанавливается один раз (или несколько версий). * Проект — это ваша игра: уровни, ассеты, настройки, код.

    Интерфейс Unreal Editor: что где находится

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

    !Схема основных панелей Unreal Editor и их назначение

    Viewport

    Viewport — это окно, где вы видите уровень и работаете с объектами в 3D: перемещаете, вращаете, масштабируете, проверяете освещение.

    World Outliner

    World Outliner — список всех объектов текущего уровня.

    * Здесь удобно выбирать объекты, переименовывать их, группировать по папкам. * Если в сцене много объектов, Outliner — лучший способ быстро найти нужный.

    Details

    Details показывает свойства выделенного объекта.

    * Трансформации: позиция, поворот, масштаб. * Компоненты объекта. * Параметры материалов, света, коллизий и многое другое (зависит от типа объекта).

    Логика простая: выбрали объект в Viewport или Outliner → настраиваете его в Details.

    Content Drawer / Content Browser

    Это место, где живут ассеты проекта:

    * меши (3D-модели), материалы, текстуры; * звуки; * Blueprints; * уровни (Maps).

    Обычно снизу есть Content Drawer (выдвижной контент), который открывается и закрывается, чтобы не занимать место постоянно.

    Toolbar и Play

    Верхняя панель (Toolbar) содержит основные кнопки:

    * сохранение; * сборка (Build); * выбор режима отображения; * Play — запуск игры прямо в редакторе.

    Навигация в Viewport

    Чтобы комфортно работать, важно освоить управление камерой и выделением.

    Базовые приёмы

    * Зажмите правую кнопку мыши в Viewport, чтобы управлять обзором. * Двигаясь с зажатой правой кнопкой мыши, используйте W, A, S, D для перемещения камеры как в играх. * Нажмите F, чтобы сфокусировать камеру на выделенном объекте.

    Удобная таблица управления

    | Действие | Управление | |---|---| | Осмотреться | Зажать правую кнопку мыши и двигать мышь | | Полёт по сцене | Зажать правую кнопку мыши + W A S D | | Поднять/опустить камеру (часто работает в режиме полёта) | Обычно E (вверх) и Q (вниз) | | Сфокусироваться на объекте | F | | Ускорить/замедлить скорость полёта | Ползунок скорости камеры в Viewport (Camera Speed) и колесо мыши при полёте |

    Примечание: сочетания могут немного отличаться в зависимости от версии UE и настроек, но F и навигация через правую кнопку мыши — стандартная база.

    Трансформации объектов: перемещение, поворот, масштаб

    В редакторе вы постоянно будете менять положение объектов. Для этого есть три основных режима (через гизмо):

    * Move (перемещение) * Rotate (поворот) * Scale (масштаб)

    Практика работы:

    * Выделите объект. * Выберите нужный режим трансформации. * Тяните оси гизмо в Viewport. * Точные значения при необходимости задавайте в Details.

    Чтобы объекты ровно становились на сетку и не «плыли» в координатах, используйте привязки.

    Привязки и точность: Snap

    В верхней части редактора есть переключатели привязок (Snap):

    * привязка перемещения к шагу сетки; * привязка поворота к углу; * привязка масштаба к шагу.

    Когда Snap включён:

    * уровень легче собирать аккуратно (особенно модульные окружения); * меньше микрозазоров и странных пересечений; * проще поддерживать порядок в сцене.

    Окна, вкладки и сброс раскладки

    Редактор позволяет таскать панели мышью, стыковать их и сохранять удобную раскладку.

    Если вы случайно «сломали» интерфейс:

    * найдите в меню пункт сброса раскладки (обычно что-то вроде Reset Layout) и вернитесь к стандартному виду.

    Также полезно помнить:

    * вкладки можно пристыковывать в разные области; * можно открыть нужную панель через меню Window, если она пропала.

    Настройки, которые стоит сделать сразу

  • Проверьте, где лежат проекты, и держите их в простой папке без длинных путей (например, D:\UEProjects).
  • Настройте скорость камеры в Viewport под себя, чтобы не «летать» слишком быстро или слишком медленно.
  • Включайте Snap при сборке уровня из модулей.
  • Привыкайте переименовывать объекты в Outliner — это помогает при любом масштабе проекта.

    • Если вы выбрали C++: что может понадобиться дополнительно

    Для C++ проектов на Windows обычно нужна установленная Visual Studio с компонентами разработки на C++.

    Актуальная инструкция от Epic:

    * Setting Up Visual Studio for Unreal Engine

    Если вы пока не уверены, что вам нужен C++, смело начинайте с Blueprint: это позволит быстрее перейти к созданию геймплея.

    Что дальше по курсу

    Дальше мы будем работать уже внутри проекта: разберём, что такое уровень (Level), акторы (Actors), компоненты (Components), и начнём собирать простую сцену, которую можно запустить кнопкой Play.

    2. Основы уровней: акторы, компоненты и материалы

    Основы уровней: акторы, компоненты и материалы

    В прошлой статье вы установили Unreal Engine и освоили базовую навигацию в редакторе. Теперь переходим к тому, из чего реально состоит сцена: уровень (Level), акторы (Actors), их компоненты (Components) и материалы (Materials). Это фундамент для любых следующих тем — от сборки окружения до интерактивности на Blueprints.

    Что такое уровень (Level) и зачем он нужен

    Уровень (часто говорят Map) — это файл сцены, который хранит:

    * какие объекты стоят в мире; * их расположение и параметры; * освещение и пост-обработку; * ссылки на ассеты (меши, материалы, звуки и т.д.).

    Уровень — это не ассеты сами по себе, а композиция из них.

    Полезная документация:

    * Levels

    Как открыть и сохранить уровень

    Обычно в проекте есть стартовый уровень. Чтобы создать новый:

  • В верхнем меню выберите File → New Level.
  • Выберите шаблон (например, пустой).
  • Сохраните уровень: File → Save Current Level As....

    • Практика именования:

    * L_ или Map_ в начале имени, например L_TestRoom. * Храните уровни в отдельной папке, например Content/Maps.

    Актор (Actor): базовая сущность в мире

    Actor — это объект, который может существовать на уровне. Проще всего думать так: всё, что вы размещаете в сцене, почти всегда является актором.

    Примеры акторов:

    * Static Mesh Actor (объект со статическим мешем: стена, ящик); * источники света (Directional Light, Point Light); * камера; * персонаж; * триггер-объёмы.

    Ключевой признак: актор имеет трансформацию — позицию, поворот, масштаб.

    Документация:

    * Actors

    Где акторы видны в редакторе

    * Viewport — вы видите их в мире. * World Outliner — список акторов на текущем уровне. * Details — свойства выбранного актора.

    Практический совет: переименовывайте акторы в Outliner, иначе через пару дней вы получите десятки StaticMeshActor123.

    Компоненты (Components): из чего сделан актор

    Актор — это контейнер. Реальная «начинка» актора обычно хранится в компонентах.

    Component — это часть актора, которая добавляет ему функциональность или представление.

    Типичные компоненты:

    * StaticMeshComponent — показывает 3D-модель (меш). * CameraComponent — камера. * AudioComponent — звук. * Collision-компоненты — коллизия. * LightComponent — свет (часто внутри соответствующего light-актора).

    Документация:

    * Components

    !Диаграмма связи: уровень → акторы → компоненты

    Как увидеть компоненты в редакторе

    Если вы откроете Blueprint-актор или выберете актор с понятной структурой, вы увидите список компонентов (например, StaticMeshComponent). Даже если вы пока не пишете логику, понимание структуры важно:

    Актор* отвечает за присутствие в мире. Компоненты* отвечают за геометрию, коллизию, камеру, звук и т.д.

    Ассеты: что хранится в Content Browser

    Чтобы не путаться, разделим понятия:

    * Actor живёт на уровне. * Asset живёт в папках проекта и используется актором по ссылке.

    Примеры ассетов:

    * Static Mesh (3D-модель); * Material (материал); * Texture (текстура); * Sound Wave (звук); * Blueprint Class (класс, из которого можно создать актор на уровне).

    Если вы удалили ассет, акторы, которые на него ссылались, будут «сломаны» (с пропавшим мешем/материалом).

    Static Mesh и его роль в сцене

    Static Mesh — это ассет 3D-модели, предназначенный для объектов, которые обычно не деформируются как персонажи (стены, реквизит, окружение).

    Документация:

    * Static Meshes

    Быстрое упражнение: разместить объект на уровне

  • Откройте Content Drawer / Content Browser.
  • Найдите меш из Starter Content (если включали его при создании проекта).
  • Перетащите меш в Viewport.
  • Переименуйте актор в Outliner, например SM_Crate_01.

    • Важно: на уровне вы разместили актор, а меш — это ассет, который подключён в компоненте.

    Материалы (Materials): как объект выглядит

    Материал определяет, как поверхность реагирует на свет и как она выглядит: цвет, металличность, шероховатость, прозрачность, свечение.

    Документация:

    * Materials * Material Editor

    Главные параметры, которые стоит понимать сразу

    В Unreal часто используется модель PBR (физически корректный рендеринг), но на старте достаточно понимать смысл основных входов материала:

    * Base Color — базовый цвет поверхности. * Metallic — насколько материал похож на металл. * Roughness — насколько поверхность шероховатая. * Normal — микрорельеф (обычно из normal map текстуры). * Emissive Color — самосвечение.

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

    Создание простого материала и применение к объекту

  • В Content Browser создайте материал: Add → Material.
  • Назовите его, например M_Color.
  • Откройте материал двойным кликом.
  • В Material Editor:
    • * добавьте Constant3Vector (цвет) и подключите в Base Color; * установите Roughness через Constant (например, 0.7).
  • Нажмите Apply и Save.
  • Примените материал к мешу:
    • * выберите актор на уровне; * в Details найдите Materials у StaticMeshComponent; * назначьте M_Color в нужный слот.

    Практический совет по именованию:

    * M_ — материал (например, M_Wall_Paint). * MI_ — material instance (к нему вы придёте позже, это «настройка поверх материала»). * T_ — текстура.

    !Как материал собирается в редакторе узлами и применяется к объекту

    Связь «уровень → актор → компонент → ассет» на одном примере

    Разберём на простом кейсе: вы перетащили ящик в сцену и назначили ему материал.

  • На уровне появился Actor (например, SM_Crate_01).
  • Внутри него есть StaticMeshComponent.
  • В компоненте указана ссылка на Static Mesh ассет.
  • В компоненте (в слотах материалов) указана ссылка на Material ассет.

    • Это один из главных паттернов Unreal: на уровне хранится размещение объектов, а внешний вид и ресурсы лежат в ассетах.

    Частые ошибки новичков и как их избежать

    * Не сохранять уровень и ассеты * Путать актор и ассет * Сваливать всё в одну папку Content * Оставлять хаос в именах в Outliner

    Практичные правила на старте:

  • Делайте папки: Maps, Materials, Meshes, Textures, Blueprints.
  • Держите единый стиль имён: префиксы M_, SM_, T_.
  • После любого изменения материала нажимайте Apply, затем Save.

    • Что дальше по курсу

    Теперь у вас есть базовые строительные блоки: уровень, акторы, компоненты и материалы. Следующий шаг — собрать маленькую тестовую сцену как игровое пространство: добавить свет, коллизию, простую логику взаимодействия и научиться проверять результат через Play.

    3. Blueprints: логика, события и взаимодействия

    Blueprints: логика, события и взаимодействия

    В предыдущих статьях вы настроили Unreal Engine, разобрались с уровнями, акторами, компонентами и материалами. Теперь добавим то, что превращает сцену в игру: логику поведения и взаимодействия. Для этого в Unreal Engine чаще всего используют Blueprints — визуальные скрипты, которые позволяют быстро создавать геймплей без C++.

    Что такое Blueprint и где он живёт

    Blueprint — это способ описать логику объекта с помощью графа узлов. Чаще всего Blueprint создаёт класс, из которого вы размещаете экземпляры на уровне.

    Важно различать понятия:

    * Blueprint Class — ассет в Content Browser, который описывает поведение. * Actor на уровне — конкретный экземпляр этого класса, который живёт в мире и виден в World Outliner.

    Если вы помните связку из прошлой темы уровень → актор → компонент → ассет, то Blueprint чаще всего является ассетом типа класс, который создаёт акторов.

    Документация:

    * Blueprints Visual Scripting

    Какие бывают Blueprints

    На старте вам пригодятся три типа:

    * Blueprint Class — логика конкретного объекта (дверь, кнопка, лифт, враг). * Level Blueprint — логика конкретного уровня (катсцена, глобальные триггеры, сценарий миссии). * Blueprint Interface — контракт для общения объектов без жёсткой привязки к конкретному классу.

    Документация:

    * Level Blueprint * Blueprint Interface

    Как устроен Blueprint-актор

    Откройте любой Blueprint Class двойным кликом, и вы увидите несколько ключевых частей.

    Components

    Слева обычно расположен список Components. Это то, что вы уже знаете из прошлой статьи: меши, коллизии, камера, звук.

    Типичный пример для интерактивного объекта:

    * StaticMeshComponent — что видно. * BoxCollision или SphereCollision — область, где можно взаимодействовать.

    Construction Script

    Construction Script выполняется, когда актор создаётся или изменяется в редакторе.

    Используйте его, когда нужно:

    * автоматически настроить компоненты по параметрам; * собрать объект из частей; * обновить внешний вид по переменным, не нажимая Play.

    Не используйте Construction Script для того, что должно происходить только во время игры.

    Event Graph

    Event Graph — главный граф геймплейной логики. Он запускается событиями и вызывает функции.

    !Подсказка, где искать основные части Blueprint и за что они отвечают

    События: что запускает логику

    Blueprint-логика обычно строится так:

    * Событие сообщает, что что-то произошло. * Дальше выполняется цепочка узлов.

    Самые частые события для начала:

    * Event BeginPlay — срабатывает при старте игры или при спавне актора. * Event Tick — срабатывает каждый кадр. * OnComponentBeginOverlap — когда что-то вошло в триггер-объём. * OnComponentEndOverlap — когда что-то вышло из триггера.

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

    Переменные: как хранить состояние

    Переменные в Blueprint нужны, чтобы хранить параметры и состояние.

    Примеры того, что удобно хранить переменными:

    * цвет или материал для переключения; * ссылка на игрока или нужный актор; * флаг состояния, например IsOpen у двери; * скорость анимации открытия.

    Полезные настройки переменной

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

    * Instance Editable — позволяет менять значение у конкретного экземпляра на уровне через Details. * Expose on Spawn — позволяет передать значение при создании актора через SpawnActor.

    Это один из главных способов сделать Blueprint переиспользуемым: один класс, разные настройки на уровне.

    Функции, макросы и таймлайны

    Функции

    Function подходит, когда вам нужен повторяемый кусок логики.

    Свойства, которые важны на практике:

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

    Макросы

    Macro похож на функцию, но используется скорее как шаблон узлов.

    Практическое правило для новичка:

    * начните с функций, а к макросам переходите позже, когда будет ясно, зачем они вам.

    Timeline

    Timeline часто используют, чтобы плавно менять значение во времени, например:

    * открывать дверь; * плавно менять яркость света; * делать исчезновение объекта.

    Timeline даёт кривую изменения и событие обновления, на котором вы применяете новое значение.

    Практика: делаем интерактивную дверь

    Цель: создать Blueprint двери, которая открывается при нажатии клавиши, если игрок находится рядом.

    Подготовка ассетов

  • Создайте Blueprint Class на основе Actor и назовите его BP_Door.
  • Внутри добавьте компоненты:
    • 1. StaticMeshComponent и назначьте меш двери. 2. BoxCollision перед дверью, чтобы определять зону взаимодействия.
  • В BoxCollision включите генерацию overlap-событий и проверьте, что коллизия настроена как триггер.

    • Переменные

    Добавьте переменные:

    * IsPlayerInRange типа Boolean. * IsOpen типа Boolean. * OpenAngle типа Float, сделайте Instance Editable, например 90. * OpenTime типа Float, сделайте Instance Editable, например 1.0.

    Логика определения игрока рядом

    В Event Graph у BoxCollision добавьте обработчики:

  • OnComponentBeginOverlap:
    • 1. проверьте, что вошёл игрок; 2. установите IsPlayerInRange = true.
  • OnComponentEndOverlap:
    • 1. установите IsPlayerInRange = false.

    Проверка «что вошёл игрок» на старте обычно делается через Cast к классу персонажа проекта. Позже мы заменим это на более гибкие способы, но для первой интеракции это нормально.

    Логика нажатия клавиши

    Самый быстрый вариант для теста:

  • В BP_Door в Details установите Auto Receive Input в значение Player 0.
  • Добавьте событие InputKey E.
  • Перед открытием проверьте IsPlayerInRange.

    • Если условие истинно:

    * если IsOpen = false, запускайте открытие; * если IsOpen = true, запускайте закрытие.

    Важно: в реальном проекте ввод обычно обрабатывает персонаж или контроллер, а интерактивные объекты получают команду через интерфейсы или события. Но для изучения механики Blueprint это хороший старт.

    Плавное открытие через Timeline

  • Создайте Timeline с треком Float от 0 до 1 на длительность OpenTime.
  • На обновлении Timeline вычисляйте текущий угол.
  • Устанавливайте поворот двери через SetRelativeRotation у нужного компонента.

    • Практическая идея:

    * значение Timeline от 0 до 1 — это «процент открытия»; * итоговый поворот — это «процент» умноженный на OpenAngle.

    Если дверь должна закрываться, можно проигрывать Timeline в обратную сторону.

    Взаимодействие Blueprint-объектов: основные способы

    Когда в проекте появляется несколько логических объектов, нужно, чтобы они «общались». В Unreal есть несколько базовых подходов.

    | Способ | Когда использовать | Плюсы | Минусы | |---|---|---|---| | Прямая ссылка на актор | Объекты заранее известны | Просто и быстро | Сильная связность, неудобно расширять | | Cast к конкретному классу | Быстрый старт, прототип | Понятно новичку | Ломается при рефакторинге, много зависимостей | | Blueprint Interface | Разные типы объектов с одним действием | Слабая связность, удобно масштабировать | Нужно продумать контракт | | Event Dispatcher | Событийная модель «подписка-уведомление» | Хорошо для UI и реакций на события | Нужно управлять подписками |

    Документация:

    * Event Dispatchers

    Пример, где нужен Blueprint Interface

    Вы хотите, чтобы игрок мог взаимодействовать с разными объектами:

    * дверь открывается; * кнопка нажимается; * предмет подбирается.

    Вместо множества Cast к разным классам вы создаёте интерфейс, например BPI_Interact, с функцией Interact. Любой объект, который поддерживает взаимодействие, реализует этот интерфейс и делает внутри свою логику.

    Отладка Blueprints: как понимать, что происходит

    Инструменты, которые стоит применять сразу:

    * Print String для быстрых проверок. * Breakpoints на узлах. * Окно наблюдения значений переменных во время выполнения. * Debug Filter в Blueprint Editor, чтобы выбрать, какой экземпляр вы отлаживаете.

    Практическое правило: если логика «не работает», сначала убедитесь, что событие вообще срабатывает. Это быстрее всего проверяется Print String прямо в начале цепочки.

    Частые ошибки новичков

    * Путать ассет Blueprint Class и актор-экземпляр на уровне. * Делать всю логику в Level Blueprint вместо переиспользуемых Blueprint Class. * Строить поведение на Tick без необходимости. * Забывать включать overlap-события у коллизии. * Жёстко привязываться к конкретным классам через Cast там, где лучше интерфейс.

    Что дальше по курсу

    Теперь у вас есть базовый инструментарий геймплея: события, переменные, ввод, overlap-взаимодействия и способы общения объектов. Следующий шаг — собрать маленькую игровую сцену как «уровень-песочницу» и начать соединять окружение, коллизию, простые механики и проверку через Play в единый прототип.

    4. C++ в Unreal: классы, компоненты и интеграция

    C++ в Unreal: классы, компоненты и интеграция

    В прошлой теме вы делали геймплей на Blueprints: события, переменные, таймлайны, взаимодействия. C++ в Unreal Engine решает ту же задачу — описывает поведение игры — но даёт больше контроля, производительности и удобства для больших проектов.

    В этой статье вы разберёте, как устроены C++ классы Unreal, как правильно создавать акторы и компоненты, и как интегрировать C++ с Blueprints, чтобы сочетать скорость прототипирования Blueprint и мощь C++.

    Полезная официальная база:

  • Programming with C++ in Unreal Engine
  • Unreal Build System
  • Unreal Engine C++ API Reference

    • Когда выбирать C++, а когда Blueprint

    Blueprint отлично подходит для:

  • прототипирования механик;
  • сборки логики взаимодействий;
  • настройки параметров на уровне;
  • быстрой итерации без перекомпиляции кода.

    • C++ особенно полезен, когда:

  • нужна архитектура, которую удобно масштабировать и поддерживать;
  • вы пишете базовые системы и переиспользуемые компоненты;
  • важны производительность и контроль над памятью;
  • требуется доступ к функциональности, которой нет в Blueprint.

    • Практический подход для обучения и реальной разработки:

  • Делайте ядро и каркас систем в C++.
  • Оставляйте конкретные настройки и контентную часть в Blueprint (например, какой меш у двери, сколько секунд открывается, какие звуки проигрывать).

    • Как C++ живёт внутри Unreal проекта

    Проект Unreal — это не просто набор .cpp файлов. Вокруг них есть система сборки и отражения, из-за которой C++ в UE выглядит немного иначе, чем в «обычном» C++.

    Ключевые элементы:

  • Module — единица сборки (у игры обычно есть модуль проекта).
  • Unreal Build System — собирает код по правилам .Build.cs.
  • Unreal Header Tool — обрабатывает заголовки с UCLASS, UPROPERTY, UFUNCTION, чтобы движок мог видеть ваши типы в редакторе.

    • !Как Unreal превращает ваш C++ код в классы и свойства, видимые в редакторе

    Базовые типы: UObject, Actor, Component

    В прошлых темах вы работали с акторами и компонентами в редакторе. В C++ это те же сущности, только описанные кодом.

    UObject

    UObject — базовый класс для большинства объектов Unreal, которые:

  • поддерживают отражение (видимость в редакторе и Blueprints);
  • участвуют в системе сборки мусора (garbage collection);
  • могут иметь UPROPERTY поля.

    • AActor

    AActor — то, что вы размещаете на уровне. Почти любой объект в сцене в итоге актор или содержит актор.

    Важно помнить про жизненный цикл:

  • Constructor — создание и настройка компонентов и значений по умолчанию.
  • BeginPlay() — старт игры для этого актора.
  • Tick() — обновление каждый кадр (используйте осторожно).

    • UActorComponent

    UActorComponent — логика, которую можно «прикрутить» к разным акторам.

    Примеры того, что часто удобно делать компонентами:

  • здоровье и урон;
  • взаимодействие;
  • инвентарь;
  • простой «сенсор» игрока;
  • управление открытием/закрытием объектов.

    • !Связь базовых классов Unreal и идея "актор состоит из компонентов"

    Макросы отражения: UCLASS, UPROPERTY, UFUNCTION

    Чтобы Unreal мог видеть ваш код в редакторе, Blueprints и системе сериализации, используются специальные макросы.

    UCLASS

    UCLASS() ставится перед объявлением класса и включает его в систему отражения.

    Пример:

    Что важно:

  • GENERATED_BODY() обязателен для классов с UCLASS().
  • Файл ...generated.h должен быть подключён последним среди #include в этом заголовке.

    • UPROPERTY

    UPROPERTY() помечает поле так, чтобы движок мог:

  • сохранять и загружать значение;
  • показывать его в Details;
  • корректно удерживать ссылки для сборщика мусора;
  • давать доступ из Blueprint.

    • Частая практическая причина использовать UPROPERTY:

  • если вы храните указатель на компонент или другой UObject и хотите, чтобы ссылка не «исчезла» из-за сборки мусора.

    • UFUNCTION

    UFUNCTION() делает функцию видимой для движка и позволяет:

  • вызывать её из Blueprint;
  • подписывать её на события и делегаты;
  • реализовывать часть логики в Blueprint.

    • Компоненты в C++: создание и привязка

    Самый типичный шаблон для актора в C++:

  • Создать компоненты в конструкторе через CreateDefaultSubobject.
  • Назначить корневой компонент RootComponent.
  • Прикрепить остальные компоненты к корню.

    • Пример: актор с мешем и триггером.

    Заголовок

    Реализация

    Что это даёт на практике:

  • В редакторе у актора появятся компоненты в списке Components.
  • Компоненты будут корректно сериализоваться и отображаться в Details.
  • Указатели на компоненты безопасно хранятся через UPROPERTY.

    • Данные и доступность: как сделать класс удобным для дизайна

    Сильная сторона Unreal — вы пишете базу в C++, а настройки отдаёте в редактор.

    Спецификаторы UPROPERTY, которые полезны сразу

    | Что вы хотите | Пример | Зачем это нужно | |---|---|---| | Видеть значение, но не менять | VisibleAnywhere | Удобно для компонентов | | Менять значение в Details | EditAnywhere | Настраиваемые параметры | | Доступ в Blueprint на чтение | BlueprintReadOnly | Blueprint читает, но не пишет | | Доступ в Blueprint на чтение и запись | BlueprintReadWrite | Blueprint может менять | | Редактировать у экземпляра на уровне | EditInstanceOnly | Один класс, разные экземпляры | | Редактировать только в классе по умолчанию | EditDefaultsOnly | Настройки для всех экземпляров |

    Пример параметров двери, которые удобно настраивать с уровня:

    Интеграция с Blueprints: вызовы и события

    Вам почти всегда нужно, чтобы C++ и Blueprint работали вместе.

    Вызвать C++ функцию из Blueprint

  • BlueprintCallable делает функцию доступной как узел в Blueprint.

    • Реализовать поведение в Blueprint, но объявить в C++

    Это полезно, когда вы хотите «контракт» в C++, но конкретную реализацию отдать в Blueprint.

    Практический смысл:

  • В C++ вы вызываете OnDoorOpened().
  • В Blueprint, который наследуется от вашего C++ класса, вы добавляете реализацию события.
  • Дизайнер может добавить звук, VFX, UI подсказку без правки кода.

    • Частый паттерн

  • В C++ делаете логику и состояние.
  • В Blueprint делаете визуал и контент.

    • Например:

  • C++ решает, когда дверь открыта.
  • Blueprint решает, как это выглядит и звучит.

    • Обработка Overlap в C++

    То, что вы делали через OnComponentBeginOverlap в Blueprint, в C++ обычно делается подпиской на делегат.

    Пример: подписка на события триггера

    Подписка в конструкторе:

    Ключевой момент:

  • Для AddDynamic обработчик должен быть UFUNCTION(), иначе Unreal не сможет корректно связать функцию с делегатом.

    • Как добавить C++ в Blueprint-проект

    Если вы начинали курс с Blueprint-проекта, это нормально. C++ можно добавить позже.

    Практический путь через редактор:

  • Откройте меню добавления классов C++ (обычно Tools → New C++ Class).
  • Выберите базовый класс (например, Actor).
  • Создайте класс и дождитесь генерации файлов.
  • Скомпилируйте проект.

    • Важно про итерации:

  • Для изменений в .cpp часто помогает Live Coding.
  • Для изменений в заголовках с UCLASS/UPROPERTY/UFUNCTION нередко требуется полноценная перекомпиляция, потому что задействован генератор кода.

    • Unreal Build System: зачем нужен Build.cs

    Каждый модуль описывает зависимости в .Build.cs. Это влияет на то, какие заголовки и модули можно подключать.

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

    Пример структуры зависимостей (упрощённо):

    Если при #include вы получаете ошибки вида «cannot open source file», одна из частых причин — не подключён нужный модуль в .Build.cs.

    Частые ошибки новичков в C++ для Unreal

  • Забыть GENERATED_BODY() в классе с UCLASS().
  • Хранить UObject ссылки без UPROPERTY, а потом ловить странные падения из-за сборки мусора.
  • Делать сложную логику в Tick, когда можно обойтись событиями.
  • Пытаться создавать компоненты через new вместо CreateDefaultSubobject.
  • Менять структуру UPROPERTY и ожидать, что Hot Reload всегда корректно всё подхватит.

    • Как связать эту тему с тем, что вы уже сделали на Blueprints

    Ваш Blueprint-опыт прямо переносится в C++:

  • BeginPlay в C++ соответствует Event BeginPlay.
  • Overlap-события есть и там, и там.
  • Переменные Blueprint ≈ поля C++ с UPROPERTY.
  • Переиспользуемые Blueprint классы ≈ C++ базовые классы + Blueprint наследники.

    • Самая полезная практика после этой статьи:

  • Перенесите один простой объект (например, дверь) в C++ так, чтобы он работал.
  • Сверху сделайте Blueprint-наследника для контента и настройки.

    • Что дальше

    Теперь у вас есть два инструмента геймплея:

  • Blueprint для скорости и визуальной сборки.
  • C++ для архитектуры, переиспользования и сложных систем.

    • Следующий шаг в курсе логично делать на стыке: собрать небольшой прототип уровня, где окружение и материалы собраны как в предыдущих темах, интерактивность частично на Blueprints, а базовые системы вынесены в C++.

    5. Анимации, персонаж и система ввода

    Анимации, персонаж и система ввода

    В прошлых темах вы научились собирать уровень, работать с акторами и компонентами, делать интерактивность на Blueprints и понимать роль C++ в архитектуре. Теперь соберём три ключевых элемента, без которых почти не бывает игры от третьего или первого лица: персонаж, анимации и система ввода.

    Цель статьи — чтобы у вас появился управляемый персонаж, который:

  • получает команды из ввода (клавиатура/мышь/геймпад);
  • двигается и прыгает;
  • проигрывает корректные анимации ходьбы/бега/прыжка.

    • Полезная документация:

  • Character
  • Animation Blueprints
  • Enhanced Input

    • Персонаж в Unreal: из каких частей состоит управление

    Чтобы не путаться, разделим ответственность между основными сущностями.

    Pawn и Character

  • Pawn — базовый класс для сущности, которой можно управлять (игрок, дрон, машина).
  • Character — специализированный Pawn с готовой системой передвижения (CharacterMovementComponent), капсулой коллизии и удобными настройками для ходьбы/прыжка.

    • Для большинства игр «человек/существо ходит по миру» удобнее начинать с Character.

    PlayerController

    PlayerController — объект, который принимает ввод игрока и «рулит» тем, чем игрок управляет.

    Важно:

  • в игре может существовать Controller даже без персонажа в мире;
  • Controller может переключать управление между разными Pawn (например, персонаж → машина).

    • GameMode: кто спавнится по умолчанию

    GameMode задаёт правила уровня, в том числе:

  • какой класс персонажа спавнится;
  • какой PlayerController используется.

    • Если вы создали своего персонажа, но при запуске всё равно появляется «старый» — чаще всего причина в настройках GameMode.

    !Как ввод превращается в движение и анимацию

    Базовые ассеты анимации: что есть что

    Анимационная система Unreal обычно опирается на несколько типов ассетов.

    | Что это | Как выглядит в проекте | Зачем нужно | |---|---|---| | Skeletal Mesh (скелетный меш) | 3D-модель персонажа | Модель, которая деформируется костями | | Skeleton (скелет) | отдельный ассет | Набор костей и их иерархия, «общий язык» для анимаций | | Animation Sequence | отдельный ассет | Один клип: шаг, прыжок, idle | | Animation Blueprint | ABP_... | Логика выбора анимаций (состояния, переходы, смешивание) | | Blend Space | BS_... | Плавное смешивание анимаций по параметрам (например, скорость и направление) | | Animation Montage | AM_... | Проигрывание «особых» действий поверх базовой анимации (атака, перезарядка) |

    Термины, которые важно понимать:

  • Кость — элемент скелета (например, spine, hand_l).
  • Позинг — текущее положение всех костей.
  • Смешивание (blending) — переход между анимациями без резкого рывка.

    • Практический маршрут: берём готовый шаблон и понимаем, как он устроен

    Самый быстрый способ выстроить «правильную» структуру — создать проект на основе Third Person Template (или открыть его как пример) и повторить ключевые элементы у себя.

    Что стоит найти в шаблоне:

  • Blueprint персонажа (часто BP_ThirdPersonCharacter);
  • Animation Blueprint (часто ABP_...);
  • Input Actions и Mapping Context (в UE5 с Enhanced Input);
  • GameMode (который назначает персонажа по умолчанию).

    • Идея не в том, чтобы «навсегда остаться на шаблоне», а в том, чтобы увидеть эталонную связку: ввод → движение → переменные → анимация.

    Animation Blueprint: как персонаж выбирает анимации

    Animation Blueprint (AnimBP) — это ассет, который «управляет позингом» скелетного меша. На практике он отвечает на вопрос: какую анимацию показывать прямо сейчас.

    Event Graph в AnimBP: откуда берутся переменные

    AnimBP почти всегда получает данные от персонажа:

  • скорость (чтобы понять: idle или walk/run);
  • признак «в воздухе» (чтобы включить jump/fall);
  • направление движения (чтобы корректно поворачивать шаги).

    • Типичный паттерн:

  • В AnimBP на событии обновления анимации берёте владельца (Owner).
  • Приводите (Cast) к вашему классу персонажа.
  • Считываете нужные значения и сохраняете в переменные AnimBP.

    • Практическое правило: AnimBP должен читать состояние, а не решать, куда идти персонажу. Управление остаётся в персонаже.

    State Machine: логика «Idle/Run/Jump»

    State Machine — это граф состояний анимации.

    Минимальный набор для старта:

  • Idle/Run (земля)
  • JumpStart (начало прыжка)
  • InAir (падение/полёт)
  • Land (приземление)

    • Переходы между состояниями обычно завязаны на переменные:

  • Speed (скорость движения)
  • IsInAir (персонаж не на земле)

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

  • State Machines

    • Blend Space: плавная ходьба и бег

    Если вы просто переключаете Idle ↔ Walk ↔ Run, переходы могут быть резкими. Blend Space решает это смешиванием.

    Самый популярный вариант для начинающих — Blend Space 1D по скорости:

  • слева Idle (скорость 0)
  • в середине Walk (скорость условно 200)
  • справа Run (скорость условно 600)

    • Затем в State Machine вы используете Blend Space как одну «анимацию состояния», подавая в него Speed.

    Документация:

  • Blend Spaces

    • Animation Montage: действие поверх движения

    Montage удобен для действий, которые не должны ломать базовый цикл движения:

  • удар мечом;
  • перезарядка;
  • взаимодействие (нажатие кнопки).

    • Montage обычно запускается из Blueprint персонажа (или из C++), а AnimBP «подмешивает» его в нужной части тела.

    Документация:

  • Animation Montages

    • Система ввода в UE5: Enhanced Input

    В UE5 рекомендуемый подход — Enhanced Input. Он делает ввод более гибким: можно легко поддерживать клавиатуру и геймпад, добавлять модификаторы, создавать разные режимы управления.

    Основные понятия Enhanced Input

  • Input Action — «что игрок хочет сделать» (Move, Look, Jump, Interact).
  • Input Mapping Context — «какими кнопками/осями это делается» (WASD, левый стик, пробел).
  • Triggers — условия срабатывания (например, «только при удержании»).
  • Modifiers — преобразование значения (например, инверсия оси, чувствительность).

    • !Структура Enhanced Input и путь сигнала

    Какие типы значений бывают у Input Action

    Вы выбираете тип значения (Value Type) под задачу:

  • Bool — кнопка (прыжок, взаимодействие).
  • Axis1D — одна ось (газ в машине).
  • Axis2D — движение в плоскости (WASD, левый стик).
  • Axis3D — редкие случаи (например, полёт в 3D с тягой по трём осям).

    • Подключение Mapping Context в игру

    Чтобы ввод начал работать, обычно делают так:

  • В начале игры берут Local Player Subsystem для Enhanced Input.
  • Добавляют нужный Input Mapping Context.

    • На Blueprints это часто делается в персонаже или PlayerController на BeginPlay.

    Практическое правило: если у вас «вообще не приходит ввод», сначала проверьте, что Mapping Context действительно добавлен.

    Привязка действий в Character (Blueprint-логика)

    Типичный набор действий для прототипа:

  • IA_Move (Axis2D)
  • IA_Look (Axis2D)
  • IA_Jump (Bool)

    • Затем в Blueprint персонажа:

  • На IA_Move берёте X/Y.
  • Вызываете Add Movement Input в направлениях вперёд/вправо.
  • На IA_Look крутите камеру через Add Controller Yaw/Pitch Input.
  • На IA_Jump вызываете Jump и Stop Jumping.

    • Это связывает ввод с CharacterMovementComponent, а тот уже меняет скорость персонажа — и именно скорость затем читает AnimBP.

    Связка «ввод → движение → анимация» на одном кейсе

    Соберём всю цепочку концептуально:

  • Игрок нажимает W.
  • Enhanced Input выдаёт значение для IA_Move (например, (X=0, Y=1)).
  • Персонаж получает событие IA_Move и вызывает Add Movement Input.
  • CharacterMovementComponent обновляет скорость персонажа.
  • AnimBP читает скорость, получает Speed > 0.
  • State Machine остаётся в Idle/Run, а Blend Space смещается от idle к walk/run.

    • Если на этом пути что-то не работает, проще всего проверять по шагам: сначала увидеть, что Action срабатывает, затем что скорость меняется, затем что AnimBP видит скорость.

    Отладка: как быстро понять, где сломалось

    Проверка ввода

    Быстрые приёмы:

  • повесьте Print String на событие Input Action;
  • временно упростите Triggers/Modifiers (уберите всё лишнее);
  • убедитесь, что Mapping Context добавлен и имеет приоритет.

    • Проверка анимаций

    Если персонаж двигается, но анимация не меняется, чаще всего проблема в одном из пунктов:

  • у Skeletal Mesh выбран не тот Anim Class (не ваш AnimBP);
  • AnimBP читает переменные не от того персонажа (неверный Cast);
  • скорость считается не так (например, берётся локальная скорость вместо мировой);
  • State Machine переходы никогда не становятся истинными.

    • Что дальше по курсу

    Теперь у вас есть скелетная «игровая петля» персонажа: ввод управляет движением, движение задаёт состояние, анимации отражают состояние. Следующий логичный шаг — расширять взаимодействие: делать предметы, которые можно поднимать, двери/кнопки через интерфейсы, а также переносить часть логики в C++ так, чтобы Blueprint оставался удобным для настройки контента.

    6. UI, звук, VFX и работа с ассетами

    UI, звук, VFX и работа с ассетами

    Эта тема закрывает важный практический слой между механиками и ощущением игры. В предыдущих статьях вы собрали уровни, сделали взаимодействия на Blueprints, познакомились с C++ и настроили персонажа, анимации и ввод. Теперь добавим то, что игрок видит и слышит: UI, звук, визуальные эффекты (VFX), а также разберём, как держать ассеты в порядке, чтобы проект не превращался в хаос.

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

    Работа с ассетами как фундамент: порядок, зависимости, перенос

    В Unreal большая часть работы происходит с ассетами: меши, материалы, текстуры, звуки, Niagara-системы, UI-виджеты, Blueprints. Если не выстроить базовые правила, проект быстро станет неудобным: сломанные ссылки, дубли, непонятные имена, тяжёлые ассеты, которые трудно оптимизировать.

    Полезная документация:

  • Content Browser
  • Asset Redirectors
  • Reference Viewer
  • Size Map
  • Migrating Assets

    • Рекомендуемая структура папок

    Хорошее правило: разделяйте по типам и подсистемам. Один из рабочих вариантов для небольшого проекта:

  • Content/Maps
  • Content/Blueprints
  • Content/UI
  • Content/Audio
  • Content/VFX
  • Content/Materials
  • Content/Meshes
  • Content/Textures

    • Если у вас уже есть игровые зоны (например, Hub, Dungeon), удобно делать второй уровень группировки:

  • Content/Levels/Hub/...
  • Content/Levels/Dungeon/...

    • Именование: почему префиксы реально помогают

    Вы уже использовали M_, SM_, T_. Расширим практичный набор:

    | Тип ассета | Префикс | Пример | |---|---|---| | Widget Blueprint | WBP_ | WBP_HUD | | Sound Wave | S_ | S_Door_Open | | Sound Cue | SC_ | SC_Door_Open | | Niagara System | NS_ | NS_Impact_Sparks | | Niagara Emitter | NE_ | NE_Sparks | | Animation Montage | AM_ | AM_Attack |

    Смысл префиксов простой: вы быстрее находите нужный тип через поиск и меньше ошибаетесь при назначении (например, не путаете Sound Wave и Sound Cue).

    Перемещение, переименование и Redirectors

    В Unreal ассеты часто ссылаются друг на друга. Когда вы перемещаете или переименовываете ассет, движок создаёт Redirector (переадресацию), чтобы старые ссылки не развалились мгновенно.

    Практические правила:

  • Переименовывайте и переносите ассеты внутри Content Browser, а не через файловый менеджер ОС.
  • Регулярно выполняйте очистку redirectors:
    • 1. В Content Browser включите фильтр redirectors. 2. Используйте команду Fix Up Redirectors для папки проекта.

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

    Жёсткие и мягкие ссылки: почему проект "раздувается"

    Когда Blueprint, виджет или Niagara-система жёстко ссылается на ассет, движок считает этот ассет зависимостью и старается загрузить его вместе с владельцем.

    Типичные причины "внезапно тяжёлого" UI:

  • Виджет HUD содержит ссылки на большие текстуры или Skeletal Mesh.
  • Внутри виджета лежит ссылка на Blueprint, который тянет за собой половину уровня.

    • Инструменты проверки:

  • Reference Viewer показывает граф зависимостей.
  • Size Map показывает, какие ассеты занимают место и что тянется зависимостями.

    • !Иллюстрация того, как одна лишняя ссылка в UI может потянуть большие зависимости

    Migrate: как правильно перенести ассеты в другой проект

    Если вы хотите перенести готовый UI, звук или VFX в новый проект, используйте Migrate, а не копирование файлов.

  • Выберите ассет в Content Browser.
  • Нажмите правой кнопкой мыши и выберите Asset Actions → Migrate.
  • Unreal покажет список зависимостей.
  • Укажите папку Content целевого проекта.

    • Это переносит ассет вместе с тем, от чего он зависит.

    UI в Unreal: UMG и Widget Blueprints

    UI в Unreal чаще всего делают через UMG и Widget Blueprint.

    Документация:

  • UMG UI Designer
  • Widget Blueprints

    • Как устроен виджет

    У виджета обычно есть две части:

  • Designer: визуальная раскладка (текст, картинки, прогресс-бары, контейнеры).
  • Graph: логика (обновление текста, реакции на события, вызовы функций).

    • Важно помнить связку из прошлых тем:

  • персонаж получает ввод и меняет состояние;
  • UI отображает состояние.

    • Практическое правило: старайтесь не делать в UI логику уровня "как играть", UI должен быть витриной данных.

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

    Соберём типовую основу:

  • Создайте Widget Blueprint с именем WBP_HUD.
  • В Designer добавьте:
    • 1. Progress Bar для здоровья. 2. Text для подсказки взаимодействия (например, "Нажмите E").
  • В Graph добавьте переменные:
    • 1. HealthNormalized типа Float (ожидается 0..1). 2. InteractHintVisible типа Boolean.

    Дальше есть два подхода обновления UI.

    Binding против событий: что выбрать

    Binding (привязки) удобно на старте, но может часто пересчитываться и незаметно дорожать, если вы повесили много привязок.

    Для прототипа можно начать с Binding, но для более чистой архитектуры лучше обновлять UI по событиям:

  • Персонаж или компонент здоровья меняет Health.
  • Он вызывает событие (например, Event Dispatcher) или интерфейс.
  • HUD получает новые данные и обновляет прогресс-бар один раз.

    • Эта идея напрямую продолжает тему про Event Dispatcher и Blueprint Interface из статьи про Blueprints.

    Показ виджета на экране

    Обычно HUD создаётся и добавляется на экран в PlayerController или в персонаже на BeginPlay.

    Blueprint-логика выглядит так:

    Практическое правило: сохраняйте ссылку HUDRef, чтобы обновлять UI без поиска и повторного создания.

    Звук: ассеты, воспроизведение, затухание и конкуренция

    Звук в Unreal строится вокруг ассетов и компонентов. На базовом уровне вам достаточно понимать, чем отличаются аудиофайл и логика воспроизведения.

    Документация:

  • Audio in Unreal Engine
  • Sound Cues

    • Основные типы аудио ассетов

    | Тип | Что это | Когда использовать | |---|---|---| | Sound Wave | импортированный звук (wav и т.д.) | когда нужен один конкретный файл | | Sound Cue | граф, который может выбирать/случайно миксовать звуки | шаги, вариативные эффекты, многослойные звуки |

    Практический пример: для двери полезно сделать SC_Door_Open, который иногда выбирает один из 2-3 вариантов скрипа.

    2D и 3D звук

  • 2D звук не имеет позиционирования в мире (подходит для UI кликов, уведомлений).
  • 3D звук воспроизводится в точке и зависит от расстояния до игрока.

    • В Blueprint чаще всего используются узлы:

  • Play Sound 2D
  • Spawn Sound at Location
  • Spawn Sound Attached

    • Attenuation: затухание по расстоянию

    Чтобы 3D звук вел себя естественно, ему нужна Sound Attenuation (настройка падения громкости и пространственности).

    Практический сценарий:

  • Создайте ассет Sound Attenuation (например, SA_Door).
  • Настройте радиусы слышимости.
  • Назначьте attenuation при воспроизведении звука (в узле) или в AudioComponent.

    • Concurrency: чтобы звуки не превращались в шум

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

    Решение: Sound Concurrency ограничивает количество одновременно играющих экземпляров.

    Практическое правило: почти все короткие повторяющиеся SFX стоит ограничивать concurrency (например, "не более 3 одновременно").

    VFX: Niagara как современная система эффектов

    В UE5 основной инструмент для визуальных эффектов частицами и не только — Niagara.

    Документация:

  • Niagara Overview

    • Базовые термины Niagara

    | Термин | Объяснение простыми словами | |---|---| | Niagara System | готовый эффект, который вы спавните в игре | | Emitter | "источник" частиц внутри системы | | User Parameters | параметры, которые можно менять из Blueprint (цвет, размер, интенсивность) |

    Как подключить VFX к событию

    Самый типичный паттерн из прошлых тем:

  • Происходит событие (overlap, нажатие, попадание).
  • Вы спавните Niagara System.

    • Для этого в Blueprint используются узлы:

  • Spawn System at Location
  • Spawn System Attached

    • Практический совет:

  • Если эффект должен "ехать" вместе с объектом (например, дым из трубы), используйте Attached.
  • Если это одноразовая вспышка (например, искры в точке удара), используйте at Location.

    • Производительность: что важно понимать сразу

    VFX легко перегрузить проект. Минимальные правила, которые стоит ввести с первого прототипа:

  • Не спавните эффект каждый кадр.
  • Старайтесь не держать бесконечные системы там, где можно включать их по событию.
  • Давайте эффектам логичный Auto Destroy, если это одноразовый спавн.

    • !Схема, связывающая взаимодействие с UI, звуком и эффектом

    Практическая связка: одно действие, три отклика (UI + звук + VFX)

    Соберём типичный игровой момент: игрок подходит к объекту и нажимает E, объект реагирует.

    С точки зрения архитектуры, лучше, чтобы:

  • ввод обрабатывал персонаж;
  • объект умел "взаимодействовать" через интерфейс;
  • объект сам решал, какой звук и VFX проиграть;
  • UI обновлялся через событие (а не через постоянный Tick).

    • Шаги реализации на Blueprints

  • Создайте интерфейс BPI_Interact с функцией Interact.
  • В персонаже:
    • 1. по нажатию E выполните трассировку или проверку ближайшего объекта (упрощённо можно начать с overlap-зоны, как вы делали для двери); 2. если объект поддерживает BPI_Interact, вызовите Interact.
  • В интерактивном объекте (например, BP_Door или BP_Button) реализуйте Interact:
    • 1. проиграйте звук через Spawn Sound at Location или Spawn Sound Attached; 2. заспавните VFX через Spawn System at Location; 3. при необходимости отправьте событие в UI (например, показать текст "Открыто").

    Какие ассеты удобно сделать на этом шаге

  • SC_Door_Open (Sound Cue) и SA_Door (Attenuation).
  • NS_Door_DustPuff (Niagara System) или любой простой эффект.
  • WBP_HUD для отображения подсказок.

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

    Частые ошибки новичков

  • UI виджет содержит прямые ссылки на тяжёлые ассеты и начинает тянуть лишние зависимости.
  • Звуки проигрываются без attenuation, из-за чего 3D ощущается как 2D.
  • Один и тот же звук спамится десятками экземпляров, потому что нет concurrency.
  • VFX спавнится слишком часто или не уничтожается.
  • Ассеты переименовываются через проводник ОС, после чего ломаются ссылки.
  • Redirectors не чинятся, и проект постепенно загрязняется.

    • Что дальше по курсу

    Теперь у вас есть все основные слои прототипа:

  • уровень и окружение;
  • логика (Blueprints и при необходимости C++);
  • персонаж, ввод и анимации;
  • UI, звук и VFX;
  • дисциплина работы с ассетами.

    • Следующий логичный шаг для роста качества проекта — собрать маленький вертикальный срез: один уровень, одна цель, несколько интерактивных объектов, базовый UI, и довести это до состояния, где приятно играть и не стыдно показывать.

    7. Оптимизация, освещение, сборка и публикация проекта

    Оптимизация, освещение, сборка и публикация проекта

    В прошлых статьях вы собрали фундамент прототипа: уровни и ассеты, интерактивность на Blueprints, базовые классы на C++, персонажа с вводом и анимацией, а также UI, звук и VFX. Теперь задача становится «производственной»: сделать так, чтобы проект

  • работал стабильно и быстро на целевом железе;
  • выглядел предсказуемо по свету и теням;
  • корректно собирался в исполняемый билд;
  • был готов к распространению (папка билда, архив, обновления, базовый чеклист релиза).

    • Эта статья специально «сшивает» все предыдущие темы в единый процесс: вы не просто добавляете фичи, а доводите игру до состояния, когда её можно дать другому человеку и она запустится, не развалится по ссылкам и не будет тормозить.

    !Памятка: в каком порядке обычно приводят проект в релизное состояние

    Оптимизация: что именно мы оптимизируем

    Оптимизация в Unreal почти всегда про три ресурса:

  • CPU: логика игры, Blueprints/C++, физика, анимация, обработка ввода, подготовка команд рендера.
  • GPU: отрисовка геометрии, материалы и шейдеры, тени, пост-обработка, прозрачность, VFX.
  • Память и стриминг: текстуры, меши, звуки, анимации, подгрузка уровней и ассетов.

    • Практическая цель оптимизации формулируется так:

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

    • Официальная база по теме:

  • Performance and Profiling
  • Unreal Insights
  • GPU Visualizer

    • Профилирование: как понять, что тормозит

    Главная ошибка новичка: пытаться «оптимизировать всё сразу» по ощущениям. Правильный подход начинается с измерений.

    Быстрые команды в игре и редакторе

    Команды полезно вводить в консоли (обычно клавиша ~) во время Play.

    Как читать stat unit:

  • Frame: время кадра целиком.
  • Game: нагрузка на игровой поток CPU (логика, Blueprints, часть анимаций).
  • Draw: подготовка рендера на CPU.
  • GPU: время кадра на видеокарте.

    • Практическое правило:

  • если больше всего Game/Draw, вы ограничены CPU;
  • если больше всего GPU, вы ограничены GPU;
  • оптимизация должна бить в самое большое число, иначе эффект будет незаметным.

    • GPU Visualizer: из чего состоит кадр на видеокарте

    Если у вас упирается GPU, используйте GPU Visualizer. Он покажет, сколько стоят:

  • тени;
  • освещение;
  • базовый проход (Base Pass);
  • прозрачность;
  • пост-обработка;
  • эффекты.

    • Инструмент особенно полезен, когда вы добавили динамический свет, VFX из Niagara или тяжёлые материалы и внезапно получили просадку.

    Unreal Insights: когда нужны точные причины на CPU

    Unreal Insights помогает, когда у вас:

  • микрофризы;
  • непонятные пики;
  • много логики на Blueprints;
  • подозрение на дорогие тики, таймеры, анимации, физику.

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

    Основные рычаги оптимизации в Unreal

    Ниже перечислены самые частые «кнопки», которые реально дают эффект в прототипах и небольших проектах.

    Геометрия, LOD и инстансинг

    Что делать в первую очередь:

  • Использовать LOD у статических мешей там, где объект часто далеко.
  • Использовать HISM/ISM (иерархические/обычные инстансы) для повторяющихся объектов (трава, камни, одинаковые фонари).
  • Проверять, не завышены ли полигоны там, где это не видно.

    • Если проект на UE5 и вы используете Nanite:

  • Nanite обычно упрощает вопрос треугольников, но не отменяет стоимость материалов, теней и прозрачности.

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

  • Nanite Virtualized Geometry

    • Материалы и шейдеры

    Материалы часто становятся узким местом, потому что:

  • их видно сразу на большом количестве пикселей;
  • они влияют на Base Pass, освещение и пост-обработку;
  • сложные графы материалов компилируются в тяжёлые шейдеры.

    • Практические правила:

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

    • Текстуры и память

    Что обычно даёт быстрый выигрыш:

  • Проверить разрешения текстур и не держать 4K там, где объект маленький в кадре.
  • Использовать корректные настройки сжатия и групп текстур.
  • Следить за тем, какие ассеты тянутся зависимостями (вы уже знакомы с этим из темы про ассеты).

    • Инструменты из прошлой статьи особенно важны здесь:

  • Reference Viewer;
  • Size Map.

    • Blueprints, Tick и событийная логика

    Вы уже видели правило «не делать всё на Tick». В оптимизации это становится критичным.

    Что улучшать:

  • Убирать Event Tick там, где можно заменить на события, таймеры или overlap.
  • Не запускать тяжёлые трассировки и поиск акторов каждый кадр.
  • Не создавать и не уничтожать объекты слишком часто без необходимости.

    • Практический паттерн:

  • делайте компонент/систему в C++ для частых операций;
  • оставляйте в Blueprint настройку параметров и визуальную часть.

    • Scalability: как поддержать слабые машины без отдельной версии игры

    Unreal позволяет настраивать качество по группам (тени, эффекты, пост-обработка и т.д.). Это помогает сделать один и тот же проект играбельным на разном железе.

    Полезная точка входа:

  • Scalability

    • Практический подход для прототипа:

  • Сначала добейтесь стабильности на «средних» настройках.
  • Затем проверьте, что на низких настройках FPS заметно растёт.
  • И только потом улучшайте «эпик»-картинку.

    • Освещение: как получить красивый свет и не убить производительность

    Освещение в Unreal тесно связано с оптимизацией, потому что свет и тени могут стать самым дорогим элементом кадра.

    Документация:

  • Lighting the Environment

    • Типы источников света и базовый смысл

    Самые распространённые:

  • Directional Light: солнце, общий свет на уровне.
  • Sky Light: вклад неба и окружения.
  • Point Light: лампочка, источник во все стороны.
  • Spot Light: фонарь, свет конусом.

    • Mobility: Static, Stationary, Movable

    Mobility определяет, как свет ведёт себя и сколько стоит.

  • Static: не меняется во время игры, обычно самый дешёвый в рантайме.
  • Stationary: частично динамический (обычно для случаев, где нужен компромисс).
  • Movable: полностью динамический, самый дорогой вариант.

    • Практическое правило:

  • чем больше у вас Movable-света и динамических теней, тем выше шанс упереться в GPU.

    • !Памятка по выбору Mobility для источников света

    Lumen и запечённое освещение

    В UE5 часто используют Lumen для глобального освещения и отражений, потому что он ускоряет итерации и даёт динамичность.

    Документация:

  • Lumen Global Illumination and Reflections

    • Практический выбор для обучения и прототипов:

  • Если важна скорость разработки и динамическое время суток, часто выбирают Lumen.
  • Если важна максимальная стабильность и предсказуемая стоимость кадра, нередко рассматривают статическое освещение и lightmaps.

    • Важно: «правильного ответа для всех» нет, выбор зависит от жанра, масштаба уровня и целевой платформы.

    Тени как частая причина просадки

    Если у вас GPU упирается в тени, проверьте:

  • сколько источников света дают тени;
  • радиусы и дистанции отрисовки теней;
  • качество теней в Scalability;
  • тип системы теней.

    • Для UE5 отдельная большая тема:

  • Virtual Shadow Maps

    • Практический чеклист «свет выглядит странно»

    Если картинка неожиданно плохая или «плоская», чаще всего проблема в одном из пунктов:

  • Sky Light выключен или неправильно настроен.
  • Слишком сильная пост-обработка или экспозиция.
  • Неправильные материалы (например, Metallic или Roughness неадекватны).
  • Слишком много одинаково ярких источников света без логики.

    • Сборка проекта: как превратить проект в игру, которую можно запустить

    Сборка в Unreal обычно включает две большие операции:

  • Cook: подготовка контента (ассеты преобразуются в формат, удобный для игры).
  • Package: формирование папки/пакета приложения (exe и данные).

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

  • Packaging Unreal Engine Projects
  • Cooking Content

    • Конфигурации сборки: Development и Shipping

    Ключевые различия:

  • Development: удобнее для тестов, больше отладочной информации.
  • Shipping: релизная сборка, меньше отладочного шума, обычно лучше по производительности и «чистоте».

    • Практическое правило:

  • тестируйте геймплей в Development;
  • перед тем как отдавать билд другим людям, собирайте Shipping и проверяйте его отдельно.

    • Настройки, которые чаще всего ломают первый билд

    Проверьте до сборки:

  • Какая карта стартовая, и добавлена ли она в список карт для упаковки (если вы используете явный список).
  • Не забыли ли вы сохранить уровень и ассеты.
  • Нет ли сломанных ссылок после перемещений ассетов (redirectors должны быть «починены»).
  • Работают ли шрифты, звуки и виджеты в упакованной игре (UI иногда тянет лишние зависимости, а иногда наоборот не подхватывает нужное из-за неправильной настройки).

    • Пошагово: базовая упаковка через редактор

    Обычно достаточно стандартного пути:

  • Откройте Project Settings и убедитесь, что основные параметры проекта заполнены.
  • Выберите целевую платформу (например, Windows).
  • Запустите упаковку через меню Platforms.
  • Дождитесь завершения и протестируйте игру из папки сборки на запуск.

    • Практическое правило: тестируйте не из редактора и не из папки проекта, а именно из результата packaging.

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

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

    Чеклист качества

    Перед тем как отдавать билд:

  • Пройдите игру от начала до конца в упакованной версии.
  • Проверьте управление, звук, UI, сохранения (если есть).
  • Проверьте, что игра корректно закрывается.
  • Проверьте, что на другом компьютере игра запускается и не требует «магических файлов» из вашей среды.

    • Чеклист контента и ассетов

    Чтобы не получить сюрпризы:

  • Почините redirectors.
  • Убедитесь, что в проект не попали лишние тяжёлые ассеты, которые тянутся зависимостями (проверьте Size Map).
  • Убедитесь, что в билд попали только нужные карты.

    • Версионирование и повторяемость

    Даже для маленького проекта полезны два правила:

  • Храните номер версии (хотя бы в названии папки билда): GameName_0_1_0_Win64.
  • Сохраняйте список изменений: что именно вы поменяли между версиями.

    • Это упрощает тестирование и обратную связь: вам скажут баг, а вы поймёте, на какой версии он найден.

    Как связать эту тему с предыдущими статьями

    Эта статья завершает «петлю разработки»:

  • Вы создаёте механику (Blueprint/C++).
  • Вы добавляете ощущение игры (UI/звук/VFX).
  • Вы профилируете и оптимизируете, чтобы механика работала стабильно.
  • Вы настраиваете свет и тени так, чтобы картинка была управляемой.
  • Вы собираете билд и проверяете его как отдельный продукт.

    • Если вы хотите быстро почувствовать рост качества, выберите один уровень из вашего проекта и доведите его до «вертикального среза»: стабильный FPS, понятный свет, минимальный UI, 1–2 интерактивных объекта, и упакованная версия, которую можно дать другу.