Merge branch 'master' of github.com:raysan5/raylib into fork/master

1 files changed, 423 insertions, 85 deletions

diff --git a/src/models.c b/src/models.c
index 315b51d4..8e9a6586 100644
--- a/src/models.c
+++ b/src/models.c
@@ -10,10 +10,14 @@
 *   #define SUPPORT_FILEFORMAT_MTL
 *       Selected desired fileformats to be supported for loading.
 *
+*   #define SUPPORT_MESH_GENERATION
+*       Support procedural mesh generation functions, uses external par_shapes.h library
+*       NOTE: Some generated meshes DO NOT include generated texture coordinates
+*
 *
 *   LICENSE: zlib/libpng
 *
-*   Copyright (c) 2014-2017 Ramon Santamaria (@raysan5)
+*   Copyright (c) 2014-2018 Ramon Santamaria (@raysan5)
 *
 *   This software is provided "as-is", without any express or implied warranty. In no event
 *   will the authors be held liable for any damages arising from the use of this software.
@@ -36,13 +40,12 @@
 //-------------------------------------------------
 #define SUPPORT_FILEFORMAT_OBJ
 #define SUPPORT_FILEFORMAT_MTL
+#define SUPPORT_MESH_GENERATION
 //-------------------------------------------------
 
 #include "raylib.h"
 
-#if defined(PLATFORM_ANDROID)
-    #include "utils.h"      // Android fopen function map
-#endif
+#include "utils.h"          // Required for: fopen() Android mapping
 
 #include <stdio.h>          // Required for: FILE, fopen(), fclose(), fscanf(), feof(), rewind(), fgets()
 #include <stdlib.h>         // Required for: malloc(), free()
@@ -51,6 +54,9 @@
 
 #include "rlgl.h"           // raylib OpenGL abstraction layer to OpenGL 1.1, 2.1, 3.3+ or ES2
 
+#define PAR_SHAPES_IMPLEMENTATION
+#include "external/par_shapes.h"    // Shapes 3d parametric generation
+
 //----------------------------------------------------------------------------------
 // Defines and Macros
 //----------------------------------------------------------------------------------
@@ -644,12 +650,147 @@ void UnloadMesh(Mesh *mesh)
     rlUnloadMesh(mesh);
 }
 
