3D Animation and Rigging — Skinning, Blending and Inverse Kinematics

import numpy as np

class Bone:
    def __init__(self, name, parent=None):
        self.name = name
        self.parent = parent
        self.children = []
        self.local_transform = np.eye(4)  # Relative to parent
        self.world_transform = np.eye(4)  # Final transform
        self.inverse_bind_pose = np.eye(4)  # Bind pose inverse

    def get_world_transform(self):
        if self.parent is None:
            return self.local_transform
        return self.parent.get_world_transform() @ self.local_transform

# Build a simple skeleton
root = Bone("hips")
spine = Bone("spine", root)
neck = Bone("neck", spine)
head = Bone("head", neck)
left_arm = Bone("left_arm", spine)
left_forearm = Bone("left_forearm", left_arm)
left_hand = Bone("left_hand", left_forearm)

class SkinnedMesh:
    def __init__(self, vertices, bones):
        self.vertices = np.array(vertices)  # Rest pose vertices
        self.bones = bones
        # Each vertex has up to 4 bone influences
        self.bone_indices = np.zeros((len(vertices), 4), dtype=int)
        self.bone_weights = np.zeros((len(vertices), 4))

    def deform(self, bone_matrices):
        """Compute deformed vertex positions."""
        deformed = np.zeros_like(self.vertices)
        for i, vert in enumerate(self.vertices):
            pos = np.append(vert, 1.0)
            deformed_pos = np.zeros(4)
            for j in range(4):
                if self.bone_weights[i, j] > 0:
                    bone_idx = self.bone_indices[i, j]
                    weight = self.bone_weights[i, j]
                    # Transform from bind pose to current pose
                    bind = self.bones[bone_idx].inverse_bind_pose
                    current = bone_matrices[bone_idx]
                    deformed_pos += weight * (current @ bind @ pos)
            deformed[i] = deformed_pos[:3]
        return deformed

// Vertex shader for GPU skinning
#version 330 core

const int MAX_BONES = 128;
uniform mat4 boneMatrices[MAX_BONES];

layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;
layout (location = 2) in vec2 aTexCoord;
layout (location = 3) in ivec4 aBoneIDs;
layout (location = 4) in vec4 aWeights;

void main()
{
    mat4 skinTransform = boneMatrices[aBoneIDs[0]] * aWeights[0]
                       + boneMatrices[aBoneIDs[1]] * aWeights[1]
                       + boneMatrices[aBoneIDs[2]] * aWeights[2]
                       + boneMatrices[aBoneIDs[3]] * aWeights[3];

    vec4 worldPos = model * skinTransform * vec4(aPos, 1.0);
    gl_Position = projection * view * worldPos;
}

class Keyframe:
    def __init__(self, time, bone_transforms):
        self.time = time          # Seconds
        self.bone_transforms = bone_transforms  # List of transforms per bone

class AnimationClip:
    def __init__(self, name, duration, keyframes):
        self.name = name
        self.duration = duration
        self.keyframes = keyframes

    def sample(self, time):
        """Interpolate bone transforms at a given time."""
        time = time % self.duration
        for i in range(len(self.keyframes) - 1):
            if self.keyframes[i + 1].time >= time:
                t0 = self.keyframes[i].time
                t1 = self.keyframes[i + 1].time
                blend = (time - t0) / (t1 - t0)
                # Interpolate each bone transform
                blended = []
                for j in range(len(self.keyframes[i].bone_transforms)):
                    mat = lerp_matrix(
                        self.keyframes[i].bone_transforms[j],
                        self.keyframes[i + 1].bone_transforms[j],
                        blend
                    )
                    blended.append(mat)
                return blended
        return self.keyframes[-1].bone_transforms

def blend_animations(anim_a, anim_b, blend_factor):
    """Cross-fade between two animation poses."""
    blended = []
    for bone_a, bone_b in zip(anim_a, anim_b):
        mat = lerp_matrix(bone_a, bone_b, blend_factor)
        blended.append(mat)
    return blended

# Example: blend walk -> run
walk_pose = walk_clip.sample(1.5)
run_pose = run_clip.sample(1.5)
blended = blend_animations(walk_pose, run_pose, 0.3)

def ccd_ik(chain, target, max_iterations=20, tolerance=0.01):
    """Cyclic Coordinate Descent IK solver."""
    for iteration in range(max_iterations):
        end_effector = chain[-1].get_world_transform()[:3, 3]
        error = np.linalg.norm(target - end_effector)
        if error < tolerance:
            return True

        # Iterate joints from end to root
        for i in range(len(chain) - 2, -1, -1):
            joint_pos = chain[i].get_world_transform()[:3, 3]
            joint_to_end = end_effector - joint_pos
            joint_to_target = target - joint_pos

            if np.linalg.norm(joint_to_end) < 0.001:
                continue

            # Compute rotation to align
            cross = np.cross(joint_to_end, joint_to_target)
            sin_theta = np.linalg.norm(cross)
            cos_theta = np.dot(joint_to_end, joint_to_target)
            if sin_theta < 0.001:
                continue

            axis = cross / sin_theta
            angle = np.arctan2(sin_theta, cos_theta)

            rotation = rotation_matrix(axis, angle * 0.5)
            chain[i].local_transform = chain[i].local_transform @ rotation

            end_effector = chain[-1].get_world_transform()[:3, 3]
    return False