Unreal Engine How To’s

UE4 – Blueprints – Set Parent Class

Posted on March 22, 2020March 22, 2020 by Oded Maoz Erell

Software:
Unreal Engine 4.24

When It comes to OOP inheritance, the best practice is to take a moment to think about code structure and decide which classes should be be extensions of a common super-class. But in a wild hackathon or game-jam, we may be blueprinting too hastily for that, and we may find out different blueprint classes actually have to be child classes of a common parent class after they already exist and have existing blueprints in them.
In this case will have to Set their parent class as a different class than the class we chose when we initially created them, and also create calls to the parent class event functions if needed.

Setting a BP’s parent class:

Click Class Settings, and under Class Options, in the Parent Class drop-down select the wanted parent class (superclass).

Calling the Parent Class’s event functions:

Note:
When creating a BP class that is defined as child class in its creation this is done automatically

Right-Click the current class’s Event icon, and select Add call to parent function:
Connect the execution flow graph, and other inputs if necessary:

UE4 – First Person Projectile Overlap Event

Posted on March 14, 2020 by Oded Maoz Erell

Software:
Unreal Engine 4.24

Had some frustrating time not understanding why doesn’t the FirstPersonProjectile Actor doesn’t “play ball” and generate Overlap Events when hitting my bad guys..
It turns out I had to change its collision (sphere) component’s collision settings to overlap dynamic objects (see image):

UE4 – Basic Material Blending

Posted on December 26, 2019January 7, 2020 by Oded Maoz Erell

Software:
Unreal Engine 4.24

The example explained in this article is creating a blend between a mud material, and a mud-leaves material using a mask (Alpha) texture.
>> The scanned PBR materials in demonstrated in this post are from Texture Haven (texturehaven.com)

How does it work?
There is actually no blending of Unreal materials, but rather a regular Unreal material in which each of the parameters is defined as a linear blend between 2 different source values for that parameter.
We could create such a material blueprint that uses a Lerp (Linear Interpolate) node’s to provide each of the material parameters with a blend of 2 input textures/colors or parameters, connecting the alpha texture to all the Lerp nodes’s Alpha input, and effectively achieve blending of 2 different materials, but it would be a complex blueprint in which it’s very inconvenient to design each of the individual materials participating in the blend:

This complexity can be greatly simplified by collecting each of the participating materials parameters into a Material Attributes data structure.
The Material Attributes data structure contains all the data needed to compile a material, and allows input, output, and processing of this data as a single blueprint data stream (connection).
For example, when the material parameters are grouped as a Material Attributes data structure, they can be blended by connecting them into a single BlendMaterialAttributes node, instead of “Lerping” (blending) between 2 inputs to create each individual material parameter, which produces an unworkable complex material blueprint like the previous example.

> To collect material parameters into a Material Attributes data structure, connect them into a MakeMaterialAttributes node:

> To create a blend between 2 Material Attributes data streams, use the BlendMaterialAttributes node:
* The Alpha parameter determines the weights of the blend (a black and white texture can be connected to it as the blend mask)

> In order for the material output to receive a grouped Material attributes input instead of individual inputs for each parameter, select the material output, and in the Details panel, check the Use Material Attributes option:

Using the Material Attributes data structure, the blended material’s Blueprint in now much simpler and cleaner, while producing the exact same result as before:

But designing 2 different materials within one material Blueprint is still far from being ideal..
What if we want to use just one of these materials on some surfaces?
What if the individual materials are not as simple as the materials shown here, it would be mush more efficient to be able to have one Blueprint for each of the materials allowing to focus on its development and preview it.
We can achieve this desired workflow by developing each of the materials as a Material Function.
Each of the participating materials is created as a Material Function with a Material Attributes output.

> One of the huge advantages of UE4’s material editing is that it allows us to preview a full material while developing it as a Material Function.
* This may sound trivial, but it isn’t. the Material Function isn’t compiled by itself as a material, it just produces data needed to define a material. in many other media production systems, this would have meant that you can develop data within the function but only preview it in the main material where the function is used.

> Learn how to create Material Functions

The Material Function defining the mud material:

The Material Function defining the mud-leaves material:
Annotation 2019-12-26 024906.jpg

