Some debug prints for assimp structures

diff --git a/src/engine/asset.c b/src/engine/asset.c
index 8bb19e50a686099ad95470b35bd13fcda46aa4f2..a26a7e4794da3cbbe60b2bae023592c0b7a87f25 100644 (file)
--- a/src/engine/asset.c
+++ b/src/engine/asset.c
@@ -2,18 +2,88 @@
 
 #include <stdlib.h>
 #include <assimp/cimport.h>
+//#include <assimp/metadata.h>
 #include <assimp/postprocess.h>
 #include <assimp/scene.h>
 
 #include "logger.h"
 #include "tga.h"
 
+#define IMPORT_DEBUG_ 1
+
 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);
 
 
 
+#if IMPORT_DEBUG_
+static void printMetadata(const struct aiMetadata* meta) {
+       if (meta) {
+               for (size_t i = 0; i < meta->mNumProperties; ++i) {
+                       char* key = memcpy(malloc((meta->mKeys[i].length + 1) * sizeof(char)),
+                                          meta->mKeys[i].data,
+                                          meta->mKeys[i].length * sizeof(char));
+                       key[meta->mKeys[i].length] = '\0';
+                       const struct aiMetadataEntry value = meta->mValues[i];
+                       switch (value.mType) {
+                               case AI_BOOL:
+                                       logDebug("\"%s\": (bool) %d", key, *((int*) value.mData));
+                                       break;
+                               case AI_INT32:
+                                       logDebug("\"%s\": (int32) %d", key, *((int32_t*) value.mData));
+                                       break;
+                               case AI_UINT64:
+                                       logDebug("\"%s\": (uint64) %llu", key, *((uint64_t*) value.mData));
+                                       break;
+                               case AI_FLOAT:
+                                       logDebug("\"%s\": (float) %f", key, *((float*) value.mData));
+                                       break;
+                               case AI_DOUBLE:
+                                       logDebug("\"%s\": (double) %f", key, *((double*) value.mData));
+                                       break;
+                               case AI_AISTRING: {
+                                       struct aiString aistr = *((struct aiString*) value.mData);
+                                       char* str = memcpy(malloc((aistr.length + 1) * sizeof(char)),
+                                                          aistr.data,
+                                                          aistr.length * sizeof(char));
+                                       str[aistr.length] = '\0';
+                                       logDebug("\"%s\": (string) %s", key, str);
+                                       free(str);
+                                       break; }
+                               case AI_AIVECTOR3D: {
+                                       struct aiVector3D vec = *((struct aiVector3D*) value.mData);
+                                       logDebug("\"%s\": (vector3d) { %f, %f, %f }", key, vec.x, vec.y, vec.z);
+                                       break; }
+                               case AI_META_MAX:
+                               default:
+                                       logDebug("\"%s\": (unrecognized type)", key);
+                                       break;
+                       }
+                       free(key);
+               }
+       }
+}
+
+void printAiNodeMetadata(const struct aiNode* node) {
+       if (!node) {
+               return;
+       }
+
+       struct aiString aistr = node->mName;
+       char* name = memcpy(malloc((aistr.length + 1) * sizeof(char)),
+                           aistr.data,
+                           aistr.length * sizeof(char));
+       name[aistr.length] = '\0';
+       logDebug("Metadata from node \"%s\": %p", name, node->mMetaData);
+       printMetadata(node->mMetaData);
+
+       for (size_t i = 0; i < node->mNumChildren; ++i) {
+               printAiNodeMetadata(node->mChildren[i]);
+       }
+}
+#endif // IMPORT_DEBUG_
+
 const Solid* importSolid(const char* path) {
        const struct aiScene* scene = importScene(path);
        if (scene == NULL) {
@@ -21,6 +91,13 @@ const Solid* importSolid(const char* path) {
                return NULL;
        }
        
+#if IMPORT_DEBUG_
+       const struct aiMetadata* meta = scene->mMetaData;
+       logDebug("Metadata from %s: %p", path, meta);
+       printMetadata(meta);
+       printAiNodeMetadata(scene->mRootNode);
+#endif // IMPORT_DEBUG_
+       
        const unsigned int numMeshes = scene->mNumMeshes;
        const unsigned int numMaterials = scene->mNumMaterials;
 
@@ -86,6 +163,24 @@ const Solid* importSolid(const char* path) {
        
        for (unsigned int matIndex = 0; matIndex < numMaterials; ++matIndex) {
                Material material = { .textureId = textureIds[matIndex] };
+
+#if IMPORT_DEBUG_
+               const struct aiMaterialProperty* prop;
+               aiGetMaterialProperty(scene->mMaterials[matIndex],
+                                     AI_MATKEY_SHADING_MODEL,
+                                     &prop);
+               // print mKey
+               struct aiString aistr = prop->mKey;
+               char* key = memcpy(malloc((aistr.length + 1) * sizeof(char)),
+                                  aistr.data,
+                                  aistr.length * sizeof(char));
+               key[aistr.length] = '\0';
+
+               logDebug("Material property \"%s\": Shading model: (length %u) %d",
+                        key,
+                        prop->mDataLength,
+                        *((int32_t*) prop->mData));
+#endif // IMPORT_DEBUG_
                
                glBindTexture(GL_TEXTURE_2D, material.textureId);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

diff --git a/src/engine/render.c b/src/engine/render.c
index b09f25bbd803ae91a2983c057f30c9b2c24a45cc..c75dc7198a2427f92dc6bfdb9e5d8269fbbadcd2 100644 (file)
--- a/src/engine/render.c
+++ b/src/engine/render.c
@@ -7,7 +7,7 @@
 #include "performance.h"
 
 #define SCENE_DEBUG_ 0
-#define RENDER_DEBUG_ 1
+#define RENDER_DEBUG_ 0
 
 float viewportAspectRatio = 1.0f;
 const Scene* cameraAnchor;
@@ -185,12 +185,13 @@ static void drawSolid(const Solid* solid) {
                        
                        for (size_t i = 0; i < face.numIndices; ++i) {
                                size_t vertIndex = face.indices[i];
+                               size_t normalIndex = face.indices[2];
                                if (hasNormals) {
                                        if (hasTextureCoords) {
                                                Vector3D coords = mesh.textureCoords[vertIndex];
                                                glTexCoord2f(coords.x, coords.y);
                                        }
-                                       Vector3D normal = mesh.normals[vertIndex];
+                                       Vector3D normal = mesh.normals[normalIndex];
                                        glNormal3f(normal.x, normal.y, normal.z);
                                }
                                Vector3D vertex = mesh.vertices[vertIndex];