Index

Symbols

∗ operator, 63

+ operator, 64

= operator, 469

== operator, 469

− operator, 62

Numbers

2D coordinate systems, 151

2D graphics, 14–15

drawing, 19–21

filtering analog sticks, 267–269

implementing, 18–21

Initialize function, 19

scrolling backgrounds, 51–53

Shutdown function, 19

sprites, 42

animating, 48–50

drawing, 44–48

2D transformations

rotation matrix, 157–158

scale matrix, 157

translation matrices, 158–159

3D

Actor transform, 184, 189–190

BasicMesh shader, 203–204

calculating view-projection matrix, 200

Euler angles, 185–186

lighting. See lighting

MeshComponent, 204–206

quaternions, 186–187

in code, 188–189

combining rotations, 187

quaternion-to-rotation matrix, 188

rotating vectors, 188

spherical linear interpolation (Slerp), 188

transform matrices, 184–185

transforming clip space

projection matrix, 197–200

view matrix, 196–197

updating vertex attributes, 193–194

z-buffering, 201–203

3D AABB, 308

3D coordinate system, 184

3D meshes, drawing, 195–196

3D models

choosing formats, 191–193

loading, 190

vertex and index buffers, 133–138

3D positional audio, 233–234

setting up listeners, 234–236

4x4 matrices, 184–185

A

A*, 106, 111–113

optimizing, 113

AABB (axis-aligned bounding box), 303–306

AABB contains point tests, 308

AABB versus AABB test, 311–312

acceleration, 79

Actor transform, 3D, 184, 189–190

Actor::LoadProperties, 436–437

actors

adding to world transforms, 159–161

associating with sound events, AudioComponent, 237–238

jumping, 248–251

loading in level files, 435–439

saving in level files, 446–448

Actor::SaveProperties, 446–447

adaptive refresh rate, 18

AddButton, 349

adding

an aiming reticule, 352–354

flipY option to UIScreen::DrawTexture, 406

pitch to first-person cameras, 278–280

point lights, 418

PointLightComponent class, 419

positional functionality to SoundEvent, 236–237

radar, 354–358

shaders to games, 146

springs to follow cameras, 283–285

text maps, 359–361

world transforms, to actors, 159–161

AddInt, 444

addition, vector addition, 63–64

AddSprite, 46

AddTarget, 352

adjacency lists, 99

admissible, heuristics, 104

adversarial, 116

AI (artificial intelligence), 91

designing state machines, 92–93

game trees, 116–118

alpha-beta pruning, 121–124

incomplete game trees, 120–121

minimax, 118–119

graphs, 98–100

BFS (breadth-first search), 100–103

implementing state machines, 93–95

pathfinding 98

Dijkstra’s Algorithm, 113–114

following paths, 114–115

heuristics, 104–105

navigation meshes, 115–116

path nodes, 115

state machine behaviors, 92

states, as classes, 95–98

AIComponent class, 93–95

AIComponent::Update function, 94, 96

AIDeath state, 97

aiming reticule, adding, 352–354

AIPatrol class, 97

AIState, 95

Alarm state, 93

Alert state, 93

alpha, 121

alpha blending, 178–180

alpha values, 14–15

alpha-beta pruning, 121–124

AlphaBetaDecide, 121–122

AlphaBetaMax, 122–123

AlphaBetaMin, 123

ambient light, 207–208

loading global properties, 434–435

analog sticks, 264–267

filtering, 267–269

anchors, 361

angle summation, 309

angles

converting from forward vectors, 67–68

converting to forward vectors, 66–67

determining between two vectors, dot product, 68–70

animating sprites, 48–50

animation, skeletal animation. See skeletal animation

Animation class, 381–382

animation data, 371–372

loading for skeletal animation, 380–385

animations, updating, 386–389

AnimSpriteComponent, 49, 50, 53–54

anisotropic filtering, 399–400

API (application programming interface), 3

Apple macOS, setting up development environments, 2

application programming interface (API), 3

architecture, InputSystem, 251–253

arctangent, 67–68

arrays, 460–461, 462

artificial intelligence. See AI (artificial intelligence)

ASCII, 358–359

AStarScratch, 111

Asteroid constructor, 74–75

Asteroids, 84–86

atan2 function, 67

Attack state, 93

attenuates, 233

attributes

OpenGL, 129

skinning vertex attributes, drawing with, 374–378

vertex attributes, updating, 193–194, 206

audio

3D positional audio, 233–234

setting up listeners, 234–236

audio systems, creating, 224–226

AudioComponent, creating to associate actors with sound events, 237–238

banks, loading/unloading, 227–229

bootstrapping, 222

buses, 242–243

Doppler effect, 240–241

effects, 241–242

equalization, 242

FMOD, 222–223

banks and events, 226–227

event instances, 229–230

installing, 223–224

listeners, in third-person games, 239–240

mixing, 241–242

occlusion, 243–244

positional functionality, adding to SoundEvent, 236–237

reverb, 242

snapshots, 243

SoundEvent class, 230–233

audio systems, creating, 224–226

AudioComponent, creating to associate actors with sound events, 237–238

AudioComponent::PlayEvent, 238

AudioComponent::StopAllEvents, 238

AudioComponent::Update, 238

AudioSystem::PlayEvent Implementation with Event IDs, 230–231

AudioSystem::SetListener, 235–236

AudioSystem::UnloadAllBanks, 228

AudioSystem::Update, 231

auto, 475–476

axis, filters, 265

axis-aligned bounding box. See AABB (axis-aligned bounding box)

B

back buffer, 17

backgrounds, scrolling backgrounds, 51–53

ball collisions

with SegmentCast, 327–328

testing in PhysWorld, 329–331

BallActor, 328

balls

drawing, 20–23

updating position of, 28–30

banks

FMOD, 226–227

loading/unloading, 227–229

basic input processing, 11–13

Basic.frag file, 141

BasicMesh shader, 203–204

BasicMesh.vert shader, 421

Basic.vert file, writing basic shaders, 139–140

beta, 121

BFS (breadth-first search), 100–103

BGSpriteComponent, 51

BGTexture, 51

bidirectional light, 214

bidirectional reflectance distribution function (BRDF), 209

Big-O notation, 470–471

bilinear filtering, 169, 394, 395–397, 400

bilinear interpolation, 396

binary data, 448–449

binary mesh files, loading, 452–454

saving, binary mesh files, 449–452

binary mesh files

loading, 452–454

saving, 449–452

bind pose, 368

Feline Swordsman, 378

blank windows, creating, 10–11

Blended, 339

blitting, 131

bone hierarchy, 367–368

Bone struct, 370

