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

Сравнение движков Unity и UE4, чтобы вы могли быстро освоиться.

Windows
MacOS
Linux

image_0.png

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

Редактор

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

EditorCompare_Windows.png

EditorCompare_Mac.png

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

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

TabbedWindows_Windows.png

TabbedWindows_Mac.png

Словарь терминов

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

Категория

Unity

UE4

Базовые типы

Component

Component

GameObject

Actor, Pawn

Prefab

Blueprint Class

Интерфейс редактора

Hierarchy Panel

World Outliner

Inspector

Details Panel

Project Browser

Content Browser

Scene View

Viewport

Меши

Mesh

Static Mesh

Skinned Mesh

Skeletal Mesh

Материалы

Shader

Material, Material Editor

Material

Material Instance

Эффекты

Particle Effect

Effect, Particle, Cascade

Shuriken

Cascade

Игровой интерфейс

UI

UMG (Unreal Motion Graphics)

Анимация

Animation

Skeletal Animation System

Mecanim

Persona , Animation Blueprint

2D

Sprite Editor

Paper2D

Программирование

C#

C++

Script

Blueprint

Физика

Raycast

Line Trace, Shape Trace

Rigid Body

Collision, Physics

Платформы запуска

iOS Player, Web Player

Platforms

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

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

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

Куда я должен поместить свои ассеты?

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

ProjectOnDisk_Windows.png

ProjectOnDisk_Mac.png

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

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

Тип ассета

Поддерживаемые форматы

3D объекты

.fbx, .obj

Текстура

.png, .jpeg, .bmp ,.tga, .dds, .exr, .psd, .hdr

Звук

.wav

Шрифты

.ttf, .otf

Видео

.mov, .mp4, .wmv

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

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

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

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

Где мои файлы исходного кода?

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

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

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

От GameObject к Актору

Где мой 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 Actor - это  C++ класс, который можно расширять и изменять с помощью наследования. Мы поговорим об этом позже!

Где мои Components?

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

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

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

От Префабов Unity к Блупринтам UE4

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

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

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

Где Script Component и MonoBehaviour?

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

UE4 имеет нечто подобное. Вы можете создавать новые собственные классы компонентов (Component Class) и добавлять их к любому Актору. Можно создавать компоненты как на языке C++, так и на Blueprint Visual Scripting (системе визуального программирования).

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

image alt text

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

В UE4, также есть стандартные методы InitializeComponent() и TickComponent(), которые аналогичны Start и Update.

Если вы создадите класс компонента через Blueprint Script Component вы получите такие же функции в системе программирования Blueprint:

image alt text

Программируемый актор

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

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

Unity C#

UE4 C++

UE4 Blueprint

    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);
        }
    }
    #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 Классы могут быть расширены

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

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

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

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

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

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

Нужно ли использовать визуальное программирование Blueprint Scripting, C++, или всё вместе?

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

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

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

С++ класс как основа для Blueprint класса

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

image alt text

Компонент Transform

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

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

Даже если вы поместите пустой Empty Actor, UE4 создаст "Default Scene Root" - простой Scene Component для актора. Если вы добавите новый Scene component, он заменит Default Scene Root.

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

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

image alt text

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

image alt text

Как видно из диаграммы, вложенные иерархии могут быть созданы путем присоединения Scene Components друг к другу, поскольку они имеют transform, аналогичный transform в Unity. Actor Component (базовый класс для всех компонентов в UE4) могут быть присоединены только непосредственно к актору.

Я строю все из компонентов?

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

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

  • Pawn - Пешка, тип актора, который описывает контролируемый игровой объект, обычно персонаж в игре. Пешки управляются игроками и ИИ через контроллер.

  • Character - более специализированная версия Pawn для антропоморфных персонажей с реализацией передвижения ногами.

  • Controller - управляет акторами Pawn (Пешка). Логически разделяя объект актора-персонажа и контроллер, вы можете писать ИИ контроллеры которые могут управлять акторами используя тот же интерфейс что и игрок.

  • Player Controller - контроллер игрока , предназначенный для получения ввода от геймпада, сенсорного экрана или мыши/клавиатуры игрока и использования этого ввода для управления акторами Pawn или Character.

