1 files changed, 81 insertions, 23 deletions

diff --git a/gfx/src/scene/animation.c b/gfx/src/scene/animation.c
index 18e2a99..08d02ce 100644
--- a/gfx/src/scene/animation.c
+++ b/gfx/src/scene/animation.c
@@ -9,7 +9,7 @@
 
 static const R PLAYBACK_UNINITIALIZED = -1;
 
-static rel_idx get_anima_root_joint_index(Anima* anima) {
+static joint_idx get_anima_root_joint_index(Anima* anima) {
   assert(anima);
   assert(anima->num_joints > 0);
   assert(anima->num_joints < GFX_MAX_NUM_JOINTS);
@@ -21,7 +21,7 @@ static Joint* get_anima_root_joint(Anima* anima) {
   return &anima->joints[get_anima_root_joint_index(anima)];
 }
 
-static Joint* get_anima_joint(Anima* anima, rel_idx index) {
+static const Joint* get_anima_joint(const Anima* anima, joint_idx index) {
   assert(anima);
   assert(index < GFX_MAX_NUM_JOINTS);
   assert(index != INDEX_NONE);
@@ -29,22 +29,33 @@ static Joint* get_anima_joint(Anima* anima, rel_idx index) {
   return &anima->joints[index];
 }
 
+static Joint* get_anima_joint_mut(Anima* anima, joint_idx index) {
+  return (Joint*)get_anima_joint(anima, index);
+}
+
+static const Joint* get_skeleton_joint(
+    const Anima* anima, const Skeleton* skeleton, joint_idx index) {
+  assert(anima);
+  assert(skeleton);
+  return get_anima_joint(anima, skeleton->joints[index]);
+}
+
 static void set_joint_parent(
-    Anima* anima, rel_idx joint_index, rel_idx parent_index) {
+    Anima* anima, joint_idx joint_index, joint_idx parent_index) {
   assert(anima);
   assert(joint_index != INDEX_NONE);
   assert(joint_index != get_anima_root_joint_index(anima));
   assert(parent_index != INDEX_NONE);
 
-  Joint* parent = get_anima_joint(anima, parent_index);
+  Joint* parent = get_anima_joint_mut(anima, parent_index);
 
   if (parent->child == INDEX_NONE) {
     parent->child = joint_index;
   } else {
     // Find the last child in the chain of children.
-    Joint* child = get_anima_joint(anima, parent->child);
+    Joint* child = get_anima_joint_mut(anima, parent->child);
     while (child->next != INDEX_NONE) {
-      child = get_anima_joint(anima, child->next);
+      child = get_anima_joint_mut(anima, child->next);
     }
     // Wire up this joint as the last child's sibling.
     child->next = joint_index;
@@ -64,6 +75,7 @@ static void make_joint(Anima* anima, const JointDesc* desc, Joint* joint) {
   joint->transform       = mat4_id();
   joint->inv_bind_matrix = desc->inv_bind_matrix;
   joint->joint_matrix    = mat4_id();
+  joint->box             = desc->box;
 }
 
 static Skeleton* make_skeleton(const SkeletonDesc* desc) {
@@ -88,6 +100,7 @@ static Animation* make_animation(const AnimationDesc* desc) {
   animation->num_channels = desc->num_channels;
   R start_time            = 0;
   R end_time              = 0;
+
   for (size_t c = 0; c < desc->num_channels; ++c) {
     const ChannelDesc* channel_desc = &desc->channels[c];
     Channel*           channel      = &animation->channels[c];
@@ -110,6 +123,7 @@ static Animation* make_animation(const AnimationDesc* desc) {
       end_time   = keyframe->time > end_time ? keyframe->time : end_time;
     }
   }
+
   // LOGD("Animation start/end: %f / %f", start_time, end_time);
   animation->duration = end_time - start_time;
   assert(animation->duration >= 0);
@@ -122,7 +136,7 @@ Anima* gfx_make_anima(const AnimaDesc* desc) {
   assert(desc->num_joints <= GFX_MAX_NUM_JOINTS);
   // All joints should have a parent except for the root.
   for (size_t i = 0; i < desc->num_joints - 1; ++i) {
-    const rel_idx parent = desc->joints[i].parent;
+    const joint_idx parent = desc->joints[i].parent;
     assert(parent != INDEX_NONE);
     assert(parent < desc->num_joints);
   }
@@ -134,10 +148,7 @@ Anima* gfx_make_anima(const AnimaDesc* desc) {
   // Wire the skeletons in the same order they are given in the descriptor.
   Skeleton* last_skeleton = 0;
   for (size_t i = 0; i < desc->num_skeletons; ++i) {
-    Skeleton* skeleton = make_skeleton(&desc->skeletons[i]);
-    // TODO: Here and everywhere else, I think it would simplify the code
-    // greatly to make mem_alloc_xyz() fail if the allocation fails. At that
-    // point the user should just bump their memory limits.
+    Skeleton*          skeleton       = make_skeleton(&desc->skeletons[i]);
     const skeleton_idx skeleton_index = mem_get_skeleton_index(skeleton);
     if (last_skeleton == 0) {
       anima->skeleton = skeleton_index;
@@ -166,7 +177,7 @@ Anima* gfx_make_anima(const AnimaDesc* desc) {
   // Child and sibling pointers must be initialized before wiring up the
   // hierarchy.
   for (size_t i = 0; i < desc->num_joints; ++i) {
-    Joint* joint = get_anima_joint(anima, i);
+    Joint* joint = get_anima_joint_mut(anima, i);
     make_joint(anima, &desc->joints[i], joint);
   }
   // Wire up joints to their parents. -1 to skip the root.
@@ -339,7 +350,7 @@ static void animate_channel(Anima* anima, const Channel* channel, R t) {
   // work.
   t = t > channel->keyframes[next].time ? channel->keyframes[next].time : t;
 
-  Joint* target = get_anima_joint(anima, channel->target);
+  Joint* target = get_anima_joint_mut(anima, channel->target);
 
   switch (channel->type) {
   case RotationChannel: {
@@ -380,7 +391,7 @@ static void compute_joint_matrices_rec(
 
   // Recursively compute the joint matrices for this joint's siblings.
   if (joint->next != INDEX_NONE) {
-    Joint* sibling = get_anima_joint(anima, joint->next);
+    Joint* sibling = get_anima_joint_mut(anima, joint->next);
 
     compute_joint_matrices_rec(
         anima, sibling, parent_global_joint_transform,
@@ -389,7 +400,7 @@ static void compute_joint_matrices_rec(
 
   // Recursively compute the joint matrices for this joint's children.
   if (joint->child != INDEX_NONE) {
-    Joint* child = get_anima_joint(anima, joint->child);
+    Joint* child = get_anima_joint_mut(anima, joint->child);
 
     compute_joint_matrices_rec(
         anima, child, &global_joint_transform, root_inv_global_transform);
@@ -431,16 +442,14 @@ void gfx_update_animation(Anima* anima, R t) {
 
   // Compute joint matrices after having transformed the skeletons.
   //
-  // Skeletons are not guaranteed to have a common parent, but are generally a
-  // set of disjoint trees (glTF). The anima's parent node, however, is
-  // guaranteed to be the common ancestor of all skeletons.
+  // The anima's parent node is the common ancestor of all skeletons, and its
+  // transform maps the skeletons from object space to world space. This is the
+  // transform used as the "global transform" in the joint matrix equations.
   //
-  // Joint matrix calculation therefore begins by descending from the anima's
-  // node. This node's immediate children may not be joints, however, so we need
-  // to gracefully handle them and proceed recursively.
+  // Joint matrix calculation begins by descending from the anima's root joint,
+  // which we have constructed to be the common root of all skeletons.
   //
-  // Lack of a common parent aside, the procedure touches every joint exactly
-  // once (and potentially other non-joint intermediate nodes).
+  // This procedure touches every joint exactly once.
   SceneNode* root_node = mem_get_node(anima->parent);
   // LOGD("Root: %u, child: %u", anima->parent.val, root->child.val);
   const mat4 root_global_transform = gfx_get_node_global_transform(root_node);
@@ -464,3 +473,52 @@ const Skeleton* gfx_get_anima_skeleton(const Anima* anima, size_t i) {
 
   return skeleton;
 }
+
+size_t gfx_get_skeleton_num_joints(const Skeleton* skeleton) {
+  assert(skeleton);
+  return skeleton->num_joints;
+}
+
+bool gfx_joint_has_box(
+    const Anima* anima, const Skeleton* skeleton, size_t joint_index) {
+  assert(anima);
+  assert(skeleton);
+  assert(joint_index < skeleton->num_joints);
+
+  const Joint* joint = get_skeleton_joint(anima, skeleton, joint_index);
+  return !aabb3_is_empty(joint->box);
+}
+
+Box gfx_get_joint_box(
+    const Anima* anima, const Skeleton* skeleton, size_t joint_index) {
+  assert(anima);
+  assert(skeleton);
+
+  const Joint* joint = get_skeleton_joint(anima, skeleton, joint_index);
+
+  // Transform the box to anima space.
+  // Note that joint matrices do not usually have a translation since joints
+  // mostly just rotate with respect to their parent.
+  const vec3 pmin = joint->box.min;
+  const vec3 pmax = joint->box.max;
+  return (Box){
+      .vertices = {
+                   mat4_mul_vec3(
+                   joint->joint_matrix, vec3_make(pmin.x, pmin.y, pmax.z), 1),
+                   mat4_mul_vec3(
+                   joint->joint_matrix, vec3_make(pmax.x, pmin.y, pmax.z), 1),
+                   mat4_mul_vec3(
+                   joint->joint_matrix, vec3_make(pmax.x, pmax.y, pmax.z), 1),
+                   mat4_mul_vec3(
+                   joint->joint_matrix, vec3_make(pmin.x, pmax.y, pmax.z), 1),
+                   mat4_mul_vec3(
+                   joint->joint_matrix, vec3_make(pmin.x, pmin.y, pmin.z), 1),
+                   mat4_mul_vec3(
+                   joint->joint_matrix, vec3_make(pmax.x, pmin.y, pmin.z), 1),
+                   mat4_mul_vec3(
+                   joint->joint_matrix, vec3_make(pmax.x, pmax.y, pmin.z), 1),
+                   mat4_mul_vec3(
+                   joint->joint_matrix, vec3_make(pmin.x, pmax.y, pmin.z), 1),
+                   }
+  };
+}