What is a Function?

Blueprint Functions are self-contained pieces of logic that you can create once and run from multiple places in your Blueprints. They allow input and output parameters for flexibility.

For example, instead of writing the same logic to calculate damage multiple times, you can create a function called CalculateDamage, call it wherever needed, and update it in one place if changes are required.

Note that a function is created for a specific blueprint actor and can only be used

In this guide we are going to start right from the beginning and create a simple function to help you understand this concept. We then expand upon this and show you more features that functions can have!

Creating a Function

To start, we are going to make a simple function that prints a string to the screen.

Firstly we need to open the blueprint actor that we want to add the function to. In this example we are using the FirstPersonCharacter blueprint from the First Person Shooter template provided by Unreal Engine.

As you can see in the image below, on the left side of the editor window, there is a drop down section named “Functions”. This section is where all of our functions live for this specific blueprint.

We can create a new function by clicking the circle with a plus symbol on the right side of the functions drop down as shown in the image below.

Next, we can then give our function a name. It is advised to give our functions readable and clear names to keep our project clean.

Messy names that are confusing make developing a large project difficult so it is best to keep this in mind.

Once the function is named either press enter, or click anywhere in the blueprint window, then click the “Compile” button as indicated in the image. This then creates our function and compiles it into the blueprint so we can start using it in our project.

Adding Basic Functionality

Now that we have our new function created and compiled, we can see it doesn’t do anything at the moment. We need to add some simple functionality!

In this first example we are printing a string to the screen. To achieve this we need to add that node to our function.

First, click and drag from the white sidewards triangle on our “My Custom Function” node. This is called an exec pin and allows us to add pieces of code together to run one after another (sequentially).

Once we click and drag then let go of the click, anywhere on the grey background grid, we then are greeted with a popup menu showing all of the blueprint nodes (these are functions!) we can add to our own function.

Click “Print String” in the menu, this creates the “Print String” node in our function graph.

As we dragged from the white exec pin, our Print String node is automatically connected to our MyCustomFunction as shown in the image below.

When our “My Custom Function” runs, it will now run the Print String node that is connected to it!

You may also see people talking about “call”, “called”, or “calling” functions. This is the same as running a function!

Testing our Print String

Now that our function is setup to print a string to the output log we need to run our function. The easiest way is to run our function on Begin Play!

Begin play is an “Event”. An event is similar to a function but cannot return values and can run a few special asynchronous nodes that functions cannot.

Begin Play is an event that is called when the actor is spawned into the game world. As our FirstPersonCharacter already is in the game world, this Begin Play event runs code when the game starts.

We first want to click the Event Graph button at the top of the blueprint editor.

Now our main blueprint event graph will appear again on the screen.

Find somewhere free and right click. In the box that appears search for Event Begin Play and click it to create the event.

Unreal Engine will automatically run the Begin Play event as described in the previous section so no setup is required.

Like before, drag from the white exec pin and let go of the mouse click in the grid. In the pop up menu, search for our MyCustomFunction and click it in the list.

Now our MyCustomFunction is connected to our BeginPlay event. The last step is to press the Compile button and save our blueprint.

Clicking play now in our FirstPersonMap will print “hello” in our output log.

Adding more functionality

Now we have text printing on the screen! That’s great for testing but not very useful for gameplay. Lets add some more functionality to our blueprint function.

In this next example we are going to make the CalculateDamage function we talked about earlier!

This function will take in a number called “damage“, seeing how much “armor” our character has, then finally subtract the amount of “armor” from our “damage” number. In short we are calculating how much damage is dealt after our “armor” has absorbed some of the damage.

Notes on advanced functionality

Delay nodes are not supported in functions. If your blueprint needs delay nodes, consider using Custom Events. Click here to read our guide on How to use Custom Events in Unreal Engine.

Making the CalculateDamage function

To achieve this goal of our CalculateDamage function, first we need to input data into our function.

Firstly, click the purple “My Custom Event” node. You should now see in the details window on the right side of the editor sections for Input and Output.

As we are focussing on Input, click the small add button to add a new Input Variable.

We now see a new input parameter for our function.

In this example we want to pass in a number so we change the “Boolean” to “Float”.

Next in the left text box give our new property a name. We are naming this “Damage”.

So far the function should look like this.

Now we are adding some other nodes to calculate our damage value.

