Merge remote-tracking branch 'refs/remotes/raysan5/develop' into newaudio

4 files changed, 125 insertions, 146 deletions

diff --git a/src/raylib.h b/src/raylib.h
index 05c945f7..ea9fbfcb 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -376,7 +376,7 @@ typedef struct Mesh {
     float *tangents;            // vertex tangents (XYZ - 3 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)
-    int triangleCount;         // number of triangles to draw
+    int triangleCount;          // number of triangles stored (indexed or not)
     
     BoundingBox bounds;         // mesh limits defined by min and max points
     
diff --git a/src/raymath.h b/src/raymath.h
index 52e92b50..59d66e56 100644
--- a/src/raymath.h
+++ b/src/raymath.h
@@ -158,6 +158,7 @@ RMDEF void PrintMatrix(Matrix m);                             // Print matrix ut
 //------------------------------------------------------------------------------------
 RMDEF float QuaternionLength(Quaternion quat);                // Compute the length of a quaternion
 RMDEF void QuaternionNormalize(Quaternion *q);                // Normalize provided quaternion
+RMDEF void QuaternionInvert(Quaternion *quat);                // Invert provided quaternion
 RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2);    // Calculate two quaternion multiplication
 RMDEF Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float slerp); // Calculates spherical linear interpolation between two quaternions
 RMDEF Quaternion QuaternionFromMatrix(Matrix matrix);                 // Returns a quaternion for a given rotation matrix
@@ -908,6 +909,23 @@ RMDEF void QuaternionNormalize(Quaternion *q)
     q->w *= ilength;
 }
 
+// Invert provided quaternion
+RMDEF void QuaternionInvert(Quaternion *quat)
+{
+    float length = QuaternionLength(*quat);
+    float lengthSq = length*length;
+    
+    if (lengthSq != 0.0)
+    {
+        float i = 1.0f/lengthSq;
+        
+        quat->x *= -i;
+        quat->y *= -i;
+        quat->z *= -i;
+        quat->w *= i;
+    }
+}
+
 // Calculate two quaternion multiplication
 RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2)
 {
diff --git a/src/rlgl.c b/src/rlgl.c
index 3c0d9e79..0c0da221 100644
--- a/src/rlgl.c
+++ b/src/rlgl.c
@@ -128,54 +128,23 @@
 // Types and Structures Definition
 //----------------------------------------------------------------------------------
 
-// Vertex buffer (position + color arrays)
-// NOTE: Used for lines and triangles VAOs
+// Dynamic vertex buffers (position + texcoords + colors + indices arrays)
 typedef struct {
-    int vCounter;
-    int cCounter;
-    float *vertices;            // 3 components per vertex
-    unsigned char *colors;      // 4 components per vertex
-} VertexPositionColorBuffer;
-
-// Vertex buffer (position + texcoords + color arrays)
-// NOTE: Not used
-typedef struct {
-    int vCounter;
-    int tcCounter;
-    int cCounter;
-    float *vertices;            // 3 components per vertex
-    float *texcoords;           // 2 components per vertex
-    unsigned char *colors;      // 4 components per vertex
-} VertexPositionColorTextureBuffer;
-
-// Vertex buffer (position + texcoords + normals arrays)
-// NOTE: Not used
-typedef struct {
-    int vCounter;
-    int tcCounter;
-    int nCounter;
-    float *vertices;            // 3 components per vertex
-    float *texcoords;           // 2 components per vertex
-    float *normals;             // 3 components per vertex
-    //short *normals;           // NOTE: Less data load... but padding issues and normalizing required!
-} VertexPositionTextureNormalBuffer;
-
-// Vertex buffer (position + texcoords + colors + indices arrays)
-// NOTE: Used for quads VAO
-typedef struct {
-    int vCounter;
-    int tcCounter;
-    int cCounter;
-    float *vertices;            // 3 components per vertex
-    float *texcoords;           // 2 components per vertex
-    unsigned char *colors;      // 4 components per vertex
+    int vCounter;               // vertex position counter to process (and draw) from full buffer
+    int tcCounter;              // vertex texcoord counter to process (and draw) from full buffer
+    int cCounter;               // vertex color counter to process (and draw) from full buffer
+    float *vertices;            // vertex position (XYZ - 3 components per vertex) (shader-location = 0)
+    float *texcoords;           // vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
+    unsigned char *colors;      // vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
-    unsigned int *indices;      // 6 indices per quad (could be int)
+    unsigned int *indices;      // vertex indices (in case vertex data comes indexed) (6 indices per quad)
 #elif defined(GRAPHICS_API_OPENGL_ES2)
-    unsigned short *indices;    // 6 indices per quad (must be short)
+    unsigned short *indices;    // vertex indices (in case vertex data comes indexed) (6 indices per quad)
                                 // NOTE: 6*2 byte = 12 byte, not alignment problem!
 #endif
-} VertexPositionColorTextureIndexBuffer;
+    unsigned int vaoId;         // OpenGL Vertex Array Object id
+    unsigned int vboId[4];      // OpenGL Vertex Buffer Objects id (4 types of vertex data)
+} DynamicBuffer;
 
 // Draw call type
 // NOTE: Used to track required draw-calls, organized by texture
