DEV Community: Adriel Werlich

Why Use C++ Over Blueprints in Unreal Engine?

Adriel Werlich — Sat, 21 Jun 2025 19:15:55 +0000

Certainly! Here’s a more detailed explanation:

Why Use C++ Over Blueprints in Unreal Engine?

1. Full Engine Access

Blueprints are designed for ease of use and rapid iteration, but they only expose a subset of Unreal Engine’s features. With C++, you have direct access to the entire Unreal API, including:

Low-level engine systems (rendering, physics, networking, memory management)
Custom engine modules and plugins
Advanced gameplay systems (AI, custom input, procedural generation)
Third-party libraries and integrations

This means if you need to do something not available in Blueprints, or want to deeply customize engine behavior, C++ is required.

2. Customization and Extensibility

C++ allows you to:

Create new classes, components, and systems not possible in Blueprints
Override and extend engine functionality at any level
Implement complex algorithms or data structures
Write custom editor tools and workflows

Blueprints are great for combining existing building blocks, but C++ lets you invent new ones.

3. Performance Considerations

While Unreal’s Blueprint system is highly optimized, C++ can offer performance benefits in certain scenarios:

Tight loops, heavy math, or real-time calculations
Systems that run every frame or on many objects (e.g., custom physics, pathfinding)
Memory management and optimization

For most gameplay logic, the performance difference is minor. But for critical systems, C++ gives you more control over optimization.

4. Hybrid Workflow

Most professional Unreal projects use a hybrid approach:

C++ for core systems, custom logic, and engine extensions
Blueprints for rapid prototyping, designer-driven logic, and visual scripting

C++ classes can expose variables and functions to Blueprints, allowing designers to tweak and extend gameplay without touching code.

5. Maintainability and Collaboration

C++ code can be easier to version control, review, and merge in large teams.
Complex logic can be clearer and more maintainable in code than in large Blueprint graphs.

Summary Table

Feature/Need	Blueprints	C++
Rapid prototyping	✔️
Full engine access		✔️
Custom engine features		✔️
Performance-critical logic	(some)	✔️
Designer-friendly	✔️
Complex algorithms		✔️
Editor scripting/tools		✔️

In short:

Use Blueprints for speed, accessibility, and designer iteration.
Use C++ when you need full engine access, custom features, or maximum performance.

Chapter 2 - Converting blueprint in Cpp - BeginPlay

Adriel Werlich — Sat, 21 Jun 2025 17:09:23 +0000

Chapter 2 - Converting the BeginPlay hook into C++ script

The Event BeginPlay in blueprint/visual scritp

This BeginPlay event for the Bot Player Blueprint does the following:

Sequence Node: Splits execution into three parallel branches.
SetInputMappingContext: Calls a collapsed graph to set up input mappings.
InitFireMode: Calls a collapsed graph to initialize the fire mode.
CreateCrosshairWidget: Calls a collapsed graph to create the crosshair UI.
SetTag: Sets a tag on the actor (likely for identification).
Get All Actors of Class (BP_Enemy_Spawn): Finds all enemy spawn actors in the level.
Bind Event to On All Enemies Defeated: Binds a custom event (Event_ShowLevelClearedMessage) to an event dispatcher on the enemy spawner(s).
Event_ShowLevelClearedMessage: Custom event that, when triggered, calls ShowLevelClearedMessage on self, passing a message to display.

How to Convert This to C++

Below is a C++ outline for your BeginPlay logic. You’ll need to implement or stub out the collapsed graphs as C++ functions.

#include "BotPlayer.h"
#include "Kismet/GameplayStatics.h"
#include "BP_Enemy_Spawn.h" // Replace with your actual enemy spawn class header

void ABotPlayer::BeginPlay()
{
    Super::BeginPlay();

    // 1. Set up input mapping context
    SetInputMappingContext();

    // 2. Initialize fire mode
    InitFireMode();

    // 3. Create crosshair widget
    CreateCrosshairWidget();

    // 4. Set tag on this actor
    this->Tags.Add(FName("PlayerTag")); // Replace "PlayerTag" with the actual tag

    // 5. Get all enemy spawners in the level
    TArray<AActor*> EnemySpawners;
    UGameplayStatics::GetAllActorsOfClass(GetWorld(), ABP_Enemy_Spawn::StaticClass(), EnemySpawners);

    // 6. Bind event to OnAllEnemiesDefeated for each spawner
    for (AActor* SpawnerActor : EnemySpawners)
    {
        ABP_Enemy_Spawn* Spawner = Cast<ABP_Enemy_Spawn>(SpawnerActor);
        if (Spawner)
        {
            // Assuming the spawner has a delegate like:
            // DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnAllEnemiesDefeated);
            // UPROPERTY(BlueprintAssignable) FOnAllEnemiesDefeated OnAllEnemiesDefeated;
            Spawner->OnAllEnemiesDefeated.AddDynamic(this, &ABotPlayer::ShowLevelClearedMessage);
        }
    }
}

