First thing we need to do is create a variable.

TArray<FSomeData> MyData;
FScopedSlowTask MyTask(MyData.Num(), FText::FromString("Processing data..."));

Notice that I defined an instance of the struct passing two parameters. First one, MyData.Num() defines how many units of work we are going to be processing. In our example, we will be processing array elements, so the number of units of work is equal to the number of the array elements. The second parameter is just a text that will be displayed on a progress bar.

Then, we just need to update the our task notifying it how many units of work we are planning to process at a given time.

for (int32 Index = 0; Index < MyTask.Num(); Index++)
{
	MyTask.EnterProgressFrame(1.0f);
	...
	...
	...
}

And that’s it. We don’t need to worry about notifying the task that we have finished processing because it will wrap things up itself as soon as it runs out of the scope.

As soon as the variable runs out of the scope (at the end of the function at latest unless you explicitly declared the variable on a heap) the cursor is being changed back to normal. Let’s have a look at an example code using it.

void AMyActor::Foo()
{
	...
	...
	...
	{
		// Creating busy curosr, default cursor is being
		// replaced with busy cursor here.
		FScopedBusyCursor BusyCursor;
		for (int32 Index = 0; Index < VeryBigNumber; Index++)
		{
			...
			...
			...
		}
	}
	// Busy cursor doesn't exist here so normal cursor is
	// being set here.
}

%COPYRIGHT_LINE%

#pragma once

#include "CoreMinimal.h"
%BASE_CLASS_INCLUDE_DIRECTIVE%
#include "%UNPREFIXED_CLASS_NAME%.generated.h"

UCLASS(%UCLASS_SPECIFIER_LIST%)
class %CLASS_MODULE_API_MACRO%%PREFIXED_CLASS_NAME% : public %PREFIXED_BASE_CLASS_NAME%
{
	GENERATED_BODY()
	
public:	
	// Sets default values for this actor's properties
	%PREFIXED_CLASS_NAME%();

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

public:	
	// Called every frame
	virtual void Tick(float DeltaTime) override;

	%CLASS_FUNCTION_DECLARATIONS%
	%CLASS_PROPERTIES%
};

This is for example template file for a header file for the Actor class. I don’t know about you, but first thing I always do is delete all the comments and then move the Tick function right under the constructor to get rid of the second public namespace. Perhaps you might want to delete the tick function completely and modify the CPP file to disable ticking by default.

I highly recommend adjusting these templates to your project to improve the quality of life of your developers.

To be specific, the structure we are talking about here is FAIDataProviderValue and its subclasses. This struct has a property of type UAIDataProvider. This one is the most interesting one from the end user perspective. The engine ships with two subclasses to this one:

• UAIDataProvider_QueryParams

• UAIDataProvider_Random

The first one is used in EQS to allow specifying EQS params when requesting query execution. The second one, as the name states, is purely random.

Let’s go back to the example I mentioned in the first paragraph and assume that we are using Gameplay Ability System (GAS) in our game. This means, that the attack range is most likely a property in an attribute set for either character or a weapon. What we can do is create a subclass of UAIDataProvider class and make it bind its value to a specific attribute value.

class AIMODULE_API UAIDataProvider_Attribute : public UAIDataProvider
{
	GENERATED_BODY()
public:
	virtual void BindData(const UObject& Owner, int32 RequestId) override;

	UPROPERTY(EditAnywhere, Category = Provider)
	EAttributeType AttributeType;

	UPROPERTY()
	float FloatValue;

	UPROPERTY()
	int32 IntValue;

	UPROPERTY()
	bool BoolValue;
};

Above is an exampel code on how to declare a class that will bind attribute value based on the specified AttributeType. Inside the BindData function what we need to do is query the attribute value from the Owner and set its value to the FloatValue, IntValue and BoolValue.

Then, wherever you create a reference for the FAIDataProvider struct, you will be able to assign your new UAIDataProvider class reference to dynamically bind the attribute value to it.

Here is an example on how the above would look like in the editor when used for specifing grid half size for EQS simple grid generator:

Pro tip: it’s worth adding a property to your data provider to specifying a constant fall through value. This is because when testing EQS in the editor time using EQS testing pawn, these data providers will fail to bind to any meaningful values as there are most likely no instances of actors that we can read the attributes from.

FAutoConsoleVariableSink are usually defined in a source file (not headers) and look like this:

FAutoConsoleVariableSink FooCVarSink(FConsoleCommandDelegate::CreateStatic(&OnFooCVarChanged));

As you can see, the constructor of this property take a delegate reference. This is where we define a function we want to invoke when a console variable changes.

There are multiple examples in the engine on how these are being utilized, so if you are curious, have a look at the engine code.

Merging meshes into a single one is not always beneficial, but there are some cases where it is. In case of skeletal mesh for example, it allows you to run a single animation blueprint on a single skeletal mesh component instead running multiple instances on multiple parts. Even other instances do nothing but copy the pose, that still costs us some computation time.

This specific tag allows us to force a flag to be inlined into the same row as another property that uses it for its EditCondition.

Here is how to define it:

UPROPERTY(EditAnywhere, meta=(InlineEditConditionToggle))
bool bExampleFlag = false;

UPROPERTY(EditAnywhere, meta=(EditCondition="bExampleFlag"))
float ExampleValue = 0.0f;

With the above defined, this is what we will see in the editor:

UE5Editor.exe -run=FixRedirectors

This will run the FixRedirectors commandlet.

The problem with that is when you are iterating on your commandlet, you must boot the editor from scratch every time you make any change.