bones, 366

BoneTransform, 369, 371–372

bootstrapping, audio, 222

bounding spheres, 303

bounding volume tests, 310

AABB versus AABB test, 311–312

capsule versus capsule test, 313–314

sphere versus AABB test, 312–313

sphere versus sphere tests, 311

bounding volumes, 302–303

AABB (axis-aligned bounding box), 303–306

capsules, 306–307

convex polygons, 307

OBB (oriented bounding box), 306

spheres, 303

BoxComponent class, 324–325

BRDF (bidirectional reflectance distribution function), 209

breadth-first search (BFS), 100–103

broadphase techniques, 331

buses, 242–243

Button class, 346–350

buttons

controllers, 262–264

mouse input, 256–258

user interfaces, 346–350

Button::SetName, 347

C

C++ Standard Library, 3

calculating

lighting, 407–408

normal vectors, 70–72

points on line segments, 298

view-projection matrix, 200

weighted averages, in bilinear filtering, 396

world transform matrix, 189

camera position, computing, 282

CameraComponent, 277–278

cameras, 34

first-person camera, 276

adding pitch, 278–280

cameras without pitch, 277–278

first-person models, 280–281

movement, 276–277

follow cameras, 281–283

adding springs, 283–285

orbit cameras, 286–288

spline cameras, 289–292

unprojection, 292–294

without pitch, 277–278

capsule contains point tests, 309

capsule versus capsule test, 313–314

capsules, 306–307

Catmull-Rom spline, 289

CCD (continuous collision detection), 321

ChangeState function, 94, 96, 98

channels, 15, 222

character.jump(), 249

characters, jumping, 248–251

choosing 3D model formats, 191–193

CircleComponent subclass, creating, 83–84

circle-versus-circle intersection, 82

class hierarchies, game objects, 34–36

classes, 464–465

dynamic allocation of, 465

states as, 95–98

clip space, transforming

with projection matrix (3D), 197–200

with view matrix (3D), 196–197

from world space, 161–163

closed set, GBFS (greedy best-first search), 106

collections, 470

collision detection, 81

ball collisions

with SegmentCast, 327–328

testing in PhysWorld, 329–331

bounding volumes, 302–303

AABB (axis-aligned bounding box), 303–306

capsules, 306–307

convex polygons, 307

OBB (oriented bounding box), 306

spheres, 303

BoxComponent class, 324–325

CircleComponent subclass, creating, 83–84

circle-versus-circle intersection, 82

dynamic objects, 321–323

geometric types, 298

line segments, 298–301

planes, 301–302

intersection tests. See intersection tests

line segment tests

line segment versus AABB test, 318–320

line segment versus plane test, 314–315

line segment versus sphere test, 315–317

PhysWorld class, 325–327

player collision, against walls, 331–333

CollisionInfo, 326

color buffer, 15–16

color depth, 15

column vectors, 155, 156

combining

equations, 154

rotation, for 3D, 187

transformations, 152–153, 159

vectors, 63–64

compatibility profiles, OpenGL, 129

CompileShader, 142–143

Complete transition, Alarm state, 93

Component class, 440

component declaration, 39–40

component-based game object model, 36–38

ComponentFunc, 442

components

game objects, 36–38

as hierarchy, 38–40

loading, in level files, 439–444

saving, in level files, 446–448

composite, 248

ComputeGlobalInvBindPose, 379

ComputeMatrixPalette, 384, 389

computing

camera position, 282

positions, with Euler integration, 80

const, 464–465

contains point tests, 308

AABB contains point tests, 308

capsule contains point tests, 309

convex polygon contains point (2D) tests, 309–310

sphere contains point tests, 308

ContainsPoint, 347

context, OpenGL, 130

continuous collision detection (CCD), 321

controller input, 261

buttons, 262–264

disabling controllers, 262

enabling single controllers, 261–262

multiple controllers, 269–270

ControllerState, 263, 267

converting

from angles to forward vectors, 66–67

forward vectors, to angles, 67–68

convex polygon contains point (2D) tests, 309–310

convex polygons, 307

coordinate systems

3D coordinate system, 184

left-handed coordinate system, 184

UV coordinates, 395

coordinates, NDC (normalized device coordinates), 132–133

copy constructor, 467–468

core profile, OpenGL, 129

Create, 410

CreateMirrorTarget, 404

CreateMirrorTexture, 402

CreateRotationZ, 160

CreateScale, 160

CreateTranslation, 160

CreateWorldTransform, 160

cross product, 70–72

crosshair texture, drawing, 353

cross-platform libraries, 3

D

dead zones, 265

Death state transition, 92

debug logging, initializing, 225

Debug_Initialize, 225

deferred shading, 407–408, 424–425

G-buffer

creating, 408–411

writing to, 412–414

global lighting, 414–418

point lights, 418–419

drawing, 421–424

deleting, dynamically allocated arrays, 463

delta time, 24–28

dependency injection, 39

depth buffer, 201

depth buffering. See z-buffering

designing, state machines, AI (artificial intelligence), 92–93

Destroy, 411

destructors, 466–467

development environments, setting up, 2

Apple macOS, 2

Microsoft Windows, 2

dialog boxes, 349–352

diamond inheritance, 36

DiffuseColor, 421

digital signal processing (DSP), 241

Dijkstra’s Algorithm, 113–114

directed, 98

directed edges, 100

directional light, 208

loading global properties, 434–435

directions, vectors, 65–66

disabling controllers, 262

distance, vectors, 64–65

Doppler effect, 240–241

Dot function, 70

dot product, 68–70

double buffering, 16–18

Draw function, 52

Draw3DScene, 404–405, 413

DrawComponent, 36

DrawFromGBuffer, 416–417

drawing

2D graphics, 19–21

3D meshes, 195–196

balls, 20–23

crosshair texture, 353

mirror texture, in HUD, 406–407

paddles, 20–23

point lights, 421–424

radar, 357

with skinning vertex attributes, 374–378

sprites, 44–48

textures, 47

triangles, 146–148

transformations, 148–149

walls, 20–23

DrawScreen, 348

DSP (digital signal processing), 241

dynamic memory allocation, 462–463

dynamic memory allocation of classes, 465

dynamic objects, collision detection, 321–323

DynamicArray, 466, 467

E

edges, 98

effects, audio, 241–242

encapsulating buttons, 346

endianness, 451

equalization, 242

equations, combining, 154

ES profiles, OpenGL, 129

Escape key, 256

Euclidean distance heuristic, 105

Euler angles, 185–186

Euler integration, 80

event instances, FMOD, 229–230

event processing, 11–12

EventInstances, 229–230

