ModelData;

src/model/modelData.c

@@ -3,26 +3,96 @@
 #include <assimp/scene.h>
 #include <assimp/cimport.h>
 #include <assimp/postprocess.h>
+#include <stdio.h>
+
+static void assimpNodeTraversal(ModelNode* node, struct aiNode* assimpNode) {
+
+  // Transform
+  struct aiMatrix4x4 m = assimpNode->mTransformation;
+  aiTransposeMatrix4(&m);
+  node->transform = mat4_copy((float*) &m);
+
+  // Meshes
+  vec_init(&node->meshes);
+  vec_pusharr(&node->meshes, assimpNode->mMeshes, assimpNode->mNumMeshes);
+
+  // Children
+  vec_init(&node->children);
+  for (int n = 0; n < assimpNode->mNumChildren; n++) {
+    ModelNode* child = malloc(sizeof(ModelNode));
+    assimpNodeTraversal(child, assimpNode->mChildren[n]);
+    vec_push(&node->children, child);
+  }
+}
 
 ModelData* lovrModelDataCreate(const char* filename) {
   ModelData* modelData = malloc(sizeof(ModelData));
   const struct aiScene* scene = aiImportFile(filename, aiProcessPreset_TargetRealtime_MaxQuality);
-  const struct aiMesh* mesh = scene->mMeshes[0];
+
-  modelData->vertexCount = mesh->mNumFaces * 3;
+  // Meshes
-  modelData->data = malloc(3 * modelData->vertexCount * sizeof(float));
+  vec_init(&modelData->meshes);
-  for (int i = 0; i < mesh->mNumFaces; i++) {
+  for (int m = 0; m < scene->mNumMeshes; m++) {
-    for (int j = 0; j < mesh->mFaces[i].mNumIndices; j++) {
+    struct aiMesh* assimpMesh = scene->mMeshes[m];
-      int index = mesh->mFaces[i].mIndices[j];
+    ModelMesh* mesh = malloc(sizeof(ModelMesh));
-      modelData->data[9 * i + 3 * j + 0] = mesh->mVertices[index].x;
+
-      modelData->data[9 * i + 3 * j + 1] = mesh->mVertices[index].y;
+    // Faces
-      modelData->data[9 * i + 3 * j + 2] = mesh->mVertices[index].z;
+    vec_init(&mesh->faces);
+    for (int f = 0; f < assimpMesh->mNumFaces; f++) {
+      struct aiFace assimpFace = assimpMesh->mFaces[f];
+      ModelFace face;
+      vec_init(&face.indices);
+
+      // Indices
+      for (int i = 0; i < assimpFace.mNumIndices; i++) {
+        vec_push(&face.indices, assimpFace.mIndices[i]);
+      }
+
+      vec_push(&mesh->faces, face);
+    }
+
+    // Vertices
+    vec_init(&mesh->vertices);
+    for (int v = 0; v < assimpMesh->mNumVertices; v++) {
+      ModelVertex vertex;
+      vertex.x = assimpMesh->mVertices[v].x;
+      vertex.y = assimpMesh->mVertices[v].y;
+      vertex.z = assimpMesh->mVertices[v].z;
     }
   }
+
+  // Nodes
+  modelData->root = malloc(sizeof(ModelNode));
+  assimpNodeTraversal(modelData->root, scene->mRootNode);
+
   aiReleaseImport(scene);
   return modelData;
 }
 
 void lovrModelDataDestroy(ModelData* modelData) {
-  free(modelData->data);
+  for (int i = 0; i < modelData->meshes.length; i++) {
+    ModelMesh* mesh = modelData->meshes.data[i];
+
+    for (int f = 0; f < mesh->faces.length; f++) {
+      vec_deinit(&mesh->faces.data[f].indices);
+    }
+
+    vec_deinit(&mesh->faces);
+    vec_deinit(&mesh->vertices);
+    free(mesh);
+  }
+
+  vec_void_t nodes;
+  vec_init(&nodes);
+  vec_push(&nodes, modelData->root);
+  while (nodes.length > 0) {
+    ModelNode* node = vec_first(&nodes);
+    vec_extend(&nodes, &node->children);
+    mat4_deinit(node->transform);
+    vec_deinit(&node->meshes);
+    vec_deinit(&node->children);
+    vec_splice(&nodes, 0, 1);
+  }
+
+  vec_deinit(&modelData->meshes);
   free(modelData);
 }

src/model/modelData.h

@@ -1,9 +1,42 @@
+#include "../vendor/vec/vec.h"
+#include "../util.h"
+#include "../matrix.h"
+
 #ifndef LOVR_MODEL_DATA_TYPES
 #define LOVR_MODEL_DATA_TYPES
+
 typedef struct {
-  unsigned int vertexCount;
+  float x;
-  float* data;
+  float y;
+  float z;
+} ModelVertex;
+
+typedef vec_t(ModelVertex) vec_model_vertex_t;
+
+typedef struct {
+  vec_uint_t indices;
+} ModelFace;
+
+typedef vec_t(ModelFace) vec_model_face_t;
+
+typedef struct {
+  vec_model_face_t faces;
+  vec_model_vertex_t vertices;
+} ModelMesh;
+
+typedef vec_t(ModelMesh*) vec_model_mesh_t;
+
+typedef struct ModelNode {
+  mat4 transform;
+  vec_uint_t meshes;
+  vec_void_t children;
+} ModelNode;
+
+typedef struct {
+  ModelNode* root;
+  vec_model_mesh_t meshes;
 } ModelData;
+
 #endif
 
 ModelData* lovrModelDataCreate(const char* filename);