All content in this course uses:

Transitioning from Unreal to Unity

This guide is meant to assist Unreal Engine developers in familiarizing themselves with the Unity engine, its Editor, and its various workflows.

AccessibiltyTables.pdf

Before getting started in Unity, you need to install the right version of the engine for your needs. This can be accomplished via the 

, a standalone application that streamlines the way you find, download, and manage your Unity Projects and installations. The latest version of Unity can be accessed from the “Installs” page by clicking the “Add” button.

The recommended IDE (integrated development environment) for programming in Unity is Visual Studio, and the latest versions of Unity come packaged with Visual Studio Professional 2019. However, there is no strict requirement for what IDE needs to be used because Unity compiles all your scripts via the Unity Editor. This means that you can use whichever code editor you prefer, and many tools have existing Unity integrations. 

We install and recommend Visual Studio, because it gives you benefits like Intellisense and Auto-Completion, along with debugging tools like break and watch points.Visual Studio comes pre-installed, so there’s no need to configure anything. However, if you’re curious to learn more, you can check out the 

Getting Started

Opening Unity for the first time, you should see a layout that is similar to Unreal. Both Editors have a fully modular, customizable window system. This allows you to move, resize, and replace tabs and panels within the interface. Below are highlights of the important views in Unity and their equivalent in the Unreal Editor.

 is Unity’s Viewport, which allows you to visually navigate and edit your Scene. Selecting a 

 brings up a familiar 3D transformation handle, the type of which can be chosen with the buttons to the top left in the toolbar (which also allows you to select pivot options and switch between world/local orientation). In the center of the toolbar are the play, pause, and frame skip buttons, which allow you to test the game directly in the editor.

, located in the upper right of the Scene view, represents the view’s orientation. Clicking an axis aligns the view to that axis, and clicking the cube in the center swaps between orthographic and perspective views.

Tabbed behind the Scene view by default, the 

 provides the “Play in Editor” functionality of Unity. 

In Unreal, when the game is launched in the Editor, it is played in the active Viewport. Unreal possess the player pawn and the Viewport acts as an actual game view. Unpossessing allows you to edit the level while the game is running.

Unity separates these two “modes” into the Scene and Game views respectively. The Game view captures the cursor and responds to inputs just like a game build. Switching to the Scene view allows for updates at runtime, and it’s common to lay them out side-by-side to allow for rapid iteration.

In Unreal, all the Actors in your active sublevels are listed in the World Outliner. This provides a way for you to organize, filter, and set the visibility of Actors.

 is Unity’s equivalent, providing the same search and visibility functionality, while also providing a way to manage active scenes and add new GameObjects.

 is the Unity equivalent of the Content Browser, and it shows all available Assets in the Project. There is a search functionality, and you can filter and save searches to make finding Assets easier. Additionally, any external packages used by the project show their assets in a separate folder below the Project Assets.

 serves the same function as the Details panel in Unreal. It allows you to view and edit component properties when clicking on a GameObject or Prefab. 

Unlike the way that Unreal opens new windows to edit Asset settings, Unity shows relevant information and settings for Assets in the Inspector when they are selected in the Project window.

 appears tabbed behind the Project window, and serves as the debug output for the game and Editor. Using the “Debug” class in C#, you can output a range of messages using the following functions:

In the top menu bar of the Console, you can clear or filter these messages, and enable “Pause on Error” functionality. The debug functions also have a 

argument, which allows you to associate a GameObject to the message. When a message with a 

 is double clicked, the GameObject is focused in the scene view and hierarchy.

 tab is absent from Unity. Most Object placement is done directly from the Project window. Special interactions such as foliage painting or landscape sculpting are usually done either from a separate tool window, or contextually after selecting a relevant Object in the Scene.

. This is where you edit can things like Input, Physics, Collision Layers and Editor behavior.