Так всё ли актор?

Не всё. Акторы - это единственный класс объектов UE4 который может быть размещён в уровне.

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

Что за игровой фреймворк в UE4?

Okay, so this is where things get a little crazy (in sort of an awesome way.) Unity gives you a clean slate to start designing your game, and Unreal does the same. In Unity you can build everything out of basic GameObjects and components, and in Unreal you can build everything out of Actors and components.

However Unreal has this extra layer on top called the Gameplay Framework. This does not really exist in Unity at all. You do not have to use it in Unreal, but it is actually super cool! Basically, if you make use of some basic primitive classes and follow certain established conventions, your game will acquire some awesome features automatically that would be otherwise very difficult to implement or retrofit (such as full multiplayer support!)

Countless awesome games have been designed on top of Unreal's Gameplay Framework, and it is worth taking some time to understand how it works. Yes, you could roll your own version of this. That is totally fine if you want to! But hundreds of awesome Unreal developers have made great use of this framework in UE4 today, so it is worth taking some time to learn.

To use the Gameplay Framework, you really just need to learn the customized built-in Actor classes included with Unreal, such as Pawn, Character, and Player Controller, and eventually learn about how Unreal replication and networking features work. For now, let us get back to the basics though.

How to write code in UE4

So, I'm used to programming in MonoDevelop

For Blueprint scripting, you will only need Unreal Editor -- everything is built in! To write code in C++, download the free version of Visual Studio on Windows, or install Xcode on Mac. When you first create a new project (or add code to an existing project), UE4 will automatically create Visual Studio project files for you. You can open Visual Studio by Double-clicking on a C++ class inside Content Browser, or by clicking the Open Visual Studio button in the main File menu.

image alt text

One important difference in UE4: You will sometimes have to manually refresh your Visual Studio project files (for example, after downloading a new version of UE4, or when manually making changes to source file locations on disk.) You can do this by clicking Refresh Visual Studio Project in the main menu, or by Right-clicking on the .uproject file in your project's directory and selecting Generate Visual Studio project files.

image alt text

Writing Event Functions (Start, Update, etc.)

If you are used to working with MonoBehaviors you are used to such methods as Start, Update, and OnDestroy. Here is a comparison between a Unity behavior and its counterpart in UE4 Actors and components.

In Unity, we might have a simple component that looks like this:

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

But remember, in UE4 you can write code right on the Actor itself rather than only coding new component types. This is actually very common and useful.

Similar to Unity's Start, OnDestroy, and Update functions, we have a similar set of methods for Actors in 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 :

image_29.png

Components in UE4 contain different functions. Here is a simple example:

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 :

image_30.png

Remember, in UE4 it is important to call the parent class' version of method.

For example, in Unity C# this would be called base.Update(), but in UE4 C++ we will use Super::TickComponent():

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

You may have noticed some things begin with "A" and others with "U" in C++. The prefix "A" indicates an Actor sub-class. Where as the prefix "U" indicates an Object sub-class. There are some other prefixes too, for example "F" is used for most plain data structures or non-UObject classes.

Writing gameplay code in UE4

Okay, things are going to get a bit deeper from here on out. We will be talking about programming topics that are critical for creating games. Because you know Unity, we will be explaining features with slant toward C# users learning Unreal C++, but you can use Blueprint Scripting for pretty much everything if you want! We have added examples in both C++ and Blueprint where possible.

Let us talk about some of the most common gameplay programming patterns and how you would approach them in Unreal. Many functions in Unity have a comparable function in Unreal that should seem familiar. We will go through the most common functions one by one.

Instantiating GameObject / Spawning Actor

In Unity, we use the Instantiate function to create new instances of objects.

This function takes any UnityEngine.Object type (GameObject, MonoBehaviour, etc.), and makes a copy of it.

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

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

In UE4, there are a couple different functions to instantiate objects, depending on your needs. NewObject is used for creating new UObject types, and SpawnActor is used for spawning AActor types.

