Unreal Engine 4.X By Example电子书

Unreal Engine 4.X By Example

Table of Contents

Unreal Engine 4.X By Example

Credits

About the Author

About the Reviewer

www.PacktPub.com

eBooks, discount offers, and more

Why subscribe?

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Downloading the color images of this book

Errata

Piracy

Questions

1. Introduction to Unreal Engine 4

Navigating this book

Game Projects you say?

Installing Unreal Engine 4

Creating your first project!

Navigating the Unreal Engine UI

Creating a basic actor

Objects, Actors, Pawns, and Characters

Adding components to your Actor

The component hierarchy

Modifying components

3D transformation and axis

Adding the Unreal factor

Pre-Built projects as a learning resource

Summary

2. Blueprints and Barrels – Your First Game

Creating your first Blueprint

The Blueprint window

Working with Blueprints

Blueprint elements

Graphs

Functions

Macros

Variables

Event dispatchers

Modifying the Hello Sphere Blueprint

Working with Blueprint graphs

Compiling Blueprints

Using Blueprint variables

Utilizing the Blueprint palette

Blueprint meta-data and string manipulation

Creating the Barrel Hopper project!

Creating our Character

Bringing our character to life

Giving our character a mesh

Creating the character's camera

Game modes and how to make them

Creating and receiving input events

Creating the input Events

Receiving input events

Tweaking the character movement component

Building the level!

Camera tips and tricks

Camera settings

Controlling the camera

Creating the level

Blocking geometry

Geometry Brushes and how to use them

Placing the geometry

Converting a geometry Brush to a static mesh

Applying materials to geometry brushes

Level building and trigonometry!

Getting our barrels rolling

Applying physics to objects

Barrel spawners and Blueprint timers

Creating Blueprint variables

Event tick

Branch nodes

Trigger volumes and destroying Actors

Debugging our Blueprints

Masking our destruction with particles

Respawning the player

Delay nodes

Player controllers

Hit Events

Summary

3. Advanced Blueprint, Animation, and Sound

Cleaning up shop

Logic flow

Using a sequence

Creating custom cameras

Where do we spawn the camera?

Spawning the camera object

Setting the Target View

Respawning the player with a Blueprint function

Creating the Blueprint function

Animation with UE4

Animation Conventions

Animation Blueprints

Importing and exporting animation assets

Creating your first animation Blueprint

Navigating animation Blueprints

The toolbar

Populating the Animation graph

Working with state machines

State nodes

Transition Rules

Playing animations from within states

Finishing our state machine

The Animation Blueprint Event graph

Getting our character running

Working with Blendspaces

Creating the running Blendspace

Utilizing the running Blendspace

Creating your first sound scape

Importing sounds and sound cues

Working with sound cues

Sound modification

Playing sounds via animation notifications

Working with animation assets

Notifies

Curves

Additive layers

Statistics bar

Placing the animation notifies

Finishing our soundscape

Exploding barrels

Players death rattle

Looping level sound

Adding the finishing touches to Barrel Hopper

Ragdolls and Event dispatchers

Creating a basic HUD

Making the HUD object

Drawing the in game HUD

Making the font

Parsing information to and setting the HUD

An end goal for the player, the chapter, and the project

Summary

4. Unreal Engine, C++, and You

UE and C++

Why use C++

Polymorphism, virtual inheritance and templates

Hello World for C++

Exploring your first code class

Accommodating for the Unreal Build Tool

Pre-Compile macros and you

Breaking down the rest of the header file

The default constructor and include list

Virtual functions and calling the parent

Adding components and object creators

Construction helpers and object finders

Building the code

Adding Fire Particles and Hot Compilation

Setting the sphere on fire

Hot Compilation

Hello world text and receiving events through delegates

Adding the 3D text

Delegates and Events

Polishing the sphere

Changing materials via C++

Extending C++ into Blueprint

Extending a class with no macro specifier support

Extending a class with macro specifier support

Defining a class with macro specifiers

Working with code created components

Blueprint native events and you!

Overriding a BlueprintNativeEvent

Summary

5. Upgrade Activated – Making Bounty Dash with C++

Creating a C++ character

Create the C++ project

The UE4 object hierarchy

Creating the Character

What we have been given

What we are going to need

BountyDashCharacter's members

BountyDashCharacters methods

Constructing the Character

Borrowing from the old to make the new

Assigning Blueprints in code with generated classes

Setting up the components

Assuming default control

Writing the begin Play function

Getting In-Editor objects using the Game World

Sorting TArrays with Lambdas

Setting up inputs in C++

Binding actions

How our Character is going to Tick

Compile time

Creating the C++ world objects

Converting BSP brushes to a static mesh

Smoke and mirrors with C++ objects

Modifying the BountyDashGameMode

BountyDashGameMode class definition

BountyDashGameMode function definitions

Getting our game mode via Template functions

Coding the floor

Floor class definition

Floor function definitions

AFloor::AFloor() constructor

AFloor::Tick()

Placing the Floor in the level!

Creating the obstacles

Spawning actors from C++!

Obstacle Spawner class definition

Obstacle Spawner function definitions

Getting information from components in C++

Ensuring the Obstacle Spawner works

Minting the coin object

Coin class definition

Coin function definitons

Making the coin Blueprint!

Making it rain coins, creating the coin spawner

Coin Spawner class Definition

Coin Spawner function definitions

Testing what we have so far!

Creating the interactions between the world objects

Pushing the Character

ABountyDashCharacter Collision functions

Pushing the character back

Picking up coins

Coin collision

Summary

6. Power Ups for Your Character, Power Ups for the User

Cleaning up shop and object hierarchies