events, 11

FMOD, 226–227

input devices, 251

exchange formats, 191

extensions

.frag extension, 139

.vert extension, 139

F

falloff function, 233

falloff radius, 208

FBO (framebuffer objects)

creating, 402–404

rendering, 404–405

Feline Swordsman, bind pose, 378

FIFO (first-in, first out), 473

Filter1D, 265–267

Filter2D, 268–269

filtering, 400

analog sticks, 267–269

anisotropic filtering, 399–400

bilinear filtering, 394, 395–397, 400

nearest-neighbor filtering, 395

trilinear filtering, 398, 399, 400

filters, for axis, 265

first-in, first-out (FIFO), 473

first-person camera, 276

adding pitch, 278–280

cameras without pitch, 277–278

first-person models, 280–281

movement, 276–277

first-person models, 280–281

first-person movement, 276–277

FixCollisions, 332–333

flat shading, 211

flipY option, adding to UIScreen::DrawTexture, 406

FMOD, 222–223

audio systems, creating, 224–226

banks and events, 226–227

event instances, 229–230

installing, 223–224

occlusion, 244

positional audio, 234

snapshots, 243

FMOD Studio, 223

buses, 242–243

DSP (digital signal processing), 242

FMOD_VECTOR, 234–235

FMOD_ErrorString, 225

follow cameras, 281–283

adding springs, 283–285

FollowCamera, 282

FollowCamera::Update, 283, 284–285

following paths, AI (artificial intelligence), 114–115

font rendering, 338–340

Font::Load, 338–339

Font::RenderText, 339, 340, 359

For loops, 475–476

force, 79–80

force feedback, 5

formats, 3D model formats, choosing, 191–193

forward rendering, 407–408

forward vectors

converting from angles, 66–67

converting to angles, 67–68

FPS (frames per second), 4

FPS angular speed, 277

FPSActor::FixCollisions, 332–333

FPSCamera, 278

FPSCamera::Update, 279

.frag extension, 139

fragment shaders, 139, 412

frame buffer, 201

frame limiting, 25–26

frame rate, 4

framebuffer, 15

framebuffer objects

creating, 402–404

rendering, 404–405

frames, 4–6

rendering, in OpenGL, 131

frames per second (FPS), 4

front buffer, 17

G

game classes

main function, 10–11

skeleton game class, 6–7

Initialize function, 7–9

RunLoop function, 9–10

Shutdown function, 9

Game Declaration, skeleton game class, 7

game loops, 4

frames, 4–6

integrating game objects into, 40–42

single-threaded game loop, 5

game object models, 40

game objects as class hierarchies, 34–36

game objects as hierarchy with components, 38–40

game objects with components, 36–38

game objects, 34

as class hierarchies, 34–36

with components, 36–38

as hierarchy with components, 38–40

integrating, into game loops, 40–42

types of, 34

game projects

3D graphics, 216

Asteroids, 84–86

audio, 244–245

cameras, 295

collision detection, 333–334

convertingAstroids game to OpenGL, 180

intermediate graphics, 425

level files and binary data, 454–455

moving spaceships, 271–272

skeletal animation, 389–390

sprites, 53–55

tower defense game, 124

user interfaces, 362

game time, 24

game trees, 116–118

AI (artificial intelligence)

alpha-beta pruning, 121–124

incomplete game trees, 120–121

minimax, 118–119

Game::GenerateOutput function, 147

Game::LoadData, 430

Game::LoadShaders, 166

games

adding shaders to, 146

Asteroids, 84–86

Pac-Man game, pseudocode, 6

Pong. See Pong

tic-tac-toe, game trees, 116–117

tower defense game, 124

updating, 23

delta time, 24–28

game time, 24

real time, 24

GameState, 120

gamut, 14

GBFS (greedy best-first search), 105–111

G-buffer, 408

creating, 408–411

writing to, 412–414

GBuffer class, creating, 408–411

GBuffer::Create, 410

GBufferGlobal.frag shader, 415–416, 418

GBufferPointLight.frag shader, 419–421

GBufferWrite.frag, 412

geometric types, 298

line segments, 298–301

planes, 301–302

GetCircle function, 84

GetComponentOfType, 441

GetEventInstance, 232

GetFont, 339

GetGlobalPoseAtTime, 382–383, 387–388

GetInt, JsonHelper, 433

GetKeyState, 254, 255

GetKeyValue, 254, 255

GetLeftTrigger(), 267

GetMesh, 195

GetName function, 95

GetNextPoint function, 115

GetPossibleMoves, 120

GetRightTrigger(), 267, 276

GetScore function, 118, 120

GetType, 441

GetVector3, 434

GL_ARRAY_BUFFER, 136

GL_ELEMENT_ARRAY_BUFFER, 136

GL_LINEAR, 399

GL_RGB, 402

GL_RGB16F, 411

GL_RGB32F, 410–411

GL_STATIC_DRAW, 136

GL_TEXTURE_2D, 171

glAttachShader, 145

glBindBuffer, 136

glBindFramebuffer, 402, 404

glBindTexture, 173

glBlendFunc, 179

glBufferData, 174

glCheckFrameBuffer, 403, 404

glClear, 131, 202

glCreateProgram, 145

glDrawBuffers, 403

glDrawElements, 146–147

glEnable, 179

GLEW, initializing, 130–131

glFramebufferTexture, 403

glGenerateMipmap, 399

glGenFrameBuffers, 402

glGenTextures, 171

glGetError, 130

glGetShaderiv, 144

global lighting, 414–418

properties, loading, 430–431

global pose, 368

global properties

loading, 430–434

saving, 446

globally unique IDs (GUIDs), 229

GLSL, 138

Basic.frag file, 141

Basic.vert file, 139–140

glTexImage2D, 171

glVertexAttribIPointer, 376

glVertexAttribPointer, 376

goal nodes, 100

Gouraud shading, 211

gpmesh files, loading, 194–195

graphics

2D graphics. See 2D graphics

intermediate graphics. See intermediate graphics

graphics debuggers, 414

GraphNode, 100

graphs, AI (artificial intelligence), 98–100

BFS (breadth-first search), 100–103

Grassmann product, 187

greedy best-first search), 105–111

GUIDs (globally unique IDs), 229

H

HandleKeyPress, 344

hash maps, 475

heads-up display. See HUD (heads-up display)

heuristics, 104–105

A*, 111–113

GBFS (greedy best-first search), 105–111

hierarchies, game objects with components, 38–40

high-quality reflections, 401

homogenous coordinates, 158

horizontal field of view (FOV), 199

hot swapping, 261, 270

HUD (heads-up display), 337

