Unreal Engine 5 Guide — Blueprints and C++ Explained

Unreal Engine 5 (UE5) is Epic Games’ cutting-edge game engine, known for powering AAA titles like Fortnite, The Matrix Awakens, and Senua’s Saga: Hellblade 2. It introduces Nanite virtualized geometry and Lumen dynamic lighting to create cinematic-quality worlds.

What You’ll Learn

You’ll master UE5’s dual scripting approach — Blueprints for rapid prototyping and C++ for performance — plus Nanite, Lumen, and the level editor. You’ll build a pickup item with both Blueprint and C++.

Why Unreal Engine Matters

UE5 sets the visual standard for modern games. Its open-world tools, MetaHuman character creator, and film-quality rendering make it the choice for studios targeting PC and console. At DodaTech, we evaluate UE5 for high-fidelity product visualizations in Doda Browser.

Unreal Engine Learning Path

    flowchart LR
  A[Unity Guide] --> B[Unreal Engine 5]
  B --> C{You Are Here}
  C --> D[Blender Basics]
  C --> E[Game Physics]
  style C fill:#f90,color:#fff
  

Blueprints vs C++

UE5 offers two ways to script:

Use Blueprints for gameplay logic and C++ for performance-critical systems. You can mix both — a C++ class can expose functions callable from Blueprints.

Blueprint: Creating a Pickup Item

Let’s create a rotating pickup that the player collects:

1. Create a new Blueprint Class based on Actor
2. Add a StaticMeshComponent (e.g., a sphere or coin shape)
3. Add a SphereCollision component
4. Open the Event Graph:

Event BeginPlay → Add Timeline for rotation
  Timeline Update → AddActorLocalRotation (0, 0, 360° over 2s, looping)

Event OnComponentBeginOverlap (Pickup, OtherActor)
  → Branch: Is Player?
    Yes: Play sound, Add score to GameMode, DestroyActor

The visual graph compiles into efficient C++ under the hood. For the same logic in C++:

#include "PickupItem.h"
#include "Components/SphereComponent.h"
#include "GameFramework/RotatingMovementComponent.h"

APickupItem::APickupItem()
{
    PrimaryActorTick.bCanEverTick = true;

    MeshComp = CreateDefaultSubobject<UStaticMeshComponent>("Mesh");
    RootComponent = MeshComp;

    SphereCollision = CreateDefaultSubobject<USphereComponent>("Collision");
    SphereCollision->SetupAttachment(RootComponent);
    SphereCollision->OnComponentBeginOverlap.AddDynamic(this, &APickupItem::OnOverlap);
}

void APickupItem::BeginPlay()
{
    Super::BeginPlay();
}

void APickupItem::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);
    // Rotate pickup
    AddActorLocalRotation(FRotator(0, 100 * DeltaTime, 0));
}

void APickupItem::OnOverlap(UPrimitiveComponent* OverlappedComp, AActor* OtherActor,
    UPrimitiveComponent* OtherComp, int32 OtherBodyIndex,
    bool bFromSweep, const FHitResult& SweepResult)
{
    if (OtherActor && OtherActor->ActorHasTag("Player"))
    {
        Destroy();
    }
}

Nanite and Lumen

Nanite renders billions of polygons in real-time by streaming only visible detail. Import a ZBrush sculpt with millions of triangles — Nanite handles it automatically. Enable it per-mesh in the static mesh details panel.

Lumen provides dynamic global illumination. Light bounces off surfaces realistically without pre-baked lightmaps. Enable it in Project Settings > Rendering > Dynamic Global Illumination.

    flowchart LR
  A[3D Model] --> B[Nanite Virtualized Geometry]
  B --> C[Stream Only Visible Polygons]
  C --> D[GPU Renders Pixels]
  D --> E[Lumen Lighting]
  E --> F[Final Image]
  

Level Editor

UE5’s level editor is node-based with Blueprints driving level events. Key features:

• Place Actors panel — drag meshes, lights, cameras, volumes into the world
• World Outliner — hierarchy of all actors in the level
• Details panel — modify selected actor properties
• Landscape tool — sculpt terrain with brushes
• Brush Editing — BSP geometry for prototyping

Common Mistakes Beginners Make

1. Not Using Super::BeginPlay()

When overriding BeginPlay() in C++, always call Super::BeginPlay() at the top. Without it, engine initialization code doesn’t run.

2. Connecting Wrong Execution Pins in Blueprints

Blueprints use white execution pins (top) and colored data pins (bottom). Connecting a data pin to an execution pin causes a compile error. Keep them separate.

3. Forgetting to Set Collision Presets

A pickup with BlockAllDynamic collision won’t let the player walk through it. Use OverlapAll or OverlapOnlyPawn for collectible items.

4. Editing C++ Without Stopping the Editor

UE5’s hot-reload is unreliable. Close the editor, edit C++ in your IDE, then recompile. Use Live Coding (enabled in Editor Preferences) for safer iterative changes.

5. Using Tick When Not Needed

Tick() runs every frame. For one-time initialization, use BeginPlay(). For timers, use FTimerHandle instead of polling in Tick.

6. Not Using UPROPERTY()

Every member variable exposed to the editor or garbage collector needs UPROPERTY(). Without it, the variable may be garbage-collected or invisible in Blueprints.

7. Ignoring World Settings

The default game mode, pawn class, and HUD are set in World Settings. Forgetting to set these means your custom player character never spawns.

Practice Questions

1. What is the difference between Blueprints and C++ in UE5?

Blueprints are visual scripting for rapid prototyping; C++ is compiled code for performance-critical systems. They can interoperate via exposed functions.

2. What does Nanite do?

Nanite renders billions of polygons by streaming only the visible detail level, eliminating the need for LODs (Level of Detail).

3. What does Lumen handle?

Lumen provides dynamic global illumination — real-time light bouncing without pre-baked lightmaps.

4. Why call Super::BeginPlay()?

It ensures the parent class initialization runs before custom logic, preventing undefined behavior.

5. Challenge: Create a health pickup.

Modify the pickup to increase player health. Use UPROPERTY(EditAnywhere) to expose a health amount variable. Access the player’s health component via Cast<UHealthComponent>(OtherActor->GetComponentByClass(...)).

Mini Project: Coin Collector Level

Build a small level with 10 collectible coins:

1. Create a CoinPickup Blueprint (rotating coin mesh with overlap detection)
2. Create a BP_Player with a Character Movement Component
3. Add score tracking to the Game Mode Blueprint
4. Place 10 coins around the level using the Place Actors panel
5. Add a HUD widget showing score with a Widget Blueprint
6. When all coins are collected, display “You Win!” with Create Widget

FAQ

What’s Next

Congratulations on completing this Unreal Engine tutorial! Here’s where to go from here:

• Practice daily — Build one Blueprint mechanic per day
• Build a project — Create a simple collect-em-up level
• Explore related topics — C++ for UE5, advanced Blueprint systems
• Join the community — Share your progress and learn from others

Remember: every expert was once a beginner. Keep building!