.This enables you to change External Tools, Hotkeys, and Colors.



 menu option is where you can find all available tool windows in your Unity project. This includes default engine windows  (Scene, Inspector, Hierarchy) and any windows added by plugins or project code. If you want to restore a closed tab, this is where you can find it.

The Editor

A Unity Project is set up in a similar manner as an Unreal project, but there is a major difference in the way that Assets are managed. 



Instead of separating “Content” and “Source”, in Unity all Assets including source code are stored in the 

The only exception is the “Package” folder, which is used by Unity’s

 to store installed packages (similar to Unreal’s Plugins folder).

Assets in Unreal are stored as UAssets, which are Unreal specific Assets that allow Assets from various sources and file types to be imported as a single uniform type. UAssets store both the required data from the asset, as well as any engine related data like texture filtering or mesh collision. This also means that Unreal doesn’t actually store the original asset in its project structure. 

, alongside individual “.meta” files that contains the engine and Editor-specific data for the associated Asset. Behind the scenes, Unity processes an imported asset into an optimized, game-ready format which is what the engine actually uses at runtime. These processed assets are stored in the 

 folder, which serves as a cache and does not need to be added to source control.

Unity supports a broad array of file formats:

 are the equivalent of Map files in Unreal, and contain all the data for a specific level. 

When you are working in the Editor, you are most often actively editing some kind of .scene file (unless you are editing an individual Prefab in Prefab Mode, which is explained in the Using Prefab Mode section). Just like Unreal, you can have multiple Scenes loaded at the same time. 

A convenient bonus of Scene files is that they are, by default, registered as Unity Assets on your computer. This allows you to open the Unity Editor directly when clicking on them in your computer’s file browser.

Project and Assets

In Unreal, the basic entity that exists in your game world is an Actor. Unity’s equivalent is a 

. Actors and GameObjects are similar in that they both receive components and can be moved, rotated, and scaled in the world using their transforms (Or in Unity’s case, the Transform component).

However, there’s an important difference between Unity and Unreal. 


Unreal has specialized Actors, such as Pawns and Characters. Actors in Unreal can be extended and specialized in code to have special functionality that’s built right into the Actor itself.

Unity’s GameObjects, on the other hand, are a sealed class and cannot be extended or specialized; the behavior of a GameObject is entirely defined by its components. Instead of having a Player Character Pawn, you have a GameObject with a Player Character component.

GameObjects can be created via the “GameObject” menu in the menu bar, or by clicking the plus button (

) at the top of the Hierarchy window. This instantiates the selected GameObject into the Scene. It can then be moved around or attached to other GameObjects.

Both Unity and Unreal use components, but due to the way GameObjects work, the implementation is slightly different.

Components in Unreal
Unreal has two types of components: Actor Components and Scene Components. While Actor Components simply add behavior to the actor, Scene Components also have a transform and exist in the world as a child of the Actor. 

Static Mesh Components are a common type of Scene Component, and one Actor can have several Static Mesh Components attached to them to create a more complex shape in the world.

Unity components function like Actor Components, meaning that they don’t have any physical presence in the world. Generally, the only entity with a Transform in Unity is a GameObject. In order to get functionality like Scene Components, you can make a hierarchy of GameObjects by dragging one onto another in the 

Example: Creating a house in both engines

One useful example to highlight this difference is creating a house in both engines: 

In Unreal, you would make a “House” Actor with several static mesh components for the floor, walls, and roof. 


In Unity, you would have a “House” parent GameObject. Under this you would add additional child GameObjects for the floor, walls, and roof — each with its own Mesh Renderer component.

Components can be added to GameObjects either via the 

 button in the Inspector. 

Clicking the 

 button brings up a search widget which you can use to find the component you want to add. You can also select the 

 button from here to immediately create a new component script and add it to the GameObject. 

Components can also be added at run time. To do this, use the 

 function, where “T” is the component type you want to add.

Actors to GameObjects, Components to Components

