From fb334e2fd11ade79377a2d95a83000763c047975 Mon Sep 17 00:00:00 2001
From: Ray <raysan5@gmail.com>
Date: Sat, 2 Sep 2017 17:42:22 +0200
Subject: Testing shapes generation using additional library

---
 src/models.c | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

(limited to 'src/models.c')

diff --git a/src/models.c b/src/models.c
index 315b51d4..63b18ce9 100644
--- a/src/models.c
+++ b/src/models.c
@@ -51,6 +51,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"
+
 //----------------------------------------------------------------------------------
 // Defines and Macros
 //----------------------------------------------------------------------------------
@@ -650,6 +653,7 @@ Mesh GenMeshCube(float width, float height, float length)
 {
     Mesh mesh = { 0 };
 
+    /*
     float vertices[] = {
         -width/2, -height/2, length/2,
         width/2, -height/2, length/2,
@@ -759,6 +763,39 @@ Mesh GenMeshCube(float width, float height, float length)
     
     mesh.vertexCount = 24;
     mesh.triangleCount = 12;
+    */
+    
+    // TODO: Just testing par_shapes mesh generation functions
+    //--------------------------------------------------------
+    par_shapes_mesh *cube = par_shapes_create_cube();   // No normals/texcoords generated!!!
+    par_shapes_scale(cube, width, height, length);
+    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 i = 0; i < cube->ntriangles*3; i++) printf("%i ", cube->triangles[i]);
+    //for (int i = 0; i < cube->npoints*3; i += 3) printf("\nv%.1f %.1f %.1f ", cube->points[i], cube->points[i + 1], cube->points[i + 2]);
+
+    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] = 0.0f;//cube->tcoords[cube->triangles[k]*2];
+        mesh.texcoords[k*2 + 1] = 0.0f;//cube->tcoords[cube->triangles[k]*2 + 1];
+    }
+
+    par_shapes_free_mesh(cube);
     
     // Upload vertex data to GPU (static mesh)
     rlLoadMesh(&mesh, false);  
@@ -766,6 +803,11 @@ Mesh GenMeshCube(float width, float height, float length)
     return mesh;
 }
 
+//RLAPI Mesh GenMeshSphere(float radius, int rings, int slices);                                        // Generate sphere mesh (standard sphere)
+//RLAPI Mesh GenMeshCylinder(float radiusTop, float radiusBottom, float height, int slices);            // Generate cylinder mesh
+//RLAPI Mesh GenMeshTorus(float radius1, float radius2, int radSeg, int sides);                         // Generate torus mesh
+//RLAPI Mesh GenMeshTube(float radius1, float radius2, float height, int sides);                        // Generate tube mesh
+
 // Generate a mesh from heightmap
 // NOTE: Vertex data is uploaded to GPU
 Mesh GenMeshHeightmap(Image heightmap, Vector3 size)
-- 
cgit v1.2.3


From 20968830c0a8721c2a2d94719da5fe2cd753c114 Mon Sep 17 00:00:00 2001
From: raysan5 <raysan5@gmail.com>
Date: Mon, 18 Sep 2017 00:59:22 +0200
Subject: Added mesh generation functions

---
 src/models.c   | 385 ++++++++++++++++++++++++++++++++++++++++++++++++++++++---
 src/raylib.h   |  12 +-
 src/textures.c |   6 +
 3 files changed, 383 insertions(+), 20 deletions(-)

(limited to 'src/models.c')

diff --git a/src/models.c b/src/models.c
index 63b18ce9..ea8f6c30 100644
--- a/src/models.c
+++ b/src/models.c
@@ -10,6 +10,10 @@
 *   #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
 *
@@ -36,6 +40,7 @@
 //-------------------------------------------------
 #define SUPPORT_FILEFORMAT_OBJ
 #define SUPPORT_FILEFORMAT_MTL
+#define SUPPORT_MESH_GENERATION
 //-------------------------------------------------
 
 #include "raylib.h"
