Unreal Engine 4 для разработчиков Unity

0
41
Unreal Engine 4 для разработчиков Unity UE4

Оглавление

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

Редактор

Ниже представлены фотографии Unity Editor иUnreal Editor с цветовой кодировкой для Сопоставление редактора в UE4

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

Редактирование активов

В Unity вкладка Inspector (Наблюдатель) используется для редактирования выбранных активов в вашем проекте. В UE4 панель Details (Детали) предоставляет свойства выбранных объектов, а большие задачи редактирования приводят к выделенному окну или вкладке. Новые окна с вкладками откроются для каждого отредактированного ресурса, аналогичного веб-браузеру. Конечно, вы можете свободно перетаскивать вкладки или оставить их как автономные окна.

Актив материала UE4

Быстрый глоссарий

Следующий раздел содержит общие термины Unity слева и их эквиваленты в UE4 (или приблизительный эквивалент) справа. Ключевые слова UE4 напрямую связаны с более подробной информацией внутри онлайн-документации UnrealEngine.

КатегорияUnityUE4
Типы игрового процессаКомпонент (Component)Component (Компонент)
игровой Объект (GameObject)Actor, Pawn (Актер, Пешка)
Prefab (заготовка)Blueprint Class
Editor UI (Редактор интерфейса)Панель иерархииWorld Outliner
Inspector (наблюдатель)Details Panel (панель

сведений)

Project Browser (браузер проекта)Контент браузер
Просмотр изображенияViewport (окно просмотра)
Меш Mesh (меш)Static Mesh (статик меш)
Skinned MeshSkeletal Mesh (скелетная меш)
Материалы Шейдер (программа работы с тенями)Material, Material Editor (Материал, Редактор Материала)
Material (Материал)Material Instance (экземпляр

материала)

ЭффектыParticle Effect (эффект частиц)Эффект, Частица, Каскад
ShurikenCascade (Каскад)
Game UI (игровой интерфейс)UIUMG (графики движений в Unreal)
АнимацияАнимацияSkeletal Animation System (система скелетной

анимации)

MecanimPersona, Animation Blueprint
2DSprite EditorPaper2D
ПрограммированиеC#C++
скриптBlueprint
Physics (физика)RaycastLine Trace,  Shape Trace
RigidBody (жесткое тело)Collision, Physics (Столкновение, Физика)
Платформы выполнения iOSPlayer, веб-проигрывательPlatforms (Платформы)

Проекты и файлы

Итак, что собой представляют все эти каталоги и файлы?

Как и проекты Unity, проекты Unreal всегда существуют в своем собственном каталоге и имеют свой собственный файл проекта. Вы можете дважды щелкнуть файлы .uproject, чтобы загрузить игру в Editor Unreal, или щелкнуть правой кнопкой мышки дополнительные параметры. Папки проекта имеют различные подпапки с контентом и источником вашей игры, а также различные файлы конфигурации и двоичные файлы. Наиболее важными являются подпапки **Content** (Содержание) и Source (Источник).

Где я могу разместить свои активы?

В UE4 каждый проект имеет папку “Content”. Подобно папке Активы проекта Unity, здесь хранятся ваши игровые ресурсы. Чтобы импортировать активы в свою игру, просто поместите файлы в каталог содержимого вашего проекта, и они будут автоматически импортированы и появятся в контент браузере. Активы в редакторе будут автоматически обновляться при внесении изменений в файлы с помощью внешней программы.

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

Какие распространенные форматы файлов поддерживаются?

Unity поддерживает широкий спектр форматов файлов. UE4 поддерживает наиболее распространенные типы файлов:

Asset Type (тип актива)Supported Formats (поддерживаемые форматы)
3D.fbx, .obj
Texture / Текстура.png, .jpeg, .bmp ,.tga, .dds, .exr, .psd, .hdr
Sound / Звук.wav
Fonts / Шрифт.ttf, .otf
Videos / Видео.mov, .mp4, .wmv

Как хранится моя Сцена?

В Unity вы помещаете игровые Объекты в сцену и сохраняете это как файл ресурса сцены. У Unreal есть файл Map (Карта), похожий на Unity Scene. В файлах карт хранятся данные о вашем Level (Уровне) и объектах в нем, а также данные освещения и определенные параметры уровня.

Как изменить настройки моего проекта?

Все настройки проекта можно найти в главном меню в разделе Edit / Project Settings. Как и настройки проекта Unity, они позволяют вам указывать информацию о вашем проекте (например, название проекта и иконки), настраивать привязки ввода игры и определять, как работает движок при запуске вашего проекта. Вы можете узнать больше об отдельных настройках проекта здесь.

Unity также имеет так называемые player settings (настройки игрока). В Unreal это platform settings (настройки платформы), и их можно найти в разделе «Platforms» в настройках вашего проекта.

Куда дальше направляются мои исходные файлы?

В Unity вы привыкли размещать исходные файлы C# в папке с вашими ресурсами.

