Unreal Engine 4 Scripting with C++ Cookbook

Unreal Engine 4 Scripting with C++ Cookbook

By : William Sherif, Stephen Whittle

Buy this Book

Unreal Engine 4 Scripting with C++ Cookbook

By: William Sherif, Stephen Whittle

Buy this Book

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.

Unreal Engine 4 Scripting with C++ Cookbook

Credits

About the Authors

About the Reviewer

www.PacktPub.com

Preface

Free Chapter

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

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

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

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

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

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

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

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

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

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

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

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

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Introduction

Creating a game is an elaborate task that will require a combination of assets and code. To create assets and code, we'll need some pretty advanced tools including art tools, sound tools, level editing tools, and code editing tools. In this chapter, we'll discuss finding suitable tools for asset creation and coding. Assets include any visual artwork (2D sprites, 3D models), audio (music and sound effects), and game levels. Code is the text (usually C++) that instructs the computer on how to tie these assets together to make a game world and level, and how to make that game world "play." There are dozens of very good tools for each task; we will explore a couple of each, and make some recommendations. Game editing tools, especially, are hefty programs that require a powerful CPU and lots of memory, and very good, ideal GPUs for good performance.

Protecting your assets and work is also a necessary practice. We'll explore and describe source control, which is how you back up your work on a remote server. An introduction to Unreal Engine 4 Programming is also included, along with exploring basic logging functions and library use. Significant planning is also required to get the tasks done, so we'll use a task-planner software package to do so.

Unreal Engine 4 Scripting with C++ Cookbook

By : William Sherif, Stephen Whittle

Unreal Engine 4 Scripting with C++ Cookbook

By: William Sherif, Stephen Whittle

Overview of this book

Related Content you might be interested in

Current Title:

Unreal Engine 4 Scripting with C++ Cookbook

Introduction