@@ -205,18 +174,9 @@ static DrawMode currentDrawMode;
 
 static float currentDepth = -1.0f;
 
-// Default vertex buffers for lines, triangles and quads
-static VertexPositionColorBuffer lines;         // No texture support
-static VertexPositionColorBuffer triangles;     // No texture support
-static VertexPositionColorTextureIndexBuffer quads;
-
-// Default vertex buffers VAOs (if supported)
-static GLuint vaoLines, vaoTriangles, vaoQuads;
-
-// Default vertex buffers VBOs
-static GLuint linesBuffer[2];           // Lines buffers (position, color)
-static GLuint trianglesBuffer[2];       // Triangles buffers (position, color)
-static GLuint quadsBuffer[4];           // Quads buffers (position, texcoord, color, index)
+static DynamicBuffer lines;
+static DynamicBuffer triangles;
+static DynamicBuffer quads;
 
 // Default buffers draw calls
 static DrawCall *draws;
@@ -1207,7 +1167,7 @@ void rlglDrawEx(Mesh mesh, Material material, Matrix transform, bool wires)
             glEnableVertexAttribArray(material.shader.texcoord2Loc);
         }
         
-        if (mesh.indices != NULL) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, quadsBuffer[3]);
+        if (mesh.indices != NULL) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, quads.vboId[3]);
     }
 
     // Draw call!
@@ -1692,7 +1652,6 @@ void rlglLoadMesh(Mesh *mesh)
     mesh->vboId[4] = 0;     // Vertex tangents VBO
     mesh->vboId[5] = 0;     // Vertex texcoords2 VBO
     mesh->vboId[6] = 0;     // Vertex indices VBO
-    
 
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
     GLuint vaoId = 0;       // Vertex Array Objects (VAO)
@@ -2407,22 +2366,28 @@ static void LoadDefaultBuffers(void)
     // Lines - Initialize arrays (vertex position and color data)
     lines.vertices = (float *)malloc(sizeof(float)*3*2*MAX_LINES_BATCH);        // 3 float by vertex, 2 vertex by line
     lines.colors = (unsigned char *)malloc(sizeof(unsigned char)*4*2*MAX_LINES_BATCH);  // 4 float by color, 2 colors by line
+    lines.texcoords = NULL;
+    lines.indices = NULL;
 
     for (int i = 0; i < (3*2*MAX_LINES_BATCH); i++) lines.vertices[i] = 0.0f;
     for (int i = 0; i < (4*2*MAX_LINES_BATCH); i++) lines.colors[i] = 0;
 
     lines.vCounter = 0;
     lines.cCounter = 0;
+    lines.tcCounter = 0;
 
     // Triangles - Initialize arrays (vertex position and color data)
     triangles.vertices = (float *)malloc(sizeof(float)*3*3*MAX_TRIANGLES_BATCH);        // 3 float by vertex, 3 vertex by triangle
     triangles.colors = (unsigned char *)malloc(sizeof(unsigned char)*4*3*MAX_TRIANGLES_BATCH);  // 4 float by color, 3 colors by triangle
+    triangles.texcoords = NULL;
+    triangles.indices = NULL;
 
     for (int i = 0; i < (3*3*MAX_TRIANGLES_BATCH); i++) triangles.vertices[i] = 0.0f;
     for (int i = 0; i < (4*3*MAX_TRIANGLES_BATCH); i++) triangles.colors[i] = 0;
 
     triangles.vCounter = 0;
     triangles.cCounter = 0;