// Example stub implementations for the collapsed graphs:
void ABotPlayer::SetInputMappingContext()
{
    // Implement input mapping setup here
}

void ABotPlayer::InitFireMode()
{
    // Implement fire mode initialization here
}

void ABotPlayer::CreateCrosshairWidget()
{
    // Implement crosshair widget creation here
}

// This function will be called when all enemies are defeated
void ABotPlayer::ShowLevelClearedMessage()
{
    // Implement logic to show the level cleared message
}

Key Points:

Replace "YourTag" with the actual tag you want to set.
Replace ABP_Enemy_Spawn with your actual enemy spawner C++ class.
The delegate/event system assumes your enemy spawner has a BlueprintAssignable multicast delegate for "all enemies defeated."
Implement the collapsed graph logic as C++ member functions.

Next is to convert each variable, function, node graph or macro into C++ code.
For example in the blueprint we have the "CreateCrosshairWidget" that creates the target/crosshair widget in the center of the screen

The CreateCrosshairWidget function does the following:

Gets the Player Controller (index 0).
Creates a User Widget of a specified Widget Blueprint Class, with the player controller as the owning player.
Stores the created widget in a variable (WidgetBlueprint).
Adds the widget to the viewport so it appears on the screen.

C++ Conversion

Header File (`BotPlayer.h`)


// ...existing code...

#include "Blueprint/UserWidget.h"

UCLASS()
class YOURGAME_API ABotPlayer : public APawn
{
    GENERATED_BODY()

public:
    ABotPlayer();

    // The crosshair widget class to use (set this in the editor)
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="UI")
    TSubclassOf<UUserWidget> WidgetBlueprintClass;

    // The created widget instance
    UPROPERTY()
    UUserWidget* WidgetBlueprint;

    // Function to create the crosshair widget
    void CreateCrosshairWidget();

Source File (`BotPlayer.cpp`)

#include "BotPlayer.h"
#include "Blueprint/UserWidget.h"
#include "Kismet/GameplayStatics.h"

void ABotPlayer::CreateCrosshairWidget()
{
    // Get the player controller
    APlayerController* PC = UGameplayStatics::GetPlayerController(GetWorld(), 0);
    if (PC && WidgetBlueprintClass)
    {
        // Create the widget
        WidgetBlueprint = CreateWidget<UUserWidget>(PC, WidgetBlueprintClass);
        if (WidgetBlueprint)
        {
            // Add it to the viewport
            WidgetBlueprint->AddToViewport();
        }
    }
}

Summary:

The function gets the player controller, creates the widget, stores it in a variable, and adds it to the viewport—just like the Blueprint version.
Make sure to set WidgetBlueprintClass in the editor to your crosshair widget Blueprint.

How to Convert a Basic Blueprint to a C++ Class in Unreal Engine 5

Adriel Werlich — Sat, 21 Jun 2025 15:11:09 +0000

While it’s common to hear that C++ gives you “more control” than Blueprints, the main advantage of using C++ in Unreal Engine is full access to the Unreal API. Many engine features, advanced systems, and low-level optimizations are only available or fully customizable in C++. Blueprints are powerful for rapid prototyping and visual scripting, but they intentionally expose only a subset of the engine’s capabilities to keep things simple and safe for designers (for more info about this look: Using cpp versus blueprint scripting ).

Key Points:

Full API Access:

C++ lets you use every class, function, and subsystem in Unreal Engine. Some advanced features (like custom rendering, networking, or memory management) are only accessible in C++.
Custom Engine Features:

If you need to extend the engine, create custom components, or deeply modify gameplay systems, C++ is required.
Performance:

While C++ can be faster in some edge cases (especially for tight loops or heavy math), Unreal’s Blueprint system is highly optimized. For most gameplay logic, the performance difference is negligible. Only in performance-critical code paths does C++ offer a clear advantage.
Hybrid Approach:

Many teams use C++ for core systems and expose variables/functions to Blueprints for designers to tweak and extend. This combines the strengths of both systems.

Summary:

The biggest reason to use C++ is not raw speed, but access to the full power and flexibility of Unreal Engine.
Blueprints are ideal for most gameplay scripting, but C++ is essential for advanced or custom engine work.

This distinction helps teams choose the right tool for the job: Blueprints for speed and accessibility, C++ for depth and extensibility.

Now the topic of this article is on how to convert a blueprint into a cpp class file, meaning converting visual script logic into text logic.

This is the blueprint to convert. The bot player.