One of the functions of Unreal Blueprints is to allow you to create instances of Actors with unique components and properties for use in your project. The Blueprints you create are stored as Assets that you can place and spawn at will.

. A Prefab is a hierarchy of GameObjects that are saved as an Asset. Prefabs can either be dragged and dropped directly into the 

 from the Project window or spawned via reference in a script. 

If the 

is updated, all instances of that Prefab in all Scenes are updated. However, if property changes are made to a 

 in a scene, it keeps those modified properties.

Similarly to how Blueprints have their own Asset window for editing them, Unity gives you the ability to view Prefab Assets outside of a Scene in 

. This allows you to make local adjustments and add child GameObjects. Prefab Mode can be accessed by double-clicking the Prefab in the Project window, or by clicking the right-facing arrow next to the Prefab Instance in the Hierarchy.

Unlike Blueprints, which have an embedded visual scripting system, Prefabs do not have any scripting capabilities or features. 

All the behavior of a Prefab come from the components of the GameObjects it contains. Custom behavior is created by writing C# scripts.

A useful component in Unreal Blueprints is the 

, which allows you to use one Actor as a component of another. This allows for situations where two Blueprints must exist separately but are intrinsically linked — for example, a Player Character holding a Sword Prop.

 functionality, which allows you to place Prefabs into other Prefabs while still maintaining a link to the original. This means that if you update the child Prefab, it automatically updates in every other Prefab it is nested within.

Blueprints to Prefabs

Unlike Unreal, which uses C++ for low level behavior and Blueprints for scripting, all Unity scripting is done in C#. However, just like Unreal, Unity scripting is mostly based around 

 like frame updates and overlaps. 

You can find some examples below:

For more information on how and when Unity’s Events get executed, see 

Scripting Components Using Monobehaviours

As previously mentioned, GameObjects do not support custom behavior like Actors do, as they are a sealed class. Instead, all of their behavior comes from their components. You can create component classes by extending Unity’s 

. MonoBehaviour is the base class for all component scripts, and is what allows your code to be attached to GameObjects.

Example: Review a component script for Unity

Let’s review the following script for a component that logs various messages based on events it receives:

The script is setup as a fairly generic C# class that extends Monobehaviour, but there are a few important things to note:

At the top of the class body, the script defines two string variables for the component to log when it starts and when it is hit. However, the two string variables are not defined anywhere in the code. This is because these variables are serialized, and will be available as properties to be configured in the Editor using the Inspector.

This is very similar to the use of UProperties in Unreal. In Unity, you can make a variable appear in the Inspector by adding the “

” attribute above the variable declaration. By default, public variables are serialized and private variables are not, so using the attribute is unnecessary for public variables. 

You can still initialize the variable even when it’s serialized, as you can see with the 

variable. This will act as the default value when the variable is shown in the Inspector.

