6 files changed, 2453 insertions, 0 deletions

diff --git a/src/asset/asset_cache.c b/src/asset/asset_cache.c
new file mode 100644
index 0000000..16c4d5c
--- /dev/null
+++ b/src/asset/asset_cache.c
@@ -0,0 +1,252 @@
+#include "asset_cache.h"
+
+#include "model.h"
+#include "scene/animation_impl.h"
+#include "scene/model_impl.h"
+#include "scene/node_impl.h"
+#include "scene/scene_memory.h"
+#include "texture.h"
+
+#include <gfx/asset.h>
+#include <gfx/gfx.h>
+#include <gfx/scene/node.h>
+#include <gfx_assert.h>
+
+#include <cstring.h>
+#include <error.h>
+#include <log/log.h>
+
+static void log_model_load_failure(const LoadModelCmd* cmd) {
+  assert(cmd);
+
+  switch (cmd->origin) {
+  case AssetFromFile:
+    log_error("Failed to load model: %s", mstring_cstr(&cmd->filepath));
+    break;
+  case AssetFromMemory:
+    log_error("Failed to load model: %p", cmd->data);
+    break;
+  }
+}
+
+static void log_texture_load_failure(const LoadTextureCmd* cmd) {
+  assert(cmd);
+
+  switch (cmd->origin) {
+  case AssetFromFile:
+    switch (cmd->type) {
+    case LoadTexture:
+      log_error(
+          "Failed to load texture: %s",
+          mstring_cstr(&cmd->data.texture.filepath));
+      break;
+    case LoadCubemap:
+      log_error(
+          "Failed to load cubemap texture: %s",
+          mstring_cstr(&cmd->data.cubemap.filepaths.filepath_pos_x));
+      break;
+    }
+    break;
+  case AssetFromMemory:
+    switch (cmd->type) {
+    case LoadTexture:
+      log_error("Failed to load texture: %p", cmd->data.texture.data);
+      break;
+    case LoadCubemap:
+      log_error(
+          "Failed to load texture: %p", cmd->data.cubemap.buffers.data_pos_x);
+      break;
+    }
+    break;
+  }
+}
+
+static Hash calc_model_hash(const LoadModelCmd* cmd) {
+  assert(cmd);
+  switch (cmd->origin) {
+  case AssetFromFile:
+    return cstring_hash(mstring_cstr(&cmd->filepath));
+  case AssetFromMemory:
+    return (Hash)cmd->data;
+  }
+  FAIL("Unhandled model asset origin");
+  return 0;
+}
+
+static Hash calc_texture_hash(const LoadTextureCmd* cmd) {
+  assert(cmd);
+  switch (cmd->origin) {
+  case AssetFromFile:
+    switch (cmd->type) {
+    case LoadTexture:
+      return cstring_hash(mstring_cstr(&cmd->data.texture.filepath));
+    case LoadCubemap:
+      return cstring_hash(
+                 mstring_cstr(&cmd->data.cubemap.filepaths.filepath_pos_x)) ^
+             cstring_hash(
+                 mstring_cstr(&cmd->data.cubemap.filepaths.filepath_neg_x)) ^
+             cstring_hash(
+                 mstring_cstr(&cmd->data.cubemap.filepaths.filepath_pos_y)) ^
+             cstring_hash(
+                 mstring_cstr(&cmd->data.cubemap.filepaths.filepath_neg_y)) ^
+             cstring_hash(
+                 mstring_cstr(&cmd->data.cubemap.filepaths.filepath_pos_z)) ^
+             cstring_hash(
+                 mstring_cstr(&cmd->data.cubemap.filepaths.filepath_neg_z));
+    }
+    break;
+  case AssetFromMemory:
+    switch (cmd->type) {
+    case LoadTexture:
+      return (Hash)cmd->data.texture.data;
+    case LoadCubemap:
+      return (Hash)cmd->data.cubemap.buffers.data_pos_x ^
+             (Hash)cmd->data.cubemap.buffers.data_neg_x ^
+             (Hash)cmd->data.cubemap.buffers.data_pos_y ^
+             (Hash)cmd->data.cubemap.buffers.data_neg_y ^
+             (Hash)cmd->data.cubemap.buffers.data_pos_z ^
+             (Hash)cmd->data.cubemap.buffers.data_neg_z;
+    }
+    break;
+  }
+  FAIL("Unhandled texture asset origin");
+  return 0;
+}
+
+static Asset* lookup_cache(AssetCache* cache, Hash hash) {
+  assert(cache);
+  mempool_foreach(&cache->assets, asset, {
+    if (asset->hash == hash) {
+      return asset;
+    }
+  });
+  return 0;
+}
+
+static void log_model_cache_hit(const LoadModelCmd* cmd, Hash hash) {
+  assert(cmd);
+  switch (cmd->origin) {
+  case AssetFromFile:
+    LOGD(
+        "Found asset [%s] in cache with hash [%lu]",
+        mstring_cstr(&cmd->filepath), hash);
+    break;
+  case AssetFromMemory:
+    LOGD("Found asset [%p] in cache with hash [%lu]", cmd->data, hash);
+    break;
+  }
+}
+
+static void log_model_loaded(const LoadModelCmd* cmd) {
+  assert(cmd);
+  switch (cmd->origin) {
+  case AssetFromFile:
+    LOGD("Loaded asset from file: [%s]", mstring_cstr(&cmd->filepath));
+    break;
+  case AssetFromMemory:
+    LOGD("Loaded asset from memory: [%p]", cmd->data);
+    break;
+  }
+}
+
+static Model* clone_model(const Model* model) {
+  assert(model);
+
+  // Only the Anima needs to be cloned since everything else in the model is
+  // static.
+  //
+  // The Anima can be partially shallow-cloned. Skeletons and animations are
+  // static and can be shared with the original Anima. Other members are
+  // deep-cloned. Skeletons in particular point back to their Anima, so need to
+  // be deep-cloned.
+  const SceneNode* root = mem_get_node(model->root);
+  if (gfx_get_node_type(root) == AnimaNode) {
+    const Anima* anima      = gfx_get_node_anima(root);
+    Anima*       anima_copy = mem_alloc_anima();
+    *anima_copy             = *anima; // Shallow copy.
+
+    SceneNode* root_copy = gfx_clone_scene_shallow(root);
+    root_copy->anima     = mem_get_anima_index(anima_copy);
+    anima_copy->parent   = mem_get_node_index(root_copy);
+
+    Model* copy = mem_alloc_model();
+    copy->root  = mem_get_node_index(root_copy);
+    return copy;
+  } else {
+    return (Model*)model; // Static model, can't be mutated.
+  }
+}
+
+void gfx_init_asset_cache(AssetCache* cache) {
+  assert(cache);
+  mempool_make(&cache->assets);
+
+  // Allocate a dummy asset at index 0 to guarantee that no assets allocated by
+  // the caller map to index 0.
+  const Asset* dummy = mempool_alloc(&cache->assets);
+  assert(mempool_get_block_index(&cache->assets, dummy) == 0);
+}
+
+void gfx_destroy_asset_cache(AssetCache* cache) {
+  assert(cache);
+  mempool_del(&cache->assets);
+}
+
+Model* gfx_load_model(Gfx* gfx, const LoadModelCmd* cmd) {
+  assert(gfx);
+
+  AssetCache* cache = gfx_get_asset_cache(gfx);
+
+  // First search for the asset in the cache.
+  const uint64_t hash  = calc_model_hash(cmd);
+  Asset*         asset = lookup_cache(cache, hash);
+  if (asset) {
+    log_model_cache_hit(cmd, hash);
+    return clone_model(asset->model);
+  }
+
+  // Asset not found in the cache.
+  // Load it, insert it into the cache, and return it.
+  Model* model = gfx_model_load(gfx, cmd);
+  if (model) {
+    *(Asset*)mempool_alloc(&cache->assets) = (Asset){
+        .type  = ModelAsset,
+        .hash  = hash,
+        .model = model,
+    };
+    log_model_loaded(cmd);
+    return clone_model(model);
+  } else {
+    log_model_load_failure(cmd);
+    return 0;
+  }
+}
+
+const Texture* gfx_load_texture(Gfx* gfx, const LoadTextureCmd* cmd) {
+  assert(gfx);
+  assert(cmd);
+
+  AssetCache* cache = gfx_get_asset_cache(gfx);
+
+  // First search for the asset in the cache.
+  const uint64_t hash  = calc_texture_hash(cmd);
+  Asset*         asset = lookup_cache(cache, hash);
+  if (asset) {
+    return asset->texture;
+  }
+
+  // Asset not found in the cache.
+  // Load it, insert it into the cache, and return it.
+  GfxCore*       gfxcore = gfx_get_core(gfx);
+  const Texture* texture = gfx_texture_load(gfxcore, cmd);
+  if (texture) {
+    *(Asset*)mempool_alloc(&cache->assets) = (Asset){
+        .type    = TextureAsset,
+        .hash    = hash,
+        .texture = texture,
+    };
+  } else {
+    log_texture_load_failure(cmd);
+  }
+  return texture;
+}
diff --git a/src/asset/asset_cache.h b/src/asset/asset_cache.h
new file mode 100644
index 0000000..b2a35ed
--- /dev/null
+++ b/src/asset/asset_cache.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <gfx/sizes.h>
+
+#include <cstring.h>
+#include <mempool.h>
+
+typedef struct Model   Model;
+typedef struct Texture Texture;
+
+typedef uint64_t Hash;
+
+typedef enum AssetType {
+  ModelAsset,
+  TextureAsset,
+} AssetType;
+
+typedef struct Asset {
+  AssetType type;
+  Hash      hash;
+  union {
+    Model*         model;
+    const Texture* texture;
+  };
+} Asset;
+
+DEF_MEMPOOL(asset_pool, Asset, GFX_MAX_NUM_ASSETS)
+
+typedef struct AssetCache {
+  asset_pool assets;
+} AssetCache;
+
+/// Create a new asset cache.
+void gfx_init_asset_cache(AssetCache*);
+
+/// Destroy the asset cache.
+void gfx_destroy_asset_cache(AssetCache*);
diff --git a/src/asset/model.c b/src/asset/model.c
new file mode 100644
index 0000000..25f2780
--- /dev/null
+++ b/src/asset/model.c
@@ -0,0 +1,1968 @@
+/// Loads scenes from memory and files.
+///
+/// Only the GLTF scene format is current supported.
+///
+/// ----------------------------------------------------------------------------
+/// glTF File Format Documentation
+/// ----------------------------------------------------------------------------
+///
+/// cgltf:
+/// https://github.com/jkuhlmann/cgltf
+///
+/// gltf overview:
+/// https://raw.githubusercontent.com/KhronosGroup/glTF/master/specification/2.0/figures/gltfOverview-2.0.0b.png
+///
+/// gltf spec:
+/// https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md
+///
+/// Sample models:
+/// https://github.com/KhronosGroup/glTF-Sample-Models/tree/master/2.0
+/// https://github.com/KhronosGroup/glTF-Sample-Models/blob/master/2.0/Sponza/glTF/Sponza.gltf
+/// https://github.com/KhronosGroup/glTF-Sample-Models/blob/master/2.0/AlphaBlendModeTest/glTF/AlphaBlendModeTest.gltf
+/// https://github.com/KhronosGroup/glTF-Sample-Models/blob/master/2.0/Buggy/glTF/Buggy.gltf
+/// https://github.com/KhronosGroup/glTF-Sample-Models/blob/master/2.0/AntiqueCamera/glTF/AntiqueCamera.gltf
+/// https://github.com/KhronosGroup/glTF-Sample-Models/blob/master/2.0/DamagedHelmet/glTF/DamagedHelmet.gltf
+///
+/// ----------------------------------------------------------------------------
+/// Implementation Notes
+/// ----------------------------------------------------------------------------
+///
+/// # glTF and the gfx library
+///
+/// glTF has concepts that are similar to those in the gfx library, but there
+/// isn't an exact 1-1 mapping. Concepts map as follows:
+///
+///   glTF                           gfx
+///   ----                           ---
+///   buffer                         Buffer
+///   accessor + buffer view         BufferView
+///   mesh primitive (geom + mat)    Mesh (also geom + mat)
+///   mesh                           SceneObject
+///   node                           SceneNode
+///
+/// glTF buffers map 1-1 with gfx Buffers. glTF scenes make heavy re-use of
+/// buffers across views/accessors/meshes, so it is important to make that same
+/// re-use in the gfx library to use the data effectively and without
+/// duplication. The Sponza scene, for example, has all of its data in one giant
+/// buffer.
+///
+/// glTF accessors and buffer views are combined and mapped to gfx BufferViews.
+/// The glTF buffer view's offset/length/stride are combined with the accessor's
+/// offset, and together with the remaining information of both data structures
+/// baked into a BufferView. Internally, this information is fed into
+/// glVertexAttribPointer() calls, wrapped in a VAO (index view/accessor
+/// information is fed into glDrawElements()). This baking should not hurt
+/// re-use, at least in the OpenGL world.
+///
+/// A glTF mesh primitive contains a piece of geometry and a material. This maps
+/// directly to a gfx Mesh.
+///
+/// A glTF mesh is a list of mesh primitives. This maps nicely to a gfx
+/// SceneObject, with the only inconvenience that terminology gets a little
+/// confusing.
+///
+/// Finally, glTF nodes map directly to gfx SceneNodes. Both enforce a strict
+/// tree hierarchy; DAGs are not supported.
+///
+/// # Materials
+///
+/// glTF uses the metallic-roughness material model. However, an extension
+/// allows a scene to use the specular-glossiness model as well and cgltf
+/// supports it:
+///
+/// https://kcoley.github.io/glTF/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness/
+///
+/// From the docs, the specular-glossiness model can represent more materials
+/// than the metallic-roughness model, but it is also more computationally
+/// expensive. Furthermore, a material in glTF can specify parameters for both
+/// models, leaving it up to the implementation to decide which one to use.
+/// In our case, we use the specular-glosiness model if parameters for it are
+/// provided, otherwise we use the metallic-roughness model.
+
+#include "asset/model.h"
+
+#include "asset/texture.h"
+#include "gfx/core.h"
+#include "gfx/gfx.h"
+#include "gfx/scene/animation.h"
+#include "gfx/scene/camera.h"
+#include "gfx/scene/material.h"
+#include "gfx/scene/mesh.h"
+#include "gfx/scene/node.h"
+#include "gfx/scene/object.h"
+#include "gfx/scene/scene.h"
+#include "gfx/sizes.h"
+#include "gfx/util/shader.h"
+
+#include "gfx_assert.h"
+#include "scene/model_impl.h"
+
+#include "cstring.h"
+#include "error.h"
+#include "log/log.h"
+#include "math/camera.h"
+#include "math/defs.h"
+#include "math/mat4.h"
+#include "math/quat.h"
+#include "math/vec2.h"
+#include "math/vec3.h"
+
+#include "cgltf_tangents.h"
+#define CGLTF_IMPLEMENTATION
+#include "cgltf.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+// Taken from the GL header file.
+#define GL_NEAREST                0x2600
+#define GL_LINEAR                 0x2601
+#define GL_NEAREST_MIPMAP_NEAREST 0x2700
+#define GL_LINEAR_MIPMAP_NEAREST  0x2701
+#define GL_NEAREST_MIPMAP_LINEAR  0x2702
+#define GL_LINEAR_MIPMAP_LINEAR   0x2703
+
+// Uniforms names. Must match the names in shaders.
+#define UNIFORM_BASE_COLOR_FACTOR          "BaseColorFactor"
+#define UNIFORM_METALLIC_FACTOR            "MetallicFactor"
+#define UNIFORM_ROUGHNESS_FACTOR           "RoughnessFactor"
+#define UNIFORM_EMISSIVE_FACTOR            "EmissiveFactor"
+#define UNIFORM_BASE_COLOR_TEXTURE         "BaseColorTexture"
+#define UNIFORM_METALLIC_ROUGHNESS_TEXTURE "MetallicRoughnessTexture"
+#define UNIFORM_EMISSIVE_TEXTURE           "EmissiveTexture"
+#define UNIFORM_AMBIENT_OCCLUSION_TEXTURE  "AmbientOcclusionTexture"
+#define UNIFORM_NORMAL_MAP                 "NormalMap"
+
+// Shader compiler defines. Must match the names in shaders.
+#define DEFINE_HAS_TEXCOORDS              "HAS_TEXCOORDS"
+#define DEFINE_HAS_NORMALS                "HAS_NORMALS"
+#define DEFINE_HAS_TANGENTS               "HAS_TANGENTS"
+#define DEFINE_HAS_ALBEDO_MAP             "HAS_ALBEDO_MAP"
+#define DEFINE_HAS_METALLIC_ROUGHNESS_MAP "HAS_METALLIC_ROUGHNESS_MAP"
+#define DEFINE_HAS_NORMAL_MAP             "HAS_NORMAL_MAP"
+#define DEFINE_HAS_OCCLUSION_MAP          "HAS_OCCLUSION_MAP"
+#define DEFINE_HAS_EMISSIVE_MAP           "HAS_EMISSIVE_MAP"
+#define DEFINE_HAS_JOINTS                 "HAS_JOINTS"
+#define DEFINE_MAX_JOINTS                 "MAX_JOINTS"
+
+typedef enum TextureType {
+  BaseColorTexture,
+  MetallicRoughnessTexture,
+  EmissiveTexture,
+  AmbientOcclusionTexture,
+  NormalMap,
+} TextureType;
+
+/// Describes the properties of a mesh.
+/// This is used to create shader permutations.
+typedef struct MeshPermutation {
+  union {
+    struct {
+      // Vertex attributes.
+      bool has_texcoords : 1;
+      bool has_normals   : 1;
+      bool has_tangents  : 1;
+      bool has_joints    : 1;
+      bool has_weights   : 1;
+      // Textures.
+      bool has_albedo_map             : 1;
+      bool has_metallic_roughness_map : 1;
+      bool has_normal_map             : 1;
+      bool has_occlusion_map          : 1;
+      bool has_emissive_map           : 1;
+    };
+    int32_t all;
+  };
+} MeshPermutation;
+
+/// Build shader compiler defines from a mesh permutation.
+static size_t make_defines(
+    MeshPermutation perm, ShaderCompilerDefine* defines) {
+  static const char* str_true = "1";
+  size_t             next     = 0;
+
+#define check(field, define)                      \
+  if (perm.field) {                               \
+    defines[next].name  = sstring_make(define);   \
+    defines[next].value = sstring_make(str_true); \
+    next++;                                       \
+  }
+  check(has_texcoords, DEFINE_HAS_TEXCOORDS);
+  check(has_normals, DEFINE_HAS_NORMALS);
+  check(has_tangents, DEFINE_HAS_TANGENTS);
+  check(has_joints, DEFINE_HAS_JOINTS);
+  check(has_albedo_map, DEFINE_HAS_ALBEDO_MAP);
+  check(has_metallic_roughness_map, DEFINE_HAS_METALLIC_ROUGHNESS_MAP);
+  check(has_normal_map, DEFINE_HAS_NORMAL_MAP);
+  check(has_occlusion_map, DEFINE_HAS_OCCLUSION_MAP);
+  check(has_emissive_map, DEFINE_HAS_EMISSIVE_MAP);
+
+  if (perm.has_joints) {
+    defines[next].name  = sstring_make(DEFINE_MAX_JOINTS);
+    defines[next].value = sstring_itoa(GFX_MAX_NUM_JOINTS);
+    next++;
+  }
+
+  return next;
+}
+
+/// Compile a shader permutation.
+static ShaderProgram* make_shader_permutation(
+    GfxCore* gfxcore, MeshPermutation perm) {
+  LOGD(
+      "Compiling Cook-Torrance shader permutation: texcoords: %d, normals: "
+      "%d, tangents: %d, joints: %d, weights: %d, albedo map: %d, "
+      "metallic-roughness map: "
+      "%d, normal "
+      "map: %d, AO map: %d, emissive map: %d",
+      perm.has_texcoords, perm.has_normals, perm.has_tangents, perm.has_joints,
+      perm.has_weights, perm.has_albedo_map, perm.has_metallic_roughness_map,
+      perm.has_normal_map, perm.has_occlusion_map, perm.has_emissive_map);
+
+  ShaderCompilerDefine defines[GFX_MAX_SHADER_COMPILER_DEFINES];
+  const size_t         num_defines = make_defines(perm, defines);
+  return gfx_make_cook_torrance_shader_perm(gfxcore, defines, num_defines);
+}
+
+/// Map a texture type to the name of the shader uniform used to access the
+/// texture.
+static const char* get_texture_uniform_name(TextureType type) {
+  switch (type) {
+  case BaseColorTexture:
+    return UNIFORM_BASE_COLOR_TEXTURE;
+  case MetallicRoughnessTexture:
+    return UNIFORM_METALLIC_ROUGHNESS_TEXTURE;
+  case EmissiveTexture:
+    return UNIFORM_EMISSIVE_TEXTURE;
+  case AmbientOcclusionTexture:
+    return UNIFORM_AMBIENT_OCCLUSION_TEXTURE;
+  case NormalMap:
+    return UNIFORM_NORMAL_MAP;
+  }
+  assert(false);
+  return 0;
+}
+
+/// Map a glTF primitive type to a gfx primitive type.
+static PrimitiveType from_gltf_primitive_type(cgltf_primitive_type type) {
+  switch (type) {
+  case cgltf_primitive_type_triangles:
+    return Triangles;
+  case cgltf_primitive_type_triangle_fan:
+    return TriangleFan;
+  case cgltf_primitive_type_triangle_strip:
+    return TriangleStrip;
+  // Not yet implemented.
+  case cgltf_primitive_type_lines:
+  case cgltf_primitive_type_line_loop:
+  case cgltf_primitive_type_line_strip:
+  case cgltf_primitive_type_points:
+    break;
+  }
+  LOGE("Unsupported primitive type: %d", type);
+  assert(false);
+  return 0;
+}
+
+/// Map a glTF animation path type to its Gfx equivalent.
+static ChannelType from_gltf_animation_path_type(
+    cgltf_animation_path_type type) {
+  switch (type) {
+  case cgltf_animation_path_type_translation:
+    return TranslationChannel;
+  case cgltf_animation_path_type_rotation:
+    return RotationChannel;
+  case cgltf_animation_path_type_scale:
+    return ScaleChannel;
+  case cgltf_animation_path_type_weights:
+    return WeightsChannel;
+  case cgltf_animation_path_type_invalid:
+    assert(false);
+    break;
+  }
+  assert(false);
+  return 0;
+}
+
+/// Map a glTF interpolation to its Gfx equivalent.
+static AnimationInterpolation from_gltf_interpolation_type(
+    cgltf_interpolation_type type) {
+  switch (type) {
+  case cgltf_interpolation_type_linear:
+    return LinearInterpolation;
+  case cgltf_interpolation_type_step:
+    return StepInterpolation;
+  case cgltf_interpolation_type_cubic_spline:
+    return CubicSplineInterpolation;
+  }
+  assert(false);
+  return 0;
+}
+
+/// Return the component's size in bytes.
+static cgltf_size get_component_size(cgltf_component_type type) {
+  switch (type) {
+  case cgltf_component_type_r_8:
+    return 1;
+  case cgltf_component_type_r_8u:
+    return 1;
+  case cgltf_component_type_r_16:
+    return 2;
+  case cgltf_component_type_r_16u:
+    return 2;
+  case cgltf_component_type_r_32u:
+    return 4;
+  case cgltf_component_type_r_32f:
+    return 4;
+  case cgltf_component_type_invalid:
+    assert(false);
+    break;
+  }
+  assert(false);
+  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* 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*)component);
+    return max((float)c / 127.0, -1.0);
+  }
+  case cgltf_component_type_r_8u: {
+    // 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*)component);
+    return max((float)c / 32767.0, -1.0);
+  }
+  case cgltf_component_type_r_16u: {
+    // 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*)component);
+    return (float)c / 4294967295.0;
+  }
+  case cgltf_component_type_r_32f: {
+    const float c = *((float*)component);
+    return c;
+  }
+  case cgltf_component_type_invalid:
+    FAIL();
+    break;
+  }
+  FAIL();
+  return 0;
+}
+
+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.
+///
+/// Note that this function scans all of the scenes in the glTF data.
+static size_t get_total_primitives(const cgltf_data* data) {
+  size_t total = 0;
+  for (cgltf_size i = 0; i < data->meshes_count; ++i) {
+    total += data->meshes[i].primitives_count;
+  }
+  return total;
+}
+
+/// Load all buffers from the glTF scene.
+///
+/// If buffer data is loaded from memory, set filepath = null.
+///
+/// Return an array of Buffers such that the index of each glTF buffer in the
+/// original array matches the same Buffer in the resulting array.
+///
+/// TODO: There is no need to load the inverse bind matrices buffer into the
+/// GPU. Might need to lazily load buffers.
+static bool load_buffers(
+    const cgltf_data* data, GfxCore* gfxcore, Buffer** buffers) {
+  assert(data);
+  assert(gfxcore);
+  assert(buffers);
+
+  for (cgltf_size i = 0; i < data->buffers_count; ++i) {
+    const cgltf_buffer* buffer = &data->buffers[i];
+    assert(buffer->data);
+    buffers[i] = gfx_make_buffer(
+        gfxcore, &(BufferDesc){
+                     .usage      = BufferStatic,
+                     .type       = BufferUntyped,
+                     .data.data  = buffer->data,
+                     .data.count = buffer->size});
+    if (!buffers[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/// Load tangent buffers.
+static bool load_tangent_buffers(
+    const cgltfTangentBuffer* cgltf_tangent_buffers,
+    cgltf_size num_tangent_buffers, GfxCore* gfxcore,
+    Buffer** tangent_buffers) {
+  assert(cgltf_tangent_buffers);
+  assert(gfxcore);
+  assert(tangent_buffers);
+
+  for (cgltf_size i = 0; i < num_tangent_buffers; ++i) {
+    const cgltfTangentBuffer* buffer = &cgltf_tangent_buffers[i];
+    assert(buffer->data);
+    tangent_buffers[i] = gfx_make_buffer(
+        gfxcore, &(BufferDesc){
+                     .usage      = BufferStatic,
+                     .type       = BufferUntyped,
+                     .data.data  = buffer->data,
+                     .data.count = buffer->size_bytes});
+    if (!tangent_buffers[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/// Lazily load all textures from the glTF scene.
+///
+/// Colour textures like albedo are in sRGB colour space. Non-colour textures
+/// like normal maps are in linear space (e.g. DamagedHelmet sample). Since we
+/// don't know how the texture is going to be used at this point, we can't tell
+/// what colour space it should be loaded in (ideally this would be part of the
+/// image file format, but not all formats specify colour space.) Therefore, we
+/// load the textures lazily and don't actually commit them to GPU memory until
+/// we know their colour space when loading glTF materials.
+///
+/// Return an array of LoadTextureCmds such that the index of each cmd matches
+/// the index of each glTF texture in the scene.
+static void load_textures_lazy(
+    const cgltf_data* data, GfxCore* gfxcore, const char* directory,
+    LoadTextureCmd* load_texture_cmds) {
+  assert(data);
+  assert(gfxcore);
+  assert(load_texture_cmds);
+
+  for (cgltf_size i = 0; i < data->textures_count; ++i) {
+    const cgltf_texture* texture = &data->textures[i];
+    const cgltf_image*   image   = texture->image;
+    const cgltf_sampler* sampler = texture->sampler;
+
+    // glTF models might not specify a sampler. In such case, the client can
+    // pick its own defaults.
+    // https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#samplers
+    bool             mipmaps   = true;
+    TextureFiltering filtering = LinearFiltering;
+    TextureWrapping  wrap      = Repeat;
+
+    if (sampler) {
+      // The gfx library does not distinguish between sampling the texture and
+      // combining the mipmap levels.
+      const cgltf_int filter =
+          sampler->min_filter == 0 ? sampler->mag_filter : sampler->min_filter;
+
+      switch (filter) {
+      case GL_NEAREST_MIPMAP_NEAREST:
+        mipmaps   = true;
+        filtering = NearestFiltering;
+        break;
+      case GL_NEAREST_MIPMAP_LINEAR:
+      case GL_LINEAR_MIPMAP_NEAREST:
+      case GL_LINEAR_MIPMAP_LINEAR:
+        mipmaps   = true;
+        filtering = LinearFiltering;
+        break;
+      case GL_NEAREST:
+        filtering = NearestFiltering;
+        break;
+      case GL_LINEAR:
+        filtering = LinearFiltering;
+        break;
+      default:
+        break;
+      }
+    }
+
+    // Currently only supporting loading textures from files.
+    assert(image->uri);
+    assert(directory);
+    mstring fullpath =
+        mstring_concat_path(mstring_make(directory), mstring_make(image->uri));
+
+    load_texture_cmds[i] = (LoadTextureCmd){
+        .origin                = AssetFromFile,
+        .type                  = LoadTexture,
+        .colour_space          = sRGB,
+        .filtering             = filtering,
+        .wrap                  = wrap,
+        .mipmaps               = mipmaps,
+        .data.texture.filepath = fullpath};
+  }
+}
+
+/// Load a texture uniform.
+///
+/// This determines a texture's colour space based on its intended use, loads
+/// the texture, and then defines the sampler shader uniform.
+static bool load_texture_and_uniform(
+    const cgltf_data* data, Gfx* gfx, const cgltf_texture_view* texture_view,
+    TextureType texture_type, const Texture** textures,
+    LoadTextureCmd* load_texture_cmds, int* next_uniform, MaterialDesc* desc) {
+  assert(data);
+  assert(gfx);
+  assert(texture_view);
+  assert(textures);
+  assert(next_uniform);
+  assert(desc);
+  assert(*next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
+
+  const size_t texture_index = texture_view->texture - data->textures;
+  assert(texture_index < data->textures_count);
+
+  // Here we are assuming that if a texture is re-used, it is re-used with the
+  // same texture view. This should be fine because, e.g., a normal map would
+  // not be used as albedo and vice versa.
+  if (!textures[texture_index]) {
+    LoadTextureCmd* cmd = &load_texture_cmds[texture_index];
+    // TODO: Check for colour textures and default to LinearColourSpace instead.
+    if (texture_type == NormalMap) {
+      cmd->colour_space = LinearColourSpace;
+    }
+
+    LOGD(
+        "Load texture: %s (mipmaps: %d, filtering: %d)",
+        mstring_cstr(&cmd->data.texture.filepath), cmd->mipmaps,
+        cmd->filtering);
+
+    textures[texture_index] = gfx_load_texture(gfx, cmd);
+    if (!textures[texture_index]) {
+      log_error(
+          "Failed to load texture: %s",
+          mstring_cstr(&cmd->data.texture.filepath));
+      return false;
+    }
+  }
+
+  assert(*next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
+  desc->uniforms[(*next_uniform)++] = (ShaderUniform){
+      .name          = sstring_make(get_texture_uniform_name(texture_type)),
+      .type          = UniformTexture,
+      .value.texture = textures[texture_index]};
+
+  return true;
+}
+
+/// Load all materials from the glTF scene.
+///
+/// Return an array of Materials such that the index of each descriptor matches
+/// the index of each glTF material in the scene. Also return the number of
+/// materials and the textures used by them.
+static bool load_materials(
+    const cgltf_data* data, Gfx* gfx, LoadTextureCmd* load_texture_cmds,
+    const Texture** textures, Material** materials) {
+  assert(data);
+  assert(gfx);
+  assert(materials);
+  if (data->textures_count > 0) {
+    assert(load_texture_cmds);
+    assert(textures);
+  }
+
+  for (cgltf_size i = 0; i < data->materials_count; ++i) {
+    const cgltf_material* mat = &data->materials[i];
+
+    int          next_uniform = 0;
+    MaterialDesc desc         = {0};
+
+    // TODO: specular/glossiness and other material parameters.
+    if (mat->has_pbr_metallic_roughness) {
+      const cgltf_pbr_metallic_roughness* pbr = &mat->pbr_metallic_roughness;
+
+      assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
+      desc.uniforms[next_uniform++] = (ShaderUniform){
+          .name       = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
+          .type       = UniformVec4,
+          .value.vec4 = vec4_from_array(pbr->base_color_factor)};
+
+      assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
+      desc.uniforms[next_uniform++] = (ShaderUniform){
+          .name         = sstring_make(UNIFORM_METALLIC_FACTOR),
+          .type         = UniformFloat,
+          .value.scalar = pbr->metallic_factor};
+
+      assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
+      desc.uniforms[next_uniform++] = (ShaderUniform){
+          .name         = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
+          .type         = UniformFloat,
+          .value.scalar = pbr->roughness_factor};
+
+      assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
+      desc.uniforms[next_uniform++] = (ShaderUniform){
+          .name       = sstring_make(UNIFORM_EMISSIVE_FACTOR),
+          .type       = UniformVec3,
+          .value.vec3 = vec3_from_array(mat->emissive_factor)};
+
+      if (pbr->base_color_texture.texture) {
+        if (!load_texture_and_uniform(
+                data, gfx, &pbr->base_color_texture, BaseColorTexture, textures,
+                load_texture_cmds, &next_uniform, &desc)) {
+          return false;
+        }
+      }
+
+      if (pbr->metallic_roughness_texture.texture) {
+        if (!load_texture_and_uniform(
+                data, gfx, &pbr->metallic_roughness_texture,
+                MetallicRoughnessTexture, textures, load_texture_cmds,
+                &next_uniform, &desc)) {
+          return false;
+        }
+      }
+    }
+
+    if (mat->emissive_texture.texture) {
+      if (!load_texture_and_uniform(
+              data, gfx, &mat->emissive_texture, EmissiveTexture, textures,
+              load_texture_cmds, &next_uniform, &desc)) {
+        return false;
+      }
+    }
+
+    if (mat->occlusion_texture.texture) {
+      if (!load_texture_and_uniform(
+              data, gfx, &mat->occlusion_texture, AmbientOcclusionTexture,
+              textures, load_texture_cmds, &next_uniform, &desc)) {
+        return false;
+      }
+    }
+
+    if (mat->normal_texture.texture) {
+      if (!load_texture_and_uniform(
+              data, gfx, &mat->normal_texture, NormalMap, textures,
+              load_texture_cmds, &next_uniform, &desc)) {
+        return false;
+      }
+    }
+
+    assert(next_uniform < GFX_MAX_UNIFORMS_PER_MATERIAL);
+    desc.num_uniforms = next_uniform;
+
+    materials[i] = gfx_make_material(&desc);
+    if (!materials[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/// Create a default material for meshes that do not have a material.
+static Material* make_default_material() {
+  MaterialDesc desc = (MaterialDesc){0};
+
+  assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
+  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
+      .name       = sstring_make(UNIFORM_BASE_COLOR_FACTOR),
+      .type       = UniformVec4,
+      .value.vec4 = vec4_make(1, 1, 1, 1)};
+
+  assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
+  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
+      .name         = sstring_make(UNIFORM_METALLIC_FACTOR),
+      .type         = UniformFloat,
+      .value.scalar = 0};
+
+  assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
+  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
+      .name         = sstring_make(UNIFORM_ROUGHNESS_FACTOR),
+      .type         = UniformFloat,
+      .value.scalar = 1};
+
+  assert(desc.num_uniforms < GFX_MAX_UNIFORMS_PER_MATERIAL);
+  desc.uniforms[desc.num_uniforms++] = (ShaderUniform){
+      .name       = sstring_make(UNIFORM_EMISSIVE_FACTOR),
+      .type       = UniformVec3,
+      .value.vec3 = vec3_make(0, 0, 0)};
+
+  return gfx_make_material(&desc);
+}
+
+/// 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) {
+  aabb3 box = {0};
+  if (accessor->has_min && accessor->has_max) {
+    box = aabb3_make(
+        vec3_from_array(accessor->min), vec3_from_array(accessor->max));
+  } else {
+    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;
+}
+
+/// Load all meshes from the glTF scene.
+static bool load_meshes(
+    const cgltf_data* data, GfxCore* gfxcore, Buffer** buffers,
+    Buffer** tangent_buffers, const cgltfTangentBuffer* cgltf_tangent_buffers,
+    cgltf_size num_tangent_buffers, Material** materials,
+    ShaderProgram* const shader, size_t primitive_count, Geometry** geometries,
+    Mesh** meshes, SceneObject** scene_objects) {
+  // Walk through the mesh primitives to create Meshes. A GLTF mesh primitive
+  // has a material (Mesh) and vertex data (Geometry). A GLTF mesh maps to
+  // a SceneObject.
+  //
+  // glTF                      gfx
+  // ----                      ---
+  // Mesh                      SceneObject
+  // Mesh primitive            Mesh / Geometry
+  // Accessor + buffer view    BufferView
+  // Buffer                    Buffer
+  assert(data);
+  assert(gfxcore);
+  assert(buffers);
+  assert(materials);
+  assert(geometries);
+  assert(meshes);
+  assert(scene_objects);
+  if (num_tangent_buffers > 0) {
+    assert(tangent_buffers);
+    assert(cgltf_tangent_buffers);
+  }
+
+  // Points to the next available Mesh and also the next available Geometry.
+  // There is one (Mesh, Geometry) pair per glTF mesh primitive.
+  size_t next_mesh = 0;
+
+  for (cgltf_size m = 0; m < data->meshes_count; ++m) {
+    const cgltf_mesh* mesh = &data->meshes[m];
+
+    ObjectDesc object_desc = {0};
+
+    for (cgltf_size p = 0; p < mesh->primitives_count; ++p) {
+      assert(next_mesh < primitive_count);
+      const cgltf_primitive* prim = &mesh->primitives[p];
+      const cgltf_material*  mat  = prim->material;
+
+      MeshPermutation perm = {0};
+      if (mat) {
+        perm.has_normal_map    = mat->normal_texture.texture != 0;
+        perm.has_occlusion_map = mat->occlusion_texture.texture != 0;
+        perm.has_emissive_map  = mat->emissive_texture.texture != 0;
+
+        if (mat->has_pbr_metallic_roughness) {
+          const cgltf_pbr_metallic_roughness* pbr =
+              &mat->pbr_metallic_roughness;
+          perm.has_albedo_map = pbr->base_color_texture.texture != 0;
+          perm.has_metallic_roughness_map =
+              pbr->metallic_roughness_texture.texture != 0;
+        } else {
+          // TODO: specular/glossiness and other material parameters.
+        }
+      }
+
+      GeometryDesc geometry_desc = {
+          .type         = from_gltf_primitive_type(prim->type),
+          .buffer_usage = BufferStatic};
+
+      // Vertex indices.
+      if (prim->indices) {
+        const cgltf_accessor*    accessor     = prim->indices;
+        const cgltf_buffer_view* view         = prim->indices->buffer_view;
+        const cgltf_size         buffer_index = view->buffer - data->buffers;
+
+        assert(buffer_index < data->buffers_count);
+        Buffer* buffer = buffers[buffer_index];
+
+        const cgltf_size component_size =
+            get_component_size(accessor->component_type);
+        switch (component_size) {
+        case 1: {
+          BufferViewIdx8* indices = &geometry_desc.indices8;
+          // TODO: discards const qualifier.
+          indices->buffer           = buffer;
+          indices->offset_bytes     = accessor->offset + view->offset;
+          indices->size_bytes       = view->size;
+          indices->stride_bytes     = view->stride;
+          geometry_desc.num_indices = prim->indices->count;
+          break;
+        }
+        case 2: {
+          BufferViewIdx16* indices  = &geometry_desc.indices16;
+          indices->buffer           = buffer;
+          indices->offset_bytes     = accessor->offset + view->offset;
+          indices->size_bytes       = view->size;
+          indices->stride_bytes     = view->stride;
+          geometry_desc.num_indices = prim->indices->count;
+          break;
+        }
+        default:
+          // TODO: Handle 32-bit indices.
+          assert(false);
+          break;
+        }
+      }
+
+      // Vertex attributes.
+      for (cgltf_size a = 0; a < prim->attributes_count; ++a) {
+        const cgltf_attribute*   attrib       = &prim->attributes[a];
+        const cgltf_accessor*    accessor     = attrib->data;
+        const cgltf_buffer_view* view         = accessor->buffer_view;
+        const cgltf_size         offset       = accessor->offset + view->offset;
+        const cgltf_size         buffer_index = view->buffer - data->buffers;
+
+        assert(buffer_index < data->buffers_count);
+        Buffer* buffer = buffers[buffer_index];
+
+        BufferView2d*    buffer_view_2d    = 0;
+        BufferView3d*    buffer_view_3d    = 0;
+        BufferView4d*    buffer_view_4d    = 0;
+        BufferViewFloat* buffer_view_float = 0;
+        BufferViewU8*    buffer_view_u8    = 0;
+        BufferViewU16*   buffer_view_u16   = 0;
+
+        switch (attrib->type) {
+        case cgltf_attribute_type_position: {
+          switch (accessor->type) {
+          case cgltf_type_vec2:
+            assert(geometry_desc.positions3d.buffer == 0);
+            buffer_view_2d     = &geometry_desc.positions2d;
+            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);
+            break;
+          default:
+            FAIL(
+                "Unhandled accessor type %d in vertex positions",
+                accessor->type);
+            assert(false);
+            return false;
+          }
+          // It is assumed that meshes have positions, so there is nothing to
+          // do for the mesh permutation in this case.
+          break;
+        }
+        case cgltf_attribute_type_normal:
+          buffer_view_3d   = &geometry_desc.normals;
+          perm.has_normals = true;
+          break;
+        case cgltf_attribute_type_tangent:
+          buffer_view_4d    = &geometry_desc.tangents;
+          perm.has_tangents = true;
+          break;
+        case cgltf_attribute_type_texcoord:
+          buffer_view_2d     = &geometry_desc.texcoords;
+          perm.has_texcoords = true;
+          break;
+        case cgltf_attribute_type_color:
+          // TODO: Add support for color.
+          break;
+        case cgltf_attribute_type_joints:
+          // Joints can be either u8 or u16.
+          switch (accessor->component_type) {
+          case cgltf_component_type_r_8u:
+            buffer_view_u8 = &geometry_desc.joints.u8;
+            break;
+          case cgltf_component_type_r_16u:
+            buffer_view_u16 = &geometry_desc.joints.u16;
+            break;
+          default:
+            assert(false);
+            return false;
+          }
+          perm.has_joints = true;
+          break;
+        case cgltf_attribute_type_weights:
+          // Weights can be either u8, u16, or float.
+          switch (accessor->component_type) {
+          case cgltf_component_type_r_8u:
+            buffer_view_u8 = &geometry_desc.weights.u8;
+            break;
+          case cgltf_component_type_r_16u:
+            buffer_view_u16 = &geometry_desc.weights.u16;
+            break;
+          case cgltf_component_type_r_32f:
+            buffer_view_float = &geometry_desc.weights.floats;
+            break;
+          default:
+            assert(false);
+            return false;
+          }
+          perm.has_weights = true;
+          break;
+        case cgltf_attribute_type_invalid:
+          assert(false);
+          break;
+        }
+
+#define CONFIGURE_BUFFER(buf)         \
+  if (buf) {                          \
+    buf->buffer       = buffer;       \
+    buf->offset_bytes = offset;       \
+    buf->size_bytes   = view->size;   \
+    buf->stride_bytes = view->stride; \
+  }
+        CONFIGURE_BUFFER(buffer_view_2d);
+        CONFIGURE_BUFFER(buffer_view_3d);
+        CONFIGURE_BUFFER(buffer_view_4d);
+        CONFIGURE_BUFFER(buffer_view_u8);
+        CONFIGURE_BUFFER(buffer_view_u16);
+        CONFIGURE_BUFFER(buffer_view_float);
+      } // Vertex attributes.
+
+      assert(
+          (perm.has_joints && perm.has_weights) ||
+          (!perm.has_joints && !perm.has_weights));
+
+      // If the mesh primitive has no tangents, see if they were computed
+      // separately.
+      if (!geometry_desc.tangents.buffer) {
+        for (cgltf_size t = 0; t < num_tangent_buffers; ++t) {
+          const cgltfTangentBuffer* cgltf_buffer = &cgltf_tangent_buffers[t];
+
+          if (cgltf_buffer->primitive == prim) {
+            BufferView4d* view = &geometry_desc.tangents;
+            view->buffer       = tangent_buffers[t];
+            view->offset_bytes = 0;
+            view->size_bytes   = cgltf_buffer->size_bytes;
+            view->stride_bytes = 0; // Tightly packed.
+            break;
+          }
+        }
+      }
+
+      // Set the number of vertices in the geometry. Since a geometry can have
+      // either 2d or 3d positions but not both, here we can perform addition
+      // to compute the total number of vertices.
+      geometry_desc.num_verts =
+          (geometry_desc.positions2d.size_bytes / sizeof(vec2)) +
+          (geometry_desc.positions3d.size_bytes / sizeof(vec3));
+
+#define CHECK_COUNT(buffer_view, type, num_components)                 \
+  if (geometry_desc.buffer_view.buffer) {                              \
+    assert(                                                            \
+        (geometry_desc.buffer_view.size_bytes /                        \
+         (num_components * sizeof(type))) == geometry_desc.num_verts); \
+  }
+
+      // Check that the number of vertices is consistent across all vertex
+      // attributes.
+      CHECK_COUNT(normals, vec3, 1);
+      CHECK_COUNT(tangents, vec4, 1);
+      CHECK_COUNT(texcoords, vec2, 1);
+      CHECK_COUNT(joints.u8, uint8_t, 4);
+      CHECK_COUNT(joints.u16, uint16_t, 4);
+      CHECK_COUNT(weights.u8, uint8_t, 4);
+      CHECK_COUNT(weights.u16, uint16_t, 4);
+      CHECK_COUNT(weights.floats, float, 4);
+
+      Material* material = 0;
+      if (mat) {
+        const cgltf_size material_index = mat - data->materials;
+        assert(material_index < data->materials_count);
+        material = materials[material_index];
+      } else {
+        // Create a default  material for meshes that do not specify one.
+        material = make_default_material();
+      }
+      assert(material);
+
+      geometries[next_mesh] = gfx_make_geometry(gfxcore, &geometry_desc);
+      if (!geometries[next_mesh]) {
+        return false;
+      }
+
+      // If the user specifies a custom shader, use that instead. Otherwise
+      // compile a shader based on the mesh's permutation.
+      //
+      // Note that Gfx takes care of caching shaders and shader programs.
+      //
+      // Caching materials could be useful, but, provided they can share
+      // shaders, the renderer can check later whether uniforms have the same
+      // values. Also, changing uniforms is much faster than swapping shaders,
+      // so shader caching is the most important thing here.
+      ShaderProgram* mesh_shader =
+          shader ? shader : make_shader_permutation(gfxcore, perm);
+      assert(mesh_shader);
+
+      meshes[next_mesh] = gfx_make_mesh(&(MeshDesc){
+          .geometry = geometries[next_mesh],
+          .material = material,
+          .shader   = mesh_shader});
+
+      if (!meshes[next_mesh]) {
+        return false;
+      }
+
+      assert(object_desc.num_meshes < GFX_MAX_NUM_MESHES);
+      object_desc.meshes[object_desc.num_meshes] = meshes[next_mesh];
+      object_desc.num_meshes++;
+
+      ++next_mesh;
+    } // glTF mesh primitive / gfx Mesh.
+
+    scene_objects[m] = gfx_make_object(&object_desc);
+    if (!scene_objects[m]) {
+      return false;
+    }
+  } // glTF mesh / gfx SceneObject.
+
+  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
+/// are the joints). However, we want to map the "base joint" (the joint/node
+/// with the smallest index) to 0 in the AnimaDesc's joint array. We can do this
+/// by subtracting the "base node index" from every joint index or channel
+/// target.
+///
+/// There is an assumption in the animation library that joints are contiguous
+/// anyway, so this "base joint index" works provided the joint nodes are also
+/// contiguous in the glTF. The glTF does not guarantee this, but I think it's
+/// a reasonable assumption that exporters write glTF files in such a way, and
+/// Blender does appear to do so.
+cgltf_size find_base_joint_index(const cgltf_data* data) {
+  assert(data);
+
+  cgltf_size base_joint_index = (cgltf_size)-1;
+
+  for (cgltf_size s = 0; s < data->skins_count; ++s) {
+    const cgltf_skin* skin = &data->skins[s];
+    for (cgltf_size j = 0; j < skin->joints_count; ++j) {
+      // Joint is an index/pointer into the nodes array.
+      const cgltf_size node_index = skin->joints[j] - data->nodes;
+      assert(node_index < data->nodes_count);
+      // Min.
+      if (node_index < base_joint_index) {
+        base_joint_index = node_index;
+      }
+    }
+  }
+
+  return base_joint_index;
+}
+
+/// Load all skins (Gfx skeletons) from the glTF scene.
+/// Return the total number of joints.
+static size_t load_skins(
+    const cgltf_data* data, Buffer* const* buffers, cgltf_size base_joint_index,
+    AnimaDesc* anima_desc) {
+  assert(data);
+  assert(buffers);
+  assert(anima_desc);
+  assert(base_joint_index < data->nodes_count);
+
+  // Determines whether the ith joint in the node hierarchy is a joint node.
+  // This is then used to determine whether a joint is a root of the joint
+  // hierarchy.
+  bool is_joint_node[GFX_MAX_NUM_JOINTS] = {false};
+
+  size_t num_joints = 0;
+
+  for (cgltf_size s = 0; s < data->skins_count; ++s) {
+    const cgltf_skin*     skin              = &data->skins[s];
+    const cgltf_accessor* matrices_accessor = skin->inverse_bind_matrices;
+    assert(matrices_accessor->count == skin->joints_count);
+
+    num_joints += skin->joints_count;
+    assert(num_joints < GFX_MAX_NUM_JOINTS);
+
+    SkeletonDesc* skeleton_desc = &anima_desc->skeletons[s];
+    *skeleton_desc = (SkeletonDesc){.num_joints = skin->joints_count};
+
+    // for (cgltf_size j = 0; j < skin->joints_count; ++j) {
+    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;
+      assert(node_index < data->nodes_count);
+
+      const cgltf_size parent_node_index =
+          skin->joints[i]->parent - data->nodes;
+      assert(parent_node_index < data->nodes_count);
+
+      // Subtract the base index to pack the joints as tightly as possible in
+      // the AnimaDesc.
+      assert(node_index >= base_joint_index);
+      const cgltf_size joint_index = node_index - base_joint_index;
+
+      assert(parent_node_index >= base_joint_index);
+      const cgltf_size parent_index = parent_node_index - base_joint_index;
+
+      skeleton_desc->joints[i] = joint_index;
+
+      JointDesc* joint_desc       = &anima_desc->joints[joint_index];
+      joint_desc->parent          = parent_index;
+      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.
+    // if (skin->skeleton) {
+    //  //      cgltf_size root_index = skin->skeleton - data->nodes;
+    //  //      assert(root_index <= data->nodes_count);
+    //  //      root_node = nodes[root_index];
+    //  assert(false);
+    //}
+  }
+
+  // Animation library assumes that joints are contiguous.
+  for (size_t i = 0; i < num_joints; ++i) {
+    assert(is_joint_node[i]);
+  }
+
+  // Insert the root joint.
+  // This is the root of all skeletons. It is, specifically, the root of all
+  // joints that do not have a parent; skins (skeletons) in glTF are not
+  // guaranteed to have a common parent, but are generally a set of disjoint
+  // trees.
+  const size_t root_index = num_joints;
+  assert(root_index < GFX_MAX_NUM_JOINTS);
+  anima_desc->joints[root_index] = (JointDesc){.parent = INDEX_NONE};
+  num_joints++;
+
+  // Make root joints point to the root joint at index N.
+  // The root joints are the ones that have a non-joint node in the glTF as a
+  // parent.
+  for (size_t i = 0; i < root_index; ++i) {
+    JointDesc* joint = &anima_desc->joints[i];
+    if ((joint->parent >= root_index) || !is_joint_node[joint->parent]) {
+      joint->parent = root_index;
+    }
+  }
+
+  return num_joints;
+}
+
+/// Load all animations from the glTF scene.
+static void load_animations(
+    const cgltf_data* data, cgltf_size base_joint_index,
+    AnimaDesc* anima_desc) {
+  assert(data);
+  assert(anima_desc);
+  assert(base_joint_index < data->nodes_count);
+  assert(data->animations_count <= GFX_MAX_NUM_ANIMATIONS);
+
+  for (cgltf_size a = 0; a < data->animations_count; ++a) {
+    const cgltf_animation* animation      = &data->animations[a];
+    AnimationDesc*         animation_desc = &anima_desc->animations[a];
+
+    *animation_desc = (AnimationDesc){
+        .name         = sstring_make(animation->name),
+        .num_channels = animation->channels_count};
+
+    assert(animation->channels_count <= GFX_MAX_NUM_CHANNELS);
+    for (cgltf_size c = 0; c < animation->channels_count; ++c) {
+      const cgltf_animation_channel* channel = &animation->channels[c];
+      ChannelDesc* channel_desc              = &animation_desc->channels[c];
+      const cgltf_animation_sampler* sampler = channel->sampler;
+
+      const size_t target_index = channel->target_node - data->nodes;
+      assert(target_index < data->nodes_count);
+
+      assert(target_index >= base_joint_index);
+      const size_t tight_target_index = target_index - base_joint_index;
+      assert(tight_target_index < anima_desc->num_joints);
+
+      *channel_desc = (ChannelDesc){
+          .target        = tight_target_index,
+          .type          = from_gltf_animation_path_type(channel->target_path),
+          .interpolation = from_gltf_interpolation_type(sampler->interpolation),
+          .num_keyframes = 0};
+
+      // Read time inputs.
+      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: {
+        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: {
+        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;
+      }
+    }
+  }
+}
+
+/// Load all nodes from the glTF scene.
+///
+/// This function ignores the many scenes and default scene of the glTF spec
+/// and instead just loads all nodes into a single gfx Scene.
+static void load_nodes(
+    const cgltf_data* data, SceneNode* root_node, SceneObject** objects,
+    SceneCamera** cameras, const Anima* anima, SceneNode** nodes) {
+  // Note that with glTF 2.0, nodes do not form a DAG / scene graph but a
+  // disjount union of strict trees:
+  //
+  // "For Version 2.0 conformance, the glTF node hierarchy is not a directed
+  // acyclic graph (DAG) or scene graph, but a disjoint union of strict trees.
+  // That is, no node may be a direct descendant of more than one node. This
+  // restriction is meant to simplify implementation and facilitate
+  // conformance."
+  //
+  // This matches the gfx library implementation, where every node can have at
+  // most one parent.
+  assert(data);
+  assert(root_node);
+  assert(objects);
+  assert(cameras);
+  assert(nodes);
+
+  cgltf_size next_camera = 0;
+
+  for (cgltf_size n = 0; n < data->nodes_count; ++n) {
+    const cgltf_node* node = &data->nodes[n];
+
+    // Add SceneObject, SceneCamera or Lights.
+    // TODO: Handle lights once they are implemented in the gfx library.
+    if (node->mesh) {
+      const cgltf_size mesh_index = node->mesh - data->meshes;
+      assert(mesh_index < data->meshes_count);
+      SceneObject* object = objects[mesh_index];
+      gfx_construct_object_node(nodes[n], object);
+
+      if (node->skin) {
+        assert(anima);
+
+        const cgltf_size skin_index = node->skin - data->skins;
+        assert(skin_index < data->skins_count);
+        const Skeleton* skeleton = gfx_get_anima_skeleton(anima, skin_index);
+        gfx_set_object_skeleton(object, skeleton);
+      }
+    } else if (node->camera) {
+      assert(next_camera < data->cameras_count);
+
+      Camera              camera;
+      const cgltf_camera* cam = node->camera;
+
+      // TODO: We could define a function load_cameras() the same way we load
+      // every mesh and then remove this ad-hoc loading of cameras here, as well
+      // as remove 'next_camera'.
+      switch (cam->type) {
+      case cgltf_camera_type_orthographic:
+        camera = camera_orthographic(
+            0, cam->data.orthographic.xmag, 0, cam->data.orthographic.ymag,
+            cam->data.orthographic.znear, cam->data.orthographic.zfar);
+        break;
+      case cgltf_camera_type_perspective:
+        camera = camera_perspective(
+            cam->data.perspective.yfov, cam->data.perspective.aspect_ratio,
+            cam->data.perspective.znear, cam->data.perspective.zfar);
+        break;
+      case cgltf_camera_type_invalid:
+        break;
+      }
+
+      gfx_set_camera_camera(cameras[next_camera], &camera);
+      gfx_construct_camera_node(nodes[n], cameras[next_camera]);
+      ++next_camera;
+    } else {
+      // TODO: implementation for missing node types.
+      // These nodes currently default to logical nodes.
+    }
+    assert(nodes[n]);
+
+    // Set transform.
+    mat4 transform;
+    if (node->has_matrix) {
+      transform = mat4_from_array(node->matrix);
+    } else {
+      transform = mat4_id();
+      if (node->has_scale) {
+        const mat4 scale = mat4_scale(vec3_from_array(node->scale));
+        transform        = mat4_mul(transform, scale);
+      }
+      if (node->has_rotation) {
+        const quat q      = quat_from_array(node->rotation);
+        const mat4 rotate = mat4_from_quat(q);
+        transform         = mat4_mul(transform, rotate);
+      }
+      if (node->has_translation) {
+        const mat4 translate =
+            mat4_translate(vec3_from_array(node->translation));
+        transform = mat4_mul(translate, transform);
+      }
+    }
+    gfx_set_node_transform(nodes[n], &transform);
+
+    // If this is a top-level node in the glTF scene, set its parent to the
+    // given root node.
+    if (!node->parent) {
+      gfx_set_node_parent(nodes[n], root_node);
+    } else {
+      const cgltf_size parent_index = node->parent - data->nodes;
+      assert(parent_index < data->nodes_count);
+      SceneNode* parent = nodes[parent_index];
+      assert(parent);
+      gfx_set_node_parent(nodes[n], parent);
+    }
+  } // SceneNode.
+}
+
+/// Remove joint nodes from the Gfx Scene.
+///
+/// Joint nodes are not needed because joints are packed into the Anima.
+static void remove_joint_nodes(
+    const cgltf_data* data, SceneNode** scene_nodes) {
+  assert(data);
+  assert(scene_nodes);
+
+  // This works assuming the joint nodes are contiguous. Contiguity is checked
+  // when loading skins. See load_skins().
+  size_t min_joint_index = (size_t)-1;
+  size_t max_joint_index = 0;
+
+  // First get the minimum and maximum indices of all joint nodes.
+  for (cgltf_size s = 0; s < data->skins_count; ++s) {
+    const cgltf_skin* skin = &data->skins[s];
+
+    for (cgltf_size j = 0; j < skin->joints_count; ++j) {
+      // Joint is an index/pointer into the nodes array.
+      const cgltf_size joint_index = skin->joints[j] - data->nodes;
+      assert(joint_index < data->nodes_count);
+
+      if (joint_index < min_joint_index) {
+        min_joint_index = joint_index;
+      }
+      if (joint_index > max_joint_index) {
+        max_joint_index = joint_index;
+      }
+    }
+  }
+
+  assert(min_joint_index < data->nodes_count);
+  assert(max_joint_index < data->nodes_count);
+
+  // Now walk over the joint nodes. If a joint's parent is itself not a joint
+  // node, then that joint is a root of a joint hierarchy (skins in glTF may
+  // have multiple roots). In such case, delete the root joint recursively.
+  for (cgltf_size s = 0; s < data->skins_count; ++s) {
+    const cgltf_skin* skin = &data->skins[s];
+
+    for (cgltf_size j = 0; j < skin->joints_count; ++j) {
+      // Joint is an index/pointer into the nodes array.
+      const cgltf_size joint_index = skin->joints[j] - data->nodes;
+      assert(joint_index < data->nodes_count);
+
+      const cgltf_node* joint = &data->nodes[joint_index];
+
+      // Parent node index.
+      const cgltf_size parent_index = joint->parent - data->nodes;
+      assert(parent_index < data->nodes_count);
+
+      // If the parent is not a joint node, recursively delete this joint node.
+      if ((parent_index < min_joint_index) ||
+          (parent_index > max_joint_index)) {
+        gfx_destroy_node(&scene_nodes[joint_index]);
+      }
+    }
+  }
+}
+
+/// Load all scenes from the glTF file.
+///
+/// If the scene is loaded from memory, set filepath = null.
+///
+/// This function ignores the many scenes and default scene of the glTF spec
+/// and instead just loads all scenes into a single Gfx Scene.
+static Model* load_scene(
+    cgltf_data* data, Gfx* gfx, const mstring* filepath, ShaderProgram* shader,
+    const cgltfTangentBuffer* cgltf_tangent_buffers,
+    cgltf_size                num_tangent_buffers) {
+  // In a GLTF scene, buffers can be shared among meshes, meshes among nodes,
+  // etc. Each object is referenced by its index in the relevant array. Here we
+  // do a button-up construction, first allocating our own graphics objects in
+  // the same quantities and then re-using the GLTF indices to index these
+  // arrays.
+  //
+  // For simplicity, this function also handles all of the cleanup. Arrays are
+  // allocated up front, and the helper functions construct their elements. If
+  // an error is encountered, the helper functions can simply return and this
+  // function cleans up any intermediate objects that had been created up until
+  // the point of failure.
+  //
+  // Loading animation data:
+  //   - Buffers with animation sampler data need to stay on the CPU, not
+  //     uploaded to the GPU. We could try to implement GPU animation at a later
+  //     stage.
+  assert(data);
+  assert(gfx);
+  assert(filepath);
+  assert((num_tangent_buffers == 0) || (cgltf_tangent_buffers != 0));
+
+  bool success = false;
+
+  GfxCore*     gfxcore         = gfx_get_core(gfx);
+  const size_t primitive_count = get_total_primitives(data);
+
+  const mstring directory = mstring_dirname(*filepath);
+  LOGD("Filepath: %s", mstring_cstr(filepath));
+  LOGD("Directory: %s", mstring_cstr(&directory));
+
+  Buffer**        tangent_buffers   = 0;
+  Buffer**        buffers           = 0;
+  LoadTextureCmd* load_texture_cmds = 0;
+  const Texture** textures          = 0; // Textures are owned by asset cache.
+  Material**      materials         = 0;
+  Geometry**      geometries        = 0;
+  Mesh**          meshes            = 0;
+  AnimaDesc*      anima_desc        = 0;
+  SceneObject**   scene_objects     = 0;
+  SceneCamera**   scene_cameras     = 0;
+  SceneNode**     scene_nodes       = 0;
+  Anima*          anima             = 0;
+  SceneNode*      root_node         = 0;
+  Model*          model             = 0;
+
+  tangent_buffers = calloc(num_tangent_buffers, sizeof(Buffer*));
+  buffers         = calloc(data->buffers_count, sizeof(Buffer*));
+  textures        = calloc(data->textures_count, sizeof(Texture*));
+  materials       = calloc(data->materials_count, sizeof(Material*));
+  geometries      = calloc(primitive_count, sizeof(Geometry*));
+  meshes          = calloc(primitive_count, sizeof(Mesh*));
+  scene_objects   = calloc(data->meshes_count, sizeof(SceneObject*));
+  scene_cameras   = calloc(data->cameras_count, sizeof(SceneCamera**));
+  scene_nodes     = calloc(data->nodes_count, sizeof(SceneNode**));
+  // A glTF scene does not necessarily have textures. Materials can be given
+  // as constants, for example.
+  if (data->textures_count > 0) {
+    load_texture_cmds = calloc(data->textures_count, sizeof(LoadTextureCmd));
+  }
+
+  if (!buffers || !tangent_buffers ||
+      ((data->textures_count > 0) && !load_texture_cmds) || !textures ||
+      !materials || !geometries || !meshes || !scene_objects ||
+      !scene_cameras || !scene_nodes) {
+    goto cleanup;
+  }
+
+  if ((num_tangent_buffers > 0) &&
+      !load_tangent_buffers(
+          cgltf_tangent_buffers, num_tangent_buffers, gfxcore,
+          tangent_buffers)) {
+    goto cleanup;
+  }
+
+  if (!load_buffers(data, gfxcore, buffers)) {
+    goto cleanup;
+  }
+
+  if (data->textures_count > 0) {
+    load_textures_lazy(
+        data, gfxcore, mstring_cstr(&directory), load_texture_cmds);
+  }
+
+  if (!load_materials(data, gfx, load_texture_cmds, textures, materials)) {
+    goto cleanup;
+  }
+
+  if (!load_meshes(
+          data, gfxcore, buffers, tangent_buffers, cgltf_tangent_buffers,
+          num_tangent_buffers, materials, shader, primitive_count, geometries,
+          meshes, scene_objects)) {
+    goto cleanup;
+  }
+
+  // Skins refer to nodes, and nodes may refer to skins. To break this circular
+  // dependency, glTF defines skins in terms of node indices. We could do the
+  // same if Gfx allowed allocating nodes contiguously in memory. For now,
+  // create the nodes up front and use the indices of the array to map to the
+  // node_idx.
+  for (cgltf_size i = 0; i < data->nodes_count; ++i) {
+    scene_nodes[i] = gfx_make_node();
+  }
+
+  // Create the scene's root node.
+  // This is an anima node if the scene has skins; otherwise it is a logical
+  // node.
+  root_node = gfx_make_node();
+  if (data->skins_count > 0) {
+    anima_desc = calloc(1, sizeof(AnimaDesc));
+    if (!anima_desc) {
+      goto cleanup;
+    }
+
+    const cgltf_size base = find_base_joint_index(data);
+
+    anima_desc->num_skeletons  = data->skins_count;
+    anima_desc->num_animations = data->animations_count;
+    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);
+  }
+
+  // The root node becomes the root of all scene nodes.
+  load_nodes(data, root_node, scene_objects, scene_cameras, anima, scene_nodes);
+
+  // Clean up scene nodes that correspond to joints in the glTF. These are
+  // not needed anymore.
+  if (data->skins_count > 0) {
+    remove_joint_nodes(data, scene_nodes);
+  }
+
+  model = gfx_make_model(root_node);
+
+  success = true;
+
+cleanup:
+  // The arrays of resources are no longer needed. The resources themselves are
+  // destroyed only if this function fails.
+  if (tangent_buffers) {
+    if (!success) {
+      for (cgltf_size i = 0; i < num_tangent_buffers; ++i) {
+        if (tangent_buffers[i]) {
+          gfx_destroy_buffer(gfxcore, &tangent_buffers[i]);
+        }
+      }
+    }
+    free(tangent_buffers);
+  }
+  if (buffers) {
+    if (!success) {
+      for (cgltf_size i = 0; i < data->buffers_count; ++i) {
+        if (buffers[i]) {
+          gfx_destroy_buffer(gfxcore, &buffers[i]);
+        }
+      }
+    }
+    free(buffers);
+  }
+  if (load_texture_cmds) {
+    free(load_texture_cmds);
+  }
+  if (textures) {
+    free(textures);
+  }
+  if (materials) {
+    if (!success) {
+      for (cgltf_size i = 0; i < data->materials_count; ++i) {
+        if (materials[i]) {
+          gfx_destroy_material(&materials[i]);
+        }
+      }
+    }
+    free(materials);
+  }
+  if (geometries) {
+    if (!success) {
+      for (size_t i = 0; i < primitive_count; ++i) {
+        if (geometries[i]) {
+          gfx_destroy_geometry(gfxcore, &geometries[i]);
+        }
+      }
+    }
+    free(geometries);
+  }
+  if (meshes) {
+    if (!success) {
+      for (size_t i = 0; i < primitive_count; ++i) {
+        if (meshes[i]) {
+          gfx_destroy_mesh(&meshes[i]);
+        }
+      }
+    }
+    free(meshes);
+  }
+  if (anima_desc) {
+    free(anima_desc);
+  }
+  if (scene_objects) {
+    if (!success) {
+      for (cgltf_size i = 0; i < data->meshes_count; ++i) {
+        if (scene_objects[i]) {
+          gfx_destroy_object(&scene_objects[i]);
+        }
+      }
+    }
+    free(scene_objects);
+  }
+  if (scene_cameras) {
+    if (!success) {
+      for (cgltf_size i = 0; i < data->cameras_count; ++i) {
+        if (scene_cameras[i]) {
+          gfx_destroy_camera(&scene_cameras[i]);
+        }
+      }
+    }
+    free(scene_cameras);
+  }
+  if (scene_nodes) {
+    if (!success) {
+      for (cgltf_size i = 0; i < data->nodes_count; ++i) {
+        if (scene_nodes[i]) {
+          gfx_destroy_node(&scene_nodes[i]);
+        }
+      }
+    }
+    free(scene_nodes);
+  }
+  if (!success) {
+    if (root_node) {
+      gfx_destroy_node(&root_node); // Node owns the anima.
+    } else if (anima) {
+      gfx_destroy_anima(&anima);
+    }
+  }
+  return model;
+}
+
+Model* gfx_model_load(Gfx* gfx, const LoadModelCmd* cmd) {
+  assert(gfx);
+  assert(cmd);
+
+  Model* model = 0;
+
+  cgltf_options       options         = {0};
+  cgltf_data*         data            = NULL;
+  cgltfTangentBuffer* tangent_buffers = 0;
+
+  cgltf_result result;
+  switch (cmd->origin) {
+  case AssetFromFile:
+    result = cgltf_parse_file(&options, mstring_cstr(&cmd->filepath), &data);
+    break;
+  case AssetFromMemory:
+    result = cgltf_parse(&options, cmd->data, cmd->size_bytes, &data);
+    break;
+  }
+  if (result != cgltf_result_success) {
+    goto cleanup;
+  }
+
+  if (cmd->origin == AssetFromFile) {
+    // Must call cgltf_load_buffers() to load buffer data.
+    result = cgltf_load_buffers(&options, data, mstring_cstr(&cmd->filepath));
+    if (result != cgltf_result_success) {
+      goto cleanup;
+    }
+  }
+
+  // Compute tangents for normal-mapped models that are missing them.
+  cgltf_size num_tangent_buffers = 0;
+  cgltf_compute_tangents(
+      &options, data, &tangent_buffers, &num_tangent_buffers);
+
+  model = load_scene(
+      data, gfx, &cmd->filepath, cmd->shader, tangent_buffers,
+      num_tangent_buffers);
+
+cleanup:
+  if (data) {
+    cgltf_free(data);
+  }
+  if (tangent_buffers) {
+    free(tangent_buffers);
+  }
+  return model;
+}
diff --git a/src/asset/model.h b/src/asset/model.h
new file mode 100644
index 0000000..d6399b1
--- /dev/null
+++ b/src/asset/model.h
@@ -0,0 +1,12 @@
+/// Load scene files.
+#pragma once
+
+#include <gfx/asset.h>
+
+typedef struct Gfx   Gfx;
+typedef struct Model Model;
+
+/// Load a model.
+///
+/// Currently only supports the GLTF format.
+Model* gfx_model_load(Gfx*, const LoadModelCmd*);
diff --git a/src/asset/texture.c b/src/asset/texture.c
new file mode 100644
index 0000000..c790394
--- /dev/null
+++ b/src/asset/texture.c
@@ -0,0 +1,177 @@
+#include "texture.h"
+
+#include "gfx/core.h"
+
+#include "error.h"
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "stb_image.h"
+
+#include <assert.h>
+
+static void flip_horizontally(
+    unsigned char* pixels, int width, int height, int components) {
+  assert(pixels);
+
+  for (int y = 0; y < height; ++y) {
+    for (int x = 0; x < width / 2; ++x) {
+      unsigned char* p1 = &pixels[(y * width + x) * components];
+      unsigned char* p2 = &pixels[(y * width + (width - x - 1)) * components];
+
+      for (int c = 0; c < components; ++c) {
+        unsigned char tmp = *p1;
+        *p1               = *p2;
+        *p2               = tmp;
+        p1++;
+        p2++;
+      }
+    }
+  }
+}
+
+// Note that the cubemap coordinate system uses the one in RenderMan:
+//
+//   https://www.khronos.org/opengl/wiki/Cubemap_Texture
+//
+// This is what happens:
+//
+//   - Cubemaps follow a left-handed coordinate system. Say, +X is right, +Y is
+//     up, and +Z is forward.
+//   - The texture coordinate system follow's DirectX's, so +V goes down, not up
+//     like it does in OpenGL.
+//
+// For this reason, we do X and Y flips when doing cubemap textures so that we
+// can sample cubemaps as if they were given in the usual OpenGL coordinate
+// system.
+Texture* gfx_texture_load(GfxCore* gfxcore, const LoadTextureCmd* cmd) {
+  assert(gfxcore);
+  assert(cmd);
+  assert(cmd->origin == AssetFromFile || cmd->origin == AssetFromMemory);
+  assert(cmd->type == LoadTexture || cmd->type == LoadCubemap);
+
+  int            width, height, components, old_components;
+  unsigned char* pixels[6] = {0};
+
+  switch (cmd->origin) {
+  case AssetFromFile:
+    switch (cmd->type) {
+    case LoadTexture: {
+      const char* filepath = mstring_cstr(&cmd->data.texture.filepath);
+      stbi_set_flip_vertically_on_load(0);
+      pixels[0] = stbi_load(filepath, &width, &height, &components, 0);
+      if (!pixels[0]) {
+        log_error("Failed to load texture file: %s", filepath);
+      }
+      break;
+    }
+    case LoadCubemap:
+      for (int i = 0; i < 6; ++i) {
+        // Flip +Y and -Y textures vertically.
+        stbi_set_flip_vertically_on_load(((i == 2) || (i == 3)) ? 1 : 0);
+        const char* filepath =
+            mstring_cstr(&cmd->data.cubemap.filepaths.filepath_pos_x + i);
+        stbi_uc* image_pixels =
+            stbi_load(filepath, &width, &height, &components, 0);
+        if (!image_pixels) {
+          log_error("Failed to load texture file: %s", filepath);
+          break;
+        }
+        if (i > 0 && components != old_components) {
+          log_error("All textures in a cubemap must have the same number of "
+                    "components");
+          break;
+        }
+        if ((i != 2) && (i != 3)) {
+          flip_horizontally(image_pixels, width, height, components);
+        }
+        pixels[i]      = image_pixels;
+        old_components = components;
+      }
+      break;
+    }
+    break;
+  case AssetFromMemory:
+    // TODO: Load textures from memory.
+    log_error("Loading textures from memory is not yet implemented");
+    return 0;
+  }
+
+  // Error out if we failed to load a texture.
+  if (!pixels[0] ||
+      (cmd->type == LoadCubemap &&
+       (!pixels[1] || !pixels[2] || !pixels[3] || !pixels[4] || !pixels[5]))) {
+    for (int i = 0; i < 6; ++i) {
+      if (pixels[i]) {
+        stbi_image_free(pixels[i]);
+      }
+    }
+    return 0;
+  }
+
+  TextureDesc desc = (TextureDesc){0};
+  desc.width       = width;
+  desc.height      = height;
+
+  switch (cmd->type) {
+  case LoadTexture:
+    desc.dimension = Texture2D;
+    break;
+  case LoadCubemap:
+    desc.dimension = TextureCubeMap;
+    break;
+  }
+
+  switch (components) {
+  case 3:
+    switch (cmd->colour_space) {
+    case LinearColourSpace:
+      desc.format = TextureRGB8;
+      break;
+    case sRGB:
+      desc.format = TextureSRGB8;
+      break;
+    default:
+      log_error("Unsupported texture colour space: %d", cmd->colour_space);
+      return 0;
+    }
+    break;
+  case 4:
+    switch (cmd->colour_space) {
+    case LinearColourSpace:
+      desc.format = TextureRGBA8;
+      break;
+    case sRGB:
+      desc.format = TextureSRGBA8;
+      break;
+    default:
+      log_error("Unsupported texture colour space: %d", cmd->colour_space);
+      return 0;
+    }
+    break;
+  default:
+    log_error("Unsupported number of texture components: %d", components);
+    return 0;
+  }
+
+  desc.filtering = cmd->filtering;
+  desc.mipmaps   = cmd->mipmaps;
+
+  switch (cmd->type) {
+  case LoadTexture:
+    desc.data.pixels = pixels[0];
+    break;
+  case LoadCubemap:
+    for (int i = 0; i < 6; ++i) {
+      *(&desc.data.cubemap.pixels_pos_x + i) = pixels[i];
+    }
+    break;
+  }
+
+  Texture* texture = gfx_make_texture(gfxcore, &desc);
+  for (int i = 0; i < 6; ++i) {
+    if (pixels[i]) {
+      stbi_image_free(pixels[i]);
+    }
+  }
+  return texture;
+}
diff --git a/src/asset/texture.h b/src/asset/texture.h
new file mode 100644
index 0000000..0d38bd9
--- /dev/null
+++ b/src/asset/texture.h
@@ -0,0 +1,7 @@
+/// Load textures from images.
+#pragma once
+
+#include <gfx/asset.h>
+
+/// Load a texture.
+Texture* gfx_texture_load(GfxCore*, const LoadTextureCmd*);