+    triangles.tcCounter = 0;
 
     // Quads - Initialize arrays (vertex position, texcoord, color data and indexes)
     quads.vertices = (float *)malloc(sizeof(float)*3*4*MAX_QUADS_BATCH);        // 3 float by vertex, 4 vertex by quad
@@ -2468,96 +2433,95 @@ static void LoadDefaultBuffers(void)
     if (vaoSupported)
     {
         // Initialize Lines VAO
-        glGenVertexArrays(1, &vaoLines);
-        glBindVertexArray(vaoLines);
+        glGenVertexArrays(1, &lines.vaoId);
+        glBindVertexArray(lines.vaoId);
     }
 
-    // Create buffers for our vertex data
-    glGenBuffers(2, linesBuffer);
-
     // Lines - Vertex buffers binding and attributes enable 
     // Vertex position buffer (shader-location = 0)
-    glBindBuffer(GL_ARRAY_BUFFER, linesBuffer[0]);
+    glGenBuffers(2, &lines.vboId[0]);
+    glBindBuffer(GL_ARRAY_BUFFER, lines.vboId[0]);
     glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*2*MAX_LINES_BATCH, lines.vertices, GL_DYNAMIC_DRAW);
     glEnableVertexAttribArray(currentShader.vertexLoc);
     glVertexAttribPointer(currentShader.vertexLoc, 3, GL_FLOAT, 0, 0, 0);
 
     // Vertex color buffer (shader-location = 3)
-    glBindBuffer(GL_ARRAY_BUFFER, linesBuffer[1]);
+    glGenBuffers(2, &lines.vboId[1]);
+    glBindBuffer(GL_ARRAY_BUFFER, lines.vboId[1]);
     glBufferData(GL_ARRAY_BUFFER, sizeof(unsigned char)*4*2*MAX_LINES_BATCH, lines.colors, GL_DYNAMIC_DRAW);
     glEnableVertexAttribArray(currentShader.colorLoc);
     glVertexAttribPointer(currentShader.colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
 
-    if (vaoSupported) TraceLog(INFO, "[VAO ID %i] Default buffers VAO initialized successfully (lines)", vaoLines);
-    else TraceLog(INFO, "[VBO ID %i][VBO ID %i] Default buffers VBOs initialized successfully (lines)", linesBuffer[0], linesBuffer[1]);
+    if (vaoSupported) TraceLog(INFO, "[VAO ID %i] Default buffers VAO initialized successfully (lines)", lines.vaoId);
+    else TraceLog(INFO, "[VBO ID %i][VBO ID %i] Default buffers VBOs initialized successfully (lines)", lines.vboId[0], lines.vboId[1]);
 
     // Upload and link triangles vertex buffers
     if (vaoSupported)
     {
         // Initialize Triangles VAO
-        glGenVertexArrays(1, &vaoTriangles);
-        glBindVertexArray(vaoTriangles);
+        glGenVertexArrays(1, &triangles.vaoId);
+        glBindVertexArray(triangles.vaoId);
     }
 
-    // Create buffers for our vertex data
-    glGenBuffers(2, trianglesBuffer);
-
     // Triangles - Vertex buffers binding and attributes enable 
     // Vertex position buffer (shader-location = 0)
-    glBindBuffer(GL_ARRAY_BUFFER, trianglesBuffer[0]);
+    glGenBuffers(1, &triangles.vboId[0]);
+    glBindBuffer(GL_ARRAY_BUFFER, triangles.vboId[0]);
     glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*3*MAX_TRIANGLES_BATCH, triangles.vertices, GL_DYNAMIC_DRAW);
     glEnableVertexAttribArray(currentShader.vertexLoc);
     glVertexAttribPointer(currentShader.vertexLoc, 3, GL_FLOAT, 0, 0, 0);
 
     // Vertex color buffer (shader-location = 3)
