WARNING: BIG rewrite of rlgl module

This commit implements a big update of rlgl module, intended to optimize some parts. This change could break some code bases... hopefully not, but it could.
The BIG changes to the module are:
 - Replaced LINES-TRIANGLES-QUADS buffers by a single one, now all vertex data is accumulated on a single buffer and managed with registered draw calls. LINES-TRIANGLES-QUADS could be used the same way as before, rlgl will manage them carefully. That's a big improvement of the system.
 - Support multi-buffering if required. Just define MAX_BATCH_BUFFERING desired size (currently set to 1 batch). Should be enough for most of the situations.
 - Removed temporal accumulative buffers for matrix transformations, now transformations are directly applied to vertex when on rlVertex3f()
 - Reviewed rlPushMatrix()/rlPopMatrix() to be consistent with OpenGL 1.1, probably I should remove that ancient behaviour but... well, it was not consistent and now it is.
 - Minor tweaks: LoadText(), I broke it in last update... also multiple comments reviewed.
 - TODO: MAX_BATCH_ELEMENTS checking should probably be reviewed... done some tests and it works but...

examples/models/models_billboard.c

@@ -28,7 +28,6 @@ int main()
     camera.fovy = 45.0f;
     camera.type = CAMERA_PERSPECTIVE;
     
-
     Texture2D bill = LoadTexture("resources/billboard.png");     // Our texture billboard
     Vector3 billPosition = { 0.0f, 2.0f, 0.0f };                 // Position where draw billboard
     
@@ -52,11 +51,11 @@ int main()
             ClearBackground(RAYWHITE);
 
             BeginMode3D(camera);
-            
-                DrawBillboard(camera, bill, billPosition, 2.0f, WHITE);
                 
                 DrawGrid(10, 1.0f);        // Draw a grid
-
+                
+                DrawBillboard(camera, bill, billPosition, 2.0f, WHITE);
+                
             EndMode3D();
 
             DrawFPS(10, 10);

examples/models/models_rlgl_solar_system.c

