For this chapter, you will need the following:

• A PC with Windows or Linux, and the tools listed later in this section
• Git for source-code management
• A text editor (such as Notepad++ or Kate) or a full IDE (such as Visual Studio 2022 for Windows, or Eclipse/KDevelop for Linux)

Now, let’s get the source code for this book and start unpacking the code.

Getting the source code and the basic tools

The code for this book is hosted on GitHub, which you can find here:

https://github.com/PacktPublishing/Mastering-Cpp-Game-Animation-Programming

You need to install Git since the build system utilizes Git to download the third-party projects...

Moving a game character around in a virtual world with lots of different animations, changeable outfits, a collision detection system for other characters and the environment, and maybe even interaction with other characters looks nice and simple when playing a game.

But the mathematics and techniques behind the smoothly animated game characters are extensive and complex. Every movement, animation, action, or state change of the character involves a long journey until the final image is rendered to the screen.

Let’s look at a high-level explanation of animations first. If you already know the details, you can skip to the next section.

About nodes, bones, skeletal animation, and skinning

The building blocks of an animated three-dimensional character model are the so-called nodes. A node can be compared to a joint in the virtual body of the character, like the shoulder or hip.

All nodes in the character model are...

Open Asset Import Library, in short Assimp, is a cross-platform library to import and convert 3D model files. The different file formats are converted into a hierarchical data structure, enabling a programmer to support a wider range of model formats in a single, comprehensive way.

Figure 1.20 shows the key elements and their relationships:

Figure 1.20: A simplified version of Assimp’s data structures

Let us take a closer look at these data structures and their functions:

• aiScene is the central element of Assimp’s data structure. The root node entry, all information about the polygonal meshes, the materials, and the animations are stored in the aiScene element.
• The root node of aiScene points to a structure called aiNode. In every aiNode, possible child nodes are stored, eventually creating a node tree. Also, a transform matrix resides in the aiNode structure, defining the local transformation, relative...

To load a model file with Open Asset Import Library, we must include the following three headers in the implementation file of the AssimpModel model loading class in the model folder:

#include <assimp/scene.h>
#include <assimp/Importer.hpp>
#include <assimp/postprocess.h>

Next, we create an Assimp::Importer instance in the loadModel() method, and use the importer to load a file from disk:

  Assimp::Importer importer;
  const aiScene *scene = importer.ReadFile(modelFilename,
   aiProcess_Triangulate | aiProcess_GenNormals);

We hand over the file name of the asset file we want to load, plus the two values aiProcess_Triangulate and aiProcess_GenNormals as optional postprocessing flags.

The first flag, aiProcess_Triangulate, instructs Assimp to triangulate all polygons with more than three vertices, if those polygons exist in the file. Since our basic renderer only understands triangles, a polygon with more than three vertices...

ImGui can be used to create simple UIs like in our animation application, but the code can be also extended to build different kinds of tools. For our application, a dialog to choose a file on the system is helpful to load models at runtime, freeing us of hardcoding the model names in the code or using models as command-line parameters when starting the application.

Various ImGui-based file dialogs exist; a nice and easy-to-integrate file dialog can be found in the GitHub repository of Stephane Cuillerdier at https://github.com/aiekick/ImGuiFileDialog.

For a simple integration of the file dialog, we will use CMake’s FetchContent to download and build the code.

Integrating the file dialog into CMakeLists.txt

First, we add a new FetchContent block into the CMakeLists.txt file, right below the end of the ImGui fetching:

FetchContent_Declare(
  filedialog
  GIT_REPOSITORY https://github.com/aiekick/ImGuiFileDialog
 ...

Supporting multiple instances from multiple models was done by creating the class AssimpInstance in the model folder. Every AssimpInstance contains a smart pointer to access its base model, including the nodes and bones. Adding multiple instances of the same model requires one of two options to handle nodes and bones: using a copy of the node data structures in every instance or sharing the model’s nodes across all instances.

To avoid the duplication of all nodes in every instance, we will reuse the nodes of the model during the calculation of each final node position for the frame.

Reusing the bones for the sake of simplicity

To calculate the nodes during animation in the updateAnimation() method, we iterate the channels of the clip and use the model’s corresponding node:

  for (const auto& channel : animChannels) {
    std::string nodeNameToAnimate =
      channel->getTargetNodeName();
    std:...

In this chapter, we took the first steps toward mastering C++ game animation programming by using Open Asset Importer Library, or Assimp. Assimp enables us to simplify and accelerate the path to animating and rendering model instances.

We started by looking at the general data structures of the Assimp library, how to parse the different parts of a file, and in which order. Next, we added a nice ImGui-based file dialog to the code, allowing us to select files in an interactive manner, instead of having to hardcode one or more model files we wish to open. At the end of the chapter, we explored how to add or remove models and instances at runtime, enabling us to create a more “crowded” virtual world.

In Chapter 2, we will move the computational load to calculate the model matrices from the CPU to the GPU, allowing us to have more CPU power left to do amazing things in our virtual world.

You will see this section at the end of every chapter in the book. Here, I will add a bunch of suggestions and exercises that you can try out with the code on GitHub.

You could try to do the following:

• Add more controls to the animations, like the play direction, one/time vs. loop play, or even ping-pong replay, alternating between forward and backward replay of the chosen animation.
• Add an animation slider that lets you choose to show the frame at some point in time of an animation.
• Search for model files on the internet. Try out which models work, or to which extent they work. You do not have to limit this search to game character models; you can also search for game maps in compatible formats, or 3D-printable objects. Remember to adjust the file dialog filter to show the additional file formats.

For further reading, please take a look at the following resources:

• Microsoft on path length limit: https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=registry
• Assimp GitHub repository: https://github.com/assimp/assimp
• Assimp documentation: https://assimp-docs.readthedocs.io/en/latest/
• Learn OpenGL section on Assimp: https://learnopengl.com/Model-Loading/Assimp
• Skeletal animation tutorial: https://www.ogldev.org/www/tutorial38/tutorial38.html