-    glBindBuffer(GL_ARRAY_BUFFER, trianglesBuffer[1]);
+    glGenBuffers(1, &triangles.vboId[1]);
+    glBindBuffer(GL_ARRAY_BUFFER, triangles.vboId[1]);
     glBufferData(GL_ARRAY_BUFFER, sizeof(unsigned char)*4*3*MAX_TRIANGLES_BATCH, triangles.colors, GL_DYNAMIC_DRAW);
     glEnableVertexAttribArray(currentShader.colorLoc);
     glVertexAttribPointer(currentShader.colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
 
-    if (vaoSupported) TraceLog(INFO, "[VAO ID %i] Default buffers VAO initialized successfully (triangles)", vaoTriangles);
-    else TraceLog(INFO, "[VBO ID %i][VBO ID %i] Default buffers VBOs initialized successfully(triangles)", trianglesBuffer[0], trianglesBuffer[1]);
+    if (vaoSupported) TraceLog(INFO, "[VAO ID %i] Default buffers VAO initialized successfully (triangles)", triangles.vaoId);
+    else TraceLog(INFO, "[VBO ID %i][VBO ID %i] Default buffers VBOs initialized successfully(triangles)", triangles.vboId[0], triangles.vboId[1]);
 
     // Upload and link quads vertex buffers
     if (vaoSupported)
     {
         // Initialize Quads VAO
-        glGenVertexArrays(1, &vaoQuads);
-        glBindVertexArray(vaoQuads);
+        glGenVertexArrays(1, &quads.vaoId);
+        glBindVertexArray(quads.vaoId);
     }
 
-    // Create buffers for our vertex data
-    glGenBuffers(4, quadsBuffer);
-
     // Quads - Vertex buffers binding and attributes enable 
     // Vertex position buffer (shader-location = 0)
-    glBindBuffer(GL_ARRAY_BUFFER, quadsBuffer[0]);
+    glGenBuffers(1, &quads.vboId[0]);
+    glBindBuffer(GL_ARRAY_BUFFER, quads.vboId[0]);
     glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*MAX_QUADS_BATCH, quads.vertices, GL_DYNAMIC_DRAW);
     glEnableVertexAttribArray(currentShader.vertexLoc);
     glVertexAttribPointer(currentShader.vertexLoc, 3, GL_FLOAT, 0, 0, 0);
 
     // Vertex texcoord buffer (shader-location = 1)
-    glBindBuffer(GL_ARRAY_BUFFER, quadsBuffer[1]);
+    glGenBuffers(1, &quads.vboId[1]);
+    glBindBuffer(GL_ARRAY_BUFFER, quads.vboId[1]);
     glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*4*MAX_QUADS_BATCH, quads.texcoords, GL_DYNAMIC_DRAW);
     glEnableVertexAttribArray(currentShader.texcoordLoc);
     glVertexAttribPointer(currentShader.texcoordLoc, 2, GL_FLOAT, 0, 0, 0);
 
     // Vertex color buffer (shader-location = 3)
-    glBindBuffer(GL_ARRAY_BUFFER, quadsBuffer[2]);
+    glGenBuffers(1, &quads.vboId[2]);
+    glBindBuffer(GL_ARRAY_BUFFER, quads.vboId[2]);
     glBufferData(GL_ARRAY_BUFFER, sizeof(unsigned char)*4*4*MAX_QUADS_BATCH, quads.colors, GL_DYNAMIC_DRAW);
     glEnableVertexAttribArray(currentShader.colorLoc);
     glVertexAttribPointer(currentShader.colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
 
     // Fill index buffer
-    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, quadsBuffer[3]);
+    glGenBuffers(1, &quads.vboId[3]);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, quads.vboId[3]);
 #if defined(GRAPHICS_API_OPENGL_33)
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int)*6*MAX_QUADS_BATCH, quads.indices, GL_STATIC_DRAW);
 #elif defined(GRAPHICS_API_OPENGL_ES2)
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(short)*6*MAX_QUADS_BATCH, quads.indices, GL_STATIC_DRAW);
 #endif
 
-    if (vaoSupported) TraceLog(INFO, "[VAO ID %i] Default buffers VAO initialized successfully (quads)", vaoQuads);
-    else TraceLog(INFO, "[VBO ID %i][VBO ID %i][VBO ID %i][VBO ID %i] Default buffers VBOs initialized successfully (quads)", quadsBuffer[0], quadsBuffer[1], quadsBuffer[2], quadsBuffer[3]);
+    if (vaoSupported) TraceLog(INFO, "[VAO ID %i] Default buffers VAO initialized successfully (quads)", quads.vaoId);
+    else TraceLog(INFO, "[VBO ID %i][VBO ID %i][VBO ID %i][VBO ID %i] Default buffers VBOs initialized successfully (quads)", quads.vboId[0], quads.vboId[1], quads.vboId[2], quads.vboId[3]);
 
     // Unbind the current VAO
     if (vaoSupported) glBindVertexArray(0);