BountyDashObject

Modifying existing objects

Creating a Plug-in with C++

Modules and code files

The anatomy of a plugin

Describing a plugin

PowerUpPlugin.uplugin

Working with our first plugin module

PowerUpPlugin.Build.cs

Declaring the PowerUpPlugin code module

Adding the PowerUp object

Using our plugin in engine

Creating the BountyDashPowerUp object

Incorporating power-ups into Bounty Dash

Modifying the Coin Spawner

Build, run, and test!

Colliding with power ups

Powering up the character

Reducing the game speed

Making the coin magnet

How to create, load and smash Destructible Meshes

Creating HUDs using C++

ABountyDashHUD

Getting information from our objects

Setting the HUD class in the game mode

Implementing a custom DrawHUD function

Completing the Bounty Dash game loop!

The beginning of the end and pausing the game

Pausing the Game

Restarting the game

Drawing the game over text

Finishing the wall of death and polishing the project

Making the wall of death

Making the new floor mesh

ADestroyedFloorPiece

Modifying the AFloor object

Bells, whistles and explosions

Playing sound from C++

Playing particles from C++

Getting the character to run

The last bit of concealer

Summary

7. Boss Mode Activated – Unreal Robots

Setting up the project

The first-person character

Importing what we need

Beginning the FPC

Establishing a FPC aim/movement

Defining the FPC constructor

Defining the FPC move and aim functions

Creating the input bindings

Binding the inputs

Abstracting a BM character into Blueprint

Setting a Blueprint object as the default pawn in a C++ game mode

Testing what we have!

Adding a custom HUD and drawing a cross hair

BMHUD class definition

Defining the BMHUD

Creating the projectile

Defining the Projectile

Initializing the Projectile

Colliding with the Projectile

Subclass templates and firing the projectile

Modifying BMCharacter accommodate for the projectile

Creating the FPProjectile Blueprint

Modifying FPCharacter

Unreal Robots

AI breakdown

Preparing your project for AI intergration

Creating the AI character base class

Creating your first AI controller

Behavior tree breakdown and logic flow

What are blackboards?

Creating a basic behavior tree and black-board!

Setting up the blackboard

The behavior tree Editor

Setting up the behavior Tree

Creating a custom task via blueprint

Creating a custom decorator using blueprint

Creating a custom service using C++

Defining the BMArgoCheck class

Advanced collision in UE4

Defining the service tick

Adding the C++ service to the BossBT

Integrating the AI Character

Creating a custom object collision channel

Modifying the level to support AI

What is a navigation mesh

Adjusting the NavMesh generation settings

Placing a NavMesh in the scene

Placing the AI in the level and testing

Summary

8. Advanced AI and Unreal Rendering

Expanded AI and tracking projectiles

Tracking projectiles and you

Creating the line trace

Preparing the projectile

Creating the custom channel and testing the tracking!

Expanded AI

Damage in UE4

Boss state and enums in blackboard!

Interpreting our C++ enum in Blackboard

Modifying the BossBT to support Boss States

Debugging BossBT to check Blackboard values

Upgrading the ABMIController

Tracking to the player

Testing what we have so far

Arming the boss

Adding the Turret boss state

The Final Behaviour State

BMRandomMoveTo

Finishing the BossBT

AI Complete

Rendering in UE4

UE4 Materials

What are materials

Physically Based Rendering

The Material editor

The Toolbar

The Viewport

The Graph and Base material node

The Details panel

The stats panel

The Palette

Starting the Boss outer material

Your first material expression and color channels

Applying a Normal Map and the texture viewer

Emissive color and masks

Adding more detail and advanced material use

Texture UV's and adding normals

Functions of time within materials and pulsing glow

Making the Boss inner material

Setting up what we know

Masking values based on UV

Applying the material to the Boss

Summary

9. Creating a Networked Shooter

Creating the project

Adding a marketplace package

Network multiplayer theory

Networking patterns

Peer to Peer (P2P)

Client/server

UE4 Networking

Dedicated or listen servers

UE4 replication

Network role

Remote Procedure Calls (RPCs)

Types of RPC

Defining RPCs

Net ownership, player controllers and game modes

Starting the networked First Person Shooter

Preparing the NS project

Making a networked player character

NSCharacter visual and audio assets

Player states and networking

Finishing the Player class definition

Writing the ANSCharacter RPCs

Defining the ANSCharacter functions

Dynamic materials and material parameters

Getting the player to shoot… online

Taking damage and UE4 timers

Cleaning up shop

Preparing the ANSCharacter blueprint

Preparing the third-person Mesh

Creating the force feedback asset

Custom collision channel

Highlighting the VectorParameter that drives team color

Making the fire montage assets

Tying it all together

Testing the multiplayer with a PIE session!

Spawn points and spawning the players

Defining the ANSSpawnPoint class

ANSSpawnPoint function definitions

Game modes and servers

Game mode class definition

Construction the Game mode and Finding Spawn points

Ending the Game and ticking the game mode

Connecting players

Spawning the players

Respawning the player

Preparing our game map

Testing our game functionality

Drawing the HUD and preparing the lobby

Creating the GameState

Drawing in the HUD

Testing our Game

Summary

10. Goodbyes and Thank yous

Packaging a project

Build Targets

Build configuration

Compiler specific building to configuration

Packaging NS

Testing the NS package

Creating the listen server instance

Console commands

Connecting to the local host

Profiling using the console commands

Console visualizations

Wrapping up the NS project

What we have learned so far

The Editors

Blueprints

Unreal animation

C++

Artificial Intelligence

Unreal Rendering

Unreal networking!

Summary

Index