Уроки unreal engine 5

Создаем болото в стиле Elden Ring в Maya и Unreal Engine 5

Техническая художница Анук Донкерс рассказала о процессе работы над проектом Cauldron Swamp Ruins, а также о создании растительности и трудностях, связанных с поиском подходящей атмосферы.

Это перевод статьи, в которой доходчиво описывается процесс создания болота в стиле Elden Ring. Статья будет полезна для художников, левел-дизайнеров и других специалистов, кто работает со сценой или окружением.

Вступление

Меня зовут Анук Донкерс, я техническая художница из Нидерландов. Там я изучала дизайн в течение четырех лет, а после этого решила, что хочу специализироваться на техническом арте для игр и поэтому продолжила учебу в Digital Arts and Entertainment в Бельгии. Помимо учебы, я также помогаю разрабатывать игры виртуальной реальности для физиотерапии в компании inMotion VR. Здесь я в основном работаю над Corpus VR, платформой виртуальной реальности, нацеленной на то, чтобы помочь пациентам получить более качественное и увлекательное лечение. На занятиях я изучаю множество разных тем, но больше всего меня интересуют концепт-арт окружения, а также технический и процедуральный арт. Мне нравится решать проблемы, упрощать и оптимизировать процессы.

Cauldron Swamp Ruins

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

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

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

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

Еще большим источником вдохновения оказались туториалы на YouTube. Я люблю включать их в фоновом режиме и время от времени выбираю что-то новое. Одно из видео, которое действительно помогло мне, — это туториал на канале Quixel. В нем объясняется, как правильно выстроить сцену, применить различные способы освещения и как сделать так, чтобы ваша сцена выглядела особенной.

Ассеты и архитектура

Я знала, что самыми сложными элементами в создании сцены будут земля, расположение мха, который должен вести взгляд зрителя к композиционному центру, и наклонная башня на заднем плане. Мне нравится начинать с блокаута (драфт 3D уровня с помощью простых форм), так как это самая важная часть окружения. Благодаря этому образуются базовые элементы сцены, и у вас уже складывается приблизительное представление о том, как она будет выглядеть. Это хорошая возможность, чтобы поэкспериментировать с настройками освещения.

Я полностью создала блокаут в Unreal Engine. Иногда я использую BSP браши для моделирования детализированных частей вместо простых кубов. Они дают больше свободы для экспериментов с различными формами.

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

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

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

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

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

Растительность

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

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

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

Затем с помощью Autodesk Maya я смоделировала все растения вместе. Я постаралась оптимизировать их так, чтобы было как можно меньше избыточной прорисовки.

После этого я поместила модель в Substance 3D Painter. Я загрузила свои текстуры в Photoshop, затем добавила карту шероховатости и начала рисовать, используя разные элементы и градиенты. Хорошо, когда у растений темный градиент идет снизу вверх — так они более гармонично сочетаются с окружением.

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

А теперь начинается самое интересное! Наконец-то я могу импортировать растительность и настроить листву в Unreal Engine. Для этого я перетаскиваю модель и использую кисть, чтобы нарисовать растения везде, где захочу!

Текстурирование

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

В Megascans еще есть большая библиотека декалей (наклеек). Я часто использую декали, чтобы соединить листву с фоном, например, чтобы плющ выглядел немного гуще, я использую зеленую декаль с листвой позади него. Декали — это отличный способ придать вашей сцене индивидуальность!

Сборка финальной сцены

Для меня детализация — это один из самых веселых этапов. Именно тут зарождается история, и у сцены появляется своя особая атмосфера.

На этапе детализации важно расположить горшки так, чтобы взгляд зрителя естественным образом был направлен к башне. А еще в сами горшки нужно поместить растения. Я собрала несколько ассетов вместе. В Unreal Engine есть очень удобная опция, позволяющая сделать один ассет из группы ассетов, поэтому для группирования и повторного использования элементов я часто использовала эту функцию. Так я “высаживаю” все растения в горшки в сцене.

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

Я люблю создавать шейдеры, поэтому экспериментировать с настройками тумана очень весело! Я нарисовала красивое облако в Photoshop, а затем шейдеры сделали всю остальную работу. Наиболее важной частью шейдера является техника Depth Fade (затухание по глубине), которая помогает гармонично вписать облако в окружение.

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

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

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

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

Финальный рендеринг

Основным источником света для сцены определенно является направленный свет. Новый Lumen в Unreal Engine 5 работает удивительно хорошо и почти мгновенно придает сцене приятную атмосферу.

Чтобы добавить глубины, я также использую точечное освещение. Мне нравится подсвечивать листву, чтобы она ярче выделялась.

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

Затем, когда все освещение готово, я перехожу к объему постобработки (Post Processing Volume) в Unreal Engine. Я стараюсь добиться нужных мне цветов с помощью слайдеров настройки цвета. У меня есть два отличных цветовых решения этой сцены, поэтому довольно трудно выбрать что-то одно. В итоге я принимаю решение придерживаться оригинальной концепции и останавливаюсь на более голубоватых тонах.

Атмосфера Souls игр

Определенно, самой сложной задачей было создать правильную атмосферу. Сделать сцену мрачной, но не слишком темной и при этом красочной. Вот почему так важно иметь хорошую концепцию и реалистичные референсы!

Dark Souls и Elden Ring — потрясающие игры, и поскольку я знала, что хочу добиться таких же ощущений, мне было важно погрузиться в визуализацию этих игр и понять, как их авторы подходили к созданию окружения.

Мне всегда трудно сказать, что я закончила работу над окружением, потому что я всегда хочу добавить что-то еще или попробовать другие варианты. Я работала над этим окружением около четырех дней, причем блокаут и первоначальное создание ассетов заняли больше всего времени. Для меня это является большим испытанием, и я хочу быть полностью уверенной в блокауте и первичных настройках, прежде чем продолжать детализацию. Иногда трудно не потеряться в постоянном желании все совершенствовать; чтобы не сбиться с пути лучше поставить себе четкие сроки и сравнивать различные настройки.

Заключение

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

Я довольна результатом и не могу дождаться, когда приступлю к своим следующим проектам!

Unreal Engine 4. Учебник для начинающих: Введение в основы

В этом уроке посвященному Unreal Engine вы узнаете, как использовать функции программы, познакомитесь с интерфейсом и создадите свой первый игровой объект.

Исходные материалы можно скачать по ссылке.

Unreal Engine 4 имеет целый набор инструментов для создания игр, которые адаптированы как для мобильных устройств, так и для современных игровых консолей.

На этой платформе были созданы такие игры как: Survival Evolved, Tekken 7 и Kingdom Hearts III.

Рабочий процесс Unreal Engine 4 понятен даже новичкам. Используя систему визуальных сценариев Blueprints, вы сможете создавать полноценные игры без специальных навыков и знаний. Простой и интуитивно понятный интерфейс программы способствует быстрому освоению Unreal Engine 4 и созданию своей первой игры.

Данное руководство по Unreal Engine 4 предназначено для начинающих. Вот список основных вопросов, которые мы затронем в этом руководстве:

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

Это занятие является частью серии, которая состоит из 10 уроков, посвященных Unreal Engine:

Установка программы Unreal Engine 4

Unreal Engine 4 использует Epic Games Launcher для установки.

Для того, чтобы скачать exe файл необходимо перейти на официальный сайт Unreal Engine и нажать кнопку Download в правом верхнем углу страницы.

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

После установки появится такое окно:

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

После этого вам нужно нажать Install Engine в верхнем левом углу окна. Следуя указаниям установщика вы попадете на экран, где вы сможете выбрать, какие компоненты вы хотели бы установить.

Примечание: Epic Games регулярно обновляет Unreal Engine, поэтому текущая версия вашей программы может немного отличаться от той, которую мы используем в уроке.

Мы рекомендуем отметить следующие значения: Starter Content, Templates Packs и Feature Packs, Engine Source. Это необходимые для работы элементы, которые проверены на практике. Вот почему они полезны:

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

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

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

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

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

Вот что означает каждая из этих опций:

Target Hardware: выбор между Mobile/Tablet отключает некоторые эффекты во время постобработки. Кроме того, эта функция дает возможность использовать мышь в качестве инструмента для ввода. Вам нужно установить эту функцию на Desktop/Console.

Graphical Target: выбор функции Scalable 3D или 2D также отключает некоторые эффекты, доступные во время постобработки проекта. Сейчас вы должны установить этот параметр на максимум.

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

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

Вы можете в любой момент изменить местоположение корневой папки вашего проекта, нажав на три точки в конце поля «Папка». Название проекта не соответствует названию игры, если вы захотите, то всегда сможете изменить это название позже. Теперь вам нужно выбрать текст в поле «Имя» и ввести название «BananaTurntable». Теперь нажмите кнопку «Создать проект»

Навигация по интерфейсу программы

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

Импорт активных элементов

Для продолжения урока вам необходимо скачать два файла: Banana_Model.fbx и Banana_Texture.jpg. Конечно, вы можете использовать любую другую модель, если таковая имеется у вас на устройстве.

Прежде, чем использовать какой-либо новый файл в программе, его необходимо импортировать. Для этого зайдите в меню Unreal и нажмите кнопку «Импорт».

Теперь найдите папку, в которой находятся файлы Banana_Model.fbx и Banana_Texture.jpg, выберете их и нажмите кнопку «Открыть».

Далее вам нужно нажать кнопку «Импорт», чтобы оба файла отобразились в диалоговом окне программы.

После импорта файлов вам нужно сохранить их, т.к. это не происходит в программе по умолчанию. Для этого кликните правой кнопкой мыши по одному из файлов и в появившемся списке выберите «сохранить». Также можно сохранить все файлы сразу при помощи действий File ⇒ Save All.

Важно: в Unreal объекты называются сетками.

Теперь, когда у вас есть сетка для вашего банана, пришло время поместить его в рабочую область.

Добавление сеток в рабочую область

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

Добавленные объекты можно свободно перемещать, вращать и изменять их масштаб. Для этого также можно использовать клавиши W, E, R. Посмотрите, как можно поменять угол наклона или размер объекта:

Об использовании материалов

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

Что такое материал?

Материал определяет, как будет выглядеть поверхность какого-либо объекта. На данном этапе вам нужно знать, что материал определяет четыре основные вещи:

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

Создание материала

Чтобы создать материал, вам необходимо перейти в меню Content Browser и нажать там зеленую кнопку «Add New», после чего появится диалоговое окно со списком команд. Вам нужно выбрать пункт «Material».

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

Редактор материалов

Редактор материалов состоит из четырех основных панелей:

Что такое узел?

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

Перед вами пример использования узла Multiply и Constant3Vector для добавления желтого цвета в текстуру объекта:

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

Добавление текстур

Чтобы добавить цвет и детали для объекта, понадобится текстура. Текстура — это обычное 2D-изображение, с последующим проецированием на 3D-объекты, чтобы придать им цвет и детализацию. Чтобы добавить текстуру для вашего банана, вам нужно будет использовать файл Banana_Texture.jpg и узел TextureSample.

Теперь перейдите к панели «Palette» и найдите там «TextureSample». Удерживая левую кнопку мыши, перетащите объект в рабочую область. Таким образом вы добавили новый узел.

Чтобы выбрать текстуру, вам нужно убедиться, что вы уже выбрали узел TextureSample. Для этого перейдите к панели «Details» и щелкните мышью по списку справа от текстуры.

В появившемся окне будут перечислены все доступные текстуры вашего проекта. Выберите Banana_Texture.

Чтобы ваша текстура появилась на сетке предварительного просмотра, вам нужно подключить ее к узлу Result. Для этого удерживайте левую кнопку мыши на белом выходном контакте (как мы помним, это маленькая стрелочка) узла TextureSample. Далее вам нужно переместить его на входной контакт Base Color узла Result.

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

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

Использование материалов

Чтобы использовать материал для банана, его необходимо назначить. Для этого вам нужно вернуться к меню Content Browser и дважды щелкнуть мышью по Banana_Model, чтобы открыть его свойства. Появится редактор:

Теперь перейдите на панель «Details», найдите там раздел «Materials» и нажмите на раскрывающееся меню справа от Element 0, выбрав Banana_Material.

Закройте редактор сетки и вернитесь к просмотру вашей рабочей области. Поздравляем, теперь ваш банан имеет текстуру.

Примечание: вы всегда можете изменить яркость объекта перейдя в World Outliner и нажав на Light Source. В появившихся настройках найдите параметр «Интенсивность» и установите для него более высокое значение.

О возможностях Blueprints.

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

Blueprint позволяет создавать пользовательские поведения для ваших объектов. Например, созданный вами объект может быть чем-то физическим (например, музыкальный проигрыватель) или чем-то абстрактным, например, системой здравоохранения.

Хотите сделать движущуюся машину? Создайте план. Хотите создать летающую свинку? Используйте чертежи. Может быть вы хотите, чтобы у вас в игре был предмет, который взрывается при ударе? Вам помогут светокопии.

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

Примечание. Если вам так будет удобнее, то вы можете использовать C++ и прописать код вручную. Не смотря на то, что освоение и использование Blueprints очень простое, код C++ гораздо быстрее. Вы также можете использовать обе возможности одновременно, оптимизируя процесс в зависимости от поставленных целей.

Создание Blueprint

Перейдите в Content Browser и нажмите кнопку «Add New». В появившемся списке вам нужно выбрать Blueprint Class.

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

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

Далее, дважды кликните мышью Banana_Blueprint, чтобы открыть его. После нажатия Full Blueprint Editor у вас должно появиться следующее окно:

Blueprint Editor

Сначала убедитесь, что в редакторе Blueprint выбрана вкладка «График событий».

Редактор Blueprint имеет пять основных рабочих области:

Создание проигрывателя

Для создания проигрывателя вам понадобятся две вещи: основа и дисплей. Вы можете создать их оба при помощи компонентов.

Что такое компонент?

Компоненты являются своего рода строительными блоками для создания различных объектов. Например, для создания движения какого-либо предмета необходимо использовать компоненты движения.

Добавление компонентов

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

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

Меню также содержит два компонента:

Теперь вам необходимо перейти на панель «Components» ⇒ «Add Component» и выбрать «Цилиндр».

Попробуйте при помощи мыши и используя клавишу «R» настроить размер объекта:

Вернитесь к панели «Components» и щелкните левой кнопкой мыши в любом месте рабочей области, отменить выбор компонента «Цилиндр». Это нужно для того, чтобы следующий добавленный компонент не был привязан к компоненту Cylinder.

Важно: Если не провести отмену, то следующий компонент будет прикреплен к компоненту Cylinder. Это значит, что все параметры, применяемые к объекту Cylinder, также будут применены к новому компоненту.

Теперь вам нужно нажать Add Component и выбрать из появившегося списка Static Mesh.

Для того чтобы ваш банан корректно отобразился в рабочей области, вам нужно выбрать компонент «Static Mesh» и перейдите на вкладку «Details». Теперь необходимо перейти к появившемуся справа меню от Static Mesh и в нем выбрать Banana_Model.

Посмотрите, все ли вас устраивает в расположении объекта в пространстве. При необходимости вы можете переместить банан при помощи клавиши клавиатуры «W» и компьютерной мыши.

Подробнее об узлах Blueprint

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

Узлы A и B будут выполнять свою функцию корректно, потому что их входные контакты имеют соединение. Обратите внимание на то, что узел C и узел D не будут работать, потому что входной вывод узла C не имеет соединения.

Вращающаяся платформа

Обратите внимание на панель «Components» — Cylinder и Static Mesh имеют небольшой отступ, а DefaultSceneRoot — нет. Это потому, что они прикреплены к DefaultSceneRoot.

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

Создание узла

Сейчас вам нужно вернуться к меню «Event Graph» и создать всего на всего один узел. Для этого щелкните правой кнопкой мыши пустое место на графике, чтобы вызвать меню доступных узлов и найдите в списке AddLocalRotation.

Примечание: Если вы не находите узел в списке, возможно вы не сняли флажок с отметки «Context Sensitive» который находится в правом верхнем углу этого меню.

Для того чтобы установить нужные значения вращения, перейдите к Delta Rotation и измените значение Z=1,0. Чем выше это значение, тем выше скорость поворота платформы.

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

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

Для того чтобы обновить Blueprint и сохранить изменения вам нужно нажать «Compile», после чего вы можете закрыть редактор.

Добавление Blueprint в рабочую область

Перед тем как добавить Blueprint, вернитесь в Viewport в главном редакторе и удалите модель банана. Для этого выберите объект «Правка ⇒ Удалить».

Чтобы добавить Blueprint, удерживая левой кнопкой мыши нужный файл и перетащите его в рабочую область. Теперь перейдите на панель инструментов и нажмите Play, чтобы посмотреть результат проделанной вами работы.

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

Что делать дальше?

Вы можете скачать готовый проект по ссылке.

Вы многое узнали из этого урока, но это лишь малая часть знаний о Unreal.

В следующих уроках Unreal Engine вы сможете освоить более сложные манипуляции с объектами.

UEngine.Ru

Русскоязычное сообщество Unreal Engine 4

Уроки

Уроки Unreal Engine 4. В данной категории находятся как видеоуроки, так и текстовые уроки для тех, у кого слабый интернет и не хватает трафика/скорости для видео.

Видеоуроки

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

Текстовые уроки

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

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

В этом уроке мы будем использовать имитацию физического объекта, созданного в Max (или в любом другом программном обеспечении для моделирования, если требуется) и работать будем во временной шкале анимации, и затем импортируем наш результат в Unreal Engine 4, минуя создание скелета, скина, или использования любых костей.

Как срендерить анимацию в unreal engine

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

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

Для анимации я создаю пустой проект, games > blank, так же можно указать путь, где будет храниться проект и имя проекта, и нажать create (Так же, можно поставить галочку на starter content, если у вам пока что моделек нет и вы хотите просто попробовать сделать анимацию, тогда вам сразу добавится в проект несколько моделек):

Настройка unreal engine

Те, кто привыкли работать в ue4, могут нажать dock in layout, тогда док зафиксируется и не будет скрываться:

Так же надо открыть вкладку с place actors, чтобы можно было размещать объекты, эффекты и т.д на сцене (можно не открывать из из верхних менюшек вытягивать их, но лично мне не удобно это делать), делается это так:

Настройка сцены

Далее нам нужно создать новый мир, делается это просто, тыкаем правой кнопкой мыши на content browser > level, называйте как хотите и тыкайте 2 раза по появившейся иконке:

Теперь мы можем увидеть превосходную темноту, как же она прекрасна:

Давай те создадим террейн:

Пролистываем вниз и нажимаем create:

Переходим обратно в режим select:

Далее нам нужно осветить превосходную темноту, переходим во вкладку lights и перетаскиваем direction light на сцену:

Далее переходим во вкладку visual effects и перетаскиваем sky atmosphere для создания неба:

В той же вкладке берем и перетаскиваем volumetric cloud для создания облаков:

Сделаем небольшой туман в далеке, в той же вкладке перетащим ExponentialHeightFog на сцену:

Можете нажать сюда, чтобы сменить цвет тумана, я оставлю как есть:

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

Создание анимации

Для начала надо перетащить камеру на сцену:

Чтобы менять режимы выбора объекта(перемещение, вращение, изменение размера) надо нажать на пробел:

При выставлении объекта можно изменять систему координат с глобальных на локальные и наоборот:

Далее нам нужно создать новую секвенцию:

Выбираем где ее сохранить и еще можно поменять название секвенции и нажимаем save:

Должна открыться такая вкладка:

Если не открылась то добавляем ее вручную:

Чтобы выбрать режим вида от лица камеры, нужно кликнуть сюда:

Я собираюсь изменять у нее только transform, поэтому я ключевой кадр ставлю только на transform:

Должна появиться такая точка:

Перехожу на последний кадр, ставлю камеру как надо и делаю тоже самое, ставлю ключевой кадр:

Так же можно менять режим интерполяции, кликнув правой кнопкой мыши на ключевой кадр (кружочек):

Так же можно изменять количество кадров, перетаскивая красную полосу:

Рендер анимации

Теперь нам надо подключить 1 плагин к проекту, для этого переходим сюда:

Вбиваем «render» в поиск и ищем этот плагин:

Далее restart now, unreal должен перезагрузится:

Далее открываем это окошко:

В появившемся окне нажимаем + Render и выбираем нашу секвенцию:

Кликаем сюда для настройки анимации:

можно нажать delete, чтобы удалить опцию, и + Settings, чтобы добавить опцию (я обычно рендерю в png, поэтому я удалил jpg и добавил png):

Далее я добавил anti-aliasing со следующими параметрами:

Далее меняю директорию вывода секвенции:

Далее сохраняем пресет настроек рендера:

Сохраняем и жмем Accept:

Далее Render (Local), чтобы срендерить сцену:

Далее начнется рендер:

Собираем видео

Далее мы видим куча изображений, в папке, которую указывали на вывод рендера:

Далее надо объединить это в видео, сделать это можно в любом видеоредакторе, я буду использовать blender. Когда открыли блендер надо открыть вкладку video editing:

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

Нажимаем кнопку «A», чтобы выбрать все, и нажимаем add:

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

Так же можно выбрать тип файла:

Далее нажимаем render animation и получаем видео:

На этом все, всем спасибо за просмотр, пока.

Видеоурок

Материалы для курса

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

Задание к уроку

Добавьте в дом объект лампа, а также объект кресло.

В пакете «Starter Content» найдите объект лампы и кресла. Переместите их на игровую сцену и расположите внутри дома.

Также стоит посмотреть

Навигация по курсу

Навигация

Справочник

Консультация

Необходима консультация? Вы можете задавать все свои вопросы из личного кабинета и получать ответы в удобном формате прямиком на сайте!

Тест на выбор языка

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

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

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

Учусь визуализации в Unreal Engine с полного нуля. Прогресс за полгода

Всем привет. Хочу поделиться своим опытом изучения UE. Может, кто-то прямо сейчас тоже хочет, но сомневается. А мой текст прочитает — и сомневаться перестанет!

16 лет занимаюсь журналистикой, из них 14 — автомобильной. Помимо непосредственно писанины, всегда основательно подходил к визуальной стороне своих материалов — щедро разбавлял инфографикой, интерактивными элементами. Ну, и фото, конечно. Почти всё время в свои материалы снимал сам.

В видео тоже пробовал, но YouTube требовал очень много ресурсов с минимальной отдачей. В итоге на канал я забил (Бурцев всё равно делает лучше), искал другие инструменты визуализации. Пару лет назад тут, на DTF, прочитал статью про продакшен «Мандалорца» с задниками на UE — резко стало интересно.

Начитался официальной документации «Эпиков», открыл UE 4 и… закрыл ещё на пару лет. Слишком громоздким и сложным показалось всё, что я увидел. Изучать в итоге стал Blender, хотя он меня поначалу тоже отпугнул.

На каком-то YouTube-канале по Blender увидел ролик вида «UE 5 для самых слабых умом», решился на попытку №2. Для верности докупил книжку непосредственно по интересующей теме (так и называется «Unreal Engine 4 для дизайна и визуализации»), скачал тогда ещё ранний доступ UE 5 и сел ковырять.

Тут-то у меня и открылся третий глаз, прочистились чакры, а в сутках резко убавилось часов — все они пошли на UE.

После нескольких туториалов и чтения эпиковской документации решил собрать свой первый, назовём это, синематик. По факту — попытка собрать воедино азы.

На каждом этапе плотно офигевал, какие штуки можно делать относительно просто:

Короче, от возможностей продакшена в UE я остался в полном восторге. Хотя, в принципе, ничего особо нового — все предыдущие 14 лет я делал то же самое, только на пленэре. Но там чаще всего машину надо было отмыть, с натуральным освещением угадать, тихое место найти, найденную съёмочную локацию очистить от валяющихся бычков и банок (фраза, типа, «. в «Фотошопе» потом вычистишь» выдаёт далёкого от темы человека, потому что «Фотошоп» не всесилен, особенно когда поджимают сроки, а фотосет включает 20-30 кадров).

В общем, возни со съёмкой авто на натуре куда больше.

Первые восторги (и успехи) решил сконвертировать в следующий, продолжим называть это, синематик. Вокруг уже началось вот это вот всё, что нельзя называть вслух и дискредитировать, перспективы экономики на ближайшие лет 15 обрисовались loud & clear, поэтому в моём синематике появилось некое подобие сюжета не сюжета, месседжа не месседжа — назову это «концепт».

Концепт я попытался выразить через реквизит и дизайн локации, а работу назвал «. The Next 15 years». Или Afterlife. То и то подходит.

Под конец марта стало много разговоров об «отменах» — русского языка, русской культуры, русского мира. Я сидел и думал, что русский мир не надо отменять — он сам себя прекрасно такими темпами отменит, переварит, в каком-то виде пересоберёт. Мои думы выросли в следующий синематик, для которого пришлось писать сценарий и корпеть над, назовём это, режиссурой и работой оператора-постановщика. Генплан был сделать весь ролик в модном формате «снято а-ля одним кадром», поэтому куча часов ушла на пристрелку движений камеры. Получилось всё равно шероховато, но работой я доволен.

После релиза и относительного успеха «Русского мiра» в прокате (т.е. среди моей жены и подписчиков в запрещённой соцсети) я неожиданно сделал следующую, самую трогательную работу. Почему «неожиданно»: как-то ехали с 5-летним сыном с английского в метро, я ковырял «Скетчфаб» в поисках вдохновения, сын попросил найти «модельку Оптимуса». Их там было несколько, одна — бесплатная, скачиваемая, ещё и с парой анимаций. Решение созрело моментально.

Тут, помимо дизайна локации, размещения объектов и движений камеры, я заморочился за звук: Оптимуса озвучила нейросеть, я показал черновик своему другу, саунд-дизайнеру. Он внезапно для меня взял и отсаунддизайнил всю звуковую дорожку, добавив характерных для фильмов Майкла Бэя звуковых эффектов. Сын был в полном восторге от поздравления, которое ему прислал сам Оптимус!

Мои читатели знают, что я довольно давно прокачиваю тему «Роботы заменят журналистов». По моему велению нейросети уже писали тексты про автомобили, генерили видеообзоры про автомобили, но мне хотелось настоящего комбо времён ожившей «Лавины»: цифровой аватар Кирилла Зайцева озвучивает нейросетевым голосом тексты, тоже сгенерированные нейросетью. И всё это — в полном три-дэ. Отказался в итоге только от идеи написания текста нейросетью — всё писал сам. Так получился репортаж с Московского автосалона в новых реалиях.

Аватар из MetaHuman на меня похож сильно отчасти, отдельный цирк был по перенавешиванию анимаций из сторонних ресурсов. В итоге более-менее корректно мой аватар мог только сидеть. Весьма, причём, жеманно.

Саунд-дизайном снова занимался мой друг Паша — спец от бога, вот его страница.

Самим роликом же я иронично высказался на очень грустную тему: в России кончилась автоиндустрия. Огромная отрасль, которую строили с конца девяностых, и за которую было реально не стыдно. Но пришло всё вот в сюда.

В конце мая стало известно, что Renault всё-таки уходит из России, а на месте её завода в Москве в каком-то виде возрождают «Москвич». Пока коллеги гадают, какие перелицованные китайские авто поставят на конвейер, я взял на себя смелость приоткрыть завесу тайны и сделать возрождённому «Москвичу» первую рекламу.

На стоках не было бесплатных моделей хорошего качества, только всратая. Что в контексте всего ролика даже выглядит как фича, а не баг.

Искал у себя в городе какие-нибудь офлайн-курсы по UE, нашёл только курсы иллюстраторов. Так что как миллионы самоучек — всё сам, наощупь.

Туториалы на Youtube, уже помянутая книжка, документация разрабов, помощь зала из профильных чатов (типа канала VideoSmile в телеге), форумы и FAQ.

Чаще всего я делаю так: визуализирую у себя в голове, что примерно хочу увидеть на выходе. Выписываю в два столбика — что я уже умею, чего я ещё не умею. Например, до создания «Русского мира» я ничего не знал о проигрывании и записи анимаций, пришлось отдельно гуглить туториалы по запросам «animations in sequencer». Аналогично по работе с металюдьми: отдельный туториал на создание, отдельный туториал на лицевую анимацию через FaceLink.

Да, это, конечно, фуфло, а не образование. Сам не люблю методику туториалов «тут нажми — туда зажми», остро не хватает широты и фундамента, но уж как есть.

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

[5] Создание Survival Horror в стиле RE2 на Unreal Engine и С++. Пространственный инвентарь(Часть 2)

Теперь приступим к настройке самих виджетов.

Перейдем в WBP_Inventory.

Удалим текст и добавим Canvas Panel:

На Canvas добавим Border и переименуем его в Background:

Зальем наш Background на всю площадь Canvas. Нужно нажать на «белый квадрат» ЛКМ+CTRL:

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

И добавим небольшое размытие:

Силу размытия можно менять в параметре Blur Strength:

Теперь добавим на Canvas нашу сетку инвентаря WBP_InventoryGrid и назовем InventoryGridWidget:

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

Установим следующие параметры:

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

Size To Content нужно поставить true.

Теперь переходим в WBP_InventoryGrid. Добавляем Canvas и Border, который называем Grid:

Grid ставим по центру:

И зададим ему пока такие параметры:

Padding изменим на 0:

Цвет изменим на черный и сделаем чуть менее прозрачный, чем Background.

В SHInventoryGridWidget.h объявим функцию InitializeWidget, у которой будет два параметра. Указатель на компонент инвентаря и размер ячейки:

Также создадим две приватные переменные:

И не забываем про такую строку, заголовочный файл мы подключим в cpp файле:

В теле функции присвоим переменным значения:

Теперь нам нужно получить доступ к Border(Grid), который мы создавали в виджете WBP_InventoryGrid.

Перейдем в SHInventoryGridWidget.h «забиндим» Grid из виджета на созданный указатель UBorder с именем Grid. Имена обязательно. должны совпадать:

И опять не забываем:

Также переопределим виртуальную функцию Initialize у UserWidget:

В Функции InitializeWidget добавим несколько строк для изменения размера ячеек инвентаря.

Сначала посчитаем ширину и высоту ячейки. Из эти значений создадим новый Vector2D.

И уже потом этот вектор подставим в функцию SetSize.

Теперь перейдем в SHInventoryWidget.h и создадим публичную функцию InitializeInventoryWidget, которая будет принимать компонент инвентаря:

В секции protected опять «забиндим» компонент InventoryGridWidget из виджета:

И опять не забываем:

Переходим в SHInventoryWidget.срр и в теле функции у InventoryGridWidget вызываем функцию InitializeWidget:

Перейдем в SHPlayerHUD.cpp и в момент открытия инвентаря вызываем у InventoryWidget функцию InitializeInventoryWidget:

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

Перейдем в SHInventoryGridWidget.h и объявим функцию CreateLineSegments:

Также создадим структуру FLine. В ней будет два поле типа Vector2D:

В приватной секции создадим массив TArray с типом нашей структуры и назовем его Lines:

Перейдем в cpp файл в Функцию CreateLineSegments.

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

Начнем с вертикальных.

Пока Index меньше или равен чем значение Column в компоненте инвентаря, цикл будет выполняться.

Находим две точки X и Y для отрисовки линии.

Потом создадим временную переменную Temp типа структуры FLine, куда поместим наши координаты.

И потом добавляем в массив Lines:

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

Теперь перейдем в функцию InitializeWidget и после изменения размера ячеек вызовем функцию CreateLineSegments:

Вернемся в заголовочный файл и переопределим функцию NativePaint:

В теле функции сначала создадим переменную Context:

После этого создадим еще один цикл и будем проходить по массиву Lines.

C помощью функции DrawLine у UWidgetBlueprintLibrary рисуем наши линии:

Не забываем подключить заголовочный файл:

Теперь перейдем в редактор и изменим размер инвентаря и ячеек в компоненте инвентаря, который мы создали у персонажа:

И если во время игры нажать Tab у нас появится инвентарь указанных размеров:

Уроки и видео обучение Unreal Engine 4 на русском

Уроки и видео обучение на движке Unreal Engine 4 на русском языке с нуля

Здесь вы сможете найти подробное описание уроков и видео обучения на движке Unreal Engine 4 с нуля.

Кому это будет интересно?

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

При изучении Unreal Engine 4 вам не потребуется учить никаких языков программирования, всё будет куда проще, благодаря специальным инструментам графического и схемового отображения.

Сейчас мой ПК при изучении движка UE 4:

18.07.18. Вводное слово, почему я захотел изучать Unreal Engine 4

В первом своём видео я коснулся объяснения относительной доступности освоения UE4, хотя трудностей на этом пути будет предостаточно.

Начинаю изучать Unreal Engine 4, хватит говорить пора действовать!

19.07.18. Запуск UE4 на слабом ПК, а также, как его установить

Запуск Unreal Engine 4 на слабом ПК, + как его установить

21.07.18. Мой прогресс в UE4 #1. Построение приятного ландшафта

Мой прогресс в UE4 #1. Построение приятного ландшафта

28.07.18. Мой прогресс в Unreal Engine 4 #3. Простая сцена из F.E.A.R.? Попробуем 🙂

Мой прогресс в Unreal Engine 4 #3. Простая сцена из F.E.A.R.? Попробуем 🙂

ЧИТАТЬ ОБЯЗАТЕЛЬНО.

Поделитесь с друзьями, так вы поможете распространению полезной информации

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

Информация
Посетители, находящиеся в группе Гости, не могут оставлять комментарии к данной публикации.

Лучшие платные и бесплатные онлайн-курсы Unreal Engine для начинающих и опытных создателей игр

Приветствую всех начинающих гейм-разработчиков!

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

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

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

Топ-10 платных курсов

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

И в этом блоке мы рассмотрим лучшую десятку курсов. Эти программы выделяются на фоне остальных своими бесспорными достоинствами.

1. Профессия Разработчик на Unreal Engine 4 с нуля до Middle – Skillbox

Профессия Разработчик на Unreal Engine 4 с нуля до Middle – это онлайн-обучение, которое длится 2 года. Студенты учатся работать с игровым движком и кодить на языке C++, в результате чего они смогут выйти с нулевого уровня на уровень middle. Кроме новичков, не знакомых с Анриал Энджин, программа подойдет и для практикующих junior-разработчиков.

Выпускники онлайн-школы устраиваются в крупные студии по разработке игр и в IT-компании. Более того, многие ученики находят работу еще во время обучения.

План занятий состоит из 82 тематических модулей и около 390 видеолекций по следующим темам:

Стоимость обучения – 4 788 руб. в месяц.

Еще несколько онлайн-программ от Skillbox:

2. GameCode – XYZ School

GameCode – это практический онлайн-курс, длительность которого составляет 5 месяцев. Программа предназначена для практикующих специалистов.

Чтобы стать участником курса, необходимо знать хотя бы один язык программирования, а лучше владеть C++ на среднем уровне. Также желательно иметь представление об объектно-ориентированном подходе.

Преподавателями являются опытные профессионалы, известные в индустрии гейм-разработки. Учеников ждет более 380 часов практики и около 150 видеолекций. В конце обучения студенты будут работать над крупным дипломным проектом.

В программе онлайн-курса рассматриваются следующие темы:

Полная стоимость онлайн-курса – 75 000 руб. Оплачивать программу можно в рассрочку по 4 687 руб. в месяц.

Предлагаю рассмотреть еще парочку программ от XYZ School:

3. Факультет Разработки игр на Unreal Engine – GeekBrains

Факультет Разработки игр на Unreal Engine – это обучающая программа, которая длится 1 год и 3 месяца. Каждую неделю проходит по 2 занятия в виде “живых” онлайн-уроков, вебинаров и видеолекций. Каждый месяц материалы курса обновляются и актуализируются.

Студенты с нуля осваивают разработку игр, чтобы в результате трудоустроиться в крупную студию. Учеников ждет 160 академических часов теории и более 170 часов практики.

В план занятий входят темы:

Стоимость программы – 4 194 руб. в месяц.

Ознакомьтесь и с другими онлайн-курсами от образовательной веб-платформы:

4. Unreal Engine 4 – Coddy

Unreal Engine 4 – это полугодовой обучающий курс, который предназначен для детей и подростков от 12 до 16 лет. Ученики с нуля изучают основы гейм-разработки и особенности использования популярного игрового движка. В результате они научатся создавать игры различных направленностей и жанров.

Юным студентам не нужно иметь каких-либо специальных знаний или умений. Достаточно обладать базовыми навыками работы с компьютером.

Стоимость обучающей программы зависит от выбранного формата. Групповые онлайн-занятия стоят от 750 руб. за час, офлайн – от 850 руб. Индивидуальные дистанционные уроки стоят от 1 050 руб. за час.

5. Разработчик игр на Unreal Engine – Fungi

Разработчик игр на Unreal Engine – это семимесячный онлайн-курс, который состоит из 120 часов лекционных занятий. Обучение подходит и для начинающих, и для практикующих гейм-разработчиков.

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

Слушатели плавно погружаются в мир разработки игр посредством изучения таких тем:

Полная стоимость – 1 995 белорусских рублей (около 51 000 российских рублей), в рассрочку – 300 белорусских рублей в месяц (около 8 000 российских рублей).

6. Unreal Engine 4. Уровень 1 – Специалист.ru

Unreal Engine 4. Уровень 1 – это онлайн-обучение, предназначенное для начинающих разработчиков 3D-игр. Студенты выполняют практические задания после прохождения каждой темы. В конце программы у выпускников будет разработан собственный FS-шутер.

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

В плане имеются такие занятия:

Стоимость онлайн-программы – 19 990 руб. Индивидуальное обучение стоит 46 200 руб.

7. Создание игр на Unreal Engine 4 – MyRusakov

Создание игр на Unreal Engine 4 – это программа обучения, в которую входят более 180 видеолекций. После каждого занятия идут обязательные практические упражнения. Продолжительность курса в общей сложности составляет около 40 часов.

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

Онлайн-программа разделена на 12 учебных модулей. Темы уроков:

Стоимость курса – 4 970 руб.

8. Unreal Engine – Айтигенио

Курс Unreal Engine предназначен для начинающих гейм-разработчиков, которые ранее не работали с игровым движком. Всю программу можно пройти за 60–100 часов в среднем. Однако ученики могут не торопиться и учиться сколь угодно долго.

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

Учебный план состоит из 10 тематических модулей. Они содержат следующие уроки:

Стоимость онлайн-программы зависит от выбранного формата: групповые занятия стоят от 590 до 1 080 руб. за один урок, цена на индивидуальное обучение варьируется от 1 180 до 1 360 руб. за занятие.

9. Unreal Engine Game Developer – Otus

Unreal Engine Game Developer – это четырехмесячная программа обучения для тех, кто хочет освоить профессию разработчика игр и устроиться в студию на работу.

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

На протяжении всего обучения студенты изучают:

Стоимость онлайн-программы – 55 000 руб.

10. Разработчик игр – Avenue