drawing, mirror texture, 406–407

UI screen stack, 342–344

UI screens, 340–342

HUD elements, 352

adding

an aiming reticule, 352–354

radar, 354–358

HUD::Draw, 353

HUD::UpdateCrosshair, 353

HUD::UpdateRadar, 356–357

I

IDE (integrated development environment), 2

image files, loading, 43–44

IMG_Load, 43

implementing

2D graphics, 18–21

lighting, 212–216

skeletal animation, 373–374

drawing with skinning vertex attributes, 374–378

skeleton game class, 6–7

Initialize function, 7–9

RunLoop function, 9–10

Shutdown function, 9

state machines, AI (artificial intelligence), 93–95

improving texture quality, 394

inadmissible, heuristics, 104

incomplete game trees, 120–121

index buffers, 133–138

inheritance, diamond inheritance, 36

Initialize function

2D graphics, 19

skeleton game class, 7–9

initializing

debug logging, 225

GLEW, 130–131

OpenGL, 128

input devices, 248

analog sticks, 264–267

controller input, 261

analog sticks. See analog sticks

buttons, 262–264

enabling single controllers, 261–262

multiple controllers, 269–270

events, 251

keyboards, 253–256

mouse, 256

buttons and position, 256–258

relative motion, 258–259

scroll wheels, 260–261

polling, 248

positive and negative edges, 248–251

triggers, 264

input mappings, 270–271

InputComponent class, creating, 76–79

InputSystem, architecture, 251–253

InputSystem::Filter2D, 268–269

InputSystem::Initialize, 263

installing

FMOD, 223–224

Xcode, 2

instantaneous tests, 321

integrated development environment (IDE), 2

integrating game objects into game loops, 40–42

intermediate graphics

anisotropic filtering, 399–400

deferred shading, 407–408

drawing mirror texture in HUD, 406–407

global lighting, 414–418

improving texture quality, 394

mipmapping, 397–399

rendering to textures, 400–401

creating framebuffer objects, 402–404

creating textures, 401–402

texture sampling, 395–397

interpolate, 186

Intersect function, 83, 315, 319–320

intersection, circle-versus-circle intersection, 82

intersection tests, 307

bounding volume tests, 310

AABB versus AABB test, 311–312

capsule versus capsule test, 313–314

sphere versus AABB test, 312–313

sphere versus sphere tests, 311

contains point tests, 308

AABB contains point tests, 308

capsule contains point tests, 309

convex polygon contains point (2D) tests, 309–310

sphere contains point tests, 308

inverse bind pose matrix, 371

IsCompiled, 143–144

IsTerminal, 120

IsValidProgram, 145

iterative deepening, 124

iterators, 475–476

J

joints, 366

JSON (JavaScript Object Notation), 191, 448–449

level files

loading actors, 435–439

loading components, 439–444

loading global properties, 430–434

saving, 444–446

saving actors and components, 446–448

saving global properties, 446

JsonHelper, 433, 444

JsonHelper::GetInt, 433

jumping characters, spacebar, 248–251

K

keyboards, 248

input, 253–256

KeyboardState, 254

L

last-in, first-out (LIFO), 474

left-handed coordinate system, 184

length, vectors, 64–65

Length () function, 65

LengthSquared() function, 65

level files

loading, 430

actors, 435–439

components, 439–444

global properties, 430–434

saving, 444–446

actors, 446–448

components, 446–448

global properties, 446

LevelLoader, 437

LevelLoader class, 431

LevelLoader::LoadActors, 438–439

LevelLoader::LoadComponents, 443–444

LevelLoader::LoadGlobalProperties, 434–435

LevelLoader::LoadJSON, 431–433

LevelLoader::SaveActors, 447–448

LevelLoader:SaveLevel, 445

LevelLoader::SaveLevel, 445

libraries

3D positional audio library, 234–235

C++ Standard Library, 3

OpenGL. See OpenGL

SDL (Simple DirectMedia Layer) library, 4

SDL TTF library, 338

LIFO (last-in, first-out), 474

lighting, 206

ambient light, 207–208

loading global properties, 434–435

bidirectional light, 214

deferred shading. See deferred shading

directional light, 208

global lighting, 414–418

implementing, 212–216

Phong reflection model, 209–211

point lights, 208

adding, 418–419

drawing, 421–424

spotlight, 209

vertex attributes, 206–207

lighting calculations, 407–408

line segment tests, 314

line segment versus AABB test, 318–320

line segment versus plane test, 314–315

line segment versus sphere test, 315–317

line segment versus AABB test, 318–320

line segment versus plane test, 314–315

line segment versus sphere test, 315–317

line segments, 298–301

linear mechanics, 79–80

LineSegment::MinDistSq, 300–301, 309

linked lists, 472

listeners, 233

setting up for 3D positional audio, 234–236

in third-person games, 239–240

listings

AABB::Rotate Implementation, 305–306

Abbreviated Render Declaration, 195–196

Actor Declaration, 38–39

Actor::ComputeWorldTransform Implementation, 161

Actor::LoadProperties Function, 436–437

Actor::RotateToNewForward, 327–328

Actors with Components in JSON (Excerpt from the Full File), 440

Actor::SaveProperties Implementation, 447

Adding a flipY Option to UIScreen::DrawTexture, 406

AIComponent::ChangeState Implementation, 96

AlphaBetaDecide Implementation, 122

AlphaBetaMin Implementation, 123

AlphaBetaMax Implementation, 123

Animation Declaration, 381–382

AnimSpriteComponent Declaration, 49

AnimSpriteComponent::Update Implementation, 50

Asteroid Constructor, 74–75

AudioComponent Declaration, 237

AudioSystem::LoadBank Implementation, 227–228

AudioSystem::PlayEvent Implementation with Event IDs, 230–231

AudioSystem::SetListener Implementation, 235–236

AudioSystem::Update Implementation with Event IDs, 231

Basic InputSystem Declarations, 252

Basic.frag Code, 141

Basic.vert Code, 140

The Beginning of a Skeleton Data, 370

The Beginning of an Animation Data, 380–381

BGSpriteComponent Declaration, 51

BoxComponent Declaration, 324

BoxComponent::OnUpdateWorldTransform Implementation, 325

Breadth-First Search, 102

Button Declaration, 346

Circle Class with const Member, 464

CircleComponent Declaration, 83

CircleComponent Intersection, 83

Component Declaration, 39–40

ComputeGlobalInvBindPose, 379–380

ComputeMatrixPalette, 384

Constructing a Plane from Three Points, 301

ConvexPolygon::Contains Implementation, 310

Creating a Texture for Rendering, 401–402