First we will briefly talk about UObjects and NewObject. Subclassing UObject in Unreal is much like subclassing ScriptableObject in Unity. They are useful for gameplay classes that do not need to spawn into the world or have attached components like Actors do.

In Unity, if you created your own subclass of ScriptableObject, you may instantiate it like this:

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

And in Unreal, if you created your own UObject derived type, you may instantiate it like this:

UMyObject* NewObj = NewObject<UMyObject>();

So what about Actors? Actors are spawned using the SpawnActor method on a World (UWorld in C++) object. How do you get the World object? Some UObjects provide a GetWorld method for you, as an example, all Actors do.

You will notice instead of passing in another Actor, we pass in the "class" of the Actor we want to spawn. In our example, the class can be any subclass of AMyEnemy.

But what if you want to make a "copy" of another object, like what Instantiate allows you to do?

The NewObject and SpawnActor functions can also be given a "template" object to work with. Unreal will make a copy of that object, instead of making one "from scratch". This will copy over all of its UPROPERTYs and components.

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);
}

You might be wondering what "from scratch" means in this context. Each object class you create has a default template that contain default values for its properties and components. If you do not override these properties and do not provide your own template, Unreal will use these default values to construct your object. To help illustrate this, let us first look at a MonoBehaviour for example:

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;
        }
    }
}

In the above example, we have an int property that defaults to 42, and a SphereCollider component that defaults to a radius of 20.

We can achieve the same thing in Unreal using the object's constructor.

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;
    }
};

In the constructor of AMyActor, we have set the default property values for the class. Note the use of the CreateDefaultSubobject function. We can use it to create components and assign default properties to them. All the subobjects we create using this function act as a default template, so we can modify them in a subclass or Blueprint.

Casting from one Type to Another

In this case, we get a component we know we have, then cast it to a specific type and conditionally do something.

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)
{
        // ...
}

Destroying GameObject / Actor

Unity

C++

Blueprint

    Destroy(MyGameObject);
    MyActor->Destroy();

image_23.png

Destroying GameObject / Actor (With 1 Second Delay)

Unity

C++

Blueprint

    Destroy(MyGameObject, 1);
    MyActor->SetLifeSpan(1);

Click for full view.

Disabling GameObjects / Actors

Unity

C++

Blueprint

    MyGameObject.SetActive(false);
    // Hides visible components
    MyActor->SetActorHiddenInGame(true);

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

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

Click for full view.

Accessing the GameObject / Actor from Component

Unity

C++

Blueprint

    GameObject ParentGO = 
    MyComponent.gameObject; 
     AActor* ParentActor = 
     MyComponent->GetOwner();

Click for full view.

Accessing a Component from the GameObject / Actor

Unity

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

C++

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

Blueprint

image_33.png

Finding GameObjects / Actors

// 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;
        // ...
}

image alt text

// 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"))))
    {
        // ...
    }
}

image alt text

Adding tags to GameObjects / Actors

MyGameObject.tag = "MyTag";

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

image alt text

Adding tags to MonoBehaviours / ActorComponents

// 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"));

Comparing tags on GameObjects / Actors and MonoBehaviours / ActorComponents

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"))))
{
    // ...
}

image alt text

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

image alt text

Physics: RigidBody vs. Primitive Component

In Unity to give any GameObject physics characteristics, you first give it a RigidBody component. In Unreal, any PrimitiveComponent (UPrimitiveComponent in C++) can be a physical object. Some common Primitive Components are ShapeComponents (Capsule, Sphere, Box), StaticMeshComponent, and SkeletalMeshComponent.

Unlike Unity which separates the responsibilities of collision and visualizations into separate components. Unreal combines the concepts of the potentially physical and the potentially visible into PrimitiveComponent. Any component that would have any geometry in the world, that could either be rendered or interacted with physically sub-classes from PrimitiveComponent.

Layers vs Channels

In Unity, they are called "Layers". UE4 uses Collision Channels, and they work in a similar way. You can read up on them here.

