Dunsky / Szauer C++ Game Animation Programming

Learn modern animation techniques from theory to implementation using C++, OpenGL, and Vulkan
2. Auflage 2025
ISBN: 978-1-80324-136-4
Verlag: De Gruyter
Format: EPUB
Kopierschutz: 0 - No protection

E-Book, Englisch, 480 Seiten

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 find expanded content on high-performance graphics and modern animation techniques, along with improved workflows and enhanced guidance on using OpenGL and Vulkan. 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.

Autoren/Hrsg.

Dunsky, Michael

Szauer, Gabor

Fachgebiete

• Mathematik | Informatik EDV | Informatik Programmierung | Softwareentwicklung Software Engineering

Leseproben

Preface

Character animations have existed since the first games were created for computers. The spaceships in , written by Steve Russell in 1962 for a PDP-1, and by Nolan Bushnell, released in 1971 as an arcade cabinet, were animated, with the animation showing the direction in which the spaceships headed.

Over time, the evolution of character animation went from these raster graphics, drawn by the electron beam inside the cathode-ray tube of old TV sets, to simple 2D pictures (so-called “sprites”). These sprites were drawn by hand, picture by picture, and every one of these pictures showed a different animation phase. To create the illusion of real-time animations, the pictures were shown quickly one after another, like cartoons. The main characters in and are just a bunch of two-dimensional pictures, brought to life by proper timing between the sprites and their motion over the screen.

Eventually, the character models became real 3D objects. First, they were made of simply dozens of triangles, and as the graphics hardware became more powerful, the numbers got larger and larger. Current 3D models can have more than 500,000 polygons, and even these characters are animated smoothly in real time.

This book covers the animation of 3D game characters, taking a closer look at the principles of character components and animation. After explaining the theoretical elements of animation, we will provide an example implementation that will guide you from the conceptual stage to the real-world usage in an application. With this knowledge, you will be able to implement a similar animation system, regardless of the programming language or rendering API.

Who this book is for

This book is for programmers who want to “look behind the curtain” of character animation in games. You should be familiar with C++, and it would be best to have a modern version such as C++17. Basic knowledge of a rendering pipeline will come in handy too, but it is not required, as it will be covered in the book. The remaining skills, including opening a window, preparing a rendering API to draw triangles, and loading models and animating them, will also be explained throughout the book.

What this book covers

, , covers the initial steps to open a window using GLFW, a lightweight cross-platform window management library. The window will be enhanced to detect OpenGL 4.6 and Vulkan 1.1; code for handling window events such as resizing and moving will be added, followed by an introduction on using the keyboard and mouse as input devices.

, , explains how to create a basic OpenGL 4 renderer that can display a textured quad consisting of two triangles.

, , explores the creation of a renderer, similar to , but instead using the newer Vulkan API to display the textured quad.

, , covers the different shaders of the graphics pipeline for OpenGL and Vulkan, the buffer types, and how to access the variables of shaders from renderer code. At the end of the chapter, the parts of a vertex and a fragment shader will be discussed.

, , explains how to add a simple UI to both renderers to display information about the rendering process, such as the frames per second or timing of code sections. Also, checkboxes, buttons, and sliders will be added to the UI to control the rendering parameters.

, , is a quick recap of the data types of a vector and a matrix, their transformations, and their operations.

, , explains the advantage of quaternions over matrix operations and introduces some spline types that are used in game character animations.

, , covers the internals of the glTF file format. glTF is an open file format, supported by many 3D content creation tools. Being able to load this format will let you view models and animations authored in many 3D creation tools in the application.

, , covers the internal skeleton of a model as a base for animation, plus vertex skinning to match different poses of the skeleton. Different methods to apply vertex skinning will be discussed in this chapter.

, , explains the different data types required for character animation, allowing you to get from a simple model pose to a complete animation clip.

, , shows different blending methods for animated mode. The chapter covers simple blending between a basic pose and an animation clip, cross-blending between different clips, and additive blending to mix different clips.

, , enhances the UI created in with more
user-interactable elements, such as combo boxes and radio buttons. These controls enable the modification of animation parameters in real time. In addition, the timer values for the code sections will be visualized as graphical plots.

, , explains how to use inverse kinematics to achieve an interaction between a character and its environment. The two inverse kinematics methods, Cyclic Coordinate Descent (CCD) and Forward And Backward Reaching Inverse Kinematics (FABRIK), will be explained and implemented.

, , shows how to add more than one model to a scene, plus different ways to transfer model data to the graphics memory.

, , introduces methods to find bottlenecks by profiling code and using RenderDoc to analyze the graphics pipeline. It also offers ideas to move calculations from runtime to compile time and examines the importance of scaling to get meaningful results.

To get the most out of this book

To follow the code snippets and the example code, you should have some experience using C++. Any special or advanced features will be explained, and resources to learn more about these features are included in the chapters when they are first used. However, you should be able to debug simple C++ problems (e.g., by using logging statements).

The code in this book is written for OpenGL 4.6 and Vulkan 1.1. These versions are widely supported in modern GPUs; the oldest graphics cards known to work with these API versions are from the Intel HD Graphics 4000 series, created about 10 years ago.

Software used in the book

Operating system requirements

OpenGL 4.6 and Vulkan 1.1

Windows or Linux

The example code presented in this book can be compiled on any desktop computer or laptop running a recent version of Windows and Linux. The code has been tested with the following combinations:

• Windows 10 with Visual Studio 2022
• Windows 10 with Eclipse 2023-06, using GCC from MSYS2 and Ninja as the build system
• Ubuntu 22.04 with Eclipse 2023-06, using GCC or Clang
• Ubuntu 22.04 compiling on the command line, using GCC or Clang

If you are using the digital version of this book, we advise you to type the code yourself or access the code from the book’s GitHub repository (a link is available in the next section). Doing so will help you avoid any potential errors related to the copying and pasting of code.

The full source code for the examples is available from the book’s GitHub repository (a link is available in the next section). The chapters in the book contain only excerpts from the code, covering the important parts.

Download the example code files

You can download the example code files for this book from GitHub at https://github.com/PacktPublishing/Cpp-Game-Animation-Programming-Second-Edition. If there’s an update to the code, it will be updated in the GitHub repository.

We also have other code bundles from our rich catalog of books and videos available at...

Über Autor(innen)

Dunsky Michael :

Michael Dunsky is an educated electronics technician, game developer, and console porting programmer with more than 20 years of programming experience. He started at the age of 14 with BASIC, adding along the way Assembly language, C, C++, Java, Python, VHDL, OpenGL, GLSL, and Vulkan to his portfolio. During his career, he has also gained extensive knowledge of virtual machines, server operation, infrastructure automation, and other DevOps topics. Michael holds a master of science degree in computer science from the Fern University in Hagen, focusing on computer graphics, parallel programming, and software systems.Szauer Gabor :

Gabor Szauer has been making games since 2010. He graduated from Full Sail University in 2010 with a bachelor's degree in game development. Gabor maintains an active Twitter presence, and maintains a programming-oriented game development blog. Gabor's previously published books are Game Physics Programming Cookbook and Lua Quick Start Guide, both published by Packt.