Simplify cleanup in the scene loader.

1 files changed, 156 insertions, 315 deletions

diff --git a/gfx/src/util/scene.c b/gfx/src/util/scene.c
index dc97259..706e518 100644
--- a/gfx/src/util/scene.c
+++ b/gfx/src/util/scene.c
@@ -207,80 +207,44 @@ static size_t get_total_primitives(const cgltf_data* data) {
 ///
 /// 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.
-static Buffer** load_buffers(
-    const cgltf_data* data, RenderBackend* render_backend,
-    cgltf_size* num_buffers) {
+static bool load_buffers(
+    const cgltf_data* data, RenderBackend* render_backend, Buffer** buffers) {
   assert(data);
   assert(render_backend);
-  assert(num_buffers);
-
-  Buffer** buffers = 0;
-
-  buffers = calloc(data->buffers_count, sizeof(Buffer*));
-  if (!buffers) {
-    goto cleanup;
-  }
+  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(render_backend, buffer->data, buffer->size);
     if (!buffers[i]) {
-      goto cleanup;
+      return false;
     }
   }
-  *num_buffers = data->buffers_count;
-  return buffers;
 
-cleanup:
-  if (buffers) {
-    for (cgltf_size i = 0; i < data->buffers_count; ++i) {
-      if (buffers[i]) {
-        gfx_destroy_buffer(render_backend, &buffers[i]);
-      }
-    }
-    free(buffers);
-  }
-  *num_buffers = 0;
-  return 0;
+  return true;
 }
 
 /// Load tangent buffers.
-static Buffer** load_tangent_buffers(
-    const cgltfTangentBuffer* tangent_buffers, cgltf_size num_tangent_buffers,
-    RenderBackend* render_backend) {
-  assert(tangent_buffers);
+static bool load_tangent_buffers(
+    const cgltfTangentBuffer* cgltf_tangent_buffers,
+    cgltf_size num_tangent_buffers, RenderBackend* render_backend,
+    Buffer** tangent_buffers) {
+  assert(cgltf_tangent_buffers);
   assert(render_backend);
-
-  Buffer** buffers = 0;
-
-  buffers = calloc(num_tangent_buffers, sizeof(Buffer*));
-  if (!buffers) {
-    goto cleanup;
-  }
+  assert(tangent_buffers);
 
   for (cgltf_size i = 0; i < num_tangent_buffers; ++i) {
-    const cgltfTangentBuffer* buffer = &tangent_buffers[i];
+    const cgltfTangentBuffer* buffer = &cgltf_tangent_buffers[i];
     assert(buffer->data);
-    buffers[i] =
+    tangent_buffers[i] =
         gfx_make_buffer(render_backend, buffer->data, buffer->size_bytes);
-    if (!buffers[i]) {
-      goto cleanup;
+    if (!tangent_buffers[i]) {
+      return false;
     }
   }
 
-  return buffers;
-
-cleanup:
-  if (buffers) {
-    for (cgltf_size i = 0; i < num_tangent_buffers; ++i) {
-      if (buffers[i]) {
-        gfx_destroy_buffer(render_backend, &buffers[i]);
-      }
-    }
-    free(buffers);
-  }
-  return 0;
+  return true;
 }
 
 /// Lazily load all textures from the glTF scene.
@@ -294,24 +258,13 @@ cleanup:
 /// 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. Also return the number of
-/// textures.
-///
-/// Return true on success (all textures processed or no textures in the
-/// scene), false otherwise.
-static bool load_textures_lazy(
+/// the index of each glTF texture in the scene.
+static void load_textures_lazy(
     const cgltf_data* data, RenderBackend* render_backend,
-    const char* directory, LoadTextureCmd** load_texture_cmds,
-    cgltf_size* num_textures) {
+    const char* directory, LoadTextureCmd* load_texture_cmds) {
   assert(data);
   assert(render_backend);
   assert(load_texture_cmds);
-  assert(num_textures);
-
-  *load_texture_cmds = calloc(data->textures_count, sizeof(LoadTextureCmd));
-  if (!*load_texture_cmds) {
-    goto cleanup;
-  }
 
   for (cgltf_size i = 0; i < data->textures_count; ++i) {
     const cgltf_texture* texture = &data->textures[i];
@@ -359,7 +312,7 @@ static bool load_textures_lazy(
     mstring fullpath =
         mstring_concat_path(mstring_make(directory), mstring_make(image->uri));
 
-    (*load_texture_cmds)[i] = (LoadTextureCmd){
+    load_texture_cmds[i] = (LoadTextureCmd){
         .origin                = TextureFromFile,
         .type                  = LoadTexture,
         .colour_space          = sRGB,
@@ -368,16 +321,6 @@ static bool load_textures_lazy(
         .mipmaps               = mipmaps,
         .data.texture.filepath = fullpath};
   }
-
-  *num_textures = data->textures_count;
-  return true;
-
-cleanup:
-  if (*load_texture_cmds) {
-    free(*load_texture_cmds);
-  }
-  *num_textures = 0;
-  return false;
 }
 
 /// Load a texture uniform.
@@ -438,25 +381,15 @@ static bool load_texture_and_uniform(
 /// 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 Material** load_materials(
+static bool load_materials(
     const cgltf_data* data, RenderBackend* render_backend,
-    LoadTextureCmd* load_texture_cmds, Texture*** textures,
-    cgltf_size* num_materials) {
+    LoadTextureCmd* load_texture_cmds, Texture** textures,
+    Material** materials) {
   assert(data);
   assert(render_backend);
   assert(load_texture_cmds);
   assert(textures);
-  assert(num_materials);
-
-  Material** materials = calloc(data->materials_count, sizeof(Material*));
-  if (!materials) {
-    goto cleanup;
-  }
-
-  *textures = calloc(data->textures_count, sizeof(Texture*));
-  if (!*textures) {
-    goto cleanup;
-  }
+  assert(materials);
 
   for (cgltf_size i = 0; i < data->materials_count; ++i) {
     const cgltf_material* mat = &data->materials[i];
@@ -495,18 +428,18 @@ static Material** load_materials(
       if (pbr->base_color_texture.texture) {
         if (!load_texture_and_uniform(
                 data, render_backend, &pbr->base_color_texture,
-                BaseColorTexture, *textures, load_texture_cmds, &next_uniform,
+                BaseColorTexture, textures, load_texture_cmds, &next_uniform,
                 &desc)) {
-          goto cleanup;
+          return false;
         }
       }
 
       if (pbr->metallic_roughness_texture.texture) {
         if (!load_texture_and_uniform(
                 data, render_backend, &pbr->metallic_roughness_texture,
-                MetallicRoughnessTexture, *textures, load_texture_cmds,
+                MetallicRoughnessTexture, textures, load_texture_cmds,
                 &next_uniform, &desc)) {
-          goto cleanup;
+          return false;
         }
       }
     }
@@ -514,25 +447,25 @@ static Material** load_materials(
     if (mat->emissive_texture.texture) {
       if (!load_texture_and_uniform(
               data, render_backend, &mat->emissive_texture, EmissiveTexture,
-              *textures, load_texture_cmds, &next_uniform, &desc)) {
-        goto cleanup;
+              textures, load_texture_cmds, &next_uniform, &desc)) {
+        return false;
       }
     }
 
     if (mat->occlusion_texture.texture) {
       if (!load_texture_and_uniform(
               data, render_backend, &mat->occlusion_texture,
-              AmbientOcclusionTexture, *textures, load_texture_cmds,
+              AmbientOcclusionTexture, textures, load_texture_cmds,
               &next_uniform, &desc)) {
-        goto cleanup;
+        return false;
       }
     }
 
     if (mat->normal_texture.texture) {
       if (!load_texture_and_uniform(
-              data, render_backend, &mat->normal_texture, NormalMap, *textures,
+              data, render_backend, &mat->normal_texture, NormalMap, textures,
               load_texture_cmds, &next_uniform, &desc)) {
-        goto cleanup;
+        return false;
       }
     }
 
@@ -541,42 +474,20 @@ static Material** load_materials(
 
     materials[i] = gfx_make_material(&desc);
     if (!materials[i]) {
-      goto cleanup;
+      return false;
     }
   }
 
-  *num_materials = data->materials_count;
-  return materials;
-
-cleanup:
-  if (materials) {
-    for (cgltf_size i = 0; i < data->materials_count; ++i) {
-      if (materials[i]) {
-        gfx_destroy_material(&materials[i]);
-      }
-    }
-    free(materials);
-  }
-  if (*textures) {
-    for (cgltf_size i = 0; i < data->textures_count; ++i) {
-      if ((*textures)[i]) {
-        gfx_destroy_texture(render_backend, &(*textures)[i]);
-      }
-    }
-    free(*textures);
-    *textures = 0;
-  }
-  *num_materials = 0;
-  return 0;
+  return true;
 }
 
 /// Load all meshes from the glTF scene.
-static SceneObject** load_meshes(
+static bool load_meshes(
     const cgltf_data* data, Gfx* gfx, Buffer** buffers,
     Buffer** tangent_buffers, const cgltfTangentBuffer* cgltf_tangent_buffers,
     cgltf_size num_tangent_buffers, Material** materials, ShaderProgram* shader,
-    Geometry*** geometries, Mesh*** meshes, cgltf_size* num_geometries,
-    cgltf_size* num_meshes, cgltf_size* num_scene_objects) {
+    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.
@@ -594,9 +505,7 @@ static SceneObject** load_meshes(
   assert(shader);
   assert(geometries);
   assert(meshes);
-  assert(num_geometries);
-  assert(num_meshes);
-  assert(num_scene_objects);
+  assert(scene_objects);
   if (num_tangent_buffers > 0) {
     assert(tangent_buffers);
     assert(cgltf_tangent_buffers);
@@ -605,21 +514,6 @@ static SceneObject** load_meshes(
   // TODO: pass render_backend as argument instead of gfx.
   RenderBackend* render_backend = gfx_get_render_backend(gfx);
 
-  const size_t primitive_count = get_total_primitives(data);
-
-  *geometries = calloc(primitive_count, sizeof(Geometry*));
-  if (!*geometries) {
-    goto cleanup;
-  }
-  *meshes = calloc(primitive_count, sizeof(Mesh*));
-  if (!*meshes) {
-    goto cleanup;
-  }
-  SceneObject** objects = calloc(data->meshes_count, sizeof(SceneObject*));
-  if (!objects) {
-    goto cleanup;
-  }
-
   // 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;
@@ -627,9 +521,9 @@ static SceneObject** load_meshes(
   for (cgltf_size m = 0; m < data->meshes_count; ++m) {
     const cgltf_mesh* mesh = &data->meshes[m];
 
-    objects[m] = gfx_make_object();
-    if (!objects[m]) {
-      goto cleanup;
+    scene_objects[m] = gfx_make_object();
+    if (!scene_objects[m]) {
+      return false;
     }
 
     for (cgltf_size p = 0; p < mesh->primitives_count; ++p) {
@@ -689,7 +583,7 @@ static SceneObject** load_meshes(
                 "Unhandled accessor type %d in vertex positions",
                 accessor->type);
             assert(false);
-            break;
+            return false;
           }
           // It is assumed that meshes have positions, so there is nothing to
           // do for the mesh permutation in this case.
@@ -776,16 +670,9 @@ static SceneObject** load_meshes(
       assert(material_index < data->materials_count);
       Material* material = materials[material_index];
 
-      // TODO: We need a better way to handle clean-up, specifically of
-      // materials. One is to add materials to a dynamically-allocated list or
-      // vector. Another is to expose some kind of scene purge that deletes the
-      // resources of a given scene. The latter would make clean-up much simpler
-      // in general, not just for materials.
-
-      (*geometries)[next_mesh] =
-          gfx_make_geometry(render_backend, &geometry_desc);
-      if (!(*geometries)[next_mesh]) {
-        goto cleanup;
+      geometries[next_mesh] = gfx_make_geometry(render_backend, &geometry_desc);
+      if (!geometries[next_mesh]) {
+        return false;
       }
 
       // If the user specifies a custom shader, use that instead.
@@ -802,65 +689,31 @@ static SceneObject** load_meshes(
       // swapping shaders, so shader caching is the most important thing here.
       assert(shader);
 
-      (*meshes)[next_mesh] = gfx_make_mesh(&(MeshDesc){
-          .geometry = (*geometries)[next_mesh],
+      meshes[next_mesh] = gfx_make_mesh(&(MeshDesc){
+          .geometry = geometries[next_mesh],
           .material = material,
           .shader   = shader});
 
-      gfx_add_object_mesh(objects[m], (*meshes)[next_mesh]);
+      if (!meshes[next_mesh]) {
+        return false;
+      }
+
+      gfx_add_object_mesh(scene_objects[m], meshes[next_mesh]);
 
       ++next_mesh;
     } // glTF mesh primitive / gfx Mesh.
   }   // glTF mesh / gfx SceneObject.
 
-  *num_geometries    = primitive_count;
-  *num_meshes        = primitive_count;
-  *num_scene_objects = data->meshes_count;
-  return objects;
-
-cleanup:
-  // Destroy resources, free pointers arrays.
-  if (*geometries) {
-    for (size_t i = 0; i < primitive_count; ++i) {
-      if ((*geometries)[i]) {
-        gfx_destroy_geometry(render_backend, &(*geometries[i]));
-      }
-    }
-    free(*geometries);
-    *geometries = 0;
-  }
-  if (*meshes) {
-    for (size_t i = 0; i < primitive_count; ++i) {
-      if ((*meshes[i])) {
-        gfx_destroy_mesh(&(*meshes)[i]);
-      }
-    }
-    free(*meshes);
-    *meshes = 0;
-  }
-  if (objects) {
-    for (cgltf_size i = 0; i < data->meshes_count; ++i) {
-      if (objects[i]) {
-        gfx_destroy_object(&objects[i]);
-      }
-    }
-    free(objects);
-    objects = 0;
-  }
-  *num_geometries    = 0;
-  *num_meshes        = 0;
-  *num_scene_objects = 0;
-  return 0;
+  return true;
 }
 
 /// 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 SceneNode** load_nodes(
+static void load_nodes(
     const cgltf_data* data, Gfx* gfx, SceneNode* root_node,
-    SceneObject** scene_objects, SceneCamera*** cameras,
-    cgltf_size* num_cameras, cgltf_size* num_nodes) {
+    SceneObject** objects, SceneCamera** cameras, SceneNode** nodes) {
   // Note that with glTF 2.0, nodes do not form a DAG / scene graph but a
   // disjount union of strict trees:
   //
@@ -876,19 +729,9 @@ static SceneNode** load_nodes(
   // TODO: gfx not needed?
   assert(gfx);
   assert(root_node);
-  assert(scene_objects);
+  assert(objects);
   assert(cameras);
-  assert(num_cameras);
-  assert(num_nodes);
-
-  SceneNode** nodes = calloc(data->nodes_count, sizeof(SceneNode**));
-  if (!nodes) {
-    goto cleanup;
-  }
-  *cameras = calloc(data->cameras_count, sizeof(SceneCamera**));
-  if (!*cameras) {
-    goto cleanup;
-  }
+  assert(nodes);
 
   cgltf_size next_camera = 0;
 
@@ -902,7 +745,7 @@ static SceneNode** load_nodes(
     if (node->mesh) {
       const cgltf_size mesh_index = node->mesh - data->meshes;
       assert(mesh_index < data->meshes_count);
-      nodes[n] = gfx_make_object_node(scene_objects[mesh_index]);
+      nodes[n] = gfx_make_object_node(objects[mesh_index]);
     } else if (node->camera) {
       assert(next_camera < data->cameras_count);
 
@@ -927,8 +770,8 @@ static SceneNode** load_nodes(
         break;
       }
 
-      gfx_set_camera_camera((*cameras)[next_camera], &camera);
-      nodes[n] = gfx_make_camera_node((*cameras)[next_camera]);
+      gfx_set_camera_camera(cameras[next_camera], &camera);
+      nodes[n] = gfx_make_camera_node(cameras[next_camera]);
       ++next_camera;
     } else {
       continue; // TODO: implementation for missing node types.
@@ -977,32 +820,6 @@ static SceneNode** load_nodes(
       gfx_set_node_parent(child_scene_node, parent_scene_node);
     }
   }
-
-  *num_cameras = data->cameras_count;
-  *num_nodes   = data->nodes_count;
-  return nodes;
-
-cleanup:
-  // Destroy resources, free pointers arrays.
-  if (nodes) {
-    for (cgltf_size i = 0; i < data->nodes_count; ++i) {
-      if (nodes[i]) {
-        gfx_destroy_node(&nodes[i]);
-      }
-    }
-    free(nodes);
-  }
-  if (cameras) {
-    for (cgltf_size i = 0; i < data->cameras_count; ++i) {
-      if (cameras[i]) {
-        gfx_destroy_camera(&(*cameras)[i]);
-      }
-    }
-    free(cameras);
-  }
-  *num_cameras = 0;
-  *num_nodes   = 0;
-  return 0;
 }
 
 /// Load all scenes from the glTF file into the given gfx Scene.
@@ -1015,143 +832,167 @@ static bool load_scene(
     cgltf_data* data, Gfx* gfx, SceneNode* root_node, const char* 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.
+  // 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.
   assert(data);
   assert(gfx);
   assert(root_node);
 
-  RenderBackend* render_backend = gfx_get_render_backend(gfx);
+  RenderBackend* render_backend  = gfx_get_render_backend(gfx);
+  const size_t   primitive_count = get_total_primitives(data);
 
   const mstring directory = mstring_dirname(mstring_make(filepath));
   LOGD("Filepath: %s", filepath);
   LOGD("Directory: %s", mstring_cstring(&directory));
 
-  Buffer**        buffers           = 0;
   Buffer**        tangent_buffers   = 0;
-  Geometry**      geometries        = 0;
+  Buffer**        buffers           = 0;
+  LoadTextureCmd* load_texture_cmds = 0;
+  Texture**       textures          = 0;
   Material**      materials         = 0;
+  Geometry**      geometries        = 0;
   Mesh**          meshes            = 0;
   SceneObject**   scene_objects     = 0;
   SceneCamera**   scene_cameras     = 0;
   SceneNode**     scene_nodes       = 0;
-  Texture**       textures          = 0;
-  LoadTextureCmd* load_texture_cmds = 0;
-  cgltf_size      num_buffers       = 0;
-  cgltf_size      num_geometries    = 0;
-  cgltf_size      num_materials     = 0;
-  cgltf_size      num_meshes        = 0;
-  cgltf_size      num_scene_objects = 0;
-  cgltf_size      num_scene_cameras = 0;
-  cgltf_size      num_scene_nodes   = 0;
-  cgltf_size      num_textures      = 0;
-
-  // TODO: Let this function handle all the cleanup. Let the other functions
-  // return pass/failure booleans and the arrays as in/out parameters. This way
-  // we do not need the individual functions to duplicate cleanup code.
-  buffers = load_buffers(data, render_backend, &num_buffers);
-  if (!buffers) {
-    goto cleanup;
+
+  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 (num_tangent_buffers > 0) {
-    tangent_buffers = load_tangent_buffers(
-        cgltf_tangent_buffers, num_tangent_buffers, render_backend);
-    if (!tangent_buffers) {
-      goto cleanup;
-    }
+  if (!buffers || !tangent_buffers ||
+      ((data->textures_count > 0) && !load_texture_cmds) || !textures ||
+      !materials || !geometries || !meshes || !scene_objects ||
+      !scene_cameras || !scene_nodes) {
+    goto cleanup;
   }
 
-  if (!load_textures_lazy(
-          data, render_backend, mstring_cstring(&directory), &load_texture_cmds,
-          &num_textures)) {
+  if ((num_tangent_buffers > 0) &&
+      !load_tangent_buffers(
+          cgltf_tangent_buffers, num_tangent_buffers, render_backend,
+          tangent_buffers)) {
     goto cleanup;
   }
 
-  materials = load_materials(
-      data, render_backend, load_texture_cmds, &textures, &num_materials);
-  if (!materials) {
+  if (!load_buffers(data, render_backend, buffers)) {
     goto cleanup;
   }
 
-  scene_objects = load_meshes(
-      data, gfx, buffers, tangent_buffers, cgltf_tangent_buffers,
-      num_tangent_buffers, materials, shader, &geometries, &meshes,
-      &num_geometries, &num_meshes, &num_scene_objects);
-  if (!scene_objects) {
+  load_textures_lazy(
+      data, render_backend, mstring_cstring(&directory), load_texture_cmds);
+
+  if (!load_materials(
+          data, render_backend, load_texture_cmds, textures, materials)) {
     goto cleanup;
   }
 
-  scene_nodes = load_nodes(
-      data, gfx, root_node, scene_objects, &scene_cameras, &num_scene_cameras,
-      &num_scene_nodes);
-  if (!scene_nodes) {
+  if (!load_meshes(
+          data, gfx, buffers, tangent_buffers, cgltf_tangent_buffers,
+          num_tangent_buffers, materials, shader, primitive_count, geometries,
+          meshes, scene_objects)) {
     goto cleanup;
   }
 
+  load_nodes(data, gfx, root_node, scene_objects, scene_cameras, scene_nodes);
+
   return true;
 
 cleanup:
-  if (buffers) {
-    for (cgltf_size i = 0; i < num_buffers; ++i) {
-      gfx_destroy_buffer(render_backend, &buffers[i]);
-    }
-    free(buffers);
-  }
   if (tangent_buffers) {
     for (cgltf_size i = 0; i < num_tangent_buffers; ++i) {
-      gfx_destroy_buffer(render_backend, &tangent_buffers[i]);
+      if (tangent_buffers[i]) {
+        gfx_destroy_buffer(render_backend, &tangent_buffers[i]);
+      }
     }
     free(tangent_buffers);
   }
+  if (buffers) {
+    for (cgltf_size i = 0; i < data->buffers_count; ++i) {
+      if (buffers[i]) {
+        gfx_destroy_buffer(render_backend, &buffers[i]);
+      }
+    }
+    free(buffers);
+  }
+  if (load_texture_cmds) {
+    free(load_texture_cmds);
+  }
   if (textures) {
-    for (cgltf_size i = 0; i < num_textures; ++i) {
-      gfx_destroy_texture(render_backend, &textures[i]);
+    for (cgltf_size i = 0; i < data->textures_count; ++i) {
+      if (textures[i]) {
+        gfx_destroy_texture(render_backend, &textures[i]);
+      }
     }
     free(textures);
   }
   if (materials) {
-    for (cgltf_size i = 0; i < num_materials; ++i) {
-      gfx_destroy_material(&materials[i]);
+    for (cgltf_size i = 0; i < data->materials_count; ++i) {
+      if (materials[i]) {
+        gfx_destroy_material(&materials[i]);
+      }
     }
     free(materials);
   }
   if (geometries) {
-    for (cgltf_size i = 0; i < num_geometries; ++i) {
-      gfx_destroy_geometry(render_backend, &geometries[i]);
+    for (size_t i = 0; i < primitive_count; ++i) {
+      if (geometries[i]) {
+        gfx_destroy_geometry(render_backend, &geometries[i]);
+      }
     }
     free(geometries);
   }
   if (meshes) {
-    for (cgltf_size i = 0; i < num_meshes; ++i) {
-      gfx_destroy_mesh(&meshes[i]);
+    for (size_t i = 0; i < primitive_count; ++i) {
+      if (meshes[i]) {
+        gfx_destroy_mesh(&meshes[i]);
+      }
     }
     free(meshes);
   }
   if (scene_objects) {
-    for (cgltf_size i = 0; i < num_scene_objects; ++i) {
-      gfx_destroy_object(&scene_objects[i]);
+    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) {
-    for (cgltf_size i = 0; i < num_scene_cameras; ++i) {
-      gfx_destroy_camera(&scene_cameras[i]);
+    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) {
-    for (cgltf_size i = 0; i < num_scene_nodes; ++i) {
-      gfx_destroy_node(&scene_nodes[i]);
+    for (cgltf_size i = 0; i < data->nodes_count; ++i) {
+      if (scene_nodes[i]) {
+        gfx_destroy_node(&scene_nodes[i]);
+      }
     }
     free(scene_nodes);
   }
-  if (load_texture_cmds) {
-    free(load_texture_cmds);
-  }
   return false;
 }