Some notes on defining classes with mutual references to instances of each other:
The classes can’t hold the actual other class’s instance data, because that could potentially cause an infinite expansion memory allocation, so by definition, the classes should be defined to contain pointers to the instance of the other class.
The classes C++ header files can’t be including each other (it will cause a compile error), because, this is literally telling the compiler to endlessly read the files, each one including the other. So only one class header can have an “include” statement pointing to the other.
In order to successfully compile the class header file which doesn’t contain an “include” statement for the other class, a forward declaration of the other class is needed. I.E. a ‘ghost’ declaration of the class at the beginning of the file, just so the compiler ‘knows’ there is such an entity, and doesn’t throw an error.
Class A code:
Class B code:
Hope this was helpful! If you find mistakes or inaccuracies in this post I’ll be very grateful of you share them with me in the comments.
To import an external Python module, Add its folder path to the sys.path list, Then import the wanted code.
In this example, there is a Python file: C:\Oded\GoogleDrive\CGL_Studio\CGL_Python\py\cgl_pixel_utils.py Containing a function: cgl_fill_int_range
The following Python code checks the path isn’t already found in sys.path, and if so adds the module path to sys.path, Imports the cgl_fill_int_range function for the cgl_pixel_utils module, And calls the cgl_fill_int_range function:
modulepath = r"C:\Oded\GoogleDrive\CGL_Studio\CGL_Python\py"
if modulepath not in sys.path:
from cgl_pixel_utils import cgl_fill_int_range
To force reloading of an external module, Use the reload function from the built-in imp module. Note that this works with importing full modules and not just specific functions:
modulepath = r"C:\Oded\GoogleDrive\CGL_Studio\CGL_Python\py"
if modulepath not in sys.path:
# Force reload of cgl_pixel_utils:
Software: Unreal Engine 4.25 *Also tested on Unreal Engine 5.0.1
Disclaimer: I’m probably the 10th guy that’s documenting these steps on the web, I didn’t come up with this solution myself, I learned it from the sources listed below. The reason I’m documenting this (again) myself is to have a clear source I can come back to for this issue because I’m absolutely incapable of remembering subjects like this…… :-\ If you find inaccuracies in the steps I’m detailing or my explanation, I’ll be very grateful if you share a comment.
In short: AFAIK since version 4.21 UE doesn’t load custom node shader code from your project/Shaders folder by default anymore, but only from the shaders folder in the engine installation, which makes it less practical for developing shaders for specific projects.
Steps for setting the UE project to load shaders from the project folder in UE 4.22:
> The examples here are for a project named: “Tech_Lab”
A. The project must be a C++ project:
So either create a new project, define as such or just create a new C++ class and compile the project with it to convert it to a C++ project. Notes: a. You may need to right click the .uproject file icon and and Generate Visual Studio Project Files for the project to load correctly into Visual Studio and compile. b. You can delete the unneeded C++ class you added after the new settings took place.
B. Create a folder for the shader files:
Typically, it will be called “Shaders” and will be placed in the project root folder.
C. Add the RenderCore module to the project:
This is done by adding string “RenderCore” to array of public dependency modules in the <project>.build.cs file:
Notes: a. In UE 4.21 it should be ShaderCore. b. This addition is needed in-order to compile a new primary project module (next step).
D. Define a custom primary module for your project:
In <project_name>.h file add a new module named F<project_name>Module, with a StartupModule function overrides. Notes: a. We have add an include statement for “Modules/ModuleManager”. b. The <project_name>.h file is located in the /Source/<project_name> folder. c. Some sources state that you also have to override the ShutdownModule function, with an empty override, it works for me without this (maybe its just a mistake..)
E. Implement the function override, and set the custom module as the project primary module:
In <project_name>.cpp file, add the StartupModule override, With the definition of the added shaders path: FString ShaderDirectory = FPaths::Combine(FPaths::ProjectDir(), TEXT("Shaders"));
and mapping this new path as “/Project” for conveniently including it: AddShaderSourceDirectoryMapping("/Project", ShaderDirectory);
Last thing to do is to replace “FDefaultGameModuleImpl” with our custom module name in the IMPLEMENT_PRIMARY_GAME_MODULE macro: IMPLEMENT_PRIMARY_GAME_MODULE(FTech_LabModule, Tech_Lab, "Tech_Lab" );
Notes: a. We must include “Misc/Paths” b. Note that the addition of this folder mapping is restricted to versions 4.22 and higher via a compiler directive condition. for version 4.21, you should state “ENGINE_MINOR_VERSION >= 21: Note for UE5: Unreal Engine 5 supports this from the get go so this compiler directive condition should be deleted for this to work.
F. Wrapping up:
After taking these steps and compiling the project. You should be able to include .ush and .usf files stored in <your_ue_project>/Shaders with the “Project” path mapping: include "/Project/test.usf"
That’s it! 🙂
I hope you found this helpful, And if you encountered errors, or inaccuracies, I’ll be grateful if you’ll take the time to comment.
Steps for creating a new Visual Studio project based on existing code files:
Create an empty project folder and name it your intended project name.
Inside the new project folder, create a folder for your source code files. * I call is “Source”, not sure if it has to named that way..
Copy your existing code files to the source folder.
Launch Visual Studio, and open it without code:
Select: File > New > Project From Existing Code.. To open the Create New Project From Existing Code Files wizard:
Note: The documentation on this operation states that the wizard will copy files by itself, my own experience is that it doesn’t, it just links them to the project, that’s why I copy the source files prior to this step. In the Create New Project From Existing Code Files wizard, 1. Set the path to your project folder. 2. Specify a project name. * I set this to be the same name as the project folder name, not sure if otherwise it will create a sub-folder.. 3. This is set to the same folder as the project folder. * It’s possible that I don’t understand this correctly.. but I think theoretically, the intention is that you would add external folders to this list, from which source files would be copied, but like I said, when I tried that the files where not copied to the project.
Set your new projects settings and press Finish to create the new project:
If your writing code in languages that are based on a common language but their files names have an uncommon extension, for example, the 3D shading languages OSL, and HLSL, which are written in C syntax but have .osl and .hlsl, or .fx as file name extensions, Notepad++ wont automatically recognize that the code in these files is actually C language and present their syntax properly.
To set Notepad++ to recognize specific file associations with a wanted language:
Goto: Settings > Style Configurator:
In the Style Configurator window:
Select the wanted language in the language list on the left,
And in the User ext. field, type a list of file extensions separated by spaces:
These file extensions will be interpreted as the selected language.
If your writing code in languages that are based on a common language but their files names have an uncommon extension, for example, the 3D shading languages OSL, and HLSL, which are written in C syntax but have .osl and .hlsl, or .fx as file name extensions, GitHub wont automatically recognize that the code in these files is actually C language and present their syntax properly.
It’s very easy to fix this by adding a simple setting to your .gitattributes file, that tells GitHub’s linguist system to associate a specific file extension with the wanted language like this example:
# consider OSL as C language
* .osl linguist-language=C
About 1 or 2 weeks ago GitHub Desktop stopped opening it’s window when lunched.
It would run in the background, you could see it in the Windows Task Manager, but its window would not open.
Looking into this on various web discussions, I found that deleting the folder named app-2.4.3 in its application data solves the problem:
This is the path to GitHub Desktop‘s data:
After deleting the folder and re-launching GitHub Desktop, I found it generated a new folder with the same name, so I guess settings for the latest update got corrupted, and the software generated new settings..
Software: Unreal Engine 4.24 | Git for Windows | Git LFS | GitHub Desktop
What is this all about?
A game development project is in fact a software development project, and therefore requires Source Control (aka “Version Control”).
A Source Control solution is a software system that registers and stores states of the code as it develops, and allows the developers to manage the changes, compare different versions of the project, revert to previous versions and much more.
There are more than one popular Source Control solutions in the market.
This article is written specifically about setting-up Source Control for an Unreal Engine 4 project using Git Source Control software, focusing on working with the GitHubdesktop client app for Windows.
Although I’ve already had some experience using Git Source Control,
This is the first time I’ve had to set it up for myself by myself from scratch specifically for UE4 (using Git LFS), So this article can’t be regarded as an authoritative guide to the subject.
This is simply an informative record of the steps taken, problems encountered, notes, etc.
Hopefully, this post will be helpful, and if you find mistakes, inaccuracies, or that I forgot some steps, I’ll be grateful if you’ll post a comment.
Create a GitHub account: github.com Note:
The installations of the Git client tools in the next steps will require your GitHub login credentials (I don’t remember exactly which and when, because I didn’t document every step being busy getting things to work…)
Install Git for Windows: gitforwindows.org Note:
With the installation of Git for windows we not only get the Git Client software, responsible for performing all the Source Control operations, but also Git Bash which is (in my opinion) a very convenient command-line console specialized for Git operations.
Install Git LFS: git-lfs.github.com Note:
The Git LFS client is responsible for compressing and uploading the large binary files, which is to simply say, the files that are not ascii text format like software source code files / scripts / meta-data / settings etc., but typically media files like 3D models, graphic files, audio and the like.
We generally don’t have to do anything directly with the Git LFS client, The Git Client automatically runs it, and it operates according settings written in text files placed at the Git repository root folder (more detail on this below).
Optional: Install GitHub Desktop: desktop.github.com Note:
This is an optional desktop Git client with a GUI for performing git operations.
You can do everything without it, but its convenient, and was specifically helpful for me with setting up a UE4 repository, because it provides preset Git LFS settings (more on that below).
Steps for setting up a UE4 project GitHub repository:
I’m using GitHub Desktop to initialize the repository with UE4 Git LFS settings and also
Create an Unreal Engine 4 project (if you haven’t already created one..) Note:
If you want the 3D assets, texture files, etc. to be tracked and version controlled as an integral part of the UE4 project, add a “Raw_Content” or “Raw_Assets” folder inside the UE4 project folder to store them in their editable formats prior to being imported to the Unreal project.
Uploading such large binary files to git requires using Git LFS as described below.
Important: Backup a full copy of the UE4 project somewhere safe at least for the first steps. Note:
I Actually needed to use this backup to save my own project (see below)
In GitHub Desktop, choose File > New repository to open the Create a new repository dialog.
A. In the Name field Type the exact name of the UE4 project (The name of it’s root folder). B. Write a short description of your project in the Description field. C. Set the Local path to the folder containing the your project folder, not the project folder itself. D. In the Git ignore drop-down select the UnrealEngine Option. E. Press the Create repository button. Note:
Stage D is very important, it creates an initial .gitignore file with specific settings for a UE4 project, namely what files and folders to track and upload. a UE4 project generates massive files that are needed to run the game but are redundant, because they can always be generated again. these files shouldn’t be tracked or uploaded, and without proper settings in the .gitignore file, you wont be able to push (upload) the repository to the remote server.
This is one of GitHub Desktop’s advantages, that it offers these Git Ignore presets. Another Note:
We could “Publish” the repository to to GitHub server at this stage (see explanation below).
But the reason I don’t recommend performing this action at this stage is that for a UE4 project to be successfully uploaded (“pushed”) to the remote server, we must have proper Git LFS settings, which we haven’t finished to set up prior to that. Blender Note:
If you work with Blender and it’s setup to save the *.blend1 backup files, it’s recommended to add this type of file to the Git Ignore file like this:
Setting up Git LFS for the new repository:
Note: Git LFS (Large File Storage) is necessary for tracking and uploading large binary files like 3D models, texture files, audio, etc.
Depending on the size of your project, you may need to upgrade the LFS storage capacity of your GitHub account.
Open Git Bash for the new repository by right clicking its root folder background and choosing Git Bash Here:
In the Git Bash console, write the command: git lfs install
This command sets-up Git LFS for the repository:
For every type of binary file that you want to be tracked and uploaded by Git LFS,
Type the command: git lfs track *.<file type extension>
To add this file type to the list of files tracked by Git LFS:
* This list is stored in the text file named “.gitattributes” that was automatically created in the project folder when the repository was initiated. Note:
You can at any time type the command:
git lfs track
to display a list of the file types being tracked.
You can open the .gitattributes file and see the list.
This is an example of the LFS track list for one of my UE4 projects:
Publishing the new repository to the GitHub server:
This step includes initiating the remote repository on the GitHub server, setting it as the local repository’s origin, verifying it and pushing (uploading) the current state of the local repository to the remote one. GitHub desktop let’s us perform all these actions at ones with it’s Publish repository button.
If you wish to know how to perform these operations without using GitHub desktop, this article gives detailed explanations.
Steps for publishing the new repository with GitHub desktop:
Commit the recent changes (Git LFS settings we just set):
In Github desktop (assuming the repository we just initiated is selected in the Current repository drop-down), in the Changes pane, observe the list of latest changes to the repository. it should include the changed .gitattributes file, and maybe more changes.
In the Description field, type a short description of the changes like “Updated Git LFS settings” for example, and press the Commit to master button to commit the updated state of the repository to the source control history.
Publish the repository:
The next actions will both initiate a remote repository on the GitHub server, set it up as the origin of the local repository, and push (upload) the the local repository to the server.
In GitHub desktop, make sure the new repository is selected in the Current repository drop-down and press the Publish repository button to open the Publish repository dialog.
In the Publish repository dialog, name the remote repository (AFAIK it doesn’t have to be the exact name as your local repository’s root folder’s name, but it’s convenient if it is..), Type a description for the project, check weather it should be public or private and press the Publish repository button.
The repository’s remote origin will now be initiated, and the local repository’s state and commit history will be pushed (uploaded) to the server to update the origin.
* Depending on the size of your local repository, this may take some time…
Once the process of publishing the new repository has finished, we can browse the new remote repository on GitHub:
Regularly committing and pushing updated state of the project/repository:
You might want to commit an updated state of your project to source control at the end of a day’s work to back it up, or when some specific development goal has been reached, or prior to some significant change, or maybe in-order for other team members/users to be able to get the latest version of the project. there could be many reasons for committing the current state of the project to Git, but the most important reason is that you want to be able to restore the current state of the project In the future.
Steps for committing the updated state of the repository to Git and pushing it to the remote server:
Commit the changes to Git:
In Github desktop select the repository of your project in the Current repository drop-down, observe the list of latest changes to the repository in the Changes pane, where you can highlight a changed file and see on the right the actual change in code it represents. un-check changes you don’t want to commit.
In the Description field, type a short description of update, and press the Commit to master button to commit the updated state of the repository to the source control history.
After the latest changes have been committed, you’l see the new committed state appear in the History pane, with an upwards arrow icon indicating it hasn’t been pushed to the server yet.
Highlight the top committed state and press the Push origin button to update the remote repository on the GitHub server. Note:
When the repository wasn’t yet initiated on the remote server,
The same button that now has the title Push origin had the title Publish repository.
While committing changes to source control for version management and backup is the basic usage of Git, there are many more source control operations that can be performed, like reverting to past commits (states) of the repository, opening new branches for to manage different version of the project, merging branches etc. to name just a few examples. these operations are beyond the scope of this article, and I strongly recommend to get to know them and more.
Unreal Editor Git Plugin:
There is a free, open source Git client plugin for the Unreal Editor developed by Sébastien Rombauts, that ships (at beta stage) included with UE4 4.24, and has many useful features integrated into the Unreal Editor like initiating the project repository with Git LFS setting, committing project states directly from the within the Editor, comparing versions of blueprints and more.
I did some tests with the plugin and found it very convenient, however It doesn’t track changes to the projects C++ code so if your coding you’ll have to commit code changes using a different Git client.
It may be that I just didn’t understand how use the plugin or set it up to track C++ code. I didn’t to find out if it officially doesn’t support this. however, if you work heavily with Blueprints It should be very useful.
Some issues I encountered:
I don’t know if these issues happen frequently, the reason may very well be me not doing things correctly.
There may be simple solutions to these issues that I don’t know about..
What’s absolutely certain is:
When you’s about to start your first steps with source control on a real project, make sure you back it up first!
Corrupted .uproject file:
After the first time I managed to get all the LFS setting right and successfuly push publish the project, strangely, it wouldn’t launch in the UE Editor, displaying the following message when I tried to double click the project .uproject file:
And displaying the following message when I tried to launch it through the Epic launcher:
After some inquiry I found out (to my astonishment) that some how the git operations have replaced the text contents of the .uproject file from this:
Luckily for me I had a full backup of the whole project before starting the setup trial and error process, so I could manually restore the .uproject file to it’s correct state and go on working.
Corruption during download from GitHub:
After a couple of successful commit and push operations with my project, I decided to test how a git repository works as backup, so I tried to download the project folder compressed to a zip file.
The extracted project would launch and compile, but fail to load the main (and only) level it had, displaying this message:
Looking into this, I found that the level umap file is was actually in it’s place but drastically reduced in size:
* The left is the original
The good news:
I then tried to clone the project via git clone command, and that way it did work as expected.
I hope you’ll find this article useful or even time/error saving.
If you find anything unclear, inaccurate or missing, I’ll be grateful if you leave a comment.