Procedurally Animated Creatures using FABRIK

Foreword

This article will explore the techniques and theory behind procedural animation and creating code based animations for games. Inspiration was drawn from creators such as Codeer and Makan Gilani as well as the Unity Prototype Series.

Table of contents

1. Animating the limbs
   1. Basic concepts
      • Chain concepts
   2. Forward & Inverse Kinematics
   3. Algorithms for Inverse Kinematics
      • CCD
      • FABRIK
   4. Poletargets
2. Procedural walking
   1. Simple controller
   2. Adding limbs
   3. Stepping
      • When to step
      • Step pattern
      • Step height
3. Results
4. Future
5. Sources

Did you like it?

Another creature made using only Procedural Animation
with a focus on 3D Navigation. We call it the Tetrad.

Big Stuff Coming Soon👀👀

🧬Follow us here for more🧬: @SynthSelection#madewithunity #unity #indiegamedev #gamedev #indiedev #SyntheticSelection pic.twitter.com/FatzMuyyc6

— Makan Gilani (@Makan_Gilani) October 28, 2020

Procedural animation in 10 steps#madewithunity #unitytips #unity3d #gamedev #indiedev pic.twitter.com/nhbwIm5OV1

— Codeer (@CodeerDev) March 28, 2020

To be able to understand how the limbs are going to be moved, it’s important to first list and understand the different parts of the limb that will have to be dealt with. From here on limbs will be referred to as a ‘chain’ since we will treat it as a chain of bones. A chain consists of all the components spanning from its root (1) to its effector (3).

Chain concepts (Figure 1.)

1. Root: The base of the chain; its position will be fixed to the body of the creature. Also the first joint in the chain. (1.)
2. Joint: The start (or end) of a bone, also the point where the chain can kink/bend. (2a & b.)
3. Effector: The end of the chain; its position will be able to move around and follow a target. Also the final joint in the chain. (3.)
4. Bone: The length between two successive joints, this length is constant. (4a, b & c.)
5. Ancestor: All joints further up the chain in the direction of the root. (for example; 2a‘s sole ancestor is the root, while 2b‘s ancestors are both 2a and the root.)
6. Descendant: All joints further down the chain in the direction of the effector. (for example; 2a‘s descendants are both 2b and the effector, while 2b‘s sole descendant is the effector.)
7. Parent: A joint’s direct ancestor.
8. Child: A joint’s direct descendant.

Cyclic Coordinate Descent or CCD is an algorithm that iteratively rotates all joints in a chain to move the effector closer to the target. The algorithm loops through all joints, excluding the effector, from the joint furthest down in the chain to the root.
Step 1: For each joint two vectors are calculated (a):

• The vector between the joint’s position and the effector
• The vector between the joint’s position and the target

Step 2: Using these vectors a rotation is calculated to get the joint as close to the target as possible. This rotation is then applied to the joint (b, c & d).

When all the joints in the chain have been rotated the algorithm has finished one iteration. If the effector is not close enough to the target the algorithm will repeat (e & f) untileffector is close enough to the target or the maximum amount of iterations has been reached.

One of the disadvantages of CCD is that it’s fairly biased towards the end of the chain. This can result in the chain being positioned in unnatural looking poses.

Forward and Backward Reaching Kinematics or FABRIK propagates through the joints in the chain twice per iteration; first it moves from the effector to the root (forward) and then from the root to the effector (backward).

Step 0: In the example (figure 2.) we start out with the original chain (a) and the target t.

Step 1: During the forward pass the position of the chain’s effector will be set to the target position (b). After which the joint’s ancestor’s new positions will be calculated.

Step 2: To calculate this new position the vector between the joints child’s position and it’s old position will be normalized to represent the direction the new position will be in. This normalized vector will be multiplied by the corresponding bone’s length to find the new position (c).

Step 3: Now we repeat step 2 for all joints up to and including the root (d). A problem arises here as the root, which position should stay the same, has moved. To fix this we will now repeat the process we just executed in reverse.

Step 4: To start the backward pass the position of the root wil be returned to it’s original position (e).