To do this first, drag from the green Damage pin into the grid and let go of the mouse click. In the popup search “-” or “subtract” to find the subtract node.

Next we click and drag from the bottom subtract node pin and let go, in the menu we then click “Promote to variable”. This will create a new variable that we name “Armor” to store our character’s armour number.

Next, click the new armor variable in the graph and on the right side details panel and set the armor value to any number you want. In this example we set armor to 15.

Our MyCustomFunction now takes in the Damage value and subtracts Armor from itself, this is then printed into the output log.

Returning our value

Our function now calculates values but does not send those values anywhere! We need to “return” this value out of our new function.

Returning a value is the word used to describe the output of our function. In Unreal Engine Blueprints we can have as many input and output values as we like.

First click our MyCustomFunction and look to the details panel on the right side of the editor again.

This time we are clicking the plus button on the Output section.

In the newly created Output result, change the type to Float and set the name to Result.

After creating the new output parameter a “Return Node” will be created automatically in the graph.

This Return Node result pin is where we can “return” our values out of the function.

We then delete the print string from the function as we no longer need it inside the function.

Our final function now looks like this.

In the event graph our function now looks like this. We can give it a “damage” value and get a “result” value out from the function!

To test this is working we set damage to 20.0 and connect our returned result value to a print string node.

Demonstration

Finally, with our damage set to 20 and our armor set to 15, when we call our MyCustomFunction we get the value 5!

20 – 15 = 5

In the output you can see that our returned value of 5 is printed to the log!

Conclusion

You’ve now taken the first steps in getting started with Blueprint Functions in Unreal Engine 5! These essential aspects of programming allow you to separate logic into reusable nodes, cleaning up your blueprint actors and making your dream game easier to manage.

The basic concept and example covered in this guide provides a foundation to build upon. Whether you’re building gameplay mechanics, working on core technology, or cleaning up your existing code, Blueprint Functions are a fundamental aspect of Unreal Engine development.

Further Reading:

• Click here to read the official blueprint function unreal engine documentation
• Click here to watch Mathew Wadstein’s in depth blueprint function guide on YouTube (Not affiliated or associated with CouchLearn)

The post Getting started with Blueprint Functions in Unreal Engine 5 appeared first on Couch Learn.

Prerequisites

To follow this guide you need to understand the basics of Unreal Engine, working with blueprints inside the editor and using a custom Game Instance. We have linked guides below to these topics.
The basics of blueprint actors.
Adding variables to blueprint actors.
How to use custom Game Instances.
Custom Events in Unreal Engine.

It would also be beneficial to understand how Input Actions work in Unreal Engine:
Click here to learn how to use input actions and axis.

How it Works

SaveGame is a class in Unreal Engine that is preconfigured to save and load the data contained in the variables you add.

The variables you set are then saved to a file stored on the user’s machine. This is then read and the variables can be accessed in your game.

The save file is located in these locations:
Windows: Local Appdata folder
MacOS: Library/Application Support
Linux: /home/username/.local/share

Almost every variable type can be saved and loaded using the SaveGame class.

Creating our Save Class

Firstly, create a new blueprint class from the content drawer.

Next, in the popup window, click the drop down arrow at the bottom. In the search bar type “SaveGame” and click the option from the list.

Then, give your new SaveGame blueprint a suitable name. We need to remember this as it is used later. In our case, we used the name DemoSaveGame.

Saving the variables

Now that your SaveGame class has been created, you can add any variables you need for your project.

For this demo we create a new Vector variable called “PlayerPosition”.

Once you have created the variables you need for your project, click Compile and Save to ensure your changes are applied and saved.

Adding Save and Load Functionality

Firstly, in our Game Instance, add two new custom events. “Save” and “Load”.

We also need to add a new variable on the Game Instance. Name this variable SaveGame and set the type to the class you created in the previous step.

Loading our Variables from the Save File

Now that our Game Instance is setup, on the Load event, create a new “Does Save Game Exist” node. The “Slot Name” pin needs to be given a name. This can be set to anything you want. Each different name you use saves to a different file.

In our case we just named this “savegame”.

Next, add a branch to the output pin of the “Does Save Game Exist” node. This will branch if our save file exists or not.

If the Save File Exists

From the “True” pin, create a new “Load Game From Slot” node with the same “Slot Name” as before.

