product iamge

C++ Game Animation Programming: Learn modern animation techniques from theory to implementation using C++, OpenGL, and Vulkan

This document was uploaded by one of our users. The uploader already confirmed that they had the permission to publish it. If you are author/publisher or own the copyright of this documents, please report to us by using this DMCA report form.

Download
Search on Amazon

Simply click on the Download Book button.

Yes, Book downloads on Ebookily are 100% Free.

Sometimes the book is free on Amazon As well, so go ahead and hit "Search on Amazon"

Build your own OpenGL or Vulkan application in C++ and use it as a playground to explore the path from basic features to advanced techniques of character animation in modern games with the help of this illustrated guide

Key Features

  • Learn how to create a game skeleton with keyboard and mouse controls along with modern graphics
  • Gain insights into model loading, character animations, inverse kinematics, and debugging techniques
  • Master the art of creating animated characters and controlling their various aspects
  • Purchase of the print or Kindle book includes a free PDF eBook

Book Description

If you‘re fascinated by the complexities of animating video game characters and are curious about the transformation of model files into 3D avatars and NPCs that can explore virtual worlds, then this book is for you.

In this new edition, you’ll learn everything you need to know about game animation, from a simple graphical window to a large crowd of smoothly animated characters. First, you’ll learn how to use modern high-performance graphics, dig into the details of how virtual characters are stored, and load the models and animations into a minimalistic game-like application. Then, you’ll get an overview of the components of an animation system, how to play the animations and combine them, and how to blend from one animation into another. You’ll also get an introduction to topics that will make your programming life easier, such as debugging your code or stripping down the graphical output.

By the end of this book, you’ll have gained deep insights into all the parts of game animation programming and how they work together, revealing the magic that brings life to the virtual worlds on your screen.

What you will learn

  • Create simple OpenGL and Vulkan applications and work with shaders
  • Explore the glTF file format, including its design and data structures
  • Design an animation system with poses, clips, and skinned meshes
  • Find out how vectors, matrices, quaternions, and splines are used in game development
  • Discover and implement ways to seamlessly blend character animations
  • Implement inverse kinematics for your characters using CCD and FABRIK solvers
  • Understand how to render large, animated crowds efficiently
  • Identify and resolve performance issues

Who this book is for

This book is for curious C++ developers, game programmers, game designers, and character animators, either pursuing this as a hobby or profession, who have always wanted to look behind the curtain and see how character animation in games works. The book assumes basic C++ and math knowledge, and you should be able to read code and math formulas to get the most out of this book.

Table of Contents

  1. Creating the Game Window
  2. Building an OpenGL 4 Renderer
  3. Building a Vulkan Renderer
  4. Working with Shaders
  5. Adding Dear ImGui to show valuable information
  6. Understanding Vector and Matrix
  7. A Primer on Quaternions and Splines
  8. Loading Models in the glTF format
  9. The Model Skeleton and Skin
  10. About Poses, Frames, and Clips
  11. Blending between Animations
  12. Cleaning up the User Interface
  13. Implementing Inverse Kinematics
  14. Creating Instanced Crowds
  15. Measuring Performance and Optimizing the Code

Author(s): Michael Dunsky, Gabor Szauer
Edition: 2
Publisher: Packt Publishing
Year: 2023

Language: English
Commentary: Published: December 2023 | !!! >>> !!! >>> !!! NOTE: The book has the wrong cover BUT the whole content is about C++ Game Animation Programming !!! <<< !!! <<< !!!
Pages: 480
City: Birmingham
Tags: Computer Graphics; Character Animation; Game Animation; Game Animation Programming; Animation System; Game Programming; kinematics; C++; OpenGL; Vulkan; Shaders; Vector; Matrix; Quaternions; Splines

Cover
Title Page
Copyright and Credits
Contributors
Dedicated
Table of Contents
Preface
Part 1:Building a Graphics Renderer
Chapter 1: Creating the Game Window
Technical requirements
Getting the source code and the basic tools
Code organization in this book
The basic code for our application
NULL versus nullptr
Creating your first window
Adding support for OpenGL or Vulkan to the window
GLFW and OpenGL
GLFW and Vulkan
Event handling in GLFW
The GLFW event queue handling
Mixing the C++ classes and the C callbacks
The mouse and keyboard input for the game window
Key code, scan code, and modifiers
Different styles of mouse movement
Summary
Practical sessions
Additional resources
Chapter 2: Building an OpenGL 4 Renderer
Technical requirements
The rendering pipeline of OpenGL 4
Basic elements of the OpenGL 4 renderer
The OpenGL loader generator Glad
Anatomy of the OpenGL renderer
The main OpenGL class
Buffer types for the OpenGL renderer
Loading and compiling shaders
Vertex and fragment shaders
Creating our shader loader
Creating the simple Model class
Getting an image for the texture
Summary
Practical sessions
Additional resources
Chapter 3: Building a Vulkan Renderer
Technical requirements
Basic anatomy of a Vulkan application
Differences and similarities between OpenGL 4 and Vulkan
Technical similarities
Differences
Using helper libraries for Vulkan
Initializing Vulkan via vk-bootstrap
Memory management with VMA
Fitting the Vulkan nuts and bolts together
General considerations about classes
Changes in the Window class
Passing around the VkRenderData structure
Vulkan object initialization structs
Required changes to the shaders
Drawing the triangles on the screen
Differences and similarities between OpenGL and Vulkan, reprised
Summary
Practical sessions
Additional resources
Chapter 4: Working with Shaders
Technical requirements
Shader basics
GLM, the OpenGL Mathematics library
GLM data types and basic operations
GLM transformations
Vertex data transfer to the GPU
Switching shaders at runtime
Creating a new set of shaders
Binding the shader switching to a key
The shader switch in the draw call
Shader switching in Vulkan
Sending additional data to the GPU
Using uniform buffers to upload constant data
Creating a uniform buffer
Shader changes to use the data in the buffer
Preparing and uploading data
Using uniform buffers in Vulkan
Using push constants in Vulkan
Summary
Practical sessions
Additional resources
Chapter 5: Adding Dear ImGui to Show Valuable Information
Technical requirements
What is Dear ImGui?
Adding ImGui to the OpenGL and Vulkan renderers
Adding the headers to the OpenGL renderer
Adding the headers to the Vulkan renderer
CMake adjustments needed for ImGui
Moving the shared data to the OGLRenderData header
Creating the UserInterface class
Adding the implementation of the UserInterface class
Adding the UserInterface class to the OpenGL renderer
Creating an FPS counter
Using GLFW as a simple timer
Adding the values to the user interface
Timing sections of your code and showing the results
Adding the Timer class
Integrating the new Timer class into the renderer
Adding UI elements to control the application
Adding a checkbox
Adding a button to switch between the shaders
Adding a slider to control the field of view
Summary
Practical sessions
Additional resources
Part 2: Mathematics Roundup
Chapter 6: Understanding Vector and Matrix
Technical requirements
A review of the vector and its operations
Representations of vectors
Adding and subtracting vectors
Calculating the length of a vector
Zero and unit vectors
Vector normalization
Vector multiplication
A review of the matrix and its operations
Matrix representation
Null matrix and identity matrix
Matrix addition and subtraction
Matrix multiplication
Transposed and inverse matrices
Matrix/vector multiplication
Adding a camera to the renderer
Creating the new Camera class
Integrating the new camera into the Renderer class
Implementing mouse control in the Window class
Showing the camera values in the user interface
Adding camera movement
Using new variables to change the camera position
Moving the camera around
Adding the camera position to the user interface
Summary
Practical sessions
Additional resources
Chapter 7: A Primer on Quaternions and Splines
Technical requirements
What are quaternions?
Imaginary and complex numbers
The discovery of the quaternion
Creating a quaternion
Quaternion operations and transformations
Exploring vector rotation
The Euler rotations
The gimbal lock
Rotating using quaternions
Incremental rotations
Using quaternions for smooth rotations
A quick take on splines
Constructing a Hermite spline
Spline continuity
Hermite polynomials
Combining quaternions and splines
Summary
Practical sessions
Additional resources
Part 3: Working with Models and Animations
Chapter 8: Loading Models in the glTF Format
Technical requirements
An analysis of the glTF file format
Exploring an example glTF file
Understanding the scenes element
Finding the nodes and meshes
Decoding the raw data in the buffers element
Understanding the accessor element
Translating data using the buffer views
Checking the glTF version in the asset element
Using a C++ glTF loader to get the model data
Adding new glTF shaders
Organizing the loaded data into a C++ class
Learning about the design and implementation of the C++ class
Adding the new model class to the renderer
Adding the glTF loader and model to the Vulkan renderer
Summary
Practical sessions
Additional resources
Chapter 9: The Model Skeleton and Skin
Technical requirements
These skeletons are not spooky
Why do we create a node tree of the skeleton?
Adding the node class
Filling the skeleton tree in the Gltf model class
The inverse bind matrices and the binding pose
How (not) to apply a skin to a skeleton
Naive model skinning
Vertex skinning in glTF
Connecting joints and nodes
Joints and weights for the vertices
Creating the joint transformation matrices
Applying vertex skinning
Implementing GPU-based skinning
Moving the joints and weights to the vertex shader
Getting rid of the UBO fixed array size
Identifying linear skinning problems
The dual quaternion
Using dual quaternions as data storage
Dual quaternions in GLM
Adding dual quaternions to the glTF model
Adding a dual quaternion shader
Adjusting the renderer
Summary
Practical sessions
Additional resources
Chapter 10: About Poses, Frames, and Clips
Technical requirements
A brief overview of animations
What is a pose and how do we represent it?
From a single frame to an entire animation clip
Pouring the knowledge into C++ classes
Storing the channel data in a class
Adding the class for the animation clips
Loading the animation data from the glTF model file
Adding new control variables for the animations
Managing the animations in the user interface
Adding the animation replay to the renderer
Summary
Practical sessions
Additional resources
Chapter 11: Blending between Animations
Technical requirements
Does it blend?
Fading animation clips in and out
Crossfading between animation clips
Adding multiple animation clips into one clip
Blending between the binding pose and animation clip
Enhancing the node class
Updating the model class
Adding the blend to the animation clip class
Implementing animation blending in the OpenGL renderer
Crossfading animations
Upgrading the model classes
Adjusting the OpenGL renderer
Adding new controls to the user interface
How to do additive blending
Splitting the node skeleton – part I
Splitting the node skeleton – part II
Updating the animation clip class
Finalizing additive blending in the OpenGL renderer
Exposing the additive blending parameters in the user interface
Summary
Practical sessions
Part 4: Advancing Your Code to the Next Level
Chapter 12: Cleaning Up the User Interface
Technical requirements
UI controls are cool
Creating combo boxes and radio buttons
Implementing a combo box the C++ way
Swapping the data types
Filling the arrays for the combo boxes
Fine-tuning selections with radio buttons
Adjusting the renderer code
Updating the model class
Switching the control elements in the user interface
Drawing time series with ImGui
One ring buffer to rule them all
Creating plots in ImGui
Adding plots to the user interface
Popping up a tooltip with the plot
The sky is the limit
Summary
Practical sessions
Additional resources
Chapter 13: Implementing Inverse Kinematics
Technical requirements
What is Inverse Kinematics, and why do we need it?
The two types of Kinematics
Choosing a path to reach the target
Building a CCD solver
Understanding the CCD basics
Updating the code of the node class
Updating the model class
Outlining the new solver class
Implementing the Inverse Kinematics solver class and the CCD solver
Adding Inverse Kinematics to the renderer
Extending the user interface
Building a FABRIK solver
Understanding the FABRIK basics
Adding the methods for the FABRIK algorithm
Implementing the FABRIK solving methods
Completing the FABRIK solver
Updating the renderer
Allowing the selection of FABRIK in the user interface
Summary
Practical sessions
Additional resources
Chapter 14: Creating Instanced Crowds
Technical requirements
Splitting the model class into two parts
Deciding which data to keep in the model class
Collecting the data to move
Adding a new ModelSettings struct to store the instance data
Adjusting the OGLRenderData struct
Cutting the model class into two pieces
Implementing the logic in the new instance class
Enhancing the shader code
Preparing the renderer class
Changing the renderer to create and manage instances
Displaying the instance data in the user interface
What about Vulkan?
The need for application speed
Rendering instances of different models
Using GPU instancing to reduce data transfers
Changing the model class to use instanced drawing
Firing the turbo boost in the renderer
Textures are not just for pictures
YABT – Yet Another Buffer Type
Updating the vertex shader one last time
Summary
Practical sessions
Additional resources
Chapter 15: Measuring Performance and Optimizing the Code
Technical requirements
Measure twice, cut once!
Always measure before you take actions
Three steps of code optimization
Avoid premature optimizations
Moving computations to different places
Recalculate only when necessary
Utilize compile time over runtime
Convert your data as soon as possible
Split the calculations into multiple threads
Use compute shaders on your graphics card
Profiling the code to find hotspots
Profiling code using Visual Studio
Profiling code using GCC or Clang on Linux
Profiling code using Eclipse
Analyzing the code and planning the optimizations
Promoting the local matrices to member variables
Moving the matrix calculations
Fixing the getNodeMatrix() method
Re-profiling the application
Using RenderDoc to analyze a GPU frame
Downloading and installing RenderDoc
Analyzing frames of an application
Comparing the results of different versions of our application
Scale it up and do A/B tests
Scale up to get better results
Make one change at a time and profile again
Summary
Practical sessions
Additional resources
Index
Other Books You May Enjoy