Forem: Haris

Unreal Engine 3D Fluid To Flipbook

Haris — Sun, 08 Mar 2026 00:15:31 +0000

I always wanted to create blood VFX using alembics but that turned out to be a bit high end effect which can have a huge file size, it still is perfectly fine to use it for high fidelity games, but it obviously doesn't scale well enough.

All this time unreal engine had a built-in solution to convert your fluid simulations into flipbooks which you can then use in your particle effects.

In this section I will go over how to extract flipbook textures from Grid3D_Gas_ColoredSmoke.

Create a Gas 3D simulation from particle system

Open up this Niagara asset and click on the Baker button

In the Bake menu adjust your camera so you have the particle at the center of your screen

In the Bake menu adjust your camera so you have the particle at the center of your screen.

Set name, frame size is best kept at 128, Use Texture Atlas Size to set the resolution 1K or 2K is best for games, Then Click on the Bake button mentioned with a green arrow.

This will generate a texture atlas like this:

Creating Our Material

Now before we start to create our 2D Sprite emitter we first are going to setup the material using the Atlas

Set the material blend mode to Translucent, Press T to add a texture sample node, assign the atlas to it.

To get rid of the black background we divide RGB with Alpha and plug it into the Emissive Color, The Alpha also goes into Opacity.

Creating Sprite Emitter

Using this template create a new Particle system.

Once created Add these 2 modules:

Scale Sprite Size (Optional)
Sub UV Animation

And to change the size of our sprite do this:

That is it, you now have a 2D Flip book version of your 3D fluid simulation.

To Have it loop you have to click the Emitter Update Module and Set it to infinite there and loop delay as well.

Gameplay Ability System Tips

Haris — Sat, 07 Mar 2026 23:34:53 +0000

Who Can Have Ability System Component (ASC)

Any actor can have ability system component that includes things like chests, breakable boxes, turrets etc.
It is recommended to create the base class in C++ because we need to implement the “AbilitySystemInterface”, it is not needed but it is recommended because with this interface you can use some functions from Ability system library.

Best Place to have ASC for Players

For a simple single player game, you can have your ASC attached to your player character and initialize with the owner and avatar with player character actor as well.
The best actor that works for multiplayer is Player State.
Player state exists on server but is replicated to clients as well unlike controllers which only exist on server, if your game is single player you can opt to have your ASC only on controller.
For AI bots in multiplayer games all you need to do is set bWantsPlayerState of AI Controller to true.
Player State is persistence across respawns so all of your de-buffs, cooldowns will remain as they were when you respawn. You will need to manually remove and reset them.

Owner And Avatar

Owner actor is what persistently represents your character like Controller or Player state, where as Avatar is what physically represents you like Pawn or Character.
Things like Turret and Boxes can be both Owner and Avatar themselves.

Where to call Init Or Refresh Ability Actor Info

This must be called on both server and client to work.
To Guarantee that PC exists client-side before calling Init is to do this in the Player state’s On Rep function inside the PC, this is done in Lyra as well:

void ALyraPlayerController::OnRep_PlayerState()
{
    Super::OnRep_PlayerState();
    BroadcastOnPlayerStateChanged();

    // When we're a client connected to a remote server, the player controller may replicate later than the PlayerState and AbilitySystemComponent.
    if (GetWorld()->IsNetMode(NM_Client))
    {
        if (ALyraPlayerState* LyraPS = GetPlayerState<ALyraPlayerState>())
        {
            if (ULyraAbilitySystemComponent* LyraASC = LyraPS->GetLyraAbilitySystemComponent())
            {
                // Calls InitAbilityActorInfo
                LyraASC->RefreshAbilityActorInfo();
                LyraASC->TryActivateAbilitiesOnSpawn();
            }
        }
    }
}

The other part how I handled It was through another function inside the PC, this will do it for client.

// For Client, Must be used for initializing the ability system
virtual void AcknowledgePossession(APawn* InPawn) override;

void ARHN_PlayerController::AcknowledgePossession(APawn* InPawn)
{
    Super::AcknowledgePossession(InPawn);

    ARHN_CustomCharacter* C = Cast<ARHN_CustomCharacter>(InPawn);
    if (C)
    {
        C->GetAbilitySystemComponent()->InitAbilityActorInfo(C, C);

        // Client / Call this On Server as well
        C->InitializeAttributes();
    }
}