UE4 работает по-разному. Для проектов, на которых есть код на C++, вы найдете подпапку Source (Источник) в каталоге проекта, в котором есть различные файлы, включая исходные файлы C++ (.cpp) и header (.h), а также некоторые скрипты сборки (.Build.cs, .Target.cs). Однако проекты только для Blueprint не будут содержать папку Source.

Самый простой способ начать работу с C++ в UE4 – это использовать редактор для Add Code to Project (добавления кода в проект) (в основном меню File) или просто создать новый проект C++ с нуля из одного из многих шаблонов. Вы можете найти классы C++ прямо в контент браузере и можете открыть файлы в Visual Studio или Xcode, дважды щелкнув по их значкам.

От игровых Объектов – GameObjects к Актерам – Actors

Где находится мой Игровой объект – GameObject?

В Unity GameObject – это Объект, который может быть помещен в Мир. Эквивалент в UE4 – это Актер. В редакторе Unreal вы можете перетащить новый Empty Actor (пустой Актер) в окно просмотра с панели Placement (Размещение):

Вы можете создать игру из Empty Actors, но UE4 также включает специальные типы Актеров со встроенными функциями, такими как Pawn (Пешка) (для игроков или AI – объектов) или Character (персонаж) – для анимированных существ. Также как и Empty Actors, вы можете сбросить эти специальные типы Актеров, а затем добавить или настроить их свойства и компоненты. Вы узнаете об этом позже, но на данный момент попытайтесь вспомнить, что UE4 имеет Gameplay Framework (игровая система), который работает с этими специальными актерами.

Актеры в UE4 немного отличаются от GameObjects в Unity. В Unity GameObject – это класс C#, который вы не можете продлить напрямую. В UE4 Актер – это класс C++, который вы можете расширять и настраивать с помощью наследования. Мы поговорим об этом позже!

Где найти мои Компоненты?

В Unity вы добавляете компоненты в Объект, чтобы придать ему функциональность.

В UE4 вы добавляете компоненты к Актерам. После того, как вы сбросили пустого Актера на свой уровень, нажмите кнопку Add Component (Добавить компонент) (на панели Details) и выберите компонент для добавления. Здесь мы создаем «огонек», опуская пустой Актер, а затем, добавляя компонент меши для основания, за которым следует источник света, и систему частиц для создания своего «огонька».

В Unity GameObject содержится список компонентов, но в UE4 Актер фактически содержит Иерархию компонентов, прикрепленных друг к другу. Вы можете увидеть это в примере выше, где Свет и Частица прикреплены к Меши. У всего этого имеются некоторые важные последствия, которые мы обсудим позже в составных Актерах и GameObjects.

От заготовок Unity до классов UE4 Blueprint

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

Соответствующий рабочий процесс UE4 основан на классах Blueprint. В UE4 вы создаете актера с компонентами, выбираете его и нажимаете кнопку Blueprint / Add Script (Добавить скрипт) на панели Details. Затем выберите место для сохранения своего класса Blueprint и нажмите Create Blueprint, чтобы сохранить новый Класс Blueprint!

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

Где находятся компонент Script и MonoBehaviour?

В Unity у вас есть компоненты Script, которые вы бросаете на GameObjects, чтобы добавить скрипты C#. Вы создаете класс, который наследует от MonoBehaviour, чтобы определить, что делает этот компонент.

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

Итак, как вы создаете свой собственный класс компонентов в UE4? В раскрывающемся списке «Add Component» панели Details вы увидите, что вы можете создавать новые компоненты или выбирать существующие:

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

В Unity при создании нового MonoBehaviour вам будет предоставлен файл скелетного класса с функцией Start() и функцией Update().

В UE4 вам также будет предоставлен skeleton класс с функцией InitializeComponent() и функцией TickComponent(), которые выполняют функции, аналогичные Start (начать) и Update (обновить).

Если вы создадите Компонент Скрипта Blueprint, вам будут предоставлены те же функции, что и визуальные узлы:Актер событие ue4

Пишущий Актер в Blueprint классах

Вот представлена замечательная особенность в UE4: ваш новый Класс Актера Blueprint может иметь собственный Blueprint Visual Scripting! Это позволяет добавлять логику ко всему объекту, а не только к отдельному компоненту. В сочетании с наследованием (объясняется ниже) это дает вам большую гибкость при разработке вашей игры.

Помимо Классов Blueprint, поддерживающих визуальные скрипты, UE4 также поддерживает классы C++, реализованные с кодом. Вот представлены оба варианта.

Unity C#

using UnityEngine;
using System.Collections;
public class MyComponent : MonoBehaviour
{
    int Count;
    // Use this for initialization.
    void Start ()
    {
        Count = 0;
    }
    // Update is called once per frame.
    void Update ()
    {
        Count = Count + 1;
        Debug.Log(Count);
    }
}
UE4 C++

