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

7 files changed, 342 insertions, 280 deletions

diff --git a/src/core.c b/src/core.c
index 8b61aaf7..7b7d65fc 100644
--- a/src/core.c
+++ b/src/core.c
@@ -309,8 +309,8 @@ void InitWindow(int width, int height, const char *title)
     emscripten_set_touchcancel_callback("#canvas", NULL, 1, EmscriptenInputCallback);
 #endif
 
-    mousePosition.x = screenWidth/2;
-    mousePosition.y = screenHeight/2;
+    mousePosition.x = (float)screenWidth/2.0f;
+    mousePosition.y = (float)screenHeight/2.0f;
 
     // raylib logo appearing animation (if enabled)
     if (showLogo)
@@ -577,7 +577,7 @@ void Begin3dMode(Camera camera)
 
     // Setup perspective projection
     float aspect = (float)screenWidth/(float)screenHeight;
-    double top = 0.1f*tan(45.0f*PI / 360.0f);
+    double top = 0.1f*tan(45.0f*PI/360.0f);
     double right = top*aspect;
 
     // NOTE: zNear and zFar values are important when computing depth buffer values
@@ -608,7 +608,7 @@ void End3dMode(void)
 // Set target FPS for the game
 void SetTargetFPS(int fps)
 {
-    targetTime = 1 / (double)fps;
+    targetTime = 1.0/(double)fps;
 
     TraceLog(INFO, "Target time per frame: %02.03f milliseconds", (float)targetTime*1000);
 }
@@ -625,7 +625,7 @@ float GetFrameTime(void)
     // As we are operate quite a lot with frameTime, 
     // it could be no stable, so we round it before passing it around
     // NOTE: There are still problems with high framerates (>500fps)
-    double roundedFrameTime =  round(frameTime*10000)/10000;
+    double roundedFrameTime =  round(frameTime*10000)/10000.0;
 
     return (float)roundedFrameTime;    // Time in seconds to run a frame
 }
@@ -806,8 +806,8 @@ Ray GetMouseRay(Vector2 mousePosition, Camera camera)
     
     // Calculate normalized device coordinates
     // NOTE: y value is negative
-    float x = (2.0f * mousePosition.x) / GetScreenWidth() - 1.0f;
-    float y = 1.0f - (2.0f * mousePosition.y) / GetScreenHeight();
+    float x = (2.0f*mousePosition.x)/(float)GetScreenWidth() - 1.0f;
+    float y = 1.0f - (2.0f*mousePosition.y)/(float)GetScreenHeight();
     float z = 1.0f;
     
     // Store values in a vector
@@ -880,7 +880,7 @@ Vector2 WorldToScreen(Vector3 position, Camera camera)
     Vector3 ndcPos = { worldPos.x / worldPos.w, -worldPos.y / worldPos.w, worldPos.z / worldPos.z };
     
     // Calculate 2d screen position vector
-    Vector2 screenPosition = { (ndcPos.x + 1.0f) / 2.0f * GetScreenWidth(), (ndcPos.y + 1.0f) / 2.0f * GetScreenHeight() };
+    Vector2 screenPosition = { (ndcPos.x + 1.0f)/2.0f*(float)GetScreenWidth(), (ndcPos.y + 1.0f)/2.0f*(float)GetScreenHeight() };
     
     return screenPosition;
 }
@@ -1963,7 +1963,7 @@ static void PollInputEvents(void)
 
         int key = keysBuffer[i];
 
-        if (keyboardMode == 2)
+        if (keyboardMode == 2)  // scancodes
         {
             // NOTE: If (key == 0x1b), depending on next key, it could be a special keymap code!
             // Up -> 1b 5b 41 / Left -> 1b 5b 44 / Right -> 1b 5b 43 / Down -> 1b 5b 42
@@ -1998,9 +1998,13 @@ static void PollInputEvents(void)
             // Detect ESC to stop program
             if ((key == 0x1b) && (numKeysBuffer == 1)) windowShouldClose = true;
         }