For server we would use the character’s Possessed By function:

void ARHN_CustomCharacter::PossessedBy(AController* NewController)
{
    Super::PossessedBy(NewController);

    if (ASC)
    {
        ASC->InitAbilityActorInfo(this, this);
    }

    SetOwner(NewController);

    // Give Ability to Player on the server
    if (ASC && AbilityToGive && AbilityToGive2)
    {
        ASC->GiveAbility(FGameplayAbilitySpec(AbilityToGive.GetDefaultObject(), 1, 0));
        ASC->GiveAbility(FGameplayAbilitySpec(AbilityToGive2.GetDefaultObject(), 1, 1));
    }

    // Call this when you get respawned
    //ASC->RefreshAbilityActorInfo();

    // In the future if players rejoin an ongoing session and we don't want to reset attributes, then change this
    // Server / Call this on Client as well
    InitializeAttributes();
}

Replication Modes

There are three replication modes: Full, Mixed and Minimal.

Most of time you would be either using Full or Mixed, Mixed is even more common as in Mixed the owning client will receive full Gameplay Effect information where as other clients will only get the tag.

A Good example of using Full is when other clients need to be able to see the remaining gameplay effect durations that are applied on other clients or bots.

Simulated Touch With Input Swapping In Unreal Engine

Haris — Sat, 07 Mar 2026 07:40:50 +0000

Problem

So swapping keyboard with touch input is quite easy by default in unreal engine all you need is one function which is called ActivateTouchInterface.

PlayerController->ActivateTouchInterface(TouchInterface);

If you provide no touch interface it will switch your input from touch to mouse and keyboard, but our problem is that our project has pixel streaming enabled which means it always run on a remote PC. To support touch even in that scenario we have to simulate mouse as touch input, this can be done in project settings: Use Mouse for Touch

You can find this setting in Engine→Input inside your project settings.

With this option enabled there is now another issue at hand upon switching to keyboard at runtime will mess up your camera controls even if you turn this option off in Input Settings.

We noticed this bug in our testing phase and found out that this maybe happening because of the DefaultInput Config is still set to false even if you change your bUseMouseForTouch inside the input settings.

Upon manually writing in that DefaultInput Config still didn’t solve the issue because turns out the engine is still overwriting it.

Solution

In order to fix this issue we came across a function inside SlateApplication there is function called:

void FSlateApplication::SetGameIsFakingTouchEvents(const bool bIsFaking, FVector2D* CursorLocation)

So in our function where we swap the inputs we call this function via getting the slate application and it fixed the issue.

Change Platform UI

My UI gets added to viewport on begin play and it pops up 2 buttons which player needs to choose which input mode they want to use.

Here is how the Widget blueprint looks like:
Construct:

Desktop Button:

Mobile Button:

The main thing you will notice here is that we created a custom function in our game instance class which swaps the input given the UTouchInterface

Game Instance

Create a new game instance class, honestly it might be better to move this function into player controller but I choose game instance for this example.

UFUNCTION(BlueprintCallable, Category = "Input")
    void ToggleTouchInterface(APlayerController* PlayerController, UTouchInterface* TouchInterface);

Implementation:

void UMyGameInstance::ToggleTouchInterface(APlayerController* PlayerController, UTouchInterface* TouchInterface)
{
    if (!IsValid(PlayerController))
    {
        return;
    }

    AMyPlayerController* MyPlayerController = Cast<AMyPlayerController>(PlayerController);
    if (IsValid(MyPlayerController))
    {
        return;
    }

    const bool bIsUsingTouch = IsValid(TouchInterface);

    MyPlayerController->ToggleTouchInput(bIsUsingTouch);

    PlayerController->ActivateTouchInterface(TouchInterface);
}

before calling the ActivateTouchInterface we run a custom function which we created in our player controller called: ToggleTouchInput this takes a Boolean as parameter which determines if we are using touch or not.
Toggle Touch Input In Player Controller:

void AMyPlayerController::ToggleTouchInput(bool IsUsingTouch)
{
    UInputSettings* InputSettings = UInputSettings::GetInputSettings();
    if (!InputSettings)
    {
        return;
    }

    InputSettings->bUseMouseForTouch = IsUsingTouch;
    InputSettings->SaveConfig();

    FSlateApplication::Get().SetGameIsFakingTouchEvents(IsUsingTouch);

    GConfig->SetBool(TEXT("/Script/Engine.InputSettings"), TEXT("bAlwaysShowTouchInterface"), IsUsingTouch, FPaths::ProjectConfigDir() + "DefaultInput.ini");
    GConfig->SetBool(TEXT("/Script/Engine.InputSettings"), TEXT("bUseMouseForTouch"), IsUsingTouch, FPaths::ProjectConfigDir() + "DefaultInput.ini");
    GConfig->Flush(false, FPaths::ProjectConfigDir() + "DefaultInput.ini");
}

Nothing fancy here at first all we are doing is getting and saving the input settings with our new input mode, after that we call the function from Slate application and update our touch mode there as well.

Once that is finished for sake of full completion we save the Booleans in our Default input config as well.

Hope this helps, it is quite common for Clients to demand both touch and desktop controls in pixel streaming projects, switching them isn’t as straight forward since you need to be using simulated touch from the get-go.

Pitch Replication And Axis Compression In Unreal Engine

Haris — Sat, 07 Mar 2026 07:25:34 +0000

Replicating Pitch for using in aim offsets is a quite a common task to come across while building almost any kind of multiplayer game, you want to replicate the look view of other players to know where they are looking or aiming at.

Quite a lot of young developers will search about this on internet and come across tutorials that manually replicate the pitch value from control rotation, this is all well and good and I myself was one of those guys back in university days starting to learn Unreal I also replicated the pitch using the same way, it was not until I came across Shooter Game where upon seeing the source code I realized that a better and more efficient solution already comes with Unreal Engine.

The Pawn Class

You can use the function called GetBaseAimRotation() which exists inside the pawn class to get the replicated pitch in blueprints as well.

Follow these steps:

Get Base Aim Rotation and Get its forward vector.
Inverse transform the direction from world to local space using the world transform of the pawn itself.
Break the resultant vector and get pitch.

In C++ you can either use the functions provided by Kismet library or the C++ native functions both do the same thing, If using Kismet Library remember to add it’s respective header.

Let’s create a function which we can use to get our replicated pitch value:

FRotator GetReplicatedPitch() const;

In the implementation file:

float AMyCharacter::GetReplicatedPitch() const
{
    const FVector AimDirectionWorld = UKismetMathLibrary::GetForwardVector(GetBaseAimRotation());
    const FVector AimDirectionLocal = UKismetMathLibrary::InverseTransformDirection(GetActorTransform(), AimDirectionWorld);
    const FRotator AimRotationLocal = UKismetMathLibrary::MakeRotFromX(AimDirectionLocal);

    return AimRotationLocal.Pitch;
}

Or if you don’t want to use Kismet Math Library you can easily do the same thing with native functions:

float AMyCharacter::GetReplicatedPitch() const
{
    const FVector AimDirectionWorld = GetBaseAimRotation().Vector();
    const FVector AimDirectionLocal = ActorToWorld().InverseTransformVectorNoScale(AimDirectionWorld);
    const FRotator AimRotationLocal = AimDirectionLocal.Rotation();

    return AimRotationLocal.Pitch;
}

Under The Hood:

You might be curious that how this works under the hood, you can use the same method for replicating other axis or even other values.

As you have seen the method at the core is called GetBaseAimRotation() this function is divided into two paths, if the player has the controller and if the controller isn’t present AKA If it is a simulated proxy.

In case of controller being valid the method executes a very simple set of instructions:

FVector POVLoc;
FRotator POVRot;
if( Controller != nullptr && !InFreeCam() )
{
    Controller->GetPlayerViewPoint(POVLoc, POVRot);
    return POVRot;
}

We are just getting the player’s eyes or direction at which the player is looking at. However if the controller is not valid:

// If we have no controller, we simply use our rotation
POVRot = GetActorRotation();

// If our Pitch is 0, then use a replicated view pitch
if( FMath::IsNearlyZero(POVRot.Pitch) )
{
            // use the RemoteViewPitch
            const UWorld* World = GetWorld();
            // Simulated network driver for recording and playing back game sessions
            const UDemoNetDriver* DemoNetDriver = World ? World->GetDemoNetDriver() : nullptr;
            // This is for replay and recording skip this if statement
            if (DemoNetDriver && DemoNetDriver->IsPlaying() && (DemoNetDriver->GetPlaybackEngineNetworkProtocolVersion() < FEngineNetworkCustomVersion::PawnRemoteViewPitch))
            {
                POVRot.Pitch = RemoteViewPitch;
                POVRot.Pitch = POVRot.Pitch * 360.0f / 255.0f;
            }
            else
            {
                // This is the main part, we are just assigning Remote View pitch to pitch and returning it
                POVRot.Pitch = FRotator::DecompressAxisFromByte(RemoteViewPitch);
            }
}