Next, from the blue output pin, create a “Cast to” node. This should cast to the class you created in the first step. For us this is “Cast to DemoSaveGame”.

Then set the Game Instance’s Save Game variable we created earlier to the output of the “Cast to” node.

From there, we create a “Set Actor Location” node. This will be used to move our character to the saved location.

From the variables list on the left of the editor, drag the “SaveGame” variable and drop near the the nodes. This will show a list of options. Click the “Get SaveGame” option to allow us easy access to this variable for the next few steps.

Dragging from the “Save Game” blue pin then typing “get player position”, we can see our “Player Position” Vector variable that we created earlier. Click this option in the list to add it to the blueprint graph.

Next, connect the “Player Position” vector pin to the “New Location” option on the “Set Actor Location” node.

Lastly, create a “Get Player Character” node and connect this to the “Target” pin of the “Set Actor Location” node. This now gets our saved player position and moves the player character to it.

If the Save File doesn’t Exist

If the save file does not exist then we need to create a new file. From the “False” pin create a new “Create Save Game Object” node. Then set the “Save Game Class” purple pin to the custom SaveGame class we created earlier.

Then, set the Game Instance “Save Game” variable to the blue output pin value.

Lastly, connect the “Set Save Game” node to the blueprint nodes above. This can be done by double clicking the white lines to create points.

Connect the blueprints nodes together as shown in the image below.

Saving our Variables to the Save File

Now that we can load saved variables, we need to save the variables!

Firstly, drag and drop the SaveGame variable and click “Get SaveGame” next to the Save event.

From there, we create an “? Is Valid” node. This allows us to branch the code if our save file has been loaded or not.

If the Save File is Valid

From our “Save Game” blue variable, create a “Set Player Position” node and connect it to the “Is Valid” pin.

Next, create a “Get Player Character” node and from the blue output pin, create a “Get Actor Location” pin.

Lastly, connect the yellow output pin of the “Get Actor Location” node to the yellow input pin on the “Set Player Position” node. Now if our save game object is valid we will save the player character location to the save file on disk.

If the Save File is not Valid

If the save game object isn’t valid, we need to create it before saving any data.

Firstly, create a “Create Save Game Object” node, set the purple input value to our previously created save game class, then connect this to the “Is Not Valid” pin as shown below.

Next, set the Game Instance SaveGame variable to the blue output pin of the “Create Save Game Object” node.

Then, connect the “Set Save Game” node to the “Set Player Position” node as shown below. This will save the player character’s position after the “Save Game” object is valid.

Finally, create either a “Save Game to Slot” or “Async Save Game to Slot” node from the blue SaveGame variable.

If your game needs to save lots of information, use the “Async Save Game to Slot” node.

If your game only saves a small amount of data, use the “Save Game to Slot” node.

Make sure to set the “Slot Name” variable to the name you used earlier. In our case this was “savegame”.

Saving and Loading the Player Position

Now that your Save and Load system is complete, we need to trigger this functionality.

In your Player Character class add an Key Press Event. For this guide we used the number 1 key from our ThirdPersonCharacterBP class.

From there, create a “Get Game Instance” node and a “Cast To” node to your custom game instance. Connect the two as shown below.

Next, from the blue “As Game Instance” pin, call the “Save” event we created earlier. Now when we press the number 1 key, our game will save the current player character’s position to the save file.

Repeat the previous step for the number 2 key as shown in the image below.

Finally, call the “Load” event from the “As Game Instance” blue pin. This will now load our saved player position from the save file and teleport our player to that position.

Demo

Download the Project Files

Conclusion

Now your project has saving and loading capabilities!

This is a very basic implementation but allows you to expand this further. Any data you want to save and load can be implemented into the events we created during this guide.

An example of this would be the player’s health. This variable could be created on the SaveGame, saved and loaded onto the character with minimal setup.

Further Reading:
Official UE4/5 documentation for the Saving and Loading in the engine.
Tom Looman’s great guide for implementing Saving and Loading for C++ classes

The post How to Save and Load in Unreal Engine 5 appeared first on Couch Learn.

Unreal Marketplace Plugins

Firstly, open the Epic Games Launcher and navigate to the Unreal Marketplace.

Next, in the “Browse” tab, click the “Code Plugins” option.

Then, choose the plugin you want to install. For this guide we are using the VaRest network plugin.