@@ -647,13 +652,142 @@ 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[vertexCount];
+    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[vertexCount];
+    for (int n = 0; n < vertexCount; n++) normals[n] = (Vector3){ 0.0f, 1.0f, 0.0f };   // Vector3.up;
+
+    // TexCoords definition		
+    Vector2 texcoords[vertexCount];
+    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 nbFaces = (resX - 1)*(resZ - 1);
+    int triangles[nbFaces*6];
+    int t = 0;
+    for (int face = 0; face < nbFaces; 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 = nbFaces*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];
+    
+#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,
@@ -763,12 +897,23 @@ Mesh GenMeshCube(float width, float height, float length)
     
     mesh.vertexCount = 24;
     mesh.triangleCount = 12;
-    */
     
-    // TODO: Just testing par_shapes mesh generation functions
-    //--------------------------------------------------------
-    par_shapes_mesh *cube = par_shapes_create_cube();   // No normals/texcoords generated!!!
+#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));
@@ -777,9 +922,6 @@ Mesh GenMeshCube(float width, float height, float length)
 
     mesh.vertexCount = cube->ntriangles*3;
     mesh.triangleCount = cube->ntriangles;
-    
-    //for (int i = 0; i < cube->ntriangles*3; i++) printf("%i ", cube->triangles[i]);
-    //for (int i = 0; i < cube->npoints*3; i += 3) printf("\nv%.1f %.1f %.1f ", cube->points[i], cube->points[i + 1], cube->points[i + 2]);
 
     for (int k = 0; k < mesh.vertexCount; k++)
     {
@@ -791,11 +933,50 @@ Mesh GenMeshCube(float width, float height, float length)
         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] = 0.0f;//cube->tcoords[cube->triangles[k]*2];
-        mesh.texcoords[k*2 + 1] = 0.0f;//cube->tcoords[cube->triangles[k]*2 + 1];
+        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);  
@@ -803,10 +984,183 @@ Mesh GenMeshCube(float width, float height, float length)
     return mesh;
 }
 
-//RLAPI Mesh GenMeshSphere(float radius, int rings, int slices);                                        // Generate sphere mesh (standard sphere)
-//RLAPI Mesh GenMeshCylinder(float radiusTop, float radiusBottom, float height, int slices);            // Generate cylinder mesh
-//RLAPI Mesh GenMeshTorus(float radius1, float radius2, int radSeg, int sides);                         // Generate torus mesh
-//RLAPI Mesh GenMeshTube(float radius1, float radius2, float height, int sides);                        // Generate tube 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);  
+
+    return mesh;
+}
 
 // Generate a mesh from heightmap
 // NOTE: Vertex data is uploaded to GPU
@@ -1276,6 +1630,7 @@ Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize)
 
     return mesh;
 }
+#endif      // SUPPORT_MESH_GENERATION
 
 // Load material data (from file)
 Material LoadMaterial(const char *fileName)
diff --git a/src/raylib.h b/src/raylib.h
index bc7a0677..07674531 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -998,12 +998,14 @@ RLAPI void UnloadModel(Model model);
 RLAPI Mesh LoadMesh(const char *fileName);                                                              // Load mesh from file
 RLAPI void UnloadMesh(Mesh *mesh);                                                                      // Unload mesh from memory (RAM and/or VRAM)
 
-//RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ);                               // Generate plane mesh (with desired subdivisions)
+// Mesh generation functions
+RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ);                                 // Generate plane mesh (with subdivisions)
 RLAPI Mesh GenMeshCube(float width, float height, float length);                                        // Generate cuboid mesh
-//RLAPI Mesh GenMeshSphere(float radius, int rings, int slices);                                        // Generate sphere mesh (standard sphere)
-//RLAPI Mesh GenMeshCylinder(float radiusTop, float radiusBottom, float height, int slices);            // Generate cylinder mesh
-//RLAPI Mesh GenMeshTorus(float radius1, float radius2, int radSeg, int sides);                         // Generate torus mesh
-//RLAPI Mesh GenMeshTube(float radius1, float radius2, float height, int sides);                        // Generate tube mesh
+RLAPI Mesh GenMeshSphere(float radius, int rings, int slices);                                          // Generate sphere mesh (standard sphere)
+RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices);                                      // Generate half-sphere mesh (no bottom cap)
+RLAPI Mesh GenMeshCylinder(float radius, float height, int slices);                                     // Generate cylinder mesh
+RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides);                               // Generate torus mesh
+RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides);                                // Generate trefoil knot mesh
 RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size);                                             // Generate heightmap mesh from image data
 RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize);                                           // Generate cubes-based map mesh from image data
 