#pragma once
#include "GameFramework/Actor.h"
#include "MyActor.generated.h"
UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()
    int Count;
    // Sets default values for this actor's properties.
    AMyActor()
    {
        // Allows Tick() to be called
        PrimaryActorTick.bCanEverTick = true;  
    }
    // Called when the game starts or when spawned.
    void BeginPlay()
    {
        Super::BeginPlay();
        Count = 0;
    }
    // Called every frame.
    void Tick(float DeltaSeconds)
    {
        Super::Tick(DeltaSeconds);
        Count = Count + 1;
        GLog->Log(FString::FromInt(Count));
    }
};

UE4 Blueprint

Blueprint UE4

Классы UE4 Blueprint могут быть расширены

Unity prefabs (заготовки) и UE4 Blueprint Classes могут быть созданы в вашей игре аналогичным образом. Тем не менее, в Unity есть сложности, связанные с вложенными сборками в другие сборные блоки, которые ограничивают их роль в качестве расширяемых строительных блоков.

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

Например, в UE4 вы можете создать Класс Blueprint с именем Monster, который реализует основные функции монстра, такие как преследование людей. Затем вы можете создавать дополнительные классы Blueprint, которые расширяют его, например Dragon (тип монстра, который дышит огнем), Grue (монстр, который может съесть вас с наступлением темноты) и, к примеру, еще 8 других. Эти подклассы Monster все наследуют базовую функциональность от Monster и добавляют новые возможности поверх уже существующих.

В Unity вы реализуете все это, создавая множество различных заготовок GameObject: один для Dragon, один для Grue и т.д. Теперь скажите, что вы хотите добавить некоторые новые функции для всех монстров, например, возможность говорить с помощью нового компонента Speak (говорить). В Unity вам нужно будет перейти и обновить все 10 готовых файлов, чтобы индивидуально копировать и вставлять в нее новые функции.

В UE4 вы можете просто изменить Класс Monster Blueprint, чтобы добавить эту новую способность говорить. Это все! Дракон, Grue и 8 других подклассов Monster автоматически наследуют новую функциональность говорящего, и вам уже не нужно с ними возиться.

Но есть еще кое-что! Все, что мы говорили здесь о Классах Blueprint, также относится к Классам C++, и все в равной мере относится к Актерам и Компонентам. Эти системы предназначены для поддержки широкомасштабной разработки расширяемой функциональности и могут масштабироваться для проектов с десятками или сотнями разработчиков.

Могу ли я использовать Blueprint Scripting, C++ или оба варианта?

Blueprint Visual Scripting (визуальный скрипт) идеально подходит для простого логического процесса в игре и последовательности действий. Это отличная система для дизайнеров, художников и визуально-ориентированных программистов, потому что они легкодоступны и контролируют игровые объекты визуально. Вы даже можете создать небольшую автономную игру, используя только Blueprints; см. образец Tappy Chicken для полноценного примера.

Программирование на C++ предназначено для более масштабных задач, таких как создание систем геймплея, complex AI и новые возможности движка. Если у вас уже есть опыт работы на C++, ознакомьтесь с инструкцией Introduction to C++ Programming in UE4.

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

Классы Blueprint могут расширять классы C++

Большая часть магии разработки игр UE4 исходит из взаимодействия между программистами, реализующими новые функции на C++, с дизайнерами и художниками, использующими их в Blueprints, и этого еще недостаточно! Вот как команда может структурировать шутер игру на основе UE4, реализующую пикапы, используя сочетание систем программирования C++ Classes и Blueprint Classes для поведения и внешнего вида:

C++ классы и Blueprint классы UE4

Компоненты преобразования

В Unity каждый GameObject имеет компонент Transform (трансформация), который дает GameObject позицию, поворот и масштаб в мире.

Аналогично в UE4, у Актеров есть Root Component (Корневой Компонент), который может быть любым подклассом Scene Component (Компонента Сцены (эпизода)). Scene Component (Компонент Сцены) дает Актеру место, поворот и масштаб в мире, который применяется иерархически ко всем компонентам под ним. Многие из компонентов, которые вы будете использовать, классифицированы из Scene Component (Компонента Сцены), потому что иметь позицию/локацию – это действительно удобно!

Даже если вы разместите Empty Actor, UE4 создаст “Default Scene Root” (Ошибка корневой сцены) для этого Актера, который является просто обычным Компонентом Сцены. Если вы добавите новый Компонент сцены, он заменит на Корневую Сцену по Умолчанию.

Составные объекты

В Unity вы создаете сложные объекты, создавая иерархию GameObjects и наблюдая их совместные преобразования:

Игровые объекты UE4

В UE4 вы создаете сложные игровые объекты и вложенные компоненты иерархически:

Иерархия актеров UE4

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

Все ли можно создавать из Компонентов?

