Book Image

Unreal Engine 4 Scripting with C++ Cookbook

By : William Sherif, Stephen Whittle
Book Image

Unreal Engine 4 Scripting with C++ Cookbook

By: William Sherif, Stephen Whittle

Overview of this book

Unreal Engine 4 (UE4) is a complete suite of game development tools made by game developers, for game developers. With more than 100 practical recipes, this book is a guide showcasing techniques to use the power of C++ scripting while developing games with UE4. It will start with adding and editing C++ classes from within the Unreal Editor. It will delve into one of Unreal's primary strengths, the ability for designers to customize programmer-developed actors and components. It will help you understand the benefits of when and how to use C++ as the scripting tool. With a blend of task-oriented recipes, this book will provide actionable information about scripting games with UE4, and manipulating the game and the development environment using C++. Towards the end of the book, you will be empowered to become a top-notch developer with Unreal Engine 4 using C++ as the scripting language.

Related Content you might be interested in

Current Title:

Small book image
Unreal Engine 4 Scripting with C++ Cookbook
William Sherif | Stephen Whittle
Oct, 2016 | 452 pages
No titles found
Table of Contents (19 chapters)
Unreal Engine 4 Scripting with C++ Cookbook
Unreal Engine 4 Scripting with C++ Cookbook
Credits
Credits
About the Authors
About the Authors
About the Reviewer
About the Reviewer
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
UE4 Development Tools
UE4 Development Tools
Introduction
Installing Visual Studio
Creating and building your first C++ project in Visual Studio
Changing the code font and color in Visual Studio
Extension – changing the color theme in Visual Studio
Formatting your code (Autocomplete settings) in Visual Studio
Shortcut keys in Visual Studio
Extended mouse usage in Visual Studio
UE4 – installation
UE4 – first project
UE4 – creating your first level
UE4 – logging with UE_LOG
UE4 – making an FString from FStrings and other variables
Project management on GitHub – getting your Source Control
Project management on GitHub – using the Issue Tracker
Project management on VisualStudio.com – managing the tasks in your project
Project management on VisualStudio.com – constructing user stories and tasks
2
Creating Classes
Creating Classes
Introduction
Making a UCLASS – deriving from UObject
Creating a user-editable UPROPERTY
Accessing a UPROPERTY from Blueprints
Specifying a UCLASS as the type of a UPROPERTY
Creating a Blueprint from your custom UCLASS
Instantiating UObject-derived classes (ConstructObject < > and NewObject < >)
Destroying UObject-derived classes
Creating a USTRUCT
Creating a UENUM( )
Creating a UFUNCTION
3
Memory Management and Smart Pointers
Memory Management and Smart Pointers
Introduction
Unmanaged memory – using malloc( )/free( )
Unmanaged memory – using new/delete
Managed memory – using NewObject< > and ConstructObject< >
Managed memory – deallocating memory
Managed memory – smart pointers (TSharedPtr, TWeakPtr, TAutoPtr) to track an object
Using TScopedPointer to track an object
Unreal's garbage collection system and UPROPERTY( )
Forcing garbage collection
Breakpoints and stepping through code
Finding bugs and using call stacks
Using the Profiler to identify hot spots
4
Actors and Components
Actors and Components
Introduction
Creating a custom Actor in C++
Instantiating an Actor using SpawnActor
Destroying an Actor using Destroy and a Timer
Destroying an Actor after a delay using SetLifeSpan
Implementing the Actor functionality by composition
Loading assets into components using FObjectFinder
Implementing the Actor functionality by inheritance
Attaching components to create a hierarchy
Creating a custom Actor Component
Creating a custom Scene Component
Creating a custom Primitive Component
Creating an InventoryComponent for an RPG
Creating an OrbitingMovement Component
Creating a building that spawns units
5
Handling Events and Delegates
Handling Events and Delegates
Handling events implemented via virtual functions
Creating a delegate that is bound to a UFUNCTION
Unregistering a delegate
Creating a delegate that takes input parameters
Passing payload data with a delegate binding
Creating a multicast delegate
Creating a custom Event
Creating a Time of Day handler
Creating a respawning pickup for an First Person Shooter
6
Input and Collision
Input and Collision
Introduction
Axis Mappings – keyboard, mouse and gamepad directional input for an FPS character
Axis Mappings – normalized input
Action Mappings – one button responses for an FPS character
Adding Axis and Action Mappings from C++
Mouse UI input handling
UMG keyboard UI shortcut keys
Collision – letting objects pass through one another using Ignore
Collision – picking up objects using Overlap
Collision – preventing interpenetration using Block
7
Communication between Classes and Interfaces
Communication between Classes and Interfaces
Introduction
Creating a UInterface
Implementing a UInterface on an object
Checking if a class implements a UInterface
Casting to a UInterface implemented in native code
Calling native UInterface functions from C++
Inheriting UInterface from one another
Overriding UInterface functions in C++
Exposing UInterface methods to Blueprint from a native base class
Implementing UInterface functions in Blueprint
Creating C++ UInterface function implementations that can be overridden in Blueprint
Calling Blueprint-defined interface functions from C++
Implementing a simple interaction system with UInterfaces
8
Integrating C++ and the Unreal Editor
Integrating C++ and the Unreal Editor
Introduction
Using a class or struct as a blueprint variable
Creating classes or structs that can be subclassed in Blueprint
Creating functions that can be called in Blueprint
Creating events that can be implemented in Blueprint
Exposing multi-cast delegates to Blueprint
Creating C++ enums that can be used in Blueprint
Editing class properties in different places in the editor
Making properties accessible in the Blueprint editor graph
Responding to property – changed events from the editor
Implementing a native code Construction Script
Creating a new editor module
Creating new toolbar buttons
Creating new menu entries
Creating a new editor window
Creating a new Asset type
Creating custom context menu entries for Assets
Creating new console commands
Creating a new graph pin visualizer for Blueprint
Inspecting types with custom Details panels
9
User Interfaces – UI and UMG
User Interfaces – UI and UMG
Introduction
Drawing using Canvas
Adding Slate Widgets to the screen
Creating screen size-aware scaling for the UI
Displaying and hiding a sheet of UMG elements in-game
Attaching function calls to Slate events
Use Data Binding with Unreal Motion Graphics
Controlling widget appearance with Styles
Create a custom SWidget/UWidget
10
AI for Controlling NPCs
AI for Controlling NPCs
Introduction
Laying down a Navigation Mesh
Following behavior
Connecting a Behavior Tree to a Character
Constructing Task nodes
Using Decorators for conditions
Using periodic services
Using Composite nodes – Selectors, Sequences, and Simple Parallel
AI for a Melee Attacker
11
Custom Materials and Shaders
Custom Materials and Shaders
Introduction
Modifying color using a basic Material
Modifying position using a Material
Shader code via Custom node
The Material function
Shader parameters and Material instances
Glimmer
Leaves and Wind
Reflectance dependent on the viewing angle
Randomness – Perlin noise
Shading a Landscape
12
Working with UE4 APIs
Working with UE4 APIs
Introduction
Core/Logging API – Defining a custom log category
Core/Logging API – FMessageLog to write messages to the Message Log
Core/Math API – Rotation using FRotator
Core/Math API – Rotation using FQuat
Core/Math API – Rotation using FRotationMatrix to have one object face another
Landscape API – Landscape generation with Perlin noise
Foliage API – Adding trees procedurally to your level
Landscape and Foliage API – Map generation using Landscape and Foliage APIs
GameplayAbilities API – Triggering an actor's gameplay abilities with game controls
GameplayAbilities API – Implementing stats with UAttributeSet
GameplayAbilities API – Implementing buffs with GameplayEffect
GameplayTags API – Attaching GameplayTags to an Actor
GameplayTasks API – Making things happen with GameplayTasks
HTTP API – Web request
HTTP API – Progress bars
Index
Index

Managed memory – smart pointers (TSharedPtr, TWeakPtr, TAutoPtr) to track an object

When people are afraid that they'll forget the delete call for standard C++ objects they create, they often use smart pointers to prevent memory leaks. TSharedPtr is a very useful C++ class that will make any custom C++ object reference-counted—with the exception of UObject derivatives, which are already reference-counted. An alternate class TWeakPtr is also provided for pointing to a reference-counted object with the strange property of being unable to prevent deletion (hence, "weak").

Tip

UObject and it's derivative classes (anything created with NewObject or ConstructObject) cannot use TSharedPtr!

Getting ready

If you don't want to use raw pointers and manually track deletes into your C++ code that does not use UObject derivatives, then that code is a good candidate for using smart pointers such as TSharedPtr, TSharedRef, and the like. When you use a dynamically allocated object (created using the keyword...

Previous Section
End of Section 7
Next Section