Разработчик игр – это онлайн-программа, которая длится 3,5 месяцев. Уроки проходят по 2 раза в неделю. В группах максимум 10 человек, чтобы преподаватель мог уделить время каждому студенту.

Обучение будет полезно для начинающих и практикующих разработчиков игр. Студенты учатся создавать компьютерные игры и программировать на C++ с нуля.

Стоимость онлайн-обучения – 36 710 руб. За тариф VIP придется заплатить 50 710 руб. Очное обучение стоит 43 710 руб.

Другие обучающие программы

Рассматриваемый движок весьма популярен и востребован. Анриал Энджин используют разработчики и в крупных IT-компаниях, и в небольших студиях. Поэтому специалисты по работе с этим игровым движком всегда нужны.

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

Unreal Engine 4 – Realtime School

Unreal Engine 4 – это дистанционный курс, который длится 50 часов. Занятия идут 5 дней с 10 утра до 10 вечера с небольшими перерывами. Программа предназначена для опытных пользователей ПК, однако кроме компьютерной грамотности больше никаких специфических знаний не требуется.

Студенты с нуля научатся создавать проекты различного уровня сложности: от мобильных 2D-игр до VR-приложений и фотореалистичных компьютерных игр. В результате после курса выпускники смогут работать в индустрии гейм-разработки или создавать интерактивные приложения в студиях.

Стоимость онлайн-обучения – 45 000 руб.

Еще парочка курсов от образовательной веб-платформы:

Уроки Unreal Engine 4 – itProger

Уроки Unreal Engine 4 предназначены для обучения разработке игр для компьютеров, приложений и VR. Студенты создают 2D- и 3D-проекты, которые могут стать основой портфолио.

Этот комплекс занятий подходит для начинающих специалистов. На нем студенты изучают все с самых азов. Для более глубокого освоения Анриал Энджин можно пройти другой курс, который тоже есть на этой же веб-площадке.

В программе онлайн-обучения имеются следующие темы:

Стоимость программы определяется длительностью подписки. Подписка на месяц стоит 7 долларов, на 3 месяца – 17 долларов, на полгода – 25 долларов, на 9 месяцев – 79 долларов.

Еще один онлайн-курс от itProger:

Unreal Engine – полное руководство по разработке на C++ – Udemy

Unreal Engine – полное руководство по разработке на C++ подходит для студентов начального и среднего уровня подготовки. Здесь учат программировать на C++, а также использовать движок Анриал Энджин.

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

Учебный план состоит из 14 модулей и около 160 видеолекций на следующие темы:

Стоимость онлайн-программы – 12,99 долларов.

Unreal Engine for Archviz 3.0 – Arhi.Teach

Unreal Engine for Archviz 3.0 – это дистанционное обучение, длится которое 6 недель. Студенты с нуля изучают архитектурную визуализацию и основы гейм-разработки.

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

Процесс обучения состоит из просмотра 100 видеолекций, посещения “живых” вебинаров и выполнения практических заданий. Кураторы и преподаватели дают развернутые ответы после проверки домашних заданий.

Стоимость онлайн-программы – 56 000 руб. При повторном обучении пользователям можно заплатить только половину этой суммы.

Онлайн-курс Unreal Engine для детей – Keencentre

Онлайн-курс Unreal Engine для детей длится 4 месяца. Каждую неделю ученики получают новые видеолекции с пошаговыми инструкциями, а после просмотра урока выполняют практические задания в виде тестов.

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

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

Преподаватели рассказывают о следующем:

Стоимость обучения можно узнать после подачи заявки на участие.

Бесплатные онлайн-уроки

И в конце осталось рассмотреть только бесплатные занятия. Новички могут использовать эти онлайн-курсы в качестве основного источника информации. Однако в большинстве случаев бесплатные уроки являются лишь полезным дополнением к главной обучающей программе.

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

Уроки Unreal Engine 4 – YouTube-канал Unreal Engine Rus

Уроки Unreal Engine 4 представлены Ютуб-каналом, который посвящен обучению работе с игровым движком. Онлайн-программа включает в себя небольшие видеолекции по 10–20 минут в среднем.

Intro.GameCode – XYZ School

Intro.GameCode – это онлайн-курс, созданный для начинающих гейм-разработчиков, которые еще не знакомы с игровым движком. Однако знать язык C++ студентам нужно.

Здесь нет домашних заданий и их проверки, только заранее записанные видеолекции. Цель онлайн-программы – показать ученикам, как работает гейм-разработчик и в чем его обязанности.

Уроки по Unreal Engine 4 – 4Creates

Уроки по Unreal Engine 4 предназначены для обучения работе с популярным игровым движком. Этот пошаговый видеокурс включает в себя более 50 занятий, имеющих общую продолжительность около 11 часов.

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

В программе курса:

Разработка игры на Unreal Engine – Dev2dev

Разработка игры на Unreal Engine – это обучающая инструкция по разработке собственной игры с нуля при помощи популярного игрового движка. Студенты создадут оригинального персонажа и врагов для него, настроят освещение и звук, добавят анимацию и спецэффекты.

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

Курс состоит из 3 тематических модулей и 12 видеолекций на следующие темы:

Создание игр и приложений на Unreal Engine – Stepik

Создание игр и приложений на Unreal Engine – это развернутый онлайн-курс, состоящий из почти 70 занятий и более 60 тестов. Он обучает студентов терминологии и этапам создания проекта. Ученики проходят уроки на такие темы:

Старт в Unreal Engine – Мастерская Исаева

Старт в Unreal Engine – это короткий онлайн-курс, который подходит и начинающим, и опытным специалистам по гейм-разработке. Ученики осваивают базовые инструменты Анриал Энджин.

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

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

Заключение

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

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

Бесплатный левел-дизайн, или как строить ландшафт в реальном времени на UE4

Всем привет! Меня зовут Влад Маркелов, и сегодня я расскажу, как можно бесплатно и быстро создавать огромные игровые уровни и как в реальном времени строить ландшафт по информации из Интернета.

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

Немного предыстории

В геймдев меня затянуло в 2013 году — с тех пор так оттуда и не выбрался. Если конкретнее, изначально меня занесло в модостроение: с 2016 года я работал с командой мода над стартапом, как раз на UE4. Тогда версия движка была еще 4.12 — как будто вечность прошла с того момента. Параллельно я фрилансил, по большей части тоже на Unreal Engine. Таким образом, уже 5 лет я не расстаюсь с ним. В прошлом году ушел во «взрослый» геймдев: сначала в 1C Entertaiment, ну а сейчас я занимаю должность старшего программиста в MY.GAMES.

С детства я любил видеоигры — особенно с большим открытым миром. Skyrim, «Ведьмак», GTA. Иди, куда хочешь, смотри, на что хочешь, — полная свобода. Ну, или почти полная.

И я всегда мечтал об игре, где будет доступен весь мир. Прямо весь. Мечтал создать свою «GTA на Android», где можно было бы сесть на самолет «Лос-Анджелес-Москва» и выпрыгнуть с парашютом где-то над Парижем. Ну, знаете, эти детские фантазии. Разумеется, тогда я не понимал ни масштабов нашей планеты, ни масштабов работы, требующейся для ее детального отображения в игре.

Гораздо позже пришло осознание, что если это и возможно, то в не той детализации. Яркий пример тому — игра Microsoft Flight Simulator. Хоть карта в ней была сделана и не полностью процедурно, детализация при ближайшем рассмотрении оставляет желать лучшего — за исключением городов и особо красивых природных мест, да и те хорошо выглядят только с высоты низкого полета, порядка нескольких сотен метров. Но и эти масштабы работы уже впечатляют.

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

Однако, если мы готовы пожертвовать качеством на некотором масштабе — пусть даже на той же высоте полета, — мы можем воспроизвести любую местность на планете: хоть всю планету целиком, благо данных в Интернете более чем достаточно. Отличным примером может послужить и тот же Microsoft Flight Simulator, либо Google Earth, которая строит 3D-ландшафт из открытых данных. Как правило, они захватываются со спутника и практически не подвергаются ручной обработке. И раз эти данные есть, мы можем их получить и построить свой ландшафт, с блэкджеком и лодами, ограниченный в масштабах лишь мощностью компьютера.

Вводные данные: что будем делать

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

Рисовать все вручную было не вариант. Просить сканировать местность и строить ее с помощью фотограмметрии — тоже. Никто таким замороченным софтом пользоваться не будет.

И тут и возникла идея: почему бы не скачать ландшафт из Интернета?

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

Но! При небольшой доработке этот метод можно использовать не только для загрузки ландшафта в реальном времени, но и для построения обычного ландшафта в редакторе Unreal Engine 4.

Примеры генерации ландшафта через математический шум

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

Представление данных о планете Земля — как оно бывает

Итак, мы знаем, что все данные о планете хранятся в радиальных координатах. А точнее — в системе мировых геодезических координат WGS 84.

Казалось бы, у нас есть два угла. Мы знаем радиус Земли. И, как в 9-ом классе, умножив синусы углов на радиус, мы получим координату в привычных XYZ-координатах. Но не все так просто:

во-первых, радиус Земли сильно различается в разных точках планеты;

во-вторых, таким образом мы получим поверхность шара.

Игровой мир, в свою очередь, нам представляется скорее как плоскость. Но мы же знаем, что Земля не плоская. И на масштабах всего в несколько километров ее шарообразность уже становится заметной. Если мы хотим как-то экспортировать координаты из игры, ошибки будут еще критичнее. Да и работать с ними, вычислять расстояния и так далее — не особо удобно.

Плоский ландшафт

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

Пример проекции Меркатора

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

Тут и появляется новая проблема — искривление.

Для наглядности приведу довольно известный пример с расстояниями на Google Maps. На рисунке ниже расстояние, проведенное по кратчайшему пути на 2D-проекции, равно примерно 10 000 км, а вот кратчайшее расстояние, которое Google Maps строит автоматически, составляет уже 9 000 км. То есть, расстояние, проведенное по прямой на глобусе, отличается более чем на 10% от расстояния, проведенного по 2D-карте.

Если бы размер стран на плоской карте совпадал с реальным, Гренландия оказалась бы в три раза больше Австралии, а крошечная Новая Зеландия поравнялась бы с Германией. Ну а размер Антарктиды просто поражает воображение! На ней могла бы уместиться вся остальная суша целиком. А как вам острова Канады в Северном Ледовитом океане? Суммарно они по площади примерно как Колумбия, но на плоской карте готовы потягаться со всей Южной Америкой.

Может показаться, что эти изменения видно только в масштабах целой планеты, но на деле погрешность в десятки сантиметров заметна уже после пары километров — да и погрешность float тоже никуда не исчезает. Думаю, если вы сталкивались с большими игровыми мирами, вам это очень знакомо. В таком случае каждые 2-3 километра передвижения игрока нужно менять опорную точку и, соответственно, центр мира, таким образом повышая точность вокруг текущей игровой зоны, доступной игроку — благо в Unreal Engine 4 это делается парой строчек кода.

Искажение размеров при проекции

Однако, с помощью Меркатора мы можем перевести координаты из WGS84 в XY-координаты вокруг точки опоры и с этим работать дальше.

Загрузка данных о ландшафте в Unreal Engine 4

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

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

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

Но большую часть этого кода в конечном итоге мы использовать не будем — сочтем его просто компьютерной магией. В конце концов, нас интересуют лишь две функции: WGS84Bounds и WGS84ToTile.

Теперь, зная широту и долготу, мы можем вычислить нужный тайл. Далее через API Google Maps мы можем его загрузить:

Кроме того, в зависимости от наших нужд мы можем загрузить разные слои карты: схему, спутник или гибрид. В дальнейших примерах мы будем загружать именно снимки со спутника. Ну а для загрузки большего куска карты просто итерируем номера тайлов, пока не загрузим достаточное их количество. То есть, если вокруг некой широты и долготы нам нужно загрузить два тайла в каждую сторону, мы вычисляем центральный тайл и проходимся по двойному циклу от X–2 и Y–2 до X+2 и Y+2.

Важно помнить, что API работает не моментально: однозначно не стоит загружать текстуру синхронно. Еще лучше — предусмотреть сценарий, когда тайлы будут загружаться приличное количество времени, потому что, скорее всего, так и будет. Добавить экран загрузки или что-то в этом роде. Тайлы загружаются за одинаковое время практически вне зависимости от размера, и в среднем это 0.4-0.5 секунды на тайл.

Через UAsyncTaskDownloadImage мы загружаем картинку:

Хотя в теории Unreal Engine 4 позволяет нам отправить сразу все тайлы на загрузку одновременно, скорость соединения и ограничения API не дадут нам этого сделать. Только если запустить сразу несколько загрузок — тогда может прокатить.

Также для удобства можно написать наследника этого таска, который будет содержать больше информации о тайле. Однако, для универсальности мы сейчас говорим о базовых возможностях UE4. Движок сразу преобразует загруженный таском тайл в нужный нам texture 2D dynamic — наследника UTexture, который мы можем применить к динамическому материалу. Эту текстуру мы получим из делегата OnSuccess.

Асинхронно загружаем нужный тайл с диска или из интернета, применяем его к динамическому материалу

Кроме того, нередко возникают случаи, когда одна и та же область загружается по многу раз. Допустим, игрок любит летать по одинаковому маршруту. Для таких случаев можно сделать кэширование тайлов локально на диске. Загрузить эти тайлы можно будет также с помощью UAsyncTaskDownloadImage и при нужде проверять, есть ли нужный тайл на диске, и только если его нет — загружать из Интернета.

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

Пример кода приведен ниже: как вы видите, пришлось несколько ухищряться через render target, поскольку Unreal Engine 4 не поддерживает прямой экспорт динамической текстуры, в отличие от обычной.

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

Предположим, каждый наш физический тайл — то есть, геометрия тайла — соответствует по размеру тайлу с высоким разрешением. Тогда, чтобы применить изображение с низким зумом, придется провести небольшие математические операции. Но зато мы сможем использовать одну и ту же картинку сразу на 4, 16, а то и 64 физических тайлах.

Пример такого материала можно посмотреть ниже. В нем как раз используется один тайл с маленьким зумом на сетку 8×8 из маленьких тайлов — то есть, одна картинка на 64 тайла.

Рисунок ниже показывает смену тайла с разрешением 19 на тайл с разрешением 16 при удалении от объекта:

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

Но плоскую карту мы можем увидеть и в Google Maps — такое нам не интересно. Поэтому пора загружать карту высот.

Загружаем информацию о высоте

Воспользуемся сервисом Airmap. Это довольно глобальная платформа для получения информации об объектах в воздухе, опасных зонах и многом другом. Но нам интересно именно elevation API, которое и поможет нам получить информацию о высоте любой точки Земли. У Google есть свой аналог, и, возможно, он даже лучше, но он платный. Им я не пользовался, так что ни рекомендовать, ни предостерегать не буду.

У выбранного API довольно скромный набор запросов, но для ваших целей хватает:

Запрос для получения массива высот по массиву координат — в нашем случае с ним придется перебрать все точки на карте, так что он разрастется непомерно, такое нам не подходит;

Запрос высоты по направлению от A до B — чуть лучше, но тоже не то.

Но есть и вариант для нас идеальный: мы можем запросить 2D-массив, покрывающий всю площадь от угла A до угла B. Координаты передаются просто через запятую: самая южная широта, самая западная долгота, самая северная широта и самая восточная долгота.

Тут важно понимать, что у API есть свои ограничения, а именно — максимальное число точек, которое нам могут прислать (10 000). Такое количество приходится на площадь где-то между 15 и 14 зумом тайлов Google Maps. Так что самый большой тайл, высоты которого мы можем загрузить одним запросом, — это тайл с зумом 15 и небольшим запасом с каждой стороны. Поскольку плотность сетки высот никак не связана с Google Maps, а API возвращает высоту по меньшей площади, если на углах нет точного совпадения, стоит запрашивать площадь на 3-5% больше реальной площади тайла, чтобы все его высоты наверняка попали в полученный результат.

Составим такой запрос:

И получим на него примерно такой ответ:

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

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

Из-за этих различий нам нужно написать алгоритм интерполяции. В самом примитивном варианте нам нужно вычислить координаты каждого вертекса на полученной площади и найти четыре ближайшие точки к его позиции, а после этого вычислить высоту, спроецировав точку на плоскость. Это можно сделать, например, с помощью встроенной в UE4 функции PointPlaneProject.

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

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

Черной пунктирной линией на графике показана кубическая интерполяция по трем точкам — но это в 2D-плоскости, учитывая высоту и одну из оставшихся координат: либо X, либо Y. В 3D-пространстве картинка будет сложнее — в виде хитрой искривленной поверхности, которая уже ближе подходит к действительности, хоть и не идеально совпадает. Но стоит помнить, что мы ограничены во вводных данных.

Перевести информацию из JSON в понятный движку формат можно с помощью встроенных в Unreal Engine 4 утилит для работы с JSON:

Сначала мы сериализуем полученную строку в FJsonObject с помощью TJsonReader и FJsonSerializer;

Далее идем по древу JSON и получаем из него нужные значения в формате JSON;

После этого переводим их в удобные нам типы данных.

В чем хранить высоты, в целом не столь важно: можно даже в int, тут скорее вопрос удобства. А вот широту и долготу обязательно хранить в double: float катастрофически не хватает точности для описания всей планеты. Также мы могли бы воспользоваться встроенной функцией JsonObjectStringToUStruct, но, к сожалению, UE4 не поддерживает рефлексию для double и для вложенных массивов — а в ответе Airmap мы получили именно такой.

Далее с помощью procedural mesh component создаем сам меш из уже загруженных и посчитанных высот. Этот компонент, по сути, позволяет нам в режиме реального времени задать массив вертексов, треугольников, цветов вертексов, разметку UV-карты для правильного нанесения текстур и из всего этого собрать секцию меша.

Ниже — пример построения плейна 100×100 см из 25 вертексов. Конечно, предварительно надо не забыть обновить высоты вертексов.

С помощью dynamic material instance задаем одну или две текстуры — для большого и маленького зума: количество маленьких тайлов в большом зуме, индексы маленького тайла в большом зуме по X и Y — так для N тайлов. Таким образом, нам нужно получить от игрока всего одно значение широты и долготы. Более того — мы можем встроить в игру поиск координат по названию локации, используя API Google Maps.

Результаты

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

Однако, если не обращать внимание на такие мелкие недочеты, смотрите, что у нас получается. Вот, например, Эверест:

А это — Большой каньон:

Ну вот и все: с этой темой разобрались. В комментариях буду рад ответить на вопросы и вообще подискутировать на тему.

Напоследок оставлю ссылку на свой сайт — на нем можно ознакомиться с другими моими статьями.

4 новых бесплатных курса для Unreal Engine

Команда Epic Games представила новые бесплатные курсы для пользователей Unreal Engine. Они помогут начинающим композиторам, независимым режиссерам, художникам по окружению и многим другим.

В этом вводном курсе по композитингу в Unreal Engine вы узнаете основы создания композиции. Следуйте инструкциям и изучите различные методы, чтобы получить наилучшие результаты от плагина Composure.

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

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

В этом курсе вы узнаете основы работы младшего художника по окружению с Unreal Engine в производственном пайплайне.

Я обязательно начну делать игры

