If you want to help us maintaining this wiki, check out or discord server: https://discord.gg/3u69jMa 

Writing Native Code

From SWRC Wiki
Revision as of 19:41, 27 January 2018 by Leon (talk | contribs)
Jump to: navigation, search

Note: Some C++ and UnrealScript knowledge is required.


Native coding in the Unreal Engine refers to code that is written in C++ instead of UnrealScript. This C++ code can be called from a script to execute tasks that are either too slow in UnrealScript (about 20 times slower than C++) or are not possible at all due to the limited features of the language. Native coding is only officially supported by Unreal Tournament from 1999 (I think Deus Ex as well...) since it is the only game that has its native header files publicly available for download. Epic never released the headers for newer versions of the engine due to licensing issues with third party code. However, after countless hours of work it was possible to modify the UT99 headers in such a way that they're usable with Republic Commando. This process is not finished yet but the most important classes like Object, Actor, Pawn and some others already work.

The way native coding works in Unreal is that you compile your scripts into a .u package and then when you write your C++ code you compile it as a dll with the same name as your package. When the game is loading a UnrealScript class and detects that it was declared as native, it also looks for a dll which contains the native code for this UnrealScript class.

Getting Started

Before you can write any C++ code you first need to create a UnrealScript class that you declare as native. This tutorial assumes that you already know how to compile UnrealScript code with ucc. If you don't, then the download for the Republic Commando UCC contains a brief explanation in its readme.

For the sake of this tutorial I'm going create a really simple and quite useless class that has one native function which writes a string to the log file.

class TestNativeClass extends Actor native

var int TestInt;

native(1024) final function TestNativeFunc(string param);

