Utilizing Unreal Engine’s reflection system

May 18, 2016
Οrfeas
Uncategorized, Unreal Engine 4 C++ Tutorials
8 Comments

In this post, we’re going to utilize the built-in reflection system in UE4 to perform changes in our game at runtime. Reflection is the ability of a program to inspect its own code (or other associated code) and change at runtime (for more information about reflection, click here). By default, C++ isn’t capable of that, however Unreal Engine is kind enough and created this ability for us!

In this post, we’re going to create one BlueprintCallable function which will take a single FString parameter. That function will search all the available functions of our object and if it manages to find a function whose name is the same of our parameter, it will execute it. This is the most common case of using reflection.

In case you find yourself writing C++ out of the engine and want to use this feature, a simple workaround is to create a map container with string keys and pointers to functions as mapped types. Then, you can manual search your map and execute your associated function using the corresponding function pointer.

Let’s move on and use the reflection system of the engine!

Utilizing UE’s reflection system

I’ve created a Third Person C++ template project and inside my character’s header file, I’ve added to following declarations:

public:

	/*This function will search which function to execute*/
	UFUNCTION(BlueprintCallable, Category = Reflection)
	void ExecuteFunction(FString FunctionToExecute);

	UFUNCTION()
	void DoSomething();

public:

/*This function will search which function to execute*/

UFUNCTION(BlueprintCallable, Category = Reflection)

void ExecuteFunction(FString FunctionToExecute);

UFUNCTION()

void DoSomething();

Then, I’ve implemented the following logic:

void AReflectionCharacter::ExecuteFunction(FString FunctionToExecute)
{
	//FindFunction will return a pointer to a UFunction based on a
	//given FName. We use an asterisk before our FString in order to
	//convert the FString variable to FName
	UFunction* Function = FindFunction(*FunctionToExecute);

	//When you're using a pointer - make sure to check if it's valid first!
	if (Function)
	{
		//The following pointer is a void pointer,
		//this means that it can point to anything - from raw memory to all the known types -
		void* locals = nullptr;

		//In order to execute our function we need to reserve a chunk of memory in 
		//the execution stack for it.
		FFrame* frame = new FFrame(this, Function, locals);

		//Unfortunately the source code of the engine doesn't explain what the locals
		//pointer is used for.
		//After some trial and error I ended up on this code which actually works without any problem.
		
		//Actual call of our UFunction
		CallFunction(*frame, locals, Function);

		//delete our pointer to avoid memory leaks!
		delete frame;
	}
}

void AReflectionCharacter::ExecuteFunction(FString FunctionToExecute)

{

//FindFunction will return a pointer to a UFunction based on a

//given FName. We use an asterisk before our FString in order to

//convert the FString variable to FName

UFunction* Function = FindFunction(*FunctionToExecute);

//When you're using a pointer - make sure to check if it's valid first!

if (Function)

{

//The following pointer is a void pointer,

//this means that it can point to anything - from raw memory to all the known types -

void* locals = nullptr;

//In order to execute our function we need to reserve a chunk of memory in

//the execution stack for it.

FFrame* frame = new FFrame(this, Function, locals);

//Unfortunately the source code of the engine doesn't explain what the locals

//pointer is used for.

//After some trial and error I ended up on this code which actually works without any problem.

//Actual call of our UFunction

CallFunction(*frame, locals, Function);

//delete our pointer to avoid memory leaks!

delete frame;

}

Compile and save your code. When you’re done with that, add the following Blueprint code to your character:

Here is my output after pressing E a couple of times:

A big thank you to Eduard Gelbling and Sergiu Crăiţoiu for their suggestions and ideas which led to an updated code in this post! You’re awesome!

Οrfeas

This Post Has 8 Comments

Noah Zuo says:

May 23, 2016 at 10:11 am

This article is really cool, but how to pass a variable to the function please?

Reply
1. Οrfeas says:
  
  May 29, 2016 at 9:33 am
  
  Hello, in other programming languages which support reflection by default you pass an array of objects and then your program tries to execute the given function by correlating the functions’ arguments with that array. Currently in UE4 I’m unable to find a built-in way to do so.
  
  -Orfeas
  
  Reply
Jimi says:

February 26, 2017 at 7:10 am

Hi, it seems simple to use Target->ProcessEvent(Fn, Args); ? Is it wrong?

snippet from engine
static void Call(UObject* Target, const TCHAR* FunctionName, void* Args = nullptr) { if (!Target) { return; } UFunction* Fn = Target->FindFunction(FunctionName); if (Fn) { Target->ProcessEvent(Fn, Args); } }

Reply
1. Οrfeas says:
  
  March 4, 2017 at 11:47 am
  
  Hello,
  
  Even if I haven’t verified that this snippet works, it’s not unusual that the engine may provide multiple way to utizile a functionality. It depends on your use case and your needs.
  
  Having said that, I wouldn’t say that your snippet is wrong.
  
  -Orfeas
  
  Reply
ahsan muzaheed says:

April 7, 2018 at 8:02 am

hi.
thanks for this incredibly helpful article.
I am curious to know is there any way to get the return value of a function?

Reply
1. Οrfeas says:
  
  May 12, 2018 at 1:41 pm
  
  Hello,
  
  That’s actually a good question, unfortunately I haven’t investigated this at the time of writing this comment.
  You should probably check the engine’s code.
  
  -Orfeas
  
  Reply
Joon says:

November 19, 2020 at 5:32 pm

Hi. This post was very helpful to me.
And I have a question.
With the Unreal’s reflection system, can I expose, use or search any properties on an UObject too?

Reply
Jax says:

September 7, 2021 at 6:14 pm

Sorry, but this solution simply crashes engine. Tested in 4.26

Reply