Сколько не пытался начать нормально что-то делать на ue или том же unity, все время останавливался на том, что это тупо скучно делать одному и, к сожалению, среди знакомых нет никого, кому это было бы интересно, а жаль =(

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

Ты бы, я бы, хуябы. Суть не в том, кого и чего задевает это или нет, а в том, что такое говорят только ублюдки, считающие, что если у человека не получается что-то, в чем ты сам хоть немного разобрался, то они могут усмехаться над ними таким вот образом. Нормальный человек даст совет, как знающий тему или поможет чем-то, в противном случае пройдет мимо, а фраза «может это не твоё», лишь попытка возвысить себя над кем-либо, достойная только мразей.

Дак я тоже пошутил, дурилка, не принимай так близко к сердцу! Чмоки-чмоки (=^_^=)

Уроки unreal engine 5

Ну а что до светлого будущего, то Энскейп и Врай Вэнтидж через пару-тройку итераций версий будут делать то же самое, что и анрил, только при этом изнутри удобного для моделинга/редактирования макса, с возможностью рендерить статику с одной кнопки.

И сразу, чтобы меня не упрекали в поверхностности. Я в курсе анрила, изучал, делал тесты и интерьеров и экстерьеров, и РТХ-видеокарта имеется, и виар в виде первого реверба тоже лежит.
Проблема всего этого в том, что ты берёшь себе кучу гемора, несоразмерного с увеличением цены за проект. И в итоге играешь себе же в минус.

Мне не о чем с вами разговаривать. Вы не компетентны в работе с UE судя по вашему посту. Вы только рендерить анимацию в короне 4к будете по цене от 30к на ферме и то в 30 кадров. И с первого раза не отрендерите. Будут косяки, флики. Подрендерить пролеты еще деньги.

Конечно я некомпетентен))) Непонятно только зачем разговариваете, если не о чем. Выглядит это как «я три квартала бежал, чтобы сказать вам, как вы мне безразличны».
Продолжайте охранять свою святую корову. Особенно это забавно выглядит, когда на нее никто не нападает.

По факту в анриле нет всех удобных инструментов для моделинга и редактирования геометрии. Это тащит кучу времени за собой. И таких мелочей там куча.

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

Про параллельные вселенные и унитазы всегда смешно читать от людей, которые даже отдалённо не знают наших заказчиков, проекты, и наши заработки. Имхо, это вы там в каких-то выдуманных вами вселенных витаете, а не я.
Логика очень простая. Дизайн продаёт дизайнер или менеджер, а не визуализации, и не синематики уж точно. И гонорар обычно имеет верхнюю планку. И если вы проект станете делать не за месяц, а за полтора, то вы тем самым лишите себя одной трети прибыли.

Разницу понимаете между «никто не будет платить за анрил» и » никто не будет платить в разы больше чисто за ходилку»? Или русский не родной?

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

Я всю дорогу вам говорю, что сейчас анрил крадёт больше времени на разработку проекта, чем макс + врай/корона, и поэтому сидя на анриле, вы у себя крадёте бабки из кармана, т.к. делаете ту же работу за большее время.
А в прекрасном будущем, в котором по вашему мнению все будут всё делать на анриле, и поэтому надо всем срочно бежать качать бету UE5, по моему мнению будет куча подобного софта под макс, синему, майку и тд, и поэтому когда все пересядут на синематики и интерактивку, никакой анрил вам даром будет уже не нужен.

«Я бы вам советовал в свободное время изучать.»
Советы, которых никто не спрашивал, т.к. вы не являетесь для человека экспертом.

«Мне не о чем с вами разговаривать. Вы не компетентны в работе с UE судя по вашему посту.»
Переход на личности, заочное признание некомпетентности незнакомого человека. По гаданию на хрустальном шаре, видимо.

«Вы просто ограничили у себя в голове сферу Виза до санузлов рядовому обывателю.»
Переход на личности, оскорбление, фантазии на тему санузлов и моих проектов.

«53 коммента за 7 мес. Да, это омногом говорит»
Оценка качества ПО по количеству комментов в ютубе. Ну это, имхо, клиника, и преступление против собственного же здравого смысла, но ваше дело, т.к. как мне почему-то кажется, и это сугубо моё оценочное суждение, у вас его и так немного.

«И не лень было это писать..)»
Не надо оскоблять людей и считать себя самым умным, когда это не так, и никто тебе ничего писать не будет.

» Простыни, которые вообще к теме не относятся) »
Тебе написали по теме и коротко, ты начал называть всех подряд профанами и считать, что только ты умеешь работать в анриле. Соответственно, тебе пояснили, что это мягко говоря не так. Потом объяснили, что никакой эксклюзивной мегаубертехнологии в анриле по части архвиза нет, и все это частично есть в более юзерфрендли софте, а в будущем будет повсеместно.

«Но у вас же тау много негатива внутри вашей коробочки узкой, что прям неемется все вылить на меня, вашего неприятеля еще с давних времен, и тема то не важна по сути»
А ты кто? И почему ты считаешь, что ты мне на кой-то чёрт сдался? Каких еще давних времён? О чём ты? Я на форуме и в комментах бываю крайне редко, и мне в реальной жизни достаточно людей, чтобы запоминать кого-то с ддд и выливать какой-то негатив.
Перечитай сначала. Я тебе конкретно и по фактам объяснил свою позицию касательно анрила. Кто ты такой и о чём мы там с тобой, видимо, спорили в прошлом, я вообще не помню, т.к. срачи в инетах не имеют для меня никакого значения, веду их редко, недолго, и быстро забываю с кем и о чём спорил, т.к. никакого практического смысла в реальной жизни это всё не имеет.

«Был бы кто другой на моем месте, вы бы и не писали ничего)»
Бред величия? О_о

«Пишу это и улыбаюсь) Смешны вы.»
Могу только пожелать тебе больше социализироваться, и общаться с реальными людьми, может и полегчает.

«Я знаю себе цену. Я хороший специалист и умею многое.»
А мне девушка говорит, что я самый красивый и умный 😛
Вот))) Я тоже похвалился)))

«Работы мои нравятся многим.»
И? Я ни разу не говорил, что у тебя плохие работы.
Ты наехал на Вэнтидж, оценивая качества софта от уважаемой конторы по количеству комментов в ютубе под роликом ранней демки.
Не кажется ли тебе, что это мягко говоря дурацкий способ оценки софта? Не?
На этот неадекват, я вернул тебе твой упрёк Вэнтиджа и комментов обратно, указав тебе, что у тебя самого проектов в инсте и ютубе кот наплакал. А остальные выводы ты уже сам сделал 😉

«Ты же (сам перешел) хрен пойми кто. Без профиля нормального, с древними работами и фришными моделями.»
И? Заказы я на ддд не ищу, тут денежных заказчиков нет, моделингом мысла заниматься не вижу, т.к. заказы по дизу и визу приносят намного больше.

«Да еще и чушь несешь тут про то, что не знаешь». «Это не домыслы мои, а вывод»
Телепат ты наш, светила мысли))
Я тестил Luishuang’овское детище еще с первых публичных версий, и лайтлики ловил пачками, и свет ставил кучей спотов под окно, и ****ался с развёртками, и тупил над статиком и стэйшенари, валился из-за нехватки видеопамяти, еще когда вылеты были неочевидно откуда и в логи надо было лезть, и тырил блюпринты у врая для анрила чтобы привязать к каждой камере клипинг плэйн. Расскажи мне про то, чего я не знаю)))

Туториал по Unreal Engine. Часть 3: материалы

Как и в реальном мире, в играх есть множество объектов, каждый со своим внешним видом. В Unreal Engine этот внешний вид зависит от материалов. Какой цвет имеет объект? Прозрачен ли он? Блестит ли? Все эти свойства задаются материалами.

Материалы используются почти для любого визуального элемента в Unreal Engine. Материалы можно наносить на любые объекты, включая меши, частицы и элементы UI.

В этой части туториала вы научитесь следующему:

Примечание: эта статья является одной из восьми частей туториала по Unreal Engine:

Приступаем к работе

Скачайте заготовку проекта и распакуйте её. Чтобы открыть проект, перейдите в папку проекта и откройте BananaCollector.uproject.

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

Вы увидите небольшую область, в которой расположены бананы. Нажмите Play, чтобы управлять красным кубом с помощюь клавиш W, A, S и D. Собирать бананы можно, касаясь их.

Для начала давайте изменим материал банана, чтобы менять его яркость. Перейдите в папку Materials и дважды нажмите на M_Banana, чтобы открыть его в редакторе материалов.

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

Управление текстурами

По своей сущности текстура является изображением, а изображение — это набор пикселей. В цветном изображении цвет пикселя определяется его красным ®, зелёным (G) и синим (B) каналами.

Ниже представлен пример изображения 2×2 с указанными для каждого пикселя значениями RGB.

Примечание: в Unreal Engine каналы RGB имеют интервал значений от 0.0 до 1.0. Однако в большинстве других приложений каналы RGB имеют интервал от 0 до 255. Это просто разные способы отображения одинаковой информации и они не означают, что интервал цветов Unreal Engine меньше.

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

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

Вот как это можно сделать в редакторе материалов:

Теперь можно использовать нод Multiply для регулировки яркости текстуры.

Нод Multiply

Нод Multiply делает именно то, что следует из его названия: он умножает один вход на другой вход.

С помощью умножения можно изменять яркость пикселя, не затрагивая его оттенок или насыщенность. Ниже представлен пример уменьшения яркости наполовину умножением каждого канала на 0.5.

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

Мы не будем рассматривать это в туториале, но вы можете использовать нод Multiply в сочетании с текстурой-маской. С помощью маски можно указать, какие области базовой текстуры должны быть темнее. Вот пример наложения маски из текстуры плитки на текстуру камня:

Наложение маски работает, потому что градации серого представляют собой интервал от 0 (чёрный) до 1 (белый).

Белые области имеют полную яркость, потому что каналы умножены на 1. Серые области темнее, потому что каналы умножаются на значения меньше 1. Чёрные области не имеют яркости, потому что каналы умножены на 0.

Теперь настало время воспользоваться нодом Multiply.

Регулировка яркости текстур

Разорвите связь между нодом Texture Sample и контактом Base Color. Это можно сделать, нажав правой клавишей мыши на любой контакт и выбрав Break Link(s). Или же можно удерживать клавишу Alt и нажать левой клавишей мыши на соединяющей линии.

Создайте нод Multiply и Constant. Их можно создать быстро, удерживая клавишу M (для нода Multiply) или клавишу 1 (для нода Constant) и левой клавишей мыши на пустом пространстве в графе. После этого соединение должно выглядеть следующим образом:

Такая схема будет итеративно обходить каждый пиксель и умножать каждый канал на значение нода Constant. Наконец, получившаяся текстура будет выведена как Base Color.

Пока получившаяся текстура будет чёрной, потому что множитель равен нулю. Для изменения значения множителя выберите нод Constant и перейдите в панель Details. Введите в поле Value значение 5.

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

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

Об экземплярах материалов

Экземпляр материала — это копия материала. Все изменения, вносимые в базовый материал, отображаются также и на экземпляре материала.

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

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

Экземпляры материалов удобно применять в следующих случаях:

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

Создание параметров материалов

Вернитесь в редактор материалов и выберите материал M_Banana.

Во-первых, нам нужен нод, меняющий оттенок текстуры. Для этого можно использовать нод HueShift. Добавьте его в граф и соедините следующим образом:

Теперь нам нужно создать нод Scalar Parameter. В этом ноде хранится единственное значение и его можно будет изменять в экземпляре материала. Этот нод можно быстро создать, удерживая клавишу S и нажав левой клавишей мыши на пустом пространстве в графе. После создания нода соедините его с контактом Hue Shift Percentage (S) нода HueShift.

Неплохо также будет давать названия параметрам. Выберите нод Scalar Parameter и перейдите в панель Details. Измените Parameter Name на HueShiftPercentage.

Можно также преобразовать ноды Constant в Scalar Parameter. Нажмите правой клавишей мыши на добавленный ранее нод Constant, а затем выберите Convert to Parameter. Переименуйте параметр в Brightness.

Теперь мы создадим экземпляр материала.

Создание экземпляра материала

Перейдите в Content Browser и выберите папку Materials. Нажмите правой клавишей мыши на M_Banana и выберите Create Material Instance. Переименуйте новый ассет в MI_Banana_Green.

Дважды нажмите на MI_Banana_Green, чтобы открыть его. При этом он откроется в редакторе экземпляров материалов.

Редактор экземпляров материалов состоит из трёх панелей:

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

Укажите для Brightness значение 0.5, а для HueShiftPercentage — значение 0.2. В результате у вас получится следующее:

Мы создали экземпляр материала, теперь можно применить его на некоторые из бананов! Закройте экземпляр материала и перейдите во Viewport основного редактора.

Применение экземпляра материала

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

Выберите любой банан и перейдите в панель Details. В списке компонентов выберите компонент StaticMesh.

В панели Details отобразятся свойства компонента StaticMesh. Измените материал на MI_Banana_Green.

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

Динамически изменяемые материалы

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

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

Убедитесь, что находитесь в папке Materials и дважды щёлкните на M_Cube, чтобы открыть его.

Во-первых, нам нужен способ создания цветов. К ноду Base Color подсоединён нод Constant3Vector. Эти ноды идеально подходят для выбора цветов, потому что у них есть красный, зелёный и синий каналы.

Поскольку красный цвет уже был создан, мы создадим белый цвет. Добавьте ещё один нод Constant3Vector. Это можно сделать быстро, удерживая клавишу 3 и нажав левой клавишей мыши на пустом пространстве в графе.

Откройте инструмент выбора цвета, дважды щёлкнув на нод Constant3Vector.

Выберите белый цвет, или с помощью ползунков, или введя значение 1.0 для каналов R, G и B. Затем нажмите кнопку OK.

Чтобы изменить цвет с белого на красный, нам нужен способ создания плавного перехода между ними. Есть простой способ его реализации — линейная интерполяция.

Что такое «линейная интерполяция»?

Линейная интерполяция — это способ нахождения значений между A и B. Например, можно использовать линейную интерполяцию для нахождения значения посередине между 100 и 200.

Линейная интерполяция становится ещё более мощным инструментом, если можно управлять alpha. Мы можем воспринимать alpha как процент между A и B. Alpha = 0 вернёт значение A, а alpha = 1 — значение B.

Например, можно увеличивать alpha постепенно, чтобы плавно перемещать объект из точки A в точку B.

В этом туториале мы будем управлять alpha с помощью количества собранных бананов.

Использование нода LinearInterpolate

Во-первых, добавим нод LinearInterpolate. Это можно сделать быстро, удерживая клавишу L и нажав левой клавишей мыши на пустом пространстве в графе.

Затем создадим нод Scalar Parameter и назовём его ColorAlpha. Соединим ноды следующим образом (заметьте, что белый теперь находится сверху):

Подведём итог: нод LinearInterpolate будет выводить значение входного значения A. Так происходит потому, что начальное значение alpha равно 0. При приближении alpha к 1, выходное значение будет приближаться ко входному значению B.

Материал уже готов. Нам ещё предстоит многое сделать, но чтобы посмотреть, что у нас получилось, нажмите на Apply и закройте редактор материалов. Если нажать Play, то вы увидите, что теперь куб не красный, а белый.

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

О динамических экземплярах материалов

В отличие от обычного экземпляра, динамический экземпляр материала можно изменять во время игрового процесса. Это можно делать с помощью Blueprints или C++.

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

Ещё один хороший аспект динамических экземпляров материалов заключается в том, что их можно изменять индивидуально.

Ниже представлен пример обновления отдельных экземпляров для наложения маски на области объекта.

Давайте начнём с создания динамического экземпляра материала.

Создание динамического экземпляра материала

Динамические экземпляры материалов можно создавать только во время процесса игры. Для этого можно использовать Blueprints (или C++).

В Content Browser перейдите в папку Blueprints и дважды щёлкните на BP_Player, чтобы открыть его.

Первое, что мы сделаем — это создадим новый динамический экземпляр материала и затем применим его к мешу куба. Логично будет делать это, когда Unreal спаунит актора, а эту задачу выполняет нод Event BeginPlay.

Перейдите в Event Graph и найдите нод Event BeginPlay.

Теперь добавьте нод Create Dynamic Material Instance (StaticMesh). Этот нод будет одновременно создавать и применять новый динамический экземпляр материала к мешу куба.

Теперь нам нужно указать, какой материал должен использовать куб. Нажмите на раскрывающийся список в Source Material и выберите M_Cube.

Чтобы удобнее ссылаться на материал, лучше всего хранить его в переменной. Проще всего это сделать нажав правой клавишей мыши на контакт Return Value нода Create Dynamic Material Instance. Затем выберите Promote to Variable.

Если заглянуть во вкладку My Blueprint, то вы заметите, что там появилась новая переменная. Переименуйте её в CubeMaterial. Это можно быстро сделать, нажав клавишу F2.

Наконец, соедините нод Event BeginPlay с нодом Create Dynamic Material Instance.

Подведём итог: когда Unreal спаунит BP_Player, он создаёт новый динамический экземпляр материала и применяет его к компоненту StaticMesh. Затем он сохраняет материал в переменную под названием CubeMaterial.

Следующим шагом будет создание счётчика для отслеживания количества собранных бананов.

Создание счётчика бананов

Если немного переместиться от нода Event BeginPlay, то можно увидеть следующую схему. Здесь мы будем обновлять счётчик бананов и материал.

Нод On Component Begin Overlap выполняется, когда куб перекрывает другого актора. Затем нод Cast to BP_Banana проверяет, является ли перекрываемый актор бананом. Если актор — это банан, то нод DestroyActor уничтожает его и он исчезает из игры.

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

Создайте новую переменную Float и назовите её BananaCounter. Перетащите переменную BananaCounter в Event Graph и выберите Get.

Далее присоедините нод DestroyActor к ноду IncrementFloat.

Теперь, когда игрок будет поднимать банан, переменная BananaCounter будет увеличиваться на единицу.

Если бы мы использовали BananaCounter в качестве alpha прямо сейчас, то получили бы неожиданные результаты, потому что нод LinearInterpolation ожидает значения в интервале от 0 до 1. Можно использовать нормализацию для преобразования счётчика в интервал от 0 до 1.

Для нормализации мы просто разделим BananaCounter на максимальное значение. Это значение равно количеству бананов, которое должен собрать куб, чтобы полностью стать красным.

Добавим нод float / float и соединим его верхний контакт с оставшимся контактом нода IncrementFloat.

Зададим в качестве нижнего входного значения нода float / float значение 6. Это значит, что куб станет полностью красным, когда игрок соберёт шесть бананов.

Но есть небольшая проблема. Когда игрок соберёт больше шести бананов, то alpha станет больше единицы. Чтобы исправить это, воспользуемся нодом Clamp (float) для ограничения alpha интервалом от 0 до 1.

Добавьте нод Clamp (float) и соедините контакт Value с правым контактом нода float / float.

Теперь, когда у нас есть alpha, настало время для передачи её значения материалу.

Обновление материала

Перетащите переменную CubeMaterial в Event Graph и выберите Get.

Затем перетащите контакт переменной CubeMaterial на пустое пространство и отпустите левую клавишу мыши. При этом появится список нодов, которые могут использовать переменную этого типа. Любой выбранный нод будет автоматически соединён с переменной. Добавьте нод Set Scalar Parameter Value. Этот нод будет задавать указанному параметру передаваемое значение.

Теперь нужно указать обновляемый параметр. Выберите в поле Parameter Name значение ColorAlpha. Это параметр, который мы создали в материале куба.

Соедините результат нода Clamp (float) с контактом Value нода Set Scalar Parameter Value.

Наконец, соедините нод IncrementFloat с нодом Set Scalar Parameter Value.

Порядок выполнения будет следующим:

Нажмите на Play и начните собирать бананы. Куб сначала будет белым и постепенно станет краснеть при собирании бананов. Когда вы соберёте шесть бананов, он станет полностью красным.

