Uploaded by Валерия Бубнова

16лекция

advertisement
МИРЭА - РОССИЙСКИЙ
ТЕХНОЛОГИЧЕСКИЙ
УНИВЕРСИТЕТ
(www.mirea.ru)
Лекция: знакомство с Unreal Engine 4
Лектор: Болбаков Роман Геннадьевич 18 ноября 2015 г.
Кафедра инструментального и прикладного программного
обеспечения
Epic Games последовательно развивает систему визуального программирования Blueprints в Unreal Engine. Она
продвигается как полноценная рабочая среда, в которой любой новичок может освоиться и собрать свою игру или
приложение. Но действительно ли «блюпринты» ни в чём не уступают классическому программированию?
Блюпринты выигрывают у C++ на начальных этапах разработки, особенно
если код игры пишется с нуля. Они не требуют установки дополнительной
среды, к тому же предлагают быстрые итерации. А блочный синтаксис
блюпринтов понятен не только программистам, но и тем, кто знаком с
аналогичными системами в программах для создания контента — например,
художникам.
Но если рассматривать разработку в целом, в долгосрочной перспективе, то
классический подход к программированию показывает свои преимущества.
Даже сами Epic Games заостряют внимание на том, что блюпринты — это не
код, а данные, поэтому и относиться к ним нужно соответственно. Например,
некоторая общая логика всё равно должна выноситься в код.
По этой же причине блюпринты невозможно толком «мёрджить», то есть соединять
результаты разработки. Поэтому их приходится отдельно блокировать, чтобы не создавать
конфликтов и не терять проделанную работу. С классическим же кодом могут работать
даже несколько человек одновременно, но результат их работы в одном файле обычно всё
равно очень просто совместить.
Наконец, блюпринты бьют по производительности, так как компилируются в байт-код,
который работает на встроенной в движок виртуальной машине. Да, их можно
нативизировать, — то есть преобразовать Blueprint-логику в файлы C++, но даже
разработчики из Epic рекомендуют этим не злоупотреблять.
Да и с точки зрения GOMS-анализа нажатие на клавишу клавиатуры оказывается быстрее, чем перемещение
мышки. Это ни в коем случае не отменяет удобство визуального редактора, но, по моему опыту, с
автодополнениями и прочими синтаксическими функциями современных IDE писать код удобнее и быстрее,
чем создавать граф в блюпринтах. Хотя полезные сочетания клавиш и шорткаты в Unreal Engine тоже
облегчают жизнь.
Но если программисту нужно работать с необычными функциями, или он использует какую-то сложную
математику и пространственные запросы (например, LineTrace), всё это лучше вынести в С++. Отчасти из-за
всех перечисленных особенностей Epic Games раздумывают над созданием отдельного скриптового языка
для реализации игровой логики в Unreal Engine.
Тем не менее, блюпринты — достаточно мощный инструмент, который в Unreal Engine 4 используется не
только для построения игровой логики, но и для работы с анимацией и системой эффектов Niagara. Поэтому
каждая студия должна сама найти подходящий баланс между Blueprints и С++. Например, технические
дизайнеры Riot Games использовали блюпринты в Valorant только для создания способностей игроков.
Сами Epic Games рекомендуют использовать блюпринты, когда в проекте очень много
ссылок на контент, а его логика работает в первую очередь на визуальную составляющую.
Также они пригодятся в создании прототипов, прямолинейной или редко используемой
логики, которая не является частью основной архитектуры. Всё, что не получит
преимуществ в С++ с точки зрения производительности, масштабируемости и
стабильности, тоже может быть создано в Blueprints.
Ну а с С++ лучше работать, если функционал используется более чем в одном месте и
включает в себя сложные элементы — например, сохранение игр или сетевой код. Если
проект в дальнейшем будет расширяться, то его тоже лучше создавать с помощью
классического программирования — оно помогает тщательно поддерживать логику и
стабильность кода.
Словом, с любыми важными переменными, перечислениями и типами данных C++
работает лучше. Но и работа в Blueprints не отменяет классический подход, а только
органично дополняет его в необходимых случаях. Так что разработчикам от визуального
программирования никуда не деться.
Blueprints — это система визуального скриптинга Unreal Engine 4. Она
является быстрым способом создания прототипов приложений. Вместо
построчного написания кода всё можно делать визуально: перетаскивать ноды
(узлы), задавать их свойства в интерфейсе и соединять их «провода».
Кроме быстрого прототипирования, Blueprints также упрощают создание
скриптов для тех кто плохо разбирается в написании кода.
Рассмотрим использование Blueprints для следующих операций:
• Настройка камеры с видом сверху
• Создание управляемого игроком актора с простыми движениями
• Настройка ввода игрока
• Создание элемента, исчезающего при контакте с игроком
Создадим начальную сцену. На которой будет происходить вся работа и
взаимодействие. Пользователь будет перемещаться и собирать предметы.
Это можно сделать к в сторонней программе трехмерного моделирования,
например уже знакомый 3DS max, так и в самом Unuty, используя стандартные
объекты и ассеты
Для удобства навигации разобьем
файлы проекта на папки, как показано
на рисунке:
Выделенную красным кнопку можно
использовать, чтобы показать или
скрыть панель исходников.
Создание игрока
В Content Browser перейдите к
папке Blueprints. Нажмите на
кнопку Add New и выберите
Blueprint Class.
Мы хотим, чтобы актор получал
вводимую игроком информацию,
поэтому нам подходит класс Pawn.
Выберите во всплывающем окне
Pawn и назовите его BP_Player.
Прикрепление камеры
Камера — это способ игрока смотреть на мир. Мы создадим камеру, смотрящую на игрока
сверху вниз.
В Content Browser дважды нажмите на BP_Player, чтобы открыть его в Blueprint editor.
Для создания камеры перейдите на панель Components. Нажмите на Add Component и
выберите Camera.
Чтобы камера смотрела сверху вниз, нужно расположить её над игроком. Выбрав компонент камеры,
перейдите во вкладку Viewport.
Активируйте манипулятор перемещения, нажав клавишу W, а затем переместите камеру в (-1100, 0, 2000).
Или же можно ввести координаты в поля Location. Она находится в разделе Transform панели Details.
Если вы потеряли камеру из виду, нажмите клавишу F, чтобы сфокусироваться на ней.
Затем активируйте манипулятор поворота, нажав клавишу E. Поверните камеру вниз на -60 градусов по оси
Y.
Отображаем игрока
Мы обозначим персонажа игрока красным кубом, поэтому для его отображения нужно будет использовать
компонент Static Mesh.
Во-первых, снимите выделение с компонента Camera, нажав левой клавишей мыша на пустом пространстве в
панели Components. Если этого не сделать, то следующий добавленный компонент будет дочерним по
отношению к камере.
Нажмите на Add Component и выберите Static Mesh.
Чтобы отобразить красный куб, выберите компонент Static Mesh, а затем перейдите во
вкладку Details. Нажмите на раскрывающийся список, находящийся справа от Static
Mesh и выберите SM_Cube.
Вы должны увидеть следующее (можно нажать F внутри Viewport, чтобы
сфокусироваться на кубе, если вы его не видите):
Теперь настало время добавить на сцену актора Pawn игрока.
Нажмите на Compile и вернитесь к основному редактору.
Спаун игрока
Чтобы игрок мог управлять Pawn, нужно указать две вещи:
1. Класс Pawn, которым будет управлять игрок
2. Место спауна Pawn
Первую задачу можно выполнить, создав новый класс Game Mode.
Создание Game Mode
Класс Game Mode (игровой режим) — это класс, управляющий тем,
как игрок входит в игру. Например, в многопользовательской игре
Game Mode используется для задания появления каждого игрока. Что
более важно, Game Mode определяет. какой Pawn будет использовать
игрок.
Перейдите к Content Browser и зайдите в папку Blueprints. Нажмите
на кнопку Add New и выберите Blueprint Class.
Во всплывающем меню выберите Game Mode Base и назовите его
GM_Tutorial.
Теперь нужно указать, какой класс Pawn будет использоваться по умолчанию. Дважды нажмите на GM_Tutorial, чтобы
открыть его.
Перейдите на панель Details и загляните в раздел Classes. Нажмите на раскрывающийся список Default Pawn Class и
выберите BP_Player.
Чтобы использовать новый Game Mode, нужно сообщить уровню, какой Game Mode он
должен использовать. Это можно указать в World Settings. Нажмите на Compile и закройте
Blueprint editor.
Каждый уровень имеет собственные параметры. Получить доступ к этим параметрам
можно, выбрав Window\World Settings. Или же можно зайти в Toolbar и выбрать
Settings\World Settings.
Рядом со вкладкой Details откроется новая вкладка World Settings. В ней нажмите на
раскрывающийся список GameMode Override и выберите GM_Tutorial.
Наконец, нам нужно задать точку спауна игрока. Это реализуется размещением на уровне
актора Player Start.
Размещение Player Start
В процессе спауна игрока Game Mode ищет актор Player Start. Если Game Mode находит его, то предпринимает попытку
заспаунить игрока там.
Чтобы разместить Player Start, перейдите к панели Modes и найдите Player Start. Нажмите левой клавишей и перетащите
Player Start из панели Modes во Viewport. Отпустите левую клавишу мыши, чтобы разместить его.
Можете разместить его где угодно. Когда закончите, перейдите в Toolbar и нажмите Play. Вы будете заспаунены в точке
расположения Player Start.
Чтобы выйти из игры, нажмите кнопку Stop в Toolbar или нажмите клавишу Esc. Если вы не видите курсор, нажмите
Shift+F1.
Так как пока что двигаться в приложении невозмонжно, то и текущие взаимодействие пользователя с программой
оставляет желать лучшего. Наша следующая задача — настроить параметры ввода.
Настройка ввода
Назначение клавиши действию называется привязкой клавиши.
В Unreal можно настроить привязки клавиш, чтобы при их нажатии срабатывали события. События — это ноды,
выполняющиеся при определённых действиях (в этом случае — при нажатии указанной клавиши). При срабатывании
события выполняются все ноды, соединённые с событием.
Такой способ привязки клавиш удобен, потому
что он означает, что нам не нужно жёстко
задавать клавиши в коде.
Например, можно привязать нажатие левой
клавиши мыши и назвать её Shoot. Любой актор,
умеющий стрелять, может использовать событие
Shoot, чтобы знать, когда игрок нажимает на
левую клавишу мыши. Если вы хотите изменить
клавишу, то это можно сделать в параметрах
ввода.
Если мы будем задавать клавиши жёстко, то нам
придётся заходить в каждый актор и менять
клавиши отдельно.
Привязка осей и действий
Чтобы перейти к параметрам ввода, зайдите в Edit\Project Settings. В разделе Engine выберите слева
Input. В разделе Bindings выполняется настройка ввода.
•Unreal предоставляет два способа создания привязок клавиш:
Привязка действий: они могут находиться всего в двух состояниях — нажато и не нажато. События действий
срабатывают только когда вы нажимаете или отпускаете клавишу. Используются для действий, не имеющих
промежуточных состояний, например, для стрельбы из пушки.
•Привязка осей: оси передают на выход численное значение, называемое значением оси (подробнее об этом позже).
События оси срабатывают каждый кадр. Обычно используются для действий, требующих управления стиками или
мышью.
Создание привязок движения
Во-первых, мы создадим две группы привязки осей. Группы позволяют привязывать несколько клавиш к одному событию.
Для создания новой группы привязки осей нажмите на значок + справа от Axis Mappings. Создайте две группы и назовите
их MoveForward и MoveRight.
MoveForward будет управлять движением вперёд и назад. MoveRight будет управлять движением влево и вправо.
Мы привяжем движение к четырём клавишам: W, A, S и D. Пока у нас есть только два слота для привязки клавиш.
Добавим к каждой группе ещё одну привязку осей, нажав на значок + рядом с полем имени группы.
Чтобы привязать клавишу, нажмите на раскрывающийся список с перечислением клавиш. Привяжите клавиши W и S к
MoveForward. Привяжите клавиши A и D к MoveRight.
Теперь нужно задать значения в полях Scale.
Значение оси и масштаб ввода
Перед заданием полей Scale нам нужно больше узнать о том, как работать со значениями
осей.
Значение оси — это численное значение, определяемое типом ввода и способом его
использования. При нажатии на кнопки и клавиши на выход подаётся 1. Стики имеют
выходные значения от -1 до 1, зависящие от направления и наклона стика.
Мы можем использовать значение оси для управления скоростью Pawn. Например, если
мы нажмём стик до упора, то значение оси будет 1. Если нажать наполовину, то значение
будет 0.5.
Умножая значение оси на переменную скорости, мы можем регулировать с помощью
стика скорость движения.
Также значение оси можно использовать для задания направления вдоль оси. Если умножить скорость Pawn на
положительное значение оси, то мы получим положительное смещение. При использовании отрицательного значения оси
получим отрицательное смещение. Прибавляя это смещение к местонахождению Pawn, мы задаём направление его
движения.
Клавиши клавиатуры могут подавать на выход только значения 1 или 0, то можно использовать scale для преобразования
их в отрицательные числа. Это можно сделать, взяв значение оси и умножив его на масштаб.
Умножив положительное (значение оси) на отрицательный (масштаб), мы получим отрицательное значение.
Задайте масштаб клавиш S и A, нажав на поле Scale и введя -1.
Теперь начинается интересное: заставим Pawn двигаться! Закройте Project Settings и откройте BP_Player в Blueprints
editor, дважды нажав на него.
Сначала нам нужно выбрать события для привязок движения. Нажмите правой клавишей мыши на пустом пространстве
в Event Graph, чтобы открыть список нодов. Найдите в этом меню MoveForward. Добавьте нод MoveForward из списка
Axis Events. Учтите, что вам нужен красный нод в Axis Events, а не зелёный нод в Axis Values.
Повторите процесс для MoveRight.
Теперь мы настроим ноды для MoveForward.
Использование переменных
Для перемещения необходимо указать, с какой скоростью будет двигаться Pawn. Один из
простых способов указания скорости — хранение её в переменной.
Чтобы создать переменную, зайдите во вкладку My Blueprint и нажмите на значок + в
правой части раздела Variables.
Выбрав новую переменную, перейдите во вкладку Details. Измените имя переменной на
MaxSpeed. После этого замените тип переменной на Float. Для этого нужно нажать на
раскрывающийся список рядом с Variable Type и выбрать Float.
Теперь необходимо задать значение по умолчанию. Но чтобы его задать, нужно будет нажать Compile в Toolbar.
Выбрав переменную, перейдите ко вкладке Details. Зайдите в раздел Default Value и измените значение MaxSpeed по
умолчанию на 10.
Затем перетащите переменную MaxSpeed из вкладки My Blueprint на Event Graph. Выберите из меню пункт Get.
Теперь нужно умножить MaxSpeed на значение оси, чтобы получить конечную скорость и направление. Добавим нод float
* float и присоединим к нему Axis Value и MaxSpeed.
Получение направления игрока
Чтобы двигаться вперёд, нам нужно знать, куда смотрит Pawn. К счастью, в Unreal есть для этого нод. Добавьте нод Get
Actor Forward Vector.
Затем добавьте нод Add Movement Input. Этот нод получает направление и значение, преобразуя их в хранимое смещение.
Соедините ноды следующим образом:
Белая линия обозначает цепочку выполнения. Другими словами, когда игрок перемещает ось ввода, то генерируется
событие, выполняющее нод InputAxis MoveForward. Белая линия показывает, что после этого выполняется нод Add
Movement Input.
Нод Add Movement Input получает на входе следующие данные:
Target: задайте self, что в нашем случае является персонажем игрока
(красным кубом).
World Direction: направление для движения цели, которое в нашем
случае является направлением, в котором смотрит игрок.
Scale Value: как далеко мы двигаем игрока, в нашем случае это
макс_скорость * значение_оси (которое, как мы помним, является
значением в интервале от -1 до 1).
Повторим процесс для MoveRight, но заменим Get Actor Forward
Vector на Get Actor Right Vector.
Добавление смещения
Чтобы действительно двигать Pawn, нам нужно получить смещение, вычисленное Add Movement Input, и прибавить его к
местоположению Pawn.
В сущности, наша стратегия будет заключаться в перемещении игрока на небольшую величину в каждом кадре игры,
поэтому нам нужно добавить перемещение к событию Event Tick, которое генерируется каждый кадр.
Перейдите к ноду Event Tick в Event Graph. Он должен быть неактивным и находиться слева, но если его нет, то создайте
нод самостоятельно.
Чтобы получить смещение, создадим нод Consume Movement Input Vector. Чтобы прибавить смещение, создадим нод
AddActorLocalOffset. После этого соединим их следующим образом:
Это означает, что в каждом кадре игры мы будем сохранять весь ввод перемещения и прибавлять его к текущему
местоположению актора.
Нажмите Compile, перейдите к основному редактору и нажмите на Play. Теперь вы можете двигаться в сцене!
Однако есть небольшая проблема. Мощные компьютеры могут рендерить кадры с большей частотой. Event Tick
вызывается каждый кадр, поэтому ноды перемещения будут выполняться чаще. Это значит, что Pawn будет двигаться на
мощных компьютерах быстрее, и наоборот.
Чтобы решить эту проблему, наше движение должно быть независимым от частоты кадров.
Независимость от частоты кадров
Независимость от частоты кадров означает, что мы постоянно будем получать одинаковые результаты, вне зависимости от
частоты кадров. К счастью, достичь такой независимости в Unreal очень просто.
Выйдите из игры, а затем откройте BP_Player. Затем перейдите к узлу Event Tick и посмотрите на Delta Seconds.
Delta Seconds — это величина времени, прошедшего после предыдущего Event Tick.
Умножив смещение на Delta Seconds, мы сделаем перемещение независимым от частоты
кадров.
Например, наш Pawn имеет максимальную скорость 100. Если после предыдущего Event
Tick прошла одна секунда, то Pawn переместится на полные 100 единиц. Если прошли
полсекунды, то он переместится на 50 единиц.
Если движение зависимо от частоты кадров, то Pawn будет перемещаться на 100 единиц в каждом кадре, вне
зависимости от времени между кадрами.
Чтобы умножить смещение на Delta Seconds, добавьте нод vector * float. После этого соедините ноды
следующим образом:
Время между кадрами (Delta Seconds) очень мало, поэтому Pawn будет двигаться намного медленнее. Это
можно исправить, заменив значение MaxSpeed по умолчанию на на 600.
Можно заметить, что куб проходить сквозь все объекты. Чтобы исправить это, нам нужно познакомиться с
коллизиями.
Коллизии актора
Когда мы вспоминаем о столкновениях, то представляем автомобильные аварии. К счастью, коллизии в Unreal намного
безопаснее.
Чтобы иметь возможность сталкиваться с объектами, актору нужно обозначение его пространства столкновений (обычно
называемого коллизией). Можно использовать одно из следующих пространств:
Меш коллизии: они автоматически генерируются (если выбрать такую опцию) при импорте мешей. Пользователь также
может создать в 3D-редакторе произвольный меш коллизии. У красного куба уже есть автоматически сгенерированный
меш коллизии.
Компоненты коллизии: они могут иметь одну из трёх форм: параллелепипед, капсула и сфера. Их можно добавлять на
панели Components. Обычно используются для простых коллизий.
Ниже представлен пример персонажа и его коллизии.
Коллизия происходит, когда коллизия актора касается коллизии другого актора.
Теперь настало время включить коллизии.
Включение коллизий
Вы, наверно, недоумеваете, почему куб не сталкивается с объектами, хотя у него
есть меш коллизии. При перемещении актора Unreal учитывает для коллизий
только корневой компонент. Поскольку корневой компонент Pawn не имеет
коллизии, он проходит сквозь все объекты.
Примечание: актор, не имеющий коллизии в корневом компоненте, всё равно
может блокировать других акторов. Но если перемещать актора, то он не будет ни
с чем сталкиваться.
Итак, чтобы использовать меш коллизии, StaticMesh должен быть корневым. Для
этого перейдите в панель Components. Затем зажмите левую клавишу мыши и
перетащите StaticMesh на DefaultSceneRoot. Отпустите левую клавишу мыши,
чтобы сделать StaticMesh новым корневым компонентом.
Чтобы коллизии начали работать, нужно выполнить ещё одно действие. Переключитесь на Event Graph и перейдите к узлу
AddActorLocalOffset. Найдите вход Sweep и измените значение на true, нажав левой клавишей мыши на флажок.
AddActorLocalOffset занимается тем, что телепортирует актора в новое место. Sweep гарантирует, что актор будет
сталкиваться со всем, что находится между старым и новым местоположением.
Перейдите в основной редактор и нажмите на Play. Теперь куб будет реагировать на коллизии с уровнем!
Последнее, что мы создадим — это предмет, исчезающий при контакте с персонажем игрока.
Создание предмета
В общем случае предметом является любой собираемый игроком объект. Мы используем в качестве предмета BP_Banana.
Чтобы распознать контакт куба и предмета, нам нужен нод события, срабатывающего при коллизии. Для генерирования
таких событий можно использовать реакции на коллизи.
Реакция на коллизию также определяет, как актор реагирует на коллизию с другим актором. Существует три типа реакций
на коллизии: Ignore, Overlap и Block. Вот как они взаимодействуют друг с другом:
Хотя здесь можно использовать и Overlap, и Block, но будем использовать только Overlap.
Задание реакции на коллизию
Закройте игру и откройте BP_Banana. Выберите компонент StaticMesh, а затем перейдите в панель Details. Реакции на
коллизии задаются в разделе Collision.
Как вы видите, большинство параметров неактивно. Чтобы сделать их изменяемыми, нажмите на раскрывающийся
список рядом с Collision Presets. Выберите в списке Custom.
Теперь нам нужно указать реакцию на коллизию между предметом и кубом.
Компоненты имеют атрибут под названием object type (тип объекта). Тип
объекта — это просто удобный способ группировки похожих акторов.
Куб имеет тип WorldDynamic, поэтому нам нужно изменить реакцию на
коллизию этого типа. В разделе Collision Responses измените реакцию на
коллизию WorldDynamic на Overlap. Это можно сделать, нажав на средний
флажок справа от WorldDynamic.
Обработка коллизий
Для обработки коллизий нужно использовать событие наложения. Перейдите в панель Components и нажмите правой
клавишей мыши на StaticMesh. В контекстном меню выберите Add Event\Add OnComponentBeginOverlap.
Так мы добавим в Event Graph нод OnComponentBeginOverlap (StaticMesh).
Наконец, создадим нод DestroyActor и соедините его с нодом OnComponentBeginOverlap (StaticMesh). Как можно
догадаться по названию, он удаляет целевой актор из игры. Однако поскольку целевого актора нет, он уничтожит актор,
вызвавший его.
Размещение предмета
Закройте Blueprint editor и
перейдите в папку Blueprints.
Начните располагать объекты на
уровне зажав левую клавишу
мыши и перетаскивая BP_Banana
во Viewport.
Нажмите Play и начните собирать объекты
Реализация сцены виртуальной реальность с помощью игрового движка Unreal Engine
Перед началом разработки нужно вооружиться знаниями о том, как работать с Blueprint’ами, что уже было описано выше.
По шагам разберём процесс создания нового проекта, настройки уровня и создания простой игровой логики, чтобы
можно было указать на объект, нажать на спуск и уничтожить его.
Запускаем Unreal Engine и переходим на закладку New project. В разделе Blueprint выбираем Virtual Reality. В настройках
проекта (Project setup) выбираем Desktop/console, Maximum Quality (максимальное качество) and No starter content (без
начальных данных), а в Location (расположение) прописываем путь к файлам проекта.
Переходим в меню плагинов, и подтверждаем в Virtual Reality, что у нас включён плагин “SteamVR”.
В браузере данных (content browser) переходим в папку VirtualRealityBP/maps и открываем “MotionControllerMap”.
Перед нами появится заранее сгенерированный уровень, который можно использовать. Здесь мы можем применять самые
разные действия. Например, хватать объекты и телепортировать игрока по уровню. Поэкспериментируйте, чтобы
убедиться, что всё работает правильно. Теперь давайте внедрим логику уничтожения объекта, когда мы наводимся на него
и нажимаем на спуск.
Для этого в VirtualRealityBP/Blueprints откроем Blueprint “MotionControllerPawn”.
Вызовем событие “MotionController ® Trigger” для правой руки и зададим булево значение (true/false) для нажатия и
отпускания кнопки спуска:
Для события Tick создадим линию прицеливания
(linetrace), чтобы знать, на какой объект мы
наводимся. Для этого нужно задать начальную и
конечную точки. Для начальной точки мы
связываем Right Controller, Motion Controller и
получаем GetWorldLocation.
Также с Motion Controller связываем Get Forward
Vector. Таким образом мы будем получать
направление прицеливания контроллером.
Умножаем этот вектор на необходимую
дистанцию (скажем, на 1000 = 10 метров) и
добавляем к начальному местоположению, тем
самым получив конечную точку.
Добавляем модуль LineTraceByChannel,
соединяем начальную и конечную точки, во
вкладке Draw Debug Type выбираем One Frame.
Этот параметр означает отрисовку линии между
начальной и конечной точками.
Далее переходим к выходным данным Break Hit Result, для Hit Actor делаем переход Cast to BP_PickupCube. Это означает,
что на уровне мы можем выбирать только синие кубы.
Теперь кидаем ветку и проверяем булево значение для ранее созданного Can Destroy. Если оно равно false, то мы ничего
не делаем. Если true, то вызываем модуль DestroyActor для уничтожения выбранного объекта.
Готово. Можно нажать кнопку Play, выбрать VRpreview и испытать своё творение.
Подводя итоги проведем небольшое сравнение двух изученных игровых
движков: Unity и Unreal engine:
Первая область сравнения — UI-редакторы для создания уровней, которые,
по своей сути, очень похожи. В них есть браузеры контента для ассетов,
скриптов и других файлов проекта. Игровые объекты можно перетаскивать в
область сцены и таким образом добавлять в её иерархию.
Объекты в редакторе сцены изменяются с помощью инструментов
перемещения, поворота и масштабирования — они похожи в обоих движках.
Свойства Unity-объектов отображаются в Inspector, а UE4 — в части Details.
В обоих движках есть статические меши (static meshes) — их можно двигать,
поворачивать, и масштабировать — и скелетные меши (skeletal meshes) —
геометрические объекты, привязанные к костям скелета и используемые для
анимирования персонажей.
Анимации, включённые для скелетных мешей, также можно импортировать. В
Unity они прикрепляются к импортированному объекту, как клипы анимации
(animation clips), а в UE4 называются последовательностями анимации
(animation sequences). В первом движения управляются с помощью
контроллеров анимации (animation controllers), а во втором по тому же
принципу действуют анимационные Blueprints.
В обоих движках есть стейт-машины, определяющие переходы из одного
состояния ассета в другое. В UE4 система называется Persona, а в Unity —
Mecanim. Также возможно применение скелетных мешей одного скелета к
другим, но в Unity это в основном используется для анимирования
гуманоидов.
В UE4 анимации можно редактировать, в Unity — практически нет, особенно плохо дело
обстоит с движениями гуманоидов. По мнению автора, движки не подходят для
профессионального анимирования персонажей — лучше использовать программы вроде
Blender или Maya, а результат импортировать в виде FBX-файлов. Прикреплённый к
объектам материал добавляется в проект, но его свойства вроде шейдера или текстур
придётся применять вручную.
Для этого в Unity нужно задать материалу шейдер и добавить в его слоты текстуры —
карты шероховатостей, нормалей или диффузии. Собственные шейдеры придётся писать
самостоятельно или с помощью сторонних инструментов вроде Shader Forge или ASE. А в
UE4 встроен очень мощный редактор материалов, основанный, как и система Blueprints, на
нодах.
Для программирования в UE4 используется язык C++, который не все любят из-за
сложности и продолжительности компилирования. Однако у движка понятный API и
приемлемый период компиляции. В UE4 очень мощная и проработанная система
визуального скриптования — Blueprints, с помощью которой можно достичь практически
тех же результатов, что и c C++.
Unity 5 поддерживает языки C# и UnityScript. API и его концепт очень похож
на аналог из UE4. При использовании управляемого языка вроде C#,
программист не обязан использовать указатели (pointers), компилирование
происходит быстро. В Unity нет системы визуального скриптования, и чтобы
использовать что-то подобное, разработчик вынужден покупать сторонние
дополнения вроде Playmaker.
Для 2D-разработки в Unity есть великолепные инструменты — sprite creator,
sprite editor и sprite packer. UE4 также поддерживает спрайты в Paper 2d, но
решения из Unity мощнее, кроме того, в последнем есть отдельный
физический движок для 2d-объектов.
В UE4 встроен постпроцессинг. К сцене можно применять bloom-эффект,
тонирование и антиалиасинг как глобально, так и к отдельным её частям (при
помощи компонента PostProcessVolume).
В Unity есть стек постпроцессинга, который можно скачать из магазина
ассетов движка. Система менее гибкая, чем в UE4 — эффекты применяются
только стеком или скриптами к камере.
Sequencer в UE4 можно использовать для создания синематиков. Это мощный
инструмент, работающий по принципу добавления объектов на временную
шкалу. К настоящему моменту в Unity 5.6 нет системы для синематиков, но
timeline-редактор добавят в Unity 2017.
Оба движка — очень мощные, но UE4 более гибок. В то же время, для создания 2D Unity 5
будет удобнее, а вот для дорогого и большого 3D-проекта, следует отдать предпотчения
UE4.
Download