If you do not already own the plugin, click add to cart and complete the purchase.

Free plugins still need to be “purchased” but you are not charged.

As these plugins are installed to the engine, we need to click the “Install to Engine” button.

Then, choose the engine version you would like to install the plugin to.

Lastly, the plugin is now shown in the downloads tab of the Epic Games Launcher. Once the plugin has been successfully installed continue to the final step.

Enabling the Plugin

New plugins are not enabled in the project by default. This is to prevent all projects building unnecessary code and increasing your executable size. In this final step we need to enable the plugin on your project.

Firstly, to enable the plugin, click “Edit” then “Plugins”.

Once the Plugins tab has opened, type the name of the plugin in the search box to find the newly installed plugin details.

Finally, click the check box for the plugin, then click the “Restart Now” button. This will restart the editor and allow use of the plugin in C++ and Blueprints.

Manually Installed Plugins (Advanced)

Disclaimer

BE CAREFUL when downloading untrusted files and code online.

Only download Unreal Engine plugins from trusted sources.

CouchLearn is not responsible for any damage caused by downloading unknown files.

Make sure the plugin you are downloading is compatible with the version of Unreal Engine 5 that you have installed.

Installing the Plugin

To demonstrate the steps of installing a UE5 plugin manually, we will be using the Victory BP plugin by Rama.

Firstly, we need to make sure your project folder contains a “Plugins” folder.

If this folder does not exist, simply create a new folder named “Plugins”.

Then, copy your plugin’s folder into the Plugins folder shown above.

For example we copied the VictoryPlugin folder compatible with Unreal Engine 5.0 into the Plugins folder of the project.

Inside this folder is the plugin files downloaded from the Victory Plugin Unreal Engine forums page.

Enabling the Plugin

Plugins are not enabled by default. This is to prevent all projects building unnecessary code and increasing your executable size. In this final step we need to enable the plugin on your project.

Firstly, to enable the plugin, click “Edit” then “Plugins”.

Once the Plugins tab has opened, type the name of the plugin in the search box to find the newly installed plugin details.

Finally, click the check box for the plugin, then click the “Restart Now” button. This will restart the editor and allow use of the plugin in C++ and Blueprints.

Conclusion

Now your Unreal Engine 5 project has new functionality!

Plugins can infinitely extend the functionality of your project, the engine, and even the editor itself! The Unreal Engine Marketplace has hundreds of quality plugins that can give your project the features you need to realize your vision!

Further Reading:
Click here to read the official documentation for making your own plugins in Unreal Engine
Click here to see the code plugins on the Unreal Engine Marketplace

The post How to Install Plugins for Unreal Engine 5 appeared first on Couch Learn.

Before Installation

To reduce the install size of a new install of Unreal Engine, firstly click the plus button next to “Engine Versions”. This is found in the Unreal Engine / Library tab of the Epic Games Launcher.

From there select the engine version you would like to download and click the “Install” button.

In the popup box, choose the directory to install the engine to then click “Options”.

Finally scroll through the list of options and remove the ones you do not need in your install then click “Apply” and “Install”.

We recommend keeping the templates and editor symbols to aid in development and debugging.

The easiest to remove are TVOS and HoloLens2 as most users do not build for these platforms.

After Installation

It is still possible to reduce the install size even if you have already installed a version of Unreal Engine.

First find the version you would like to reduce in size then click the arrow next to “Launch”.

Next click the “Options” button in the drop down menu underneath the editor version you are editing.

Finally scroll through the list of options and remove the ones you want to remove in your current install then click “Apply”.

We recommend keeping the templates and editor symbols to aid in development and debugging.

The easiest to remove are TVOS and HoloLens2 as most users do not build for these platforms.

Conclusion

Your Unreal Engine 5 editor install size is now reduced!

Newer versions of the editor are considerably larger than older Unreal Engine 4 installs and this most likely will continue to grow as more features are added.

For the best development experience, we recommend installing Unreal Engine to a separate 512GB SSD. This improves the speed of the editor and allows you to have all the features and files installed in case you begin to develop for separate platforms or need to use the standard assets.

Click here to read the official UE5 install documentation
Click here to read the official required and recommended hardware for Unreal Engine 5

The post How to reduce Unreal Engine 5 editor install size appeared first on Couch Learn.

Prerequisites