Куда двигаться дальше?

Готовый проект можно скачать здесь.

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

Если вы хотите больше узнать о материалах, то рекомендую прочитать страницу Material Inputs в документации Unreal Engine. Изучение возможностей входов позволит вам создавать более сложные материалы.

Советую поэкспериментировать с материалами и протестировать разные ноды (их там много). Лучший способ обучения — попробовать всё самому.

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

Руководство по пользовательскому интерфейсу Unreal Engine 4

В этом уроке, который посвящен подробному изучению пользовательского интерфейса Unreal Engine 4, вы научитесь, как создавать, отображать и обновлять HUD.

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

Вы можете создать пользовательский интерфейс в программе Unreal Engine 4, используя Unreal Motion Graphics (UMG). UMG позволяет легко конструировать любые элементы UI, просто перемещая метки, кнопки и другие объекты пользовательского интерфейса в нужное вам место.

Из этого урока вы узнаете:

Обратите внимание: вы будете использовать Blueprints в этом уроке. Если вам необходимо освежить знания об этих инструментах, пожалуйста, вернитесь к предыдущим частям руководства прежде чем продолжить.

Это занятие является частью серии, которая состоит из 10 уроков, посвященных Unreal Engine:

Начало работы

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

После этого перейдите в папку проекта и откройте GeometryCatcher.uproject.

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

Первое, что вы должны будете сделать, это создать HUD, который отображает две вещи:

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

Что нужно знать о виджетах

Виджет — это элемент пользовательского интерфейса, который предоставляет своего рода визуальную функциональность пользовательскому интерфейсу. Например, виджет Button дает возможность использовать объект, который пользователь может видеть и нажимать.

Сам виджет не должен быть видимым, например, виджет Grid Panel предназначен для разделения рабочего пространства между его содержимым. Пользователь не может видеть сетку разделения, но может видеть ее эффект.

Кроме того, виджеты также могут содержать другие виджеты. Перед вами пример такого случая, когда пользовательский виджет также содержит «Текст» (метка «Имя») и «Текстовое поле»:

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

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

Процесс создания виджета

Перейдите в меню Content Browser и найдите там папку пользовательского интерфейса. Нажмите кнопку «Add New» и выберите «User Interface\Widget Blueprint». Переименуйте новый элемент в WBP_HUD:

Дважды кликните мышью по WBP_HUD, чтобы открыть его в редакторе UMG UI.

UMG UI редактор

Окно UMG UI редактора состоит из семи основных элементов:

Создание текстового виджета

Текстовые виджеты идеально подходят для отображения числовой информации, такой как счетчик очков и таймер оставшегося/прошедшего времени.

Перейдите на панель «Palette» и найдите там виджет «Text». Добавьте его, удерживая левую кнопку мыши и перетаскивая значок в свободную область панели «Designer».

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

Переименуйте виджет в CounterText, выбрав его и перейдя на панель «Details». Введите название CounterText в текстовое поле, расположенное вверху.

Вы можете расположить новый виджет в любом месте, перетаскивая его при помощи мышки.

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

Установка расположения и границ виджета также происходит на панели «Details». Сейчас вам нужно ввести следующие свойства и значения для CounterText:

Обратите внимание, что сейчас текст занимает лишь небольшую часть поля:

Вы можете изменить размер шрифта, перейдя на панель «Details» и перейдя в раздел «Appearance». Справа от свойства Font есть текстовое поле для установки размера шрифта.

Установите размер шрифта = 68:

Теперь нужно улучшить наш счетчик, добавив значок рядом с ним.

Создание изображения для виджета

Графическое изображение для виджета — это простой способ отображения графики в вашем пользовательском интерфейсе, например, при создании значков.

Создайте новый виджет Image и назовите его CounterIcon. Установите Положение X = 75 и Положение Y = 50, чтобы он расположился рядом с объектом CounterText:

Чтобы выбрать и установить определенное изображение, перейдите на панель «Details» и найдите раздел «Appearance». Теперь откройте свойства Brush и выберете в появившемся списке пункт T_Counter.

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

Вместо изменения размера виджета вы можете использовать функцию «Size To Content». Это автоматически изменит размер виджета в соответствии с его содержимым, в данном случае с изображением.

Не покидая панель «Details», перейдите в раздел «Slot» (Canvas Panel Slot) и установите флажок рядом с пунктом Size To Content:

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

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

Для чего нужны анкоры

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

В приведенном ниже примере каждое изображение привязано к одной точке (ближайшему углу):

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

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

В приведенном ниже примере объект привязан к верхнему левому и верхнему правому углам:

По вертикали полоса перемещается вверх без изменений ее размера или длинны. Это происходит потому, что данный объект имеет только один анкор на оси Y (вверху). Тем не менее, размер полоски изменяется при горизонтальном перемещении, поскольку он имеет две опорные точки на оси X.

Так называемый Anchor Medallion представляет местоположение вашего анкора. Эта функция будет отображаться всякий раз, когда у вас будет выбран виджет:

Анкоры для CounterText и CounterIcon уже установлены в правильном положении, поэтому вам не нужно ничего изменять.

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

Создание таймера

Создайте новый текстовый виджет, назовите его TimerText и установите для него следующие свойства:

Теперь установите анкор в верхнем правом углу, щелкнув левой кнопкой мыши и выбрав соответствующую область на Anchor Medallion (сейчас вам нужен верхний правый угол):

Обратите внимание, каким образом теперь обновились координаты:

Далее создайте виджет Image, назовите его TimerIcon и присвойте ему следующие значения:

Вместо того, чтобы снова устанавливать анкор с помощью Anchor Medallion, вы можете использовать шаблоны. Для этого перейдите на панель «Details» и откройте список, который находится рядом с раскрывающийся список рядом с пунктом «Анкоры». Вам нужно выбрать третий шаблон, у которого квадрат расположен справа вверху.

Теперь макет для пользовательского интерфейса завершен. Вы можете увидеть, как действуют анкоры, эмулируя экран разных размеров. Перейдите на панель «Designer» и выберете пункт «Screen Size»:

Выбор определенного значения изменит размер WBP_HUD для соответствия определенному устройству. Ниже показано, как HUD будет выглядеть на iPad Air, обратите внимание, что виджеты тут расположены немного ближе друг к другу:

Отображение HUD

Чтобы сохранить изменения, нажмите Compile и затем вернитесь в главный редактор. Перейдите в папку «Чертежи» и дважды щелкните мышкой BP_GameManager, чтобы открыть файл.

HUD должен быть виден сразу после того, как начнется игра. Для этого вы можете использовать узел Event BeginPlay. Найдите его и добавьте в последовательность еще один узел под названием Create Widget, чтобы он мог создать экземпляр указанного виджета.

Теперь в меню рядом с входом Class выберете пункт WBP_HUD:

Для того, чтобы HUD корректно отображалось, вам нужно использовать узел Add to Viewport. Щелкните левой кнопкой мыши и перетащите выход «Return Value» узла «Create Widget» в пустое место. Появится контекстное меню в котором вам нужно выбрать функцию Add to Viewport.

Давайте повторим порядок действий:

Для сохранения результата, нажмите Compile, вернитесь в главный редактор и нажмите Play, чтобы посмотреть, как работает новый HUD:

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

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

Использование ссылок

Чтобы получить быстрый доступ к какому-то определенному экземпляру очень удобно использовать ссылки к нему. Представьте, что у вас была одна коробка с шариком. Если бы вы хотели взять этот мяч и рассмотреть его, то легко бы это сделали – коробка то всего одна.

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

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

Создание переменной

Откройте WBP_HUD и переключитесь в режим редактора, выбрав график:

Перейдите к вкладке My Blueprint и создайте новую переменную с именем GameManager.

Теперь вам нужно перейти к панели «Details» и щелкнуть по списку рядом с «Variable Type». Найдите BP_GameManager и выберите BP Game Manager\Object Reference.

Использование ссылок

Для того, чтобы сохранить результат, нажмите Compile и затем откройте BP_GameManager.

Найдите узел «Create Widget» и перетащите значок «Return Value» в пустую область. Вам нужно выбрать команду «Set Game Manager» в появившемся меню и связать узел Add to Viewport с узлом Set Game Manager.

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

Следующим шагом создайте узел Self и подключите его к левому выводу узла Set Game Manager. Узел Self должен иметь свойство Get a reference to self:

Теперь, когда вы создали WBP_HUD, он будет иметь ссылку на BP_GameManager.

Функции

В Blueprints функции представляют собой график, аналогичный графику событий. Только в отличие от графика событий, вы можете вызывать функцию, используя отдельный узел. Давайте разберемся в преимуществе этого метода.

Организация

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

Внимательно посмотрите на Event BeginPlay в разделе BP_GameManager: тут есть две функции Restart и SetUpCamera.

Вот как будет выглядеть этот раздел без использования функций:

Согласитесь, график выглядит немного пустовато.

Возможность повторного использования

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

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

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

Обновление данных виджета

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

Для сохранения прогресса нажмите Compile и откройте WBP_HUD, переключившись в режим редактора. Вам необходимо выбрать CounterText и перейти к панели «Details». Установите флажок в квадрате «Variable», расположенному в самом верху окна.

Теперь вы сможете обновлять значение CounterText. Следующим шагом является создание функции для изменения текста в соответствии с необходимым значением.

Создание функции обновления данных

Вам необходимо вернуться в режим редактирования графика и перейти к вкладке «My Blueprint». Нажмите знак «+» справа от раздела «Functions»:

Таким образом вы создадите новую функцию и построит новый график. Переименуйте функцию в UpdateCounterText.

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

Для того, чтобы CounterText корректно отображал переменную ShapesCollected, вам нужно создать новое соединение. Переместите с помощью мыши переменную GameManager в область графика и также поместите в свободную область новый значок, присвоив ему свойство «Get Shapes Collected»:

Чтобы установить значение текста, вам нужно использовать узел SetText (Text). Перетащите переменную CounterText в график событий и добавьте новый узел SetText (Text):

SetText (Text) принимает только данные типа Text, однако переменная ShapesCollected имеет тип Integer, для которого программа выполняет автоматическое преобразование данных.

Подключите переменную ShapesCollected к выходу In Text узла Set Text (Text). Смотрите, Unreal автоматически создает новый узел ToText (int):

Для завершения создания функции подключите узел Entry к узлу Set Text (Text):

Резюмируя:

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

Вызов функции обновления данных

Лучшее время для появления UpdateCounterText – момент, который наступает сразу после того, как игра увеличивает значение ShapesCollected. Для этого вы будете использовать функцию IncrementShapesCollected, которая будет это делать автоматически. Каждый раз, когда падающие фигуры будут соприкасаться с платформой, эта функция будет срабатывать.

Нажмите Compile и вернитесь к окну BP_GameManager.

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

После того, как вы создадите переменную, переименуйте ее в HUDWidget:

Теперь перетащите правой кнопкой мыши узел Pin HUDWidget и отпустите его на пустом месте графика. Добавьте новый узел UpdateCounterText, чтобы обеспечить корректное отображение данных CounterText значения ShapesCollected при каждом запуске игры.

Вернитесь к панели «My Blueprint» и найдите там раздел «Functions». Дважды щелкните на IncrementShapesCollected, чтобы открыть его график:

Перетащите переменную HUDWidget в график и добавьте узел UpdateCounterText, подключив его следующим образом:

Теперь, когда будет выполняется команда IncrementShapesCollected, она будет увеличивать значение ShapesCollected и затем вызывать команду UpdateCounterText. Эта же функция выполняет обновление CounterText до значения ShapesCollected.

Для того, чтобы сохранить результат, нажмите Compile и закройте BP_GameManager. Нажмите Play и попробуйте поймать несколько падающих фигур, чтобы увидеть, как теперь работает виджет CounterText:

Зачем нужны привязки

Так называемые привязки (Bindings) позволяют автоматически обновлять определенные свойства виджета. Чтобы быть привязываемым, свойство должно иметь «Bind drop-down».

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

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

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

Откройте WBP_HUD и переключитесь в режим редактора. Вам нужно выбрать тут TimerText и перейдите раздел «Content» на панели «Details». Посмотрите, для свойства Text можно создать привязку, указав соответствующую команду в списке меню «Bind drop-down».

Это создаст новую функцию и график для нее. Переименуйте эту функцию в UpdateTimerText.

Функция будет иметь узел Return с выводом Return Value типа Text. TimerText будет отображать любой текст, который вы впишете в это поле.

Переместите GameManager в график, а затем создайте для него переменную TimeRemaining. Подключите новую переменную к выходу Return Value узла Return. Как и в прошлый раз, Unreal автоматически добавит узел преобразования.

Резюмируя:

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

Что делать дальше?

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

Теперь, когда вы знакомы с основами UMG, вы сможете самостоятельно создавать несложные элементы интерфейса. Попробуйте самостоятельно создать какие-нибудь виджеты для этой или любой другой игры.

С другими типами виджетов вы можете ознакомиться на странице Widget Type Reference документации Unreal Engine.

В следующем уроке этой серии вы узнаете, как самостоятельно создать простую игру!

Руководство по созданию собственных шейдеров в Unreal Engine

Благодаря системе нодов редактор материалов является отличным инструментом для создания шейдеров. Однако у него есть свои ограничения. Например, там невозможно создавать циклы и конструкции switch.

К счастью, эти ограничения можно обойти с помощью написания собственного кода. Для этого существует нод Custom, позволяющий писать код HLSL.

В этом туториале вы научитесь следующему:

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

В туториале также предполагается, что вы знакомы с похожими на C языками, такими как C++ или C#. Если вам знакомы синтаксически схожие языки, например, Java, то вы тоже сможете разобраться.

Примечание: этот туториал является частью серии туториалов, посвящённых шейдерам:

Приступаем к работе

Начните с загрузки материалов этого туториала (скачать их можно здесь). Распакуйте их, перейдите в CustomShadersStarter и откройте CustomShaders.uproject. Вы увидите следующую сцену:

Сначала мы воспользуемся HLSL для снижения насыщенности изображения сцены. Для этого нам нужно создать и применить нод Custom в материале постобработки.

Создание нода Custom

Перейдите в папку Materials и откройте PP_Desaturate. Этот материал мы будем редактировать, чтобы получить эффект уменьшения насыщенности.

Для начала создайте нод Custom. Как и другие ноды, он может иметь несколько входов, но только всего один выход.

Затем выберите нод Custom и перейдите в панель Details. Вы увидите следующее:

Вот, что делает каждое из свойств:

Для снижения насыщенности изображения замените текст внутри Code на следующий:

Наконец, соединим всё следующим образом:

Вам может быть интересно, откуда взялся код снижения насыщенности. Когда мы используем нод материала, он преобразуется в HLSL. Если просмотреть сгенерированный код, то можно найти соответствующий фрагмент и скопипастить его. Именно так я преобразовал нод Desaturation в HLSL.

В следующем разделе мы узнаем, как преобразовывать нод материала в HLSL.

Преобразование нодов материалов с HLSL

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

Для начала перейдите в папку Maps и откройте GaussianBlur. Затем вернитесь в Materials и откройте PP_GaussianBlur.

Unreal генерирует HLSL для всех нодов, участвующих в конечном выводе. В нашем случае Unreal сгенерирует HLSL для нода SceneTexture.

Чтобы просмотреть код HLSL всего материала, выберите Window\HLSL Code. При этом откроется отдельное окно со сгенерированным кодом.

Примечание: если окно HLSL Code окажется пустым, то необходимо будет включить в Toolbar Live Preview.

Так как сгенерированный код имеет длину в несколько тысяч строк, то по нему достаточно сложно перемещаться. Чтобы упростить поиск, нажмите на кнопку Copy и вставьте код в текстовый редактор (я пользуюсь Notepad++). Затем закройте окно HLSL Code.

Так как это материал постобработки, нам важен только EmissiveColor. Как вы видите, его значение — это значение Local1. Переменные вида LocalX — это локальные переменные, которые функция использует для хранения промежуточных значений. Если посмотреть чуть выше выходов, то можно увидеть, как движок вычисляет каждую локальную переменную.

Теперь, когда у нас есть нужная функция, давайте её протестируем.

Использование функции SceneTextureLookup

Для начала зададимся вопросом — что делают параметры? Вот сигнатура SceneTextureLookup() :

Вот, что делает каждый параметр:

Для тестирования мы будем выводить World Normal. Перейдите в редактор материалов и создайте нод Custom с именем Gaussian Blur. Затем вставьте в поле Code следующее:

Так мы выведем в текущий пиксель World Normal. GetDefaultSceneTextureUV() будет получать UV текущего пикселя.

Примечание: до версии 4.19 можно было получать UV, передавая в качестве входа нод TextureCoordinate. В 4.19 правильным способом будет использование GetDefaultSceneTextureUV() и передача нужного индекса.

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

Далее отсоедините нод SceneTexture. Затем присоедините Gaussian Blur к Emissive Color и нажмите на Apply.

На этом этапе вы получите следующую ошибку:

К счастью, решить эту проблему просто. Выберите для нода SceneTexture ту же текстуру, из которой мы выполняем сэмплирование. В нашем случае нужно выбрать WorldNormal.

Затем соедините его с Gaussian Blur. Наконец, нам нужно задать контакту входа имя, отличающееся от None. В этом туториале мы выберем SceneTexture.

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

Нажмите Apply и вернитесь в основной редактор. Теперь вы увидите нормаль мира для каждого пикселя.

Пока редактировать код в ноде Custom вполне удобно, потому что мы работаем с небольшими фрагментами. Однако когда наш код начнёт разрастаться, то поддерживать его будет сложнее.

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

Использование внешних файлов шейдеров

Откройте папку проекта и создайте новую папку Shaders. Папка проекта должна выглядеть примерно так:

Затем перейдите в папку Shaders и создайте новый файл. Назовите его Gaussian.usf. Он будет нашим файлом шейдера.

Примечание: файлы шейдеров должны иметь расширение .usf или .ush.

Откройте Gaussian.usf в текстовом редакторе и вставьте показанный ниже код. После каждого изменения сохраняйте файл.

Это тот же код, что и раньше, но он выводит Diffuse Color.

Чтобы Unreal смог распознать новую папку и шейдеры, нам нужно перезапустить редактор. После перезапуска перейдите к GaussianBlur. Затем повторно откройте PP_GaussianBlur и замените код в Gaussian Blur на следующий:

Теперь после компиляции компилятор заменит первую строку содержимым Gaussian.usf. Заметьте, что мы не должны заменять Project именем своего проекта.

Нажмите на Apply и вернитесь в основной редактор. Теперь вместо нормалей мира вы увидите диффузные цвета.

Теперь, когда всё настроено для удобной разработки шейдеров, настало время создания гауссова размытия (Gaussian blur).

Примечание: так как это не туториал по гауссовому размытию, я не буду подробно его объяснять. Если вы хотите узнать подробности, то изучите статьи Gaussian Smoothing и Calculating Gaussian Kernels.

Создание гауссова размытия

Как и в туториале про toon-контуры, в этом эффекте будет использоваться свёртка. Конечный выход — это среднее значение всех пикселей в ядре.

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

При использовании нодов материалов свёртка неидеальна из-за большого количества необходимых сэмплов. Например, при ядре 5×5 нам потребуется 25 сэмплов. Удвойте размеры до 10×10, и количество сэмплов увеличится до 100! На этом этапе граф нодов будет походить на тарелку со спагетти.

Создание параметра радиуса

Сначала вернёмся к редактору материалов и создадим новый ScalarParameter под названием Radius. Зададим ему значение по умолчанию 1.

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