Creating the Mirror Framebuffer, 403–404

Cube.gpmesh, 192

Current Implementation of SpriteComponent::Draw, 166–167

Declaring Vertex Attributes in the VertexArray Constructor, 375–376

directional light, loading global properties, 434–435

Drawing MeshComponents in Renderer::Draw, 205

Drawing Point Lights in Renderer::DrawFromGBuffer, 422

English.gptext Text Map File, 359

Filter1D Implementation, 266

Final Version of GetGlobalPoseAtTime, 387–388

First Version of GetGlobalPoseAtTime, 382–383

FollowCamera::Update Implementation (with Spring), 284–285

Font Declaration, 338

Font::Load Implementation, 339

Font::RenderText Implementation, 340

FPS Angular Speed Calculation from the Mouse, 277

FPSActor::FixCollisions, 332–333

FPSCamera::Update Implementation (with Pitch Added), 279

FPSCamera::Update Implementation (Without Pitch), 278

Game Declaration, 7

Game::GenerateOutput Attempting to Draw Sprites, 147

Game::ProcessInput Implementation, 13

Game::UpdateGame Implementation, 26

Game::UpdateGame Updating Actors, 41–42

GBuffer Declaration, 409

GBuffer::Create Implementation, 410

GBufferGlobal.frag Shader, 415–416

GBufferPointLight.frag Main Function, 420–421

GBufferWrite.frag shader, 412

Greedy Best-First Search, 110–111

HUD::UpdateCrosshair, 353

HUD::UpdateRadar Implementation, 356–357

Initial AudioSystem Declaration, 224

Initial ControllerState, 263

Initial MouseState Declaration, 258

Initial Shader Declaration, 142

Initial UIScreen Declaration, 341–342

InputComponent Declaration, 77

InputComponent::ProcessInput Implementation, 77–78

InputSystem::Filter2D, 268–269

InputSystem::ProcessEvent Implementation for the Scroll Wheel, 260

JsonHelper::GetInt Implementation, 433

KeyboardState Declaration, 254

KeyboardState::GetKeyState, 255

Level with Actors (Level1.gplevel), 435–436

Level with Global Lighting Properties, 430–431

LevelLoader::LoadActors Implementation, 438–439

LevelLoader::LoadComponents Implementation, 443–444

LevelLoader::LoadGlobalProperties, 434–435

LevelLoader::LoadJSON, 432

LevelLoader::SaveActors Implementation, 447–448

LevelLoader:SaveLevel Implementation, 445

Line Segment Versus AABB Helper Function, 319

Line Segment Versus AABB Intersection, 320

Line Segment Versus Plane Intersection, 315

Line Segment Versus Sphere Intersection, 317

LineSegment::MinDistSq Implementation, 300–301

Loading the G-buffer Global Lighting Shader, 416

Loop over the Adjacent Nodes in an A* Search, 112–113

main Implementation, 10

MaxPlayer and MinPlayer Functions, 118–119

MaxPlayerLimit Implementation, 120

Mesh Declaration, 194

MeshBinHeader Struct, 449–450

MeshComponent Declaration, 204

MeshComponent::Draw Implementation, 205

MeshComponent::LoadProperties Implementation, 442

Mesh::LoadBinary Outline, 452–453

Mesh::SaveBinary Implementation, 450–451

MoveComponent Declaration, 73

MoveComponent::Update Implementation, 74

MoveComponent::Update Implementation with Quaternions, 190

OrbitCamera::Update Implementation, 287–288

Pac-Man Game Loop Pseudocode, 6

Phong.frag Lighting Uniforms, 212

Phong.frag Main Function, 215

Phong.vert Main Function, 214

PhysWorld::SegmentCast, 326–327

PhysWorld::TestPairWise, 329

PhysWorld::TestSweepAndPrune, 330–331

PointLightComponent Declaration, 419

PointLightComponent::Draw Implementation, 423–424

Quaternion Functions of Note, 189

Renderer::Draw Updated to Render Both Mirror and Default Passes, 405

Renderer::Draw3DScene Helper Function, 404–405

Renderer::DrawFromGBuffer Implementation, 417

Renderer::GetScreenDirection Implementation, 294

Renderer::Unproject Implementation, 293

Requesting OpenGL Attributes, 129

Shader::CompileShader Implementation, 143

Shader::IsCompiled Implementation, 144

Shader::Load Implementation, 144–145

Shader::SetMatrixUniform, 165

Ship Declaration, 54

SkeletalMeshComponent Declaration, 377

Skeleton Declaration, 378–379

Skeleton PhysWorld Declaration, 325–326

Skinned.vert Main Function, 385–386

SoundEvent Declaration, 232

SoundEvent's Is3D and Set3DAttributes Implementation, 236–237

SplineCamera::Update, 291–292

Spline::Compute Implementation, 290

SpriteComponent Declaration, 45–46

SpriteComponent::Draw Implementation, 48

Sprite.frag Implementation, 177

Sprite.vert Implementation, 176

Swept-Sphere Intersection, 323

Texture Declaration, 170–171

Texture::Load Implementation, 172–173

Transform.vert Vertex Shader, 164

UIScreen::ProcessInput, 348–349

Updating Position and Rotation of the First-Person Model, 280

Using SegmentCast for Ball Movement, 328

VertexArray Declaration, 135

Z-Buffering Pseudocode, 202

Load function, 144–145, 338–339, 379

LoadActors, 438

LoadBank, 227–228

LoadBinary, 452–453

LoadComponents, 443–444

LoadData function, 44

LoadGlobalProperties, 434

loading

3D models, 190

animation data, skeletal animation, 380–385

banks, 227–229

binary mesh files, 452–454

G-buffer global lighting shader, 416

global properties, 430–434

gpmesh files, 194–195

image files, 43–44

level files, 430

actors, 435–439

components, 439–444

global properties, 430–434

shaders

adding shaders to games, 146

CompileShader, 142–143

IsCompiled, 143–144

IsValidProgram, 145

Load, 144–145

OpenGL, 141–142

SetActive, 145

Unload, 146

skeletons, 378–380

textures, 170–173

LoadJSON, 431–433

LoadLevel function, 431

LoadProperties, 436, 441

LoadShaders, 146, 415

LoadText, 359

local lighting model, 209

local pose, 368

localization, 358, 361

text maps, adding, 359–361

Unicode, 358–359

look-at matrix, 196

low-pass filter, occlusion, 243

low-quality reflections, 401

M

Mac, installing FMOD, 223

macros

offsetof macro, 175

SDL_BUTTON macro, 257

main function, 10–11

Manhattan distance heuristics, 104–105

maps, 474–475

hash maps, 475

mass, 79–80

Math::Clamp, 266

Math::Cos, 67

Math.h library

Dot function, 70

Normalize(), 66

Math::Max, 313

Math::NearZero function, 73–74

Math::Sin, 67

Math::ToDegrees, 47

matrices

inverse bind pose matrix, 371

look-at matrix, 196

transformations, matrix multiplication, 154–155

transformations and, 154

transforming points, 155–157

view matrix (3D), 196–197

view-projection matrix, calculating, 200

matrix multiplication, 154–155, 156

matrix palettes, 385

max players, 116

maxAngularSpeed, 277

maxMouseSpeed, 277

MaxPlayer, 119

MaxPlayerLimit function, 120

mCurrFrame, 50

membership tests, 106

memory allocation, 462–463

memory usage, reducing, 375

Mesh, 194–195

MeshBinHeader, 449–450

MeshBinHeader*, 451

MeshComponent, 439

3D, 204–206

MeshComponent::GetType, 441

MeshComponent::LoadProperties, 442

meshes, drawing 3D meshes, 195–196

Mesh::Load, 195, 452

Mesh::LoadBinary, 452–453

Mesh::SaveBinary, 450–451

Microsoft Visual Studio Community 2017, 2

Microsoft Windows

API (application programming interface), 3

setting up development environments, 2

min players, 116

MinDistSq, 300–301, 313

minimax, 118–119

MinimaxDecide, 119

mirror framebuffer, creating, 403–404

mirror texture, drawing in HUD, 406–407

MirrorCamera, 405

mirrors, rendering framebuffer objects, 404–405

mixing audio, 241–242

monolithic hierarchy, 36

mouse, 256

buttons and position, 256–258

FPS angular speed, 277

relative motion, 258–259

scroll wheels, 260–261

MouseState, 257–258

MoveComponent, 190, 276

creating, 73–75

movement, 270

first-person camera, 276–277

InputComponent class, creating, 76–79

MoveComponent class, creating, 73–75

multiple controllers, 269–270

multiplying vectors, 62–63

N

narrowphase techniques, 331

nav mesh, 115–116

NavComponent, 114

navigation meshes, 115–116

NDC (normalized device coordinates), 132–133

nearest-neighbor filtering, 395

nearest-neighbor mipmapping, 398

negative edges, 248–251

Newtonian physics, 79

linear mechanics, 79–80

node adoption, 111

nodes, 98

goal nodes, 100

parent nodes, 100

path nodes, 115

start nodes, 100

NodeToPointerMap, 101

non-player characters (NPCs), 115

normal vectors, calculating, 70–72

normalization, unit vectors, 65–66

Normalize(), 66

normalized device coordinates (NDC), 132–133

NPCs (non-player characters), 115

numeric integration, 80–81

O

OBB (oriented bounding box), 306

object space, 149–150

occlusion, 243–244

offsetof macro, 175

OnClick, 347, 349

OnEnter, 95

OnExit, 95

OnUpdateWorldTransform, 324–325

open set, GBFS (greedy best-first search), 106

OpenGL

alpha blending, 178–180

anisotropic filtering, 399

context, 130

initializing, 128

loading shaders, 141–142

adding shaders to games, 146

CompileShader, 142–143

IsCompiled, 143–144

IsValidProgram, 145

Load, 144–145

SetActive, 145

Unload, 146

mipmapping, 399

rendering frames, 131

requesting attributes, 129

setting up OpenGL window, 128–129

texture mapping, 167–170

updating vertex format, 173–175

UBOs (uniform buffer objects), 165

vertex array object, 134–135

writing basic shaders, 139–141

operator overloading, 468–470

operator+, 469

optimizing A*, 113

orbit cameras, 286–288

OrbitCamera class, 287

OrbitCamera::Update, 287–288

oriented bounding box (OBB), 306

orthographic projection, 197

outMap, 101

overdraw, 200

overloading operators, 468–470

P

Pac-Man game

partial class hierarchy, 36

pseudocode, 6

state machine behaviors, 92

paddles

drawing, 20–23

updating position of, 26–28

painter’s algorithm, issues with in 3D, 200–201

parallax effect, 53

parameters, sound events, 223

parent nodes, 100

pass by value, 459

path nodes, 115

path-cost component, 111

pathfinding, AI (artificial intelligence), 98

BFS (breadth-first search), 100–103

Dijkstra’s Algorithm, 113–114

following paths, 114–115

heuristics, 104–105

navigation meshes, 115–116

path nodes, 115

Patrol state, 92, 94–95

pause menu, 344–345

perspective divide, 199

perspective projection, 197

phantom inputs, 265

Phong reflection model, 209–211

Phong shading, 211

physics, Newtonian physics, 79

linear mechanics, 79–80

PhysWorld class, 325–327

testing ball collisions, 329–331

PhysWorld::TestPairWise, 329

pitch, 185

pixels, 14

PlaneActor, 331, 333

planes, 301–302

platform specific libraries, 3

player collision, against walls, 331–333

PlayEvent, 229, 230, 238

playing event instances, 229–230

PNG files, 43

point light fragment shaders, 419–421

point lights, 208

adding, 418–419

drawing, 421–424

pointers, 459–460

PointLightComponent class, adding, 419

PointLightComponent::Draw, 423–424

points, transforming, with matrices, 155–157

polling, 248

polygons, 131–132

Pong

drawing walls, balls, and paddles, 20–23

updating

ball’s position, 28–30

paddle’s position, 26–28

poses, skeletons and, 367–370

position of

balls, updating, 28–30

mouse, 256–258

paddles, updating, 26–28

positional functionality, adding to SoundEvent, 236–237

positions, computing with Euler integration, 80

positive edges, 248–251

PosNormTex format, 191–192

PrepareForUpdate, 255, 264

printf function, 8

processing, basic input processing, 11–13

ProcessInput, 11–12, 13, 251, 343

InputComponent class, 76

ProcessKeyboard function, 54

projection matrix (3D), transforming, clip space, 197–200

properties, loading global properties, 430–434

Q

quality, improving texture quality, 394

quaternions, 186–187

in code, 188–189

combining, rotations, 187

MoveComponent, 190

quaternion-to-rotation matrix, 188

rotating vectors, 188

spherical linear interpolation (Slerp), 188

quaternion-to-rotation matrix, 188

queues, 473–474

quit dialog box, 351

R

radar

adding, 354–358

drawing, 357

Random function, 75

range-based For loops, 475–476

RapidJSON, 194, 430, 449

saving level files, 444–446

raster graphics, 14

real time, 24

red, green, blue (RGB), 14

reducing memory usage, 375

references, 458–459, 464–465

reflections, 401

refresh rate, 16

RegisterState function, 96

relative motion, mouse input, 258–259

RemoteTarget, 352

RemoveActor, 41

Renderer, abbreviated declaration, 195–196

renderer, 19

Renderer::Draw, 343, 377, 405

Renderer::DrawFromGBuffer, 417

Renderer::GetScreenDirection, 294

Renderer::Initialize, 404, 411

Renderer::Shutdown, 404, 411

rendering

framebuffer objects, 404–405

frames, OpenGL, 131

to textures, 400–401

creating framebuffer objects, 402–404

creating textures, 401–402

RenderText, 338, 340, 347

repositories, 3

requesting OpenGL, attributes, 129

resolution, 14

supporting multiple resolutions, 361–362

reticule, adding, aiming reticule, 352–354

reverb, 242

RGB (red, green, and blue), 14

RGBA, 14–15

roll, 185

RotateToNewForward, 327–328

rotating vectors, quaternions, 188

rotation, 152

combining for 3D, 187

Euler angles, 3D, 185–186

quaternions, 3D, 186–187

quaternion-to-rotation matrix, 188

rotation matrix, 157–158

row vectors, 155

RunLoop function, 9–10

S

sample data, 226–227

SaveActors, 447–448

SaveBinary, 450–451

SaveComponents, 448

SaveLevel, 445, 446

saving

binary mesh files, 449–452

level files, 444–446

actors, 446–448

components, 446–448

global properties, 446

scalar multiplication, 62–63

scale, 151–152

scale matrix, 157

scaling vectors, 62–63

screen tearing, 16–17

scroll wheels, mouse input, 260–261

scrolling backgrounds, 51–53

SDL (Simple DirectMedia Layer) library, 4

input devices, 251

SDL 2D coordinate system, mouse position, 257

SDL controller axis constants, 264

SDL Image, 43

SDL image file formats, 43

SDL subsystem flags, 8

SDL TTF library, 338

SDL_BUTTON macro, 257

SDL_CreateRenderer, 19

SDL_CreateTextureFromSurface, 43

SDL_CreateWindow function, 8, 128

SDL_DestroyRenderer, 19

SDL_Event, 12

SDL_GameControllerAddMappingsFromFile, 262

SDL_GameControllerGetAxis, 267

SDL_GameControllerGetButton, 264

SDL_GameControllerOpen, 261

SDL_GetKeyboardState, 13, 248, 253

SDL_GetMouseState, 256–258

SDL_GetRelativeMouseState, 259, 277

SDL_GetTicks, 25

SDL_INIT_AUDIO, 8

SDL_INIT_GAMECONTROLLER, 8

SDL_INIT_HAPTIC, 8

SDL_INIT_VIDEO, 8

SDL_Log function, 8

SDL_PollEvent function, 11–12

SDL_QueryTexture, 46

SDL_QUIT, 12

SDL_Rect, 21

SDL_RenderClear, 20

SDL_RenderCopy, 47

SDL_RenderCopyEx, 47

SDL_Renderer, 128

SDL_RenderFillRect, 20, 22

SDL_RenderPresent, 20

SDL_SCANCODE, 13

SDL_SetRenderDrawColor, 20

SDL_ShowCursor, 256

SDL_Surface, 43, 339

SDL_Texture, 44

SDL_WINDOW_FULLSCREEN, 9

SDL_WINDOW_FULLSCREEN_DESKTOP, 9

SDL_WINDOW_OPENGL, 9

SDL_WINDOW_RESIZABLE, 9

SegmentCast, 326

ball collisions, 327–328

Set3DAttributes, 236–237

set3DSettings, 241

SetActive, 137, 145, 416

SetAnimTextures function, 50

SetIntUniform, 415–416

SetListener, 235, 236

SetMatrixUniform, 164, 165, 386

setMatrixUniform, 415–416

SetName, 347

SetTexture function, 46

SetTexturesActive, 416–417

setting up

development environments, 2

Apple macOS, 2

Microsoft Windows, 2

listeners, for 3D positional audio, 234–236

OpenGL window, 128–129

SetViewMatrix, 277–278

SetVolume, 242

shader programs, 145

shaders, 138

adding shaders to games, 146

BasicMesh shader, 203–204

BasicMesh.vert shader, 421

fragment shaders, 139

loading, 141–142

CompileShader, 142–143

IsCompiled, 143–144

IsValidProgram, 145

Load, 144–145

SetActive, 145

Unload, 146

point light fragment shaders, 419–421

skinning vertex shaders, 385–387

updating, 175–176

Sprite.frag shader, 176–178

to use transform matrices, 163–167

vertex shaders, 138–139

writing basic shaders, 139

Basic.frag file, 141

Basic.vert file, 139–140

Ship::UpdateActor function, 54

Shutdown function, 2D graphics, 19

Shutdown function, 9

Simple DirectMedia Layer. See SDL

Simple OpenGL Image Library (SOIL), 170

SimpleViewProjection matrix, 163

single controllers, enabling, 261–262

single-threaded game loop, 5

skeletal animation, 365–367

animation data, 371–372

drawing with skinning vertex attributes, 374–378

implementing, 373–374

inverse bind pose matrix, 371

loading animation data, 380–385

loading skeletons, 378–380

skeletons and poses, 367–370

skinning, 372–373

skinning vertex shader, 385–387

updating, 386–389

skeletal hierarchy, 367–368

SkeletalMeshComponent, 376–377, 380, 383–384, 441

SkeletalMeshComponent::Draw, 386

SkeletalMeshComponent::Update, 388–389

skeleton game class, 6–7

Initialize function, 7–9

RunLoop function, 9–10

Shutdown function, 9

skeletons

loading, 378–380

poses and, 367–370

skinned animation. See skeletal animation

Skinned.vert, 374, 385–386

skinning, 372–373

skinning vertex attributes, drawing with, 374–378

skinning vertex shaders, 385–387

Slerp (spherical linear interpolation), 188

smoothstep function, 421

SnapToIdeal, 285

SOIL (Simple OpenGL Image Library), 170, 172

sound effects, third-person games, 239–240

sound events, 223

sound occlusion, 243–244

SoundEvent class, 230–233

adding positional functionality to, 236–237

SoundEvent::IsValid, 233

sounds. See audio

source code, 3

source control systems, 3

space

clip space. See clip space, 161–163

object space, 149–150

world space, 150

transforming, 150–151

sphere contains point tests, 308

sphere versus AABB test, 312–313

sphere versus sphere tests, 311

spheres, 303