To understand this guide and implement timers into your project, you will need to know how to use custom events and functions in Unreal Engine 5 before starting.

Click here to read our guide on custom events.

How to create Blueprint Timers

Basic Timer Settings

Before we create our timer, we will look at the basic timer settings that all timers have. These allow us to set the frequency of the timer and if the timer repeats or not.

The green Time pin is the time Unreal Engine will wait to call your event. If this value is less than or equal to 0, the timer will be cleared and will not call the event.

The Looping check box will repeat the timer if set to true and only run once if set to false. Ticking this box is best for functionality that you want to run repeatedly.

Timer by Event

When you want to create a timer that uses a custom event in the event graph, you need to use Set Timer by Event.

As shown below, your custom events can be connected using the red event delegate square. Any custom event are connected to this pin to trigger on the time set. Only one event is connected at a time.

Timer by Function

If you want to use a function instead of an event delegate, we have the Timer by Function Name blueprint node. This has function name and object pins replacing the red delegate pin.

Object is the reference to the object that you want to run the function on (e.g. FirstPersonCharacter or your own custom actors). If you want to run the function on this actor, you can leave this pin empty.

“Function Name” is the name of the function found in the function list in your object.

In this example we have created a new function in the My Blueprint panel on the left of the blueprint editor. Our new function is called MyCustomFunction.

Now our function has been created, we then add the functions name into the Function Name pin.

The blueprint node above now run MyCustomFunction after 5 seconds without looping.

Saving the Timer

If you want to change any properties about a timer, you need to save a reference to the return value. The easiest way to do this is to drag from the return value and click Promote to Variable.

Pausing and Unpausing Timers

Now we have a reference to our timer, we can pause and un-pause the timer. The nodes below show the handle and function versions of pausing and unpausing your timer.

Function timers can be paused and unpaused using the function name and do not need a timer handle.

Removing a Timer

When you need a timer to stop, use the clear and invalidate timer blueprint nodes. These nodes will stop the timer and destroy the specified handle object.

When using a Function Timer, you will need to clear and invalidate the timer separately if you want to use a function name.

Checking a Timer’s Status

With the handle or function name, you can check various properties about a timer.

Firstly we have Does Timer Exist. These nodes check if the timer exists in memory. If the timer is cleared and invalidated this value is false.

Is Timer Active will return true if the handle or function name has a timer that is actively running and exists.

“Is Timer Paused” returns true if the timer is not actively running but does exist.

Conclusion

Now you have all the knowledge to use timers in your blueprint code in Unreal Engine 5!

Having all of these nodes at your disposal allows code and functionality to run at specific times and at certain frequencies. This will overall improve the readability of your code and can bring great performance gains. We recommend setting the Time value to 0.1 or 0.05 seconds instead of running every frame on tick.

Further reading:
In depth use of timers with gameplay example from Unreal Engine documentation
Click here to read how C++ Timers work in Unreal Engine

The post How to use Timers in Unreal Engine 5 appeared first on Couch Learn.

What are LODs?

LOD (Level of Detail) is a technique found in all game engines that switches between different complexities of a 3D mesh over distance to reduce the amount of polygons that are needed to draw the scene.

These LODs, when setup correctly, will improve your games GPU performance!

Creating Levels of Detail

Firstly, to automatically generate different LODs for your skeletal mesh, open the mesh from the content browser.

Once the mesh is shown find the LOD Settings tab in the details section on the left.

Increase the “Number of LODs” slider to the amount that you want, then press the “Regenerate” button.

For this guide we chose four LODs. You can create and setup as many levels of detail you need for your specific mesh.

Setting up the Level of Detail

Firstly, inside the LOD drop down box, select the LOD level you wish to adjust.

Then, as LOD 0 is our full detail mesh, we want to change LOD 1 first.

Changing the LOD Distance

Inside the LOD Info drop down adjust the screen size value to the size we want for this LOD to be visible on the screen.

For this mesh we used these screen size values:

• LOD 0: 1.1
• LOD 1: 1.0
• LOD 2: 0.75
• LOD 3: 0.2

These values give the model a high quality look then quickly drops the mesh detail down over longer distances.

Reducing the Triangles

Inside the “LOD Info” drop down find the “Reduction Settings” section and adjust the “Percent of Triangles” value to what ever you require.