Далее создадим новый вход для Gaussian Blur и назовём его Radius. Затем создадим нод Round и соединим всё следующим образом:

Round необходим для того, чтобы размеры ядра всегда были целыми числами.

Теперь пора приступить к кодингу! Так как для каждого пикселя нам нужно вычислять гауссово размытие дважды (вертикальное и горизонтальное смещения), то логично будет превратить это в функцию.

При использовании нода Custom мы не можем создавать функции стандартным образом, потому что компилятор копирует наш код в функцию. Так как мы не можем определять функции внутри функции, то получим ошибку.

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

Создание глобальных функций

Как сказано выше, компилятор в буквальном смысле копипастит текст из нода Custom в функцию. То есть если у нас есть следующее:

то компилятор вставит это в функцию CustomExpressionX. Он даже не поставит отступ!

Посмотрите, что произойдёт, если мы используем такой код:

Сгенерированный HLSL превратится в такой:

Как видите, MyGlobalVariable и MyGlobalFunction() не находятся внутри функции. Это делает их глобальными, то есть мы можем использовать их где угодно.

Примечание: Заметьте, что во входном коде отсутствует последняя скобка. Это важно, потому что компилятор вставляет в конец скобку. Если оставить скобку, то в результате у нас будет две скобки и мы получим ошибку.

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

Создание гауссовой функции

В этом туториале мы поместим гауссову функцию в отдельный нод Custom. Создайте новый нод Custom и назовите его Global.

Затем замените текст Code на следующий:

Calculate1DGaussian() — это упрощённая 1D-гауссиана в виде кода.

Чтобы эта функция была доступна, нам нужно использоватьGlobal где-нибудь в графе материала. Проще всего это сделать, умножив Global на первый нод графа. Так мы гарантируем, что глобальные функции определяются до того, как мы используем их в других нодах Custom.

Для начала задайте для Output Type нода Global значение CMOT Float 4. Мы должны сделать это, потому что мы будем выполнять умножение на SceneTexture, имеющую тип float4.

Далее создадим Multiply и соединим всё следующим образом:

Нажмите на Apply, чтобы выполнить компиляцию. Теперь все последующие ноды Custom смогут использовать функции, определённые в Global.

Следующим шагом будет использование цикла for для сэмплирования каждого пикселя в ядре.

Сэмплирование нескольких пикселей

Откройте Gaussian.usf и замените код на следующий:

Вот, для чего нужна каждая из переменных:

Таким образом мы создадим сетку, центрированную на текущем пикселе. Её размеры задаются как 2r + 1. Например, если радиус равен 2, то сетка будет иметь размеры (2 * 2 + 1) на (2 * 2 + 1) или 5×5.

Далее нам нужно аккумулировать цвета и веса пикселей. Для этого добавим следующий код во внутренний цикл for :

Вот, что делает каждая из строк:

И так мы реализовали гауссово размытие! Закройте Gaussian.usf и вернитесь в редактор материалов. Нажмите на Apply и закройте PP_GaussianBlur. Используйте PPI_Blur, чтобы протестировать разные радиусы размытия.

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

Ограничения

Несмотря на всю мощь нода Custom, у него есть свои недостатки. В этом разделе я расскажу о некоторых ограничениях и изъянах его использования.

Доступ к рендерингу

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

Совместимость версий движка

Оптимизация

Вот, что говорит Epic про оптимизацию:

Использование нодов Custom делает невозможным сворачивание констант и может приводить к значительно большему количеству инструкций по сравнению с аналогичной версией, построенной на нодах! Сворачивание констант — это оптимизация, используемая UE4 для снижения при необходимости количества шейдерных инструкций.

Например, цепочка выражений Time >Sin >Mul by parameter > Add к чему-то может и будет свёрнута движком UE4 в одну инструкцию, конечное Add. Это возможно, потому что все входы этого выражения (Time, parameter) являются константами на протяжении всего вызова отрисовки, то есть не меняются для каждого пикселя. UE4 не может сворачивать ничего в ноде Custom, что может приводит к созданию менее эффективных шейдеров по сравнению с аналогичными версиями на основе готовых нодов.

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

Куда двигаться дальше?

Готовый проект можно скачать здесь.

Если вы хотите глубже разобраться в ноде Custom, то рекомендую изучить блог Райана Брука. У него есть посты, подробно объясняющие использование нода Custom для создания raymarching и других эффектов.

Unreal Engine 4: использование материалов

Из этой части самоучителя Unreal Engine 4 вы узнаете, как изменять в редакторе текстуру материалов, создавать новые материалы и научитесь их обновлять в готовой игре.

Также, как и в реальном мире, в любой игре есть множество объектов — каждый со своим внешним видом и свойствами. В Unreal Engine они определяются материалами – цвет объектов, блеск или матовость, прозрачность и т.п.

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

В этом уроке вы научитесь:

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

Это занятие является частью серии, которая состоит из 10 уроков, посвященных Unreal Engine:

Введение

Скачайте стартовый проект, разархивируйте и откройте его с помощью программы. Для этого перейдите в папку проекта и найдите файл BananaCollector.uproject.

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

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

Открыв файл, вы увидите небольшую игровую локацию, в которой размещены бананы. Нажмите Play, чтобы попробовать управлять персонажем, который на данный момент представлен в виде красного куба, при помощи клавиш W, A, S и D. Вы также можете собирать бананы вашим персонажем.

Чтобы изменить яркость цвета банана вам необходимо перейти в папку «Materials» и дважды кликните мышью п файлу M_Banana, чтобы открыть его в редакторе материалов.

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

Изменение структуры объекта

По своей сути, текстура — это изображение, а изображение — это набор пикселей. В цветном изображении цвет пикселя определяется его красным (R), зеленым (G) и синим (B) каналами.

Ниже приведен пример изображения размером 2 × 2 пикселя с помеченными значениями «RGB»:

Примечание: диапазон каналов RGB в Unreal Engine составляет от 0,0 до 1,0 единиц. Однако в большинстве других программ этот же диапазон составляет уже от 0 до 255 единиц. По сути, это просто разные способы отображения одной и той же графической информации, однако это не означает, что цветовой диапазон Unreal Engine меньше, а качество структур хуже.

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

Ниже приведен пример фиксации каждого канала в диапазоне от 0,4 до 1,0. Таким образом минимальное значение каждого канала становится выше, что делает каждый пиксель текстуры светлее.

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

Узел умножения (Multiply)

Узел Multiply он умножает один вход на другой, что это значит: используя умножение вы можете изменить яркость пикселя, не влияя на его оттенок или насыщенность цвета. Ниже приведен пример уменьшения яркости вдвое путем умножения каждого канала на 0,5:

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

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

В этом случае применение эффекта маски сработало, потому что шкала серого представляет диапазон от 0 (черный) до 1 (белый):

Белая область изображения имеет максимальную яркость, потому что каналы умножены на 1. Серые области этого изображения темнее, потому что каналы умножены на значения меньше 1. Черные области соответственно не имеют яркости, потому что каналы изображения умножены на 0.

Настройка яркости текстуры

Для продолжения вам необходимо разорвать связь между узлом образца текстуры и выводом базового цвета. Вы можете сделать это, щелкнув правой кнопкой мыши по любому контакту и выбрать команду «Break Link». Кроме того, вы также можете удерживая клавишу Alt щелкнуть левой кнопкой мыши на контакте (белая лини между узлами).

Теперь создайте два новых узла — Multiply и Constant. Вы можете сделать это быстро, удерживая клавишу M (для создания узла Multiply) или клавишу 1 (для создания узла Constant), а затем щелкните мышью по пустой области и свяжите эти узлы следующим образом:

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

В данный момент ваша текстура черного цвета, потому что множитель установлен в нулевое положение (умножение на ноль, как вы знаете, дает ноль). Чтобы изменить значение множителя, вам нужно выбрать узел «Constant» и перейдите на панель «Details». Установите значение = 5.

Нажмите кнопку «Apply» и вернитесь в главный редактор. Посмотрите, бананы стали намного светлее:

Что такое Material Instances (экземпляр материала)

Material Instances — это небольшая копия этого же материала. Любые изменения, сделанные в базовом материале, также происходят в его экземпляре.

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

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

Работа с экземплярами подходит для того, чтобы:

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

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

Настройка параметров материала

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

Далее вам необходимо создать еще один узел Scalar Parameter. Он будет содержать всего одно значение, которое можно редактировать в экземпляре данного материала (M_BAnana). Для быстрого создания узла удерживайте клавишу S и щелкните мышью на любом пустом пространстве рабочей области. После создания подключите новый узел к выходу Hue Shift Percentage (S) на узле HueShift.

Теперь нужно обозначить новые параметры, выбрав узел «Scalar Parameter» и перейдя на панель «Details». Измените имя параметра на HueShiftPercentage.

Кроме того, вы также можете преобразовать константы в скалярные параметры. Для этого щелкните правой кнопкой мыши узел «Constant», который вы добавили ранее, и выберите команду «Convert to Parameter», после чего введите новое название «Brightness».

Теперь нажмите кнопку Apply и закройте редактор материалов.

Создание Material Instances

Вам нужно перейти в Content Browser и найти папку «Materials», в которой находится материал M_Banana. Щелкните по материалу правой кнопкой мыши и выберите команду «Create Material Instance». Назовите новый объект MI_Banana_Green.

Дважды щелкните MI_Banana_Green, чтобы открыть файл в редакторе Material Instances.

Этот редактор состоит из трех рабочих панелей:

Чтобы увидеть изменения которые произошли с вашим материалом, вам нужно перейти на панель «Details» и найти раздел «Previewing». Щелкните левой кнопкой мыши раскрывающийся список рядом с Preview Mesh и выберите SM_Banana. Теперь вместо сферы вы увидите банан.

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

Установите параметр яркость на 0,5 и параметры HueShiftPercentage на 0,2. У вас должен получится приблизительно такой цвет:

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

Использование Material Instances

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

Выберите любой банан и перейдите на панель «Details». В списке найдите компонент StaticMesh.

Данные панели «Details» обновятся со свойствами компонента StaticMesh. Измените материал на MI_Banana_Green.

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

Динамически меняющийся материал

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

Перед созданием Material Instances вам необходимо настроить материал куба. Для этого перейдите в папку Materials и откройте файл M_Cube. Вам необходимо создать способ создавать и менять цвета. Посмотрите на узел Constant3Vector, подключенный к базовому цвету. Он идеально подходят для выбора цветов, потому что они имеет красный, зеленый и синий каналы.

Красный цвет уже создан, поэтому вам необходимо создать белый цвет. Добавьте еще один узел Constant3Vector, это можно сделать, удерживая клавишу «3» и щелкнув левой кнопкой мыши пустое место рабочей области.

Откройте палитру цветов, дважды щелкнув мышью по Constant3Vector:

Найдите белый цвет, используя ползунки или введя значение 1,0 в каналы R, G и B. После этого нажмите кнопку ОК.

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

Что такое линейная интерполяция?

Линейная интерполяция — это способ найти значения между A и B. Например, вы можете использовать линейную интерполяцию, чтобы найти значение, которое находится на половине отрезка между значениями 100 и 200.

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

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

Использование узла LinearInterpolate

Добавьте новый узел LinearInterpolate, для этого также можно использовать клавишу «L» и мышку.

Затем создайте параметр узла Scalar Parameter и назовите его ColorAlpha. Подключите ваши узлы как показано на изображении (обратите внимание, где теперь находится белый цвет):

Примечание: узел LinearInterpolate будет выводить значение входа A, потому что начальное значение альфа равно 0. Когда альфа приближается к 1, выход приблизится к значению входа B.

Нажмите кнопку Apply и закройте редактор материалов. Если вы нажмете кнопку Play, вы увидите, что куб теперь стал белым.

Чтобы куб мог менять цвета, необходимо отредактировать параметр ColorAlpha.

Динамичное изменение цвета Material Instances

Динамичный Material Instances возможно редактировать прямо во время воспроизведения игровой сцены. Для этого вы можете использовать Blueprints или C++.

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

Кроме того, каждый Material Instances можно редактировать по отдельности, используя индивидуальные настройки.

Посмотрите, как это выглядит на практике:

Создание Material Instances

Находясь в Content Browser перейдите в папку «Чертежи» и дважды щелкните BP_Player, чтобы открыть ее.

Убедитесь, что вы находитесь в разделе Event Graph и найдите узел Event BeginPlay.

Добавьте узел Create Dynamic Material Instance (StaticMesh). Он будет одновременно создавать и применять новый Material Instances материала к объекту.

Теперь вам нужно указать, какой материал должен использовать куб. Щелкните раскрывающийся список под пунктом «Source Material» и выберите «M_Cube».

Чтобы потом было легче использовать материал, мы рекомендуем хранить его в переменной. Самый простой способ сделать это — щелкнуть правой кнопкой мыши на значке «Return Value» в узле «Create Dynamic Material Instance» и выбрать пункт Promote to Variable.

Если вы обратите внимание на вкладку My Blueprint, то увидите, что там появилась новая переменная. Переименуйте ее в CubeMaterial нажав клавишу F2.

Теперь соедините узел Event BeginPlay с узлом Create Dynamic Material Instance.

Примечание: при создании BP_Player, в программе автоматически создается dynamic material и применяется к компоненту StaticMesh. Затем Unreal сохраняет материал в качестве переменной с именем CubeMaterial.

Создание счетчика бананов

Рядом с узлом Event BeginPlay есть настройки, с помощью которых вы будете обновлять счетчик бананов и цвет материала куба.

Узел On Component Begin Overlap будет выполняться, когда куб пересечет другой объект. Затем узел Cast to BP_Banana проверит, является ли этот объект бананом, если да, то узел DestroyActor уничтожит его, поэтому он исчезнет из локации.

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

Создайте новую переменную Float, назовите ее BananaCounter и выберете пункт Get, наведя мышь на переменную:

Теперь, чтобы увеличить значение на единицу, добавьте еще один узел IncrementFloat и подключите к нему BananaCounter:

Затем вам нужно подключить узел DestroyActor к IncrementFloat:

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

Если бы вы сейчас использовали BananaCounter в качестве альфы, то получили бы неоднозначный результат. Дело в том, что узел LinearInterpolation имеет значение в диапазоне от 0 до 1, и вы можете использовать нормализацию для преобразования счетчика в диапазоне только от 0 до 1.

Чтобы ввести нормализацию, разделите BananaCounter на максимальное значение. Это значение — сколько бананов нужно собрать игроку, прежде чем куб станет полностью красным. Добавьте узел float/float и соедините его верхний контакт с оставшимся контактом узла IncrementFloat:

Установите нижний вход узла float/float на 6. Это означает, что куб будет полностью красным, когда игрок соберет 6 бананов.

Однако, если более 6 бананов, альфа будет иметь значение больше 1. Чтобы исправить это, вам нужно использовать узел Clamp (float), чтобы альфа сохраняла значение в от 0 до 1. Добавьте узел Clamp (float) и соедините Value с узлом float/float.

Обновление материала

Перетащите переменную CubeMaterial в поле Event Graph и нажмите «Get». После этого вам нужно вывести список узлов, которые могут использовать переменные типа CubeMaterial. Добавьте узел «Set Scalar Parameter Value», чтобы установить нужный параметр в указанное значение.

Теперь необходимо указать, какой параметр будет обновляться. Впишите в поле «Parameter Name» значение ColorAlpha.

Соедините узел Clamp (float) с выходом Value узла Set Scalar Parameter Value.

В завершении соедините узел IncrementFloat с узлом «Set Scalar Parameter Value»:

Подробная описание функций всех узлов:

Проверьте, все ли верно, нажмите кнопку «Compile», а затем закройте редактор Blueprint.

Нажмите Play и попробуйте собрать бананы. Посмотрите, в самом начале куб имеет белый цвет, но постепенно его окрас меняется. Как только вы соберете 6 бананов, он станет полностью красным.

Что делать дальше?

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

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

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

Если вы хотите узнать больше о материалах, рекомендуем вам статью Material Inputs из документации Unreal Engine.

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

Руководство по Unreal Engine 5 для начинающих

The Ultimate Guide to Unreal Engine 5 For Complete Beginners

Я выбрал основным проектом в этом курсе 3D-платформер от первого лица, потому что он имеет обширную библиотеку концепций разработки игр, которые мы можем реализовать и изучить.

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

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

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

Раздел 1: Введение

Мы начнем с загрузки Epic Games Launcher. Качаем Unreal Engine 5 и закладываем фундамент. Мы немного разберемся в истории Unreal Engine и сделаем нашу Первую Игру просто для того, чтобы поднять себе настроение.

Раздел 2: Создание редактора уровней виртуальных миров

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

Раздел 3: Unreal Architecture Actors

В этом разделе мы узнаем об Актерах. Мы разберемся со статическими меш-актерами, геометрическими кистями, объемами и материалами. Мы заканчиваем тем, что создаем и учимся настраивать освещение и атмосферу вместо того, чтобы использовать то, что нам дали.

Раздел 4: CyberSpy 3027 — Строим наш мир

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

Раздел 5: Визуальные сценарии Blueprint

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

Unreal Engine 4 Blueprints Tutorial

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

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

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

В этом уроке вы научитесь использовать Blueprints для:

Примечание: В этом руководстве предполагается, что вы уже знаете, как ориентироваться в интерфейсе Unreal Engine 4. Из предыдущего урока вы должны были узнать основные понятия Blueprint, такие как компоненты и узлы. При необходимости вы можете посмотреть материал предыдущего занятия еще раз, чтобы освежить ваши знания. Также, если вам нужна переподготовка, то мы рекомендуем ознакомьтесь с нашим руководством для начинающих по Unreal Engine 4.

Это учебное руководство также основано на использовании векторов. Если Вы не знакомы с векторами, я рекомендую эту статью с gamedev.net

Это занятие является частью серии, которая состоит из 10 уроков, посвященных Unreal Engine:

Начало работы

В первую очередь вам необходимо скачать и разархивировать стартовый проект.

Для того, чтобы открыть его, вам нужно перейти в корневую папку, где находится скаченный файл BananaCollector.uproject и открыть его.

Примечание: Не пугайтесь, если вы увидите системное сообщение о том, что проект был создан с использованием более ранней версии программы Unreal, это нормально (для редактора часто выходят обновления).

Вы можете выбрать один из вариантов: «открыть копию», или «преобразовать» файл.

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

Для вашего удобства все файлы проекта разбиты на категории и помещены в соответствующие папки, как на этом изображении:

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

Создание персонажа

Для того, чтобы создать игрового персонажа вам нужно в меню Content Browser перейдите в папку «Blueprints» и нажать кнопку «Add New», выбрав команду «Blueprint Class».

Для того, чтобы вы могли в дальнейшем вносить редактируемые свойства для персонажа, вам необходимо выбрать класс «Pawn». Итак, выбирайте Pawn в появившемся окне и переименуйте его в «BP_Player».

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

Прикрепление камеры

Камера является своего рода способом для игрока осматривать игровое пространство. Сейчас вам нужно будет создать камеру с видом сверху. Для этого откройте двойным нажатием левой кнопки мыши BP_Player в Content Browser. Теперь вы можете приступить к редактированию.

Чтобы создать камеру вам нужно перейти к панели «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», чтобы быстро переместится к месту камеры):

Теперь пришло время создать нового игрового персонажа с именем Pawn. Для сохранения результата вам нужно нажать кнопку Compile и вернуться в главный редактор.

Создание персонажа

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

Создание игрового режима

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

Вам нужно перейти в Content Browser и найти папку Blueprints. Теперь нажмите кнопку Add New ⇒ Blueprint Class. В появившемся окне выберите Game Mode Base и назовите его GM_Tutorial.