Это в действительности зависит от вас самих, но чаще всего вы будете использовать комбинацию настраиваемых типов компонентов вместе с классами Актера, которые и используют эти компоненты. Мы упоминали об этом выше, но UE4 имеет множество специальных типов Актеров, которые гарантируют определенный уровень возможностей и всегда включают определенные компоненты. Например, Character (Персонаж) всегда содержит Character Movement Component (Компонент движения персонажа).

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

  • Pawn / Пешка – тип актера, который является контролируемым объектом игры, обычно аватар игрока. Пешки перемещаются Игроками и AI (искусственный интеллект), также как и через Controller (Контролер).
  • Character / Персонаж – более специализированная версия Пешки, предназначенная для двуногих аватаров, которые справляются с большой сложностью этих видов игровых объектов.
  • Controller / Контроллер – владеет и управляет пешкой. Отделяя Пешку от контроллера, вы можете написать AI Controllers, которые могут манипулировать пешкой, используя тот же интерфейс, которым бы пользовался игрок.
  • Player Controller / Игровой Контроллер – более специализированный контроллер, предназначенный для ввода информации от игрового устройства, сенсорного экрана или мыши / клавиатуры и использования этого входа для управления пешкой или персонажем, которым они обладают.

А все ли здесь Актеры?

Не все. Актеры являются наиболее распространенным классом, используемым для геймплея в UE4 и единственным типом, который может Воспроизвестись в Мире. Итак, все, что вы ставите на свой уровень, будет Актером.

Следующий важный тип, о котором нужно знать – Object (Объект). Объект фактически является базовым классом всех классов Unreal, включая Актера и многие другие. Это гораздо более низкоуровневая конструкция, чем Актер, но все же есть функции, которые вы ожидаете от Unreal-класса, такие как Reflection (Отражение) и Serialization (Сериализация). Объект – это очень простой класс, который мы используем, когда нам нужно определить новый тип, который просто не соответствует форме Актера. Например, Компонент Актера является базовым классом для всех Компонентов и происходит от Объекта вместо Актера.

Что собой представляет игровая система в UE4?

Итак, что-то здесь все запуталось (но это же здорово!). Unity дает вам возможность начать разработку вашей новой игры, и Unreal делает то же самое. В Unity вы можете создать все, что связано с базовыми GameObjects и компонентами, а в Unreal вы можете создавать все из Актеров и компонентов.

Однако у Unreal этот дополнительный слой называется Gameplay Framework (игровая система). Все это не может существовать вместе как единое целое. Вам не нужно использовать его в Unreal, но на самом деле все это очень круто! В принципе, если вы используете некоторые базовые примитивные классы и следуете определенным установленным правилам, ваша игра автоматически приобретет некоторые удивительные функции, которые в противном случае было бы очень сложно реализовать или модифицировать (например, полная поддержка мультиплеера!).

Бесчисленные потрясающие игры были разработаны поверх Gameplay Framework Unreal, и стоит потратить некоторое время, чтобы понять, как это работает. Да, вы можете перевернуть свою собственную версию. Это нормально, если вы хотите! Но сотни потрясающих разработчиков Unreal отлично использовали эту инфраструктуру в UE4 сегодня, поэтому стоит потратить некоторое время на изучение.

Чтобы использовать Gameplay Framework, вам просто нужно изучить встроенные классы Актера, включенные в Unreal, такие как Pawn (Пешка), Character (Персонаж) и Player Controller, и в конечном итоге изучить, как работают функции репликации Unreal и сама сеть. А пока давайте вернемся к основам.

Как написать код в UE4

Итак, я программирую в MonoDevelop

Для сценариев Blueprint вам понадобится только Unreal Editor – все уже встроено! Чтобы написать код на C++, загрузите бесплатную версию Visual Studio в Windows или установите Xcode на Mac. Когда вы вначале создаете новый проект (или добавляете код в существующий проект), UE4 автоматически создаст для вас файлы проектов Visual Studio. Вы можете открыть Visual Studio, дважды щелкнув по классу C++ внутри контент браузера или нажав кнопку Open Visual Studio в главном меню File.

Проект в C++ классах UE4

Одно из важных отличий в UE4 в том, что иногда вам придется вручную обновлять файлы проекта Visual Studio (например, после загрузки новой версии UE4 или при внесении изменений в расположение исходных файлов на диске вручную). Вы можете сделать это, нажав кнопку Refresh Visual Studio Project в главном меню, или щелкнув правой кнопкой мышки на файл .uproject в каталоге вашего проекта и выбрав Generate Visual Studio project files.

Generate Visual Studio project files UE4

Написание функций события – запуск, обновление и т.д.

Если вы привыкли работать с MonoBehaviors, вы привыкли к таким методам, как Start (Старт), Update (Обновление) и OnDestroy (удаление). Ниже приведено сравнение режима Unity и его аналога в UE4 Актерах и компонентах.

В Unity у нас может быть простой компонент, который выглядит так: 

public class MyComponent : MonoBehaviour
{
    void Start() {}
    void OnDestroy() {}
    void Update() {}
}

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

Подобно функциям Unity’s Start, OnDestroy и Update, у нас есть аналогичный набор методов для Актеров в UE4:

C++:

UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()

    // Called at start of game.
    void BeginPlay();

    // Called when destroyed.
    void EndPlay(const EEndPlayReason::Type EndPlayReason);

    // Called every frame to update this actor.
    void Tick(float DeltaSeconds);
};

Blueprint:

Инициация события Blueprint UE4

Компоненты в UE4 содержат разные функции. Вот простой пример:

C++:

UCLASS()
class UMyComponent : public UActorComponent
{
    GENERATED_BODY()

    // Called after the owning Actor was created
    void InitializeComponent();

    // Called when the component or the owning Actor is being destroyed
    void UninitializeComponent();

    // Component version of Tick
    void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction);
};

Инициация события Blueprint UE4

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

Например, в Unity C# это будет называться base.Update (), но в UE4 C++ мы будем использовать Super:: TickComponent():

void UMyComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
    // Custom tick stuff here
    Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
}

Возможно, вы уже заметили, что некоторые понятия начинаются с «A», а другие с «U» на C++. Префикс «A» указывает подкласс у класса. А префикс «U» указывает на подкласс Объекта. Существуют и другие префиксы, как, например, «F», который используется для большинства простых структур данных или классов, отличных от UObject.

Написание кода геймплея в UE4

А теперь углубимся в изучение данного материала. Мы будем обсуждать темы программирования, которые имеют решающее значение для создания игр. Поскольку вы знаете Unity, мы будем объяснять функции для пользователей C#, изучающие Unreal C++, но вы можете использовать Blueprint Scripting практически для всего, чего хотите! Мы добавили примеры как в C++, так и в Blueprint, где это было возможно.

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

Instantiating GameObject / Spawning Actor – Мгновенное действие

В Unity мы используем функцию Instantiate для создания новых экземпляров объектов.

Эту функция применяется любым типом Unity Engine.Object (GameObject, MonoBehaviour и др.) и создает его копию.

public GameObject EnemyPrefab;
public Vector3 SpawnPosition;
public Quaternion SpawnRotation;

void Start()
{
    GameObject NewGO = (GameObject)Instantiate(EnemyPrefab, SpawnPosition, SpawnRotation);
    NewGO.name = "MyNewGameObject";
}

В UE4 существует несколько различных функций для создания объектов в зависимости от ваших потребностей. Новый Объект (New Object) используется для создания новых типов UObject, а SpawnActor используется для создания типов AActor.

Сначала мы кратко поговорим о UObjects и NewObject. Подкласс UObject в Unreal очень похож на подкласс Scriptable Object в Unity. Они полезны для классов геймплея, которые не должны проявляться или иметь прикрепленные компоненты, такие как Актеры.

В Unity, если вы создали свой собственный подкласс Scriptable Object, вы можете создать его следующим образом:

MyScriptableObject NewSO = ScriptableObject.CreateInstance<MyScriptableObject>();

А в Unreal, если вы создали свой собственный производный тип UObject, вы можете создать его следующим образом:

UMyObject* NewObj = NewObject<UMyObject>();

Как насчет Актеров? Актеры генерируются с использованием метода SpawnActor на объекте World (UWorld in C++). Как вы получите объект в Мире? Некоторые UObjects используют метод GetWorld, как, например, делают все Актеры.

Вы увидите, что вместо того, чтобы пройти мимо Актера, мы переходим к «class» Актера, которого хотим создать. В нашем примере класс может быть любым подклассом AMyEnemy.

Но а что, если вы хотите сделать «копию» другого объекта, как, например, нам позволяет это сделать Instantiate?

В функциях New Object и Spawn Actor также может быть задан объект «шаблон» для работы. Unreal сделает копию этого объекта вместо того, чтобы сделать его «с нуля». Это скопирует все его УПРАВЛЕНИЯ и компоненты.

AMyActor* CreateCloneOfMyActor(AMyActor* ExistingActor, FVector SpawnLocation, FRotator SpawnRotation)
{
    UWorld* World = ExistingActor->GetWorld();
    FActorSpawnParameters SpawnParams;
    SpawnParams.Template = ExistingActor;
    World->SpawnActor<AMyActor>(ExistingActor->GetClass(), SpawnLocation, SpawnRotation, SpawnParams);
}

Возможно, вас заинтересовало, что означает «с нуля» в данном контексте. Каждый класс объектов, который вы создаете, имеет шаблон по умолчанию, который содержит значения по умолчанию для своих свойств и компонентов. Если вы не переопределите эти свойства и не предоставите свой собственный шаблон, Unreal будет использовать эти значения по умолчанию для создания вашего объекта. Чтобы проиллюстрировать это, давайте сначала посмотрим на MonoBehaviour:

public class MyComponent : MonoBehaviour
{
    public int MyIntProp = 42;
    public SphereCollider MyCollisionComp = null;