0.85 (15% reduction in triangles) works well for this skeletal mesh at LOD level 1.

For this guide we used these percent of triangle values:

• LOD 0: 1.0
• LOD 1: 0.85
• LOD 2: 0.45
• LOD 3: 0.1

Demonstration

Finally, with the settings used in this guide, the skeletal mesh will change between these LOD states based on the distance from the camera.

This reduced the complexity of the model, boosted your game’s performance whilst maintaining a high level of detail and quality at shorter distances.

Conclusion

Now your skeletal meshes are setup to dynamically change in quality over distance!

This simple setup drastically improves performance for lower end machines as is essential for an optimised game.

This technique is not a silver bullet for performance, but if implemented correctly, will increase the performance on many PCs when using high poly meshes.

This technique in conjunction with the static mesh level of detail setup will allow your game to contain more meshes and allow higher detail scenes without affecting performance heavily!

Click here to read the official documentation for the skeletal mesh reduction tool in Unreal Engine 4

Click here to setup automatically generating levels of detail for your static meshes in Unreal Engine 4

The post Easy LODs for Skeletal Meshes in Unreal Engine 4 appeared first on Couch Learn.

Creating the Custom Event

To create a custom event, right click anywhere in your actor’s event graph and write “Custom Event”.

Then click “Add Custom Event”.

Once created, name the new custom event.

It’s good practise to name your custom event based on its purpose.

Your event has now been created!

For this guide we named our custom event “My Custom Event”.

Adding Inputs

Similar to functions, custom events can have input variables attached to them.

These are used to send information to the nodes running from the custom event.

To add an input firstly click your custom event in the event graph and look to the right side of the screen.

Click the “New Parameter” button shown below to add a new variable to the inputs list.

Then change the name of the input. The left side text box is the name that will be displayed inside the custom event.

On the right side we can then change the input variables type.

We are changing this variable from Boolean to String. This means we can use text values in our input.

The finished custom event input should now look like this.

The custom event in the event graph will now look like this.

Using your Custom Event

Now that are custom event is created and the input variable has been setup, we can now create a “Print String” node to display the value of “My New Input” on the screen.

This is the easiest way to test if the custom event is working correctly.

Once the “Print String” node is created, connect the “My New Input” variable from your custom event to the In String pin on the Print String node.

To run your custom event simply create a “Event BeginPlay” node, drag from the execution pin and type the name of your new custom event. In our case this is “My Custom Event”.

As your custom event is connected to an execution pin, it is now being called by the other event.

Now that your custom event is being called by the BeginPlay event you can see the input variable.

This input variable pin can be connected to any variable with the same type.

We can now write any text into the My New Input variable.

Testing the Custom Event

Running the game will now show the text that we wrote in the custom event.

Conclusion

Now you have the knowledge to create and use custom events in Unreal Engine 4!

Custom events are an essential component of Unreal Engine and are especially important for multiplayer game creation using blueprints.

Below are a few links for the full custom event documentation and a guide for using custom events and other Unreal Engine 4 features to make a multiplayer damage and health system.

Click here to read the official documentation on Custom Events in Unreal Engine 4

Click here to see our guide on making a multiplayer ready damage and health system with custom events.

The post How to use Custom Events in Unreal Engine 4 appeared first on Couch Learn.

Smoothing the Turning

Firstly, click the top section of the character in the top left side of the editor window.

In our case this is AITestCharacter(self).

This will now show the character and actor information in the details section on the right.

In the Pawn section, Untick the “Use Controller Rotation Yaw”

Next, click the “CharacterMovement (Inherited)” section to show the character movement settings on the right.

In the top right search box type “rotation” to show the related options.

In the Character Movement Rotation Settings tab, change the Z Rotation Rate value to 180 and tick the “Orient Rotation to Movement” box.

Demonstration

In this demo we show AI smooth rotation in Unreal Engine 4 that use the Troll mesh and animations from the Troll Pack PBR asset pack found on the Unreal Marketplace by InfinityPBR.

Instant AI Rotation

Smooth AI Rotation

Conclusion

Your AI characters now rotation smoothly and can be customised based on the agility of your game characters!

Let us know in the comments or contact us directly if you have any problems or want to request new Unreal Engine 4 topics.

Further Reading:

To enable your AI characters to roam large open worlds, check out our guide on enabling dynamic nav mesh generation.