Теперь вам нужно указать, какой класс персонаж Pawn будет использоваться по умолчанию. Для этого дважды щелкните GM_Tutorial, чтобы он открылся.

Перейдите на панель «Details» и в разделе «Classes» в появившемся списке «Default Pawn Class» выберите «BP_Player».

Прежде чем вы сможете использовать новый игровой режим, необходимо указать его для конкретного игрового уровня. Это делается в настройках игрового мира. Сейчас вам нужно нажать Compile и закрыть редактор Blueprint.

Каждый игровой уровень имеет свои настройки. Вы можете получить доступ к настройкам и изменять их по своему усмотрению, выбрав Window ⇒ World Settings. Другой вариант, как это можно сделать – перейти к панели инструментов и выбрать Settings ⇒ World Settings.

Новая вкладка World Settings откроется рядом с вкладкой Details. Тут вам нужно будет перейти к раскрывающемуся списку для изменения настроек GameMode и выбрать там GM_Tutorial.

Вы можете увидеть, что все классы изменились на те, которые вы выбрали в GM_Tutorial.

Наконец, вам нужно указать место, в котором где будет появляться игрок. Это делается при помощи специальной метки «Player Start» на карте.

Расположение метки Player Start

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

Для того, чтобы разместить Player Start, перейдите к панели управления и найдите там функцию Player Start. Теперь щелкните левой кнопкой мыши по Player Start и перетащите его из панели «Modes» в рабочую область, отпустите левую кнопку мыши.

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

Чтобы выйти из игрового режима, нажмите кнопку «Stop» на панели инструментов или клавишу «Esc» на клавиатуре. Кроме того, если вы не видите курсор, нажмите Shift + F1.

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

Настройка управления

Назначение команд для выполнения какого-либо действия называется привязкой ключа.

В Unreal вы можете настроить клавиши управления, которые будут выполнять определенное действие или вызывать событие при нажатии на них. События представляют собой это узлы, которые выполняются, когда происходят определенные действия (в этом случае, когда вы нажимаете связанную клавишу). Узлы, подключенные к событию выполняются после инициации события.

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

Только представьте, насколько бы этот процесс был сложнее, если бы вы вводили для каждой команды специальный код.

Что такое Axis и Action Mappings

Для просмотра настроек ввода вам нужно перейти к Edit ⇒ Project Settings. Слева выберите Input в разделе Engine.

В разделе «Bindings» вы можете изменить данные входа.

В Unreal доступны два метода для создания привязок клавиш:

В этом уроке мы рассмотрим, как пользоваться методом Axis.

Создание Movement Mappings

Для начала вам нужно создать две группы отображения осей (Axis). Они дадут возможность создать несколько привязок ключей к одному событию.

Для того, чтобы создать новую группу axis осей, вам нужно нажать знак «+» сопоставлений осей. Назовите две новые группы и назовите их MoveForward и MoveRight.

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

Вам нужно будет назначить для движения персонажа четыре стандартные клавиши: W, A, S и D. Добавьте еще одно сопоставление осей для каждой группы, щелкнув знак «+» рядом с соответствующем полем.

В окне редактора сопоставьте клавиши W и S с MoveForward и клавиши A и D с MoveRight.

Далее вам нужно установить поля Scale.

Функции Axis Value и Input Scale

Значение оси (Axis Value) — это числовое значение, которое определяется типом ввода и тем, как вы планируете его использовать. Посмотрите, как это выглядит на изображении ниже, чтобы лучше понимать, как распределяются числовые значения:

Вы также можете использовать значение Axis, чтобы контролировать скорость персонажа. Например, если вы сдвинете джойстик к краю, значение оси будет равно 1. Если вы поместите его посередине, значение будет равно 0,5.

Вы также можете использовать значение Axis, чтобы указать направление движения. Формула следующая – если вы умножите скорость персонажа на положительное значение Axis, то вы получите положительное смещение. Использование отрицательного значения оси приведет соответственно к отрицательному смещению. Конечное значение этого смещения по отношению к местоположению игрового персонажа определит, в каком направлении он будет двигаться.

Клавиши клавиатуры могут выводить значение оси только равное 1 или 0, однако вы можете использовать масштаб для преобразования его в отрицательное значение. Это делается путем умножения значения Axis на масштаб. Если вы умножите положительное значение (значение Axis) на отрицательное значение (Scale), вы получите отрицательное значение.

Установите значения клавиш S и A, нажав на поле Scale и введя -1.

Движение игрового персонажа

Для начала вам необходимо указать необходимые события которые будут отображать движение перка. Для этого правой кнопкой мыши пустое место на графике событий, чтобы получить список узлов. Добавьте узел MoveForward, который находится в разделе «Axis Events».

Обратите внимание: вы ищете красный узел в Axis Events, а не зеленый узел в Axis Values.

Повторите процесс для MoveRight.

Использование переменных

Чтобы ваш персонаж перемещался в пространстве, необходимо указать скорость его движения. Для этого перейдите к меню «My Blueprint» и нажмите кнопку «+», которая находится справа от раздела «Variables».

Теперь вам нужно перейти перейдите на вкладку Details и изменить название новой переменной на MaxSpeed и ее тип на Float.

Нажмите на панели инструментов кнопку Compile и переходите к следующему шагу. Убедитесь, что вы выбрали новую переменную и перейдите на вкладку Details. Вам нужно найти раздел «Default Value» и измените значение по умолчанию MaxSpeed=10.

Переместите переменную MaxSpeed на вкладке «My Blueprint» в график событий и выберите Get из меню.

Чтобы определить конечную скорость и направление движения необходимо умножить значение MaxSpeed и значение оси. Добавьте узел float * float и подключите к нему Axis Value и MaxSpeed.

Определение направления движения персонажа

Во-первых, вам нужно добавить узел под названием Get Actor Forward Vector:

Во-вторых, необходимо добавить узел Add Movement и соединить узлы между собой следующим образом:

Обратите внимание, белая линия выполняет функцию соединения цепочки исполнения команды. Другими словами, когда игрок перемещает входную ось, то автоматически генерируется событие, которое будет выполнять узел InputAxis MoveForward. Белая линия означает, что когда это произойдет, вы выполните узел Add Movement Input.

Узел Add Movement Input отвечает за выполнение следующих входных данных:

Вам нужно повторить процесс также для MoveRight, но при этом заменить Get Actor Forward Vector на Get Actor Right Vector.

Добавление функции Offset

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

Чтобы добавить функцию Offset, также создайте узлы Consume Movement Input Vector и AddActorLocalOffset и свяжите их следующим образом:

Это позволит вам получать любые сохраненные данные о движении персонажа и добавлять их в текущее местоположение перка.

Нажмите Compile, вернитесь в главный редактор и нажмите Play. Посмотрите, теперь вы можете управлять вашим персонажем!

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

Примечание: На данном этапе, для вашего удобства некоторые привязки клавиш уже настроены для того, чтобы продемонстрировать вам эффекты в зависимости от частоты кадров. Попробуйте нажать «0», чтобы ограничить частоту кадров до 60 и увидеть результат, затем нажмите 1, чтобы сбросить ограничение. Попробуйте перемещать персонажа при обоих значениях скорости, чтобы увидеть разницу.

Настройка частоты кадров

Выйдите из воспроизведения игры и откройте BP_Player. Далее перейдите к узлу Event Tick и посмотрите на панель Delta Seconds.

Delta Seconds определяет время, прошедшее с момента последнего события. Если при этом вы умножите значение смещения на Delta Seconds, то движение персонажа станет независимым от частоты кадров.

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

Чтобы умножить смещение на Delta Seconds, вам нужно добавить vector * float и подключить узлы следующим образом:

Посмотрите, время между кадрами (Delta Seconds) очень короткое, ваш персонаж будет двигаться намного медленнее, чем нужно. Чтобы это исправить, измените значение MaxSpeed на 600.

Столкновение с пространством

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

Посмотрите, как это выглядит на изображении:

Взаимодействие персонажа активируется, когда его сфера соприкасается с сферой другого персонажа или объекта.

Активация столкновения

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

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

Перейдите к панели «Components» и переместите StaticMesh в DefaultSceneRoot.

Теперь переключитесь на график событий и перейдите к узлу AddActorLocalOffset. Тут вам нужно найти вход Sweep и установить для него значение true, щелкнув левой кнопкой мыши по флажку.

Вернитесь в главный редактор и нажмите «Play». Куб теперь будет останавливаться, сталкиваясь с препятствиями!

Создание объектов

В этом уроке вы создадите объект с которым будет взаимодействовать ваш персонаж. В качестве этого объекта вы будете использовать BP_Banana. Чтобы определить момент, в который персонажа будет соприкасаться с элементом, необходимо создать узел события, который будет срабатывать при столкновении. Существует три типа реакции персонажа на столкновение: «Ignore», «Overlap» и «Block». Вот что происходит при активации каждого из них:

Настройка реакции на столкновение

Выйдите из игры и откройте BP_Banana. Теперь выберите компонент StaticMesh и перейдите на панель «Details». Раздел «Collision» — это место, где вы можете указать нужную реакцию на столкновение с каким-либо объектом.

Как видите, сейчас большинство настроек неактивны. Чтобы сделать их редактируемыми, щелкните левой кнопкой мыши раскрывающийся список, который находится рядом с пунктом «Collision Presets» и выберите Custom из списка.

Теперь вам нужно указать, как будет реагировать персонаж на столкновение с объектом. Если вы не забыли, то тип вашего персонажа – WorldDynamic, так что нужно выбрать реакцию на столкновение именно для этого типа. Теперь перейдите в раздел Collision Responses и измените реакцию на столкновение WorldDynamic на Overlap, щелкнув средний флажок справа от WorldDynamic.

Настройка столкновения

Перейдите в панель «Components» и щелкните правой кнопкой мыши StaticMesh. В контекстном меню вам нужно выбрать Add Event ⇒ Add OnComponentBeginOverlap.

Смотрите, теперь у вас есть новый узел OnComponentBeginOverlap (StaticMesh):

Далее создайте узел DestroyActor и свяжите его с узлом OnComponentBeginOverlap (StaticMesh):

Размещение объекта

Закройте редактор Blueprint и убедитесь, что вы находитесь в папке Blueprints. Теперь разместите несколько бананов (BP_Banana) по всему уровню при помощи мыши.

Теперь нажмите Play и попробуйте собрать несколько бананов при помощи вашего персонажа.

Что делать дальше?

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

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

Я у мамы вээфыксер

Итак, вы захотели делать эффекты для игр. Куда бежать, с чего начать?

1. База

Для начала вам нужно обладать какими-то базовыми знаниями по 3м софтовым направлениям:

С первыми двумя пунктами все относительно просто:
если не обладаете базовыми знаниями, то, открываете строку гугла и вбиваете “ базовые уроки”. Из редакторов я бы выбрал фотошоп, потомучто он более универсален и по нему больше уроков, а из 3D-пакетов что-нибудь из первой тройки (потомучто гудини — сложный для старта, а в синеме нет некоторых узконарпавленных геймдев инструментов, в отличие от блендера и автостола, но это в целом не сильно критично). Хотя это ваш путь и в конечном счете выбирать вам исходя из своих предпочтений.
После успешного изучения основ, когда слова RGBA каналы вас перестанут пугать, простой моделинг будет освоен и придет четкое понимание, что такое развёртка, можно переходить к движку.

Я сам прокачивал своего перса по ветке Unreal Engine, поэтому начнём с него. А так же по этой причине ветка Unity будет выглядеть ампутированной культёй на фоне анриловской (но статья будет ещё дополняться, поэтому я открыт к предложениям ссылок на материалы по Unity эффектам в чате).

Помимо этого есть рускоязычный канал Unreal Engine Rus с большой библиотекой базовых уроков по различным тематикам. Ну и обратите внимание на канал Мэтью Вадштейна WTF Is?, в котором наглядно можно посмотреть как работать с тем или иным инструментом\нодой в движке. Ну и конечно можно влиться в рускоязычное комьюнити в телеге или международное в дискорде.

Что можно сказать про Unity? Так же качается с офф сайта, так же есть раздел с обучением, где можно найти базовые уроки по движку. Так же уделяйте внимание шейдерам. Есть ещё хороший канал со всякими разными вещами, в том числе и базовыми. И есть рускоязычный чат в телеге.

2. Системы частиц

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

В ссылках представлен материал и по Unity и по UE4. Ну а мы по традиции начнём со второго. В Unreal Engine на данный момент существуют две системы частиц: старая Cascade и новая Niagara. В идеале неплохо бы знать обе, потомучто довольно много игровых компаний используют до сих пор старую систему и ещё будут её использовать по причине сырости новой. Это не составит особого труда, поскольку по самим принципам работы старая не сильно отличается от новой, просто выглядит на её фоне кастрированным огрызком с ограниченными возможностями. К тому же по новой системе ещё нет такого количества уроков и обучающего материала, как по старой.

Так или иначе, начать изучение Cascade можно с этого официального плейлиста или короткого курса из обучающего раздела. Так же можно собственноручно посмотреть и потрогать примеры систем частиц на уровне Effects в проекте Content Examples, который можно найти в разделе Learn в лаунчере. В нём же, кстати, а также вообще во вкладке Learn, можно найти много интересного по базе движка.

Изучение Niagara я советую начать с этого плейлиста от хорошего спеца Томаса Харле или же с плейлиста базовых уроков канала GameDev Outpost. Ещё очень-очень рекомендую заглянуть в Content Examples уровни Niagara и Niagara Advanced, где лежат наглядные примеры возможностей новой системы частицы.

Дальше можно двигаться так:

А что по Unity?
Сейчас там тоже присутствуют две системы частиц: старая Shuriken ( вводник туть) и новая VFX Graph ( вводник туть).
Но из каналов с эффектами на Unity я знаю только эти:

Принимаю ваши предложения по дополнению этого раздела в чате.

Вдохновляться эффектами других людей и вообще всяким разным можно вот здесь:

3. Симуляции

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

Для подобного рода симуляций идеально подойдет Houdini, но, так как он неописуемо сложен, добавлю ещё несколько альтернативных вариантов:

Что касается взаимодействия Houdini и игровых движков:

4. Дополнительный софт

Помимо всего вышепречисленного vfx artistы активно юзают Adobe After Effects для эффектов и работы со спрайт-шитами и Substance Designer для процедурной генерации текстур для эффектов.

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

5. Не лезь, она тебя сожрёт

Для тех, кто всё ещё хочет, чтобы ему напихали по самые небалуйся ещё, вот дополнительные ссылочки:

Blueprints Quick Start Guide

Get up and running by creating your first Blueprint.

Choose your operating system:

This quick start guide will walk you through building an Actor in the level with different Components, then turning it into a Blueprint Class you can add launching behavior to so your Character will fly around the level! Making it into a Blueprint Class also means you can create as many launchpads in your world as you want, just by dragging into the level from the Content Browser.

From the New Project tab of the Unreal Project Browser, create a new project from the Games category that uses the following settings:

With Starter Content

Choose whatever scalability and quality settings work best for your setup.

If you are unsure of what settings are right for you, you can find more information in the Project Settings section.

Name your project, then create it by clicking the Create Project button.

You should now be ready to jump into and start adding to the side-scroller level that appears.

In the Level Editor, you will build a launchpad, then convert it to a Blueprint Class so you can add your gameplay behavior to it.

First, move around in the viewport until you are looking at the top platforms in the level.

We are going to create the container to hold all the parts of our launchpad by using the Empty Actor. The two parts (or Components) you will need are a shape to represent the launchpad, and a trigger for when the character overlaps it.

In the Main Toolbar, press the Modes button, and from the dropdown click on Select to display the Place Actors panel.

In the Place Actors panel, click on Basic, then find the Empty Actor.

Drag it into the level so that it is sitting on one of the top platforms.

Now that you have the Actor selected in the level, its properties are visible in the Details panel. At the top of the Details panel, you can rename it. Go ahead and click in the box to enter a new name, like LaunchPad.

In the Details panel, click the Add Component button, then select Cube under Common.

Click and drag the newly addedВ Cube to theВ DefaultSceneRoot to make theВ Cube the new root.

With the Cube component selected, change theВ Scale toВ (X: 1.0, Y: 1.0, Z: 0.1)

Now, we will add a Box Collision Component, which will fire off an event whenever something overlaps it. In the Details panel, click the Add Component button, then (under Collision) select Box Collision.

Change theВ Box Collision scale to ( X: 1.25, Y: 1.25, Z: 9.75) and location to ( X: 0, Y: 0, Z: 200) so the box covers and extends above the launch pad.

If at any time you need to change your Actor’s properties, you can click on LaunchPad (Instance), found in the Details panel, under the Add Components button.

Now that you have your Actor the way you want it, we will turn it into a Blueprint Class. You can add more components inside the Blueprint Editor, and tweak them just like you can in the Level.

When you make changes inside the Blueprint, each time you make a new launchpad in the Level, it will have the look and feel that you have created in the Blueprint Editor. While you could simply duplicate your LaunchPad Actor around the level, any changes you make on a particular launchpad would only affect that one copy.

In the Details panel, click on the Blueprint/Add Script button.

The Create Blueprint from Selection dialog box appears. We are going to edit the default path of the Blueprint.

Change the path from Game/SideScrollerBP to Game/SideScrollerBP/Blueprints.

At this point, you could rename your Blueprint, or leave it as the default LaunchPad_Blueprint.

Click on Create Blueprint.

Your Blueprint is now visible in the Content Browser. Right now, you could drag and drop from the Content Browser into the level to create lots of copies of your platform mesh and trigger, but there will not be any behavior on it yet. In the next step, you will start setting up the graph nodes inside of your Blueprint to launch your Character when it crosses the launchpad.

To start adding behavior to your Blueprint Class, you will need to open it in the Blueprint Editor.

Double-click the Blueprint Class in the Content Browser.

The Blueprint Editor will open, and you can see your Cube and Box components in a viewport. At this point, if you adjust the Box Component’s placement, it will be applied to all launchpads you make from this Blueprint Class. Just like when you were working with components on your LaunchPad Actor, you can select the Box component in the Components list and adjust the location. Try a location of (X: 0, Y: 0, Z: 350).

Docked next to the Viewport tab is a Construction Script tab and an Event Graph tab. Since you are going to be creating gameplay behavior, you should start with the Event Graph. Click on that tab now.

Events are the starting point of your Blueprint graph’s execution, and can be associated with a number of different gameplay situations. A selection of the most commonly used events are visible right away, seen as translucent Event nodes. Though certainly useful for many of your Blueprint graphs, we will be making one of our very own.

We want an event that will execute when anything overlaps our Box component. First, select the Box component in the Components tab.

Right-click in an empty spot in your graph to bring up the context menu of nodes you could add to the graph.

To move around in the graph, right-click and drag around. At this point, you could drag the graph to the left, moving the pre-placed event nodes off the left side of the screen and creating more blank space to create your launchpad logic in.

We are adding an event for this Component, so expand the Add Event for Box dropdown, and then Collision. You could also use the search box, using «Component Begin Overlap» to filter the menu.

Select On Component Begin Overlap.

Your graph now has an OnComponentBeginOverlap node. Any nodes connected to this event will execute when something overlaps the Box component of your launchpad.

In the next step of this guide, you will begin connecting nodes to the output pins of this node, and learn more about working with nodes in Blueprints.

Right now, that OnComponentBeginOverlap event will execute when anything overlaps the Box trigger. We only want to actually execute our launching behavior, though, if the overlapping thing is our avatar, or Pawn. Think of it as asking «Is the Actor overlapping the Box trigger the same Actor as our Pawn?»