The Blend material using the Material Function nodes:

Note:
When blending a non-metallic material with a metal material, the alpha values (mask colors) should be only 0 or 1 (black or white), otherwise blend areas that have a mid-range metallic value will make no sense visually.
> A RemapValueRange node can be used to force a color threshold on the mask texture or value.

UE4 – Create and Play a Level Sequence

Posted on December 23, 2019December 23, 2019 by Oded Maoz Erell

Software:
Unreal Engine 4.24

To create animations and trigger them to play on game start:

First create a Level Sequence containing the animation:

Create a new Level Sequence actor:
Name the new Level Sequence and drag it to into the level:
Select the actor you want to animate in the level and double click the Level Sequence in the Content Browser to open it in the Sequencer window:
In the Sequencer window, press the +Track button to add a sequence track, choose the upper most option Actor To Sequence, the option to Add the selected actor will automatically appear first on the menu that will open on the right:
Add the selected actor as a sequence track, expand the track’s Transform channels to reveal the Transform property you would like to animate, and click the + button for that channel to create the first key-frame:
Activate the Create when channels/properties change option button:
Move the time slider to a desired time for the motion and move/change the actors transform to create a new key-frame:

The Level Sequence now contains animation for the Actor, but when we play the game, the animation doesn’t play.
For the animation to play in game, we must trigger it fro a Blueprint, in this case the Level Blueprint:

From the Editor Blueprints menu, choose Open Level Blueprint:
In the Level Blueprint, drag the Event BeginPlay execution graph and create CreateLevelSequencePlayer node that will follow it:
Drag the CreateLevelSequencePlayer node’s Return Value output and create a Play node that will be executed after it and receive it’s output:
The Level Blueprint now has instructions to play a Level Sequence,
but it’s not yet specified which Level Sequence to play:
In the Variables list on the left, press the +Variable button to create a new variable and name it:
With the new variable selected, in it’s details on the right, press the Variable Type button, and locate Level Sequence – Object Reference type:
The Level Blueprint now contains a variable named seq of type: Level Sequence – Object Reference:
Drag the new variable to the Blueprint and choose Get when placing it:
Connect the variable’s output to the Level Sequence input of the CreateLevelSequencePlayer node:
With the variable selected, in the details panel on the right, select the Level Sequence object it will be referencing:
Press Compile and save the Level Blueprint:

The Level Blueprint now has instructions to play the desired Level Sequence when the level begins playing so a the animation we created plays when we hit play game in the editor:

Related:
UE4 Camera Animation

UE4 – Package a Project for Windows

Posted on June 13, 2019July 15, 2020 by Oded Maoz Erell

Software:
Unreal Engine 4.25

Basic steps for packaging a simple UE4 project for Windows:

Package settings:
Open the Project Settings window:

In: Project > Description
Set the project’s details and thumbnail:
> The Project thumbnail will apear in the UE4 Editor browser.
> Thumbnail image must be a 192 x 192 resolution PNG
In: Project > Maps & Modes
Set default level (Map) for the project:
In: Project > Packaging
Choose build configuration
> For final distribution choose ‘Shipping‘:
In: Project > Supported Platforms:
Make sure Windows is selected:

Setting user input focus:
* So the user doesn’t have to mouse click the screen before being able to control the game.
Select the FirstPersonCharacter Actor and enter editing mode.
In the Event Graph Blueprint, locate the Event BeginPlay node, add a Set Input Game Only node, after it, and connect a Get Player Controller node set to index 0, to it’s Player Controller input:
Annotation 2020-07-14 175909
Note that if there are UI user interactions, in the game, you may need to switch to different input modes during the game to allow interaction with UI.

Adding a Quit command:
Select the FirstPersonCharacter Actor and enter editing mode.
In the Event Graph Blueprint, add an Escape key press Event node,
And connect it to a Quit Game command node.

Creating the game package:
Choose:
File > Package Project > Windows > Windows (64-bit)
And select an output folder.

A folder named “WindowsNoEditor” will be created,
And inside it will be the game executable along with code and assets folders.
This package can be renamed and copied to other locations.