To read more about AI in Unreal Engine, click here to read the official documentation on Behaviour Trees.

The post How to Smoothly Rotate AI Characters in Unreal Engine 4 appeared first on Couch Learn.

Why does SteamVR start with my UE4 project?

Unreal Engine 4 has many Virtual Reality plugins enabled by default once you start a new project.

This is done to get many developers seamlessly working on their projects without any initial setup or complicated menus.

Disabling these VR related plugins will prevent SteamVR loading when you launch your project.

Disabling the SteamVR plugin

Firstly, click the Edit button in the top left of the Unreal Engine 4 editor and then click the Plugins button at the bottom of the drop down window.

Then, once the Plugins menu has opened, scroll down on the left side categories until you find the Virtual Reality section.

Once you have found this button, click it to show the Virtual Reality plugins on the right.

In this new right side menu, scroll down until you see the SteamVR plugin.

Disable the SteamVR plugin by unticking the Enabled section.

To allow these changes Unreal Engine 4 needs to restart, press Restart Now to restart the editor.

Conclusion

After these steps the editor should restart and SteamVR will no longer start when you start the Unreal Engine 4 editor with your project.

All future projects created do not keep these settings.

All new projects make will need to go through these steps if you are not using Virtual Reality in your project.

To read more about Unreal Engine 4 plugins, click here to see the full Plugin documentation.

To easily purchase and download Plugins for Unreal Engine 4, click here to go to the Unreal Engine 4 Marketplace.

The post How to Stop SteamVR Starting with Unreal Engine 4 appeared first on Couch Learn.

How a Line Trace Works

A line trace is a way to check if an object is intersecting a line. The hit data is then broken down access more information such as location of hit, normal of hit. the actor that was hit and distance from hit.

Different Types of Line Traces

“Line Trace for Objects” checks an intersection with a specific collision object type. (WorldStatic, WorldDynamic, Pawn, Ragdoll, PhysicsActor, etc)

“Line Trace by Channel” checks for an intersection with a specific line trace collision channel. (Visibility and Camera are the default options)

“Line Trace by Channel” checks for an intersection with a specific collision profile by name. (These can be viewed and created in the collision tab of the project settings)

How to Calculate the First Person Line Trace

All line traces have the same basic setup. The nodes below setup the vector maths required to check for any collisions wherever the camera is located and facing.

Breaking down the Maths

Firstly you use the FirstPersonCamera variable connected to the GetWorldLocation node to begin the line trace from your character’s camera position.

Next using the Get Controller node, get the controller rotation from the Get Control Rotation node. This will get the rotation of your camera and even works multiplayer games.

Afterwards connect the Get Control Rotation node to the Get Forward Vector node. This will get the direction your camera is facing of your camera.

Multiply this Get Forward Vector value by 5000 (Multiple Vector by Float) to get a point in space from 0,0,0 that is 5000 units away facing the direction of the camera.
(This is the distance away from the camera to check fora collision. Change this to whichever distance you need for your project).

Finally add the Get World Location return value of your First Person Camera to the multiplied value. This gets the point in 3D space that you are looking at 5000 units in front of your camera.

Accessing the Hit Data

Connecting the return value to a branch only allows successful line traces to be accessed. Not including this branch will cause lots of console errors when accessing the hit result data.

To access this data click and drag from the Out Hit value and create a Break Hit Result node.

The Complete First Person Line Trace

This is one example of a complete first person line trace.

To use this system simply connect the execution pins to any event you want e.g. Event Tick or an event

Conclusion

Your project now is setup to use a basic First Person Line Trace in Unreal Engine 4!

Your project can now detect when objects are in front of the camera. Many use this system for weapons, interacting with objects such as doors, pickups and much more!

Further Reading:

Combine this line trace system with our easy AI movement guide to create computer controlled character that can interact with objects! https://couchlearn.com/easy-ai-movement-in-unreal-engine-4/

Unreal Engine’s documentation on single line traces: https://docs.unrealengine.com/en-US/Engine/Physics/Tracing/HowTo/SingleLineTraceByChannel/index.html

Unreal Engine’s full documentation on traces: https://docs.unrealengine.com/en-US/Engine/Physics/Tracing/Overview/index.html

The post Basic First Person Line Trace in Unreal Engine 4 appeared first on Couch Learn.