Replace custom OBJ/MTL implementations by tinyobj_loader -WIP-

src/models.c

@@ -52,9 +52,9 @@
 
 #include "rlgl.h"           // raylib OpenGL abstraction layer to OpenGL 1.1, 2.1, 3.3+ or ES2
 
-#if defined(SUPPORT_FILEFORMAT_OBJ)
+#if defined(SUPPORT_FILEFORMAT_OBJ) || defined(SUPPORT_FILEFORMAT_MTL)
     #define TINYOBJ_LOADER_C_IMPLEMENTATION
-    #include "external/tinyobj_loader_c.h"  // OBJ file format loading
+    #include "external/tinyobj_loader_c.h"      // OBJ/MTL file formats loading
 #endif
 
 #if defined(SUPPORT_FILEFORMAT_IQM)
@@ -93,9 +93,6 @@
 #if defined(SUPPORT_FILEFORMAT_OBJ)
 static Model LoadOBJ(const char *fileName);     // Load OBJ mesh data
 #endif
-#if defined(SUPPORT_FILEFORMAT_MTL)
-static Material LoadMTL(const char *fileName);  // Load MTL material data
-#endif
 #if defined(SUPPORT_FILEFORMAT_GLTF)
 static Model LoadIQM(const char *fileName);     // Load IQM mesh data
 #endif
@@ -1811,7 +1808,17 @@ Material LoadMaterial(const char *fileName)
     Material material = { 0 };
 
 #if defined(SUPPORT_FILEFORMAT_MTL)
-    if (IsFileExtension(fileName, ".mtl")) material = LoadMTL(fileName);
+    if (IsFileExtension(fileName, ".mtl"))
+    {
+        tinyobj_material_t *materials;
+        int materialCount = 0;
+        
+        int result = tinyobj_parse_mtl_file(&materials, &materialCount, fileName);
+        
+        // TODO: Process materials to return
+        
+        tinyobj_materials_free(materials, materialCount);
+    }
 #else
     TraceLog(LOG_WARNING, "[%s] Material fileformat not supported, it can't be loaded", fileName);
 #endif