diff --git a/src/textures.c b/src/textures.c
index 9322004b..b6c90ad7 100644
--- a/src/textures.c
+++ b/src/textures.c
@@ -23,6 +23,9 @@
 *       Support multiple image editing functions to scale, adjust colors, flip, draw on images, crop...
 *       If not defined only three image editing functions supported: ImageFormat(), ImageAlphaMask(), ImageToPOT()
 *
+*   #define SUPPORT_IMAGE_GENERATION
+*       Support proedural image generation functionality (gradient, spot, perlin-noise, cellular)
+*
 *   DEPENDENCIES:
 *       stb_image        - Multiple image formats loading (JPEG, PNG, BMP, TGA, PSD, GIF, PIC)
 *                          NOTE: stb_image has been slightly modified to support Android platform.
@@ -56,6 +59,7 @@
 #define SUPPORT_FILEFORMAT_DDS
 #define SUPPORT_FILEFORMAT_HDR
 #define SUPPORT_IMAGE_MANIPULATION
+#define SUPPORT_IMAGE_GENERATION
 //-------------------------------------------------
 
 #include "raylib.h"
@@ -1447,6 +1451,7 @@ void ImageColorBrightness(Image *image, int brightness)
 }
 #endif      // SUPPORT_IMAGE_MANIPULATION
 
+#if defined(SUPPORT_IMAGE_GENERATION)
 // Generate image: vertical gradient
 Image GenImageGradientV(int width, int height, Color top, Color bottom)
 {
@@ -1647,6 +1652,7 @@ Image GenImageCellular(int width, int height, int tileSize)
 
     return image;
 }
+#endif      // SUPPORT_IMAGE_GENERATION
 
 // Generate GPU mipmaps for a texture
 void GenTextureMipmaps(Texture2D *texture)
-- 
cgit v1.2.3


From 86df9168e78ab048f5aba989b2e704e87adea736 Mon Sep 17 00:00:00 2001
From: Ray San <raysan5@gmail.com>
Date: Thu, 19 Oct 2017 14:14:18 +0200
Subject: Updated raylib VS2015 project

---
 project/vs2015/raylib/raylib.vcxproj |   2 +-
 release/libs/win32/msvc/raylib.lib   | Bin 2336290 -> 2589838 bytes
 src/models.c                         |  19 ++++++++++++-------
 3 files changed, 13 insertions(+), 8 deletions(-)

(limited to 'src/models.c')

diff --git a/project/vs2015/raylib/raylib.vcxproj b/project/vs2015/raylib/raylib.vcxproj
index 6ab4a6c1..37e8b183 100644
--- a/project/vs2015/raylib/raylib.vcxproj
+++ b/project/vs2015/raylib/raylib.vcxproj
@@ -75,7 +75,7 @@
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions);GRAPHICS_API_OPENGL_33;PLATFORM_DESKTOP</PreprocessorDefinitions>
-      <AdditionalIncludeDirectories>$(SolutionDir)..\..\src\external\openal_soft\include;$(SolutionDir)..\..\src\external\glfw3\include;$(SolutionDir)..\..\src\external;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)..\..\release\include;$(SolutionDir)..\..\src\external;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <CompileAs>CompileAsC</CompileAs>
     </ClCompile>
     <Link>
diff --git a/release/libs/win32/msvc/raylib.lib b/release/libs/win32/msvc/raylib.lib
index 0af993c9..6983d9a8 100644
Binary files a/release/libs/win32/msvc/raylib.lib and b/release/libs/win32/msvc/raylib.lib differ
diff --git a/src/models.c b/src/models.c
index ea8f6c30..4b8a6731 100644
--- a/src/models.c
+++ b/src/models.c
@@ -666,7 +666,7 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
     // Vertices definition
     int vertexCount = resX*resZ*6;  // 6 vertex by quad
 