-        else if (keyboardMode == 1)
+        else if (keyboardMode == 1)     // keycodes (K_MEDIUMRAW mode)
         {
             TraceLog(DEBUG, "Pressed key (keycode): 0x%02x", key);
+            
+            // NOTE: Each key is 7-bits (high bit in the byte is 0 for down, 1 for up)
+            
+            // TODO: Review (or rewrite) this code... not clear... replace by events!
 
             int asciiKey = -1;
 
diff --git a/src/models.c b/src/models.c
index dd170e0b..06044820 100644
--- a/src/models.c
+++ b/src/models.c
@@ -56,7 +56,7 @@ extern unsigned int whiteTexture;
 // Module specific Functions Declaration
 //----------------------------------------------------------------------------------
 static float GetHeightValue(Color pixel);
-static VertexData LoadOBJ(const char *fileName);
+static Mesh LoadOBJ(const char *fileName);
 
 //----------------------------------------------------------------------------------
 // Module Functions Definition
@@ -558,23 +558,23 @@ void DrawGizmo(Vector3 position)
 Model LoadModel(const char *fileName)
 {
     Model model;
-    VertexData vData = { 0 };
+    Mesh mesh = { 0 };
     
     // NOTE: Initialize default data for model in case loading fails, maybe a cube?
 
-    if (strcmp(GetExtension(fileName),"obj") == 0) vData = LoadOBJ(fileName);
+    if (strcmp(GetExtension(fileName),"obj") == 0) mesh = LoadOBJ(fileName);
     else TraceLog(WARNING, "[%s] Model extension not recognized, it can't be loaded", fileName);
 
-    // NOTE: At this point we have all vertex, texcoord, normal data for the model in vData struct
+    // NOTE: At this point we have all vertex, texcoord, normal data for the model in mesh struct
     
-    if (vData.vertexCount == 0)
+    if (mesh.vertexCount == 0)
     {
         TraceLog(WARNING, "Model could not be loaded");
     }
     else
     {
         // NOTE: model properties (transform, texture, shader) are initialized inside rlglLoadModel()
-        model = rlglLoadModel(vData);     // Upload vertex data to GPU
+        model = rlglLoadModel(mesh);     // Upload vertex data to GPU
 
         // Now that vertex data is uploaded to GPU, we can free arrays
         // NOTE 1: We don't need CPU vertex data on OpenGL 3.3 or ES2... for static meshes...
@@ -583,10 +583,10 @@ Model LoadModel(const char *fileName)
         /*
         if (rlGetVersion() != OPENGL_11)
         {
-            free(vData.vertices);
-            free(vData.texcoords);
-            free(vData.normals);
-            free(vData.colors);
+            free(mesh.vertices);
+            free(mesh.texcoords);
+            free(mesh.normals);
+            free(mesh.colors);
         }
         */
     }
@@ -595,7 +595,7 @@ Model LoadModel(const char *fileName)
 }
 
 // Load a 3d model (from vertex data)
-Model LoadModelEx(VertexData data)
+Model LoadModelEx(Mesh data)
 {
     Model model;
 
@@ -610,7 +610,7 @@ Model LoadModelEx(VertexData data)
 // Load a heightmap image as a 3d model
 Model LoadHeightmap(Image heightmap, float maxHeight)
 {
-    VertexData vData;
+    Mesh mesh;
 
     int mapX = heightmap.width;
     int mapZ = heightmap.height;
@@ -621,12 +621,12 @@ Model LoadHeightmap(Image heightmap, float maxHeight)
     // TODO: Consider resolution when generating model data?
     int numTriangles = (mapX-1)*(mapZ-1)*2;    // One quad every four pixels
 
-    vData.vertexCount = numTriangles*3;
+    mesh.vertexCount = numTriangles*3;
 
-    vData.vertices = (float *)malloc(vData.vertexCount*3*sizeof(float));
-    vData.normals = (float *)malloc(vData.vertexCount*3*sizeof(float));
-    vData.texcoords = (float *)malloc(vData.vertexCount*2*sizeof(float));
-    vData.colors = (unsigned char *)malloc(vData.vertexCount*4*sizeof(unsigned char)); // Not used...
+    mesh.vertices = (float *)malloc(mesh.vertexCount*3*sizeof(float));
+    mesh.normals = (float *)malloc(mesh.vertexCount*3*sizeof(float));
+    mesh.texcoords = (float *)malloc(mesh.vertexCount*2*sizeof(float));
+    mesh.colors = (unsigned char *)malloc(mesh.vertexCount*4*sizeof(unsigned char)); // Not used...
 
     int vCounter = 0;       // Used to count vertices float by float
     int tcCounter = 0;      // Used to count texcoords float by float
@@ -644,51 +644,51 @@ Model LoadHeightmap(Image heightmap, float maxHeight)
             //----------------------------------------------------------
 
             // one triangle - 3 vertex
-            vData.vertices[vCounter] = x;
-            vData.vertices[vCounter + 1] = GetHeightValue(heightmapPixels[x + z*mapX])*scaleFactor;
-            vData.vertices[vCounter + 2] = z;
+            mesh.vertices[vCounter] = x;
+            mesh.vertices[vCounter + 1] = GetHeightValue(heightmapPixels[x + z*mapX])*scaleFactor;
+            mesh.vertices[vCounter + 2] = z;
 
-            vData.vertices[vCounter + 3] = x;
-            vData.vertices[vCounter + 4] = GetHeightValue(heightmapPixels[x + (z+1)*mapX])*scaleFactor;
-            vData.vertices[vCounter + 5] = z+1;
+            mesh.vertices[vCounter + 3] = x;
+            mesh.vertices[vCounter + 4] = GetHeightValue(heightmapPixels[x + (z+1)*mapX])*scaleFactor;
+            mesh.vertices[vCounter + 5] = z+1;
 
-            vData.vertices[vCounter + 6] = x+1;
-            vData.vertices[vCounter + 7] = GetHeightValue(heightmapPixels[(x+1) + z*mapX])*scaleFactor;
-            vData.vertices[vCounter + 8] = z;
+            mesh.vertices[vCounter + 6] = x+1;
+            mesh.vertices[vCounter + 7] = GetHeightValue(heightmapPixels[(x+1) + z*mapX])*scaleFactor;
+            mesh.vertices[vCounter + 8] = z;
 
             // another triangle - 3 vertex
-            vData.vertices[vCounter + 9] = vData.vertices[vCounter + 6];
-            vData.vertices[vCounter + 10] = vData.vertices[vCounter + 7];
-            vData.vertices[vCounter + 11] = vData.vertices[vCounter + 8];
+            mesh.vertices[vCounter + 9] = mesh.vertices[vCounter + 6];
+            mesh.vertices[vCounter + 10] = mesh.vertices[vCounter + 7];
+            mesh.vertices[vCounter + 11] = mesh.vertices[vCounter + 8];
 
-            vData.vertices[vCounter + 12] = vData.vertices[vCounter + 3];
-            vData.vertices[vCounter + 13] = vData.vertices[vCounter + 4];
-            vData.vertices[vCounter + 14] = vData.vertices[vCounter + 5];
+            mesh.vertices[vCounter + 12] = mesh.vertices[vCounter + 3];
+            mesh.vertices[vCounter + 13] = mesh.vertices[vCounter + 4];
+            mesh.vertices[vCounter + 14] = mesh.vertices[vCounter + 5];
 
-            vData.vertices[vCounter + 15] = x+1;
-            vData.vertices[vCounter + 16] = GetHeightValue(heightmapPixels[(x+1) + (z+1)*mapX])*scaleFactor;
-            vData.vertices[vCounter + 17] = z+1;
+            mesh.vertices[vCounter + 15] = x+1;
+            mesh.vertices[vCounter + 16] = GetHeightValue(heightmapPixels[(x+1) + (z+1)*mapX])*scaleFactor;
+            mesh.vertices[vCounter + 17] = z+1;
             vCounter += 18;     // 6 vertex, 18 floats
 
             // Fill texcoords array with data
             //--------------------------------------------------------------
-            vData.texcoords[tcCounter] = (float)x / (mapX-1);
-            vData.texcoords[tcCounter + 1] = (float)z / (mapZ-1);
+            mesh.texcoords[tcCounter] = (float)x / (mapX-1);
+            mesh.texcoords[tcCounter + 1] = (float)z / (mapZ-1);
 
-            vData.texcoords[tcCounter + 2] = (float)x / (mapX-1);
-            vData.texcoords[tcCounter + 3] = (float)(z+1) / (mapZ-1);
+            mesh.texcoords[tcCounter + 2] = (float)x / (mapX-1);
+            mesh.texcoords[tcCounter + 3] = (float)(z+1) / (mapZ-1);
 
-            vData.texcoords[tcCounter + 4] = (float)(x+1) / (mapX-1);
-            vData.texcoords[tcCounter + 5] = (float)z / (mapZ-1);
+            mesh.texcoords[tcCounter + 4] = (float)(x+1) / (mapX-1);
+            mesh.texcoords[tcCounter + 5] = (float)z / (mapZ-1);
 
-            vData.texcoords[tcCounter + 6] = vData.texcoords[tcCounter + 4];
-            vData.texcoords[tcCounter + 7] = vData.texcoords[tcCounter + 5];
+            mesh.texcoords[tcCounter + 6] = mesh.texcoords[tcCounter + 4];
+            mesh.texcoords[tcCounter + 7] = mesh.texcoords[tcCounter + 5];
 
-            vData.texcoords[tcCounter + 8] = vData.texcoords[tcCounter + 2];
-            vData.texcoords[tcCounter + 9] = vData.texcoords[tcCounter + 3];
+            mesh.texcoords[tcCounter + 8] = mesh.texcoords[tcCounter + 2];
+            mesh.texcoords[tcCounter + 9] = mesh.texcoords[tcCounter + 3];
 
-            vData.texcoords[tcCounter + 10] = (float)(x+1) / (mapX-1);
-            vData.texcoords[tcCounter + 11] = (float)(z+1) / (mapZ-1);
+            mesh.texcoords[tcCounter + 10] = (float)(x+1) / (mapX-1);
+            mesh.texcoords[tcCounter + 11] = (float)(z+1) / (mapZ-1);
             tcCounter += 12;    // 6 texcoords, 12 floats
 
             // Fill normals array with data
@@ -696,9 +696,9 @@ Model LoadHeightmap(Image heightmap, float maxHeight)
             // NOTE: Current Model implementation doe not use normals!
             for (int i = 0; i < 18; i += 3)
             {
-                vData.normals[nCounter + i] = 0.0f;
-                vData.normals[nCounter + i + 1] = 1.0f;
-                vData.normals[nCounter + i + 2] = 0.0f;
+                mesh.normals[nCounter + i] = 0.0f;
+                mesh.normals[nCounter + i + 1] = 1.0f;
+                mesh.normals[nCounter + i + 2] = 0.0f;
             }
 
             // TODO: Calculate normals in an efficient way
@@ -713,20 +713,20 @@ Model LoadHeightmap(Image heightmap, float maxHeight)
 
     // Fill color data
     // NOTE: Not used any more... just one plain color defined at DrawModel()
-    for (int i = 0; i < (4*vData.vertexCount); i++) vData.colors[i] = 255;
+    for (int i = 0; i < (4*mesh.vertexCount); i++) mesh.colors[i] = 255;
 
-    // NOTE: At this point we have all vertex, texcoord, normal data for the model in vData struct
+    // NOTE: At this point we have all vertex, texcoord, normal data for the model in mesh struct
 
-    Model model = rlglLoadModel(vData);
+    Model model = rlglLoadModel(mesh);
 
     // Now that vertex data is uploaded to GPU, we can free arrays
     // NOTE: We don't need CPU vertex data on OpenGL 3.3 or ES2
     if (rlGetVersion() != OPENGL_11)
     {
-        free(vData.vertices);
-        free(vData.texcoords);
-        free(vData.normals);
-        free(vData.colors);
+        free(mesh.vertices);
+        free(mesh.texcoords);
+        free(mesh.normals);
+        free(mesh.colors);
     }
 
     return model;
@@ -735,14 +735,14 @@ Model LoadHeightmap(Image heightmap, float maxHeight)
 // Load a map image as a 3d model (cubes based)
 Model LoadCubicmap(Image cubicmap)
 {
-    VertexData vData;
+    Mesh mesh;
 
     Color *cubicmapPixels = GetImageData(cubicmap);
     
     // Map cube size will be 1.0
     float mapCubeSide = 1.0f;
-    int mapWidth = cubicmap.width * (int)mapCubeSide;
-    int mapHeight = cubicmap.height * (int)mapCubeSide;
+    int mapWidth = cubicmap.width*(int)mapCubeSide;
+    int mapHeight = cubicmap.height*(int)mapCubeSide;
 
     // NOTE: Max possible number of triangles numCubes * (12 triangles by cube)
     int maxTriangles = cubicmap.width*cubicmap.height*12;
@@ -753,11 +753,11 @@ Model LoadCubicmap(Image cubicmap)
 
     float w = mapCubeSide;
     float h = mapCubeSide;
-    float h2 = mapCubeSide * 1.5;   // TODO: Review walls height...
+    float h2 = mapCubeSide*1.5f;   // TODO: Review walls height...
 
-    Vector3 *mapVertices = (Vector3 *)malloc(maxTriangles * 3 * sizeof(Vector3));
-    Vector2 *mapTexcoords = (Vector2 *)malloc(maxTriangles * 3 * sizeof(Vector2));
-    Vector3 *mapNormals = (Vector3 *)malloc(maxTriangles * 3 * sizeof(Vector3));
+    Vector3 *mapVertices = (Vector3 *)malloc(maxTriangles*3*sizeof(Vector3));
+    Vector2 *mapTexcoords = (Vector2 *)malloc(maxTriangles*3*sizeof(Vector2));
+    Vector3 *mapNormals = (Vector3 *)malloc(maxTriangles*3*sizeof(Vector3));
 
     // Define the 6 normals of the cube, we will combine them accordingly later...
     Vector3 n1 = { 1.0f, 0.0f, 0.0f };
@@ -775,12 +775,12 @@ Model LoadCubicmap(Image cubicmap)
         float height;
     } RectangleF;
 
-    RectangleF rightTexUV = { 0, 0, 0.5, 0.5 };
-    RectangleF leftTexUV = { 0.5, 0, 0.5, 0.5 };
-    RectangleF frontTexUV = { 0, 0, 0.5, 0.5 };
-    RectangleF backTexUV = { 0.5, 0, 0.5, 0.5 };
-    RectangleF topTexUV = { 0, 0.5, 0.5, 0.5 };
-    RectangleF bottomTexUV = { 0.5, 0.5, 0.5, 0.5 };
+    RectangleF rightTexUV = { 0.0f, 0.0f, 0.5f, 0.5f };
+    RectangleF leftTexUV = { 0.5f, 0.0f, 0.5f, 0.5f };
+    RectangleF frontTexUV = { 0.0f, 0.0f, 0.5f, 0.5f };
+    RectangleF backTexUV = { 0.5f, 0.0f, 0.5f, 0.5f };
+    RectangleF topTexUV = { 0.0f, 0.5f, 0.5f, 0.5f };
+    RectangleF bottomTexUV = { 0.5f, 0.5f, 0.5f, 0.5f };
 
     for (int z = 0; z < mapHeight; z += mapCubeSide)
     {
@@ -1041,25 +1041,25 @@ Model LoadCubicmap(Image cubicmap)
     }
 
     // Move data from mapVertices temp arays to vertices float array
-    vData.vertexCount = vCounter;
+    mesh.vertexCount = vCounter;
 
-    vData.vertices = (float *)malloc(vData.vertexCount*3*sizeof(float));
-    vData.normals = (float *)malloc(vData.vertexCount*3*sizeof(float));
-    vData.texcoords = (float *)malloc(vData.vertexCount*2*sizeof(float));
-    vData.colors = (unsigned char *)malloc(vData.vertexCount*4*sizeof(unsigned char));  // Not used...
+    mesh.vertices = (float *)malloc(mesh.vertexCount*3*sizeof(float));
+    mesh.normals = (float *)malloc(mesh.vertexCount*3*sizeof(float));
+    mesh.texcoords = (float *)malloc(mesh.vertexCount*2*sizeof(float));
+    mesh.colors = (unsigned char *)malloc(mesh.vertexCount*4*sizeof(unsigned char));  // Not used...
 
     // Fill color data
     // NOTE: Not used any more... just one plain color defined at DrawModel()
-    for (int i = 0; i < (4*vData.vertexCount); i++) vData.colors[i] = 255;
+    for (int i = 0; i < (4*mesh.vertexCount); i++) mesh.colors[i] = 255;
 
     int fCounter = 0;
 
     // Move vertices data
     for (int i = 0; i < vCounter; i++)
     {
-        vData.vertices[fCounter] = mapVertices[i].x;
-        vData.vertices[fCounter + 1] = mapVertices[i].y;
-        vData.vertices[fCounter + 2] = mapVertices[i].z;
+        mesh.vertices[fCounter] = mapVertices[i].x;
+        mesh.vertices[fCounter + 1] = mapVertices[i].y;
+        mesh.vertices[fCounter + 2] = mapVertices[i].z;
         fCounter += 3;
     }
 
@@ -1068,9 +1068,9 @@ Model LoadCubicmap(Image cubicmap)
     // Move normals data
     for (int i = 0; i < nCounter; i++)
     {
-        vData.normals[fCounter] = mapNormals[i].x;
-        vData.normals[fCounter + 1] = mapNormals[i].y;
-        vData.normals[fCounter + 2] = mapNormals[i].z;
+        mesh.normals[fCounter] = mapNormals[i].x;
+        mesh.normals[fCounter + 1] = mapNormals[i].y;
+        mesh.normals[fCounter + 2] = mapNormals[i].z;
         fCounter += 3;
     }
 
@@ -1079,8 +1079,8 @@ Model LoadCubicmap(Image cubicmap)
     // Move texcoords data
     for (int i = 0; i < tcCounter; i++)
     {
-        vData.texcoords[fCounter] = mapTexcoords[i].x;
-        vData.texcoords[fCounter + 1] = mapTexcoords[i].y;
+        mesh.texcoords[fCounter] = mapTexcoords[i].x;
+        mesh.texcoords[fCounter + 1] = mapTexcoords[i].y;
         fCounter += 2;
     }
 
@@ -1090,18 +1090,18 @@ Model LoadCubicmap(Image cubicmap)
     
     free(cubicmapPixels);
 
-    // NOTE: At this point we have all vertex, texcoord, normal data for the model in vData struct
+    // NOTE: At this point we have all vertex, texcoord, normal data for the model in mesh struct
 
-    Model model = rlglLoadModel(vData);
+    Model model = rlglLoadModel(mesh);
 
     // Now that vertex data is uploaded to GPU, we can free arrays
     // NOTE: We don't need CPU vertex data on OpenGL 3.3 or ES2
     if (rlGetVersion() != OPENGL_11)
     {
-        free(vData.vertices);
-        free(vData.texcoords);
-        free(vData.normals);
-        free(vData.colors);
+        free(mesh.vertices);
+        free(mesh.texcoords);
+        free(mesh.normals);
+        free(mesh.colors);
     }
 
     return model;
@@ -1147,7 +1147,7 @@ void SetModelTexture(Model *model, Texture2D texture)
 void DrawModel(Model model, Vector3 position, float scale, Color tint)
 {
     Vector3 vScale = { scale, scale, scale };
-    Vector3 rotationAxis = { 0, 0, 0 };
+    Vector3 rotationAxis = { 0.0f, 0.0f, 0.0f };
 
     DrawModelEx(model, position, 0.0f, rotationAxis, vScale, tint);
 }
@@ -1163,7 +1163,7 @@ void DrawModelEx(Model model, Vector3 position, float rotationAngle, Vector3 rot
 void DrawModelWires(Model model, Vector3 position, float scale, Color color)
 {
     Vector3 vScale = { scale, scale, scale };
-    Vector3 rotationAxis = { 0, 0, 0 };
+    Vector3 rotationAxis = { 0.0f, 0.0f, 0.0f };
 
     rlglDrawModel(model, position, 0.0f, rotationAxis, vScale, color, true);
 }
@@ -1188,7 +1188,7 @@ void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size,
     //Vector3 up = { viewMatrix.m1, viewMatrix.m5, viewMatrix.m9 };
     
     // NOTE: Billboard locked to axis-Y
-    Vector3 up = { 0, 1, 0 };
+    Vector3 up = { 0.0f, 1.0f, 0.0f };
 /*
     a-------b
     |       |
@@ -1336,18 +1336,28 @@ bool CheckCollisionBoxSphere(Vector3 minBBox, Vector3 maxBBox, Vector3 centerSph
     return collision;
 }
 
-// Detect collision between ray and box
+// Detect collision between ray and sphere
+bool CheckCollisionRaySphere(Ray ray, Vector3 spherePosition, float sphereRadius)
+{
+    bool collision = false;
+    
+    // TODO: implement collision...
+    
+    return collision;
+}
+
+// Detect collision between ray and bounding box
 bool CheckCollisionRayBox(Ray ray, Vector3 minBBox, Vector3 maxBBox)
 {
     bool collision = false;
     
     float t[8];
-    t[0] = (minBBox.x - ray.position.x) / ray.direction.x;
-    t[1] = (maxBBox.x - ray.position.x) / ray.direction.x;
-    t[2] = (minBBox.y - ray.position.y) / ray.direction.y;
-    t[3] = (maxBBox.y - ray.position.y) / ray.direction.y;
-    t[4] = (minBBox.z - ray.position.z) / ray.direction.z;
-    t[5] = (maxBBox.z - ray.position.z) / ray.direction.z;
+    t[0] = (minBBox.x - ray.position.x)/ray.direction.x;
+    t[1] = (maxBBox.x - ray.position.x)/ray.direction.x;
+    t[2] = (minBBox.y - ray.position.y)/ray.direction.y;
+    t[3] = (maxBBox.y - ray.position.y)/ray.direction.y;
+    t[4] = (minBBox.z - ray.position.z)/ray.direction.z;
+    t[5] = (maxBBox.z - ray.position.z)/ray.direction.z;
     t[6] = fmax(fmax(fmin(t[0], t[1]), fmin(t[2], t[3])), fmin(t[4], t[5]));
     t[7] = fmin(fmin(fmax(t[0], t[1]), fmax(t[2], t[3])), fmax(t[4], t[5]));
     
@@ -1359,6 +1369,32 @@ bool CheckCollisionRayBox(Ray ray, Vector3 minBBox, Vector3 maxBBox)
 // TODO: Useful function to check collision area?
 //BoundingBox GetCollisionArea(BoundingBox box1, BoundingBox box2)
 
+// Calculate mesh bounding box limits
+BoundingBox CalculateBoundingBox(Mesh mesh)
+{
+    // Get min and max vertex to construct bounds (AABB)
+    Vector3 minVertex = mesh.vertices[0]; 
+    Vector3 maxVertex = mesh.vertices[0];
+
+    for (int i = 1; i < mesh.vertexCount; i++)
+    {
+		// TODO: Compare min and max with previous vertex
+        //minVertex = Vector3.Min(minVertex, mesh.vertices[i]);
+        //maxVertex = Vector3.Max(maxVertex, mesh.vertices[i]);
+    }
+
+    // NOTE: For OBB, transform mesh by model transform matrix
+    //minVertex = VectorTransform(meshMin, mesh.transform);
+    //maxVertex = VectorTransform(meshMax, mesh.transform);
+ 
+    // Create the bounding box
+    BoundingBox box;
+    box.min = minVertex;
+    box.max = maxVertex;
+    
+    return box;
+}
+
 // Detect and resolve cubicmap collisions
 // NOTE: player position (or camera) is modified inside this function
 Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *playerPosition, float radius)
@@ -1366,7 +1402,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
     Color *cubicmapPixels = GetImageData(cubicmap);
     
     // Detect the cell where the player is located
-    Vector3 impactDirection = { 0, 0, 0 };
+    Vector3 impactDirection = { 0.0f, 0.0f, 0.0f };
 
     int locationCellX = 0;
     int locationCellY = 0;
@@ -1389,7 +1425,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
                 {
                     playerPosition->x = locationCellX + mapPosition.x - (CUBIC_MAP_HALF_BLOCK_SIZE - radius);
                     playerPosition->z = locationCellY + mapPosition.z - (CUBIC_MAP_HALF_BLOCK_SIZE - radius);
-                    impactDirection = (Vector3) { 1, 0, 1};
+                    impactDirection = (Vector3){ 1.0f, 0.0f, 1.0f };
                 }
             }
         }
@@ -1405,7 +1441,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
                 {
                     playerPosition->x = locationCellX + mapPosition.x - (CUBIC_MAP_HALF_BLOCK_SIZE - radius);
                     playerPosition->z = locationCellY + mapPosition.z + (CUBIC_MAP_HALF_BLOCK_SIZE - radius);
-                    impactDirection = (Vector3) { 1, 0, 1};
+                    impactDirection = (Vector3){ 1.0f, 0.0f, 1.0f };
                 }
             }
         }
@@ -1421,7 +1457,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
                 {
                     playerPosition->x = locationCellX + mapPosition.x + (CUBIC_MAP_HALF_BLOCK_SIZE - radius);
                     playerPosition->z = locationCellY + mapPosition.z - (CUBIC_MAP_HALF_BLOCK_SIZE - radius);
-                    impactDirection = (Vector3) { 1, 0, 1};
+                    impactDirection = (Vector3){ 1.0f, 0.0f, 1.0f };
                 }
             }
         }
@@ -1437,7 +1473,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
                 {
                     playerPosition->x = locationCellX + mapPosition.x + (CUBIC_MAP_HALF_BLOCK_SIZE - radius);
                     playerPosition->z = locationCellY + mapPosition.z + (CUBIC_MAP_HALF_BLOCK_SIZE - radius);
-                    impactDirection = (Vector3) { 1, 0, 1};
+                    impactDirection = (Vector3){ 1.0f, 0.0f, 1.0f };
                 }
             }
         }
@@ -1452,7 +1488,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
                 if ((playerPosition->x - mapPosition.x + CUBIC_MAP_HALF_BLOCK_SIZE) - locationCellX < radius)
                 {
                     playerPosition->x = locationCellX + mapPosition.x - (CUBIC_MAP_HALF_BLOCK_SIZE - radius);
-                    impactDirection = (Vector3) { 1, 0, 0};
+                    impactDirection = (Vector3){ 1.0f, 0.0f, 0.0f };
                 }
             }
         }
@@ -1464,7 +1500,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
                 if ((playerPosition->x - mapPosition.x + CUBIC_MAP_HALF_BLOCK_SIZE) - locationCellX > 1 - radius)
                 {
                     playerPosition->x = locationCellX + mapPosition.x + (CUBIC_MAP_HALF_BLOCK_SIZE - radius);
-                    impactDirection = (Vector3) { 1, 0, 0};
+                    impactDirection = (Vector3){ 1.0f, 0.0f, 0.0f };
                 }
             }
         }
@@ -1476,7 +1512,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
                 if ((playerPosition->z - mapPosition.z + CUBIC_MAP_HALF_BLOCK_SIZE) - locationCellY < radius)
                 {
                     playerPosition->z = locationCellY + mapPosition.z - (CUBIC_MAP_HALF_BLOCK_SIZE - radius);
-                    impactDirection = (Vector3) { 0, 0, 1};
+                    impactDirection = (Vector3){ 0.0f, 0.0f, 1.0f };
                 }
             }
         }
@@ -1488,7 +1524,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
                 if ((playerPosition->z - mapPosition.z + CUBIC_MAP_HALF_BLOCK_SIZE) - locationCellY > 1 - radius)
                 {
                     playerPosition->z = locationCellY + mapPosition.z + (CUBIC_MAP_HALF_BLOCK_SIZE - radius);
-                    impactDirection = (Vector3) { 0, 0, 1};
+                    impactDirection = (Vector3){ 0.0f, 0.0f, 1.0f };
                 }
             }
         }
@@ -1512,7 +1548,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
                     if (((playerPosition->x - mapPosition.x + CUBIC_MAP_HALF_BLOCK_SIZE) - locationCellX < radius / 3) &&
                         ((playerPosition->z - mapPosition.z + CUBIC_MAP_HALF_BLOCK_SIZE) - locationCellY < radius / 3))
                     {
-                        impactDirection = (Vector3) { 1, 0, 1};
+                        impactDirection = (Vector3){ 1.0f, 0.0f, 1.0f };
                     }
                 }
             }
@@ -1535,7 +1571,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
                     if (((playerPosition->x - mapPosition.x + CUBIC_MAP_HALF_BLOCK_SIZE) - locationCellX < radius / 3) &&
                         ((playerPosition->z - mapPosition.z + CUBIC_MAP_HALF_BLOCK_SIZE) - locationCellY > 1 - radius / 3))
                     {
-                        impactDirection = (Vector3) { 1, 0, 1};
+                        impactDirection = (Vector3){ 1.0f, 0.0f, 1.0f };
                     }
                 }
             }
@@ -1558,7 +1594,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
                     if (((playerPosition->x - mapPosition.x + CUBIC_MAP_HALF_BLOCK_SIZE) - locationCellX > 1 - radius / 3) &&
                         ((playerPosition->z - mapPosition.z + CUBIC_MAP_HALF_BLOCK_SIZE) - locationCellY < radius / 3))
                     {
-                        impactDirection = (Vector3) { 1, 0, 1};
+                        impactDirection = (Vector3){ 1.0f, 0.0f, 1.0f };
                     }
                 }
             }
@@ -1581,7 +1617,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
                     if (((playerPosition->x - mapPosition.x + CUBIC_MAP_HALF_BLOCK_SIZE) - locationCellX > 1 - radius / 3) &&
                         ((playerPosition->z - mapPosition.z + CUBIC_MAP_HALF_BLOCK_SIZE) - locationCellY > 1 - radius / 3))
                     {
-                        impactDirection = (Vector3) { 1, 0, 1};
+                        impactDirection = (Vector3){ 1.0f, 0.0f, 1.0f };
                     }
                 }
             }
@@ -1591,13 +1627,13 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p
     // Floor collision
     if (playerPosition->y <= radius)
     {
-        playerPosition->y = radius + 0.01;
+        playerPosition->y = radius + 0.01f;
         impactDirection = (Vector3) { impactDirection.x, 1, impactDirection.z};
     }
     // Roof collision
-    else if (playerPosition->y >= 1.5 - radius)
+    else if (playerPosition->y >= (1.5f - radius))
     {
-        playerPosition->y = (1.5 - radius) - 0.01;
+        playerPosition->y = (1.5f - radius) - 0.01f;
         impactDirection = (Vector3) { impactDirection.x, 1, impactDirection.z};
     }
     
@@ -1617,9 +1653,9 @@ static float GetHeightValue(Color pixel)
 }
 
 // Load OBJ mesh data
-static VertexData LoadOBJ(const char *fileName)
+static Mesh LoadOBJ(const char *fileName)
 {
-    VertexData vData = { 0 };
+    Mesh mesh = { 0 };
 
     char dataType;
     char comments[200];
@@ -1636,7 +1672,7 @@ static VertexData LoadOBJ(const char *fileName)
     if (objFile == NULL)
     {
         TraceLog(WARNING, "[%s] OBJ file could not be opened", fileName);
-        return vData;
+        return mesh;
     }
 
     // First reading pass: Get numVertex, numNormals, numTexCoords, numTriangles
@@ -1747,15 +1783,15 @@ static VertexData LoadOBJ(const char *fileName)
     }
 
     // At this point all vertex data (v, vt, vn) has been gathered on midVertices, midTexCoords, midNormals
-    // Now we can organize that data into our VertexData struct
+    // Now we can organize that data into our Mesh struct
 
-    vData.vertexCount = numTriangles*3;
+    mesh.vertexCount = numTriangles*3;
 
     // Additional arrays to store vertex data as floats
-    vData.vertices = (float *)malloc(vData.vertexCount*3*sizeof(float));
-    vData.texcoords = (float *)malloc(vData.vertexCount*2*sizeof(float));
-    vData.normals = (float *)malloc(vData.vertexCount*3*sizeof(float));
-    vData.colors = (unsigned char *)malloc(vData.vertexCount*4*sizeof(unsigned char));
+    mesh.vertices = (float *)malloc(mesh.vertexCount*3*sizeof(float));
+    mesh.texcoords = (float *)malloc(mesh.vertexCount*2*sizeof(float));
+    mesh.normals = (float *)malloc(mesh.vertexCount*3*sizeof(float));
+    mesh.colors = (unsigned char *)malloc(mesh.vertexCount*4*sizeof(unsigned char));
 
     int vCounter = 0;       // Used to count vertices float by float
     int tcCounter = 0;      // Used to count texcoords float by float
@@ -1783,32 +1819,32 @@ static VertexData LoadOBJ(const char *fileName)
                 else if (numNormals == 0) fscanf(objFile, "%i/%i %i/%i %i/%i", &vNum[0], &vtNum[0], &vNum[1], &vtNum[1], &vNum[2], &vtNum[2]);
                 else fscanf(objFile, "%i/%i/%i %i/%i/%i %i/%i/%i", &vNum[0], &vtNum[0], &vnNum[0], &vNum[1], &vtNum[1], &vnNum[1], &vNum[2], &vtNum[2], &vnNum[2]);
 
-                vData.vertices[vCounter] = midVertices[vNum[0]-1].x;
-                vData.vertices[vCounter + 1] = midVertices[vNum[0]-1].y;
-                vData.vertices[vCounter + 2] = midVertices[vNum[0]-1].z;
+                mesh.vertices[vCounter] = midVertices[vNum[0]-1].x;
+                mesh.vertices[vCounter + 1] = midVertices[vNum[0]-1].y;
+                mesh.vertices[vCounter + 2] = midVertices[vNum[0]-1].z;
                 vCounter += 3;
-                vData.vertices[vCounter] = midVertices[vNum[1]-1].x;
-                vData.vertices[vCounter + 1] = midVertices[vNum[1]-1].y;
-                vData.vertices[vCounter + 2] = midVertices[vNum[1]-1].z;
+                mesh.vertices[vCounter] = midVertices[vNum[1]-1].x;
+                mesh.vertices[vCounter + 1] = midVertices[vNum[1]-1].y;
+                mesh.vertices[vCounter + 2] = midVertices[vNum[1]-1].z;
                 vCounter += 3;
-                vData.vertices[vCounter] = midVertices[vNum[2]-1].x;
-                vData.vertices[vCounter + 1] = midVertices[vNum[2]-1].y;
-                vData.vertices[vCounter + 2] = midVertices[vNum[2]-1].z;
+                mesh.vertices[vCounter] = midVertices[vNum[2]-1].x;
+                mesh.vertices[vCounter + 1] = midVertices[vNum[2]-1].y;
+                mesh.vertices[vCounter + 2] = midVertices[vNum[2]-1].z;
                 vCounter += 3;
 
                 if (numNormals > 0)
                 {
-                    vData.normals[nCounter] = midNormals[vnNum[0]-1].x;
-                    vData.normals[nCounter + 1] = midNormals[vnNum[0]-1].y;
-                    vData.normals[nCounter + 2] = midNormals[vnNum[0]-1].z;
+                    mesh.normals[nCounter] = midNormals[vnNum[0]-1].x;
+                    mesh.normals[nCounter + 1] = midNormals[vnNum[0]-1].y;
+                    mesh.normals[nCounter + 2] = midNormals[vnNum[0]-1].z;
                     nCounter += 3;
-                    vData.normals[nCounter] = midNormals[vnNum[1]-1].x;
-                    vData.normals[nCounter + 1] = midNormals[vnNum[1]-1].y;
-                    vData.normals[nCounter + 2] = midNormals[vnNum[1]-1].z;
+                    mesh.normals[nCounter] = midNormals[vnNum[1]-1].x;
+                    mesh.normals[nCounter + 1] = midNormals[vnNum[1]-1].y;
+                    mesh.normals[nCounter + 2] = midNormals[vnNum[1]-1].z;
                     nCounter += 3;
-                    vData.normals[nCounter] = midNormals[vnNum[2]-1].x;
-                    vData.normals[nCounter + 1] = midNormals[vnNum[2]-1].y;
-                    vData.normals[nCounter + 2] = midNormals[vnNum[2]-1].z;
+                    mesh.normals[nCounter] = midNormals[vnNum[2]-1].x;
+                    mesh.normals[nCounter + 1] = midNormals[vnNum[2]-1].y;
+                    mesh.normals[nCounter + 2] = midNormals[vnNum[2]-1].z;
                     nCounter += 3;
                 }
                 else
@@ -1817,17 +1853,17 @@ static VertexData LoadOBJ(const char *fileName)
                     Vector3 norm = VectorCrossProduct(VectorSubtract(midVertices[vNum[1]-1], midVertices[vNum[0]-1]), VectorSubtract(midVertices[vNum[2]-1], midVertices[vNum[0]-1]));
                     VectorNormalize(&norm);
 
-                    vData.normals[nCounter] = norm.x;
-                    vData.normals[nCounter + 1] = norm.y;
-                    vData.normals[nCounter + 2] = norm.z;
+                    mesh.normals[nCounter] = norm.x;
+                    mesh.normals[nCounter + 1] = norm.y;
+                    mesh.normals[nCounter + 2] = norm.z;
                     nCounter += 3;
-                    vData.normals[nCounter] = norm.x;
-                    vData.normals[nCounter + 1] = norm.y;
-                    vData.normals[nCounter + 2] = norm.z;
+                    mesh.normals[nCounter] = norm.x;
+                    mesh.normals[nCounter + 1] = norm.y;
+                    mesh.normals[nCounter + 2] = norm.z;
                     nCounter += 3;
-                    vData.normals[nCounter] = norm.x;
-                    vData.normals[nCounter + 1] = norm.y;
-                    vData.normals[nCounter + 2] = norm.z;
+                    mesh.normals[nCounter] = norm.x;
+                    mesh.normals[nCounter + 1] = norm.y;
+                    mesh.normals[nCounter + 2] = norm.z;
                     nCounter += 3;
                 }
 
@@ -1835,14 +1871,14 @@ static VertexData LoadOBJ(const char *fileName)
                 {
                     // NOTE: If using negative texture coordinates with a texture filter of GL_CLAMP_TO_EDGE doesn't work!
                     // NOTE: Texture coordinates are Y flipped upside-down
-                    vData.texcoords[tcCounter] = midTexCoords[vtNum[0]-1].x;
-                    vData.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtNum[0]-1].y;
+                    mesh.texcoords[tcCounter] = midTexCoords[vtNum[0]-1].x;
+                    mesh.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtNum[0]-1].y;
                     tcCounter += 2;
-                    vData.texcoords[tcCounter] = midTexCoords[vtNum[1]-1].x;
-                    vData.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtNum[1]-1].y;
+                    mesh.texcoords[tcCounter] = midTexCoords[vtNum[1]-1].x;
+                    mesh.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtNum[1]-1].y;
                     tcCounter += 2;
-                    vData.texcoords[tcCounter] = midTexCoords[vtNum[2]-1].x;
-                    vData.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtNum[2]-1].y;
+                    mesh.texcoords[tcCounter] = midTexCoords[vtNum[2]-1].x;
+                    mesh.texcoords[tcCounter + 1] = 1.0f - midTexCoords[vtNum[2]-1].y;
                     tcCounter += 2;
                 }
             } break;
@@ -1853,19 +1889,19 @@ static VertexData LoadOBJ(const char *fileName)
     fclose(objFile);
 
     // Security check, just in case no normals or no texcoords defined in OBJ
-    if (numTexCoords == 0) for (int i = 0; i < (2*vData.vertexCount); i++) vData.texcoords[i] = 0.0f;
+    if (numTexCoords == 0) for (int i = 0; i < (2*mesh.vertexCount); i++) mesh.texcoords[i] = 0.0f;
     
     // NOTE: We set all vertex colors to white
     // NOTE: Not used any more... just one plain color defined at DrawModel()
-    for (int i = 0; i < (4*vData.vertexCount); i++) vData.colors[i] = 255;
+    for (int i = 0; i < (4*mesh.vertexCount); i++) mesh.colors[i] = 255;
 
     // Now we can free temp mid* arrays
     free(midVertices);
     free(midNormals);
     free(midTexCoords);
 
-    // NOTE: At this point we have all vertex, texcoord, normal data for the model in vData struct
+    // NOTE: At this point we have all vertex, texcoord, normal data for the model in mesh struct
     TraceLog(INFO, "[%s] Model loaded successfully in RAM (CPU)", fileName);
 
-    return vData;
+    return mesh;
 }
diff --git a/src/raygui.c b/src/raygui.c
index 8e9a3387..2c68c96f 100644
--- a/src/raygui.c
+++ b/src/raygui.c
@@ -255,7 +255,7 @@ bool GuiToggleButton(Rectangle bounds, const char *text, bool toggle)
     
     // Update control
     //--------------------------------------------------------------------   
-   if (toggleButton.width < textWidth) toggleButton.width = textWidth + style[TOGGLE_TEXT_PADDING];
+    if (toggleButton.width < textWidth) toggleButton.width = textWidth + style[TOGGLE_TEXT_PADDING];
     if (toggleButton.height < textHeight) toggleButton.height = textHeight + style[TOGGLE_TEXT_PADDING]/2;
     if (CheckCollisionPointRec(mousePoint, toggleButton))
     {
@@ -320,7 +320,7 @@ int GuiComboBox(Rectangle bounds, int comboNum, char **comboText, int comboActiv
 {
     ComboBoxState comboBoxState = COMBOBOX_UNACTIVE;
     Rectangle comboBoxButton = bounds;
-    Rectangle click = { bounds.x + bounds.width + style[COMBOBOX_PADDING], bounds.y, style[COMBOBOX_BUTTON_WIDTH], bounds.height };
+    Rectangle click = { bounds.x + bounds.width + style[COMBOBOX_PADDING], bounds.y, style[COMBOBOX_BUTTON_WIDTH], style[COMBOBOX_BUTTON_HEIGHT] };
     Vector2 mousePoint = GetMousePosition();
 
     int textHeight = GetDefaultFont().size;
@@ -691,7 +691,7 @@ int GuiSpinner(Rectangle bounds, int value, int minValue, int maxValue)
     }
     else if (!CheckCollisionPointRec(mousePoint, labelBoxBound)) buttonSide = 0;
     
-    if(IsMouseButtonUp(MOUSE_LEFT_BUTTON))
+    if (IsMouseButtonUp(MOUSE_LEFT_BUTTON))
     {
         valueSpeed = false;
         framesCounter = 0;
@@ -710,13 +710,13 @@ int GuiSpinner(Rectangle bounds, int value, int minValue, int maxValue)
             DrawRectangleRec(rightButtonBound, GetColor(style[SPINNER_DEFAULT_BUTTON_BORDER_COLOR]));
             DrawRectangle(rightButtonBound.x + 2, rightButtonBound.y + 2, rightButtonBound.width - 4, rightButtonBound.height - 4, GetColor(style[SPINNER_DEFAULT_BUTTON_INSIDE_COLOR]));
             
-            DrawText(FormatText("-"), leftButtonBound.x + (leftButtonBound.width/2 - (MeasureText(FormatText("+"), style[GLOBAL_TEXT_FONTSIZE]))/2), leftButtonBound.y + (leftButtonBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_SYMBOL_COLOR])); 
-            DrawText(FormatText("+"), rightButtonBound.x + (rightButtonBound.width/2 - (MeasureText(FormatText("-"), style[GLOBAL_TEXT_FONTSIZE]))/2), rightButtonBound.y + (rightButtonBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_SYMBOL_COLOR])); 
+            DrawText(FormatText("-"), leftButtonBound.x + (leftButtonBound.width/2 - (MeasureText(FormatText("+"), style[GLOBAL_TEXT_FONTSIZE]))/2), leftButtonBound.y + (leftButtonBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_SYMBOL_COLOR])); 
+            DrawText(FormatText("+"), rightButtonBound.x + (rightButtonBound.width/2 - (MeasureText(FormatText("-"), style[GLOBAL_TEXT_FONTSIZE]))/2), rightButtonBound.y + (rightButtonBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_SYMBOL_COLOR])); 
             
             DrawRectangleRec(labelBoxBound, GetColor(style[SPINNER_LABEL_BORDER_COLOR]));
             DrawRectangle(labelBoxBound.x + 1, labelBoxBound.y + 1, labelBoxBound.width - 2, labelBoxBound.height - 2, GetColor(style[SPINNER_LABEL_INSIDE_COLOR]));
             
-            DrawText(FormatText("%i", value), labelBoxBound.x + (labelBoxBound.width/2 - textWidth/2), labelBoxBound.y + (labelBoxBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_TEXT_COLOR]));
+            DrawText(FormatText("%i", value), labelBoxBound.x + (labelBoxBound.width/2 - textWidth/2), labelBoxBound.y + (labelBoxBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_TEXT_COLOR]));
         } break;
         case SPINNER_HOVER:
         {
@@ -728,8 +728,8 @@ int GuiSpinner(Rectangle bounds, int value, int minValue, int maxValue)
                 DrawRectangleRec(rightButtonBound, GetColor(style[SPINNER_DEFAULT_BUTTON_BORDER_COLOR]));
                 DrawRectangle(rightButtonBound.x + 2, rightButtonBound.y + 2, rightButtonBound.width - 4, rightButtonBound.height - 4, GetColor(style[SPINNER_DEFAULT_BUTTON_INSIDE_COLOR]));
                 
-                DrawText(FormatText("-"), leftButtonBound.x + (leftButtonBound.width/2 - (MeasureText(FormatText("+"), style[GLOBAL_TEXT_FONTSIZE]))/2), leftButtonBound.y + (leftButtonBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_HOVER_SYMBOL_COLOR])); 
-                DrawText(FormatText("+"), rightButtonBound.x + (rightButtonBound.width/2 - (MeasureText(FormatText("-"), style[GLOBAL_TEXT_FONTSIZE]))/2), rightButtonBound.y + (rightButtonBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_SYMBOL_COLOR])); 
+                DrawText(FormatText("-"), leftButtonBound.x + (leftButtonBound.width/2 - (MeasureText(FormatText("+"), style[GLOBAL_TEXT_FONTSIZE]))/2), leftButtonBound.y + (leftButtonBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_HOVER_SYMBOL_COLOR])); 
+                DrawText(FormatText("+"), rightButtonBound.x + (rightButtonBound.width/2 - (MeasureText(FormatText("-"), style[GLOBAL_TEXT_FONTSIZE]))/2), rightButtonBound.y + (rightButtonBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_SYMBOL_COLOR])); 
             }                
             else if (buttonSide == 2)
             {
@@ -739,14 +739,14 @@ int GuiSpinner(Rectangle bounds, int value, int minValue, int maxValue)
                 DrawRectangleRec(rightButtonBound, GetColor(style[SPINNER_HOVER_BUTTON_BORDER_COLOR]));
                 DrawRectangle(rightButtonBound.x + 2, rightButtonBound.y + 2, rightButtonBound.width - 4, rightButtonBound.height - 4, GetColor(style[SPINNER_HOVER_BUTTON_INSIDE_COLOR]));
                 
-                DrawText(FormatText("-"), leftButtonBound.x + (leftButtonBound.width/2 - (MeasureText(FormatText("+"), style[GLOBAL_TEXT_FONTSIZE]))/2), leftButtonBound.y + (leftButtonBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_SYMBOL_COLOR])); 
-                DrawText(FormatText("+"), rightButtonBound.x + (rightButtonBound.width/2 - (MeasureText(FormatText("-"), style[GLOBAL_TEXT_FONTSIZE]))/2), rightButtonBound.y + (rightButtonBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_HOVER_SYMBOL_COLOR])); 
+                DrawText(FormatText("-"), leftButtonBound.x + (leftButtonBound.width/2 - (MeasureText(FormatText("+"), style[GLOBAL_TEXT_FONTSIZE]))/2), leftButtonBound.y + (leftButtonBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_SYMBOL_COLOR])); 
+                DrawText(FormatText("+"), rightButtonBound.x + (rightButtonBound.width/2 - (MeasureText(FormatText("-"), style[GLOBAL_TEXT_FONTSIZE]))/2), rightButtonBound.y + (rightButtonBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_HOVER_SYMBOL_COLOR])); 
             }
             
             DrawRectangleRec(labelBoxBound, GetColor(style[SPINNER_LABEL_BORDER_COLOR]));
             DrawRectangle(labelBoxBound.x + 1, labelBoxBound.y + 1, labelBoxBound.width - 2, labelBoxBound.height - 2, GetColor(style[SPINNER_LABEL_INSIDE_COLOR]));
             
-            DrawText(FormatText("%i", value), labelBoxBound.x + (labelBoxBound.width/2 - textWidth/2), labelBoxBound.y + (labelBoxBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_HOVER_TEXT_COLOR]));  
+            DrawText(FormatText("%i", value), labelBoxBound.x + (labelBoxBound.width/2 - textWidth/2), labelBoxBound.y + (labelBoxBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_HOVER_TEXT_COLOR]));  
         } break;
         case SPINNER_PRESSED:
         {
@@ -758,9 +758,9 @@ int GuiSpinner(Rectangle bounds, int value, int minValue, int maxValue)
                 DrawRectangleRec(rightButtonBound, GetColor(style[SPINNER_DEFAULT_BUTTON_BORDER_COLOR]));
                 DrawRectangle(rightButtonBound.x + 2, rightButtonBound.y + 2, rightButtonBound.width - 4, rightButtonBound.height - 4, GetColor(style[SPINNER_DEFAULT_BUTTON_INSIDE_COLOR]));
                 
-                DrawText(FormatText("-"), leftButtonBound.x + (leftButtonBound.width/2 - (MeasureText(FormatText("+"), style[GLOBAL_TEXT_FONTSIZE]))/2), leftButtonBound.y + (leftButtonBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_PRESSED_SYMBOL_COLOR])); 
-                DrawText(FormatText("+"), rightButtonBound.x + (rightButtonBound.width/2 - (MeasureText(FormatText("-"), style[GLOBAL_TEXT_FONTSIZE]))/2), rightButtonBound.y + (rightButtonBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_SYMBOL_COLOR])); 
-            }                
+                DrawText(FormatText("-"), leftButtonBound.x + (leftButtonBound.width/2 - (MeasureText(FormatText("+"), style[GLOBAL_TEXT_FONTSIZE]))/2), leftButtonBound.y + (leftButtonBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_PRESSED_SYMBOL_COLOR])); 
+                DrawText(FormatText("+"), rightButtonBound.x + (rightButtonBound.width/2 - (MeasureText(FormatText("-"), style[GLOBAL_TEXT_FONTSIZE]))/2), rightButtonBound.y + (rightButtonBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_SYMBOL_COLOR])); 
+            }
             else if (buttonSide == 2)
             {
                 DrawRectangleRec(leftButtonBound, GetColor(style[SPINNER_DEFAULT_BUTTON_BORDER_COLOR]));
@@ -769,16 +769,18 @@ int GuiSpinner(Rectangle bounds, int value, int minValue, int maxValue)
                 DrawRectangleRec(rightButtonBound, GetColor(style[SPINNER_PRESSED_BUTTON_BORDER_COLOR]));
                 DrawRectangle(rightButtonBound.x + 2, rightButtonBound.y + 2, rightButtonBound.width - 4, rightButtonBound.height - 4, GetColor(style[SPINNER_PRESSED_BUTTON_INSIDE_COLOR]));
                 
-                DrawText(FormatText("-"), leftButtonBound.x + (leftButtonBound.width/2 - (MeasureText(FormatText("+"), style[GLOBAL_TEXT_FONTSIZE]))/2), leftButtonBound.y + (leftButtonBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_SYMBOL_COLOR])); 
-                DrawText(FormatText("+"), rightButtonBound.x + (rightButtonBound.width/2 - (MeasureText(FormatText("-"), style[GLOBAL_TEXT_FONTSIZE]))/2), rightButtonBound.y + (rightButtonBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_PRESSED_SYMBOL_COLOR])); 
-            }            
+                DrawText(FormatText("-"), leftButtonBound.x + (leftButtonBound.width/2 - (MeasureText(FormatText("+"), style[GLOBAL_TEXT_FONTSIZE]))/2), leftButtonBound.y + (leftButtonBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_DEFAULT_SYMBOL_COLOR])); 
+                DrawText(FormatText("+"), rightButtonBound.x + (rightButtonBound.width/2 - (MeasureText(FormatText("-"), style[GLOBAL_TEXT_FONTSIZE]))/2), rightButtonBound.y + (rightButtonBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_PRESSED_SYMBOL_COLOR])); 
+            }
+            
             DrawRectangleRec(labelBoxBound, GetColor(style[SPINNER_LABEL_BORDER_COLOR]));
             DrawRectangle(labelBoxBound.x + 1, labelBoxBound.y + 1, labelBoxBound.width - 2, labelBoxBound.height - 2, GetColor(style[SPINNER_LABEL_INSIDE_COLOR]));
             
-            DrawText(FormatText("%i", value), labelBoxBound.x + (labelBoxBound.width/2 - textWidth/2), labelBoxBound.y + (labelBoxBound.height/2 - textHeight/2), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_PRESSED_TEXT_COLOR]));  
+            DrawText(FormatText("%i", value), labelBoxBound.x + (labelBoxBound.width/2 - textWidth/2), labelBoxBound.y + (labelBoxBound.height/2 - (style[GLOBAL_TEXT_FONTSIZE]/2)), style[GLOBAL_TEXT_FONTSIZE], GetColor(style[SPINNER_PRESSED_TEXT_COLOR]));  
         } break;
         default: break;
     }
+    
     return value;
 }
 
@@ -843,12 +845,12 @@ char *GuiTextBox(Rectangle bounds, char *text)
     {
         if (text[i] == '\0') break;
         
-        DrawText(FormatText("%c", text[i]), initPos, bounds.y + 5, style[TEXTBOX_TEXT_FONTSIZE], GetColor(style[TEXTBOX_TEXT_COLOR]));
+        DrawText(FormatText("%c", text[i]), initPos, bounds.y + style[TEXTBOX_TEXT_FONTSIZE], style[TEXTBOX_TEXT_FONTSIZE], GetColor(style[TEXTBOX_TEXT_COLOR]));
         
         initPos += ((GetDefaultFont().charRecs[(int)text[i] - 32].width + 2));
     }
 
-    if ((framesCounter/20)%2 && CheckCollisionPointRec(mousePoint, bounds)) DrawLine(initPos + 2, bounds.y, initPos + 2, bounds.y + 10 + 10, GetColor(style[TEXTBOX_LINE_COLOR]));
+    if ((framesCounter/20)%2 && CheckCollisionPointRec(mousePoint, bounds)) DrawLine(initPos + 2, bounds.y + 5, initPos + 2, bounds.y + 10 + 15, GetColor(style[TEXTBOX_LINE_COLOR]));
     //--------------------------------------------------------------------    
 
     return text;
diff --git a/src/raylib.h b/src/raylib.h
index d6b28e53..16311df8 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -308,17 +308,27 @@ typedef struct Camera {
     Vector3 up;
 } Camera;
 
+// Bounding box type
+typedef struct BoundingBox {
+    Vector3 min;
+    Vector3 max;
+} BoundingBox;
+
 // Vertex data definning a mesh
-// NOTE: If using OpenGL 1.1, data loaded in CPU; if OpenGL 3.3+ data loaded in GPU (vaoId)
-typedef struct VertexData {
-    int vertexCount;
-    float *vertices;            // 3 components per vertex
-    float *texcoords;           // 2 components per vertex
-    float *normals;             // 3 components per vertex
-    unsigned char *colors;      // 4 components per vertex
-    unsigned int vaoId;
-    unsigned int vboId[4];
-} VertexData;
+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)
+    
+    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)
+} Mesh;
 
 // Shader type (generic shader)
 typedef struct Shader {
@@ -336,8 +346,8 @@ typedef struct Shader {
     int colorLoc;         // Color attibute location point (vertex shader)
 
     // Uniforms
-    int projectionLoc;    // Projection matrix uniform location point (vertex shader)
-    int modelviewLoc;     // ModelView matrix uniform location point (vertex shader)
+    int mvpLoc;           // ModelView-Projection matrix uniform location point (vertex shader)
+    
     int modelLoc;         // Model transformation matrix uniform location point (vertex shader)
     int viewLoc;          // View transformation matrix uniform location point (vertex shader)
     int tintColorLoc;     // Color uniform location point (fragment shader)
@@ -349,7 +359,7 @@ typedef struct Shader {
 
 // 3d Model type
 typedef struct Model {
-    VertexData mesh;
+    Mesh mesh;
     Matrix transform;
     Texture2D texture;    // Only for OpenGL 1.1, on newer versions this should be in the shader
     Shader shader;
@@ -742,7 +752,7 @@ void DrawGizmo(Vector3 position);
 // Model 3d Loading and Drawing Functions (Module: models)
 //------------------------------------------------------------------------------------
 Model LoadModel(const char *fileName);                                                             // Load a 3d model (.OBJ)
-Model LoadModelEx(VertexData data);                                                                // Load a 3d model (from vertex data)
+Model LoadModelEx(Mesh data);                                                                      // Load a 3d model (from vertex data)
 //Model LoadModelFromRES(const char *rresName, int resId);                                         // TODO: Load a 3d model from rRES file (raylib Resource)
 Model LoadHeightmap(Image heightmap, float maxHeight);                                             // Load a heightmap image as a 3d model
 Model LoadCubicmap(Image cubicmap);                                                                // Load a map image as a 3d model (cubes based)
diff --git a/src/rlgl.c b/src/rlgl.c
index 2f525f47..ca08e1a2 100644
--- a/src/rlgl.c
+++ b/src/rlgl.c
@@ -821,10 +821,10 @@ void rlDeleteBuffers(unsigned int id)
 void rlClearColor(byte r, byte g, byte b, byte a)
 {
     // Color values clamp to 0.0f(0) and 1.0f(255)
-    float cr = (float)r / 255;
-    float cg = (float)g / 255;
-    float cb = (float)b / 255;
-    float ca = (float)a / 255;
+    float cr = (float)r/255;
+    float cg = (float)g/255;
+    float cb = (float)b/255;
+    float ca = (float)a/255;
 
     glClearColor(cr, cg, cb, ca);
 }
@@ -1100,24 +1100,24 @@ void rlglInitPostpro(void)
     if (postproFbo.id > 0)
     {
         // Create a simple quad model to render fbo texture
-        VertexData quadData;
+        Mesh quad;
         
-        quadData.vertexCount = 6;
+        quad.vertexCount = 6;
         
-        float w = screenWidth;
-        float h = screenHeight;
+        float w = (float)screenWidth;
+        float h = (float)screenHeight;
         
-        float quadPositions[6*3] = { w, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, h, 0.0, 0, h, 0.0, w, h, 0.0, w, 0.0, 0.0 }; 
-        float quadTexcoords[6*2] = { 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0 };
-        float quadNormals[6*3] = { 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0 };
+        float quadPositions[6*3] = { w, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, h, 0.0f, 0.0f, h, 0.0f, w, h, 0.0f, w, 0.0f, 0.0f }; 
+        float quadTexcoords[6*2] = { 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f };
+        float quadNormals[6*3] = { 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f };
         unsigned char quadColors[6*4] = { 255 };
         
-        quadData.vertices = quadPositions;
-        quadData.texcoords = quadTexcoords;
-        quadData.normals = quadNormals;
-        quadData.colors = quadColors;
+        quad.vertices = quadPositions;
+        quad.texcoords = quadTexcoords;
+        quad.normals = quadNormals;
+        quad.colors = quadColors;
         
-        postproQuad = rlglLoadModel(quadData);
+        postproQuad = rlglLoadModel(quad);
         
         // NOTE: postproFbo.colorTextureId must be assigned to postproQuad model shader
     }
@@ -1295,9 +1295,10 @@ void rlglDraw(void)
     if ((lines.vCounter > 0) || (triangles.vCounter > 0) || (quads.vCounter > 0))
     {
         glUseProgram(currentShader.id);
+        
+        Matrix matMVP = MatrixMultiply(modelview, projection);        // Create modelview-projection matrix
 
-        glUniformMatrix4fv(currentShader.projectionLoc, 1, false, MatrixToFloat(projection));
-        glUniformMatrix4fv(currentShader.modelviewLoc, 1, false, MatrixToFloat(modelview));
+        glUniformMatrix4fv(currentShader.mvpLoc, 1, false, MatrixToFloat(matMVP));
         glUniform1i(currentShader.mapDiffuseLoc, 0);
     }
 
@@ -1520,14 +1521,14 @@ void rlglDrawModel(Model model, Vector3 position, float rotationAngle, Vector3 r
     Matrix matModelView = MatrixMultiply(matModel, matView);            // Transform to camera-space coordinates
 
     // Calculate model-view-projection matrix (MVP)
-    //Matrix matMVP = MatrixMultiply(matModelView, matProjection);        // Transform to screen-space coordinates
+    Matrix matMVP = MatrixMultiply(matModelView, matProjection);        // Transform to screen-space coordinates
 
     // NOTE: Drawing in OpenGL 3.3+, matrices are passed to shader
     // TODO: Reduce number of matrices passed to shaders, use only matMVP
     glUniformMatrix4fv(model.shader.modelLoc, 1, false, MatrixToFloat(matModel));
     glUniformMatrix4fv(model.shader.viewLoc, 1, false, MatrixToFloat(matView));
-    glUniformMatrix4fv(model.shader.projectionLoc, 1, false, MatrixToFloat(matProjection));
-    glUniformMatrix4fv(model.shader.modelviewLoc, 1, false, MatrixToFloat(matModelView));
+    
+    glUniformMatrix4fv(model.shader.mvpLoc, 1, false, MatrixToFloat(matMVP));
 
     // Apply color tinting to model
     // NOTE: Just update one uniform on fragment shader
@@ -1666,7 +1667,7 @@ void rlglInitGraphics(int offsetX, int offsetY, int width, int height)
 // NOTE: Using global variables: screenWidth, screenHeight
 Vector3 rlglUnproject(Vector3 source, Matrix proj, Matrix view)
 {
-    Vector3 result = { 0, 0, 0 };   // Object coordinates
+    Vector3 result = { 0.0f, 0.0f, 0.0f };   // Object coordinates
     
     //GLint viewport[4];
     //glGetIntegerv(GL_VIEWPORT, viewport); // Not available on OpenGL ES 2.0
@@ -1697,11 +1698,11 @@ Vector3 rlglUnproject(Vector3 source, Matrix proj, Matrix view)
     quat.x = ((source.x - (float)x)/(float)width)*2.0f - 1.0f;
     quat.y = ((source.y - (float)y)/(float)height)*2.0f - 1.0f;
     quat.z = source.z*2.0f - 1.0f;
-    quat.w = 1.0;
+    quat.w = 1.0f;
     
     QuaternionTransform(&quat, modelviewprojection);
 
-    if (quat.w != 0.0)
+    if (quat.w != 0.0f)
     {
         quat.x /= quat.w;
         quat.y /= quat.w;
@@ -1981,7 +1982,7 @@ void rlglGenerateMipmaps(Texture2D texture)
 }
 
 // Load vertex data into a VAO (if supported) and VBO
-Model rlglLoadModel(VertexData mesh)
+Model rlglLoadModel(Mesh mesh)
 {
     Model model;
 
@@ -2170,7 +2171,7 @@ void *rlglReadTexturePixels(Texture2D texture)
     // Render texture to fbo
     glBindFramebuffer(GL_FRAMEBUFFER, fbo.id);
     
-    glClearColor(0.0, 0.0, 0.0, 0.0);
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     glClearDepthf(1.0f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glViewport(0, 0, width, height);
@@ -2188,7 +2189,7 @@ void *rlglReadTexturePixels(Texture2D texture)
     quad.transform = MatrixIdentity();
     quad.shader = simpleShader;
     
-    DrawModel(quad, (Vector3){ 0, 0, 0 }, 1.0f, WHITE);
+    DrawModel(quad, (Vector3){ 0.0f, 0.0f, 0.0f }, 1.0f, WHITE);
     
     pixels = (unsigned char *)malloc(texture.width*texture.height*3*sizeof(unsigned char));
     
@@ -2247,13 +2248,13 @@ Shader LoadShader(char *vsFileName, char *fsFileName)
             shader.colorLoc = -1;
 
             // Get handles to GLSL uniform locations (vertex shader)
-            shader.modelviewLoc  = glGetUniformLocation(shader.id, "modelviewMatrix");
+            shader.mvpLoc  = glGetUniformLocation(shader.id, "mvpMatrix");
+            
             shader.modelLoc  = glGetUniformLocation(shader.id, "modelMatrix");
             shader.viewLoc  = glGetUniformLocation(shader.id, "viewMatrix");
-            shader.projectionLoc = glGetUniformLocation(shader.id, "projectionMatrix");
 
             // Get handles to GLSL uniform locations (fragment shader)
-            shader.tintColorLoc = glGetUniformLocation(shader.id, "tintColor");
+            shader.tintColorLoc = glGetUniformLocation(shader.id, "fragTintColor");
             shader.mapDiffuseLoc = glGetUniformLocation(shader.id, "texture0");
             shader.mapNormalLoc = -1;       // It can be set later
             shader.mapSpecularLoc = -1;     // It can be set later
@@ -2738,40 +2739,39 @@ static Shader LoadDefaultShader(void)
         "in vec2 vertexTexCoord;            \n"
         "in vec4 vertexColor;               \n"
         "out vec2 fragTexCoord;             \n"
-        "out vec4 tintColor;                \n"
+        "out vec4 fragTintColor;                \n"
 #elif defined(GRAPHICS_API_OPENGL_ES2)
     char vShaderStr[] = "#version 100       \n"
         "attribute vec3 vertexPosition;     \n"
         "attribute vec2 vertexTexCoord;     \n"
         "attribute vec4 vertexColor;        \n"
         "varying vec2 fragTexCoord;         \n"
-        "varying vec4 tintColor;            \n"
+        "varying vec4 fragTintColor;        \n"
 #endif
-        "uniform mat4 projectionMatrix;     \n"
-        "uniform mat4 modelviewMatrix;      \n"
+        "uniform mat4 mvpMatrix;     \n"
         "void main()                        \n"
         "{                                  \n"
         "    fragTexCoord = vertexTexCoord; \n"
-        "    tintColor = vertexColor;       \n"
-        "    gl_Position = projectionMatrix*modelviewMatrix*vec4(vertexPosition, 1.0); \n"
+        "    fragTintColor = vertexColor;   \n"
+        "    gl_Position = mvpMatrix*vec4(vertexPosition, 1.0); \n"
         "}                                  \n";
 
     // Fragment shader directly defined, no external file required
 #if defined(GRAPHICS_API_OPENGL_33)
     char fShaderStr[] = "#version 330       \n"
         "in vec2 fragTexCoord;              \n"
-        "in vec4 tintColor;                 \n"
+        "in vec4 fragTintColor;                 \n"
 #elif defined(GRAPHICS_API_OPENGL_ES2)
     char fShaderStr[] = "#version 100       \n"
         "precision mediump float;           \n"     // precision required for OpenGL ES2 (WebGL)
         "varying vec2 fragTexCoord;         \n"
-        "varying vec4 tintColor;            \n"
+        "varying vec4 fragTintColor;        \n"
 #endif
         "uniform sampler2D texture0;        \n"
         "void main()                        \n"
         "{                                  \n"
         "    vec4 texelColor = texture2D(texture0, fragTexCoord); \n"   // NOTE: texture2D() is deprecated on OpenGL 3.3 and ES 3.0, use texture() instead
-        "    gl_FragColor = texelColor*tintColor; \n"    
+        "    gl_FragColor = texelColor*fragTintColor; \n"    
         "}                                  \n";
 
     shader.id = LoadShaderProgram(vShaderStr, fShaderStr);
@@ -2788,10 +2788,10 @@ static Shader LoadDefaultShader(void)
     shader.normalLoc = -1;
 
     // Get handles to GLSL uniform locations (vertex shader)
-    shader.modelviewLoc = glGetUniformLocation(shader.id, "modelviewMatrix");
+    shader.mvpLoc = glGetUniformLocation(shader.id, "mvpMatrix");
+    
     shader.modelLoc = glGetUniformLocation(shader.id, "modelMatrix");
     shader.viewLoc = glGetUniformLocation(shader.id, "viewMatrix");
-    shader.projectionLoc = glGetUniformLocation(shader.id, "projectionMatrix");
 
     // Get handles to GLSL uniform locations (fragment shader)
     shader.tintColorLoc = -1;
@@ -2831,12 +2831,11 @@ static Shader LoadSimpleShader(void)
         "attribute vec3 vertexNormal;       \n"
         "varying vec2 fragTexCoord;         \n"
 #endif
-        "uniform mat4 projectionMatrix;     \n"
-        "uniform mat4 modelviewMatrix;      \n"
+        "uniform mat4 mvpMatrix;            \n"
         "void main()                        \n"
         "{                                  \n"
         "    fragTexCoord = vertexTexCoord; \n"
-        "    gl_Position = projectionMatrix*modelviewMatrix*vec4(vertexPosition, 1.0); \n"
+        "    gl_Position = mvpMatrix*vec4(vertexPosition, 1.0); \n"
         "}                                  \n";
 
     // Fragment shader directly defined, no external file required
@@ -2849,11 +2848,11 @@ static Shader LoadSimpleShader(void)
         "varying vec2 fragTexCoord;         \n"
 #endif
         "uniform sampler2D texture0;        \n"
-        "uniform vec4 tintColor;            \n"
+        "uniform vec4 fragTintColor;        \n"
         "void main()                        \n"
         "{                                  \n"
         "    vec4 texelColor = texture2D(texture0, fragTexCoord); \n"   // NOTE: texture2D() is deprecated on OpenGL 3.3 and ES 3.0, use texture() instead
-        "    gl_FragColor = texelColor*tintColor; \n"
+        "    gl_FragColor = texelColor*fragTintColor; \n"
         "}                                  \n";
 
     shader.id = LoadShaderProgram(vShaderStr, fShaderStr);
@@ -2870,13 +2869,13 @@ static Shader LoadSimpleShader(void)
     shader.colorLoc = -1;
 
     // Get handles to GLSL uniform locations (vertex shader)
-    shader.modelviewLoc  = glGetUniformLocation(shader.id, "modelviewMatrix");
+    shader.mvpLoc  = glGetUniformLocation(shader.id, "mvpMatrix");
+    
     shader.modelLoc  = glGetUniformLocation(shader.id, "modelMatrix");
     shader.viewLoc  = glGetUniformLocation(shader.id, "viewMatrix");
-    shader.projectionLoc = glGetUniformLocation(shader.id, "projectionMatrix");
 
     // Get handles to GLSL uniform locations (fragment shader)
-    shader.tintColorLoc = glGetUniformLocation(shader.id, "tintColor");
+    shader.tintColorLoc = glGetUniformLocation(shader.id, "fragTintColor");
     shader.mapDiffuseLoc = glGetUniformLocation(shader.id, "texture0");
     shader.mapNormalLoc = -1;       // It can be set later
     shader.mapSpecularLoc = -1;     // It can be set later
@@ -3240,19 +3239,19 @@ static pixel *GenNextMipmap(pixel *srcData, int srcWidth, int srcHeight)
     int x2, y2;
     pixel prow, pcol;
 
-    int width = srcWidth / 2;
-    int height = srcHeight / 2;
+    int width = srcWidth/2;
+    int height = srcHeight/2;
 
     pixel *mipmap = (pixel *)malloc(width*height*sizeof(pixel));
 
     // Scaling algorithm works perfectly (box-filter)
     for (int y = 0; y < height; y++)
     {
-        y2 = 2 * y;
+        y2 = 2*y;
 
         for (int x = 0; x < width; x++)
         {
-            x2 = 2 * x;
+            x2 = 2*x;
 
             prow.r = (srcData[y2*srcWidth + x2].r + srcData[y2*srcWidth + x2 + 1].r)/2;
             prow.g = (srcData[y2*srcWidth + x2].g + srcData[y2*srcWidth + x2 + 1].g)/2;
diff --git a/src/rlgl.h b/src/rlgl.h
index 93b56bb2..066e0339 100644
--- a/src/rlgl.h
+++ b/src/rlgl.h
@@ -131,17 +131,22 @@ typedef enum { OPENGL_11 = 1, OPENGL_33, OPENGL_ES_20 } GlVersion;
         COMPRESSED_ASTC_8x8_RGBA        // 2 bpp
     } TextureFormat;
 
-    // VertexData type
+    // Mesh with vertex data type
     // NOTE: If using OpenGL 1.1, data loaded in CPU; if OpenGL 3.3+ data loaded in GPU (vaoId)
-    typedef struct VertexData {
-        int vertexCount;
-        float *vertices;            // 3 components per vertex
-        float *texcoords;           // 2 components per vertex
-        float *normals;             // 3 components per vertex
-        unsigned char *colors;
-        unsigned int vaoId;
-        unsigned int vboId[4];
-    } VertexData;
+    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)
+        
+        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)
+    } Mesh;
 
     // Shader type
     typedef struct Shader {
@@ -159,8 +164,8 @@ typedef enum { OPENGL_11 = 1, OPENGL_33, OPENGL_ES_20 } GlVersion;
         int colorLoc;         // Color attibute location point (vertex shader)
 
         // Uniforms
-        int projectionLoc;    // Projection matrix uniform location point (vertex shader)
-        int modelviewLoc;     // ModelView matrix uniform location point (vertex shader)
+        int mvpLoc;           // ModelView-Projection matrix uniform location point (vertex shader)
+    
         int modelLoc;         // Model transformation matrix uniform location point (vertex shader)
         int viewLoc;          // View transformation matrix uniform location point (vertex shader)
         int tintColorLoc;     // Color uniform location point (fragment shader)
@@ -179,7 +184,7 @@ typedef enum { OPENGL_11 = 1, OPENGL_33, OPENGL_ES_20 } GlVersion;
     
     // 3d Model type
     typedef struct Model {
-        VertexData mesh;
+        Mesh mesh;
         Matrix transform;
         Texture2D texture;
         Shader shader;
@@ -254,7 +259,7 @@ void rlglGenerateMipmaps(Texture2D texture);                             // Gene
 void rlglInitPostpro(void);                     // Initialize postprocessing system
 void rlglDrawPostpro(void);                     // Draw with postprocessing shader
 
-Model rlglLoadModel(VertexData mesh);           // Upload vertex data into GPU and provided VAO/VBO ids
+Model rlglLoadModel(Mesh mesh);           // Upload vertex data into GPU and provided VAO/VBO ids
 void rlglDrawModel(Model model, Vector3 position, float rotationAngle, Vector3 rotationAxis, Vector3 scale, Color color, bool wires);
 
 Vector3 rlglUnproject(Vector3 source, Matrix proj, Matrix view);    // Get world coordinates from screen coordinates
diff --git a/src/text.c b/src/text.c
index 1a75b9e4..3755932d 100644
--- a/src/text.c
+++ b/src/text.c
@@ -269,14 +269,14 @@ SpriteFont LoadSpriteFont(const char *fileName)
             spriteFont.texture = LoadTextureFromImage(image); // Convert loaded image to OpenGL texture
             spriteFont.size = spriteFont.charRecs[0].height;
             
-            defaultFont.charOffsets = (Vector2 *)malloc(defaultFont.numChars*sizeof(Vector2));
-            defaultFont.charAdvanceX = (int *)malloc(defaultFont.numChars*sizeof(int));
+            spriteFont.charOffsets = (Vector2 *)malloc(spriteFont.numChars*sizeof(Vector2));
+            spriteFont.charAdvanceX = (int *)malloc(spriteFont.numChars*sizeof(int));
             
-            for (int i = 0; i < defaultFont.numChars; i++)
+            for (int i = 0; i < spriteFont.numChars; i++)
             {
                 // NOTE: On image based fonts (XNA style), character offsets and xAdvance are not required (set to 0)
-                defaultFont.charOffsets[i] = (Vector2){ 0.0f, 0.0f };
-                defaultFont.charAdvanceX[i] = 0;
+                spriteFont.charOffsets[i] = (Vector2){ 0.0f, 0.0f };
+                spriteFont.charAdvanceX[i] = 0;
             }
         }
         else
@@ -308,7 +308,7 @@ void UnloadSpriteFont(SpriteFont spriteFont)
         free(spriteFont.charRecs);
         free(spriteFont.charOffsets);
         free(spriteFont.charAdvanceX);
-            
+
         TraceLog(INFO, "Unloaded sprite font data");
     }
 }
@@ -627,7 +627,7 @@ static SpriteFont LoadRBMF(const char *fileName)
         char charsDataType;     // Char data type provided
     } rbmfInfoHeader;
 
-    SpriteFont spriteFont;
+    SpriteFont spriteFont = { 0 };
 
     rbmfInfoHeader rbmfHeader;
     unsigned int *rbmfFileData = NULL;
@@ -695,6 +695,8 @@ static SpriteFont LoadRBMF(const char *fileName)
         // Get characters data using rbmfCharWidthData, rbmfHeader.charHeight, charsDivisor, rbmfHeader.numChars
         spriteFont.charValues = (int *)malloc(spriteFont.numChars*sizeof(int)); 
         spriteFont.charRecs = (Rectangle *)malloc(spriteFont.numChars*sizeof(Rectangle));
+        spriteFont.charOffsets = (Vector2 *)malloc(spriteFont.numChars*sizeof(Vector2));
+        spriteFont.charAdvanceX = (int *)malloc(spriteFont.numChars*sizeof(int));
 
         int currentLine = 0;
         int currentPosX = charsDivisor;
@@ -708,6 +710,10 @@ static SpriteFont LoadRBMF(const char *fileName)
             spriteFont.charRecs[i].y = charsDivisor + currentLine * ((int)rbmfHeader.charHeight + charsDivisor);
             spriteFont.charRecs[i].width = (int)rbmfCharWidthData[i];
             spriteFont.charRecs[i].height = (int)rbmfHeader.charHeight;
+            
+            // NOTE: On image based fonts (XNA style), character offsets and xAdvance are not required (set to 0)
+            spriteFont.charOffsets[i] = (Vector2){ 0.0f, 0.0f };
+            spriteFont.charAdvanceX[i] = 0;
 
             testPosX += (spriteFont.charRecs[i].width + charsDivisor);