@@ -2573,15 +2537,15 @@ static void UpdateDefaultBuffers(void)
     if (lines.vCounter > 0)
     {
         // Activate Lines VAO
-        if (vaoSupported) glBindVertexArray(vaoLines);
+        if (vaoSupported) glBindVertexArray(lines.vaoId);
 
         // Lines - vertex positions buffer
-        glBindBuffer(GL_ARRAY_BUFFER, linesBuffer[0]);
+        glBindBuffer(GL_ARRAY_BUFFER, lines.vboId[0]);
         //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*2*MAX_LINES_BATCH, lines.vertices, GL_DYNAMIC_DRAW);
         glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*3*lines.vCounter, lines.vertices);    // target - offset (in bytes) - size (in bytes) - data pointer
 
         // Lines - colors buffer
-        glBindBuffer(GL_ARRAY_BUFFER, linesBuffer[1]);
+        glBindBuffer(GL_ARRAY_BUFFER, lines.vboId[1]);
         //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*2*MAX_LINES_BATCH, lines.colors, GL_DYNAMIC_DRAW);
         glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(unsigned char)*4*lines.cCounter, lines.colors);
     }
@@ -2590,15 +2554,15 @@ static void UpdateDefaultBuffers(void)
     if (triangles.vCounter > 0)
     {
         // Activate Triangles VAO
-        if (vaoSupported) glBindVertexArray(vaoTriangles);
+        if (vaoSupported) glBindVertexArray(triangles.vaoId);
 
         // Triangles - vertex positions buffer
-        glBindBuffer(GL_ARRAY_BUFFER, trianglesBuffer[0]);
+        glBindBuffer(GL_ARRAY_BUFFER, triangles.vboId[0]);
         //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*3*MAX_TRIANGLES_BATCH, triangles.vertices, GL_DYNAMIC_DRAW);
         glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*3*triangles.vCounter, triangles.vertices);
 
         // Triangles - colors buffer
-        glBindBuffer(GL_ARRAY_BUFFER, trianglesBuffer[1]);
+        glBindBuffer(GL_ARRAY_BUFFER, triangles.vboId[1]);
         //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*3*MAX_TRIANGLES_BATCH, triangles.colors, GL_DYNAMIC_DRAW);
         glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(unsigned char)*4*triangles.cCounter, triangles.colors);
     }
@@ -2607,20 +2571,20 @@ static void UpdateDefaultBuffers(void)
     if (quads.vCounter > 0)
     {
         // Activate Quads VAO
-        if (vaoSupported) glBindVertexArray(vaoQuads);
+        if (vaoSupported) glBindVertexArray(quads.vaoId);
 
         // Quads - vertex positions buffer
-        glBindBuffer(GL_ARRAY_BUFFER, quadsBuffer[0]);
+        glBindBuffer(GL_ARRAY_BUFFER, quads.vboId[0]);
         //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*MAX_QUADS_BATCH, quads.vertices, GL_DYNAMIC_DRAW);
         glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*3*quads.vCounter, quads.vertices);
 
         // Quads - texture coordinates buffer
-        glBindBuffer(GL_ARRAY_BUFFER, quadsBuffer[1]);
+        glBindBuffer(GL_ARRAY_BUFFER, quads.vboId[1]);
         //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*4*MAX_QUADS_BATCH, quads.texcoords, GL_DYNAMIC_DRAW);
         glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float)*2*quads.vCounter, quads.texcoords);
 
         // Quads - colors buffer
-        glBindBuffer(GL_ARRAY_BUFFER, quadsBuffer[2]);
+        glBindBuffer(GL_ARRAY_BUFFER, quads.vboId[2]);
         //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*MAX_QUADS_BATCH, quads.colors, GL_DYNAMIC_DRAW);
         glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(unsigned char)*4*quads.vCounter, quads.colors);
 