+#if defined(SUPPORT_MESH_GENERATION)
+// Generate plane mesh (with subdivisions)
+Mesh GenMeshPlane(float width, float length, int resX, int resZ)
+{
+    Mesh mesh = { 0 };
+
+#define CUSTOM_MESH_GEN_PLANE
+#if defined(CUSTOM_MESH_GEN_PLANE)
+    resX++;
+    resZ++;
+    
+    // Vertices definition
+    int vertexCount = resX*resZ*6;  // 6 vertex by quad
+
+    Vector3 *vertices = (Vector3 *)malloc(vertexCount*sizeof(Vector3));
+    for (int z = 0; z < resZ; z++)
+    {
+        // [-length/2, length/2]
+        float zPos = ((float)z/(resZ - 1) - 0.5f)*length;
+        for (int x = 0; x < resX; x++)
+        {
+            // [-width/2, width/2]
+            float xPos = ((float)x/(resX - 1) - 0.5f)*width;
+            vertices[x + z*resX] = (Vector3){ xPos, 0.0f, zPos };
+        }
+    }
+
+    // Normals definition
+    Vector3 *normals = (Vector3 *)malloc(vertexCount*sizeof(Vector3));
+    for (int n = 0; n < vertexCount; n++) normals[n] = (Vector3){ 0.0f, 1.0f, 0.0f };   // Vector3.up;
+
+    // TexCoords definition		
+    Vector2 *texcoords = (Vector2 *)malloc(vertexCount*sizeof(Vector2));
+    for (int v = 0; v < resZ; v++)
+    {
+        for (int u = 0; u < resX; u++)
+        {
+            texcoords[u + v*resX] = (Vector2){ (float)u/(resX - 1), (float)v/(resZ - 1) };
+        }
+    }
+
+    // Triangles definition (indices)
+    int numFaces = (resX - 1)*(resZ - 1);
+    int *triangles = (int *)malloc(numFaces*6*sizeof(int));
+    int t = 0;
+    for (int face = 0; face < numFaces; face++)
+    {
+        // Retrieve lower left corner from face ind
+        int i = face % (resX - 1) + (face/(resZ - 1)*resX);
+
+        triangles[t++] = i + resX;
+        triangles[t++] = i + 1;
+        triangles[t++] = i;
+
+        triangles[t++] = i + resX;	
+        triangles[t++] = i + resX + 1;
+        triangles[t++] = i + 1;
+    }
+
+    mesh.vertexCount = vertexCount;
+    mesh.triangleCount = numFaces*2;
+    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.indices = (unsigned short *)malloc(mesh.triangleCount*3*sizeof(unsigned short));
+    
+    // Mesh vertices position array
+    for (int i = 0; i < mesh.vertexCount; i++)
+    {
+        mesh.vertices[3*i] = vertices[i].x;
+        mesh.vertices[3*i + 1] = vertices[i].y;
+        mesh.vertices[3*i + 2] = vertices[i].z;
+    }
+    
+    // Mesh texcoords array
+    for (int i = 0; i < mesh.vertexCount; i++)
+    {
+        mesh.texcoords[2*i] = texcoords[i].x;
+        mesh.texcoords[2*i + 1] = texcoords[i].y;
+    }
+    
+    // Mesh normals array
+    for (int i = 0; i < mesh.vertexCount; i++)
+    {
+        mesh.normals[3*i] = normals[i].x;
+        mesh.normals[3*i + 1] = normals[i].y;
+        mesh.normals[3*i + 2] = normals[i].z;
+    }
+    
+    // Mesh indices array initialization
+    for (int i = 0; i < mesh.triangleCount*3; i++) mesh.indices[i] = triangles[i];
+    
+    free(vertices);
+    free(normals);
+    free(texcoords);
+    free(triangles);
+    
+#else       // Use par_shapes library to generate plane mesh
+
+    par_shapes_mesh *plane = par_shapes_create_plane(resX, resZ);   // No normals/texcoords generated!!!
+    par_shapes_scale(plane, width, length, 1.0f);
+    par_shapes_rotate(plane, -PI/2.0f, (float[]){ 1, 0, 0 });
+    par_shapes_translate(plane, -width/2, 0.0f, length/2);
+    
+    mesh.vertices = (float *)malloc(plane->ntriangles*3*3*sizeof(float));
+    mesh.texcoords = (float *)malloc(plane->ntriangles*3*2*sizeof(float));
+    mesh.normals = (float *)malloc(plane->ntriangles*3*3*sizeof(float));
+
+    mesh.vertexCount = plane->ntriangles*3;
+    mesh.triangleCount = plane->ntriangles;
+
+    for (int k = 0; k < mesh.vertexCount; k++)
+    {
+        mesh.vertices[k*3] = plane->points[plane->triangles[k]*3];
+        mesh.vertices[k*3 + 1] = plane->points[plane->triangles[k]*3 + 1];
+        mesh.vertices[k*3 + 2] = plane->points[plane->triangles[k]*3 + 2];
+        
+        mesh.normals[k*3] = plane->normals[plane->triangles[k]*3];
+        mesh.normals[k*3 + 1] = plane->normals[plane->triangles[k]*3 + 1];
+        mesh.normals[k*3 + 2] = plane->normals[plane->triangles[k]*3 + 2];
+        
+        mesh.texcoords[k*2] = plane->tcoords[plane->triangles[k]*2];
+        mesh.texcoords[k*2 + 1] = plane->tcoords[plane->triangles[k]*2 + 1];
+    }
+
+    par_shapes_free_mesh(plane);
+#endif
+
+    // Upload vertex data to GPU (static mesh)
+    rlLoadMesh(&mesh, false);  
+
+    return mesh;
+}
+
 // Generated cuboid mesh
-// NOTE: Vertex data is uploaded to GPU
 Mesh GenMeshCube(float width, float height, float length)
 {
     Mesh mesh = { 0 };
 
+#define CUSTOM_MESH_GEN_CUBE
+#if defined(CUSTOM_MESH_GEN_CUBE)
     float vertices[] = {
         -width/2, -height/2, length/2,
         width/2, -height/2, length/2,
@@ -760,6 +901,264 @@ Mesh GenMeshCube(float width, float height, float length)
     mesh.vertexCount = 24;
     mesh.triangleCount = 12;
     
+#else               // Use par_shapes library to generate cube mesh
+/*
+// Platonic solids:
+par_shapes_mesh* par_shapes_create_tetrahedron();       // 4 sides polyhedron (pyramid)
+par_shapes_mesh* par_shapes_create_cube();              // 6 sides polyhedron (cube)
+par_shapes_mesh* par_shapes_create_octahedron();        // 8 sides polyhedron (dyamond)
+par_shapes_mesh* par_shapes_create_dodecahedron();      // 12 sides polyhedron
+par_shapes_mesh* par_shapes_create_icosahedron();       // 20 sides polyhedron
+*/
+    // Platonic solid generation: cube (6 sides)
+    // NOTE: No normals/texcoords generated by default
+    par_shapes_mesh *cube = par_shapes_create_cube();
+    cube->tcoords = PAR_MALLOC(float, 2*cube->npoints);
+    for (int i = 0; i < 2*cube->npoints; i++) cube->tcoords[i] = 0.0f;    
+    par_shapes_scale(cube, width, height, length);
+    par_shapes_translate(cube, -width/2, 0.0f, -length/2);
+    par_shapes_compute_normals(cube);
+    
+    mesh.vertices = (float *)malloc(cube->ntriangles*3*3*sizeof(float));
+    mesh.texcoords = (float *)malloc(cube->ntriangles*3*2*sizeof(float));
+    mesh.normals = (float *)malloc(cube->ntriangles*3*3*sizeof(float));
+
+    mesh.vertexCount = cube->ntriangles*3;
+    mesh.triangleCount = cube->ntriangles;
+
+    for (int k = 0; k < mesh.vertexCount; k++)
+    {
+        mesh.vertices[k*3] = cube->points[cube->triangles[k]*3];
+        mesh.vertices[k*3 + 1] = cube->points[cube->triangles[k]*3 + 1];
+        mesh.vertices[k*3 + 2] = cube->points[cube->triangles[k]*3 + 2];
+        
+        mesh.normals[k*3] = cube->normals[cube->triangles[k]*3];
+        mesh.normals[k*3 + 1] = cube->normals[cube->triangles[k]*3 + 1];
+        mesh.normals[k*3 + 2] = cube->normals[cube->triangles[k]*3 + 2];
+        
+        mesh.texcoords[k*2] = cube->tcoords[cube->triangles[k]*2];
+        mesh.texcoords[k*2 + 1] = cube->tcoords[cube->triangles[k]*2 + 1];
+    }
+
+    par_shapes_free_mesh(cube);
+#endif
+
+    // Upload vertex data to GPU (static mesh)
+    rlLoadMesh(&mesh, false);  
+
+    return mesh;
+}
+
+// Generate sphere mesh (standard sphere)
+RLAPI Mesh GenMeshSphere(float radius, int rings, int slices)
+{
+    Mesh mesh = { 0 };
+
+    par_shapes_mesh *sphere = par_shapes_create_parametric_sphere(slices, rings);
+    par_shapes_scale(sphere, radius, radius, radius);
+    // NOTE: Soft normals are computed internally 
+    
+    mesh.vertices = (float *)malloc(sphere->ntriangles*3*3*sizeof(float));
+    mesh.texcoords = (float *)malloc(sphere->ntriangles*3*2*sizeof(float));
+    mesh.normals = (float *)malloc(sphere->ntriangles*3*3*sizeof(float));
+
+    mesh.vertexCount = sphere->ntriangles*3;
+    mesh.triangleCount = sphere->ntriangles;
+
+    for (int k = 0; k < mesh.vertexCount; k++)
+    {
+        mesh.vertices[k*3] = sphere->points[sphere->triangles[k]*3];
+        mesh.vertices[k*3 + 1] = sphere->points[sphere->triangles[k]*3 + 1];
+        mesh.vertices[k*3 + 2] = sphere->points[sphere->triangles[k]*3 + 2];
+        
+        mesh.normals[k*3] = sphere->normals[sphere->triangles[k]*3];
+        mesh.normals[k*3 + 1] = sphere->normals[sphere->triangles[k]*3 + 1];
+        mesh.normals[k*3 + 2] = sphere->normals[sphere->triangles[k]*3 + 2];
+        
+        mesh.texcoords[k*2] = sphere->tcoords[sphere->triangles[k]*2];
+        mesh.texcoords[k*2 + 1] = sphere->tcoords[sphere->triangles[k]*2 + 1];
+    }
+
+    par_shapes_free_mesh(sphere);
+    
+    // Upload vertex data to GPU (static mesh)
+    rlLoadMesh(&mesh, false);  
+
+    return mesh;
+}
+
+// Generate hemi-sphere mesh (half sphere, no bottom cap)
+RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices)
+{
+    Mesh mesh = { 0 };
+
+    par_shapes_mesh *sphere = par_shapes_create_hemisphere(slices, rings);
+    par_shapes_scale(sphere, radius, radius, radius);
+    // NOTE: Soft normals are computed internally 
+    
+    mesh.vertices = (float *)malloc(sphere->ntriangles*3*3*sizeof(float));
+    mesh.texcoords = (float *)malloc(sphere->ntriangles*3*2*sizeof(float));
+    mesh.normals = (float *)malloc(sphere->ntriangles*3*3*sizeof(float));
+
+    mesh.vertexCount = sphere->ntriangles*3;
+    mesh.triangleCount = sphere->ntriangles;
+
+    for (int k = 0; k < mesh.vertexCount; k++)
+    {
+        mesh.vertices[k*3] = sphere->points[sphere->triangles[k]*3];
+        mesh.vertices[k*3 + 1] = sphere->points[sphere->triangles[k]*3 + 1];
+        mesh.vertices[k*3 + 2] = sphere->points[sphere->triangles[k]*3 + 2];
+        
+        mesh.normals[k*3] = sphere->normals[sphere->triangles[k]*3];
+        mesh.normals[k*3 + 1] = sphere->normals[sphere->triangles[k]*3 + 1];
+        mesh.normals[k*3 + 2] = sphere->normals[sphere->triangles[k]*3 + 2];
+        
+        mesh.texcoords[k*2] = sphere->tcoords[sphere->triangles[k]*2];
+        mesh.texcoords[k*2 + 1] = sphere->tcoords[sphere->triangles[k]*2 + 1];
+    }
+
+    par_shapes_free_mesh(sphere);
+    
+    // Upload vertex data to GPU (static mesh)
+    rlLoadMesh(&mesh, false);  
+
+    return mesh;
+}
+
+// Generate cylinder mesh
+Mesh GenMeshCylinder(float radius, float height, int slices)
+{
+    Mesh mesh = { 0 };
+
+    // Instance a cylinder that sits on the Z=0 plane using the given tessellation
+    // levels across the UV domain.  Think of "slices" like a number of pizza
+    // slices, and "stacks" like a number of stacked rings.  
+    // Height and radius are both 1.0, but they can easily be changed with par_shapes_scale
+    par_shapes_mesh *cylinder = par_shapes_create_cylinder(slices, 8);
+    par_shapes_scale(cylinder, radius, radius, height);
+    par_shapes_rotate(cylinder, -PI/2.0f, (float[]){ 1, 0, 0 });
+
+    // Generate an orientable disk shape (top cap)
+    par_shapes_mesh *capTop = par_shapes_create_disk(radius, slices, (float[]){ 0, 0, 0 }, (float[]){ 0, 0, 1 });
+    capTop->tcoords = PAR_MALLOC(float, 2*capTop->npoints);
+    for (int i = 0; i < 2*capTop->npoints; i++) capTop->tcoords[i] = 0.0f;
+    par_shapes_rotate(capTop, -PI/2.0f, (float[]){ 1, 0, 0 });
+    par_shapes_translate(capTop, 0, height, 0);
+    
+    // Generate an orientable disk shape (bottom cap)
+    par_shapes_mesh *capBottom = par_shapes_create_disk(radius, slices, (float[]){ 0, 0, 0 }, (float[]){ 0, 0, -1 });
+    capBottom->tcoords = PAR_MALLOC(float, 2*capBottom->npoints);
+    for (int i = 0; i < 2*capBottom->npoints; i++) capBottom->tcoords[i] = 0.95f;
+    par_shapes_rotate(capBottom, PI/2.0f, (float[]){ 1, 0, 0 });
+    
+    par_shapes_merge_and_free(cylinder, capTop);
+    par_shapes_merge_and_free(cylinder, capBottom);
+    
+    mesh.vertices = (float *)malloc(cylinder->ntriangles*3*3*sizeof(float));
+    mesh.texcoords = (float *)malloc(cylinder->ntriangles*3*2*sizeof(float));
+    mesh.normals = (float *)malloc(cylinder->ntriangles*3*3*sizeof(float));
+
+    mesh.vertexCount = cylinder->ntriangles*3;
+    mesh.triangleCount = cylinder->ntriangles;
+
+    for (int k = 0; k < mesh.vertexCount; k++)
+    {
+        mesh.vertices[k*3] = cylinder->points[cylinder->triangles[k]*3];
+        mesh.vertices[k*3 + 1] = cylinder->points[cylinder->triangles[k]*3 + 1];
+        mesh.vertices[k*3 + 2] = cylinder->points[cylinder->triangles[k]*3 + 2];
+        
+        mesh.normals[k*3] = cylinder->normals[cylinder->triangles[k]*3];
+        mesh.normals[k*3 + 1] = cylinder->normals[cylinder->triangles[k]*3 + 1];
+        mesh.normals[k*3 + 2] = cylinder->normals[cylinder->triangles[k]*3 + 2];
+        
+        mesh.texcoords[k*2] = cylinder->tcoords[cylinder->triangles[k]*2];
+        mesh.texcoords[k*2 + 1] = cylinder->tcoords[cylinder->triangles[k]*2 + 1];
+    }
+
+    par_shapes_free_mesh(cylinder);
+    
+    // Upload vertex data to GPU (static mesh)
+    rlLoadMesh(&mesh, false);  
+
+    return mesh;
+}
+
+// Generate torus mesh
+Mesh GenMeshTorus(float radius, float size, int radSeg, int sides)
+{
+    Mesh mesh = { 0 };
+
+    if (radius > 1.0f) radius = 1.0f;
+    else if (radius < 0.1f) radius = 0.1f;
+    
+    // Create a donut that sits on the Z=0 plane with the specified inner radius
+    // The outer radius can be controlled with par_shapes_scale
+    par_shapes_mesh *torus = par_shapes_create_torus(radSeg, sides, radius);
+    par_shapes_scale(torus, size/2, size/2, size/2);
+
+    mesh.vertices = (float *)malloc(torus->ntriangles*3*3*sizeof(float));
+    mesh.texcoords = (float *)malloc(torus->ntriangles*3*2*sizeof(float));
+    mesh.normals = (float *)malloc(torus->ntriangles*3*3*sizeof(float));
+
+    mesh.vertexCount = torus->ntriangles*3;
+    mesh.triangleCount = torus->ntriangles;
+
+    for (int k = 0; k < mesh.vertexCount; k++)
+    {
+        mesh.vertices[k*3] = torus->points[torus->triangles[k]*3];
+        mesh.vertices[k*3 + 1] = torus->points[torus->triangles[k]*3 + 1];
+        mesh.vertices[k*3 + 2] = torus->points[torus->triangles[k]*3 + 2];
+        
+        mesh.normals[k*3] = torus->normals[torus->triangles[k]*3];
+        mesh.normals[k*3 + 1] = torus->normals[torus->triangles[k]*3 + 1];
+        mesh.normals[k*3 + 2] = torus->normals[torus->triangles[k]*3 + 2];
+        
+        mesh.texcoords[k*2] = torus->tcoords[torus->triangles[k]*2];
+        mesh.texcoords[k*2 + 1] = torus->tcoords[torus->triangles[k]*2 + 1];
+    }
+
+    par_shapes_free_mesh(torus);
+    
+    // Upload vertex data to GPU (static mesh)
+    rlLoadMesh(&mesh, false);  
+
+    return mesh;
+}
+
+// Generate trefoil knot mesh
+Mesh GenMeshKnot(float radius, float size, int radSeg, int sides)
+{
+    Mesh mesh = { 0 };
+    
+    if (radius > 3.0f) radius = 3.0f;
+    else if (radius < 0.5f) radius = 0.5f;
+
+    par_shapes_mesh *knot = par_shapes_create_trefoil_knot(radSeg, sides, radius);
+    par_shapes_scale(knot, size, size, size);
+
+    mesh.vertices = (float *)malloc(knot->ntriangles*3*3*sizeof(float));
+    mesh.texcoords = (float *)malloc(knot->ntriangles*3*2*sizeof(float));
+    mesh.normals = (float *)malloc(knot->ntriangles*3*3*sizeof(float));
+
+    mesh.vertexCount = knot->ntriangles*3;
+    mesh.triangleCount = knot->ntriangles;
+
+    for (int k = 0; k < mesh.vertexCount; k++)
+    {
+        mesh.vertices[k*3] = knot->points[knot->triangles[k]*3];
+        mesh.vertices[k*3 + 1] = knot->points[knot->triangles[k]*3 + 1];
+        mesh.vertices[k*3 + 2] = knot->points[knot->triangles[k]*3 + 2];
+        
+        mesh.normals[k*3] = knot->normals[knot->triangles[k]*3];
+        mesh.normals[k*3 + 1] = knot->normals[knot->triangles[k]*3 + 1];
+        mesh.normals[k*3 + 2] = knot->normals[knot->triangles[k]*3 + 2];
+        
+        mesh.texcoords[k*2] = knot->tcoords[knot->triangles[k]*2];
+        mesh.texcoords[k*2 + 1] = knot->tcoords[knot->triangles[k]*2 + 1];
+    }
+
+    par_shapes_free_mesh(knot);
+    
     // Upload vertex data to GPU (static mesh)
     rlLoadMesh(&mesh, false);  
 
@@ -1234,6 +1633,7 @@ Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize)
 
     return mesh;
 }
+#endif      // SUPPORT_MESH_GENERATION
 
 // Load material data (from file)
 Material LoadMaterial(const char *fileName)
@@ -1271,14 +1671,13 @@ Material LoadMaterialDefault(void)
 // Unload material from memory
 void UnloadMaterial(Material material)
 {
-    // Unload material shader
-    UnloadShader(material.shader);
+    // Unload material shader (avoid unloading default shader, managed by raylib)
+    if (material.shader.id != GetShaderDefault().id) UnloadShader(material.shader);
 
-    // Unload loaded texture maps
+    // Unload loaded texture maps (avoid unloading default texture, managed by raylib)
     for (int i = 0; i < MAX_MATERIAL_MAPS; i++)
     {
-        // NOTE: We already check for (tex.id > 0) inside function
-        rlDeleteTextures(material.maps[i].texture.id); 
+        if (material.maps[i].texture.id != GetTextureDefault().id) rlDeleteTextures(material.maps[i].texture.id); 
     }
 }
 
@@ -1656,9 +2055,9 @@ RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight)
     return result;
 }
 
-// Calculate mesh bounding box limits
+// Compute mesh bounding box limits
 // NOTE: minVertex and maxVertex should be transformed by model transform matrix
-BoundingBox CalculateBoundingBox(Mesh mesh)
+BoundingBox MeshBoundingBox(Mesh mesh)
 {
     // Get min and max vertex to construct bounds (AABB)
     Vector3 minVertex = { 0 };
@@ -1684,6 +2083,18 @@ BoundingBox CalculateBoundingBox(Mesh mesh)
     return box;
 }
 