@@ -0,0 +1,156 @@
+/*******************************************************************************************
+*
+*   raylib [models] example - rlgl module usage with push/pop matrix transformations
+*
+*   This example has been created using raylib 2.2 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2018 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+#include "rlgl.h"
+
+
+void DrawSphereBasic(Color color);      // Draw sphere without any matrix transformation
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+    
+    const float sunRadius = 4.0f;
+    const float earthRadius = 0.6f;
+    const float earthOrbitRadius = 8.0f;
+    const float moonRadius = 0.16f;
+    const float moonOrbitRadius = 1.5f;
+
+    InitWindow(screenWidth, screenHeight, "raylib [models] example - rlgl module usage with push/pop matrix transformations");
+
+    // Define the camera to look into our 3d world
+    Camera camera = { 0 };
+    camera.position = (Vector3){ 16.0f, 16.0f, 16.0f };
+    camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
+    camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
+    camera.fovy = 45.0f;
+    camera.type = CAMERA_PERSPECTIVE;
+    
+    SetCameraMode(camera, CAMERA_FREE);
+       
+    float rotationSpeed = 0.2f;         // General system rotation speed
+    
+    float earthRotation = 0.0f;         // Rotation of earth around itself (days) in degrees
+    float earthOrbitRotation = 0.0f;    // Rotation of earth around the Sun (years) in degrees
+    float moonRotation = 0.0f;          // Rotation of moon around itself
+    float moonOrbitRotation = 0.0f;     // Rotation of moon around earth in degrees
+
+    SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateCamera(&camera);
+        
+        earthRotation += (5.0f*rotationSpeed);
+        earthOrbitRotation += (365/360.0f*(5.0f*rotationSpeed)*rotationSpeed);
+        moonRotation += (2.0f*rotationSpeed);
+        moonOrbitRotation += (8.0f*rotationSpeed);
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            BeginMode3D(camera);
+            
+                rlPushMatrix();
+                    rlScalef(sunRadius, sunRadius, sunRadius);          // Scale Sun
+                    DrawSphereBasic(GOLD);                              // Draw the Sun
+                rlPopMatrix();
+                
+                rlPushMatrix();
+                    rlRotatef(earthOrbitRotation, 0.0f, 1.0f, 0.0f);    // Rotation for Earth orbit around Sun
+                    rlTranslatef(earthOrbitRadius, 0.0f, 0.0f);         // Translation for Earth orbit
+                    rlRotatef(-earthOrbitRotation, 0.0f, 1.0f, 0.0f);   // Rotation for Earth orbit around Sun inverted
+
+                    rlPushMatrix();
+                        rlRotatef(earthRotation, 0.25, 1.0, 0.0);       // Rotation for Earth itself
+                        rlScalef(earthRadius, earthRadius, earthRadius);// Scale Earth
+                        
+                        DrawSphereBasic(BLUE);                          // Draw the Earth
+                    rlPopMatrix();
+                    
+                    rlRotatef(moonOrbitRotation, 0.0f, 1.0f, 0.0f);     // Rotation for Moon orbit around Earth
+                    rlTranslatef(moonOrbitRadius, 0.0f, 0.0f);          // Translation for Moon orbit
+                    rlRotatef(-moonOrbitRotation, 0.0f, 1.0f, 0.0f);    // Rotation for Moon orbit around Earth inverted
+                    rlRotatef(moonRotation, 0.0f, 1.0f, 0.0f);          // Rotation for Moon itself
+                    rlScalef(moonRadius, moonRadius, moonRadius);       // Scale Moon
+                    
+                    DrawSphereBasic(LIGHTGRAY);                         // Draw the Moon
+                rlPopMatrix();
+                
+                // Some reference elements (not affected by previous matrix transformations)
+                DrawCircle3D((Vector3){ 0.0f, 0.0f, 0.0f }, earthOrbitRadius, (Vector3){ 1, 0, 0 }, 90.0f, LIME);
+                DrawGrid(20, 1.0f);
+
+            EndMode3D();
+
+            DrawFPS(10, 10);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+// Draw sphere without any matrix transformation
+// NOTE: Sphere is drawn in world position ( 0, 0, 0 ) with radius 1.0f
+void DrawSphereBasic(Color color)
+{
+    int rings = 16;
+    int slices = 16;
+    
+    rlBegin(RL_TRIANGLES);
+        rlColor4ub(color.r, color.g, color.b, color.a);
+
+        for (int i = 0; i < (rings + 2); i++)
+        {
+            for (int j = 0; j < slices; j++)
+            {
+                rlVertex3f(cosf(DEG2RAD*(270+(180/(rings + 1))*i))*sinf(DEG2RAD*(j*360/slices)),
+                           sinf(DEG2RAD*(270+(180/(rings + 1))*i)),
+                           cosf(DEG2RAD*(270+(180/(rings + 1))*i))*cosf(DEG2RAD*(j*360/slices)));
+                rlVertex3f(cosf(DEG2RAD*(270+(180/(rings + 1))*(i+1)))*sinf(DEG2RAD*((j+1)*360/slices)),
+                           sinf(DEG2RAD*(270+(180/(rings + 1))*(i+1))),
+                           cosf(DEG2RAD*(270+(180/(rings + 1))*(i+1)))*cosf(DEG2RAD*((j+1)*360/slices)));
+                rlVertex3f(cosf(DEG2RAD*(270+(180/(rings + 1))*(i+1)))*sinf(DEG2RAD*(j*360/slices)),
+                           sinf(DEG2RAD*(270+(180/(rings + 1))*(i+1))),
+                           cosf(DEG2RAD*(270+(180/(rings + 1))*(i+1)))*cosf(DEG2RAD*(j*360/slices)));
+
+                rlVertex3f(cosf(DEG2RAD*(270+(180/(rings + 1))*i))*sinf(DEG2RAD*(j*360/slices)),
+                           sinf(DEG2RAD*(270+(180/(rings + 1))*i)),
+                           cosf(DEG2RAD*(270+(180/(rings + 1))*i))*cosf(DEG2RAD*(j*360/slices)));
+                rlVertex3f(cosf(DEG2RAD*(270+(180/(rings + 1))*(i)))*sinf(DEG2RAD*((j+1)*360/slices)),
+                           sinf(DEG2RAD*(270+(180/(rings + 1))*(i))),
+                           cosf(DEG2RAD*(270+(180/(rings + 1))*(i)))*cosf(DEG2RAD*((j+1)*360/slices)));
+                rlVertex3f(cosf(DEG2RAD*(270+(180/(rings + 1))*(i+1)))*sinf(DEG2RAD*((j+1)*360/slices)),
+                           sinf(DEG2RAD*(270+(180/(rings + 1))*(i+1))),
+                           cosf(DEG2RAD*(270+(180/(rings + 1))*(i+1)))*cosf(DEG2RAD*((j+1)*360/slices)));
+            }
+        }
+    rlEnd();
+}

examples/shapes/shapes_basic_shapes.c

@@ -39,26 +39,27 @@ int main()
 
             DrawText("some basic shapes available on raylib", 20, 20, 20, DARKGRAY);
 
-            DrawLine(18, 42, screenWidth - 18, 42, BLACK);
-
             DrawCircle(screenWidth/4, 120, 35, DARKBLUE);
-            DrawCircleGradient(screenWidth/4, 220, 60, GREEN, SKYBLUE);
-            DrawCircleLines(screenWidth/4, 340, 80, DARKBLUE);
 
             DrawRectangle(screenWidth/4*2 - 60, 100, 120, 60, RED);
+            DrawRectangleLines(screenWidth/4*2 - 40, 320, 80, 60, ORANGE);  // NOTE: Uses QUADS internally, not lines
             DrawRectangleGradientH(screenWidth/4*2 - 90, 170, 180, 130, MAROON, GOLD);
-            DrawRectangleLines(screenWidth/4*2 - 40, 320, 80, 60, ORANGE);
 
             DrawTriangle((Vector2){screenWidth/4*3, 80},
                          (Vector2){screenWidth/4*3 - 60, 150},
                          (Vector2){screenWidth/4*3 + 60, 150}, VIOLET);
 
+            DrawPoly((Vector2){screenWidth/4*3, 320}, 6, 80, 0, BROWN);
+
+            DrawCircleGradient(screenWidth/4, 220, 60, GREEN, SKYBLUE);
+
+            // NOTE: We draw all LINES based shapes together to optimize internal drawing,
+            // this way, all LINES are rendered in a single draw pass
+            DrawLine(18, 42, screenWidth - 18, 42, BLACK);
+            DrawCircleLines(screenWidth/4, 340, 80, DARKBLUE);
             DrawTriangleLines((Vector2){screenWidth/4*3, 160},
                               (Vector2){screenWidth/4*3 - 20, 230},
                               (Vector2){screenWidth/4*3 + 20, 230}, DARKBLUE);
-
-            DrawPoly((Vector2){screenWidth/4*3, 320}, 6, 80, 0, BROWN);
-
         EndDrawing();
         //----------------------------------------------------------------------------------
     }

src/config.h

@@ -25,7 +25,7 @@
 *
 **********************************************************************************************/
 
-#define RAYLIB_VERSION  "2.1-dev"
+#define RAYLIB_VERSION  "2.2-dev"
 
 // Edit to control what features Makefile'd raylib is compiled with
 #if defined(RAYLIB_CMAKE)