Below those declarations are functions that Unity will call in response to specific events: 


 is called as soon as the component’s GameObject is active in the Scene.


 is called whenever a collider on the GameObject is hit by something with a Rigidbody component attached. 


 If the Update() function is unnecessary, it’s good practice to remove the function from the script. This helps prevent unneeded calls each frame, similar to setting CanActorEverTick to false in Unreal.

 class, which you can extend to create objects outside of the normal Actor/Component pattern. These objects don’t get spawned into the world but can still be referenced by other objects/Actors, and are useful for containing data without polluting your level.

 class (Not to be confused with the C# Object class, System.Object). This provides a lot of the base functionality for GameObjects and Monobehaviours, but it’s not intended to be extended in the same way as UObjects. As a general rule, it doesn’t get extended directly.

The ability to create data objects without spawning them in the Scene is supported by Unity’s 

. Like UObjects, they store data and reduce dependencies across GameObjects.

However, ScriptableObjects can also be instantiated as Assets within Unity. This is similar to Data Assets in Unreal.. This is a powerful feature that allows you to completely decouple static data from GameObjects.


Imagine that you wanted to create a shop that sells potions in your game. Each potion is a prefab that stores the appearance of the potion and the scripts that control the potion’s behavior when used. When the player accesses the shop, they might see a menu that lists 30 potions for sale, listing the name, price, and description of each one. If you store this UI data on the prefab, that means that Unity will need to load all 30 potion prefabs into memory in order to get the names and prices the UI needs. However this means that all the visuals and script data of the potions are loaded as well, which are not required by the UI at all.

In order to avoid loading all this unnecessary data, we can decouple the UI data from the gameplay data, using a ScriptableObject that contains a name, price, description, and a reference to the prefab containing the visuals and behavior of the potion. By doing this, the lightweight description data can be quickly loaded and shared across the UI, while the more complex Prefab only gets loaded when the player actually equips it in game.

Below are some common use cases and patterns in Unreal and their Unity counterparts:

In Unreal, this is done with the CreateActor Blueprint node or the UWorld::SpawnActor() C++ function. In both cases, you pass in a Class reference and initialization data like name and position.

In Unity, GameObject instantiation is done with the 

 function, which takes a Prefab reference and a starting position/rotation. If all you need is an empty GameObject, you can also simply instantiate a new GameObject Instance with “new GameObject()”.

In Unreal, Typecasting is mostly done with generated Blueprint casting nodes or the Cast<Type>() function in C++.

" keyword or use c-style casting. In both cases, if the cast fails the result is null.

Both engines have garbage collection, which enables unused references to be cleaned up.

In Unreal, several object types also have explicit Destroy functions, which mark the object for deletion.

In Unity, the base UnityEngine.Object class has a static 

 function which, when passed an object reference, will destroy the object. This can be used by GameObjects and Components, or any object that inherits from the base UnityEngine.Object class. GameObjects can also be disabled with 

.

Components can be individually disabled as well, which will still allow for code execution but will prevent Unity event methods like Update and OnCollisionEnter from being called.

In order to find a component that is attached to an Actor in Unreal, you can use the GetComponentByClass node in Blueprints, or FindComponentByClass function in C++. Both methods take a class type which they will use to find a matching component. However, since it is possible to define components by name in both C++ and Blueprints, you can simply access the components by name if you know the Actor’s type.

, which returns the first component of a type that it finds on a GameObject. Unlike Unreal, you don’t get access to a GameObject’s components by name automatically. To get around this, you can simply call 

 method) and store the result in a variable. Calling 

frequently can affect performance since it needs to iterate through every component on the GameObject, so storing a reference when possible is an easy way to optimize your code.

Unreal has the GameplayTag system, which can be used to compare tags between Objects for quick identification. 

Unity has its own tag system for GameObjects. You can select or create a new tag using the drop-down Tag menu in the Inspector. That data can then be accessed using 

Tags can be edited in the Project Settings, by going to 

Edit > Project Settings... > Tags and Layers

In Unreal, you can search the world for an Actor type with a GetAllActorsOfClass, and then filter the results.

In Unity, you can find a GameObject by name using 

To find an object by component type, you can use the 

, where T is the component class you want to find. This returns an array with the results of the search.

In both engines, calls for finding objects in the world can have a high performance cost if they are called frequently, and should not be used in code that gets called every frame.

In Unreal, Raycasts and Shapecasts are completed using Trace functions. Tracing by Channel or Object type is supported for both shape and ray tracing. A cast outputs a Hit Result struct with all the relevant information about a hit.