RayCast vs 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;
}

UE4 Blueprint:

Click for full view.

Triggers

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:

image alt text

You can read more about setting up collision responses here.

Kinematic Rigidbodies

Unity C#:

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

In UE4, The collision component and rigidbody component are one. The base class for this is UPrimitiveComponent, which has many subclasses (USphereComponent, UCapsuleComponent, etc.) to suit your needs.

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);
};

UE4 Blueprint:

image alt text

This is what your input properties in your Project Settings might look like:

image alt text

You can read more about how to setup input here.

FAQ

How do I load my last project automatically?

If you are used to Unity automatically loading the last project you were working on, the same is possible in UE4. To enable, check "Always load last project on Startup" when opening a project. You can also toggle the setting at any time from the main Edit menu under Edit/Editor Preferences/Loading and Saving/Startup.

Where do I set Input Bindings for my game?

In Unity, you are used to using the Input Manager settings for Project to setup default bindings. In UE4 it works similarly. You will open your Project Settings then select the Input category. There, you can add various buttons (actions) and analog controls (axes). Give each control a name and default binding. Then, you can get callbacks to your game's Pawn when the input events are triggered. Check out the Input documentation page for the details.

How do I change the starting scene of my project?

You can change the startup map of your project from the project settings tab. From the main menu choose Edit/Project Settings->Maps & Modes to change the starting map.

How do I run my game?

The easiest way to run your game is to click the "Play" button on the the main editor toolbar, which will run the game right inside the editor's process. If you want to run it as a standalone application, click the dropdown arrow next to "Play" and choose "Standalone Game". Finally, if you want to run on a mobile device or in a web browser, you will use the "Launch" button on the toolbar (after installing any prerequisites that are needed for that platform.)

What units are these?

In Unity, the primary unit of measurement is one meter. In UE4, the primary unit of measurement is one centimeter.

So if you move something 1 unit (meter) in unity that is equivalent to moving something 100 units (centimeters) in UE4.

If you want to move something 2 Feet in Unity that would be 0.61units (meter) and in UE4 is 61 units (centimeters).

What is with this coordinate system? Which way is up?

Both Unity and UE4 use a left-handed coordinate system, but the axes are swapped around. In UE4, positive X is "forward", positive Y is "right" and positive Z is "up".

How do I see Log Output from my game?

In the UE4 editor, you can open the "Output Log" from the "Window -> Developer Tools" menu. You can also run your game with the "-log" command-line parameter to summon a dedicated log window alongside your game, which is really useful!

Speaking of Log Output, where is my Debug.Log?

Logging in UE4 is highly customizable. Read up on how to log messages here.

How do I throw exceptions?

In Unity, you are used to throwing exceptions when things go wrong. UE4 does not use exception handling. Instead, use the 'check()' function to trigger a critical assertion error. You can pass in an error message. If you want to report an error but not halt the program, use 'ensure()' instead. This will log an error with a full call stack, but program execution will continue. If you had a debugger attached, both functions will break into the debugger.

Where is the .NET Framework?

Unlike Unity, UE4 does not use the .NET framework. UE4 has its own set of container classes and libraries. Common container comparisons:

.Net Framework

UE4

String

FString, FText

List

TArray

Dictionary

TMap

HashSet

TSet

You can learn more about other UE4 containers here.

Does Unreal automatically reload code changes?

Yes! You can leave the editor open while you write code. Simply kick off a compile from Visual Studio after you have finished editing code, and the editor will "hot reload" your changes automatically. You can also click the Compile button on the editor's main toolbar. That can be useful when you have the Visual Studio debugger attached.

Where to go from here

Thanks for reading the guide! This was created for the Unreal community with the help of Unreal developers everywhere, and we very much appreciate any feedback and corrections you can offer. We will try to keep improving this document as we learn more about what is most helpful when transitioning to UE4!

We have many additional UE4 learning resources available!

Tags
Выбрать тему
Светлая
Темная

Добро пожаловать на новый сайт документации Unreal Engine 4!

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

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

Отправить отзыв