This is the Blueprint for the Bot Player in Unreal Engine 5. Here’s a breakdown of its structure and components:

Components

SphereCollision: The root component, likely used for collision detection.
BotMesh: The visual mesh representing the bot.
SpringArm: Used to position and smooth the camera relative to the bot.
ThirdPersonCamera: A camera attached to the spring arm for a third-person view.
FirstPersonCamera: An additional camera, possibly for switching to a first-person view.
FloatingPawnMovement: Handles movement logic for the pawn, allowing it to move smoothly in the world.

Functions

Several custom functions are defined, such as:
- Fire/SpawnBlaster
- FireLaser
- GetEndTrace
- GetTargetPoint
- ShowLevelClearedMessage
- IsCurrentColorNotDefault
- And more...

These functions likely handle the bot’s gameplay logic, including firing weapons, targeting, and displaying messages.

Variables

Variables like bHasRifle (Boolean), RightRifleSocketName (Name), and various transforms and names for weapon sockets.
These variables are used to manage the bot’s state, equipment, and interactions.

Interfaces and Macros

The Blueprint may implement interfaces and macros for reusable logic and communication with other Blueprints or systems. This blueprint does use the BPI_Damageable interface.

And also the BPI_TaggedActor

These interfaces are used in a combat or interaction system, where:

SetDamage is used when something is hit or attacked.

GetTag/SetTag are used to classify identity of this actor as Player (e.g., tagging this BP_BotPlayer as having the “PlayerTag” or “EnemyTag” in case of BP_Enemy).

Summary:

This Blueprint defines a player-controlled bot pawn with cameras for both first- and third-person views, movement logic, weapon handling, and various gameplay functions and variables. It serves as the main class for the bot player in your game.

Create the C++ Class In Unreal Editor, go to File > New C++ Class. Choose the appropriate parent class (e.g., APawn or ACharacter for a player, APawn or AActor for an enemy bot). Name your class (e.g., PlayerPawn, EnemyBot).

Move Variables and Components In your new C++ header file, declare variables and components you used in Blueprint (e.g., health, movement speed, mesh, camera). Use UPROPERTY macros to expose them to the editor if needed.

2.1. Declaring and creating components (sphere collision, botmesh[staticMesh], cameras, FloatingPawnMovement)

SphereCollision: A sphere collision component, likely used for collision detection and as the root.
BotMesh: A static mesh representing the bot’s visual appearance.
SpringArm: A spring arm to position and smooth the camera.
ThirdPersonCamera: A camera attached to the spring arm for a third-person view.
FirstPersonCamera: An additional camera, possibly for first-person view.
FloatingPawnMovement: Handles movement logic for the pawn.

C++ Header File (BotPlayer.h)

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Pawn.h"
#include "GameFramework/FloatingPawnMovement.h"
#include "Components/SphereComponent.h"
#include "Components/StaticMeshComponent.h"
#include "Camera/CameraComponent.h"
#include "GameFramework/SpringArmComponent.h"
#include "BotPlayer.generated.h"

UCLASS()
class YOURGAME_API ABotPlayer : public APawn
{
    GENERATED_BODY()

public:
    ABotPlayer();

protected:
    virtual void BeginPlay() override;

public:
    // Components
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components")
    USphereComponent* SphereCollision;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components")
    UStaticMeshComponent* BotMesh;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components")
    USpringArmComponent* SpringArm;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components")
    UCameraComponent* ThirdPersonCamera;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components")
    UCameraComponent* FirstPersonCamera;

    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category="Components")
    UFloatingPawnMovement* FloatingPawnMovement;
};

C++ Source File (BotPlayer.cpp)

#include "BotPlayer.h"

ABotPlayer::ABotPlayer()
{
    // Set this pawn to call Tick() every frame if needed
    PrimaryActorTick.bCanEverTick = true;

    // Create components
    SphereCollision = CreateDefaultSubobject<USphereComponent>(TEXT("SphereCollision"));
    RootComponent = SphereCollision;

    BotMesh = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("BotMesh"));
    BotMesh->SetupAttachment(RootComponent);

    SpringArm = CreateDefaultSubobject<USpringArmComponent>(TEXT("SpringArm"));
    SpringArm->SetupAttachment(RootComponent);

    ThirdPersonCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("ThirdPersonCamera"));
    ThirdPersonCamera->SetupAttachment(SpringArm);

    FirstPersonCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FirstPersonCamera"));
    FirstPersonCamera->SetupAttachment(RootComponent);

    FloatingPawnMovement = CreateDefaultSubobject<UFloatingPawnMovement>(TEXT("FloatingPawnMovement"));
}

void ABotPlayer::BeginPlay()
{
    Super::BeginPlay();

    // Initialization logic here (if needed)
    // Example: Log that BeginPlay was called
    UE_LOG(LogTemp, Log, TEXT("BotPlayer BeginPlay!"));
}