return POVRot;

You might get a bit overwhelmed at first but most of this code doesn’t even get the chance to execute in normal circumstances because it is for replay and recording features, the thing we are concerned with is the last else of the if else statements:

// This is the main part, we are just assigning Remote View pitch to pitch and returning it
POVRot.Pitch = FRotator::DecompressAxisFromByte(RemoteViewPitch);

variable called RemoteViewPitch is a replicated member of the class here is how it is declared in the header:

UPROPERTY(replicated)
uint8 RemoteViewPitch;

It’s just a replicated property and another thing that catches the eye is the unsigned integer, in this variable is where our Pitch value is stored in a compressed format.

We do the compression in the pre-replication stage, pre-replication is a virtual function that you can override, and this is called on classes of type Actors right before the actual replication occurs.

void APawn::PreReplication( IRepChangedPropertyTracker & ChangedPropertyTracker )
{
    Super::PreReplication( ChangedPropertyTracker );

    if (GetLocalRole() == ROLE_Authority && GetController())
    {
        SetRemoteViewPitch(GetController()->GetControlRotation().Pitch);
    }
}

The SetRemoteViewPitch is another function inside the Pawn class which just compresses the float axis value into a single byte.

void APawn::SetRemoteViewPitch(float NewRemoteViewPitch)
{
    // Compress pitch to 1 byte
    RemoteViewPitch = FRotator::CompressAxisToByte(NewRemoteViewPitch);
}

That is all for this topic, I do recommend to go into the pawn class and take a look at these functions again, even if you can’t grasp these fear not as most of time you just will be using the built-in pitch replication for pawns and if you want to compress some other axis the best way to do this is in the pre-replication function.

Good Luck!

Move Semantics In Unreal Engine

Haris — Sat, 07 Mar 2026 07:18:53 +0000

The Copy Problem

In traditional C++ 98 programming you had two ways in which objects were created: From scratch and from copying.

Foo(); // Default Ctor
Foo(int x); // Parameterized Ctor
Foo(const Foo& rhs); // Copy Ctor
Foo& operator=(const Foo& rhs); // Copy Assignment

Copying is usually more processor intensive to overcome this in C++ 11 move semantics were invented.

Foo(Foo&& rhs); // Move Ctor
void operator=(Foo&& rhs); // Move Assignment

Moving objects is more memory efficient than copying (not every time).

When to Implement Special Functions

Deciding for which types to implement custom move constructors basically boils down to following the Rule of Three/Five/Zero, Just ask yourself one question: Does your type deal with ownership? Or, alternatively: Does your type allocate and/or manage (dynamic) resources?

For Plain old datatypes
For POD types or POD type members, moving is the same as copying. Imagine the difference between adding instances of either of the following two types to a std::vector:

// when added, the pointer to the dynamic memory allocation of numbers can be copied to the new instance in the vector
// sizeof(Foo) = 24 with gcc on Win64
// no reallocation necessary = possible performance gain
struct Foo
{
    // dynamic vector with 1000 entries
    std::vector<int> numbers;
}

// When added, a full copy must be performed
// sizeof(Bar) = 4000 with gcc on Win64
// All 1000 bytes need to be copied
struct Bar
{
    int numbers[1000];
}

Unreal Engine Terminology

Unreal engine is a bit different when it comes to naming convention and even has some extra functionality

Smart pointers are encouraged to be used with not blueprint exposed code whenever it adds clarity and simplifies object lifetime management. The Unreal equivalents to std smart pointers are:

TUniquePtr
TSharedPtr
TWeakPtr

It’s worth noting that all of this is not usable in the following contexts:

UObjects cannot be moved or referenced by smart pointers as they are always referenced by pointer and managed by the garbage collector.
Functions with r-value-reference or smart pointer parameters are not Blueprint exposable.
UStructs may define custom move functionality, but rarely benefit from it, because they usually are plain data structs.

Geometry Scripting

Haris — Sat, 07 Mar 2026 07:08:29 +0000

Geometry scripting is much like procedural mesh component, but it comes with alot of handy functions which can make life a lot easier. You can use GS(Geometry scripting) at runtime as well as in editor.

For runtime you need to use the DynamicMeshActor and for editor use the Generated dynamic mesh actor.

In Editor

Override the On Generated function.
Get the target mesh and append box.
You can use Apply Boolean function as well.
If you want to make a temporary mesh you can use the Allocate Mesh node and then append shapes or do anything you like just to make sure to use release all allocated meshes right before the end to do clean up.

Baking Mesh To Static Mesh

You can bake your mesh to a static mesh easily you need a variable of type Static Mesh as public this is where our dynamic mesh will update and write to.

Notice the NewMaterials and NewMaterialSlotNames in the options this is for, if we want to have multiple slots in our dynamic mesh actor.

Material Slots

To have multiple slots on the baked mesh you need to do this:

Use this Remap Material ID node with the ToMaterialID parameter to which ever slot you like.

Once that is done you need one more node right before you release the allocated mesh:

The Floor and Wall materials here are public variables of type MaterialInterface which the user can set in editor.

Visualizer Components

Haris — Sat, 07 Mar 2026 06:23:29 +0000

Visualizer components are editor only components which helps us draw non-rendering debug information to the screen or HUD, this is more like a modular, lightweight, debug component that does not get shipped with packaged game.

Creating An Editor Module

To Create an editor module, you need to create a new folder with same name as your runtime module but postfix it by “Ed” or “Editor” for example:
Have the following files inside your module folder:

\Private\CustomModuleEd.cpp
\Public\CustomModuleEd.h
CustomModuleEd.Build.cs

In your build.cs file:

using UnrealBuildTool;

    public class CustomModuleEd : ModuleRules
    {
         public CustomModuleEd(ReadOnlyTargetRules Target) : base(Target)
         {
               PrivateDependencyModuleNames.AddRange(new string[] 
               {
                   "Core", 
                   "CoreUObject", 
                   "Engine", 
                   "Slate", 
                   "SlateCore", 
                   "UnrealEd", 
                   "ComponentVisualizers"
               });
         }
    }

And here is how your editor module class should look like:

    #pragma once
    #include "Modules/ModuleInterface.h"
    #include "Modules/ModuleManager.h"

    class FCustomModuleEd: public IModuleInterface
    {
        public:
        virtual void StartupModule() override;
        virtual void ShutdownModule() override;
    };

#include "CustomModuleEd.h"
#include "UnrealEdGlobals.h"
#include "Editor/UnrealEdEngine.h"

IMPLEMENT_GAME_MODULE(FCustomModuleEd, CustomModuleEd);

void FCustomModuleEd::StartupModule() {}
void FCustomModuleEd::ShutdownModule() {}

Once everything is done you can now add your editor module into your plugin file:

{
    "FileVersion": 3,
    ....
    "Modules": [
        {
            "Name": "CustomPlugin",
            "Type": "Runtime",
            "LoadingPhase": "Default"
        },
        {
            "Name": "CustomModuleEd",
            "Type": "Editor",
            "LoadingPhase": "PostEngineInit"
        }
    ]
}

Make sure to set the loading phase to PostEngineInit, in case you want to check if your module is active in editor, you can go here Tools → Debug → Modules

Adding Component

The way visualization components works is by having a class type usually that is an actor component present outside the editor module that is attached to the actual Actor present inside your levels.

Hence, we need to create a dummy component inside our Runtime module, we are going to call it debugger component:

UCLASS( ClassGroup=(Custom), meta=(BlueprintSpawnableComponent))
class MYPROJECT_API UDebuggerComponent : public UActorComponent
{
    GENERATED_BODY()

public: 
    // Sets default values for this component's properties
    UDebuggerComponent();

protected:
    // Called when the game starts
    virtual void BeginPlay() override;

public: 
    // Called every frame
    virtual void TickComponent(float DeltaTime, ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction) override;

public:
    UPROPERTY(EditAnywhere, Category = "Debug")
    float DrawDistance = 1000.0f;

    UPROPERTY(EditAnywhere, Category = "Debug")
    bool ShouldDrawDebugPoints = false;

};

Here we can also add properties, or we can simply read the properties from owning actor, but this component will act as an intermediary between our editor module visualizer and the data which exists inside our run-time module.

Add Visualizer Component in Editor Module