@@ -2659,17 +2623,17 @@ static void DrawDefaultBuffers(void)
 
         if (vaoSupported)
         {
-            glBindVertexArray(vaoLines);
+            glBindVertexArray(lines.vaoId);
         }
         else
         {
             // Bind vertex attrib: position (shader-location = 0)
-            glBindBuffer(GL_ARRAY_BUFFER, linesBuffer[0]);
+            glBindBuffer(GL_ARRAY_BUFFER, lines.vboId[0]);
             glVertexAttribPointer(currentShader.vertexLoc, 3, GL_FLOAT, 0, 0, 0);
             glEnableVertexAttribArray(currentShader.vertexLoc);
 
             // Bind vertex attrib: color (shader-location = 3)
-            glBindBuffer(GL_ARRAY_BUFFER, linesBuffer[1]);
+            glBindBuffer(GL_ARRAY_BUFFER, lines.vboId[1]);
             glVertexAttribPointer(currentShader.colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
             glEnableVertexAttribArray(currentShader.colorLoc);
         }
@@ -2687,17 +2651,17 @@ static void DrawDefaultBuffers(void)
 
         if (vaoSupported)
         {
-            glBindVertexArray(vaoTriangles);
+            glBindVertexArray(triangles.vaoId);
         }
         else
         {
             // Bind vertex attrib: position (shader-location = 0)
-            glBindBuffer(GL_ARRAY_BUFFER, trianglesBuffer[0]);
+            glBindBuffer(GL_ARRAY_BUFFER, triangles.vboId[0]);
             glVertexAttribPointer(currentShader.vertexLoc, 3, GL_FLOAT, 0, 0, 0);
             glEnableVertexAttribArray(currentShader.vertexLoc);
 
             // Bind vertex attrib: color (shader-location = 3)
-            glBindBuffer(GL_ARRAY_BUFFER, trianglesBuffer[1]);
+            glBindBuffer(GL_ARRAY_BUFFER, triangles.vboId[1]);
             glVertexAttribPointer(currentShader.colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
             glEnableVertexAttribArray(currentShader.colorLoc);
         }
@@ -2717,26 +2681,26 @@ static void DrawDefaultBuffers(void)
 
         if (vaoSupported)
         {
-            glBindVertexArray(vaoQuads);
+            glBindVertexArray(quads.vaoId);
         }
         else
         {
             // Bind vertex attrib: position (shader-location = 0)
-            glBindBuffer(GL_ARRAY_BUFFER, quadsBuffer[0]);
+            glBindBuffer(GL_ARRAY_BUFFER, quads.vboId[0]);
             glVertexAttribPointer(currentShader.vertexLoc, 3, GL_FLOAT, 0, 0, 0);
             glEnableVertexAttribArray(currentShader.vertexLoc);
 
             // Bind vertex attrib: texcoord (shader-location = 1)
-            glBindBuffer(GL_ARRAY_BUFFER, quadsBuffer[1]);
+            glBindBuffer(GL_ARRAY_BUFFER, quads.vboId[1]);
             glVertexAttribPointer(currentShader.texcoordLoc, 2, GL_FLOAT, 0, 0, 0);
             glEnableVertexAttribArray(currentShader.texcoordLoc);
 
             // Bind vertex attrib: color (shader-location = 3)
-            glBindBuffer(GL_ARRAY_BUFFER, quadsBuffer[2]);
+            glBindBuffer(GL_ARRAY_BUFFER, quads.vboId[2]);
             glVertexAttribPointer(currentShader.colorLoc, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
             glEnableVertexAttribArray(currentShader.colorLoc);
             
-            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, quadsBuffer[3]);
+            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, quads.vboId[3]);
         }
 
         //TraceLog(DEBUG, "Draws required per frame: %i", drawsCounter);
@@ -2806,21 +2770,21 @@ static void UnloadDefaultBuffers(void)
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
     // Delete VBOs from GPU (VRAM)
-    glDeleteBuffers(1, &linesBuffer[0]);
-    glDeleteBuffers(1, &linesBuffer[1]);
-    glDeleteBuffers(1, &trianglesBuffer[0]);
-    glDeleteBuffers(1, &trianglesBuffer[1]);
-    glDeleteBuffers(1, &quadsBuffer[0]);
-    glDeleteBuffers(1, &quadsBuffer[1]);
-    glDeleteBuffers(1, &quadsBuffer[2]);
-    glDeleteBuffers(1, &quadsBuffer[3]);
+    glDeleteBuffers(1, &lines.vboId[0]);
+    glDeleteBuffers(1, &lines.vboId[1]);
+    glDeleteBuffers(1, &triangles.vboId[0]);
+    glDeleteBuffers(1, &triangles.vboId[1]);
+    glDeleteBuffers(1, &quads.vboId[0]);
+    glDeleteBuffers(1, &quads.vboId[1]);
+    glDeleteBuffers(1, &quads.vboId[2]);
+    glDeleteBuffers(1, &quads.vboId[3]);
 
     if (vaoSupported)
     {
         // Delete VAOs from GPU (VRAM)
-        glDeleteVertexArrays(1, &vaoLines);
-        glDeleteVertexArrays(1, &vaoTriangles);
-        glDeleteVertexArrays(1, &vaoQuads);
+        glDeleteVertexArrays(1, &lines.vaoId);
+        glDeleteVertexArrays(1, &triangles.vaoId);
+        glDeleteVertexArrays(1, &quads.vaoId);
     }
 
     // Free vertex arrays memory from CPU (RAM)
diff --git a/src/rlgl.h b/src/rlgl.h
index afc2ab96..7b88bc9e 100644
--- a/src/rlgl.h
+++ b/src/rlgl.h
@@ -137,37 +137,41 @@ typedef enum { OPENGL_11 = 1, OPENGL_33, OPENGL_ES_20 } GlVersion;
         Vector3 max;
     } BoundingBox;
 
