© Satheesh Pv 2021
S. PvBeginning Unreal Engine 4 Blueprints Visual Scriptinghttps://doi.org/10.1007/978-1-4842-6396-9_2

2. Introduction to Blueprints

Satheesh Pv1  
(1)
Mumbai, India
 

UE4 Blueprints is a visual gameplay scripting language based on a node graph in which you connect nodes from left to right. It can create full-fledged games or simple/complex game mechanics, such as those that open the door to level-wide puzzles. The biggest advantage of Blueprints is that you don’t need a programmer to create the logic. Artists can easily make anything they want inside Blueprints and share it with a programmer.

This system is extremely powerful because it offers the artist a full range of tools that are generally only available to programmers. On top of that, C++ programmers can create baseline systems that can be accessed or modified by Blueprint users.

Nodes

In Blueprints (or any other visual programming language), a node is a self-contained functionality that does something unique. In Unreal Engine, Blueprint nodes are objects that can be anything—events, flow control operations, functions, variables, and so on. The source code for the node can be big or small. In Unreal Engine 4, a developer can use C++ to make a Blueprint node, which is accessed in the Graph Editor panel.

Figure 2-1 diagrams the logic done in a node editor to open a door that requires a key.
../images/496849_1_En_2_Chapter/496849_1_En_2_Fig1_HTML.jpg
Figure 2-1

An example of nodes

Blueprint Types

There are multiple types of Blueprints, which you need to understand to use them efficiently. All Blueprints types (except Level) are created in the Content Browser.

Blueprint Classes

The Blueprint class is the most common type used in your game because it self-contains gameplay mechanics, and it is easily reused across multiple levels. Blueprint classes are inherited from native C++ classes and can have their functionality.

You can create your own C++ classes and mark them as Blueprintable to create Blueprint classes. They can interact with each other to create interesting gameplay mechanics; for example, a light Blueprint and a switch Blueprint that communicate to toggle on or off a light. You could also make the switch interact with multiple lights to toggle them on/off randomly or sequentially.

To create a Blueprint class, right-click the Content Browser, and under Create Basic Asset, select Blueprint Class, as shown in Figure 2-2.
../images/496849_1_En_2_Chapter/496849_1_En_2_Fig2_HTML.jpg
Figure 2-2

Select Blueprint class

Figure 2-3 shows an example graph with an event that, when triggered, lists all the actors present in the world (the Get All Actors Of Class node), goes through each of them (the For Each Loop node) individually, and calls the toggle light function for each of them.
../images/496849_1_En_2_Chapter/496849_1_En_2_Fig3_HTML.jpg
Figure 2-3

Example Blueprint class with a custom event

Level Blueprint

A Level Blueprint cannot be created manually but is included within the level itself. It is available when the level is loaded. You can reference any asset in the world and interact with it. If you reference a Blueprint class inside a Level Blueprint, you can access all the public variables and functions in that class.

Note

A public variable or function is accessed from outside the class.

The advantage of using a Level Blueprint is that it is easier to access the actors on the level because you can directly reference them without casting. This is useful when creating events or functions that should be isolated to the level. An example is triggering a cinematic when a certain condition is met.

Figure 2-4 shows how to open a Level Blueprint.
../images/496849_1_En_2_Chapter/496849_1_En_2_Fig4_HTML.jpg
Figure 2-4

Access Level Blueprint from Editor toolbar

In a Level Blueprint, you can reference any asset by selecting it and right-clicking (see Figure 2-5).
../images/496849_1_En_2_Chapter/496849_1_En_2_Fig5_HTML.jpg
Figure 2-5

Referencing an asset

Blueprint Interface

A Blueprint Interface is a special type of Blueprint in which you can only create functions with their input and output parameters and variables. Let’s quickly go over these terms.

  • Functions are graphs with a single entry pin and a single output pin. Inside it, you can connect any number of nodes that make up your logic so that when the function is called, it starts from the entry pin, activates all the connected nodes, and exits through the output pin. Interfaces cannot contain any function implementation, which means you can only create a function without any logic (graphs are read-only), and variables cannot be created.

  • Variables are nodes that hold a value or a reference to an object or actor in the world.

Interfaces can be added to multiple other Blueprints, and they are guaranteed to contain the functions created in the interface, which can then be implemented. This allows multiple Blueprints to share one common interface; for example, imagine you have two completely different Blueprints, like tree and ice. You can have an interface that contains a damage function and implement this interface in tree and ice. Inside the tree and ice Blueprints, you can implement the damage function that makes the tree burn and the ice melt. If there is no interface, then you must convert (a.k.a cast) the hit actor to each type of actor and call the damage function.

Figure 2-6 is an example diagram that shows the differences between having an interface and not having an interface.
../images/496849_1_En_2_Chapter/496849_1_En_2_Fig6_HTML.jpg
Figure 2-6

Comparing interface vs. no interface

To create a Blueprint Interface, right-click the Content Browser, and under Create Advanced Asset, select Blueprint Interface from the Blueprints subsection (see Figure 2-7).
../images/496849_1_En_2_Chapter/496849_1_En_2_Fig7_HTML.jpg
Figure 2-7

Creating a Blueprint interface

Figure 2-8 shows the interface after it is created.
../images/496849_1_En_2_Chapter/496849_1_En_2_Fig8_HTML.jpg
Figure 2-8

Example Blueprint interface

Blueprint Macro Library

The Blueprint Macro Library is a Blueprint container that consists of a collection of graphs placed as nodes in other Blueprints. You cannot compile a graph in a macro library because it is a container. Any changes to a macro graph are reflected only when the Blueprint containing that macro is recompiled (see Figures 2-9 and 2-10).
../images/496849_1_En_2_Chapter/496849_1_En_2_Fig9_HTML.jpg
Figure 2-9

An example macro that gets a random item from an array, which is a list or collection of elements

../images/496849_1_En_2_Chapter/496849_1_En_2_Fig10_HTML.jpg
Figure 2-10

An example of how to use the macro in a Blueprint

Chapter 3 explains how to combine C++ and Blueprints. You can create your own classes and Blueprint-based classes. In addition, you can declare variables and functions in C++ that you can access in Blueprint.

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.134.104.173