@@ -2359,419 +2366,95 @@ void MeshBinormals(Mesh *mesh)
 static Model LoadOBJ(const char *fileName)
 {
     Model model = { 0 };
-
-    // TODO: Use tinyobj_loader_c library
     
-/*
-    char dataType = 0;
-    char comments[200];
-
-    int vertexCount = 0;
-    int normalCount = 0;
-    int texcoordCount = 0;
-    int triangleCount = 0;
-
-    FILE *objFile;
-
-    objFile = fopen(fileName, "rt");
-
-    if (objFile == NULL)
-    {
-        TraceLog(LOG_WARNING, "[%s] OBJ file could not be opened", fileName);
-        return mesh;
-    }
-
-    // First reading pass: Get vertexCount, normalCount, texcoordCount, triangleCount
-    // NOTE: vertex, texcoords and normals could be optimized (to be used indexed on faces definition)
-    // NOTE: faces MUST be defined as TRIANGLES (3 vertex per face)
-    while (!feof(objFile))
-    {
-        dataType = 0;
-        fscanf(objFile, "%c", &dataType);
-
-        switch (dataType)
-        {
-            case '#':   // Comments
-            case 'o':   // Object name (One OBJ file can contain multible named meshes)
-            case 'g':   // Group name
-            case 's':   // Smoothing level
-            case 'm':   // mtllib [external .mtl file name]
-            case 'u':   // usemtl [material name]
-            {
-                fgets(comments, 200, objFile);
-            } break;
-            case 'v':
-            {
-                fscanf(objFile, "%c", &dataType);
-
-                if (dataType == 't')    // Read texCoord
-                {
-                    texcoordCount++;
-                    fgets(comments, 200, objFile);
-                }
-                else if (dataType == 'n')    // Read normals
-                {
-                    normalCount++;
-                    fgets(comments, 200, objFile);
-                }
-                else    // Read vertex
-                {
-                    vertexCount++;
-                    fgets(comments, 200, objFile);
-                }
-            } break;
-            case 'f':
-            {
-                triangleCount++;
-                fgets(comments, 200, objFile);
-            } break;
-            default: break;
-        }
-    }
-
-    TraceLog(LOG_DEBUG, "[%s] Model vertices: %i", fileName, vertexCount);
-    TraceLog(LOG_DEBUG, "[%s] Model texcoords: %i", fileName, texcoordCount);
-    TraceLog(LOG_DEBUG, "[%s] Model normals: %i", fileName, normalCount);
-    TraceLog(LOG_DEBUG, "[%s] Model triangles: %i", fileName, triangleCount);
-
-    // Once we know the number of vertices to store, we create required arrays
-    Vector3 *midVertices = (Vector3 *)malloc(vertexCount*sizeof(Vector3));
-    Vector3 *midNormals = NULL;
-    if (normalCount > 0) midNormals = (Vector3 *)malloc(normalCount*sizeof(Vector3));
-    Vector2 *midTexCoords = NULL;
-    if (texcoordCount > 0) midTexCoords = (Vector2 *)malloc(texcoordCount*sizeof(Vector2));
-
-    int countVertex = 0;
-    int countNormals = 0;
-    int countTexCoords = 0;
-
-    rewind(objFile);        // Return to the beginning of the file, to read again
-
-    // Second reading pass: Get vertex data to fill intermediate arrays
-    // NOTE: This second pass is required in case of multiple meshes defined in same OBJ
-    // TODO: Consider that different meshes can have different vertex data available (position, texcoords, normals)
-    while (!feof(objFile))
-    {
-        fscanf(objFile, "%c", &dataType);
-
-        switch (dataType)
-        {
-            case '#': case 'o': case 'g': case 's': case 'm': case 'u': case 'f': fgets(comments, 200, objFile); break;
-            case 'v':
-            {
-                fscanf(objFile, "%c", &dataType);
-
-                if (dataType == 't')    // Read texCoord
-                {
-                    fscanf(objFile, "%f %f%*[^\n]s\n", &midTexCoords[countTexCoords].x, &midTexCoords[countTexCoords].y);
-                    countTexCoords++;
-
-                    fscanf(objFile, "%c", &dataType);
-                }
-                else if (dataType == 'n')    // Read normals
-                {
-                    fscanf(objFile, "%f %f %f", &midNormals[countNormals].x, &midNormals[countNormals].y, &midNormals[countNormals].z);
-                    countNormals++;
-
-                    fscanf(objFile, "%c", &dataType);
-                }
-                else    // Read vertex
-                {
-                    fscanf(objFile, "%f %f %f", &midVertices[countVertex].x, &midVertices[countVertex].y, &midVertices[countVertex].z);
-                    countVertex++;
-
-                    fscanf(objFile, "%c", &dataType);
-                }
-            } break;
-            default: break;
-        }
-    }
-
-    // At this point all vertex data (v, vt, vn) has been gathered on midVertices, midTexCoords, midNormals
-    // Now we can organize that data into our Mesh struct
-
-    mesh.vertexCount = triangleCount*3;
-
-    // Additional arrays to store vertex data as floats
-    mesh.vertices = (float *)malloc(mesh.vertexCount*3*sizeof(float));
-    mesh.texcoords = (float *)malloc(mesh.vertexCount*2*sizeof(float));
-    mesh.normals = (float *)malloc(mesh.vertexCount*3*sizeof(float));
-    mesh.colors = NULL;
-
-    int vCounter = 0;       // Used to count vertices float by float
-    int tcCounter = 0;      // Used to count texcoords float by float
-    int nCounter = 0;       // Used to count normals float by float
-
-    int vCount[3], vtCount[3], vnCount[3];    // Used to store triangle indices for v, vt, vn
-
-    rewind(objFile);        // Return to the beginning of the file, to read again
-
-    if (normalCount == 0) TraceLog(LOG_INFO, "[%s] No normals data on OBJ, normals will be generated from faces data", fileName);
+    tinyobj_attrib_t attrib;
+    tinyobj_shape_t *meshes = NULL;
+    int meshCount = 0;
+    
+    tinyobj_material_t *materials = NULL;
+    int materialCount = 0;
 
-    // Third reading pass: Get faces (triangles) data and fill VertexArray
-    while (!feof(objFile))
+    int dataLength = 0;
+    const char *data = get_file_data(&dataLength, fileName);
+    
+    if (data != NULL) 
     {
-        fscanf(objFile, "%c", &dataType);
-
-        switch (dataType)
+        unsigned int flags = TINYOBJ_FLAG_TRIANGULATE;
+        int ret = tinyobj_parse_obj(&attrib, &meshes, &meshCount, &materials, &materialCount, data, dataLength, flags);
+        
+        if (ret != TINYOBJ_SUCCESS) TraceLog(LOG_WARNING, "[%s] Model data could not be loaded", fileName);
+        else TraceLog(LOG_INFO, "[%s] Model data loaded successfully: %i meshes / %i materials", fileName, meshCount, materialCount);
+               
+        for (int i = 0; i < meshCount; i++)
         {
-            case '#': case 'o': case 'g': case 's': case 'm': case 'u': case 'v': fgets(comments, 200, objFile); break;
-            case 'f':
-            {
-                // NOTE: It could be that OBJ does not have normals or texcoords defined!
-
-                if ((normalCount == 0) && (texcoordCount == 0)) fscanf(objFile, "%i %i %i", &vCount[0], &vCount[1], &vCount[2]);
-                else if (normalCount == 0) fscanf(objFile, "%i/%i %i/%i %i/%i", &vCount[0], &vtCount[0], &vCount[1], &vtCount[1], &vCount[2], &vtCount[2]);
-                else if (texcoordCount == 0) fscanf(objFile, "%i//%i %i//%i %i//%i", &vCount[0], &vnCount[0], &vCount[1], &vnCount[1], &vCount[2], &vnCount[2]);
-                else fscanf(objFile, "%i/%i/%i %i/%i/%i %i/%i/%i", &vCount[0], &vtCount[0], &vnCount[0], &vCount[1], &vtCount[1], &vnCount[1], &vCount[2], &vtCount[2], &vnCount[2]);
-
-                mesh.vertices[vCounter] = midVertices[vCount[0]-1].x;
-                mesh.vertices[vCounter + 1] = midVertices[vCount[0]-1].y;
-                mesh.vertices[vCounter + 2] = midVertices[vCount[0]-1].z;
-                vCounter += 3;
-                mesh.vertices[vCounter] = midVertices[vCount[1]-1].x;
-                mesh.vertices[vCounter + 1] = midVertices[vCount[1]-1].y;
-                mesh.vertices[vCounter + 2] = midVertices[vCount[1]-1].z;
-                vCounter += 3;
-                mesh.vertices[vCounter] = midVertices[vCount[2]-1].x;
-                mesh.vertices[vCounter + 1] = midVertices[vCount[2]-1].y;
-                mesh.vertices[vCounter + 2] = midVertices[vCount[2]-1].z;
-                vCounter += 3;
-
-                if (normalCount > 0)
-                {
-                    mesh.normals[nCounter] = midNormals[vnCount[0]-1].x;
-                    mesh.normals[nCounter + 1] = midNormals[vnCount[0]-1].y;
-                    mesh.normals[nCounter + 2] = midNormals[vnCount[0]-1].z;
-                    nCounter += 3;
-                    mesh.normals[nCounter] = midNormals[vnCount[1]-1].x;
-                    mesh.normals[nCounter + 1] = midNormals[vnCount[1]-1].y;
-                    mesh.normals[nCounter + 2] = midNormals[vnCount[1]-1].z;
-                    nCounter += 3;
-                    mesh.normals[nCounter] = midNormals[vnCount[2]-1].x;
-                    mesh.normals[nCounter + 1] = midNormals[vnCount[2]-1].y;
-                    mesh.normals[nCounter + 2] = midNormals[vnCount[2]-1].z;
-                    nCounter += 3;
-                }
-                else
-                {
-                    // If normals not defined, they are calculated from the 3 vertices [N = (V2 - V1) x (V3 - V1)]
-                    Vector3 norm = Vector3CrossProduct(Vector3Subtract(midVertices[vCount[1]-1], midVertices[vCount[0]-1]), Vector3Subtract(midVertices[vCount[2]-1], midVertices[vCount[0]-1]));
-                    norm = Vector3Normalize(norm);
-
-                    mesh.normals[nCounter] = norm.x;
-                    mesh.normals[nCounter + 1] = norm.y;
-                    mesh.normals[nCounter + 2] = norm.z;
-                    nCounter += 3;
-                    mesh.normals[nCounter] = norm.x;
-                    mesh.normals[nCounter + 1] = norm.y;
-                    mesh.normals[nCounter + 2] = norm.z;
-                    nCounter += 3;
-                    mesh.normals[nCounter] = norm.x;
-                    mesh.normals[nCounter + 1] = norm.y;
-                    mesh.normals[nCounter + 2] = norm.z;
-                    nCounter += 3;
-                }
-
-                if (texcoordCount > 0)
-                {
-                    // NOTE: If using negative texture coordinates with a texture filter of GL_CLAMP_TO_EDGE doesn't work!
-                    // NOTE: Texture coordinates are Y flipped upside-down
-                    mesh.texcoords[tcCounter] = midTexCoords[vtCount[0]-1].x;
-                    mesh.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtCount[0]-1].y;
-                    tcCounter += 2;
-                    mesh.texcoords[tcCounter] = midTexCoords[vtCount[1]-1].x;
-                    mesh.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtCount[1]-1].y;
-                    tcCounter += 2;
-                    mesh.texcoords[tcCounter] = midTexCoords[vtCount[2]-1].x;
-                    mesh.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtCount[2]-1].y;
-                    tcCounter += 2;
-                }
-            } break;
-            default: break;
+            printf("shape[%d] name = %s\n", i, meshes[i].name);
         }
+        
+        /* 
+        // Data reference to process
+        typedef struct {
+            char *name;
+
+            float ambient[3];
+            float diffuse[3];
+            float specular[3];
+            float transmittance[3];
+            float emission[3];
+            float shininess;
+            float ior;          // index of refraction
+            float dissolve;     // 1 == opaque; 0 == fully transparent
+            // illumination model (see http://www.fileformat.info/format/material/)
+            int illum;
+
+            int pad0;
+
+            char *ambient_texname;            // map_Ka
+            char *diffuse_texname;            // map_Kd
+            char *specular_texname;           // map_Ks
+            char *specular_highlight_texname; // map_Ns
+            char *bump_texname;               // map_bump, bump
+            char *displacement_texname;       // disp
+            char *alpha_texname;              // map_d
+        } tinyobj_material_t;
+
+        typedef struct {
+            char *name;         // group name or object name
+            unsigned int face_offset;
+            unsigned int length;
+        } tinyobj_shape_t;
+
+        typedef struct { int v_idx, vt_idx, vn_idx; } tinyobj_vertex_index_t;
+
+        typedef struct {
+            unsigned int num_vertices;
+            unsigned int num_normals;
+            unsigned int num_texcoords;
+            unsigned int num_faces;
+            unsigned int num_face_num_verts;
+
+            int pad0;
+
+            float *vertices;
+            float *normals;
+            float *texcoords;
+            tinyobj_vertex_index_t *faces;
+            int *face_num_verts;
+            int *material_ids;
+        } tinyobj_attrib_t;
+        */
+
+        tinyobj_attrib_free(&attrib);
+        tinyobj_shapes_free(meshes, meshCount);
+        tinyobj_materials_free(materials, materialCount);
     }
 
