book

C++ Game Animation Programming - Second Edition

Name: C++ Game Animation Programming - Second Edition
ISBN: 9781803246529

by Michael Dunsky, Gabor Szauer

December 2023

Intermediate to advanced

480 pages

11h 55m

English

Packt Publishing

Read now

Unlock full access

C++ Game Animation Programming
ContributorsAbout the authorsAbout the reviewers
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Part 1:Building a Graphics Renderer
Chapter 1: Creating the Game Window
Technical requirementsGetting the source code and the basic toolsCode organization in this bookThe basic code for our applicationNULL versus nullptrCreating your first windowAdding support for OpenGL or Vulkan to the windowGLFW and OpenGLGLFW and VulkanEvent handling in GLFWThe GLFW event queue handlingMixing the C++ classes and the C callbacksThe mouse and keyboard input for the game windowKey code, scan code, and modifiersDifferent styles of mouse movementSummaryPractical sessionsAdditional resources
Chapter 2: Building an OpenGL 4 Renderer
Technical requirementsThe rendering pipeline of OpenGL 4Basic elements of the OpenGL 4 rendererThe OpenGL loader generator GladAnatomy of the OpenGL rendererThe main OpenGL classBuffer types for the OpenGL rendererLoading and compiling shadersVertex and fragment shadersCreating our shader loaderCreating the simple Model classGetting an image for the textureSummaryPractical sessionsAdditional resources
Chapter 3: Building a Vulkan Renderer
Technical requirementsBasic anatomy of a Vulkan applicationDifferences and similarities between OpenGL 4 and VulkanTechnical similaritiesDifferencesUsing helper libraries for VulkanInitializing Vulkan via vk-bootstrapMemory management with VMAFitting the Vulkan nuts and bolts togetherGeneral considerations about classesChanges in the Window classPassing around the VkRenderData structureVulkan object initialization structsRequired changes to the shadersDrawing the triangles on the screenDifferences and similarities between OpenGL and Vulkan, reprisedSummaryPractical sessionsAdditional resources
Chapter 4: Working with Shaders
Technical requirementsShader basicsGLM, the OpenGL Mathematics libraryGLM data types and basic operationsGLM transformationsVertex data transfer to the GPUSwitching shaders at runtimeCreating a new set of shadersBinding the shader switching to a keyThe shader switch in the draw callShader switching in VulkanSending additional data to the GPUUsing uniform buffers to upload constant dataCreating a uniform bufferShader changes to use the data in the bufferPreparing and uploading dataUsing uniform buffers in VulkanUsing push constants in VulkanSummaryPractical sessionsAdditional resources
Chapter 5: Adding Dear ImGui to Show Valuable Information
Technical requirementsWhat is Dear ImGui?Adding ImGui to the OpenGL and Vulkan renderersAdding the headers to the OpenGL rendererAdding the headers to the Vulkan rendererCMake adjustments needed for ImGuiMoving the shared data to the OGLRenderData headerCreating the UserInterface classAdding the implementation of the UserInterface classAdding the UserInterface class to the OpenGL rendererCreating an FPS counterUsing GLFW as a simple timerAdding the values to the user interfaceTiming sections of your code and showing the resultsAdding the Timer classIntegrating the new Timer class into the rendererAdding UI elements to control the applicationAdding a checkboxAdding a button to switch between the shadersAdding a slider to control the field of viewSummaryPractical sessionsAdditional resources
Part 2: Mathematics Roundup
Chapter 6: Understanding Vector and Matrix
Technical requirementsA review of the vector and its operationsRepresentations of vectorsAdding and subtracting vectorsCalculating the length of a vectorZero and unit vectorsVector normalizationVector multiplicationA review of the matrix and its operationsMatrix representationNull matrix and identity matrixMatrix addition and subtractionMatrix multiplicationTransposed and inverse matricesMatrix/vector multiplicationAdding a camera to the rendererCreating the new Camera classIntegrating the new camera into the Renderer classImplementing mouse control in the Window classShowing the camera values in the user interfaceAdding camera movementUsing new variables to change the camera positionMoving the camera aroundAdding the camera position to the user interfaceSummaryPractical sessionsAdditional resources