function PostBeginPlay(){

	TestNativeFunc("Hello World!");

The class is going to be implemented in C++ and thus must be declared as 'native'. I added an integer variable called 'TestInt' that we're going to modify in C++ and then use in UnrealScript just to show that both, the C++ and Unrealscript classes refer to the exact same object in memory.

Furthermore, I declared a native function called 'TestNativeFunc' that takes in a string parameter. Notice the number in parentheses right after the 'native' keyword. This is the unique identifier Unreal uses to associate this UnrealScript function declaration with the actual C++ function. Some of these IDs are already used by the engine so try not to overwrite them. You can check which ones are available by entering the 'DumpNatives' console command while ingame. It will write all available IDs to the log file. However, I always start at 1024. All following numbers are definitely not in use by the game so you can really use anything up to 4095 which is the maximum amount of native functions.

In my 'PostBeginPlay' function I simply call the native function with "Hello World!" as the string parameter and I also write 'TestInt' which at this point has been changed in C++ code to the log file.

Before you go now and compile the script with the ucc you want to do something else. When compiling a native class the ucc also generates a header and a source file with the C++ class definition and some other setup code. But these won't be created by default because the folder they're supposed to be created in doesn't exist so we'll do that before we compile our class. In the folder that contains the UnrealScript source code you have a folder with the name of your package which in turn contains a folder called 'Classes' that holds all the .uc files for this package. Navigate to your package's folder and create two new folders called 'Inc' and 'Src'.


Now compile your package with ucc make. When the compilation is successful the ucc will prompt you whether you want to overwrite the files "MyPackageClasses.h" and "MyPackageClasses.cpp". Just click on yes for both. They are created in the 'Inc' and 'Src' folders.

Setting Up Visual Studio .NET 2003

In order to write native code for Republic Commando you first need MS Visual Studio 2003. Newer versions could work but probably won't so just use this one. Since it was also used to compile RC it gives you maximum compatibility. However, due to it being rather old, it has some issues with newer versions of Windows but there are workarounds. You can ignore any errors that might occur during the installation as it should work regardless.

Once you have installed Visual Studio open it up and create a new solution that is going to contain all your native coding projects. Go to "File->New->Blank Solution...", enter a name and click Ok. Then go ahead, right click the newly created solution in the solution explorer to the left and go to "Add->New Project...". Create an "Empty Project (.NET)" with the same name of your UnrealScript package. We are actually not going to use .NET but most of the other project default configurations don't work because the buttons in the Wizard are broken on modern Windows for some reason. When you have successfully created a new project you have to adjust some settings. But before you do anything go to the top toolbar and where it says 'Debug' select 'Release' from the drop down menu. The right click the project (not the Solution!) in the solution explorer and select "Properties".

You should see the following:


There's an issue that I've seen (on Windows 7 but not on Windows 10 strangely) where the properties on the right are not visible and there's just a big grey area. In that case, close Visual Studio, download this pre-configured project and place it in the "\Documents\Visual Studio Projects\MySolution\MyProject\" folder (but delete the one you created first): Media:VisualStudioProjectTemplate.zip. Rename it so that it has name of your project.

If you didn't have any problems and everything is displaying fine you have to adjust the following properties:

	Configuration Type = Dynamic Library (.dll)
	Use Managed Extensions = No
	Character Set = Not Set
	Code Generation:
		Runtime Library = Multi-threaded DLL (/MD)	//Not necessary but recommended...
		Struct Member Alignment = 4 Bytes (/Zp4)
		Calling Convention = __fastcall (/Gr)

When that is done place the source files (.h and .cpp) generated by the ucc in the "\Documents\Visual Studio Projects\MySolution\MyProject\" folder. Open the folder in windows explorer and simply drag and drop both files onto the project they belong to in the solution explorer. You also need the header files for RC: Media:Headers.zip. Place all folders from this archive in "\Documents\Visual Studio Projects\MySolution\MyProject\".

Writing Actual Code

Now go to Visual Studio and open both source files. It should look like this:


    C++ class definitions exported from UnrealScript.
    This is automatically generated by the tools.
    DO NOT modify this manually! Edit the corresponding .uc files instead!


#pragma pack (push,4)


class MYPACKAGE_API ATestNativeClass : public AActor
    INT TestInt;
    void execTestNativeFunc(FFrame& Stack, void* Result);
    DECLARE_NATIVES(ATestNativeClass)            //REMOVE

#pragma pack (pop)

#if __STATIC_LINK                            //REMOVE

	ATestNativeClass::StaticClass(); \   //REMOVE

#endif // __STATIC_LINK                      //REMOVE



    C++ class definitions exported from UnrealScript.
    This is automatically generated by the tools.
    DO NOT modify this manually! Edit the corresponding .uc files instead!

#include "MyPackagePrivate.h" //Either Create a file called "MyPackagePrivate.h" or just replace with "MyPackageClasses.h"


FNativeEntry<ATestNativeClass> ATestNativeClass::StaticNativeMap[] = {  //REMOVE
	MAP_NATIVE(TestNativeFunc,1024)                                 //REMOVE
	{NULL,NULL}                                                     //REMOVE
};                                                                      //REMOVE
LINK_NATIVES(ATestNativeClass);                                         //REMOVE

This won't compile. You first have to modify the code a bit. Just remove every line that is marked in the code above. It is not used by RC. My guess is, that it was necessary when creating the XBox version where everything is linked statically.

Where it says this:


replace "DLL_IMPORT" with "DLL_EXPORT" since we want to export symbols from our new dll. Also in "MyPackageClasses.h" you need to include the necessary headers. Which ones depends on what classes you're using. I created a subclass of "AActor" (C++ classes have the prefix 'A' for subclasses of Actor and the prefix 'U' for subclasses of Object) which means that I have to include the headers of "Engine" since that's where Actor is defined. So add this line above your class definition:

#include "../Engine/Inc/Engine.h"    //This also includes "Core"

Now create the body of your native function in the .cpp file. The signature looks like this:

void execTestNativeFunc(FFrame& Stack, void* Result);

Notice how Unreal automatically generated the prefix "exec". That is only to differentiate between functions that are callable from UnrealScript and other ones. Also look at the parameters. Although we declared it to take in a string in UnrealScript it now has different types as parameters. The function signatures for all native functions are exactly the same. The parameters that are passed in UnrealScript are contained in the "Stack" which is of the type "FFrame".

The implementation for my function looks like this:

IMPLEMENT_FUNCTION(ATestNativeClass, 1024, execTestNativeFunc);

void ATestNativeClass::execTestNativeFunc(FFrame& Stack, void* Result){

	GLog->Logf("Native Function called from UnrealScript. Param: %s", *StringVar);

	TestInt = 12345;

Look at the use of the "IMPLEMENT_FUNCTION" macro. This is really important as it registers your native function so that it can be called from UnrealScript. The Parameters of the macro are the name of the (C++) class, the function ID number and the name of the function itself.

In the function body I use the "P_GET_STR" macro to grab the string we passed to the function in UnrealScript from the stack. This macro creates a variable of type "FString" with the name you provided as a parameter which is why I can use "StringVar" later in the function. There are also other macros for different parameter types like "P_GET_INT", "P_GET_FLOAT", "P_GET_ACTOR", etc... You can find all of them in "Core/Inc/unscript.h". So check that out if you want to. It is also important to always get all the parameters that were passed in UnrealScript or else the game will crash. For example: If my function also took in an integer variable but I only used "P_GET_STR" it'll crash. I have to do "P_GET_STR" and "P_GET_INT". Another important thing is "P_FINISH". Always use it when you're done grabbing parameters off the stack. You need it even if your function does not have any parameters. In that case just write "P_FINISH" at the beginning.

I'm then writing a simple message to the log file that shows that this function was called. I also print out the string we passed in UnrealScript. I'm using the '*' operator on an object of 'FString' to get the c-string (char*) representation of it since that is needed for the formatted logging function. Furthermore, I set "TestInt" to some random value so that I can print it out from UnrealScript to see that it is in fact the same.

Another important thing to remember is that the UnrealScript and C++ classes must be identical when it comes to class size. Don't ever add a member variable in C++ that doesn't exist in UnrealScript, don't remove one either. Functions are fine obviously.

Compile your dll by pressing F7. If there are no errors it should be created in "\Documents\Visual Studio Projects\MySolution\release". For some reason there's an error sometimes where even though you set the configuration type to dll Visual Studio will create an exe. However, this is actually just the dll with a wrong file extension so you can simply change it. To get rid of that problem completely just open "MyProject.vcproj" with a text editor (Notepad will do just fine) and replace all occurences of ".exe" (should be just two) with ".dll".

Place your dll in the System folder of Republic Commando, open the UnrealEditor and place your new native class in a map. It can be that it is invisible for some reason in the 3D viewport but you should be able to see it in the orthographic viewports.

Now save your map and launch it with the "-log" command-line parameter and the following should show up in the log window (and in the log file too obviously...):