    void Start()
    {
        // Create the collision component if we don't already have one
        if (MyCollisionComp == null)
        {
            MyCollisionComp = gameObject.AddComponent<SphereCollider>();
            MyCollisionComp.center = Vector3.zero;
            MyCollisionComp.radius = 20.0f;
        }
    }
}

В приведенном выше примере у нас есть свойство int, которое по умолчанию равно 42, и компонент SphereCollider (сферический коллайдер), который по умолчанию равен радиусу 20.

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

UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()

    UPROPERTY()
    int32 MyIntProp;

    UPROPERTY()
    USphereComponent* MyCollisionComp;

    AMyActor()
    {
        MyIntProp = 42;

        MyCollisionComp = CreateDefaultSubobject<USphereComponent>(FName(TEXT("CollisionComponent"));
        MyCollisionComp->RelativeLocation = FVector::ZeroVector;
        MyCollisionComp->SphereRadius = 20.0f;
    }
};

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

Смена одного типа на другой

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

Unity C#:

Collider collider = gameObject.GetComponent<Collider>;
SphereCollider sphereCollider = collider as SphereCollider;
if (sphereCollider != null)
{
        // ...
}

UE4 C++:

UPrimitiveComponent* Primitive = MyActor->GetComponentByClass(UPrimitiveComponent::StaticClass());
USphereComponent* SphereCollider = Cast<USphereComponent>(Primitive);
if (SphereCollider != nullptr)
{
        // ...
}

Удаление Объекта / Актера

UnityC++Blueprint
Destroy(MyGameObject);

 

 

MyActor->Destroy();

 

 

мой актер blueprint ue4

Удаление Объекта / Актера через 1 секунду

UnityC++Blueprint
Destroy(MyGameObject, 1);

 

MyActor->SetLifeSpan(1);

 

мой актер blueprint ue4 1

Отключение Объектов / Актера

UnityC++
MyGameObject.SetActive(false);

 

// Hides visible components
MyActor->SetActorHiddenInGame(true);

// Disables collision components
MyActor->SetActorEnableCollision(false);

// Stops the Actor from ticking
MyActor->SetActorTickEnabled(false);

 

Blueprint

мой актер blueprint ue4 2

Извлечение Объекта / Актера из Компонента

UnityC++
GameObject ParentGO = 
MyComponent.gameObject;

 

AActor* ParentActor = 
MyComponent->GetOwner();

 

Blueprint

мой компонент blueprint ue4

Извлечение Компонента из Объекта / Актера

Unity

MyComponent MyComp = gameObject.GetComponent<MyComponent>();

C++

UMyComponent* MyComp = MyActor->FindComponentByClass<UMyComponent>();

Blueprint

Извлечь компонент из класса UE4

Поиск Объектов / Актера

// Find GameObject by name
GameObject MyGO = GameObject.Find("MyNamedGameObject");

// Find Objects by type
MyComponent[] Components = Object.FindObjectsOfType(typeof(MyComponent)) as MyComponent[];
foreach (MyComponent Component in Components)
{
        // ...
}

// Find GameObjects by tag
GameObject[] GameObjects = GameObject.FindGameObjectsWithTag("MyTag");
foreach (GameObject GO in GameObjects)
{
        // ...
}

// Find Actor by name (also works on UObjects)
AActor* MyActor = FindObject<AActor>(nullptr, TEXT("MyNamedActor"));

// Find Actors by type (needs a UWorld object)
for (TActorIterator<AMyActor> It(GetWorld()); It; ++It)
{
        AMyActor* MyActor = *It;
        // ...
}

Извлечь всех актеров из класса ue4

// Find UObjects by type
for (TObjectIterator<UMyObject> It; It; ++it)
{
    UMyObject* MyObject = *It;
    // ...
}

// Find Actors by tag (also works on ActorComponents, use TObjectIterator instead)
for (TActorIterator<AActor> It(GetWorld()); It; ++It)
{
    AActor* Actor = *It;
    if (Actor->ActorHasTag(FName(TEXT("Mytag"))))
    {
        // ...
    }
}

Получить всех актеров из класса ue4 1

Добавление тегов в Объекты / Актер

MyGameObject.tag = "MyTag";

// Actors can have multiple tags
MyActor.Tags.AddUnique(TEXT("MyTag"));

Добавить тег ue4

Добавление тегов в MonoBehaviours / Компоненты Актера

// This changes the tag on the GameObject it is attached to
MyComponent.tag = "MyTag";

// Components have their own array of tags
MyComponent.ComponentTags.AddUnique(TEXT("MyTag"));

Сравнение тегов с Объектами / Актерами и MonoBehaviours / Компонентами Актера

if (MyGameObject.CompareTag("MyTag"))
{
    // ...
}

// Checks the tag on the GameObject it is attached to
if (MyComponent.CompareTag("MyTag"))
{
    // ...
}

// Checks if an Actor has this tag
if (MyActor->ActorHasTag(FName(TEXT("MyTag"))))
{
    // ...
}

Актер имеет тег ue4