-    Vector3 vertices[vertexCount];
+    Vector3 *vertices = (Vector3 *)malloc(vertexCount*sizeof(Vector3));
     for (int z = 0; z < resZ; z++)
     {
         // [-length/2, length/2]
@@ -680,11 +680,11 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
     }
 
     // Normals definition
-    Vector3 normals[vertexCount];
+    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[vertexCount];
+    Vector2 *texcoords = (Vector2 *)malloc(vertexCount*sizeof(Vector2));
     for (int v = 0; v < resZ; v++)
     {
         for (int u = 0; u < resX; u++)
@@ -694,10 +694,10 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
     }
 
     // Triangles definition (indices)
-    int nbFaces = (resX - 1)*(resZ - 1);
-    int triangles[nbFaces*6];
+    int numFaces = (resX - 1)*(resZ - 1);
+    int *triangles = (int *)malloc(numFaces*6*sizeof(int));
     int t = 0;
-    for (int face = 0; face < nbFaces; face++)
+    for (int face = 0; face < numFaces; face++)
     {
         // Retrieve lower left corner from face ind
         int i = face % (resX - 1) + (face/(resZ - 1)*resX);
@@ -712,7 +712,7 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
     }
 
     mesh.vertexCount = vertexCount;
-    mesh.triangleCount = nbFaces*2;
+    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));
@@ -744,6 +744,11 @@ Mesh GenMeshPlane(float width, float length, int resX, int resZ)
     // 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!!!
-- 
cgit v1.2.3


From 00c34a035c6cf32fb688dd06da39db32fa66bc70 Mon Sep 17 00:00:00 2001
From: Ray San <raysan5@gmail.com>
Date: Wed, 20 Dec 2017 12:37:08 +0100
Subject: Updated copyright year

---
 src/gestures.h | 2 +-
 src/models.c   | 2 +-
 src/shapes.c   | 2 +-
 src/text.c     | 2 +-
 src/utils.c    | 2 +-
 src/utils.h    | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

(limited to 'src/models.c')

diff --git a/src/gestures.h b/src/gestures.h
index 58670ef5..58f046cb 100644
--- a/src/gestures.h
+++ b/src/gestures.h
@@ -24,7 +24,7 @@
 *
 *   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.
diff --git a/src/models.c b/src/models.c
index 4b8a6731..002ffac3 100644
--- a/src/models.c
+++ b/src/models.c
@@ -17,7 +17,7 @@
 *
 *   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.
diff --git a/src/shapes.c b/src/shapes.c
index 0b34f921..9f405419 100644
--- a/src/shapes.c
+++ b/src/shapes.c
@@ -13,7 +13,7 @@
 *
 *   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.
diff --git a/src/text.c b/src/text.c
index f577be19..eaf450b0 100644
--- a/src/text.c
+++ b/src/text.c
@@ -17,7 +17,7 @@
 *
 *   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.
diff --git a/src/utils.c b/src/utils.c
index aaa5bdb4..72d4f2da 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -25,7 +25,7 @@
 *
 *   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.
diff --git a/src/utils.h b/src/utils.h
index a1801245..f4a1a01a 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -5,7 +5,7 @@
 *
 *   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.
-- 
cgit v1.2.3


From e7cf03b1e4c1aa7872bda7b35a7d064815332759 Mon Sep 17 00:00:00 2001
From: raysan5 <raysan5@gmail.com>
Date: Thu, 28 Dec 2017 19:27:02 +0100
Subject: Minor tweaks

---
 src/models.c   | 6 ++----
 src/rlgl.c     | 8 ++++----
 src/textures.c | 2 +-
 3 files changed, 7 insertions(+), 9 deletions(-)

(limited to 'src/models.c')

diff --git a/src/models.c b/src/models.c
index 002ffac3..1f37e345 100644
--- a/src/models.c
+++ b/src/models.c
@@ -45,9 +45,7 @@
 
 #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()
@@ -57,7 +55,7 @@
 #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"
+#include "external/par_shapes.h"    // Shapes 3d parametric generation
 
 //----------------------------------------------------------------------------------
 // Defines and Macros