Possible causes for packaging failure:
There are many reasons packaging a UE project can fail,
I certainly don’t know all of them, but I’ll list some cases I actually encountered:

If the project folder is located within a deep folder structure, packaging errors may occur because of long file paths.
* Sorry I didn’t save the actual error message..
Installing a plugin twice by mistake will cause the following error:
Error: System.ArgumentException: An item with the same key has already been added.
* I mistakenly installed the Houdini engine plugin both in the Plugins\Runtime folder and in the Plugins folder (this specific plugin should be only in Plugins\Runtime).

Related posts:

UE4 – Enable complex collision for models

Posted on May 31, 2019May 31, 2019 by Oded Maoz Erell

Software:
Unreal Engine 4.21

By default UE4 uses fast simplified convex collision shapes to calculate collision for static mesh actors.
This means that the player or projectiles wont be able to path through holes, openings or doors in the model.

To set complex (concave) collision for a static mesh model:

In Static Mesh editing window, in the details pane, under Collision:
Set Collision Complexity to: Use Complex Collision As Simple

This example shows the default behavior for a model that has an opening, neither the projectiles nor the player can pass:

In this example collision for the model was set to Use Complex Collision As Simple:

UE4 – Python Scripting – how to start

Posted on April 9, 2019December 8, 2019 by Oded Maoz Erell

Software:
Unreal Engine 4.20

Go to:
Edit > Plugins > Scripting
And enable the Python Editor Script Plugin.
* also recommended to enable Editor Scripting Utilities,
And Sequencer Scripting plugins
Restart the UE4 Editor.
Open:
Window > Developer Tools > Output Log
Switch the command-line mode from Cmd to Python, write Python commands and press Enter to execute them:
Or in Cmd mode, write ‘py‘ with a path to a Python script file, and hit Enter to execute the script:

Links:

Scripting the Editor using Python:
https://docs.unrealengine.com/en-us/Editor/ScriptingAndAutomation/Python
UE4 Python API reference:
https://api.unrealengine.com/INT/PythonAPI/

Examples:

UE4 – Bump Map

Posted on December 7, 2018November 2, 2020 by Oded Maoz Erell

Software:
Unreal Engine 4.21

To use a ‘Bump Texture’ in UE4, or in more geeky terms, derive Normal data from a supplied height map, use the NormalFromHeightMap Node.

Notes:

The height map textured is supplied via Texture Object node and not Texture Sample, and is connected to the NormalFromHeightMap‘s Height Map input.
A numeric vale is connected to the NormalFromHeightMap‘s Normal Map Intensity input to control the intensity of the resulting Normals/Bump.
UV coordinates for the bump map should be connected to the Coordinates input of the NormalFromHeightMap node.

UE4 – Animated texture using a Flip-Book node

Posted on March 8, 2018March 10, 2018 by Oded Maoz Erell

Software:
Unreal Engine 4.18

A ‘Flip Book’ node in UE4 is the way to create an animated texture using a Sprite-Sheet.
Its very simple to use:

Import a Sprite Sheet texture containing the animation frames.
In the UE4 Material, Create a Texture Object node, and set it’s Texture property to be the Sprite Sheet texture you imported.
Create a Flip Book node and connect the Texture Object Node to its Texture input.
Connect numeric value constants to the Flip Book node’s Number of Rows and Number of Columns inputs to set the layout of the Sprite Sheet.
Connect the outputs of the Flip Book node to the wanted material inputs.

The following example shows a way to create a custom Flip Book material to animate textures.
Q: Why would you do that???
A: Well the truth is I created it without knowing there is a built-in option, and found out about the Flip Book node right after I finished my own.. 😀
But it’s also a useful example of locating tile coordinates within a plane..

UE4 – Enable input for a Blueprint

Posted on February 22, 2018February 22, 2018 by Oded Maoz Erell

Software:
Unreal Engine 4.18

By default, Blueprint Actors are set not to receive player input.
* If every Blueprint would be listening to player input events it would hurt game performance.

To enable input events for a Blueprint:
In the Blueprint’s Event Graph,
Connect an Enable Input node to the BeginPlay Event,
Create a Get Player Controller node and connect it to the Player Controller parameter of the Enable Input node to set which player input events to listen to.