// Checks if an ActorComponent has this tag
if (MyComponent->ComponentHasTag(FName(TEXT("MyTag"))))
{
    // ...
}

Тег у компонента ue4Физика: RigidBody против Примитивного Компонента

В Unity, чтобы придать какие-либо физические характеристики для Объекта, вы сначала даете ему компонент RigidBody. В Unreal любой PrimitiveComponent (UPrimitiveComponent в C++) может быть физическим объектом. Некоторые общие Примитивные Компоненты – это Shape Components (фигурные компоненты) (Capsule/капсула, Sphere/сфера, Box/куб), Компонент Static Mesh и Компонент Skeletal Mesh.

В отличие от Unity, который разделяет возможности столкновения и визуализации на отдельные компоненты, Unreal объединяет концепции потенциально физических и потенциально видимых компонентов в Primitive Component. Любой компонент, который имел бы любую геометрию в мире, которую можно было бы визуализировать или взаимодействовать с физическими подклассами, является компонентом из Primitive Component.

Слои против Каналов

В Unity они называются слоями. UE4 использует Collision Channels (каналы столкновения), и они работают аналогичным образом.

RayCast против RayTrace

Unity C#:

GameObject FindGOCameraIsLookingAt()
{
    Vector3 Start = Camera.main.transform.position;
    Vector3 Direction = Camera.main.transform.forward;
    float Distance = 100.0f;
    int LayerBitMask = 1 << LayerMask.NameToLayer("Pawn");

    RaycastHit Hit;
    bool bHit = Physics.Raycast(Start, Direction, out Hit, Distance, LayerBitMask);

    if (bHit)
    {
        return Hit.collider.gameObject;
    }

    return null;
}

UE4 C++:

APawn* AMyPlayerController::FindPawnCameraIsLookingAt()
{
    // You can use this to customize various properties about the trace
    FCollisionQueryParams Params;
    // Ignore the player's pawn
    Params.AddIgnoredActor(GetPawn());

    // The hit result gets populated by the line trace
    FHitResult Hit;

    // Raycast out from the camera, only collide with pawns (they are on the ECC_Pawn collision channel)
    FVector Start = PlayerCameraManager->GetCameraLocation();
    FVector End = Start + (PlayerCameraManager->GetCameraRotation().Vector() * 1000.0f);
    bool bHit = GetWorld()->LineTraceSingle(Hit, Start, End, ECC_Pawn, Params);

    if (bHit)
    {
        // Hit.Actor contains a weak pointer to the Actor that the trace hit
        return Cast<APawn>(Hit.Actor.Get());
    }

    return nullptr;
}

Blueprint в UE4:

Blueprint в UE4

Триггеры

Unity C#:

public class MyComponent : MonoBehaviour
{
    void Start()
    {
        collider.isTrigger = true;
    }
    void OnTriggerEnter(Collider Other)
    {
        // ...
    }
    void OnTriggerExit(Collider Other)
    {
        // ...
    }
}

UE4 C++:

UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()

    // My trigger component
    UPROPERTY()
    UPrimitiveComponent* Trigger;

    AMyActor()
    {
        Trigger = CreateDefaultSubobject<USphereComponent>(TEXT("TriggerCollider"));

        // Both colliders need to have this set to true for events to fire
        Trigger.bGenerateOverlapEvents = true;

        // Set the collision mode for the collider
        // This mode will only enable the collider for raycasts, sweeps, and overlaps
        Trigger.SetCollisionEnabled(ECollisionEnabled::QueryOnly);
    }

    virtual void NotifyActorBeginOverlap(AActor* Other) override;

    virtual void NotifyActorEndOverlap(AActor* Other) override;
};

UE4 Blueprint:

Актер событие ue4

Kinematic Rigidbodies – Кинематические жесткие тела

Unity C#:

public class MyComponent : MonoBehaviour
{
    void Start()
    {
        rigidbody.isKinimatic = true;
        rigidbody.velocity = transform.forward * 10.0f;
    }
}

В UE4 компонент столкновения и компонент жесткого тела – одно целое. Базовым классом для этого является UPrimitive Component, который имеет множество подклассов (USphere Component, UCapsule Component и т.д.) в зависимости от ваших потребностей.

UE4 C++:

UCLASS()
class AMyActor : public AActor
{
    GENERATED_BODY()

    UPROPERTY()
    UPrimitiveComponent* PhysicalComp;

    AMyActor()
    {
        PhysicalComp = CreateDefaultSubobject<USphereComponent>(TEXT("CollisionAndPhysics"));
        PhysicalComp->SetSimulatePhysics(false);
        PhysicalComp->SetPhysicsLinearVelocity(GetActorRotation().Vector() * 100.0f);
    }
};

Input events – вводные события

Unity C#:

public class MyPlayerController : MonoBehaviour
{
    void Update()
    {
        if (Input.GetButtonDown("Fire"))
        {
            // ...
        }
        float Horiz = Input.GetAxis("Horizontal");
        float Vert = Input.GetAxis("Vertical");
        // ...
    }
}

