13

Implementing Inverse Kinematics

Welcome to Chapter 13! In the previous chapter, the user interface was modified to a much cleaner state by adding new types of controls. We will use the new combo boxes and radio buttons in this chapter too, allowing fine-grained control of the parameters of the new algorithms.

In this chapter, we will deep dive into an advanced technique for more natural-looking animations. Being able to easily move the hand or foot of the animated character to a specific point in space helps to create better animations, without us having to precalculate every possible motion and store them in animation clips.

First, we will clarify what Inverse Kinematics is and how it differs from the motion of the bones we used in the previous chapters. Then, we will explore the basics of the Cyclic Coordinate Descent algorithm (CCD) and add a solver class by implementing CCD.

At the end of the chapter, we will look at the Forward and Backward Reaching Inverse Kinematics...

Technical requirements

For this chapter, you will need the OpenGL and Vulkan renderer code from Chapter 12.

What is Inverse Kinematics, and why do we need it?

The word “kinematics” is defined as the mechanics behind the motion of an object but without referencing the forces that cause this motion. So, every part of our daily motion can be described, in kinematic terms, as the movement of our bones.

The two types of Kinematics

If we look at the character animations in Chapters 10–12, the kinematics definition also holds true. The type of animation of our character is called Forward Kinematics. An example of Forward Kinematics is shown in Figure 13.1:

Figure 13.1: Raising the hand of the simple skeleton by using Forward Kinematics

The skeleton in Figure 13.1 raises its simplified hand by rotating the arm at the shoulder (1), and the elbow (2).

During the movement or rotation of the skeletal bone, all the other nodes attached to it are also affected. Rotating the arm around the shoulder does not change the elbow or the forearm, as...

Building a CCD solver

CCD is a simple and popular Inverse Kinematics method to solve the motion of nodes to reach a target.

We start with an overview of the CCD algorithm, and after the CCD basics have been explored, we will add a new Inverse Kinematics solver class and enhance the existing classes, enabling the model to use the CCD solver.

Understanding the CCD basics

The basic idea of CCD is to rotate every bone of the skeleton limb in an iterative way to get closer to the target. To explain the steps involved, we will use a simplified robotic arm. A sample CCD iteration is shown in both Figure 13.3 and Figure 13.4:

1. We can see the initial position of the three nodes in Figure 13.3 (1). Here, three bones, the target, and the effector are drawn. The blue node is attached to the ground, and the outer red node is used as the effector.

Figure 13.3: Solving Inverse Kinematics using CCD – part 1

2. Then, we will draw a virtual...

Building a FABRIK solver

The second heuristic Inverse Kinematics solver to explore is FABRIK, the Forward and Backward Reaching Inverse Kinematics solver. FABRIK needs fewer iterations compared to CCD to find a satisfactory solution.

Similar to CCD, we will start with an overview of the FABRIK algorithm. After the basics have been explained, we will update the Inverse Kinematics Solver class, the user interface, and the renderer code to allow the selection of FABRIK as a second Inverse Kinematics solver.

Understanding the FABRIK basics

While CCD rotates the bones around the nodes to align the effector with the target, FABRIK moves and scales the bones to make the effector reach the target. Also, FABRIK moves along the chain of bones in two directions, forward and backward, hence its name.

Let us use the same simple robotics arm covered in the Understanding the CCD Basics section; the steps for a single iteration are shown in Figures 13.6 to 13.9. We can see the same initial...

Summary

In this chapter, we added Inverse Kinematics with the two algorithms, CCD and FABRIK. Both algorithms solve the problem of the so-called effector node reaching a target point in a heuristic manner, by rotating (CCD) or moving (FABRIK) the bones closer to the target.

After a general explanation of what Inverse Kinematics is about, we checked the basic function of the CCD algorithm.

Then, we created a solver class that implemented CCD. The new solver class required changes to the user interface to enable control of parameters, such as the number of iterations for the Inverse Kinematics algorithm, the position of the target, or the part of the skeleton that will be changed by the Inverse Kinematics solver.

Finally, we added the FABRIK algorithm to the solver class and extended the user interface, enabling us to switch the Inverse Kinematics solving between CCD and FABRIK.

In the following chapter, we will increase the number of glTF models on the screen. While we will...

Practical sessions

You can try out these ideas to get a better understanding of Inverse Kinematics:

• Create a new text field in the UserInterface class to signal whether the Inverse Kinematics algorithm was successful. We previously created the two solving algorithms to return true if the target was reached, or false if reaching the target failed.
• Advanced difficulty: The two algorithms CCD and FABRIK can be extended by so-called constraints. This means you limit the amount of rotation for every node to mimic the behavior of a natural joint, such as the knee or the shoulder. Try to add some of those limits to the nodes, such as a minimum and a maximum angle for one or more of the rotational angles, and check how many iterations a constrained algorithm needs until the target reaches the effector, compared to the original algorithm.
• Advanced difficulty: Add the textured crate back to the screen, and implement a simple collision detection between the sides of the crate...

Additional resources

• An introduction to std::weak_ptr: https://en.cppreference.com/w/cpp/memory/weak_ptr
• An introduction to the Jacobian matrix: https://medium.com/unity3danimation/overview-of-jacobian-ik-a33939639ab2
• A CCD original paper: https://core.ac.uk/download/pdf/82473611.pdf
• CCD with constraints: https://diglib.eg.org/handle/10.2312/egt.20071063.173-243
• A FABRIK original paper: https://dl.acm.org/doi/10.1016/j.gmod.2011.05.003
• FABRIK with constraints: http://andreasaristidou.com/publications/papers/Extending_FABRIK_with_Model_C%CE%BFnstraints.pdf
• The Möller–Trumbore algorithm for intersection checks: http://www.lighthouse3d.com/tutorials/maths/ray-triangle-intersection/