Chapter 7: A Primer on Quaternions and Splines
Technical requirementsWhat are quaternions?Imaginary and complex numbersThe discovery of the quaternionCreating a quaternionQuaternion operations and transformationsExploring vector rotationThe Euler rotationsThe gimbal lockRotating using quaternionsIncremental rotationsUsing quaternions for smooth rotationsA quick take on splinesConstructing a Hermite splineSpline continuityHermite polynomialsCombining quaternions and splinesSummaryPractical sessionsAdditional resources
Part 3: Working with Models and Animations
Chapter 8: Loading Models in the glTF Format
Technical requirementsAn analysis of the glTF file formatExploring an example glTF fileUnderstanding the scenes elementFinding the nodes and meshesDecoding the raw data in the buffers elementUnderstanding the accessor elementTranslating data using the buffer viewsChecking the glTF version in the asset elementUsing a C++ glTF loader to get the model dataAdding new glTF shadersOrganizing the loaded data into a C++ classLearning about the design and implementation of the C++ classAdding the new model class to the rendererAdding the glTF loader and model to the Vulkan rendererSummaryPractical sessionsAdditional resources
Chapter 9: The Model Skeleton and Skin
Technical requirementsThese skeletons are not spookyWhy do we create a node tree of the skeleton?Adding the node classFilling the skeleton tree in the Gltf model classThe inverse bind matrices and the binding poseHow (not) to apply a skin to a skeletonNaive model skinningVertex skinning in glTFConnecting joints and nodesJoints and weights for the verticesCreating the joint transformation matricesApplying vertex skinningImplementing GPU-based skinningMoving the joints and weights to the vertex shaderGetting rid of the UBO fixed array sizeIdentifying linear skinning problemsThe dual quaternionUsing dual quaternions as data storageDual quaternions in GLMAdding dual quaternions to the glTF modelAdding a dual quaternion shaderAdjusting the rendererSummaryPractical sessionsAdditional resources
Chapter 10: About Poses, Frames, and Clips
Technical requirementsA brief overview of animationsWhat is a pose and how do we represent it?From a single frame to an entire animation clipPouring the knowledge into C++ classesStoring the channel data in a classAdding the class for the animation clipsLoading the animation data from the glTF model fileAdding new control variables for the animationsManaging the animations in the user interfaceAdding the animation replay to the rendererSummaryPractical sessionsAdditional resources
Chapter 11: Blending between Animations
Technical requirementsDoes it blend?Fading animation clips in and outCrossfading between animation clipsAdding multiple animation clips into one clipBlending between the binding pose and animation clipEnhancing the node classUpdating the model classAdding the blend to the animation clip classImplementing animation blending in the OpenGL rendererCrossfading animationsUpgrading the model classesAdjusting the OpenGL rendererAdding new controls to the user interfaceHow to do additive blendingSplitting the node skeleton – part ISplitting the node skeleton – part IIUpdating the animation clip classFinalizing additive blending in the OpenGL rendererExposing the additive blending parameters in the user interfaceSummaryPractical sessions
Part 4: Advancing Your Code to the Next Level
Chapter 12: Cleaning Up the User Interface
Technical requirementsUI controls are coolCreating combo boxes and radio buttonsImplementing a combo box the C++ waySwapping the data typesFilling the arrays for the combo boxesFine-tuning selections with radio buttonsAdjusting the renderer codeUpdating the model classSwitching the control elements in the user interfaceDrawing time series with ImGuiOne ring buffer to rule them allCreating plots in ImGuiAdding plots to the user interfacePopping up a tooltip with the plotThe sky is the limitSummaryPractical sessionsAdditional resources
Chapter 13: Implementing Inverse Kinematics
Technical requirementsWhat is Inverse Kinematics, and why do we need it?The two types of KinematicsChoosing a path to reach the targetBuilding a CCD solverUnderstanding the CCD basicsUpdating the code of the node classUpdating the model classOutlining the new solver classImplementing the Inverse Kinematics solver class and the CCD solverAdding Inverse Kinematics to the rendererExtending the user interfaceBuilding a FABRIK solverUnderstanding the FABRIK basicsAdding the methods for the FABRIK algorithmImplementing the FABRIK solving methodsCompleting the FABRIK solverUpdating the rendererAllowing the selection of FABRIK in the user interfaceSummaryPractical sessionsAdditional resources
Chapter 14: Creating Instanced Crowds
Technical requirementsSplitting the model class into two partsDeciding which data to keep in the model classCollecting the data to moveAdding a new ModelSettings struct to store the instance dataAdjusting the OGLRenderData structCutting the model class into two piecesImplementing the logic in the new instance classEnhancing the shader codePreparing the renderer classChanging the renderer to create and manage instancesDisplaying the instance data in the user interfaceWhat about Vulkan?The need for application speedRendering instances of different modelsUsing GPU instancing to reduce data transfersChanging the model class to use instanced drawingFiring the turbo boost in the rendererTextures are not just for picturesYABT – Yet Another Buffer TypeUpdating the vertex shader one last timeSummaryPractical sessionsAdditional resources
Chapter 15: Measuring Performance and Optimizing the Code
Technical requirementsMeasure twice, cut once!Always measure before you take actionsThree steps of code optimizationAvoid premature optimizationsMoving computations to different placesRecalculate only when necessaryUtilize compile time over runtimeConvert your data as soon as possibleSplit the calculations into multiple threadsUse compute shaders on your graphics cardProfiling the code to find hotspotsProfiling code using Visual StudioProfiling code using GCC or Clang on LinuxProfiling code using EclipseAnalyzing the code and planning the optimizationsPromoting the local matrices to member variablesMoving the matrix calculationsFixing the getNodeMatrix() methodRe-profiling the applicationUsing RenderDoc to analyze a GPU frameDownloading and installing RenderDocAnalyzing frames of an applicationComparing the results of different versions of our applicationScale it up and do A/B testsScale up to get better resultsMake one change at a time and profile againSummaryPractical sessionsAdditional resources
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youDownload a free PDF copy of this book

