Get rid of assimp_types.h

[shadowclad.git] / src / engine / asset.c

diff --git a/src/engine/asset.c b/src/engine/asset.c
index fafe81cc2aefb0fd846b21ce6728f870054d878c..a93524c59c8f68f7b8ec6b6dc95261c735c37cfc 100644 (file)
--- a/src/engine/asset.c
+++ b/src/engine/asset.c
@@ -1,34 +1,38 @@
 #include <stdlib.h>
 #include <assimp/cimport.h>
 #include <assimp/postprocess.h>
+#include <assimp/scene.h>
 
 #include "asset.h"
 #include "logger.h"
 #include "tga.h"
 
-static const AiScene* importScene(const char* path);
-static Vector3D convertAiVector3D(AiVector3D vect);
-static const char* replaceFileExtension(const AiString path, const char* ext);
+static const struct aiScene* importScene(const char* path);
+static Vector3D convertAiVector3D(struct aiVector3D vect);
+static const char* replaceFileExtension(const struct aiString path, const char* ext);
 
 
 
-const Asset3D* importAsset(const char* path) {
-       const AiScene* scene = importScene(path);
+const Solid* importSolid(const char* path) {
+       const struct aiScene* scene = importScene(path);
        if (scene == NULL) {
+               logError("Failed to import solid from %s", path);
                return NULL;
        }
        
        const unsigned int numMeshes = scene->mNumMeshes;
        const unsigned int numMaterials = scene->mNumMaterials;
+
+       // TODO Consider assets with some arrays empty, and prevent zero mallocs
        
-       Asset3D* asset = malloc(sizeof(Asset3D));
-       asset->numMeshes = numMeshes;
-       asset->meshes = malloc(numMeshes * sizeof(Mesh));
-       asset->numMaterials = numMaterials;
-       asset->materials = malloc(numMaterials * sizeof(Material));
+       Solid* solid = malloc(sizeof(Solid));
+       solid->numMeshes = numMeshes;
+       solid->meshes = malloc(numMeshes * sizeof(Mesh));
+       solid->numMaterials = numMaterials;
+       solid->materials = malloc(numMaterials * sizeof(Material));
        
        for (unsigned int meshIndex = 0; meshIndex < numMeshes; ++meshIndex) {
-               const AiMesh* aiMesh = scene->mMeshes[meshIndex];
+               const struct aiMesh* aiMesh = scene->mMeshes[meshIndex];
                const unsigned int numVertices = aiMesh->mNumVertices;
                const unsigned int numFaces = aiMesh->mNumFaces;
                
@@ -60,12 +64,11 @@ const Asset3D* importAsset(const char* path) {
                }
                
                for (unsigned int faceIndex = 0; faceIndex < numFaces; ++faceIndex) {
-                       const AiFace aiFace = aiMesh->mFaces[faceIndex];
+                       const struct aiFace aiFace = aiMesh->mFaces[faceIndex];
                        const unsigned int numIndices = aiFace.mNumIndices;
                        
                        Face face = { .numIndices = numIndices,
-                                     .indices = malloc(numIndices
-                                                       * sizeof(unsigned int)) };
+                                     .indices = malloc(numIndices * sizeof(size_t)) };
                        
                        for (unsigned int i = 0; i < numIndices; ++i) {
                                face.indices[i] = aiFace.mIndices[i];
@@ -74,7 +77,7 @@ const Asset3D* importAsset(const char* path) {
                        mesh.faces[faceIndex] = face;
                }
                
-               asset->meshes[meshIndex] = mesh;
+               solid->meshes[meshIndex] = mesh;
        }
        
        GLuint* textureIds = malloc(numMaterials * sizeof(GLuint));
@@ -86,21 +89,21 @@ const Asset3D* importAsset(const char* path) {
                glBindTexture(GL_TEXTURE_2D, material.textureId);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                
-               AiString originalTexturePath;
+               struct aiString originalTexturePath;
                if (aiGetMaterialTexture(scene->mMaterials[matIndex],
                                         aiTextureType_DIFFUSE,
                                         0,
                                         &originalTexturePath,
                                         NULL, NULL, NULL, NULL, NULL, NULL) == AI_SUCCESS) {
-                       const char* textureFile = replaceFileExtension(originalTexturePath, ".tga");
-                       const size_t textureFileLength = strlen(textureFile);
-                       char* texturePath = malloc(strlen("assets/") + textureFileLength + 1);
+                       const char* textureFilename = replaceFileExtension(originalTexturePath, ".tga");
+                       const size_t textureFilenameLength = strlen(textureFilename);
+                       char* texturePath = malloc(strlen("assets/") + textureFilenameLength + 1);
                        strcpy(texturePath, "assets/");
-                       strncat(texturePath, textureFile, textureFileLength);
+                       strncat(texturePath, textureFilename, textureFilenameLength);
                        
                        TgaImage* textureImage = readTga(texturePath);
                        if (textureImage == NULL) {
-                               logError("Asset texture file not found: %s", texturePath);
+                               logError("Importing solid from %s: Cannot read texture file %s", path, texturePath);
                        }
                        else {
                                glTexImage2D(GL_TEXTURE_2D,
@@ -117,20 +120,17 @@ const Asset3D* importAsset(const char* path) {
                        }
                }
                
-               asset->materials[matIndex] = material;
+               solid->materials[matIndex] = material;
        }
        glBindTexture(GL_TEXTURE_2D, 0);
        
        aiReleaseImport(scene);
-       return asset;
+       return solid;
 }
 
-static const AiScene* importScene(const char* path) {
-       const AiScene* scene = aiImportFile(path, aiProcess_PreTransformVertices);
-       if (scene == NULL) {
-               logError("Failed to import asset from %s", path);
-       }
-       else if ((scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE) == AI_SCENE_FLAGS_INCOMPLETE) {
+static const struct aiScene* importScene(const char* path) {
+       const struct aiScene* scene = aiImportFile(path, aiProcess_PreTransformVertices);
+       if (scene != NULL && scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE) {
                logError("Incomplete scene imported from %s", path);
                aiReleaseImport(scene);
                scene = NULL;
@@ -138,17 +138,18 @@ static const AiScene* importScene(const char* path) {
        return scene;
 }
 
-static Vector3D convertAiVector3D(AiVector3D vect) {
+static Vector3D convertAiVector3D(struct aiVector3D vect) {
        return (Vector3D) { .x = vect.x,
                            .y = vect.y,
                            .z = vect.z };
 }
 
-/** BUGS
+/**
+ * BUGS
  * The following function will not work properly with texture
  * file names (excluding directory part) beginning with '.'
  */
-static const char* replaceFileExtension(const AiString path, const char* ext) {
+static const char* replaceFileExtension(const struct aiString path, const char* ext) {
                size_t lengthToCopy = path.length;
                
                char* lastDotSubstr = strrchr(path.data, '.');