diff --git a/src/rlgl.c b/src/rlgl.c
index 58e9187d..4bbebf03 100644
--- a/src/rlgl.c
+++ b/src/rlgl.c
@@ -1109,7 +1109,7 @@ void rlglInit(int width, int height)
         if (strcmp(extList[i], (const char *)"GL_OES_texture_npot") == 0) texNPOTSupported = true;
         
         // Check texture float support
-        if (strcmp(extList[i], (const char *)"OES_texture_float") == 0) texFloatSupported = true;
+        if (strcmp(extList[i], (const char *)"GL_OES_texture_float") == 0) texFloatSupported = true;
 #endif
 
         // DDS texture compression support
@@ -1137,11 +1137,11 @@ void rlglInit(int width, int height)
             glGetFloatv(0x84FF, &maxAnisotropicLevel);   // GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
         }
 
-        // Debug marker support
-        if(strcmp(extList[i], (const char *)"GL_EXT_debug_marker") == 0) debugMarkerSupported = true;
-
         // Clamp mirror wrap mode supported
         if (strcmp(extList[i], (const char *)"GL_EXT_texture_mirror_clamp") == 0) texClampMirrorSupported = true;
+        
+        // Debug marker support
+        if(strcmp(extList[i], (const char *)"GL_EXT_debug_marker") == 0) debugMarkerSupported = true;
     }
 
 #ifdef _MSC_VER
diff --git a/src/textures.c b/src/textures.c
index 34f2c323..fd2fae0d 100644
--- a/src/textures.c
+++ b/src/textures.c
@@ -1681,7 +1681,7 @@ Image GenImageCellular(int width, int height, int tileSize)
 // Generate GPU mipmaps for a texture
 void GenTextureMipmaps(Texture2D *texture)
 {
-#if PLATFORM_WEB
+#if defined(PLATFORM_WEB)
     // Calculate next power-of-two values
     int potWidth = (int)powf(2, ceilf(logf((float)texture->width)/logf(2)));
     int potHeight = (int)powf(2, ceilf(logf((float)texture->height)/logf(2)));
-- 
cgit v1.2.3


From 6d64327a874b09e93290d1525edd5347a9787b84 Mon Sep 17 00:00:00 2001
From: Ray <raysan5@gmail.com>
Date: Thu, 22 Feb 2018 12:39:17 +0100
Subject: Reviewed unloading model data

When UnloadModel() --> UnloadMaterial(), avoid unloading default shader (if used) and avoid unlaoding default texture (if used), that data is managed by raylib internally. The question is... should UnloadModel() also UnloadMaterial()?
---
 src/models.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'src/models.c')

diff --git a/src/models.c b/src/models.c
index 1f37e345..02e69c0c 100644
--- a/src/models.c
+++ b/src/models.c
@@ -1671,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); 
     }
 }
 
-- 
cgit v1.2.3


From 077bef42861644f1f25070d23363a1bfa2e7a4a6 Mon Sep 17 00:00:00 2001
From: Ray <raysan5@gmail.com>
Date: Sat, 24 Feb 2018 12:31:32 +0100
Subject: Support 4 components mesh.tangent data

Added struct Vector4 for convenience
---
 src/models.c | 23 ++++++++++++++---------
 src/raylib.h | 10 +++++++++-
 src/rlgl.c   | 14 +++++++-------
 src/rlgl.h   |  2 +-
 4 files changed, 31 insertions(+), 18 deletions(-)

(limited to 'src/models.c')

