Unreal Engine 5 (UE5) is one of the most powerful and popular game engines in the industry, renowned for its cutting-edge graphics, robust toolsets, and versatility in creating everything from AAA games to VR simulations and architectural visualizations. At the core of Unreal Engine 5 is C++, a language chosen for its performance and flexibility.
However, Unreal Engine’s implementation of C++ differs significantly from modern standard C++ (C++11, C++14, C++17, and C++20). These differences can be daunting for programmers new to Unreal Engine development. Understanding these distinctions is crucial for efficiently utilizing Unreal Engine’s capabilities and integrating seamlessly with its ecosystem.
In this guide, we will explore the unique features and variations of Unreal C++ compared to modern standard C++. Whether you’re a seasoned C++ developer or new to the language, this comprehensive guide will help you navigate the specific requirements and conventions of Unreal Engine 5 C++ programming, ensuring a smoother transition and more effective development process.
Understanding the key differences between Unreal Engine C++ and modern standard C++ is essential for any programmer looking to develop with Unreal Engine 5. Here, we’ll delve into the unique aspects of Unreal C++ and how they compare to standard C++.
One of the most significant differences in Unreal C++ is the reflection system. Unreal Engine uses macros to provide metadata and reflection capabilities that are not present in standard C++. These macros enable the engine to inspect and manipulate code at runtime, which is critical for features like Blueprints, garbage collection, and serialization.
UCLASS: Used to declare a class that is reflected and can be instantiated by the Unreal Engine. Classes with this macro are eligible for Blueprint integration and other engine features.
UCLASS()
class MYPROJECT_API AMyActor : public AActor
{
GENERATED_BODY()
public:
// Class properties and methods
};
USTRUCT: Similar to UCLASS, but for structures.
USTRUCT(BlueprintType)
struct FMyStruct
{
GENERATED_BODY()
UPROPERTY(EditAnywhere, BlueprintReadWrite)
int32 MyValue;
};
UENUM: Used for enums to make them usable in Blueprints and other engine systems.
UENUM(BlueprintType)
enum class EMyEnum : uint8
{
Value1 UMETA(DisplayName = "Value 1"),
Value2 UMETA(DisplayName = "Value 2")
};
UPROPERTY: Marks a class member for reflection and garbage collection, making it visible and editable in the Unreal Editor.
UPROPERTY(EditAnywhere, BlueprintReadWrite)
int32 MyProperty;
UFUNCTION: Marks a function for reflection, allowing it to be called from Blueprints or other engine systems.
UFUNCTION(BlueprintCallable)
void MyFunction();
Unreal Engine has its own garbage collection system to manage memory for UObject-derived classes. This system helps prevent memory leaks and ensures proper cleanup of objects.
UPROPERTY: To ensure an object is properly garbage collected, it should be marked with the UPROPERTY macro.
UPROPERTY()
UObject* MyObject;
Manual Memory Management: In standard C++, developers use new and delete for dynamic memory management, along with smart pointers (std::shared_ptr, std::unique_ptr). In Unreal, this is typically unnecessary for UObjects, as the engine handles their lifecycle.
Unreal Engine introduces a distinct object model centered around UObject, the base class for all objects managed by the engine.
UObject System: All objects that require reflection, serialization, or garbage collection must derive from UObject.
UCLASS()
class MYPROJECT_API UMyObject : public UObject
{
GENERATED_BODY()
};
Actor Lifecycle: Actors are special types of UObjects that exist within the game world and have additional lifecycle methods.
- BeginPlay: Called when the actor is first created or spawned.
- Tick: Called every frame if the actor is ticking.
- EndPlay: Called when the actor is about to be destroyed.
UCLASS()
class MYPROJECT_API AMyActor : public AActor
{
GENERATED_BODY()
protected:
virtual void BeginPlay() override;
public:
virtual void Tick(float DeltaTime) override;
virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
};
These key differences illustrate how Unreal Engine C++ extends and adapts standard C++ to meet the unique needs of game development. By understanding these distinctions, developers can effectively leverage Unreal Engine’s powerful features and create high-quality, performant games and simulations.
Unreal Engine 5 introduces several unique features and systems that differentiate it from standard C++. These features are specifically designed to enhance game development, providing robust tools and capabilities that streamline the creation of complex, interactive experiences.
Unreal C++ is designed to integrate seamlessly with Blueprints, Unreal Engine’s visual scripting language. This integration allows developers to expose C++ functionality to designers and artists who may prefer a visual approach.
BlueprintCallable: Marks a function as callable from Blueprints.
UFUNCTION(BlueprintCallable)
void MyBlueprintFunction();
BlueprintImplementableEvent: Allows a function to be implemented in Blueprints.
UFUNCTION(BlueprintImplementableEvent)
void MyBlueprintEvent();
BlueprintNativeEvent: Provides a base C++ implementation while allowing for Blueprint overrides.
UFUNCTION(BlueprintNativeEvent)
void MyNativeEvent();
virtual void MyNativeEvent_Implementation();
Unreal Engine’s modular architecture organizes code into modules and plugins, which is different from standard C++ project structures.
Modules: Logical units of code that can be independently compiled and linked.
- .Build.cs Files: Define module dependencies and build rules.
public class MyModule : ModuleRules
{
public MyModule(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine" });
}
}
Plugins: Packages of reusable functionality that can be shared across projects. Plugins can contain one or more modules and can be easily enabled or disabled in the Unreal Editor.
- Creating a Plugin: Plugins can be created via the Unreal Editor, allowing for encapsulation of features and tools.
- .uplugin File: Defines the plugin’s metadata and modules.json
- .uplugin File: Defines the plugin’s metadata and modules.
{
"FileVersion": 3,
"Version": 1,
"VersionName": "1.0",
"FriendlyName": "My Plugin",
"Description": "A description of my plugin.",
"Category": "Gameplay",
"Modules": [
{
"Name": "MyModule",
"Type": "Runtime",
"LoadingPhase": "Default"
}
]
}
Unreal’s Actor system is a fundamental part of game development, providing a framework for entities within the game world.
AActor: The base class for all actors in the game world.
UCLASS()
class MYPROJECT_API AMyActor : public AActor
{
GENERATED_BODY()
};
Components: Building blocks for actors, providing modular functionality.
- USceneComponent: Base class for all scene components.
- UPrimitiveComponent: Base class for components that can be rendered or have collision.
UPROPERTY(VisibleAnywhere)
USceneComponent* Root;
UPROPERTY(VisibleAnywhere)
UStaticMeshComponent* Mesh;
Unreal Engine simplifies network programming with built-in support for replication and remote procedure calls (RPCs).
Replication: Automatically synchronizes object state across the network.
UPROPERTY(Replicated)
int32 MyReplicatedProperty;
RPCs: Functions that can be called on remote machines.
UFUNCTION(Server, Reliable, WithValidation)
void ServerFunction();
Unreal Engine provides a comprehensive gameplay framework, offering a structured approach to game development with predefined classes and systems.
GameMode: Defines the rules and flow of the game.
UCLASS()
class MYPROJECT_API AMyGameMode : public AGameModeBase
{
GENERATED_BODY()
};
PlayerController: Manages player input and controls.
UCLASS()
class MYPROJECT_API AMyPlayerController : public APlayerController
{
GENERATED_BODY()
};
GameState: Holds global game state information.
UCLASS()
class MYPROJECT_API AMyGameState : public AGameStateBase
{
GENERATED_BODY()
};
PlayerState: Holds player-specific state information.
UCLASS()
class MYPROJECT_API AMyPlayerState : public APlayerState
{
GENERATED_BODY()
};
Unreal Engine 5 extends the capabilities of standard C++ with features tailored for game development, such as Blueprint integration, modular architecture, a robust actor system, simplified network programming, and a comprehensive gameplay framework. By understanding and leveraging these unique features, developers can efficiently create sophisticated, high-performance games and interactive experiences.
In Unreal Engine 5, many standard C++ features and libraries are updated or have their own versions tailored for the engine’s unique needs. Understanding these differences is crucial for writing efficient and maintainable Unreal C++ code.
Unreal Engine provides its own container classes that are optimized for performance and memory usage in game development. These containers often offer additional functionality and integration with the engine’s systems.
TArray: Dynamic array similar to std::vector.
TArray<int32> MyArray;
MyArray.Add(10);
MyArray.RemoveAt(0);
TMap: Associative container similar to std::map, providing key-value pairs.
TMap<FString, int32> MyMap;
MyMap.Add(TEXT("Key"), 100);
int32 Value = MyMap[TEXT("Key")];
TSet: Unordered collection of unique elements, similar to std::set.
TSet<int32> MySet;
MySet.Add(42);
MySet.Remove(42);
Unreal Engine uses its own smart pointer classes to manage the lifetime of objects, integrating seamlessly with the engine’s garbage collection system.
TSharedPtr: Reference-counted shared ownership, similar to std::shared_ptr.
TSharedPtr<MyClass> MySharedPtr = MakeShared<MyClass>();
TWeakPtr: Non-owning weak reference to an object managed by a TSharedPtr, similar to std::weak_ptr.
TWeakPtr<MyClass> MyWeakPtr = MySharedPtr;
TUniquePtr: Unique ownership of an object, similar to std::unique_ptr.
TUniquePtr<MyClass> MyUniquePtr = MakeUnique<MyClass>();
Unreal Engine provides its own string classes to handle text and localization efficiently.
FString: Dynamic string class for mutable strings.
FString MyString = TEXT("Hello, Unreal!");
MyString.Append(TEXT(" How are you?"));
FName: Immutable, hash-based string class for identifiers.
FName MyName(TEXT("Player"));
FText: Localized text class used for user-facing text.
FText MyText = FText::FromString(TEXT("Welcome to Unreal Engine"));
Unreal Engine provides its own math classes optimized for 3D graphics and game development.
FVector: Represents a 3D vector.
FVector MyVector(1.0f, 2.0f, 3.0f);
MyVector.Normalize();
FRotator: Represents rotation in terms of pitch, yaw, and roll.
FRotator MyRotator(45.0f, 90.0f, 0.0f);
FTransform: Combines translation, rotation, and scale.
FTransform MyTransform(MyRotator, MyVector, FVector(1.0f));
Unreal Engine provides its own concurrency classes and functions to handle multithreading and asynchronous operations.
FAsync: Utility for running tasks asynchronously.
FAsyncTask<MyTask> MyAsyncTask;
MyAsyncTask.StartBackgroundTask();
FGraphEventRef: Handles task dependencies and event-driven execution.
FGraphEventRef MyEvent = FFunctionGraphTask::CreateAndDispatchWhenReady([]()
{
// Task code here
});
FRunnable: Interface for creating custom threads.
class MyRunnable : public FRunnable
{
public:
virtual uint32 Run() override
{
// Thread code here
return 0;
}
};
Unreal Engine 5’s versions of standard C++ features and libraries are designed to optimize performance and integration with the engine’s systems. By understanding these updates and differences, developers can effectively utilize Unreal’s tools to create high-quality, efficient, and maintainable code.
The Unreal Build System (UBT) is a powerful and flexible build system designed specifically for Unreal Engine projects. It manages the compilation and linking of code, handles dependencies, and ensures that your project is built correctly for various platforms. Understanding the Unreal Build System is essential for managing large projects and creating high-performance applications.
Unreal Build System uses several configuration files to define how projects are built. The primary files you will interact with are .Build.cs and .Target.cs files.
.Build.cs Files: Define the module’s dependencies, build settings, and additional include paths.
public class MyModule : ModuleRules
{
public MyModule(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
PrivateDependencyModuleNames.AddRange(new string[] { });
}
}
.Target.cs Files: Define the build targets for your project, such as game and editor targets. Targets specify how the build system should compile and link your project.
public class MyGameTarget : TargetRules
{
public MyGameTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Game;
DefaultBuildSettings = BuildSettingsVersion.V2;
ExtraModuleNames.AddRange(new string[] { "MyGame" });
}
}
Build Configurations: Unreal Build System supports multiple build configurations, such as Development, Debug, and Shipping, each optimized for different stages of development and deployment.
BuildConfiguration = new TargetBuildConfiguration
{
BuildEnvironment = TargetBuildEnvironment.Unique,
Configuration = UnrealTargetConfiguration.Development,
Platform = UnrealTargetPlatform.Win64,
ProjectFile = ProjectFile
};
The build process in Unreal Engine consists of several phases, ensuring that the code is compiled correctly and efficiently.
- Pre-Build: The build system gathers information about the project’s dependencies and configuration.
- Compile: Source code files are compiled into object files.
- Link: Object files are linked together to create the final executable.
- Post-Build: Additional tasks, such as copying files and packaging assets, are performed.
Unreal Engine simplifies the process of packaging and deploying projects for various platforms. Packaging prepares your project for distribution, ensuring that all necessary files are included and configured correctly.
Packaging for Different Platforms: Unreal Engine supports packaging for multiple platforms, including Windows, macOS, Linux, iOS, Android, and consoles. The build system handles platform-specific settings and optimizations.
public class MyGameTarget : TargetRules
{
public MyGameTarget(TargetInfo Target) : base(Target)
{
Type = TargetType.Game;
DefaultBuildSettings = BuildSettingsVersion.V2;
ExtraModuleNames.AddRange(new string[] { "MyGame" });
// Platform-specific settings
if (Target.Platform == UnrealTargetPlatform.Win64)
{
// Windows-specific build settings
}
else if (Target.Platform == UnrealTargetPlatform.Android)
{
// Android-specific build settings
}
}
}
Automated Build Tools: Unreal Engine provides automated build tools to streamline the packaging and deployment process. The Unreal Automation Tool (UAT) can be used to automate builds, run tests, and package projects.
RunUAT BuildCookRun -project="MyProject.uproject" -noP4 -platform=Win64 -clientconfig=Shipping -serverconfig=Shipping -cook -allmaps -build -stage -pak -archive -archivedirectory="C:/MyProjectBuild"
Command Line Interface: The Unreal Build System can be controlled via the command line, allowing for integration with continuous integration and continuous deployment (CI/CD) pipelines.
UE4Editor-Cmd.exe MyProject.uproject -run=Cook -targetplatform=Win64 -fileopenlog
The Unreal Build System is a comprehensive and flexible build system tailored for Unreal Engine projects. It handles the complexities of compiling and linking code, managing dependencies, and packaging projects for distribution. By understanding the build configuration files, build phases, and deployment processes, developers can efficiently manage and deploy their Unreal Engine projects across multiple platforms.
Developing in Unreal Engine involves a distinct workflow that integrates code, assets, and the Unreal Editor. Understanding this workflow is crucial for efficiently managing and developing projects.
The Unreal Editor provides powerful scripting capabilities, allowing developers to automate repetitive tasks, extend editor functionality, and customize the development environment.
Extending the Editor with C++: You can extend the Unreal Editor by writing custom tools and functionality in C++. This can include custom editor windows, asset importers, and automation scripts.
Editor Modules: Editor-specific code is typically placed in a separate module from runtime code.
public class MyEditorModule : ModuleRules
{
public MyEditorModule(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PrivateDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "UnrealEd" });
}
}
Custom Editor Windows: You can create custom editor windows using the Slate UI framework.
void FMyEditorModule::StartupModule()
{
FGlobalTabmanager::Get()->RegisterNomadTabSpawner(MyTabName, FOnSpawnTab::CreateRaw(this, &FMyEditorModule::OnSpawnPluginTab))
.SetDisplayName(NSLOCTEXT("MyEditorModule", "TabTitle", "My Editor Tab"))
.SetMenuType(ETabSpawnerMenuType::Hidden);
}
TSharedRef<SDockTab> FMyEditorModule::OnSpawnPluginTab(const FSpawnTabArgs& SpawnTabArgs)
{
return SNew(SDockTab)
.TabRole(ETabRole::NomadTab)
[
SNew(STextBlock).Text(NSLOCTEXT("MyEditorModule", "TabText", "Hello, Unreal Editor!"))
];
}
Automating Tasks with Python: Unreal Engine supports Python scripting, which can be used to automate editor tasks and workflows.
import unreal
def rename_assets(asset_path, new_name):
asset_registry = unreal.AssetRegistryHelpers.get_asset_registry()
assets = asset_registry.get_assets_by_path(asset_path)
for asset in assets:
unreal.EditorAssetLibrary.rename_asset(asset.package_name, new_name)
rename_assets('/Game/MyAssets', 'NewAssetName')
Efficient debugging and profiling are crucial for identifying and resolving issues in Unreal Engine projects. Unreal Engine provides various tools and techniques for debugging and profiling C++ code.
Visual Studio Integration: Unreal Engine integrates with Visual Studio, allowing for seamless debugging of C++ code. You can set breakpoints, inspect variables, and step through code directly within Visual Studio.
- Attaching to Process: Attach the Visual Studio debugger to the running Unreal Editor process.
// Set a breakpoint in your C++ code
void AMyActor::BeginPlay()
{
Super::BeginPlay();
// Breakpoint here
UE_LOG(LogTemp, Warning, TEXT("Hello, Unreal!"));
}
Unreal Insights: A powerful profiling tool that provides detailed insights into the performance of your project. Unreal Insights can profile CPU and GPU performance, memory usage, and asset loading times.
- Capturing Data: Use the Unreal Insights interface to capture performance data.
void MyFunction()
{
TRACE_CPUPROFILER_EVENT_SCOPE(MyFunction);
// Function code
}
Log Files and Output Log: Unreal Engine provides extensive logging capabilities. Use the UE_LOG macro to log messages to the Output Log and log files.
UE_LOG(LogTemp, Warning, TEXT("This is a warning message"));
UE_LOG(LogTemp, Error, TEXT("This is an error message"));
Assertion and Verification: Use check and ensure macros to verify assumptions and catch errors early.
check(MyPointer != nullptr);
ensure(MyValue > 0);
Managing code and assets with version control is essential for any Unreal Engine project. Unreal Engine supports integration with popular version control systems like Git, Perforce, and Subversion.
Git Integration: Git can be used to track changes in both code and assets. Unreal Engine projects typically include both source code and binary assets, so careful management of .gitignore is important.
- .gitignore: Example
.gitignorefor Unreal Engine projects
# Unreal Engine
Binaries
DerivedDataCache
Intermediate
Saved
# Visual Studio
.vs
*.suo
*.vcxproj.user
*.VC.db
Perforce Integration: Perforce is widely used in larger teams and studios for its robust handling of large binary files and integration with Unreal Engine.
- Setting Up Perforce: Configure Perforce settings in the Unreal Editor under Edit > Editor Preferences > Source Control.
P4PORT=perforce.example.com:1666
P4USER=myusername
P4PASSWD=mypassword
P4CLIENT=myworkspace
The development workflow in Unreal Engine involves integrating code, assets, and the Unreal Editor to create interactive experiences efficiently. By leveraging editor scripting, debugging tools, profiling utilities, and version control systems, developers can streamline their workflow and ensure their projects are maintainable and performant.
Developing in Unreal Engine 5 using C++ can be complex due to the advanced features and systems involved. However, following best practices can help you write efficient, maintainable, and performant code. Here are some tips and best practices for Unreal C++ development:
Proper memory management is crucial in Unreal Engine to prevent memory leaks and ensure optimal performance.
Use UPROPERTY for UObjects: Always use UPROPERTY to manage pointers to UObjects. This ensures that the garbage collector can track and clean up these objects.
UPROPERTY()
UMyObject* MyObject;
Avoid Raw Pointers: Prefer Unreal’s smart pointers (TSharedPtr, TWeakPtr, TUniquePtr) over raw pointers for managing memory.
TSharedPtr<MyClass> MySharedPtr = MakeShared<MyClass>();
Consider Object Lifetimes: Be mindful of object lifetimes, especially when dealing with UObject-derived classes. Use the Outer property to specify the owning object, ensuring proper cleanup.
UMyObject* MyObject = NewObject<UMyObject>(this);
Organizing your code effectively is key to maintaining a large Unreal Engine project.
Modularize Your Code: Use modules to separate different functionalities and keep your codebase organized.
public class MyModule : ModuleRules
{
public MyModule(ReadOnlyTargetRules Target) : base(Target)
{
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore" });
}
}
Follow Naming Conventions: Adhere to Unreal Engine’s naming conventions to maintain consistency and readability.
- Classes:
Uprefix for UObjects,Aprefix for Actors,Fprefix for structs. - Functions: Use camel case for function names (e.g.,
MyFunction).
Use Forward Declarations: Use forward declarations to reduce compile times and dependencies.
class UMyClass;
Optimizing performance is essential for creating smooth and responsive Unreal Engine applications.
Profile Early and Often: Use Unreal Insights and other profiling tools to identify performance bottlenecks.
void MyFunction()
{
TRACE_CPUPROFILER_EVENT_SCOPE(MyFunction);
// Function code
}
Minimize Tick Functions: Avoid unnecessary use of the Tick function. Use events and timers when possible.
GetWorld()->GetTimerManager().SetTimer(TimerHandle, this, &AMyActor::MyFunction, 1.0f, true);
Optimize Memory Usage: Use TArray::Reserve to preallocate memory for arrays and reduce reallocations.
TArray<int32> MyArray;
MyArray.Reserve(100);
Use Efficient Data Structures: Choose the right data structures for your needs. Use TMap and TSet for quick lookups and unique collections.
TMap<FString, int32> MyMap;
MyMap.Add(TEXT("Key"), 100);
Efficient debugging and error handling are crucial for identifying and resolving issues.
Use UE_LOG for Debugging: Use the UE_LOG macro to log messages for debugging purposes.
UE_LOG(LogTemp, Warning, TEXT("This is a warning message"));
Check and Ensure Macros: Use check and ensure macros to verify assumptions and catch errors early.
check(MyPointer != nullptr);
ensure(MyValue > 0);
Debugging in Visual Studio: Set breakpoints, inspect variables, and step through code using Visual Studio’s debugger.
void AMyActor::BeginPlay()
{
Super::BeginPlay();
// Set a breakpoint here
UE_LOG(LogTemp, Warning, TEXT("Hello, Unreal!"));
}
The development workflow in Unreal Engine involves integrating code, assets, and the Unreal Editor to create interactive experiences efficiently. By leveraging editor scripting, debugging tools, profiling utilities, and version control systems, developers can streamline their workflow and ensure their projects are maintainable and performant.
To master Unreal Engine 5 C++ development, it’s essential to leverage various resources and continue learning. Here are some valuable resources and avenues for further education:
