Hands-On C++ Game Animation Programming by Szauer, Gabor -- Read -- Imperial Library of Trantor

Index

Hands-On C++ Game Animation Programming Why subscribe? Contributors About the author About the reviewer Packt is searching for authors like you Preface

Who this book is for What this book covers To get the most out of this book

Conventions used

Get in touch

Reviews

Chapter 1: Creating a Game Window

Technical requirements Creating an empty project Creating the application class Adding an OpenGL loader Getting glad

Adding glad to the project

Creating a window

Global variables Opening a window Creating the event handler

Exploring the samples Summary

Chapter 2: Implementing Vectors

Introducing vectors Creating a vector

Epsilon

Understanding component-wise operations

Vector addition Vector subtraction Scaling vectors Multiplying vectors Dot product

Understanding non-component-wise operations

Vector length Normalizing vectors The angle between vectors Vector projection and rejection Vector reflection Cross product

Interpolating vectors Comparing vectors Exploring more vectors Summary

Chapter 3: Implementing Matrices

Technical requirements What is a matrix?

Matrix storage

Creating a matrix Common matrix operations

Comparing matrices Adding matrices Scaling a matrix Matrix multiplication

Transforming vectors and points Inverting a matrix

Transpose Determinant and minors of lower-order matrices

Creating camera matrices

Frustum Perspective Orthographic Look at

Summary

Chapter 4: Implementing Quaternions

Creating quaternions

Angle axis Creating rotations from one vector to another

Retrieving quaternion data Common quaternion operations Comparison operations Dot product Length and squared length Unit quaternions Conjugate and inverse Multiplying quaternions Transforming vectors Interpolating quaternions

Neighborhood Understanding the mix function Understanding the nlerp function Introduction to slerp Power Implementing slerp

Look rotation Converting between quaternions and matrices Summary

Chapter 5: Implementing Transforms

Creating the transform Combining transforms Inverting transforms Mixing transforms Converting transforms to matrices Converting matrices into transforms Transforming points and vectors Summary

Chapter 6: Building an Abstract Renderer

Technical requirements Working with shaders

The Shader class declaration Implementing the Shader class

Working with buffers (attributes)

The Attribute class declaration Implementing the Attribute class

Working with uniforms

The Uniform class declaration Implementing the Uniform class

Working with index buffers

The IndexBuffer class declaration Implementing the IndexBuffer class

Rendering geometry Working with textures

Adding stb_image The Texture class declaration Implementing the Texture class

Simple shaders

The vertex shader The fragment shader

Summary

Chapter 7: Exploring the glTF File Format

Technical requirements Exploring how glTF files are stored

glTF files store a scene, not a model

Exploring the glTF format

The parts you need for animation The parts you don't need for animation Accessing data

Exploring cgltf

Integrating cgltf

Exploring the sample assets

Exporting from Blender

Summary

Chapter 8: Creating Curves, Frames, and Tracks

Understanding cubic Bézier splines Understanding cubic Hermite splines Interpolation types Creating the Frame struct Creating the Track class

Declaring the Track class Implementing the Track class

Creating the TransformTrack class

Declaring the TransformTrack class Implementing the TransformTrack class

Summary

Chapter 9: Implementing Animation Clips

Implementing poses

Declaring the Pose class Implementing the Pose class

Implementing clips

Declaring the Clip class Implementing the Clip class

glTF – loading the rest pose glTF – loading joint names glTF – loading animation clips Summary

Chapter 10: Mesh Skinning

Exploring meshes Understanding skinning

Exploring rigid skinning The rigid skinning pipeline Exploring smooth skinning

Implementing skeletons

The Skeleton class declaration The Skeleton class implementation

glTF – loading the bind pose glTF – loading a skeleton Implementing meshes

The Mesh class declaration The Mesh class implementation

glTF – loading meshes Implementing GPU skinning Summary

Chapter 11: Optimizing the Animation Pipeline

Pre-generating the skin matrix

Generating the skin matrix CPU skinning GPU skinning

Storing the skin palette in a texture Faster sampling

Optimizing the Track class Converting tracks Creating FastTransformTrack Creating FastClip

The Pose palette generation

Changing the GetMatrixPalette function Reordering joints Reordering clips Reordering meshes

Exploring Pose::GetGlobalTransform Summary

Chapter 12: Blending between Animations

Pose blending

Declaring the Blend function Implementing the Blend function

Crossfading animations

Creating helper classes Declaring the cross-fade controller Implementing the cross-fade controller

Additive blending

Declaring additive animations Implementing additive animations

Summary

Chapter 13: Implementing Inverse Kinematics

Creating a CCD solver

Declaring the CCD solver Implementing the CCD solver

Creating a FABRIK solver

Declaring the FABRIK solver Implementing the FABRIK solver

Implementing constraints

Ball-and-socket constraint Hinge constraint

Using IK to align a character's feet to the ground

Finding the foot goals Interpolating the foot goals Vertical character placement IK pass Foot alignment

Summary Further reading

Chapter 14: Using Dual Quaternions for Skinning

Introducing dual quaternions Implementing dual quaternions

Implementing dual quaternion operations Measuring, normalizing, and inverting dual quaternions Converting transforms and dual quaternions Transforming vectors and points

Skinning with dual quaternions

Modifying the pose class Modifying the skeleton class Creating new uniform types Creating a dual quaternion shader

Understanding how to use dual quaternion skinning Summary

Chapter 15: Rendering Instanced Crowds

Storing data in textures Reading data from textures Encoding animation data Exploring per-instance data Creating an animation texture

Declaring the AnimTexture class Implementing the AnimTexture class

Animation baker Creating a crowd shader Creating the Crowd utility class

Implementing the Crowd class Using the Crowd class

Blending animations Exploring texture formats Combining animation textures Optimizing texel fetches

Limiting influences Limiting animated components Not interpolating Combining these optimizations

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think

← Prev
Back
Next →

← Prev
Back
Next →