diff --git a/src/models.c b/src/models.c
index 02e69c0c..f3a168c9 100644
--- a/src/models.c
+++ b/src/models.c
@@ -2329,12 +2329,12 @@ static Mesh LoadOBJ(const char *fileName)
     else
     {
         // Attempt to calculate mesh tangents and binormals using positions and texture coordinates
-        mesh.tangents = (float *)malloc(mesh.vertexCount*3*sizeof(float));
+        mesh.tangents = (float *)malloc(mesh.vertexCount*4*sizeof(float));
         // mesh.binormals = (float *)malloc(mesh.vertexCount*3*sizeof(float));
 
         int vCount = 0;
         int uvCount = 0;
-        while (vCount < mesh.vertexCount*3)
+        while (vCount < mesh.vertexCount*4)
         {
             // Calculate mesh vertex positions as Vector3
             Vector3 v0 = { mesh.vertices[vCount], mesh.vertices[vCount + 1], mesh.vertices[vCount + 2] };
@@ -2363,17 +2363,22 @@ static Mesh LoadOBJ(const char *fileName)
             // Calculate vertex tangent
             Vector3 tangent = Vector3Subtract(t1, t2);
             Vector3Scale(&tangent, r);
+            
+            // TODO: Calculate tangent 4th component
 
             // 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;
+            mesh.tangents[vCount + 3] = 0.0f;
+            mesh.tangents[vCount + 4] = tangent.x;
+            mesh.tangents[vCount + 5] = tangent.y;
+            mesh.tangents[vCount + 6] = tangent.z;
+            mesh.tangents[vCount + 7] = 0.0f;
+            mesh.tangents[vCount + 8] = tangent.x;
+            mesh.tangents[vCount + 9] = tangent.y;
+            mesh.tangents[vCount + 10] = tangent.z;
+            mesh.tangents[vCount + 11] = 0.0f;
 
             // TODO: add binormals to mesh struct and assign buffers id and locations properly
             /* // Calculate vertex binormal
@@ -2392,7 +2397,7 @@ static Mesh LoadOBJ(const char *fileName)
             mesh.binormals[vCount + 8] = binormal.z; */
 
             // Update vertex position and texture coordinates counters
-            vCount += 9;
+            vCount += 12;
             uvCount += 6;
         }
     }
diff --git a/src/raylib.h b/src/raylib.h
index 782dd4e5..41755dc3 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -322,6 +322,14 @@ typedef struct Vector3 {
     float z;
 } Vector3;
 
+// Vector4 type
+typedef struct Vector4 {
+    float x;
+    float y;
+    float z;
+    float w;
+} Vector4;
+
 // Matrix type (OpenGL style 4x4 - right handed, column major)
 typedef struct Matrix {
     float m0, m4, m8, m12;
@@ -422,7 +430,7 @@ typedef struct Mesh {
     float *texcoords;       // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
     float *texcoords2;      // Vertex second texture coordinates (useful for lightmaps) (shader-location = 5)
     float *normals;         // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
-    float *tangents;        // Vertex tangents (XYZ - 3 components per vertex) (shader-location = 4)
+    float *tangents;        // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
     unsigned char *colors;  // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
     unsigned short *indices;// Vertex indices (in case vertex data comes indexed)
 
diff --git a/src/rlgl.c b/src/rlgl.c
index 2cb9d54e..46e0668d 100644
--- a/src/rlgl.c
+++ b/src/rlgl.c
@@ -1782,14 +1782,14 @@ void rlLoadMesh(Mesh *mesh, bool dynamic)
     {
         glGenBuffers(1, &mesh->vboId[4]);
         glBindBuffer(GL_ARRAY_BUFFER, mesh->vboId[4]);
-        glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*mesh->vertexCount, mesh->tangents, drawHint);
-        glVertexAttribPointer(4, 3, GL_FLOAT, 0, 0, 0);
+        glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*mesh->vertexCount, mesh->tangents, drawHint);
+        glVertexAttribPointer(4, 4, GL_FLOAT, 0, 0, 0);
         glEnableVertexAttribArray(4);
     }
     else
     {
         // Default tangents vertex attribute
-        glVertexAttrib3f(4, 0.0f, 0.0f, 0.0f);
+        glVertexAttrib4f(4, 0.0f, 0.0f, 0.0f, 0.0f);
         glDisableVertexAttribArray(4);
     }
 
@@ -1804,7 +1804,7 @@ void rlLoadMesh(Mesh *mesh, bool dynamic)
     }
     else
     {
-        // Default tangents vertex attribute
+        // Default texcoord2 vertex attribute
         glVertexAttrib2f(5, 0.0f, 0.0f);
         glDisableVertexAttribArray(5);
     }
