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
Michael Dunsky | Gabor Szauer
Dec, 2023 | 480 pages
Small book image
Game Physics Cookbook
Gabor Szauer
Mar, 2017 | 480 pages
Small book image
OpenGL 4 Shading Language Cookbook
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

Adding an OpenGL loader

There is some external code that this chapter depends on, called glad. When you create a new OpenGL context on Windows, it's created with a legacy OpenGL context. The extension mechanism of OpenGL will let you use this legacy context to create a new modern context.

Once the modern context is created, you will need to get function pointers to all OpenGL functions. The functions need to be loaded with wglGetProcAdress, which returns a function pointer.

Loading every OpenGL function in this fashion would be very time-consuming. This is where having an OpenGL loader comes in; glad will do all this work for you. An OpenGL loader is a library or some code that calls wglGetProcAdress on the functions that the OpenGL API defines.

There are several OpenGL loaders available on Windows.; this book will use glad. glad is a small library that consists of only a few files. It has a simple API; you call one function and get access to all the OpenGL functions. glad has a web-based interface; you can find it at https://glad.dav1d.de/.

Important note

When using an X Windows system, such as many popular Linux distributions, the function to load OpenGL functions is glXGetProcAddress. As with Windows, there are OpenGL loaders available for Linux as well. Not all OSes need an OpenGL loader; for example, macOS, iOS, and Android don't need a loader. Both iOS and Android run on OpenGL ES.

Previous Section
End of Section 5
Next Section