Starting release 5.5, there is now a console command that allows you to run a commandlet directly from the editor: RunCommandlet.

This means that you can change your code, use live coding to compile the changes and use that console command to run your commandlet directly from the editor.

{Parameter}|plural(one=Text,other=OtherText)

Let’s break it down. First, we must specify a parameter that will be used to evaluate which form the Format Text node should use. Right after that, we must insert | and specify the function (I guess?) name, in this case, plural. Then, inside paranthesis, specify version for a single item with one=YourText and finally specify version for all the other cases by typing other=YourOtherText.

Example usage:

{Num}|plural(one=item,other=items)

Here is a blueprint graph presenting the above example:

With the literal int value equal to 1, the above format text would evaluate to “You have 1 item.”. If we were to change it to any other value greater than 1, we would get “You have X items.”.

To call an event from a level blueprint use following console command:

ce EventName ParamValues

With the above command you will execute an event with a name EventName with parameter values specified right after.

ke ActorName EventName ParamValue

ActorName is the name as appears in the scene outline.

EventName is the name of the blueprint event.

ParamValue is the value of a parameter, if one exist.

Further more, you can use * instead ActorName to execute specified event on all actors. For example:

ke * Jump

will execute Jump event on all actors that have that event defined.

There is a CoreDelegate.h header file where we can find a lot of useful delegates. Go ahead and explore yourself while I will bring just few examples here.

Here is a delegate broadcasted when GConfig is ready to use.

DECLARE_MULTICAST_DELEGATE(FConfigReadyForUse);
static FConfigReadyForUse ConfigReadyForUse;

Here is a delegate that allows us to add our own message to the viewport, similar to the “Lightning needs to be rebuilt” message we can often see.

DECLARE_MULTICAST_DELEGATE_OneParam(FGetOnScreenMessagesDelegate, FSeverityMessageMap&);
static FGetOnScreenMessagesDelegate OnGetOnScreenMessages;

namespace EAIFocusPriority
{
	typedef uint8 Type;

	const Type Default = 0;
	const Type Move = 1;
	const Type Gameplay = 2;

	const Type LastFocusPriority = Gameplay;
}

As you can see, by default there are only 3 priorities available to us. Luckily, this isn’t an enum class but simply a typedef’ed uint8 constants. This means, that we can extend this in our game code by writing something like this:

namespace EAIFocusPriority
{
	const Type CustomPriority = 3;
}

This is supported by the system as it internally expand the array that stores the focus targets for each priority:

...
if (InPriority >= FocusInformation.Priorities.Num())
{
	FocusInformation.Priorities.SetNum(InPriority + 1);
}
...

I’m not going to paste any example here due to the size of the generated text but give it a try yourself!

PS. Sorry for the lack of the daily column updates in the past days but I decided to keep myself offline during my holidays. I’m back now though, and so is the unreal column!

These bindings are defined inside a BaseInput.ini file.

[/Script/Engine.PlayerInput]

; --- General bindings
+DebugExecBindings=(Key=F11,Command="LevelEditor.ToggleImmersive", bIgnoreCtrl=True, bIgnoreAlt=True)
+DebugExecBindings=(Key=F11,Command="MainFrame.ToggleFullscreen",Shift=True)
+DebugExecBindings=(Key=F1,Command="viewmode wireframe", bIgnoreShift=True)
+DebugExecBindings=(Key=F2,Command="viewmode unlit")
+DebugExecBindings=(Key=F3,Command="viewmode lit")
...

So, to add your own keys, you can either modify this config file directly, or add the [/Script/Engine.PlayerInput] section in one of your game specific configs to enable them.

The key bindings will be automatically stripped out in a shipping build.

FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
TArray<FAssetData> AssetData;
const UClass* Class = UStaticMesh::StaticClass();
AssetRegistryModule.Get().GetAssetsByClass(Class->GetFName(), AssetData);

you probably don’t want to load all of them into memory. Unfortunately, in order to read an object property, it would need to be loaded. That is, unless its properties are being marked with AssetRegistrySearchable. A property with this tag is being added to a TagsAndValues map of the FAssetData structure. This allows us to find all objects, then filter them using these tags and values, and only load the ones we really need.

Example property declared as AssetRegistrySearchable:

UPROPERTY(Category=Texture, AssetRegistrySearchable)
TEnumAsByte<enum TextureFilter> Filter;

Have a look at FGenericPlatformMisc which all of platform specific implementations inherit from to get a better understanding of what is available.

TFixedAllocator works exactly same in this regard, except it doesn’t offer a fallback which TInlineAllocator does. This means that if we exceed declared size, the program will crash. This might be intended as we may design certain functions to work on a specific order of magnitude of data, so knowing when this limit is exceeded can be very beneficial to us.

TArray<float, TFixedAllocator<32>> Floats;

The above snippets shows how to declare array using TFixedAllocator.

Adding this line of text to your ‘.uproject’ file will prevent them from loading:

...
"DisableEnginePluginsByDefault": true,
...

Of course, we still need some plugins to be enabled in order to be able to use the Editor at all. This is why some great folks created a snippets that contain the absolutely required ones you can just yank into your file and should be good to go.

Here is a link to a gist: https://gist.github.com/MilkyEngineer/a1e953f87509877adc4587cf8776c8a2

virtual void PostEditChangeChainProperty(struct FPropertyChangedChainEvent & PropertyChangedEvent) override;

The base function is defined inside UObject class, so any subclass can overwrite it. Inside it, you figure out which property has been updated based on the data from the FPropertyChangedChainEvent, but more details how to fetch this data will be covered in the future column.