Book Image

Hands-On C++ Game Animation Programming

By : Gabor Szauer
Book Image

Hands-On C++ Game Animation Programming

By: Gabor Szauer

Overview of this book

Animation is one of the most important parts of any game. Modern animation systems work directly with track-driven animation and provide support for advanced techniques such as inverse kinematics (IK), blend trees, and dual quaternion skinning. This book will walk you through everything you need to get an optimized, production-ready animation system up and running, and contains all the code required to build the animation system. You’ll start by learning the basic principles, and then delve into the core topics of animation programming by building a curve-based skinned animation system. You’ll implement different skinning techniques and explore advanced animation topics such as IK, animation blending, dual quaternion skinning, and crowd rendering. The animation system you will build following this book can be easily integrated into your next game development project. The book is intended to be read from start to finish, although each chapter is self-contained and can be read independently as well. By the end of this book, you’ll have implemented a modern animation system and got to grips with optimization concepts and advanced animation techniques.

Related Content you might be interested in

Current Title:

Small book image
Hands-On C++ Game Animation Programming
Gabor Szauer
Jun, 2020 | 368 pages
Small book image
C++ Game Animation Programming
Mr. Gabor Szauer | Michael Dunsky
Dec, 2023 | 480 pages
Small book image
Game Physics Cookbook
Mr. Gabor Szauer
Mar, 2017 | 480 pages
Small book image
OpenGL 4 Shading Language Cookbook
David A Wolff | David Wolff
Sep, 2018 | 472 pages
Table of Contents (17 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
1
Chapter 1: Creating a Game Window
Chapter 1: Creating a Game Window
Technical requirements
Creating an empty project
Creating the application class
Adding an OpenGL loader
Getting glad
Creating a window
Exploring the samples
Summary
Free Chapter
2
Chapter 2: Implementing Vectors
Chapter 2: Implementing Vectors
Introducing vectors
Creating a vector
Understanding component-wise operations
Understanding non-component-wise operations
Interpolating vectors
Comparing vectors
Exploring more vectors
Summary
3
Chapter 3: Implementing Matrices
Chapter 3: Implementing Matrices
Technical requirements
What is a matrix?
Creating a matrix
Common matrix operations
Transforming vectors and points
Inverting a matrix
Creating camera matrices
Summary
4
Chapter 4: Implementing Quaternions
Chapter 4: Implementing Quaternions
Creating quaternions
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
Look rotation
Converting between quaternions and matrices
Summary
5
Chapter 5: Implementing Transforms
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
6
Chapter 6: Building an Abstract Renderer
Chapter 6: Building an Abstract Renderer
Technical requirements
Working with shaders
Working with buffers (attributes)
Working with uniforms
Working with index buffers
Rendering geometry
Working with textures
Simple shaders
Summary
7
Chapter 7: Exploring the glTF File Format
Chapter 7: Exploring the glTF File Format
Technical requirements
Exploring how glTF files are stored
Exploring the glTF format
Exploring cgltf
Exploring the sample assets
Summary
8
Chapter 8: Creating Curves, Frames, and Tracks
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
Creating the TransformTrack class
Summary
9
Chapter 9: Implementing Animation Clips
Chapter 9: Implementing Animation Clips
Implementing poses
Implementing clips
glTF – loading the rest pose
glTF – loading joint names
glTF – loading animation clips
Summary
10
Chapter 10: Mesh Skinning
Chapter 10: Mesh Skinning
Exploring meshes
Understanding skinning
Implementing skeletons
glTF – loading the bind pose
glTF – loading a skeleton
Implementing meshes
glTF – loading meshes
Implementing GPU skinning
Summary
11
Chapter 11: Optimizing the Animation Pipeline
Chapter 11: Optimizing the Animation Pipeline
Pre-generating the skin matrix
Storing the skin palette in a texture
Faster sampling
The Pose palette generation
Exploring Pose::GetGlobalTransform
Summary
12
Chapter 12: Blending between Animations
Chapter 12: Blending between Animations
Pose blending
Crossfading animations
Additive blending
Summary
13
Chapter 13: Implementing Inverse Kinematics
Chapter 13: Implementing Inverse Kinematics
Creating a CCD solver
Creating a FABRIK solver
Implementing constraints
Using IK to align a character's feet to the ground
Summary
Further reading
14
Chapter 14: Using Dual Quaternions for Skinning
Chapter 14: Using Dual Quaternions for Skinning
Introducing dual quaternions
Implementing dual quaternions
Skinning with dual quaternions
Understanding how to use dual quaternion skinning
Summary
15
Chapter 15: Rendering Instanced Crowds
Chapter 15: Rendering Instanced Crowds
Storing data in textures
Reading data from textures
Encoding animation data
Exploring per-instance data
Creating an animation texture
Animation baker
Creating a crowd shader
Creating the Crowd utility class
Blending animations
Exploring texture formats
Combining animation textures
Optimizing texel fetches
Summary
16
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Exploring the samples

All of the code presented in this book is available in the downloadable content for the book. There is one large sample, called AllChapters, which includes every sample in a single application. There is a Bin ZIP file that contains a pre-compiled executable of the AllChapters sample.

There are also individual folders for each chapter that contain multiple sub-folders. Every chapter contains Sample00, which is the code as it was written in the book with no additional content. The subsequently numbered samples add content.

The AllChapters sample looks a bit different from the samples in the individual chapter folders. This application uses Nuklear (https://github.com/vurtun/nuklear) to display its UI. The part of the UI that is displayed is a stats counter in the upper-right corner of the screen. It looks like this:

Figure 1.5: Stats counter for the AllChapters sample

Figure 1.5: Stats counter for the AllChapters sample

The top box contains some general information about the display that the application opened on. This information contains the display frequency, whether vsynch is enabled, and what the frame budget is in milliseconds.

The second box down contains high-level frame timings. The time displayed will turn red if there was a stale frame in the last 60 frames. Some stale frames are unavoidable; if the frame rate drops to 59.9, the text will show red for a second. Seeing red here occasionally is OK; it's only a concern if the numbers are solid red.

The third box down contains two GPU timers; these measure how fast the sample is running on the GPU. This is useful for debugging any heavy draw calls. The final box contains CPU timers, which are helpful for figuring out which phase of the problem has a bottleneck.

Important note

Throughout this book, you will use C++ stl containers. The Standard Library is a bit slow in debug mode, mostly due to error checking. It's a good idea to profile any samples in release mode only.

These examples should do a fair job of demonstrating what you will learn in each of the upcoming chapters. They also provide an example for you to compare your code against.

Previous Section
End of Section 8
Next Section