UE4 C++:

UCLASS()
class AMyPlayerController : public APlayerController
{
    GENERATED_BODY()

    void SetupInputComponent()
    {
        Super::SetupInputComponent();

        InputComponent->BindAction("Fire", IE_Pressed, this, &AMyPlayerController::HandleFireInputEvent);
        InputComponent->BindAxis("Horizontal", this, &AMyPlayerController::HandleHorizontalAxisInputEvent);
        InputComponent->BindAxis("Vertical", this, &AMyPlayerController::HandleVerticalAxisInputEvent);
    }

    void HandleFireInputEvent();
    void HandleHorizontalAxisInputEvent(float Value);
    void HandleVerticalAxisInputEvent(float Value);
};

в Blueprint на UE4:

Вводные события ue4

Вот как выглядят ваши свойства ввода в ваших настройках проекта:

input в движке ue4Вопросы – Ответы

Как автоматически загрузить мой последний проект?

Если вы привыкли к Unity, автоматически загружающему последний проект, над которым вы работали, то в UE4 это тоже возможно. Чтобы это включить, при открытии проекта установите флажок “Always load last project on Startup” (Всегда загружать последний проект при запуске). Вы также можете переключать настройку в любое время из главного меню Edit в разделе Edit/Editor Preferences/Loading and Saving/Startup.

Где я могу устанавливать вводные Привязки для своей игры?

В Unity вы привыкли использовать настройки Input Manager для Project для установки привязок по умолчанию. В UE4 он работает аналогичным образом. Вы откроете свои настройки проекта, затем выберите категорию Input. Там вы можете добавлять различные кнопки (действия) и аналоговые элементы управления (оси). Дайте каждому элементу управления имя и привязку по умолчанию. Затем вы можете получить обратные вызовы к своей Пешке, когда запускаются входные события. Ознакомьтесь со страницей документации ввода для получения подробной информации.

Как изменить стартовую сцену моего проекта?

Вы можете изменить стартовую карту своего проекта с вкладки параметров проекта. В главном меню выберите Edit/Project Settings->Maps & Modes, для того чтобы изменить стартовую карту.

Как запустить свою игру?

Самый простой способ запустить игру – нажать кнопку “Play” на панели главного редактора, которая будет запускать игру прямо внутри процесса редактора. Если вы хотите запустить его как отдельное приложение, нажмите стрелку раскрывающегося списка рядом с “Play” и выберите “Standalone Game” (Автономная игра). Ну а если вы хотите работать на мобильном устройстве или в веб-браузере, вы будете использовать кнопку «Launch» на панели инструментов (после установки каких-либо предварительных условий, необходимых для этой платформы).

Какие есть Units? – какие есть единицы измерения?

В Unity первичная единица измерения – один метр. В UE4 первичный юнит измерения составляет один сантиметр.

Таким образом, если вы перемещаете что-то на 1 unit (1 метр), это эквивалентно перемещению в UE4 около 100 units (сантиметров).

Если вы хотите переместить что-то на 2 фута в Unity, которое будет составлять 0,61 юнита (метра), а в UE4 – 61 юнита (сантиметр).

Какой является эта система координат? Какой способ для поднятия?

Как Unity, так и UE4 используют левую систему координат, но оси меняются местами. В UE4 положительный X является командой «вперед», положительный Y является командой «направо», а положительный Z – «вверх».

Как я могу выйти из моей игры?

В редакторе UE4 вы можете открыть «Output Log» в меню «Window -> Developer Tools». Вы также можете запустить свою игру с параметром командной строки «-log», чтобы вызвать выделенное окно журнала рядом с игрой, что очень удобно!

Говоря о выходе, где находится мой Debug.Log?

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

Есть ли исключения?

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

Где находится .NET Framework?

В отличие от Unity, UE4 не использует платформу .NET. UE4 и имеет собственный набор хранилищ и библиотек. Общие сравнения хранилищ:

.Net FrameworkUE4
СтрокаFString, FText
СписокTArray
СловарьTArray
HeshsetTSet

Узнать больше о других вместилищах UE4 вы можете здесь.

Unreal перезагружает изменения кода автоматически?

Да! Вы можете оставить редактор открытым во время написания кода. Просто начните сборку из Visual Studio после того, как вы закончите редактирование кода, и редактор автоматически перезагрузит (“hot reload”) ваши изменения. Вы также можете нажать кнопку **Compile** (Скомпилировать) на главной панели редактора. Это может пригодиться при подключении наладчика Visual Studio.

Как перейти дальше

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

У нас есть много дополнительных учебных ресурсов UE4!

  • Документация
    • Начало работы – GettingStarted
  • Учебное видео – Видео
  • API – API
  • AnswerHub – https://answers.unrealengine.com
  • Форумы – https://forums.unrealengine.com
  • Википедия – https://wiki.unrealengine.com
    • Страница Wiki об обучении UE4, поступающей из Unity