Unity has several functions for Raycasting:

 to return all hits, instead of just the first. For performance sensitive contexts, there are also versions of these functions that don’t allocate garbage (for example: 

In Unreal, you can create actions using the Input Actions/Axis settings. These settings enable you to define various bindings for player actions (for example, "Jump" or "Throttle"). The Input actions can then be bound to functions, to enable your code to react to the inputs.

Unity uses a similar system, where the code can read from defined 

function. You can find these settings in 

Edit > Project Settings... > Input Manager > Axes

 is by default bound to the A/S keys and the left/right analog axis on controller. 

Options like deadzone, sensitivity, and inversion can be set per Axis. Although it’s called an Axis, it supports digital inputs as well, using the

function. You can also query explicit keys using 

In Unreal, the delay and timeline nodes provide simple ways to control event timing and to modify properties over time.

In Unity, these kinds of delayed executions can be handled using 

. Coroutines are special functions that run independently of regular code execution, and they can be delayed or paused at will using the "

" instruction. All Coroutines are required to return an IEnumerator, which enables you to use yield to return some kind of pause or delay. 

The example below prints a log after a five second delay:

In Unreal, you can utilize Blueprint’s Event Dispatcher system or C++ Delegates to create and bind custom events for your classes.

In Unity, you have several methods for creating and binding events. The most up-to-date example is the 

, which gives you a powerful way to bind handlers to your event using the Inspector. 

When you define serialized events in code, you will see exposed fields in the Inspector (as outlined in Serialized Fields) . You can drag and drop the GameObjects you want to react to the event into the field(s) in the Inspector. 

Unity also supports Delegates, along with generic C# events, if you want a more lightweight event system.

Scripting in Unity

Unreal has simulation and collision properties built directly into Primitive Components, which manage the channels with which the component interacts and any data like physics materials and mass. The collision bounds are defined by the visual mesh used by the component.

Unity’s built-in physics engines control physical simulation using the 

 component. There are specialized Colliders depending on the GameObject shape, including:

The Rigidbody is responsible for managing the dynamics of the GameObject’s simulation, while the Collider provides the shape properties. The physical layers that interact are defined at the Project level. 

In Unreal, you use Animation Sequences/Montages to create skeletal animation, usually controlling this animation using an Animation Blueprint and state machine.

animation system functions in a similar way. It allows you to import various animation clips and control their playback using a state machine that can be controlled by script.

Unreal’s main tool to control cinematics and multi-Object animation is the Level Sequencer. 

 is the appropriate tool. Similar to Level Sequencer assets, Timeline assets are a collection of property animations. The Timeline can work with a wide variety of systems, including:

In Unreal, most User Interface (UI) is controlled using Unreal Motion Graphics UI Designer (UMG). UMG is a retained UI system which has you creating UI objects in a hierarchy, with each object handling its own data and events. UMG utilizes special Blueprints called Widgets that enable you to lay out and script your UI in a single asset.

Unity also has a retained UI system called 

 component. Unlike UMG, this system doesn’t require separate Assets: you simply use GameObjects with UI specific components to control rendering, interaction, and layout. All UI GameObjects are placed under another GameObject with the Canvas component in the Hierarchy, which manages how the UI is rendered and how it can be interacted with. 

Adding behavior to this UI is accomplished with C# scripting, or by dragging and dropping UnityEvents in the Inspector (for components like Button).

Other Engine Properties

I'm not a traditional programmer — is there an equivalent to Blueprint Visual Scripting in Unity?

At the moment, there is no built-in Blueprint style visual programming in Unity. However, if you know how to do blueprints, then learning Unity's C# scripting is not as difficult as it may seem at first. There are plenty of 

 that can help you get up to speed with basic scripting in Unity. 

However, if you really prefer visual scripting, there is some good news. In Unity's massive plug-in ecosystem, there are several very powerful and well-supported Visual Scripting systems like 

 Using these, you can recreate a Blueprint style workflow.

This tutorial has hopefully helped bridge the gap between some of the core concepts in Unreal Engine and Unity. 

However, Unity has even more resources to help you learn and understand the engine further:

 — Everything about Unity down to the nuts and bolts. All functionality in the engine and editor can be found here.

 — Comprehensive documentation for Unity C# scripting and all the built in Unity libraries.

 — Official learning content from Unity, ranging from full guided courses to bite-sized tutorials.

 — The latest video content showing off Unity features, with many video tutorials.

Unity Version 2019.3