+// Compute mesh tangents 
+void MeshTangents(Mesh *mesh)
+{
+    // TODO: Compute mesh tangents
+}
+
+// Compute mesh binormals
+void MeshBinormals(Mesh *mesh)
+{
+    // TODO: Compute mesh binormals
+}
+
 //----------------------------------------------------------------------------------
 // Module specific Functions Definition
 //----------------------------------------------------------------------------------
@@ -1925,79 +2336,6 @@ static Mesh LoadOBJ(const char *fileName)
 
     fclose(objFile);
 
-    // Security check, just in case no normals or no texcoords defined in OBJ
-    if (texcoordCount == 0) for (int i = 0; i < (2*mesh.vertexCount); i++) mesh.texcoords[i] = 0.0f;
-    else
-    {
-        // Attempt to calculate mesh tangents and binormals using positions and texture coordinates
-        mesh.tangents = (float *)malloc(mesh.vertexCount*3*sizeof(float));
-        // mesh.binormals = (float *)malloc(mesh.vertexCount*3*sizeof(float));
-
-        int vCount = 0;
-        int uvCount = 0;
-        while (vCount < mesh.vertexCount*3)
-        {
-            // Calculate mesh vertex positions as Vector3
-            Vector3 v0 = { mesh.vertices[vCount], mesh.vertices[vCount + 1], mesh.vertices[vCount + 2] };
-            Vector3 v1 = { mesh.vertices[vCount + 3], mesh.vertices[vCount + 4], mesh.vertices[vCount + 5] };
-            Vector3 v2 = { mesh.vertices[vCount + 6], mesh.vertices[vCount + 7], mesh.vertices[vCount + 8] };
-
-            // Calculate mesh texture coordinates as Vector2
-            Vector2 uv0 = { mesh.texcoords[uvCount + 0], mesh.texcoords[uvCount + 1] };
-            Vector2 uv1 = { mesh.texcoords[uvCount + 2], mesh.texcoords[uvCount + 3] };
-            Vector2 uv2 = { mesh.texcoords[uvCount + 4], mesh.texcoords[uvCount + 5] };
-
-            // Calculate edges of the triangle (position delta)
-            Vector3 deltaPos1 = Vector3Subtract(v1, v0);
-            Vector3 deltaPos2 = Vector3Subtract(v2, v0);
-
-            // UV delta
-            Vector2 deltaUV1 = { uv1.x - uv0.x, uv1.y - uv0.y };
-            Vector2 deltaUV2 = { uv2.x - uv0.x, uv2.y - uv0.y };
-
-            float r = 1.0f/(deltaUV1.x*deltaUV2.y - deltaUV1.y*deltaUV2.x);
-            Vector3 t1 = { deltaPos1.x*deltaUV2.y, deltaPos1.y*deltaUV2.y, deltaPos1.z*deltaUV2.y };
-            Vector3 t2 = { deltaPos2.x*deltaUV1.y, deltaPos2.y*deltaUV1.y, deltaPos2.z*deltaUV1.y };
-            // Vector3 b1 = { deltaPos2.x*deltaUV1.x, deltaPos2.y*deltaUV1.x, deltaPos2.z*deltaUV1.x };
-            // Vector3 b2 = { deltaPos1.x*deltaUV2.x, deltaPos1.y*deltaUV2.x, deltaPos1.z*deltaUV2.x };
-
-            // Calculate vertex tangent
-            Vector3 tangent = Vector3Subtract(t1, t2);
-            Vector3Scale(&tangent, r);
-
-            // Apply calculated tangents data to mesh struct
-            mesh.tangents[vCount + 0] = tangent.x;
-            mesh.tangents[vCount + 1] = tangent.y;
-            mesh.tangents[vCount + 2] = tangent.z;
-            mesh.tangents[vCount + 3] = tangent.x;
-            mesh.tangents[vCount + 4] = tangent.y;
-            mesh.tangents[vCount + 5] = tangent.z;
-            mesh.tangents[vCount + 6] = tangent.x;
-            mesh.tangents[vCount + 7] = tangent.y;
-            mesh.tangents[vCount + 8] = tangent.z;
-
-            // TODO: add binormals to mesh struct and assign buffers id and locations properly
-            /* // Calculate vertex binormal
-            Vector3 binormal = Vector3Subtract(b1, b2);
-            Vector3Scale(&binormal, r);
-
-            // Apply calculated binormals data to mesh struct
-            mesh.binormals[vCount + 0] = binormal.x;
-            mesh.binormals[vCount + 1] = binormal.y;
-            mesh.binormals[vCount + 2] = binormal.z;
-            mesh.binormals[vCount + 3] = binormal.x;
-            mesh.binormals[vCount + 4] = binormal.y;
-            mesh.binormals[vCount + 5] = binormal.z;
-            mesh.binormals[vCount + 6] = binormal.x;
-            mesh.binormals[vCount + 7] = binormal.y;
-            mesh.binormals[vCount + 8] = binormal.z; */
-
-            // Update vertex position and texture coordinates counters
-            vCount += 9;
-            uvCount += 6;
-        }
-    }
-
     // Now we can free temp mid* arrays
     free(midVertices);
     free(midNormals);