@@ -1868,8 +1868,8 @@ void rlUpdateMesh(Mesh mesh, int buffer, int numVertex)
         case 4:     // Update tangents (vertex tangents)
         {
             glBindBuffer(GL_ARRAY_BUFFER, mesh.vboId[4]);
-            if (numVertex >= mesh.vertexCount) glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*numVertex, mesh.tangents, GL_DYNAMIC_DRAW);
-            else glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*3*numVertex, mesh.tangents);
+            if (numVertex >= mesh.vertexCount) glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*numVertex, mesh.tangents, GL_DYNAMIC_DRAW);
+            else glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*4*numVertex, mesh.tangents);
         } break;
         case 5:     // Update texcoords2 (vertex second texture coordinates)
         {
@@ -2019,7 +2019,7 @@ void rlDrawMesh(Mesh mesh, Material material, Matrix transform)
         if (material.shader.locs[LOC_VERTEX_TANGENT] != -1)
         {
             glBindBuffer(GL_ARRAY_BUFFER, mesh.vboId[4]);
-            glVertexAttribPointer(material.shader.locs[LOC_VERTEX_TANGENT], 3, GL_FLOAT, 0, 0, 0);
+            glVertexAttribPointer(material.shader.locs[LOC_VERTEX_TANGENT], 4, GL_FLOAT, 0, 0, 0);
             glEnableVertexAttribArray(material.shader.locs[LOC_VERTEX_TANGENT]);
         }
 
diff --git a/src/rlgl.h b/src/rlgl.h
index 68d8d4eb..94331389 100644
--- a/src/rlgl.h
+++ b/src/rlgl.h
@@ -187,7 +187,7 @@ typedef unsigned char byte;
         float *texcoords;       // vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
         float *texcoords2;      // vertex second texture coordinates (useful for lightmaps) (shader-location = 5)
         float *normals;         // vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
-        float *tangents;        // vertex tangents (XYZ - 3 components per vertex) (shader-location = 4)
+        float *tangents;        // vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
         unsigned char *colors;  // vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
         unsigned short *indices;// vertex indices (in case vertex data comes indexed)
 
-- 
cgit v1.2.3


From a7207dc6d4bc4fa7deb21bb090d4d6692e86fdf3 Mon Sep 17 00:00:00 2001
From: Ray <raysan5@gmail.com>
Date: Mon, 26 Feb 2018 12:02:05 +0100
Subject: Removed tangents generation

It has no sense to be inside LoadOBJ(), mesh processing moved to own functions: MeshTangents() and MeshBinormals(). Not exposed to user yet.
---
 src/models.c | 90 ++++++++----------------------------------------------------
 1 file changed, 12 insertions(+), 78 deletions(-)

(limited to 'src/models.c')

diff --git a/src/models.c b/src/models.c
index f3a168c9..63d227e3 100644
--- a/src/models.c
+++ b/src/models.c
@@ -2083,6 +2083,18 @@ BoundingBox CalculateBoundingBox(Mesh mesh)
     return box;
 }
 
+// Compute provided mesh tangents 
+void MeshTangents(Mesh *mesh)
+{
+    // TODO: Calculate mesh tangents
+}
+
+// Compute provided mesh binormals
+void MeshBinormals(Mesh *mesh)
+{
+    // TODO: Calculate mesh binormals
+}
+
 //----------------------------------------------------------------------------------
 // Module specific Functions Definition
 //----------------------------------------------------------------------------------
@@ -2324,84 +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*4*sizeof(float));
-        // mesh.binormals = (float *)malloc(mesh.vertexCount*3*sizeof(float));
-
-        int vCount = 0;
-        int uvCount = 0;
-        while (vCount < mesh.vertexCount*4)
-        {
-            // 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);
-            
-            // TODO: Calculate tangent 4th component
-
-            // 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] = 0.0f;
-            mesh.tangents[vCount + 4] = tangent.x;
-            mesh.tangents[vCount + 5] = tangent.y;
-            mesh.tangents[vCount + 6] = tangent.z;
-            mesh.tangents[vCount + 7] = 0.0f;
-            mesh.tangents[vCount + 8] = tangent.x;
-            mesh.tangents[vCount + 9] = tangent.y;
-            mesh.tangents[vCount + 10] = tangent.z;
-            mesh.tangents[vCount + 11] = 0.0f;
-
-            // 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 += 12;
-            uvCount += 6;
-        }
-    }
-
     // Now we can free temp mid* arrays
     free(midVertices);
     free(midNormals);
