UNREAL ENGINE PROGRAMMING PIPELINE

REPLICATION MEMORY GAMEPLAY FRAMEWORK

See Engine Structure

Input Component
Dispatches player input to any
Ownership Property RPCs Loading Assets Garbage Collector designed listener. The Input can
Ownership defines general Replication Messages called as local but sent Automatic or deferred for Automatic memory management be setup by Player ID.
rules for replication from and to one or more remote machines accurate loading control. for UPROPERTY members.
Happens when a Property is set to
to the server. to be executed.
replicated and the value changes.
Server will notify to clients.

PlayerState PlayerController
Aux class for the PlayerController As the brain of Pawn input is
that exists in server and all clients. interpreted as actions.
Good to share player info among Controllers can easily possess and
every client. unpossess Pawns. Exists on owner
client and server.

Pawn/Character Profile Launcher Editor Package Command

Physical body for everything that Allows to create different Project BuildCookRun command
Cook by the book Cook on the fly
performs actions and has a profiles for different properly configured will Cooks all the content that is Will cook only content on
Straight forward method of
Actor Reliability RepNotify Memory behavior. Can be possessed by
a Controller and perform
Build/Cook/Pak configurations. Build/Cook/Pak but with little generate any type of
executable needed.
required for a standalone
version of the application.
demand. Mainly for testing
on devices.
Replication Reliable calls are guaranteed to Let's you execute some logic in
Management its commands.
control over the process.

occur, while Unreliable calls may be response to the value of a Highly configurable system based
Can replicate properties and
entire Components.
dropped during heavy traffic. replicated variable changing. in a Garbage Collector and GameState
Reflection over references to
manage memory automatically. Aux class for the GameMode that GameMode
exists in server and clients. Good Class that defines the flow of the
for sharing global info and functions execution. Only on the server.
that are dependent on the current Lifetime dependant on level.
level among every client.

Ticking Subsystems
Ticking is a very flexible system Instead of overriding Engine
with groups and a lot of classes Subsystems allow to
configuration options. Reduce its work with instances
Delegates and use as much as possilble. automatically managed.
Replication Events Async Tasking
Network Framework natively implemented
GameInstance System to create tasks that are
Framework in the reflection system.
Client/server focused.
C++ code and BP can receive
and broadcast them. Most basic
Lifetime from the execution of the
app till it is closed.
processed asynchronously. Good
for saving data to files or making
form is DECLARE_DELEGATE.
Handles sessions, connections and the best out of the CPU. Targets
client-server communication on
each platform. Usual Solution Configs are: Diff Tool
Debug, DebugGame, Per-asset diff tool. Loading
Development, Test and system will always look for
Shipping. Base will be assets in newer paks first.
standalone and Editor will load
project in Editor. DebugGame
only loads symbols for the
project, not the Engine.

Deploy
Upload to server or device
Modules and prepare for launching.

Structured unit of Non-Coders

shared functionality.
Unreal Game Sync Files in Binaries folder should
Manages the changelists and be shared with non-coders
Engine distribution, as well as building team members - or build and
Source code is facilitated so it towards the wider team. handled via UGS.
can be modified.

Generate Compile Build Cook Pack

Project Files From IDE or from Editor. Compile source code and Convert assets and Gather all needed
generate binaries. content into resources. resources into pak files.
Plugins Based on the structure
YourGame.exe
Independent unit of shared Unreal Build Tool
of the code in the
Source folders. Source Code Unreal Automation Tool
functionality that can be
C# scripted tool that generates project Divided in Modules and Plugins. C++ scripted tool for Building, Shipped Project
deactivated. C++ with reflection capabilities. Cooking, and Packaging. Usually Shipping config.
files. Checks dependencies on SDKs
for all possible platforms. Several Solution Configurations.
Project 1

Project 2
LIVE ++
Experimental plugin that allows
Platforms to compile while in PIE.
Independent unit of shared Project etc
Platforms Extensions are used
to isolate platform specific code.

BASE TYPES

Debug and Profile

Many native tools to debug and profile,
but there are plugins and integrations for
TWeakPtr the most popular external ones.

TSharedPtr

PROFILING AND DEBUGGING

Enum TSharedRef Smart Pointers Creation Specifiers Data Objects
Have reflection metadata to expose
identifiers in the Editor.
Base Data Types Several ways of holding references UObjects created with NewObject
Usual data types have been depending on ownership. Class, Struct, Enum, Function, There are some good native data
and AActors spawned with Parameter or Properties can: objects for gameplay usage.
extended to be managed
and exposed.
TUniquePtr SpawnActor. UObjects can tick • Be exposed to BP.
inheriting from • Have extra behaviour.
FString FTickableGameObject.
Usual basic functionality string.

FName
For unique names of Actors, paths
or other kind of ID.

Strings
FText Several string types depending on
the final usage.
Localisation ready string-type. Life Cycle Destruction
Should be used for everything Asset loaded, PostLoad / Post AActor can use Destroy(). They will
displayed in-app/game. ActorCreated, initialise Components, be marked for IsPendingKill().
OnActorSpawned and BeginPlay. UObject depend on Garbage
Collector, when they are not
referenced anymore.
Stats Console Commands Session Frontend LLM ProfileGPU Gauntlet
Show timing and cost of several Deactivate or lower level on features Detailed and hierarchical Low Level Memory tracker based in Detailed GPU time. Framework to run builds and
processes and systems. to test for cost and problems. profiling tool. tags. Load with -LLM to enable. validate them. No game-side
automation required.
Data Tables Data Assets Curves
Keyed tables that can be Generic containers similar to big Float, Vector and Linear Color.
imported and exported easily. structs for custom setups of data. Useful for kinematic movements by
Structs Good for importing data
generated by other tools.
code or any kind of interpolation.

Members are exposed to the Editor

using the UProperty macro.

Actor Components
Handles sessions, connections and UActorComponent don't have
TMap Base class for objects placed in a level.
Also basic container for components.
transform in the world, but
SceneComponent have one relative
Have implicit ticking capabilities. to parent Actor.

TArray

TSet Collections
Nested containers are not supported. Unreal Insights CSV Profiler Memreport
New, detailed and hierarchical Per-frame timings for render and Detailed dump of UObject
profiling tool. game threads. memory usage.

FVector

FRotator
UObject
Base class for all the engine classes.
FQuat Transform Types Provides visibility to the engine for data
reflection capabilities and automatic
Native types for world transformation. memory management.
FTransfor gathers Location
FTransform and Rotation.

UNREALENGINE.COM/ONLINELEARNING