Step 5: To finish the iteration step 2 will be executed in reverse by using the joint’s child instead of parent to calculate the vector that represents the direction of the new joint position (f).

To move the creature we’ll start out by creating a base controller. The only functionality this controller has is updating the input and translating this to movement. We take the vertical input (up & down arrow keys) and use this to determine a forward velocity and the horizontal input (left & right arrow keys) to rotate the creature left and right. Using a simple cube as the creature’s body we can fly around.

protected virtual void Move(InputData input)
{
    float forwardVelocity = input.zAxisInput * movementSpeed * Time.fixedDeltaTime;
    float rotationVelocity = input.xAxisInput * rotationSpeed * Time.fixedDeltaTime;
    Quaternion newRotation = Quaternion.Euler(0, rotationVelocity, 0) * transform.rotation;
 
    transform.position += transform.forward * forwardVelocity;
    transform.rotation = newRotation;
}

While this simple controller is perfect for moving the body over flat surfaces, it doesn’t follow terrain that has dips or bumps. To make sure the creature sticks to the surface it’s traversing we will update its height and rotation based on the terrain directly below it.

Physics.Raycast(transform.position, Vector3.down, out RaycastHit hit, 5f, groudLayer);
Vector3 newPosition = hit.point + Vector3.up * height;
Quaternion newRotation = Quaternion.FromToRotation(transform.up, hit.normal);
newRotation *= transform.rotation;
 
transform.position = Vector3.MoveTowards(transform.position, newPosition, Time.deltaTime);
transform.rotation = Quaternion.Slerp(transform.rotation, newRotation, Time.deltaTime);

2.2. Adding limbs

Now it’s time to create a limb for the creature. Let’s start by creating a chain of joints with the root attached to the base controller and the effector planted on the floor. As you can see the chain readjusts whenever the main body moves.

2.3. Stepping

Now that we have added limbs we’ll have to start moving them. Using the IK algorithm we can make them follow a target, but we still need to move this target to make the creature walk. While moving the target should be easy, we still have to tackle the problems of when to move, which limb’s target to move and how to move the target.

Physics.Raycast(projectionOrigin, -transform.up, out RaycastHit hit, 5f, groundLayer);
Vector3 projectedStep = hit.point;

When to step

There’s a lot of ways we coud go about choosing when to make the creature step. The one I used for this prototype is to predict the step for each of the creature’s steps and to start the step whenever the distance between this predicted position and the creature’s foot’s position is a certain length. Predicting the step is done by casting a ray down from the ‘neutral’ foot position and taking the point where this ray collides with the surface the creature is walking on.

Step pattern

Moving both legs on the same side of the creature at the same time would look unnatural. To fix this we should make sure only one of the legs on each side of the creature are moving at any given time. This can be done by tracking which legs are moving and on which side of the creature they are located.

The creatures feet (the chains effector) are moving towards their targets but these steps are still looking unnatural. Right now the feet are dragging along the floor to their new position instead of moving there in an arch. To achieve this we will use the shape of the first half of a sine wave. To calculate this we need 3 values:

• The starting position of the step
• The end position of the step
• The current position of the effector

Using these 3 values we can calculate how far along the step we are by comparing the distance between the starting position and the end position (while ignoring their height) to the distance between the current position and the end position. Using the InverseLerp function we get a value that tells us how far along the step we are. With this value we can calculate where we are along the first half of the sine wave by taking the sine of Pi multiplied by the stepprogress. We can now multiply this value by the height we want the step to reach at its maximum and add this value to the step. When the stepprogress gets close enough to one or the target reaches close enough to the new position it will stop moving.

Combining the procedural animation with other systems, such as a system that makes different body segments follow each other, is also a possiblity. Shown below is an example of one such creature.

4. Future

Expanding upon the prototype created during this research I would like to create a more complete framework for procedural animation. Some features that would be interesting to explore further:

• Body height & rotation based on the creatures feet
• Being able to walk on steep incline/decline terrain and traversing terrain with 90+ degree angles
• Procedurally generating animations other than walking/moving
• Animating rigged 3D models