Overview

Embark on a journey to master the intricacies of game animation by delving into this comprehensive guide on C++ Game Animation Programming. Explore modern animation techniques including the use of OpenGL and Vulkan, and gain in-depth insight into how characters are animated and brought to life in video games.

What this Book will help me do

Learn to create efficient C++ applications integrating OpenGL and Vulkan for game animation.
Understand and manipulate the glTF file format for model data representation and animation.
Design and implement animation systems with advanced concepts like skeletons, clips, and skinning.
Develop skills in handling key mathematical tools such as vectors, matrices, and quaternions for animations.
Master blending animations and applying inverse kinematics for smooth and realistic character movements.

Author(s)

Michael Dunsky and Gabor Szauer are expert programmers and authors specializing in game development and animation technologies. With strong backgrounds in C++ programming and GPU-accelerated graphics, they are passionate about demystifying game animation. Their writing emphasizes clear explanations and practical implementations, all aimed at equipping aspiring game developers with the skills they need.

Who is it for?

This book is ideal for game developers, C++ programmers, and aspiring animators who wish to deepen their knowledge of advanced game animation techniques. If you are proficient in C programming and possess a basic understanding of mathematics, this book will guide you in mastering the animation of characters in video games. It's also helpful for game designers curious about the programming behind character animation. Whether you're a professional or a hobbyist, this book delivers the tools and concepts necessary for your growth.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781803246529

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills