1 files changed, 303 insertions, 190 deletions

diff --git a/gfx/src/asset/model.c b/gfx/src/asset/model.c
index 37f129e..2053dc4 100644
--- a/gfx/src/asset/model.c
+++ b/gfx/src/asset/model.c
@@ -94,6 +94,7 @@
 #include "gfx/sizes.h"
 #include "gfx/util/shader.h"
 
+#include "gfx_assert.h"
 #include "scene/model_impl.h"
 
 #include "cstring.h"
@@ -110,7 +111,6 @@
 #define CGLTF_IMPLEMENTATION
 #include "cgltf.h"
 
-#include <assert.h>
 #include <stdbool.h>
 #include <stdlib.h>
 
@@ -323,204 +323,231 @@ static cgltf_size get_component_size(cgltf_component_type type) {
   return 0;
 }
 
+/// Return the number dimensionality of the given data type.
+int get_num_dimensions(cgltf_type type) {
+  switch (type) {
+  case cgltf_type_scalar:
+    return 1;
+  case cgltf_type_vec2:
+    return 2;
+  case cgltf_type_vec3:
+    return 3;
+  case cgltf_type_vec4:
+    return 4;
+  case cgltf_type_mat2:
+    return 4; // 2x2
+  case cgltf_type_mat3:
+    return 9; // 3x3
+  case cgltf_type_mat4:
+    return 16; // 4x4
+  case cgltf_type_invalid:
+    FAIL("");
+    break;
+  }
+  FAIL("");
+  return 0;
+}
+
+/// Read an int64 from the given data pointer and accessor.
+/// The largest integer in glTF is u32, so we can fit all integers in an int64.
+static int64_t read_int(const void* component, const cgltf_accessor* accessor) {
+  assert(component);
+  assert(accessor);
+
+  switch (accessor->component_type) {
+  case cgltf_component_type_r_8: {
+    const int8_t c = *((int8_t*)component);
+    return c;
+  }
+  case cgltf_component_type_r_8u: {
+    const uint8_t c = *((uint8_t*)component);
+    return c;
+  }
+  case cgltf_component_type_r_16: {
+    const int16_t c = *((int16_t*)component);
+    return c;
+  }
+  case cgltf_component_type_r_16u: {
+    const uint16_t c = *((uint16_t*)component);
+    return c;
+  }
+  case cgltf_component_type_r_32u: {
+    const uint32_t c = *((uint32_t*)component);
+    return c;
+  }
+  case cgltf_component_type_r_32f: {
+    const float c = *((float*)component);
+    return (int64_t)c;
+  }
+  case cgltf_component_type_invalid:
+    FAIL("");
+    break;
+  }
+  FAIL("");
+  return 0;
+}
+
 /// Read a float from the given data pointer and accessor.
 ///
 /// This function uses the normalization equations from the spec. See the
 /// animation section:
 ///
 /// https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#animations
-static float read_float(const void* data, const cgltf_accessor* accessor) {
-  assert(data);
+static float read_float(const void* component, const cgltf_accessor* accessor) {
+  assert(component);
   assert(accessor);
 
   switch (accessor->component_type) {
   case cgltf_component_type_r_8: {
-    assert(accessor->normalized);
-    const int8_t c = *((int8_t*)data);
+    // assert(accessor->normalized);
+    const int8_t c = *((int8_t*)component);
     return max((float)c / 127.0, -1.0);
   }
   case cgltf_component_type_r_8u: {
-    assert(accessor->normalized);
-    const uint8_t c = *((uint8_t*)data);
+    // assert(accessor->normalized);
+    const uint8_t c = *((uint8_t*)component);
     return (float)c / 255.0;
   }
   case cgltf_component_type_r_16: {
-    assert(accessor->normalized);
-    const int16_t c = *((int16_t*)data);
+    // assert(accessor->normalized);
+    const int16_t c = *((int16_t*)component);
     return max((float)c / 32767.0, -1.0);
   }
   case cgltf_component_type_r_16u: {
-    assert(accessor->normalized);
-    const uint16_t c = *((uint16_t*)data);
+    // assert(accessor->normalized);
+    const uint16_t c = *((uint16_t*)component);
     return (float)c / 65535.0;
   }
   case cgltf_component_type_r_32u: {
-    assert(accessor->normalized);
-    const uint32_t c = *((uint32_t*)data);
+    // assert(accessor->normalized);
+    const uint32_t c = *((uint32_t*)component);
     return (float)c / 4294967295.0;
   }
   case cgltf_component_type_r_32f: {
-    const float c = *((float*)data);
+    const float c = *((float*)component);
     return c;
   }
   case cgltf_component_type_invalid:
-    assert(false);
+    FAIL("");
     break;
   }
-  assert(false);
+  FAIL("");
   return 0;
 }
 
-/// Iterate over the vectors in an accessor.
-#define ACCESSOR_FOREACH_VEC(dimensions, accessor, body)                       \
-  {                                                                            \
-    assert((1 <= dimensions) && (dimensions <= 4));                            \
-    assert(                                                                    \
-        ((dimensions == 1) && (accessor->type == cgltf_type_scalar)) ||        \
-        ((dimensions == 2) && (accessor->type == cgltf_type_vec2)) ||          \
-        ((dimensions == 3) && (accessor->type == cgltf_type_vec3)) ||          \
-        ((dimensions == 4) && (accessor->type == cgltf_type_vec4)));           \
-    const cgltf_buffer_view* view   = accessor->buffer_view;                   \
-    const cgltf_buffer*      buffer = view->buffer;                            \
-    const cgltf_size         offset = accessor->offset + view->offset;         \
-    const uint8_t*           bytes  = (const uint8_t*)buffer->data + offset;   \
-    /* Component size in bytes. */                                             \
-    const cgltf_size comp_size = get_component_size(accessor->component_type); \
-    /* Element size in bytes. */                                               \
-    const cgltf_size elem_size = dimensions * comp_size;                       \
-    /* Stride in bytes. If the view stride is 0, then the elements are tightly \
-     * packed. */                                                              \
-    const cgltf_size stride = view->stride != 0 ? view->stride : elem_size;    \
-    /* There isn't an accessor stride in the spec, but cgltf still specifies   \
-     * one. */                                                                 \
-    assert(accessor->stride == elem_size);                                     \
-    /* Accessor data must fit inside the buffer. */                            \
-    assert(                                                                    \
-        (offset + (accessor->count * elem_size) +                              \
-         ((accessor->count - 1) * view->stride)) <= buffer->size);             \
-    /* Accessor data must fit inside the view. */                              \
-    assert(accessor->count * accessor->stride <= view->size);                  \
-    cgltf_float x = 0, y = 0, z = 0, w = 0;                                    \
-    /* Silence unused variable warnings. */                                    \
-    (void)y;                                                                   \
-    (void)z;                                                                   \
-    (void)w;                                                                   \
-    /* The {component type} X {dimensions} combinations are a pain to handle.  \
-     For floats, we switch on type first and then lay out a loop for each      \
-     dimension to get a tight loop with a possibly inlined body. For other     \
-     types, we take the performance hit and perform checks and conversions     \
-     inside the loop for simplicity. */                                        \
-    if (accessor->component_type == cgltf_component_type_r_32f) {              \
-      switch (dimensions) {                                                    \
-      case 1:                                                                  \
-        assert(accessor->type == cgltf_type_scalar);                           \
-        for (cgltf_size i = 0; i < accessor->count; ++i, bytes += stride) {    \
-          const cgltf_float* floats = (const cgltf_float*)bytes;               \
-          x                         = *floats;                                 \
-          body;                                                                \
-        }                                                                      \
-        break;                                                                 \
-      case 2:                                                                  \
-        assert(accessor->type == cgltf_type_vec2);                             \
-        for (cgltf_size i = 0; i < accessor->count; ++i, bytes += stride) {    \
-          const cgltf_float* floats = (const cgltf_float*)bytes;               \
-          x                         = *floats++;                               \
-          y                         = *floats;                                 \
-          body;                                                                \
-        }                                                                      \
-        break;                                                                 \
-      case 3:                                                                  \
-        assert(accessor->type == cgltf_type_vec3);                             \
-        for (cgltf_size i = 0; i < accessor->count; ++i, bytes += stride) {    \
-          const cgltf_float* floats = (const cgltf_float*)bytes;               \
-          x                         = *floats++;                               \
-          y                         = *floats++;                               \
-          z                         = *floats;                                 \
-          body;                                                                \
-        }                                                                      \
-        break;                                                                 \
-      case 4:                                                                  \
-        assert(accessor->type == cgltf_type_vec4);                             \
-        for (cgltf_size i = 0; i < accessor->count; ++i, bytes += stride) {    \
-          const cgltf_float* floats = (const cgltf_float*)bytes;               \
-          x                         = *floats++;                               \
-          y                         = *floats++;                               \
-          z                         = *floats++;                               \
-          w                         = *floats;                                 \
-          body;                                                                \
-        }                                                                      \
-        break;                                                                 \
-      }                                                                        \
-    } else {                                                                   \
-      for (cgltf_size i = 0; i < accessor->count; ++i, bytes += stride) {      \
-        const uint8_t* component = bytes;                                      \
-                                                                               \
-        x = read_float(component, accessor);                                   \
-        component += comp_size;                                                \
-        if (dimensions > 1) {                                                  \
-          y = read_float(component, accessor);                                 \
-          component += comp_size;                                              \
-        }                                                                      \
-        if (dimensions > 2) {                                                  \
-          z = read_float(component, accessor);                                 \
-          component += comp_size;                                              \
-        }                                                                      \
-        if (dimensions > 3) {                                                  \
-          w = read_float(component, accessor);                                 \
-          component += comp_size;                                              \
-        }                                                                      \
-        body;                                                                  \
-      }                                                                        \
-    }                                                                          \
-  }
-
-/// Iterate over the matrices in an accessor.
-#define ACCESSOR_FOREACH_MAT(dimensions, accessor, body)                       \
-  {                                                                            \
-    assert((2 <= dimensions) && (dimensions <= 4));                            \
-    assert(!(dimensions == 2) || (accessor->type == cgltf_type_mat2));         \
-    assert(!(dimensions == 3) || (accessor->type == cgltf_type_mat3));         \
-    assert(!(dimensions == 4) || (accessor->type == cgltf_type_mat4));         \
-    const cgltf_buffer_view* view   = accessor->buffer_view;                   \
-    const cgltf_buffer*      buffer = view->buffer;                            \
-    const cgltf_size         offset = accessor->offset + view->offset;         \
-    const cgltf_size comp_size = get_component_size(accessor->component_type); \
-    const uint8_t*   bytes     = (const uint8_t*)buffer->data + offset;        \
-    assert(                                                                    \
-        (offset + accessor->count * dimensions * comp_size) < buffer->size);   \
-    /* From the spec: */                                                       \
-    /*  "Buffer views with other types of data MUST NOT not define */          \
-    /*   byteStride (unless such layout is explicitly enabled by an */         \
-    /*   extension)."*/                                                        \
-    assert(view->stride == 0);                                                 \
-    assert(accessor->stride == dimensions * dimensions * comp_size);           \
-    assert(accessor->component_type == cgltf_component_type_r_32f);            \
-    const cgltf_float* floats = (const cgltf_float*)bytes;                     \
-    switch (dimensions) {                                                      \
-    case 2:                                                                    \
-      assert(accessor->type == cgltf_type_mat2);                               \
-      for (cgltf_size i = 0; i < accessor->count; ++i) {                       \
-        body;                                                                  \
-        floats += 4;                                                           \
-      }                                                                        \
-      break;                                                                   \
-    case 3:                                                                    \
-      assert(accessor->type == cgltf_type_mat3);                               \
-      for (cgltf_size i = 0; i < accessor->count; ++i) {                       \
-        body;                                                                  \
-        floats += 9;                                                           \
-      }                                                                        \
-      break;                                                                   \
-    case 4:                                                                    \
-      assert(accessor->type == cgltf_type_mat4);                               \
-      for (cgltf_size i = 0; i < accessor->count; ++i) {                       \
-        body;                                                                  \
-        floats += 16;                                                          \
-      }                                                                        \
-      break;                                                                   \
-    }                                                                          \
+typedef struct AccessorIter {
+  const cgltf_accessor* accessor;
+  const uint8_t*        next_element;
+  cgltf_size            comp_size; // Component size in bytes.
+  cgltf_size            stride;    // ELement stride in bytes.
+  cgltf_size            index;     // Index of the next element.
+  bool                  is_matrix;
+} AccessorIter;
+
+typedef struct AccessorData {
+  union {
+    struct {
+      float   x, y, z, w;     // Possibly normalized.
+      int64_t xi, yi, zi, wi; // Always unnormalized.
+    };
+    const float* floats;
+  };
+} AccessorData;
+
+bool accessor_iter_next(AccessorIter* iter, AccessorData* data) {
+  assert(iter);
+  assert(data);
+
+  if (iter->index < iter->accessor->count) {
+    const int      dimensions = get_num_dimensions(iter->accessor->type);
+    const uint8_t* component  = iter->next_element;
+
+    // So that the caller can access the element's components as an array.
+    data->floats = (const float*)component;
+
+    if (!iter->is_matrix) { // Scalar or vector.
+      // x
+      data->x  = read_float(component, iter->accessor);
+      data->xi = read_int(component, iter->accessor);
+      component += iter->comp_size;
+      // y
+      if (dimensions > 1) {
+        data->y  = read_float(component, iter->accessor);
+        data->yi = read_int(component, iter->accessor);
+        component += iter->comp_size;
+      }
+      // z
+      if (dimensions > 2) {
+        data->z  = read_float(component, iter->accessor);
+        data->zi = read_int(component, iter->accessor);
+        component += iter->comp_size;
+      }
+      // w
+      if (dimensions > 3) {
+        data->w  = read_float(component, iter->accessor);
+        data->wi = read_int(component, iter->accessor);
+        component += iter->comp_size;
+      }
+    }
+
+    iter->next_element += iter->stride;
+    iter->index++;
+    return true;
   }
 
+  return false;
+}
+
+AccessorIter make_accessor_iter(const cgltf_accessor* accessor) {
+  assert(accessor);
+
+  const bool is_matrix = (accessor->type == cgltf_type_mat2) ||
+                         (accessor->type == cgltf_type_mat3) ||
+                         (accessor->type == cgltf_type_mat4);
+
+  const int dimensions = get_num_dimensions(accessor->type);
+  assert(
+      ((dimensions == 1) && (accessor->type == cgltf_type_scalar)) ||
+      ((dimensions == 2) && (accessor->type == cgltf_type_vec2)) ||
+      ((dimensions == 3) && (accessor->type == cgltf_type_vec3)) ||
+      ((dimensions == 4) && (accessor->type == cgltf_type_vec4)) ||
+      ((dimensions == 4) && (accessor->type == cgltf_type_mat2)) ||
+      ((dimensions == 9) && (accessor->type == cgltf_type_mat3)) ||
+      ((dimensions == 16) && (accessor->type == cgltf_type_mat4)));
+
+  const cgltf_buffer_view* view   = accessor->buffer_view;
+  const cgltf_buffer*      buffer = view->buffer;
+  const cgltf_size         offset = accessor->offset + view->offset;
+  const uint8_t*           bytes  = (const uint8_t*)buffer->data + offset;
+  // Component size in bytes.
+  const cgltf_size comp_size = get_component_size(accessor->component_type);
+  // Element size in bytes.
+  const cgltf_size elem_size = dimensions * comp_size;
+  // Stride in bytes. If the view stride is 0, then the elements are tightly
+  // packed.
+  const cgltf_size stride = view->stride != 0 ? view->stride : elem_size;
+
+  // There isn't an accessor stride in the spec, but cgltf still specifies one.
+  assert(accessor->stride == elem_size);
+
+  // Accessor data must fit inside the view.
+  assert(accessor->offset + (accessor->count * accessor->stride) <= view->size);
+
+  // Accessor data must fit inside the buffer.
+  assert(
+      (offset + (accessor->count * elem_size) +
+       ((accessor->count - 1) * view->stride)) <= buffer->size);
+
+  return (AccessorIter){
+      .accessor     = accessor,
+      .next_element = bytes,
+      .comp_size    = comp_size,
+      .stride       = stride,
+      .index        = 0,
+      .is_matrix    = is_matrix,
+  };
+}
+
 /// Return the total number of primitives in the scene. Each mesh may contain
 /// multiple primitives.
 ///
@@ -703,7 +730,7 @@ static bool load_texture_and_uniform(
 
     textures[texture_index] = gfx_load_texture(gfx, cmd);
     if (!textures[texture_index]) {
-      prepend_error(
+      log_error(
           "Failed to load texture: %s",
           mstring_cstr(&cmd->data.texture.filepath));
       return false;
@@ -856,20 +883,25 @@ static Material* make_default_material() {
 
 /// Compute the bounding box of the vertices pointed to by the accessor.
 /// 'dim' is the dimension of the vertices (2D or 3D).
-aabb3 compute_aabb(const cgltf_accessor* accessor, int dim) {
+aabb3 compute_aabb(const cgltf_accessor* accessor) {
   aabb3 box = {0};
   if (accessor->has_min && accessor->has_max) {
     box = aabb3_make(
         vec3_from_array(accessor->min), vec3_from_array(accessor->max));
   } else {
-    ACCESSOR_FOREACH_VEC(dim, accessor, {
-      const vec3 p = vec3_make(x, y, z);
+    AccessorIter iter   = make_accessor_iter(accessor);
+    AccessorData vertex = {0};
+    cgltf_size   i      = 0;
+
+    while (accessor_iter_next(&iter, &vertex)) {
+      const vec3 p = vec3_make(vertex.x, vertex.y, vertex.z);
       if (i == 0) {
         box = aabb3_make(p, p);
       } else {
         box = aabb3_add(box, p);
       }
-    });
+      ++i;
+    }
   }
   return box;
 }
@@ -1000,15 +1032,15 @@ static bool load_meshes(
           case cgltf_type_vec2:
             assert(geometry_desc.positions3d.buffer == 0);
             buffer_view_2d     = &geometry_desc.positions2d;
-            geometry_desc.aabb = compute_aabb(accessor, 2);
+            geometry_desc.aabb = compute_aabb(accessor);
             break;
           case cgltf_type_vec3:
             assert(geometry_desc.positions2d.buffer == 0);
             buffer_view_3d     = &geometry_desc.positions3d;
-            geometry_desc.aabb = compute_aabb(accessor, 3);
+            geometry_desc.aabb = compute_aabb(accessor);
             break;
           default:
-            LOGE(
+            FAIL(
                 "Unhandled accessor type %d in vertex positions",
                 accessor->type);
             assert(false);
@@ -1186,6 +1218,77 @@ static bool load_meshes(
   return true;
 }
 
+/// Compute bounding boxes for the joints in the model.
+static void compute_joint_bounding_boxes(
+    const cgltf_data* data, size_t num_joints, JointDesc* joint_descs) {
+  assert(data);
+  assert(joint_descs);
+  assert(num_joints <= GFX_MAX_NUM_JOINTS);
+
+  // Initialize bounding boxes so that we can compute unions below.
+  for (size_t i = 0; i < num_joints; ++i) {
+    joint_descs[i].box = aabb3_make_empty();
+  }
+
+  // Iterate over the meshes -> primitives -> vertices -> joint indices, and add
+  // the vertex to the joint's bounding box.
+  for (cgltf_size n = 0; n < data->nodes_count; ++n) {
+    const cgltf_node* node = &data->nodes[n];
+
+    if (node->skin) {
+      if (node->mesh) {
+        const cgltf_mesh* mesh = node->mesh;
+
+        for (cgltf_size pr = 0; pr < mesh->primitives_count; ++pr) {
+          const cgltf_primitive* prim = &mesh->primitives[pr];
+
+          // Find the indices of the positions and joints arrays in the
+          // primitive's attributes.
+          int positions_index = -1;
+          int joints_index    = -1;
+          for (int a = 0; a < (int)prim->attributes_count; ++a) {
+            const cgltf_attribute* attrib = &prim->attributes[a];
+
+            if (attrib->type == cgltf_attribute_type_position) {
+              positions_index = a;
+            } else if (attrib->type == cgltf_attribute_type_joints) {
+              joints_index = a;
+            }
+          }
+
+          if ((positions_index != -1) && (joints_index != -1)) {
+            const cgltf_accessor* positions =
+                prim->attributes[positions_index].data;
+            const cgltf_accessor* joints = prim->attributes[joints_index].data;
+
+            assert(positions->count == joints->count);
+
+            AccessorIter positions_iter = make_accessor_iter(positions);
+            AccessorIter joints_iter    = make_accessor_iter(joints);
+            AccessorData position = {0}, joint = {0};
+
+            while (accessor_iter_next(&positions_iter, &position)) {
+              const bool advance = accessor_iter_next(&joints_iter, &joint);
+              assert(advance); // Counts should match.
+
+              const vec3    p = vec3_make(position.x, position.y, position.z);
+              const int64_t j[4] = {joint.xi, joint.yi, joint.wi, joint.zi};
+
+              for (int i = 0; i < 4; ++i) {
+                const size_t joint_index = j[i];
+                assert((size_t)joint_index < num_joints);
+                
+                joint_descs[joint_index].box =
+                    aabb3_add(joint_descs[joint_index].box, p);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
 /// Find the joint node with the smallest index across all skeletons.
 ///
 /// The channels in glTF may target arbitrary nodes in the scene (those nodes
@@ -1249,8 +1352,10 @@ static size_t load_skins(
     *skeleton_desc = (SkeletonDesc){.num_joints = skin->joints_count};
 
     // for (cgltf_size j = 0; j < skin->joints_count; ++j) {
-    ACCESSOR_FOREACH_MAT(4, matrices_accessor, {
-      const mat4 inv_bind_matrix = mat4_from_array(floats);
+    AccessorIter iter   = make_accessor_iter(matrices_accessor);
+    AccessorData matrix = {0};
+    for (cgltf_size i = 0; accessor_iter_next(&iter, &matrix); ++i) {
+      const mat4 inv_bind_matrix = mat4_from_array(matrix.floats);
 
       // Joint is an index/pointer into the nodes array.
       const cgltf_size node_index = skin->joints[i] - data->nodes;
@@ -1275,7 +1380,7 @@ static size_t load_skins(
       joint_desc->inv_bind_matrix = inv_bind_matrix;
 
       is_joint_node[joint_index] = true;
-    });
+    };
 
     // glTF may specify a "skeleton", which is the root of the skin's
     // (skeleton's) node hierarchy.
@@ -1352,23 +1457,32 @@ static void load_animations(
           .num_keyframes = 0};
 
       // Read time inputs.
-      ACCESSOR_FOREACH_VEC(1, sampler->input, {
-        channel_desc->keyframes[i].time = x;
+      AccessorIter iter  = make_accessor_iter(sampler->input);
+      AccessorData input = {0};
+      for (cgltf_size i = 0; accessor_iter_next(&iter, &input); ++i) {
+        channel_desc->keyframes[i].time = input.x;
         channel_desc->num_keyframes++;
-      });
+      }
 
       // Read transform outputs.
+      AccessorData output = {0};
       switch (channel->target_path) {
-      case cgltf_animation_path_type_translation:
-        ACCESSOR_FOREACH_VEC(3, sampler->output, {
-          channel_desc->keyframes[i].translation = vec3_make(x, y, z);
-        });
+      case cgltf_animation_path_type_translation: {
+        iter = make_accessor_iter(sampler->output);
+        for (cgltf_size i = 0; accessor_iter_next(&iter, &output); ++i) {
+          channel_desc->keyframes[i].translation =
+              vec3_make(output.x, output.y, output.z);
+        }
         break;
-      case cgltf_animation_path_type_rotation:
-        ACCESSOR_FOREACH_VEC(4, sampler->output, {
-          channel_desc->keyframes[i].rotation = qmake(x, y, z, w);
-        });
+      }
+      case cgltf_animation_path_type_rotation: {
+        iter = make_accessor_iter(sampler->output);
+        for (cgltf_size i = 0; accessor_iter_next(&iter, &output); ++i) {
+          channel_desc->keyframes[i].rotation =
+              qmake(output.x, output.y, output.z, output.w);
+        }
         break;
+      }
       default:
         // TODO: Handle other channel transformations.
         break;
@@ -1421,10 +1535,6 @@ static void load_nodes(
         assert(skin_index < data->skins_count);
         const Skeleton* skeleton = gfx_get_anima_skeleton(anima, skin_index);
         gfx_set_object_skeleton(object, skeleton);
-
-        // TODO: Compute AABBs/OOBBs for the skeleton's joints here. Iterate
-        //  over  the mesh's primitives, its vertices, their joint indices, and
-        //  add  the vertex to the AABB/OOBB.
       }
     } else if (node->camera) {
       assert(next_camera < data->cameras_count);
@@ -1686,6 +1796,9 @@ static Model* load_scene(
     anima_desc->num_joints     = load_skins(data, buffers, base, anima_desc);
     load_animations(data, base, anima_desc);
 
+    compute_joint_bounding_boxes(
+        data, anima_desc->num_joints, anima_desc->joints);
+
     anima = gfx_make_anima(anima_desc);
     gfx_construct_anima_node(root_node, anima);
   }