-- 
cgit v1.2.3


From fd2adbe62ded6cb91ae7684331381afe0675df69 Mon Sep 17 00:00:00 2001
From: Ray <raysan5@gmail.com>
Date: Mon, 26 Feb 2018 12:10:45 +0100
Subject: Renamed CalculateBoundingBox() to MeshBoundingBox()

Renamed function for consistency with a possible Mesh manipulation functions (maybe added in a future). Naming follows Image*() manipulation functions.
---
 examples/models/models_mesh_picking.c |  2 +-
 src/models.c                          | 12 ++++++------
 src/raylib.h                          |  6 +++++-
 3 files changed, 12 insertions(+), 8 deletions(-)

(limited to 'src/models.c')

diff --git a/examples/models/models_mesh_picking.c b/examples/models/models_mesh_picking.c
index e150fe92..1cc38b45 100644
--- a/examples/models/models_mesh_picking.c
+++ b/examples/models/models_mesh_picking.c
@@ -38,7 +38,7 @@ int main()
     tower.material.maps[MAP_DIFFUSE].texture = texture;         // Set model diffuse texture
     
     Vector3 towerPos = { 0.0f, 0.0f, 0.0f };                    // Set model position
-    BoundingBox towerBBox = CalculateBoundingBox(tower.mesh);    
+    BoundingBox towerBBox = MeshBoundingBox(tower.mesh);        // Get mesh bounding box
     bool hitMeshBBox = false;
     bool hitTriangle = false;
 
diff --git a/src/models.c b/src/models.c
index 63d227e3..8e9a6586 100644
--- a/src/models.c
+++ b/src/models.c
@@ -2055,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 };
@@ -2083,16 +2083,16 @@ BoundingBox CalculateBoundingBox(Mesh mesh)
     return box;
 }
 
-// Compute provided mesh tangents 
+// Compute mesh tangents 
 void MeshTangents(Mesh *mesh)
 {
-    // TODO: Calculate mesh tangents
+    // TODO: Compute mesh tangents
 }
 
-// Compute provided mesh binormals
+// Compute mesh binormals
 void MeshBinormals(Mesh *mesh)
 {
-    // TODO: Calculate mesh binormals
+    // TODO: Compute mesh binormals
 }
 
 //----------------------------------------------------------------------------------
diff --git a/src/raylib.h b/src/raylib.h
index 41755dc3..c1d383fd 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -1006,6 +1006,11 @@ RLAPI void UnloadModel(Model model);
 RLAPI Mesh LoadMesh(const char *fileName);                                                              // Load mesh from file
 RLAPI void UnloadMesh(Mesh *mesh);                                                                      // Unload mesh from memory (RAM and/or VRAM)
 
+// Mesh manipulation functions
+RLAPI BoundingBox MeshBoundingBox(Mesh mesh);                                                           // Compute mesh bounding box limits
+RLAPI void MeshTangents(Mesh *mesh);                                                                    // Compute mesh tangents 
+RLAPI void MeshBinormals(Mesh *mesh);                                                                   // Compute mesh binormals
+
 // Mesh generation functions
 RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ);                                 // Generate plane mesh (with subdivisions)
 RLAPI Mesh GenMeshCube(float width, float height, float length);                                        // Generate cuboid mesh
@@ -1035,7 +1040,6 @@ RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRe
                             Vector3 center, float size, Color tint);                                    // Draw a billboard texture defined by sourceRec
 
 // Collision detection functions
-RLAPI BoundingBox CalculateBoundingBox(Mesh mesh);                                                      // Calculate mesh bounding box limits
 RLAPI bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB);       // Detect collision between two spheres
 RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2);                                     // Detect collision between two bounding boxes
 RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 centerSphere, float radiusSphere);          // Detect collision between box and sphere
-- 
cgit v1.2.3