-    // Mesh with vertex data type
-    // NOTE: If using OpenGL 1.1, data loaded in CPU; if OpenGL 3.3+ data loaded in GPU (vaoId)
+    // Vertex data definning a mesh
     typedef struct Mesh {
-        int vertexCount;            // num vertices
-        float *vertices;            // vertex position (XYZ - 3 components per vertex)
-        float *texcoords;           // vertex texture coordinates (UV - 2 components per vertex)
-        float *texcoords2;          // vertex second texture coordinates (useful for lightmaps)
-        float *normals;             // vertex normals (XYZ - 3 components per vertex)
-        float *tangents;            // vertex tangents (XYZ - 3 components per vertex)
-        unsigned char *colors;      // vertex colors (RGBA - 4 components per vertex)
+        int vertexCount;            // number of vertices stored in arrays
+        float *vertices;            // vertex position (XYZ - 3 components per vertex) (shader-location = 0)
+        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)
+        unsigned char *colors;      // vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
+        unsigned short *indices;    // vertex indices (in case vertex data comes indexed)
+        int triangleCount;          // number of triangles stored (indexed or not)
         
         BoundingBox bounds;         // mesh limits defined by min and max points
         
         unsigned int vaoId;         // OpenGL Vertex Array Object id
-        unsigned int vboId[6];      // OpenGL Vertex Buffer Objects id (6 types of vertex data)
+        unsigned int vboId[7];      // OpenGL Vertex Buffer Objects id (7 types of vertex data)
     } Mesh;
 
-    // Shader type
+    // Shader type (generic shader)
     typedef struct Shader {
-        unsigned int id;                // Shader program id
-
-        // Variable attributes
-        int vertexLoc;        // Vertex attribute location point (vertex shader)
-        int texcoordLoc;      // Texcoord attribute location point (vertex shader)
-        int normalLoc;        // Normal attribute location point (vertex shader)
-        int colorLoc;         // Color attibute location point (vertex shader)
-
-        // Uniforms
+        unsigned int id;      // Shader program id
+        
+        // Vertex attributes locations (default locations)
+        int vertexLoc;        // Vertex attribute location point (default-location = 0)
+        int texcoordLoc;      // Texcoord attribute location point (default-location = 1)
+        int normalLoc;        // Normal attribute location point (default-location = 2)
+        int colorLoc;         // Color attibute location point (default-location = 3)
+        int tangentLoc;       // Tangent attribute location point (default-location = 4)
+        int texcoord2Loc;     // Texcoord2 attribute location point (default-location = 5)
+
+        // Uniform locations
         int mvpLoc;           // ModelView-Projection matrix uniform location point (vertex shader)
         int tintColorLoc;     // Color uniform location point (fragment shader)
         
+        // Texture map locations
         int mapDiffuseLoc;    // Diffuse map texture uniform location point (fragment shader)
         int mapNormalLoc;     // Normal map texture uniform location point (fragment shader)
         int mapSpecularLoc;   // Specular map texture uniform location point (fragment shader)
@@ -205,13 +209,6 @@ typedef enum { OPENGL_11 = 1, OPENGL_33, OPENGL_ES_20 } GlVersion;
         float glossiness;
         float normalDepth;
     } Material;
-
-    // 3d Model type
-    typedef struct Model {
-        Mesh mesh;
-        Matrix transform;
-        Material material;
-    } Model;
 	
     // Color blending modes (pre-defined)
     typedef enum { BLEND_ALPHA = 0, BLEND_ADDITIVE, BLEND_MULTIPLIED } BlendMode;