Skeletal Animation Systems in C++

Skeletal animation is a popular technique used in computer graphics and game development to animate characters or objects. It separates the motion of a character’s bones from the character’s mesh (or skin). This method allows for more efficient animation, reusability of motion data, and the ability to blend multiple animations seamlessly.

In C++, skeletal animation systems are typically built using a combination of 3D math (to handle transformations, rotations, etc.), object-oriented design (for flexibility), and rendering techniques (using graphics libraries such as OpenGL or DirectX). Let’s explore the key concepts involved in creating a skeletal animation system in C++.

Key Concepts of Skeletal Animation

1. Skeleton Structure

A skeleton in skeletal animation is typically made up of a series of interconnected bones. Each bone may represent a part of a character’s body, such as the arms, legs, and spine. The hierarchy of bones determines the parent-child relationships between bones. For example, the hand is a child of the forearm, and the forearm is a child of the upper arm. The rotation and position of one bone can influence its children.

2. Skinning

Skinning is the process of attaching a mesh (the 3D model) to the skeleton. Each vertex of the mesh is weighted to one or more bones. This determines how the mesh deforms when the skeleton moves. The two most common types of skinning are:

• Rigid Skinning: Each vertex is attached to a single bone. When the bone moves, the attached vertex moves rigidly with it.

• Smooth Skinning (Linear Blend Skinning): Each vertex can be influenced by multiple bones, with each bone contributing a weight to the vertex. This results in smoother transitions and deformations.

3. Animation Data

Animation data is a sequence of keyframes that specify the position, rotation, and scale of each bone in the skeleton at specific times. These keyframes can be interpolated to create fluid animations between them.

4. Bone Transformations

Each bone in the skeleton has a transformation (position, rotation, and scale) relative to its parent bone. When animating a skeleton, we need to calculate the transformations of each bone at every frame, combining their local transformations with the transformations of parent bones.

Steps to Build a Skeletal Animation System in C++

1. Define the Bone Structure

Each bone in a skeletal animation system needs to store information about its position, rotation, scale, and its relationship with parent bones.

cpp
CopyEdit
struct Bone {
    std::string name;
    glm::mat4 transformation; // The bone's transformation matrix (position, rotation, scale)
    glm::mat4 localTransformation; // Local transformation relative to the parent
    Bone* parent;
    std::vector<Bone*> children;

    Bone(std::string boneName) : name(boneName), parent(nullptr) {}
    
    void addChild(Bone* child) {
        children.push_back(child);
        child->parent = this;
    }
};

In the example above, glm::mat4 is a 4×4 matrix (from the GLM math library) that represents the bone’s transformation, allowing for efficient transformations. The Bone structure also tracks its parent and child bones for easy traversal of the hierarchy.

2. Load and Parse Animation Data

Animation data is often stored in a file format (like FBX or glTF), and the system must load and parse this data to extract the keyframes for each bone.

For simplicity, let’s assume the animation data consists of a list of keyframes for each bone, with position and rotation values. A keyframe represents a point in time with the bone’s position, rotation, and scale.

cpp
CopyEdit
struct Keyframe {
    float time;
    glm::vec3 position;
    glm::quat rotation;
    glm::vec3 scale;
};

struct Animation {
    std::string name;
    std::vector<Keyframe> keyframes;

    Keyframe getKeyframeAtTime(float time) {
        // Linear interpolation to find keyframe at the specified time
        // Simplified version
        return keyframes[0]; // Placeholder
    }
};

The Animation structure stores keyframes and allows you to retrieve the keyframe closest to a given time.

3. Bone Transformation Computation

To animate the bones, we need to compute each bone’s transformation based on the animation data. Each bone’s transformation is influenced by its parent’s transformation and the keyframe data.

cpp
CopyEdit
glm::mat4 computeBoneTransformation(Bone* bone, float time) {
    // Get the keyframe data for the bone
    Keyframe keyframe = animation.getKeyframeAtTime(time);

    // Compute local transformation matrix for the bone (position, rotation, scale)
    glm::mat4 localTransform = glm::translate(glm::mat4(1.0f), keyframe.position);
    localTransform = localTransform * glm::mat4_cast(keyframe.rotation);
    localTransform = glm::scale(localTransform, keyframe.scale);

    // Combine with parent's transformation (if there is a parent)
    if (bone->parent != nullptr) {
        return bone->parent->transformation * localTransform;
    } else {
        return localTransform; // If the bone has no parent, it's the root
    }
}

Here, we use glm::mat4_cast to convert the quaternion rotation into a transformation matrix. The matrix is then combined with the parent’s transformation matrix (if it exists).

4. Skinning the Mesh

To apply the bone transformations to the mesh, we need to compute the final vertex positions based on the bone weights for each vertex.

cpp
CopyEdit
struct Vertex {
    glm::vec3 position;
    std::vector<std::pair<Bone*, float>> boneWeights; // List of bone and associated weight
};

void applySkinning(std::vector<Vertex>& vertices) {
    for (auto& vertex : vertices) {
        glm::vec3 finalPosition(0.0f, 0.0f, 0.0f);
        for (auto& boneWeight : vertex.boneWeights) {
            Bone* bone = boneWeight.first;
            float weight = boneWeight.second;
            glm::mat4 boneTransformation = computeBoneTransformation(bone, time);
            finalPosition += weight * glm::vec3(boneTransformation * glm::vec4(vertex.position, 1.0f));
        }
        vertex.position = finalPosition;
    }
}

Here, each vertex has a list of bones that influence it, along with their respective weights. For each vertex, the skinning process applies the transformations from each bone, weighted accordingly, and updates the vertex position.

5. Animating the Skeleton

To animate the skeleton, we need to update the bone transformations every frame and apply the skinning process to the mesh.

cpp
CopyEdit
void updateSkeleton(float deltaTime) {
    // Update animation time and compute transformations for all bones
    time += deltaTime;
    for (auto& bone : skeleton) {
        bone->transformation = computeBoneTransformation(bone, time);
    }

    // Apply skinning to mesh
    applySkinning(meshVertices);
}

This function updates the animation time and computes the transformations for each bone. Afterward, it applies skinning to the mesh to update the vertex positions.

Conclusion

Building a skeletal animation system in C++ requires handling bone hierarchies, animation data, skinning, and matrix transformations. By separating the mesh (skin) from the bones (skeleton), skeletal animation makes it easy to reuse animations and create smooth, flexible character movements. With libraries like GLM for math and animation data in formats like FBX or glTF, you can create a powerful and efficient skeletal animation system in C++.