Create a new empty class inside the editor module and call it VisualizerComponent this will inherit from FComponentVisualizer.

/**
 *  Remove the API part of class definition because we don't want to expose this to other modules
 */
class TestVisualizer : public FComponentVisualizer
{
public:
    virtual void DrawVisualization(const UActorComponent* Component, const FSceneView* View, FPrimitiveDrawInterface* PDI) override;

protected:
    AActor* ActorRef; // Reference for actor which needs to show this debug

private:
    FVector PerviousCameraLocation;
};

void TestVisualizer::DrawVisualization(const UActorComponent* Component, const FSceneView* View, FPrimitiveDrawInterface* PDI)
{
    const UDebuggerComponent* debuggerComp = Cast<UDebuggerComponent>(Component);
    if (!debuggerComp || !debuggerComp->ShouldDrawDebugPoints) { return; }
        PDI->DrawPoint(ActorRef->GetActorLocation(), FLinearColor::Green, 25.0f, SDPG_Foreground);
}

To make this all work, you need to have your run-time debugger component added onto the actor you wish to have debug visualizers for, you can either do it manually in blueprints, instances or via C++ in constructor using default sub object.

Register your Visualizer in Editor Startup

The final step is to register your visualizer component and bind it with the debugger component during the startup function of your editor module.

Go back to the CustomModuleEd.cpp and implement the following:

void FCustomModuleEd::StartupModule()
{
    if (GUnrealEd)
    {
        const TSharedPtr<TestVisualizer > TestViz = MakeShareable(new TestVisualizer ());
        GUnrealEd->RegisterComponentVisualizer(UDebuggerComponent::StaticClass()->GetFName(), TestViz);
        TestViz->OnRegister();
    }
}

void FCustomModuleEd::ShutdownModule()
{
    if (GUnrealEd)
    {
        GUnrealEd->UnregisterComponentVisualizer(UDebuggerComponent::StaticClass()->GetFName());
    }
}

Now Compile and launch the editor, once you will select the actor which has the debugger component attached to it, the PDI will draw the debugs you mentioned in DrawVisualization function inside the class.

Concepts In C++ 20

Haris — Sat, 07 Mar 2026 00:25:47 +0000

A concept is just a true of false statement, it is like a predicate that returns true or false, there are a number of built in concepts as well.

Example
Let's have two templated functions for isEqual one would be integer specialization and other will be float, for this we will be using built in concepts.

template<typename T> requires std::integral<T>
bool isEqual(T valueA, T valueB)
{
    std::cout << "Calling the integral version\n";
    return valueA == valueB;
}

template<typename T> requires std::floating_point<T>
bool isEqual(T valueA, T valueB)
{
    std::cout << "Calling the float version\n";
    return std::fabs(valueA - valueB) < 0.0001f;
}

and inside our main driver function we can call these:

std::cout << std::boolalpha << isEqual(1, 1) << std::endl;
// This will work as we have a specialization
std::cout << std::boolalpha << isEqual(1.0f, 5.0f) << std::endl;

Lets Make a Custom Concept

Our concept is going to be very simple, as mentioned above concepts are just predicates that return a boolean so we are going to hard code ours to always return true.

template<typename T>
concept AlwaysTrue = true;

Now let's use AlwaysTrue in our templated function

template<typename T> requires AlwaysTrue<T>
void printSomething(T value)
{
    std::cout << value << std::endl;
}

In our main driver function:
Since the concept is always true we can pass in pretty much anything.

printSomething(10);
printSomethingAutoVer("Hello World!");

You can also combine different concepts using || operator, so we can make a specialization that takes both integers and floating point values

template<typename T>
concept IsFloatORInt = std::floating_point<T> || std::integral<T>;

Template Specialization Only for Types that have a Push-Back

We want to have a template that only compiles for types that have a push back function.

template<typename T>
concept HasPushback = requires(T container, T::value_type valueType) {
    container.push_back(valueType);
};

Since we need to know that we can push a value in the container we are also going to be needing to know the value type that resides in our container, this can be extracted using the value_type, Now let's make our templated function:

template<typename T> requires HasPushback<T>
void addIntToContainer(T& container, int integer)
{
    container.push_back(integer);
}

Concepts are really powerful you can now use the same ideas to do things like make template specializations for types that have a size available at compile time, different specializations for small and big data etc.

Task Based Programming Over Thread Base

Haris — Sat, 07 Mar 2026 00:06:49 +0000

Prefer Task based Programming to Thread-Based

If you want to run something Async you have two basic choices: std::thread and std::async

int doAsyncWork();

std::thread th(doAsyncWork);

// Better to use Async

auto future = std::async(doAsyncWork);

std::async(doAsyncWork) is considered a task. The task is superior because it returns a future value which we can use to sync up our program. Async task also has a get function which we can use to get the status and or if our work function emits an exception.

Async task also provides more abstraction.

What is the meaning of Thread?

Hardware threads, perform computation. Contemporary machine architectures offer one or more hardware threads per CPU core.
Software threads (also known as OS threads or system threads) are the threads that the operating system manages across all processes and schedules for execution on hardware threads.
std::threads are objects in a C++ process that act as handles to underlying software threads.

Software threads are a limited resource. If you try to create more than the system can provide, a std::system_error exception is thrown. (This is even true for a function that is marked no-except)

Even if you don’t run out of threads, you can have trouble with oversubscription. That’s when there are more ready-to-run, thread scheduler time-slices the software threads on the hardware. Such context switches increase the overhead.

Your life would be much easier if you dump all this management to someone else and that someone else is std::async

Task doesn’t have same problem as Threads.

Well Task would almost never have this out of threads problem because Async task doesn’t guarantee that it will create a new software thread. Rather it permits the scheduler to arrange for the function to be run on thread requesting the doAsyncWork() result.

Launch Policy

async sometimes run on the same thread that is expecting its output, well that is only true if you use the default launch policy which is a combination of both async and deferred.
The behavior depends on the launch policy:

std::launch::async → The function is guaranteed to run on a new thread.
std::launch::deferred → The function does not run immediately. Instead, it runs only when you call future.get() or future.wait(), and it runs on the same thread that calls get or wait.
Default (std::launch::async | std::launch::deferred) → The implementation decides whether to run it asynchronously (new thread) or deferred (same thread, lazy execution).

How to Distinguish Universal From R-Value References

Haris — Fri, 06 Mar 2026 23:53:19 +0000

To declare an R-value reference in a template you would usually see something like T&& it's not that simple, the T&& has two meanings one is R-value and one is that it can be both R-value and L-value. Furthermore, they can be bound to const and non-const values, volatile and non-volatile and can be bind to virtually anything.

Universal references arise in two contexts likely in templates.

template<typename T>
void func(T&& param);

And the second in auto declarations:

auto&& var1 = var2;

What both examples above have in common is the presence of type deduction now compare the above two to the examples below:

void func(Widget&& param); // R-value
Widget&& var1 = Widget(); // R-value since no type deduction exists

Because universal references are references, they must be initialized, the initializer of the universal reference determines whether it represents R-value or L-value.
For example:

template<typename T>
void func(T&& param);

Widget w;
func(w); // since w is an l-value the universal reference will decay to an l-value.

func(std::move(w)) // this time we are first casting 'w' to an r-value then passing it into the template, thus the reference will decay to r-value.

Edge Cases

For a reference to be universal type deduction is necessary, but it's not sufficient the form of reference declaration must also be correct, and that form is quite constrained, it must be precisely “T&&” look at an example below:

template<typename T>
void func(std::vector<T>&& param); // Parameter is an R-value

The example above will result in a non-universal reference which means it will only take R-values, why you may ask? because there is no T&&, when function will be invoked the type of just T will be deduced not T&& as the && exists with the vector not our template type T.

So, this won’t work:

std::vector<int> vec;
func(vec); // Error, the function will only take R-values.

Even a simple presence of const is enough to disqualify a universal reference.

template<typename T>
void func(const T&& param); // Having a const will make parameter an R-value.

Another edge case where this fails is not always being in a template for example:

template<class T, class Allocator = allocator<T>>
class vector
{
public:
    void push_back(T&& x);
};

Here you might think that push back’s T&& has the right to form a universal reference, but there is no type deduction in this case. This also disqualifies it for being a universal reference.

Special Functions And Pimpl Idiom

Haris — Fri, 06 Mar 2026 23:30:44 +0000

Pointer to implementation is one of the idioms in C++ which dictates that the implementation must be accessed through an indirection, which in simple words mean that we encapsulate all the member data of our class in another struct that we access via a pointer.

Benefits