Summary of Steps:

All components are declared as pointers in the header file.
All necessary Unreal Engine includes are provided.
Components are created and attached in the constructor.
SphereCollision is set as the root component.

And here there is a call for closure to keep this not too long.
Next chapter will bring examples of converting the BeginPlay from blueprint to a C++ script.

Creating a simple Input Action/Input Mapping Context in Unreal 5

Adriel Werlich — Sat, 07 Jun 2025 20:54:58 +0000

This can be used with a Pawn or Character derived player character, since it´s necessary to have a player controller to set the player input local subsystem to use a IMC (Input mapping context). There are 3 basic steps (1- create a input action prefixed with IA_; 2- create a input mapping context that will use the previously created IA, prefixed with IMC_; and last but not least, 3- in script, C++ or blueprint, set the IMC to be used in the player controller).

1- Create a Input Action. E.g., IA_FireLaser
While in the content browser open the context menu and in the Input section choose to create a Input Action

This IA is used as a boolean value (ON or OFF) to indicate if should fire weapon if user is pressing a mouse button or keyboard key.

2- Create a Input Mapping Acton. E.g., IMC_Player

This IMC binds left mouse button and Z key to this fire event.

3- In script (C++ or blueprint) on begin play event:
3.1- get controller
3.2- cast to player controller
3.3- get enhanced input local player subsystem
3.4- add mapping context (this example is using IMC_PlayerBot in the Add Mapping Context node MappingContext field)

And finally,

4- in script (C++ or blueprint) create a binding
4.1- open context menu (clicking or pressing tab)
4.2- type the name of the input action associated with the imc previously set for this player
4.3- link “Triggered” with a function that fire the gun/spawns the laser

Keep learning, Unreal is very broad, and there is so much to learn 👍👍👍🆒🆒🆒

Creating a simple hover effect using C# script

Adriel Werlich — Thu, 29 May 2025 06:45:51 +0000

Learning Unity - UI - Create button OnHover effect

Buttons are essential UI elements, and adding hover effects makes them feel more alive — which is crucial for engaging gameplay. In this guide, you’ll learn how to implement a hover effect using a C# script in Unity. For example, you can change button color, size, create a transition animation effect, create a sound effect, animate/change text color so on... These ideas only for a hover effect, but creativity can also kick in for a OnClick effect etc.

Step 1: Set Up Your Unity Project
Open Unity and create a new 2D or 3D project

In the Hierarchy panel, right-click and select UI > Button to create a new button

Step 2: Customize Your Button Appearance
Select the button in the Hierarchy

In the Inspector, find the Image component

Set the Source Image to your desired button appearance

Adjust colors in the Color property

From this screen shoot is possible to see some key points about the these buttons used to change application language using lean localization:

For more information about how to localize your game to local languages I have used this solution:

I have worked previously with translation only in the context of web apps using front-end frameworks like Vue.js and React.js. I remember back in 2019 I was working in a frontend application using Vue2 and translating between 2 or 3 different languages and keeping all the text hardcoded inside each different Single-File-Component (SFC) in sync with a centralized state variable managed inside Vuex store and using computed getters to trigger reactivity everytime the user changed the language, instantaneously the UI would update and replace all text from one language to another one everything handled by javascript on the browser during runtime. Remembering that javascript is a interpreted language, dinamically typed, multi-paradigm meaning that:

JavaScript is multi-paradigm, meaning it supports object-oriented,
functional, and imperative programming styles — allowing developers
to choose the most suitable approach or mix them fluidly, depending
on the problem at hand.
Object-oriented: Classes, prototypes, inheritance.
Functional: First-class functions, closures, higher-order functions,
immutability.
Imperative: Step-by-step commands, loops, conditionals.

Create the Script

C# Script - MonoBehavior Base Class in Unity. Commonly used hooks: Start, Update, Awake, Destroy. Their names are hints for the lifecycle of objects inside the game.


using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

public class ButtonHoverEffect : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
{
    private Image buttonImage;
    private Color originalColor;
    public Color hoverColor = new Color(0.8f, 0.8f, 1f); // light blue tint

    void Start()
    {
        buttonImage = GetComponent<Image>();
        if (buttonImage != null)
            originalColor = buttonImage.color;
    }

    public void OnPointerEnter(PointerEventData eventData)
    {
        if (buttonImage != null)
            buttonImage.color = hoverColor;
    }

    public void OnPointerExit(PointerEventData eventData)
    {
        if (buttonImage != null)
            buttonImage.color = originalColor;
    }
}

At this points you should have something looking like this:

Looking towards creating more about these. Just to keep up with the challenge of teaching something I want to learn.