-    fclose(objFile);
-
-    // Now we can free temp mid* arrays
-    free(midVertices);
-    free(midNormals);
-    free(midTexCoords);
-*/
-
-    // NOTE: At this point we have all vertex, texcoord, normal data for the model in mesh struct
+    // NOTE: At this point we have all model data loaded
     TraceLog(LOG_INFO, "[%s] Model loaded successfully in RAM (CPU)", fileName);
 
     return model;
 }
 #endif
 
-#if defined(SUPPORT_FILEFORMAT_MTL)
-// Load MTL material data (specs: http://paulbourke.net/dataformats/mtl/)
-// NOTE: Texture map parameters are not supported
-static Material LoadMTL(const char *fileName)
-{
-    #define MAX_BUFFER_SIZE 128
-
-    Material material = { 0 };
-
-    char buffer[MAX_BUFFER_SIZE];
-    Vector3 color = { 1.0f, 1.0f, 1.0f };
-    char mapFileName[128];
-    int result = 0;
-
-    FILE *mtlFile;
-
-    mtlFile = fopen(fileName, "rt");
-
-    if (mtlFile == NULL)
-    {
-        TraceLog(LOG_WARNING, "[%s] MTL file could not be opened", fileName);
-        return material;
-    }
-
-    while (!feof(mtlFile))
-    {
-        fgets(buffer, MAX_BUFFER_SIZE, mtlFile);
-
-        switch (buffer[0])
-        {
-            case 'n':   // newmtl string    Material name. Begins a new material description.
-            {
-                // TODO: Support multiple materials in a single .mtl
-                sscanf(buffer, "newmtl %127s", mapFileName);
-            }
-            case 'i':   // illum int        Illumination model
-            {
-                // illum = 1 if specular disabled
-                // illum = 2 if specular enabled (lambertian model)
-                // ...
-            }
-            case 'K':   // Ka, Kd, Ks, Ke
-            {
-                switch (buffer[1])
-                {
-                    case 'a':   // Ka float float float    Ambient color (RGB)
-                    {
-                        sscanf(buffer, "Ka %f %f %f", &color.x, &color.y, &color.z);
-                        // TODO: Support ambient color
-                        //material.colAmbient.r = (unsigned char)(color.x*255);
-                        //material.colAmbient.g = (unsigned char)(color.y*255);
-                        //material.colAmbient.b = (unsigned char)(color.z*255);
-                    } break;
-                    case 'd':   // Kd float float float     Diffuse color (RGB)
-                    {
-                        sscanf(buffer, "Kd %f %f %f", &color.x, &color.y, &color.z);
-                        material.maps[MAP_DIFFUSE].color.r = (unsigned char)(color.x*255);
-                        material.maps[MAP_DIFFUSE].color.g = (unsigned char)(color.y*255);
-                        material.maps[MAP_DIFFUSE].color.b = (unsigned char)(color.z*255);
-                    } break;
-                    case 's':   // Ks float float float     Specular color (RGB)
-                    {
-                        sscanf(buffer, "Ks %f %f %f", &color.x, &color.y, &color.z);
-                        material.maps[MAP_SPECULAR].color.r = (unsigned char)(color.x*255);
-                        material.maps[MAP_SPECULAR].color.g = (unsigned char)(color.y*255);
-                        material.maps[MAP_SPECULAR].color.b = (unsigned char)(color.z*255);
-                    } break;
-                    case 'e':   // Ke float float float     Emmisive color (RGB)
-                    {
-                        // TODO: Support Ke?
-                    } break;
-                    default: break;
-                }
-            } break;
-            case 'N':   // Ns, Ni
-            {
-                if (buffer[1] == 's')       // Ns int   Shininess (specular exponent). Ranges from 0 to 1000.
-                {
-                    int shininess = 0;
-                    sscanf(buffer, "Ns %i", &shininess);
-
-                    //material.params[PARAM_GLOSSINES] = (float)shininess;
-                }
-                else if (buffer[1] == 'i')  // Ni int   Refraction index.
-                {
-                    // Not supported...
-                }
-            } break;
-            case 'm':   // map_Kd, map_Ks, map_Ka, map_Bump, map_d
-            {
-                switch (buffer[4])
-                {
-                    case 'K':   // Color texture maps
-                    {
-                        if (buffer[5] == 'd')       // map_Kd string    Diffuse color texture map.
-                        {
-                            result = sscanf(buffer, "map_Kd %127s", mapFileName);
-                            if (result != EOF) material.maps[MAP_DIFFUSE].texture = LoadTexture(mapFileName);
-                        }
-                        else if (buffer[5] == 's')  // map_Ks string    Specular color texture map.
-                        {
-                            result = sscanf(buffer, "map_Ks %127s", mapFileName);
-                            if (result != EOF) material.maps[MAP_SPECULAR].texture = LoadTexture(mapFileName);
-                        }
-                        else if (buffer[5] == 'a')  // map_Ka string    Ambient color texture map.
-                        {
-                            // Not supported...
-                        }
-                    } break;
-                    case 'B':       // map_Bump string      Bump texture map.
-                    {
-                        result = sscanf(buffer, "map_Bump %127s", mapFileName);
-                        if (result != EOF) material.maps[MAP_NORMAL].texture = LoadTexture(mapFileName);
-                    } break;
-                    case 'b':       // map_bump string      Bump texture map.
-                    {
-                        result = sscanf(buffer, "map_bump %127s", mapFileName);
-                        if (result != EOF) material.maps[MAP_NORMAL].texture = LoadTexture(mapFileName);
-                    } break;
-                    case 'd':       // map_d string         Opacity texture map.
-                    {
-                        // Not supported...
-                    } break;
-                    default: break;
-                }
-            } break;
-            case 'd':   // d, disp
-            {
-                if (buffer[1] == ' ')       // d float      Dissolve factor. d is inverse of Tr
-                {
-                    float alpha = 1.0f;
-                    sscanf(buffer, "d %f", &alpha);
-                    material.maps[MAP_DIFFUSE].color.a = (unsigned char)(alpha*255);
-                }
-                else if (buffer[1] == 'i')  // disp string  Displacement map
-                {
-                    // Not supported...
-                }
-            } break;
-            case 'b':   // bump string      Bump texture map
-            {
-                result = sscanf(buffer, "bump %127s", mapFileName);
-                if (result != EOF) material.maps[MAP_NORMAL].texture = LoadTexture(mapFileName);
-            } break;
-            case 'T':   // Tr float         Transparency Tr (alpha). Tr is inverse of d
-            {
-                float ialpha = 0.0f;
-                sscanf(buffer, "Tr %f", &ialpha);
-                material.maps[MAP_DIFFUSE].color.a = (unsigned char)((1.0f - ialpha)*255);
-
-            } break;
-            case 'r':   // refl string      Reflection texture map
-            default: break;
-        }
-    }
-
-    fclose(mtlFile);
-
-    // NOTE: At this point we have all material data
-    TraceLog(LOG_INFO, "[%s] Material loaded successfully", fileName);
-
-    return material;
-}
-#endif
-
 #if defined(SUPPORT_FILEFORMAT_GLTF)
 // Load IQM mesh data
 static Model LoadIQM(const char *fileName)