We will do that by working with the Other Actor output from the OnComponentBeginOverlap event.

The context menu is adaptive, filtering by the pin you are currently working with to show you only nodes that are compatible.

Type = into the search box to filter the available nodes, then select Equal (Object).

We could set Side Scroller Character as the other input to the Equal node, but then if we changed the Character we were using, we would need to re-open this Blueprint and manually update that. Instead, let’s get a reference to the current Pawn we are using.

Right-click in an empty part of the graph to bring up the context menu.

Type Player Pawn in the menu’s search box, then (under Game) select Get Player Pawn.

Connect the Return Value output on Get Player Pawn to the second input on the Equal node.

Now that we have got a node that will tell us if the Other Actor is the Pawn our player controls, we will use the answer to change the execution flow of our graph. That is, we will direct the execution flow as it leaves the On Component Begin Overlap node. For that, we want to use a Flow Control node, specifically the Branch node.

Drag off of the execution pin on the OnComponentBeginOverlap node and release in an empty part of the graph.

Type Branch in the search, then select Branch from the context menu.

Connect the output pin of the Equals node to the input Boolean pin on the Condition node.

The graph is now ready for you to set up different behavior to execute depending on whether the overlapping Actor is your Pawn or not. In the next step, we will do just that, and set up Blueprint nodes to launch our Character if the result of the Equals comparison is True.

Our launchpad is going to work by using a function called Launch Character. The Launch Character function adds the velocity you specify to the Character’s current velocity, allowing you to throw it in whichever direction you would like. It only works on Characters, though, so we need to make sure that our Pawn (avatar) is a Character (humanoid avatar).

We do this by casting. Casting attempts to convert your input into a different type, so you can access specific functionality that is only allowed for that particular type. It will succeed if your input is based on that type.

Everything you can place in your level is an Actor, in addition to any other specialized behavior added on later. That means that you can get a reference to anything in your level, cast it to Actor, and it will succeed. However, not everything in your level is the Pawn representing you in the game, so casting something to Pawn may or may not succeed.

From the Get Player Pawn node, drag off of the Return Value pin.

Begin typing Cast to Character in the search field of the context menu to find the node of the same name.

From the Cast to Character node, drag off of the As Character pin.

Type «Launch» into the search box, then select Launch Character in the context menu.

Click image for full size.

Notice that the output execution pin for successfully casting automatically connected to the input execution pin of Launch Character.

Type 3000 into the Z field of the Launch Character node.

Finally, connect the Branch node True execution pin to the Cast to Character node’s input execution pin, so that Cast to Character and Launch Character only occur if the overlapping Actor is our Pawn.

Click image for full size.

At this point, Compile and Save the Blueprint using the toolbar buttons, then close the Blueprint Editor.

Drag several of the launchpads into your Level from the Content Browser.

Click on Play in the toolbar, then run around the Level (using WASD) and jump (using the Spacebar). Land on one of the platforms and watch as you go flying through the air!

Using what you have learned over the course of this Quick Start guide, try to do the following:

Create a variable to store your Launch Velocity, and expose it so you can set it on each copy in the level.

Add a Particle System Component to your Blueprint and use one of the Particle Systems from the Starter Content.

Add an Arrow Component and use its rotation to define the direction to launch the character.

For more information on Blueprint Visual Scripting, see the Blueprints page.

As for specifics covered in this quick start:

For a quick overview of different types of Blueprint Classes you can make, see Blueprints Getting Started

For more information on Blueprint Classes, see: Blueprint Classes

For more short tutorials on creating and working with Blueprint Classes, see: Blueprints How-To

For more information on the Blueprint Editor, see: Blueprint Editor

Как создать простой шутер при помощи Unreal Engine 4

Кстати говоря, изначально Unreal Engine создавался именно для создания игр FPS.

В этом уроке вы узнаете, как:

Это занятие является частью серии, которая состоит из 10 уроков, посвященных Unreal Engine:

Начало работы

В первую очередь вам необходимо скачать стартовый проект и все материалы, необходимые для работы. Разархивируйте файл и откройте BlockBreaker.uproject.

Перед вами появится следующая локация:

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

Для начала вам нужно создать игрового персонажа.

Создание игрового персонажа

Перейдите в папку Blueprints и создайте новый Blueprint Class. Выберите Character в качестве основного класса и назовите его BP_Player:

Character — это один из типов игровых объектов, но с дополнительными функциями, например, такими как компонент CharacterMovement:

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

Прежде чем вы сможете сделать какие-либо действия игровым персонажем, необходимо указать момент нажатия клавиши движения. Для этого используются настройки клавиш W, A, S и D.

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

Настройка движения персонажа

Вам нужно выполнить Edit ⇒ Project Settings и открыть раздел Input. Теперь создайте два объекта Axis Mappings и назовите их MoveForward и MoveRight соответственно. MoveForward будет использоваться для движения игрока вперед и назад, а MoveRight влево и вправо:

Нужно назначить для MoveForward в качестве ключа значение измените W. Теперь тут же создайте еще один ключ со значением S и впишите в поле Scale число -1.0:

Примечание: Если вы хотите больше узнать о поле «Scale», обратитесь к руководству по Blueprints. Главы Axis Value и Input Scale описывают, что это такое и как его использовать.

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

Реализация передвижения персонажа

Откройте BP_Player и Event Graph, чтобы добавить новое событие MoveForward, которое будет выполняться каждый кадр, даже если вы ничего не нажимаете.

Это событие также будет выводить значение оси, относительно значения шкалы, которое вы установили ранее. При нажатии W это значение будет равно 1, а при нажатии S — 1. При условии, что ни одна из этих клавиш не задействована, будет использоваться значение 0.

Сейчас вам нужно настроить команду движения для персонажа, создав узел Add Move Input и подключив его следующим образом:

Чтобы определить значение Add Move Input нужно взять вектор и умножить его на значение масштаба. Таким образом получится нужное направление, в соответствии с которым компонент CharacterMovement будет перемещать персонажа.

Укажем в каком направлении должен двигаться игровой персонаж при помощи нового вектора Get Actor Forward Vector, который вам следует создать и подключить следующим образом:

Резюмируя:

Теперь вам нужно повторить процесс для MoveRight, но при этом заменить Get Actor Forward Vector на Get Actor Right Vector:

Установка расположения персонажа по умолчанию

Нажмите Compile, чтобы сохранить результаты и вернитесь в главный редактор. Вам нужно открыть панель World Settings и найдя тут раздел Game Mode, и заменить Default Pawn Class на BP_Player:

Примечание: Если у вас нет панели World Settings, перейдите к панели Toolbar инструментов и выберите Settings ⇒ World Settings.

Теперь вы будете автоматически использовать BP_Player при запуске игры. Нажмите Play и используйте клавиши W, A, S и D для перемещения, чтобы протестировать внесенные изменения:

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

Создание Look Mappings

Откройте Project Settings и создайте два новых Axis Mappings с названиями LookHor Horizontal и LookVertical:

Установите ключ для LookHor horizontal на значение Mouse X:

Это отображение выведет положительное значение при перемещении мыши вправо и наоборот.

Затем измените ключ для LookVertical на значение Mouse Y:

Это отображение выведет положительное значение при перемещении мыши вверх и наоборот.

Теперь вам нужно создать логику для осмотра вокруг себя.

Внедрение функции осмотра вокруг себя

Если у игрового персонажа все еще нет компонента Camera, Unreal создаст его автоматически. По умолчанию эта камера будет зависеть от используемого контроллера.

Примечание: Больше информации о возможностях контроллера вы можете получить из урока, посвященному работе с ИИ.

Несмотря на то, что контроллеры не являются физическими объектами, они имеют свои настраиваемые функции. Таким образом вы можете настроить вид персонажа и камеры в зависимости от того, какие цели вы преследуете – создаете игру от первого, где камера смотрит в одном направлении с персонажем, или от третьего лица, где камера и персонаж могут смотреть в разные стороны:

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

Чтобы камера могла поворачиваться вслед за персонажем в разные стороны, нужно отрегулировать поворот контроллера. Для этого создайте выход Yaw Add Controller и подключите его следующим образом:

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

Повторите процесс для LookVertical, но замените Add Controller Yaw Input на Add Controller Pitch Input:

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

Чтобы это исправить, умножьте значение оси на -1 для инвертирования обзора:

Нажмите Compile, чтобы сохранить результат, а затем нажмите Play и посмотрите изменения в действии:

Создание оружия

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

Допустим, вам нужно сделать несколько видов автомобилей. Вы можете создать базовый класс автомобиля, который содержит переменные, такие как скорость и цвет. Затем вы можете установить классы (дочерние элементы), которые используют базовый тип автомобиля в качестве основного. Каждое ответвление также будет содержать одинаковые переменные. Таким образом вы получите одинаковые автомобили с различными значениями скорости и разными цветами, приложив минимум усилий для их создания.

Создание базового класса для оружия

Вернитесь в главный редактор и создайте Blueprint Class установив его тип на Actor. Назовите новый класс BP_BaseGun и откройте его.

Теперь вам нужно создать несколько типа float переменных, которые будут определять некоторые свойства оружия:

Теперь вам нужно создать физическое представление о пистолете. Добавьте компонент Static Mesh и назовите его GunMesh:

Создание дополнительных классов оружия

Нажмите Compile для сохранения результата работы и вернитесь в главный редактор. Чтобы создать дополнительный класс, щелкните правой кнопкой мыши BP_BaseGun и выберите команду Create Child Blueprint Class:

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

Теперь каждая пуля будет преодолевать максимальное расстояние равное 5000. Если она попадет в какой-либо объект, то нанесет 2 единицы повреждения. При выполнении последовательных выстрелов продолжительность каждого из них будет составлять не менее 0,1 секунды.

Далее вам необходимо указать, какая физическая сетка должна использоваться для пистолета. Выберите компонент GunMesh и установите для его Static Mesh значение SM_Rifle:

Создание камеры

Откройте BP_Player и создайте новый компонент Camera с названием FpsCamera:

Сейчас положение камеры по умолчанию находится слишком низко, поэтому может сложиться впечатление, что вы управляете карликом или ребенком. Установите местоположение FpsCamera в положение (0, 0, 90):

Кроме того, сейчас компонент камеры зависит от перемещения контроллера. Чтобы это исправить, перейдите на панель Details и включите Camera Settings ⇒ Use Pawn Control Rotation:

Определение местоположения оружия

Найдите событие BeginPlay и создав Spawn Actor From Class, установите его значение Class на BP_Rifle:

Теперь создайте переменную типа BP_BaseGun и назовите ее EquippedGun.

Затем соедините EquippedGun с выходом Return Value узла Spawn Actor From Class:

Далее создайте ссылку на GunLocation и соедините следующим образом:

Резюмируя:

Стрельба из оружия

Трассировка — это функция, которая задает начальную и конечную точки (которые образуют линию) на условном отрезке пространства. Объект должен пересечь каждую точку вдоль линии (от начала до конца), пока не достигнет определенной цели.

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

Затем вам нужно проверить, не попала ли линия трассировки. Создайте узел Branch и подключите его как показано на изображении:

Выход Return Value будет иметь значение true, если пуля попала в цель и наоборот.

Чтобы визуально было видно эффект стрельбы, можно использовать эффекты, созданные с помощью частиц.

Частицы для создания эффекта попадания пули

Переместите Out Hit на график и в появившемся меню выберите Break Hit Result:

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

Создайте Spawn Emitter в Location и установите для Emitter Template значение PS_BulletImpact. После этого подключите его выход Location к такому же выходу Break Hit Result:

Посмотрите, как должен выглядеть общий график:

Резюмируя:

Использование функции стрельбы

Во-первых, вам нужно создать раскладку клавиш клавиатуры для стрельбы. Нажмите Compile, откройте Project Settings и создайте новое событие Axis Mapping под названием Shoot. Установите его ключ на левую кнопку мыши, а затем закройте окно Project Settings:

После этого откройте BP_Player и создайте новое событие Shoot:

Чтобы проверить, нажимает ли игрок клавишу Shoot, вам просто нужно проверить, равно ли значение Axis значению 1. Теперь создайте и разместите выделенные на изображении узлы:

Создайте ссылку на EquippedGun и назовите ее Shoot function:

Расчет местоположения трассировки линии полета пули

Во многих FPS играх пули начинают свое движение от камеры, а не от пистолета. Чтобы сделать так же, создайте ссылку на FpsCamera и подключите ее к GetWorldLocation:

Подключите все следующим образом:

Резюмируя:

Нажмите Compile, чтобы сохранить результаты, а затем нажмите Play и попробуйте выстрелить из оружия:

Уменьшение скорострельности

Теперь выстрел будет происходить, только если нажата клавиша Shoot и CanShoot равен true. Добавьте выделенные на изображении узлы:

Что поменялось:

Чтобы сохранить результаты нажмите Compile и закройте BP_Player. Нажмите Play и проверьте текущую скорострельность оружия:

Нанесение урона

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

Откройте BP_BaseGun и добавьте Apply Damage в конце функции Shoot:

Теперь нужно указать, какому объекту будет наносится урон. Для этого соедините Damaged Actor с Hit Actor узла Break Hit Result:

Чтобы указать количество нанесенного урона вам нужно получить ссылку на Damage и подключить его к Base Damage:

Теперь Shoot наносит повреждения всем объектам, которые попадают под линию стрельбы. Нажмите Compile и закройте BP_BaseGun.

Получение урона

Откройте BP_Target и создайте новое событие AnyDamage, которое будет выполняться всякий раз, когда объект получает урон:

После этого вам нужно подключить контакты функции TakeDamage следующим образом:

Теперь, когда цель будет получает урон, она потеряет здоровье. Нажмите Compile, а затем закройте BP_Target.

Далее откройте BP_ResetButton, создайте событие AnyDamage и откройте функцию ResetTargets:

Таким образом произойдет перезагрузка целей, если выстрелить по красной кнопке. Нажмите Compile и закройте BP_ResetButton.

Нажмите Play, чтобы проверить как работают новые функции:

Что делать дальше?

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

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

Мы также проводим набор авторов и переводчиков в нашу команду Unreal Engine, чтобы создавать еще больше таких же классных руководств, как эта серия.

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

Rendering Components

Outlines different types of Rendering Components, including Particle Systems, Decals, and Billboards.

Choose your operating system:

Atmospheric Fog Component

AtmosphericFogComponents are used to create fogging effects such as clouds or ambient fog in a level. There are several settings that can be adjusted for this Component that can affect how the effect is generated in your level when placed.

Examples of this type of Component in use with varying values for its Decay Height setting (which controls fog density decay height, ie. lower values cause the fog to be denser, while higher values thin the fog, causing less scatter) are portrayed below. For more information, see the Atmospheric Fog User Guide page.

Density Decay Height of 0.5 (8 km)

Density Decay Height of 0.35 (2.744 km)

Density Decay Height of 1.0 (64 km) and Max Scattering of 4

Density Decay Height of 1.0 (64 km) and Max Scattering of 1

Exponential Height Fog Component

The ExponentialHeightFogComponent is used to create fog effects but with a density that is related to the height of the fog.

Exponential Height Fog creates more density in low places of a map and less density in high places. The transition is smooth so you never get a hard cutoff as you increase altitude. Exponential Height Fog also provides two fog colors, one for the hemisphere facing the dominant directional light (or straight up if none exists), and another color for the opposite hemisphere.

See Exponential Height Fog User Guide for more information and settings that can be adjusted.

Billboard Component

The BillboardComponent is a 2D Texture that will be rendered always facing the camera and functions similarly to an ArrowComponent in that it can be used for a method of placement and easy selection. For example in the fog sheet that was created below, the only Component added is a BillboardComponent (the actual fog effect is a material that is dynamically created through script).

Inside the level, you can manipulate the fog sheet by selecting the BillboardComponent icon (which is a texture that you can specify).

For an example of how this Fog Sheet was created, see the Fog Sheet and Light Beams documentation.

Material Billboard Component

The MaterialBillboardComponent is a 2D Material that will be rendered always facing the camera. One example of where this type of Component could be used is in the form of 2D grass or foliage. Rather than using Static Meshes to represent pockets of growing grass or even individual grass blades, using a MaterialBillboardComponent with a Material used to convey growing grass, there is no need to have a 3D representation of grass as the billboard will automatically turn and face the player giving the illusion of three dimensional grass.

Cable Component

A CableComponent allows you attach two Components together while rendering a cable between them. On the cable itself, you can assign a Material and define parameters that affect the way the cable is displayed. To read more about how to use the cable component, check out the link below.

Custom Mesh Component

The CustomMeshComponent allows you to specify custom triangle mesh geometry.

Poseable Mesh Component

The PoseableMeshComponent allows bone transforms to be driven by a Blueprint.

Decal Component

A DecalComponent is a material that is rendered onto the surface of a mesh (a kind of «bumper sticker» for a model). Decals can be used for any number of purposes, such as bullet impact decals on a wall when shot, a skid mark decal for a car that breaks along a road, blood that splatters on the ground when being shot, etc. (an example decal is provided below).

There are several pages you can refer to for more information on working with Decals.

Instanced Static Mesh Component

An InstancedStaticMeshComponent is a Component that efficiently renders multiple instances of the same Static Mesh. This type of Component is particularly useful for procedural level or room creation, as instead of placing hundreds (or even thousands) of Static Mesh Actors in your level, you can place one Instanced Static Mesh and add multiple instances of the Static Mesh (floors or walls for example) at a much lower performance cost.

Particle System Component

A ParticleSystemComponent allows you to add a particle emitter as a sub-object to another object. Adding a ParticleSystemComponent could be used for several reasons, from adding an explosion effect to something that gets destroyed to adding a fire effect to something you can set on fire. By adding this type of Component to another Object, through script you can access and set any of the parameters of the Particle Effect during gameplay (ie. turning the effect on or off).

For example, below we have a security camera and have added a ParticleSystemComponent for a spark effect.

Through script we could state that the spark effect is off by default, but activated when the camera is shot.

Post Process Component

PostProcessComponets enable Post Process controls for Blueprints. It will use a parent UShapeComponent to provide volume data if available. This type of Component could be used to shift the tone of your level, when Post Process Settings are applied to it. For example suppose you defined a default Post Process Setting to use for your game, when the player is damaged (or potentially killed), you could through script change the settings to a black/white tone for the Scene Color Tint.

Scene Capture 2D Component

Scene Capture Cube Component

A SceneCaptureCubeComponent is used to capture a «snapshot» of the scene from 6 planes and feed it to a Render Target.

Spline Mesh Component

SplineMeshComponents can be used to stretch and bend a Static Mesh asset. With SplineMeshesComponents, you must provide vectors for the position and tangent for the start and end of the spline. Below, a SplineMeshComponent has been added to a Blueprint and a pipe Static Mesh has been assigned as the asset to affect.

While you specify the vectors for the position and tangent on the Component itself, you can use script to set these as variables and make them public so that they can be edited inside the Editor Viewport as seen below.

Text Render Component

A TextRenderComponent renders text in the world with the given font. Contains usual font related attributes such as Scale, Alignment, Color, etc. You might use this Component to indicate to a player that an object is intractable in your levels.

For example, suppose you had a chair in your level that players can sit down in when they approach it if they press a button. You could add a TextRenderComponent containing the instructions needed to execute the command of sitting (visibility set to off) along with a BoxComponent used as a trigger which will set visibility of the text to true when the player enters it (shown below).

In game when the player enters the trigger, the TextRenderComponent text is displayed informing the player how to sit.

Vector Field Component

A VectorFieldComponent is used for referencing a