spherical linear interpolation (Slerp), 188

spline cameras, 289–292

SplineCamera class, 290

SplineCamera::Update, 291–292

Spline::Compute, 290

splines, Catmull-Rom spline, 289

spotlight, 209

springs, adding to follow cameras, 283–285

SpriteComponent, 45–46, 166

SpriteComponent::Draw, 47–48, 166–167, 173

Sprite.frag shader, 176–178

sprites, 42, 148

animating, 48–50

drawing, 44–48

texture-mapped sprites, 178

Sprite.vert shader, 175–176

stacks, 474

start nodes, 100

state machine behaviors, AI (artificial intelligence), 92

state machines

designing, 92–93

implementing, 93–95

transitions, 94

states, as classes, 95–98

static objects, 34

std::function, 346, 437, 442

std::map, 475

std::pair, 476

std::queue, 474

std::string, 359, 437

std::unordered_map, 475

std::vector, 319, 370

strafe speed, 276

streaming data, 226–227

subtraction, vectors, 61–62

supporting multiple resolutions, 361–362

surround sound, 234

Swap, 462

sweep-and-prune, 331

swept-sphere intersection, 323

swizzle, 213–214

T

TargetActor, 435

TargetComponent, 353, 354

testing ball collisions in PhysWorld, 329–331

TestPairWise, 329

tests

contains point tests. See contains point tests

instantaneous tests, 321

intersection tests. See intersection tests

line segment tests. See line segment tests

TestSweepAndPrune, 330–331

texel density, 394

texels, 394

text, localization, 361

text maps, adding, 359–361

texture coordinates, 168, 395

texture mapping, 167–170

updating, vertex format, 173–175

texture quality, improving, 394

texture sampling, 395–397

Texture::Load, 172–173

texture-mapped sprites, 178

textures

drawing, 47

loading, 170–173

rendering to, 400–401

creating framebuffer objects, 402–404

creating textures, 401–402

Texture::SetActive, 173

Texture::Unload, 173

third-person games, listeners, 239–240

tic-tac-toe, game trees, 116–117

ToMatrix, 369

tower defense game, 124

tracking

event instances, 230

loaded banks and events, 227

tracks, 380

transform matrices

3D, 184–185

updating shaders, 163–167

transformation matrix, 155

transformations, 148–149

combining, 152–153, 159

matrices, 154

matrix multiplication, 154–155

TransformComponent, 37–38

transforming

clip space

projection matrix (3D), 197–200

view matrix (3D), 196–197

points, with matrices, 155–157

from world space, to clip space, 161–163

world space, 150–151, 157

rotation, 152

rotation matrix, 157–158

scale, 151–152

scale matrix, 157

translation, 151

translation matrices, 158–159

Transform.vert, 163

TransformWithPerspDiv, 293

transitions, 92

state machines, 94

translation, 151

translation matrices, 158–159

triangles, 131–132

drawing, 146–148

transformations, 148–149

fragment shaders, 139

normalized device coordinates (NDC), 132–133

texture mapping, 167–170

vertex and index buffers, 133–138

vertex shaders, 138–139

triggers, 34, 264

trilinear filtering, 398, 399, 400

TTF_OpenFont, 338

TTF_Quit, 338

TTF_RenderText_Blended, 339

turning on anisotropic filtering, 400

TurnTo function, 114

types of game objects, 34

U

UBOs (uniform buffer objects), 165

UI screen stack, 342–344

UI screens, 340–342

UIScreen, 340–342

UIScreen::DrawScreen, 348

UIScreen::DrawTexture, 406

UIScreen::ProcessInput, 348–349

undirected, 98

Unicode, 358–359

uniform buffer objects (UBOs), 165

uniform cost search, 114

unit quaternions, 186

unit vectors, 65–66

Unload function, 146

unloading banks, 227–229

Unproject, 294

unprojection, 292–294

unweighted graphs, 98–99

Update function, 39, 50, 388–389

UpdateActor, 39

UpdateComponents, 39

UpdateCrosshair, 353

UpdateGame, 25, 26, 41–42

UpdateMinMax, 304, 305

updating

animations, skeletal animation, 386–389

balls, position of, 28–30

games, 23

delta time, 24–28

game time, 24

real time, 24

paddles, position of, 26–28

shaders

Sprite.frag shader, 176–178

Sprite.vert shader, 175–176

to use transform matrices, 163–167

vertex attributes, 193–194

vertex format, 173–175

user interfaces (UI)

buttons, 346–350

dialog boxes, 349–352

font rendering, 338–340

localization, 358, 361

text maps, 359–361

Unicode, 358–359

pause menu, 344–345

supporting multiple resolutions, 361–362

UI screen stack, 342–344

UI screens, 340–342

UTF-8, 358

UV coordinates, 395

V

VAO (vertex array object), 150

variable time steps, 80–81

VecToFMOD, 234–235

vector addition, 63–64

vector subtraction, 61–62

vectors, 59–61, 471–472

column vectors, 155, 156

combining, 63–64

converting forward vectors to angles, 67–68

converting from angles to forward vectors, 66–67

determining angles between, dot product, 68–70

determining directions, 65–66

determining distance, length, 64–65

normal vectors, calculating, 70–72

rotating, with quaternions, 188

row vectors, 155

scaling, 62–63

velocity, 79–80

.vert extension, 139

vertex array object (VAO), 150

vertex, creating, 163

vertex attributes

lighting, 206–207

updating, 193–194

vertex buffers, 133–138

vertex format, updating, 173–175

vertex normal, 206

vertex shaders, 138–139

VertexArray class, 135, 452

VertexArray constructor, 375–376

vertical synchronization (vsync), 17

vertices, 98

view matrix (3D), transforming, clip space, 196–197

view-projection matrix, 162

calculating, 200

Visual Studio, 2

vsync (vertical synchronization), 17

W

walls

drawing, 20–23

player collision against, 331–333

waypoint graphs, 115

weighted graphs, 99

weights, edges, 98–99

Window Creation flags, 9

Windows, FMOD, installing, 223

windows, creating blank windows, 10–11

world space, 150

combining transformations, 152–153

transforming, 150–151, 157

to clip space, 161–163

rotation, 152

rotation matrix, 157–158

scale, 151–152

scale matrix, 157

translation, 151

translation matrices, 158–159

world transform matrix, calculating, 189

world transforms, adding to actors, 159–161

writing

basic shaders, 139

Basic.frag file, 141

Basic.vert file, 139–140

to G-buffer, 412–414

X

Xcode, installing, 2

.xyz syntax, 213–214

Y

yaw, 185

Z

z-buffer, 201

z-buffering, 201–203