The benefits comes in the form of lowered compilation times, easier to manage headers, the reason compile times decrease is because instead of declaring every member in a header file which than forces us to add headers as well, for example if we have members of type vector and string we will have to include their header files as well and every time we would make a change in those data member types or Let’s say we have another custom type which gets new revisions very often that would result in us recompiling the entire header for our class again.

Use Pointers

Like the name says we hold a pointer to implementation, the pointer can be a raw pointer, unique pointer or a shared pointer.

Raw and unique pointers are most performance friendly so we will look into those first.

Pointer

// Header file

class Widget
{
public:
    Widget();
    ~Widget();

private:
    struct Impl; // Also known as forward declaring or incomplete type
    Impl* pImpl; // Pointer to implementation
}

// Source file
struct Widget::Impl
{
    std::vector<int> m_age;
    std::string m_name;
    PlayerController m_controller; // Our custom type
}

Widget::Widget()
{
    // Constuctor
    pImpl = new Impl();
}

Widget::~Widget()
{
    delete pImpl;
}

This is straight forward, but we are here for smart pointers aren’t we? Let's see how this works with a unique pointer:

Unique Pointer

Before we dive into code lets establish some base points regarding pointer to implementation idiom.

It hides private data, so the API remains stable.
It won’t recompile the header as it just holds a 4 byte (OS dependent) pointer to implementation.
Downfall is the introduction of an indirection as now you have a pointer.
Beware while creating a copy constructor.
This is well used for classes that have huge number of private members.

// Header file
class Person
{
public:
    Person(std::string name, std::string address);
    ~Person();

    // Copy operations
    Person(const Person& rhs);
    Person& operator=(const Person& rhs) = delete;

    // Move operations
    Person(Person&& rhs);
    Person& operator=(Person&& rhs) = delete;

    std::string GetAttributes() const;

private:
    struct Impl;
    std::unique_ptr<Impl> pImpl;
}

// Source file
// Always first define the structure where member data is stored
struct Person::Impl
{
    std::string name;
    std::string address;
};

Person::Person(std::name, std::address) : pImpl{std::make_unique<Impl>()}
{
    pImpl->name = name;
    pImpl->address = address;
}

Person::~Person() = default;

Person::Person(const Person& rhs)
{
    pImpl = std::make_unique<Impl>();
    pImpl->name = rhs.pImpl->name;
    pImpl->address = rhs.pImpl->address;
}

Person::Person(Person&& rhs) noexcept
{
    pImpl = std::move(rhs.pImpl);
}

std::string Person::GetAttributes() const
{
    return pImpl->name + '\t' + pImpl->address;
}

A few things to note:

Always define the implementation struct before you call the constructors of class else compiler will throw undefined errors because unique pointers don’t work with incomplete types as they needed to be defined along with destructors ahead of usage.
Remember the special member function generation rules, if you declare a destructor then it will prevent compiler from auto generating the move operations.
With unique pointer you have to define your own copy constructor else it will do a shallow copy.

Shared Pointer

Though using shared pointers is not common but with shared pointers you don’t have a problem with incomplete type neither do you have to custom define any move or copy operation, with shared pointer we will have no effect as they are copyable and moveable by nature.

Null Pointer

Haris — Fri, 06 Mar 2026 23:22:09 +0000

The main reason to use nullptr over NULL or 0 is that the nullptr is of type std::nullptr_t this is very useful in case of function overloading.

Consider this example:

void func(int);

void func(bool);

void func(void*);

Now if we call the functions by the following arguments:

func(0) -> This will call func(int) not func(void*)
func(NULL)-> This will also call func(int)

So why does NULL also calls func(int)?
This is because NULL's possible implementation is: #define NULL 0 Or depending on your compiler in modern C++ version it can be #define NULL nullptr so just to be on the safe side always use 'nullptr'.

In case of pointer type (int*) the compiler correctly deduces the integer 0 to be a null pointer but like above in case of function overloading where a function overload with integer already exists will always overshadow the pointer argument overload.

Readability And Clarity

Another important thing that nullptr does well is readability along with auto keyword, consider this example:

auto result = findRecord(…);

if(result == 0) {…}

if(result == nullptr) {…}

See how the last statement gives more clarity to the reader that result is of type pointer.

Fun Fact
When you create a new object on heap which is a non-temporary object, however the pointer you get from new is an r-value but it can still point to an l-value.
Dereferencing pointers always create l-value references, notably the object created using new is also an l-value because it has an address.