Merge branch 'raysan5:master' into master

examples/models/models_rlgl_solar_system.c

@@ -14,6 +14,8 @@
 #include "raylib.h"
 #include "rlgl.h"
 
+#include <math.h>           // Required for: cosf(), sinf()
+
 //------------------------------------------------------------------------------------
 // Module Functions Declaration
 //------------------------------------------------------------------------------------

examples/others/raylib_opengl_interop.c

@@ -2,7 +2,7 @@
 *
 *   raylib [shaders] example - OpenGL point particle system
 *
-*   This example has been created using raylib 2ad3eb1 (www.raylib.com)
+*   This example has been created using raylib 3.8 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
 *   Example contributed by Stephan Soller (@arkanis -  http://arkanis.de/)
@@ -24,8 +24,9 @@
 ********************************************************************************************/
 
 #include "raylib.h"
-#include "rlgl.h"
+#include "rlgl.h"           // Required for: rlDrawRenderBatchActive(), rlGetMatrixModelview(), rlGetMatrixProjection()
-#include "glad.h"
+#include "glad.h"           // Required for: OpenGL functionality 
+#include "raymath.h"        // Required for: MatrixMultiply(), MatrixToFloat()
 
 #if defined(PLATFORM_DESKTOP)
     #define GLSL_VERSION            330
@@ -33,6 +34,15 @@
     #define GLSL_VERSION            100
 #endif
 
+#define MAX_PARTICLES       1000
+
+// Particle type
+typedef struct Particle {
+    float x;
+    float y;
+    float period;
+} Particle;
+
 int main()
 {
     // Initialization
@@ -42,32 +52,34 @@ int main()
 
     InitWindow(screenWidth, screenHeight, "raylib - point particles");
 
-    Shader shader = LoadShader(
+    Shader shader = LoadShader(TextFormat("resources/shaders/glsl%i/point_particle.vs", GLSL_VERSION),
-        TextFormat("resources/shaders/glsl%i/point_particle.vs", GLSL_VERSION),
+                               TextFormat("resources/shaders/glsl%i/point_particle.fs", GLSL_VERSION));
-        TextFormat("resources/shaders/glsl%i/point_particle.fs", GLSL_VERSION));
+
     int currentTimeLoc = GetShaderLocation(shader, "currentTime");
     int colorLoc = GetShaderLocation(shader, "color");
 
     // Initialize the vertex buffer for the particles and assign each particle random values
-    struct { float x, y, period; } particles[10000];
+    Particle particles[MAX_PARTICLES] = { 0 };
-    const size_t particleCount = sizeof(particles) / sizeof(particles[0]);
+
-    for (size_t i = 0; i < particleCount; i++)
+    for (int i = 0; i < MAX_PARTICLES; i++)
     {
-        particles[i].x = GetRandomValue(20, screenWidth - 20);
+        particles[i].x = (float)GetRandomValue(20, screenWidth - 20);
-        particles[i].y = GetRandomValue(50, screenHeight - 20);
+        particles[i].y = (float)GetRandomValue(50, screenHeight - 20);
-        // Give each particle a slightly different period. But don't spread it to much. This way the particles line up
+        
-        // every so often and you get a glimps of what is going on.
+        // Give each particle a slightly different period. But don't spread it to much. 
-        particles[i].period = GetRandomValue(10, 30) / 10.0f;
+        // This way the particles line up every so often and you get a glimps of what is going on.
+        particles[i].period = (float)GetRandomValue(10, 30)/10.0f;
     }
 
-    // Create a plain OpenGL vertex buffer with the data and an vertex array object that feeds the data from the buffer
+    // Create a plain OpenGL vertex buffer with the data and an vertex array object 
-    // into the vertexPosition shader attribute.
+    // that feeds the data from the buffer into the vertexPosition shader attribute.
-    GLuint vao = 0, vbo = 0;
+    GLuint vao = 0;
+    GLuint vbo = 0;
     glGenVertexArrays(1, &vao);
     glBindVertexArray(vao);
         glGenBuffers(1, &vbo);
         glBindBuffer(GL_ARRAY_BUFFER, vbo);
-        glBufferData(GL_ARRAY_BUFFER, sizeof(particles), particles, GL_STATIC_DRAW);
+        glBufferData(GL_ARRAY_BUFFER, MAX_PARTICLES*sizeof(Particle), particles, GL_STATIC_DRAW);
         // Note: LoadShader() automatically fetches the attribute index of "vertexPosition" and saves it in shader.locs[SHADER_LOC_VERTEX_POSITION]
         glVertexAttribPointer(shader.locs[SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, GL_FALSE, 0, 0);
         glEnableVertexAttribArray(0);
@@ -89,32 +101,33 @@ int main()
             ClearBackground(WHITE);
 
             DrawRectangle(10, 10, 210, 30, MAROON);
-            DrawText(TextFormat("%zu particles in one vertex buffer", particleCount), 20, 20, 10, RAYWHITE);
+            DrawText(TextFormat("%zu particles in one vertex buffer", MAX_PARTICLES), 20, 20, 10, RAYWHITE);
+            
+            rlDrawRenderBatchActive();      // Draw iternal buffers data (previous draw calls)
 
             // Switch to plain OpenGL
             //------------------------------------------------------------------------------
-            // rlglDraw() in raylib 3.5
-            rlDrawRenderBatchActive();
             glUseProgram(shader.id);
+            
                 glUniform1f(currentTimeLoc, GetTime());
 
                 Vector4 color = ColorNormalize((Color){ 255, 0, 0, 128 });
-                glUniform4fv(colorLoc, 1, (float*)&color);
+                glUniform4fv(colorLoc, 1, (float *)&color);
 
-                // The the current model view projection matrix so the particle system is displayed and transformed
+                // Get the current modelview and projection matrix so the particle system is displayed and transformed
-                // (e.g. by cameras) just like everything else.
-                // GetMatrixModelview() and GetMatrixProjection() in raylib 3.5
                 Matrix modelViewProjection = MatrixMultiply(rlGetMatrixModelview(), rlGetMatrixProjection());
+                
                 glUniformMatrix4fv(shader.locs[SHADER_LOC_MATRIX_MVP], 1, false, MatrixToFloat(modelViewProjection));
 
                 glBindVertexArray(vao);
-                    glDrawArrays(GL_POINTS, 0, particleCount);
+                    glDrawArrays(GL_POINTS, 0, MAX_PARTICLES);
                 glBindVertexArray(0);
+                
             glUseProgram(0);
-
-            // And back to raylib again
             //------------------------------------------------------------------------------
+            
             DrawFPS(screenWidth - 100, 10);
+            
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -124,8 +137,9 @@ int main()
     glDeleteBuffers(1, &vbo);
     glDeleteVertexArrays(1, &vao);
 
-    UnloadShader(shader);
+    UnloadShader(shader);   // Unload shader
-    CloseWindow();        // Close window and OpenGL context
+
+    CloseWindow();          // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
     return 0;

examples/others/rlgl_standalone.c

@@ -48,6 +48,16 @@
 *
 ********************************************************************************************/
 
+// NOTE: rlgl can be configured just re-defining the following values:
+//#define RL_DEFAULT_BATCH_BUFFER_ELEMENTS   8192    // Default internal render batch elements limits
+//#define RL_DEFAULT_BATCH_BUFFERS              1    // Default number of batch buffers (multi-buffering)
+//#define RL_DEFAULT_BATCH_DRAWCALLS          256    // Default number of batch draw calls (by state changes: mode, texture)
+//#define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS    4    // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
+//#define RL_MAX_MATRIX_STACK_SIZE             32    // Maximum size of internal Matrix stack
+//#define RL_MAX_SHADER_LOCATIONS              32    // Maximum number of shader locations supported
+//#define RL_CULL_DISTANCE_NEAR              0.01    // Default projection matrix near cull distance
+//#define RL_CULL_DISTANCE_FAR             1000.0    // Default projection matrix far cull distance
+
 #define RLGL_IMPLEMENTATION
 #include "rlgl.h"               // OpenGL abstraction layer to OpenGL 1.1, 3.3+ or ES2
 
@@ -57,7 +67,6 @@
 #if defined(__EMSCRIPTEN__)
     #define GLFW_INCLUDE_ES2
 #endif
-
 #include "GLFW/glfw3.h"         // Windows/Context and inputs management
 
 #include <stdio.h>              // Required for: printf()

src/config.h

@@ -91,22 +91,17 @@
 // Show OpenGL extensions and capabilities detailed logs on init
 //#define SUPPORT_GL_DETAILS_INFO        1
 
-#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
+//#define RL_DEFAULT_BATCH_BUFFER_ELEMENTS    4096    // Default internal render batch elements limits
-    #define DEFAULT_BATCH_BUFFER_ELEMENTS   8192    // Default internal render batch limits
+#define RL_DEFAULT_BATCH_BUFFERS               1      // Default number of batch buffers (multi-buffering)
-#elif defined(GRAPHICS_API_OPENGL_ES2)
+#define RL_DEFAULT_BATCH_DRAWCALLS           256      // Default number of batch draw calls (by state changes: mode, texture)
-    #define DEFAULT_BATCH_BUFFER_ELEMENTS   2048    // Default internal render batch limits
+#define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS     4      // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
-#endif
 
-#define DEFAULT_BATCH_BUFFERS            1      // Default number of batch buffers (multi-buffering)
+#define RL_MAX_MATRIX_STACK_SIZE              32      // Maximum size of internal Matrix stack
-#define DEFAULT_BATCH_DRAWCALLS        256      // Default number of batch draw calls (by state changes: mode, texture)
 
-#define MAX_MATRIX_STACK_SIZE           32      // Maximum size of internal Matrix stack
+#define RL_MAX_SHADER_LOCATIONS               32      // Maximum number of shader locations supported
-#define MAX_MESH_VERTEX_BUFFERS          7      // Maximum vertex buffers (VBO) per mesh
-#define MAX_SHADER_LOCATIONS            32      // Maximum number of shader locations supported
-#define MAX_MATERIAL_MAPS               12      // Maximum number of shader maps supported
 
-#define RL_CULL_DISTANCE_NEAR         0.01      // Default projection matrix near cull distance
+#define RL_CULL_DISTANCE_NEAR               0.01      // Default projection matrix near cull distance
-#define RL_CULL_DISTANCE_FAR        1000.0      // Default projection matrix far cull distance
+#define RL_CULL_DISTANCE_FAR              1000.0      // Default projection matrix far cull distance
 
 // Default shader vertex attribute names to set location points
 // NOTE: When a new shader is loaded, the following locations are tried to be set for convenience
@@ -195,6 +190,10 @@
 // NOTE: Some generated meshes DO NOT include generated texture coordinates
 #define SUPPORT_MESH_GENERATION     1
 
+// models: Configuration values
+//------------------------------------------------------------------------------------
+#define MAX_MATERIAL_MAPS               12      // Maximum number of shader maps supported
+#define MAX_MESH_VERTEX_BUFFERS          7      // Maximum vertex buffers (VBO) per mesh
 
 //------------------------------------------------------------------------------------
 // Module: audio - Configuration Flags

src/core.c

@@ -2333,10 +2333,10 @@ Shader LoadShader(const char *vsFileName, const char *fsFileName)
 RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode)
 {
     Shader shader = { 0 };
-    shader.locs = (int *)RL_CALLOC(MAX_SHADER_LOCATIONS, sizeof(int));
+    shader.locs = (int *)RL_CALLOC(RL_MAX_SHADER_LOCATIONS, sizeof(int));
 
     // NOTE: All locations must be reseted to -1 (no location)
-    for (int i = 0; i < MAX_SHADER_LOCATIONS; i++) shader.locs[i] = -1;
+    for (int i = 0; i < RL_MAX_SHADER_LOCATIONS; i++) shader.locs[i] = -1;
 
     shader.id = rlLoadShaderCode(vsCode, fsCode);
 

src/models.c

@@ -92,7 +92,12 @@
 //----------------------------------------------------------------------------------
 // Defines and Macros
 //----------------------------------------------------------------------------------
-// ...
+#ifndef MAX_MATERIAL_MAPS
+    #define MAX_MATERIAL_MAPS       12    // Maximum number of maps supported
+#endif
+#ifndef MAX_MESH_VERTEX_BUFFERS
+    #define MAX_MESH_VERTEX_BUFFERS  7    // Maximum vertex buffers (VBO) per mesh
+#endif
 
 //----------------------------------------------------------------------------------
 // Types and Structures Definition

src/raylib.h

@@ -102,9 +102,12 @@
 #ifndef PI
     #define PI 3.14159265358979323846f
 #endif
-
+#ifndef DEG2RAD
-#define DEG2RAD (PI/180.0f)
+    #define DEG2RAD (PI/180.0f)
-#define RAD2DEG (180.0f/PI)
+#endif
+#ifndef RAD2DEG
+    #define RAD2DEG (180.0f/PI)
+#endif
 
 // Allow custom memory allocators
 #ifndef RL_MALLOC
@@ -184,6 +187,7 @@
     #include <stdbool.h>
 #elif !defined(__cplusplus) && !defined(bool)
     typedef enum bool { false, true } bool;
+    #define RL_BOOL_TYPE
 #endif
 
 // Vector2, 2 components
@@ -344,7 +348,7 @@ typedef struct Mesh {
 // Shader
 typedef struct Shader {
     unsigned int id;        // Shader program id
-    int *locs;              // Shader locations array (MAX_SHADER_LOCATIONS)
+    int *locs;              // Shader locations array (RL_MAX_SHADER_LOCATIONS)
 } Shader;
 
 // MaterialMap

src/rlgl.h

@@ -1,14 +1,23 @@
 /**********************************************************************************************
 *
-*   rlgl v4.0 - OpenGL abstraction layer
+*   rlgl v4.0
 *
-*   rlgl is a wrapper for multiple OpenGL versions (1.1, 2.1, 3.3 Core, ES 2.0) to
+*   An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, ES 2.0)
-*   pseudo-OpenGL 1.1 style functions (rlVertex, rlTranslate, rlRotate...).
+*   that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...)
+*
+*   When chosing an OpenGL backend different than OpenGL 1.1, some internal buffer are
+*   initialized on rlglInit() to accumulate vertex data.
+*
+*   When an internal state change is required all the stored vertex data is renderer in batch,
+*   additioanlly, rlDrawRenderBatchActive() could be called to force flushing of the batch.
+*
+*   Some additional resources are also loaded for convenience, here the complete list:
+*      - Default batch (RLGL.defaultBatch): RenderBatch system to accumulate vertex data
+*      - Default texture (RLGL.defaultTextureId): 1x1 white pixel R8G8B8A8
+*      - Default shader (RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs)
+*
+*   Internal buffer (and additional resources) must be manually unloaded calling rlglClose().
 *
-*   When chosing an OpenGL version greater than OpenGL 1.1, rlgl stores vertex data on internal
-*   VBO buffers (and VAOs if available). It requires calling 3 functions:
-*       rlglInit()  - Initialize internal buffers and auxiliary resources
-*       rlglClose() - De-initialize internal buffers data and other auxiliar resources
 *
 *   CONFIGURATION:
 *
@@ -32,8 +41,42 @@
 *   #define SUPPORT_GL_DETAILS_INFO
 *       Show OpenGL extensions and capabilities detailed logs on init
 *
+*   rlgl capabilities could be customized just defining some internal 
+*   values before library inclusion (default values listed):
+*
+*   #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS   8192    // Default internal render batch elements limits
+*   #define RL_DEFAULT_BATCH_BUFFERS              1    // Default number of batch buffers (multi-buffering)
+*   #define RL_DEFAULT_BATCH_DRAWCALLS          256    // Default number of batch draw calls (by state changes: mode, texture)
+*   #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS    4    // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
+*
+*   #define RL_MAX_MATRIX_STACK_SIZE             32    // Maximum size of internal Matrix stack
+*   #define RL_MAX_SHADER_LOCATIONS              32    // Maximum number of shader locations supported
+*   #define RL_CULL_DISTANCE_NEAR              0.01    // Default projection matrix near cull distance
+*   #define RL_CULL_DISTANCE_FAR             1000.0    // Default projection matrix far cull distance
+*
+*   When loading a shader, the following vertex attribute and uniform 
+*   location names are tried to be set automatically:
+*
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Binded by default to shader location: 0
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Binded by default to shader location: 1
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL       "vertexNormal"      // Binded by default to shader location: 2
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR        "vertexColor"       // Binded by default to shader location: 3
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT      "vertexTangent"     // Binded by default to shader location: 4
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Binded by default to shader location: 5
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP         "mvp"               // model-view-projection matrix
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW        "matView"           // view matrix
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION  "matProjection"     // projection matrix
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL       "matModel"          // model matrix
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL      "matNormal"         // normal matrix (transpose(inverse(matModelView))
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR       "colDiffuse"        // color diffuse (base tint color, multiplied by texture color)
+*   #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0  "texture0"          // texture0 (texture slot active 0)
+*   #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1  "texture1"          // texture1 (texture slot active 1)
+*   #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2  "texture2"          // texture2 (texture slot active 2)
+*
 *   DEPENDENCIES:
-*       GLAD        - OpenGL extensions loading (OpenGL 3.3 Core only)
+*
+*      - OpenGL libraries (depending on platform and OpenGL version selected)
+*      - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core)
 *
 *
 *   LICENSE: zlib/libpng
@@ -124,54 +167,47 @@
 //----------------------------------------------------------------------------------
 // Defines and Macros
 //----------------------------------------------------------------------------------
-// Default internal render batch limits
+
-#ifndef DEFAULT_BATCH_BUFFER_ELEMENTS
+// Default internal render batch elements limits
+#ifndef RL_DEFAULT_BATCH_BUFFER_ELEMENTS
     #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
         // This is the maximum amount of elements (quads) per batch
         // NOTE: Be careful with text, every letter maps to a quad
-        #define DEFAULT_BATCH_BUFFER_ELEMENTS   8192
+        #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS   8192
     #endif
     #if defined(GRAPHICS_API_OPENGL_ES2)
         // We reduce memory sizes for embedded systems (RPI and HTML5)
         // NOTE: On HTML5 (emscripten) this is allocated on heap,
         // by default it's only 16MB!...just take care...
-        #define DEFAULT_BATCH_BUFFER_ELEMENTS   2048
+        #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS   2048
     #endif
 #endif
-#ifndef DEFAULT_BATCH_BUFFERS
+#ifndef RL_DEFAULT_BATCH_BUFFERS
-    #define DEFAULT_BATCH_BUFFERS            1      // Default number of batch buffers (multi-buffering)
+    #define RL_DEFAULT_BATCH_BUFFERS            1      // Default number of batch buffers (multi-buffering)
 #endif
-#ifndef DEFAULT_BATCH_DRAWCALLS
+#ifndef RL_DEFAULT_BATCH_DRAWCALLS
-    #define DEFAULT_BATCH_DRAWCALLS        256      // Default number of batch draw calls (by state changes: mode, texture)
+    #define RL_DEFAULT_BATCH_DRAWCALLS        256      // Default number of batch draw calls (by state changes: mode, texture)
 #endif
-#ifndef MAX_BATCH_ACTIVE_TEXTURES
+#ifndef RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS
-    #define MAX_BATCH_ACTIVE_TEXTURES        4      // Maximum number of additional textures that can be activated on batch drawing (SetShaderValueTexture())
+    #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS  4      // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
 #endif
 
 // Internal Matrix stack
-#ifndef MAX_MATRIX_STACK_SIZE
+#ifndef RL_MAX_MATRIX_STACK_SIZE
-    #define MAX_MATRIX_STACK_SIZE           32      // Maximum size of Matrix stack
+    #define RL_MAX_MATRIX_STACK_SIZE           32      // Maximum size of Matrix stack
 #endif
 
-// Vertex buffers id limit
+// Shader limits
-#ifndef MAX_MESH_VERTEX_BUFFERS
+#ifndef RL_MAX_SHADER_LOCATIONS
-    #define MAX_MESH_VERTEX_BUFFERS          7      // Maximum vertex buffers (VBO) per mesh
+    #define RL_MAX_SHADER_LOCATIONS            32      // Maximum number of shader locations supported
-#endif
-
-// Shader and material limits
-#ifndef MAX_SHADER_LOCATIONS
-    #define MAX_SHADER_LOCATIONS            32      // Maximum number of shader locations supported
-#endif
-#ifndef MAX_MATERIAL_MAPS
-    #define MAX_MATERIAL_MAPS               12      // Maximum number of shader maps supported
 #endif
 
 // Projection matrix culling
 #ifndef RL_CULL_DISTANCE_NEAR
-    #define RL_CULL_DISTANCE_NEAR         0.01      // Default near cull distance
+    #define RL_CULL_DISTANCE_NEAR            0.01      // Default near cull distance
 #endif
 #ifndef RL_CULL_DISTANCE_FAR
-    #define RL_CULL_DISTANCE_FAR        1000.0      // Default far cull distance
+    #define RL_CULL_DISTANCE_FAR           1000.0      // Default far cull distance
 #endif
 
 // Texture parameters (equivalent to OpenGL defines)
@@ -291,7 +327,7 @@ typedef struct rlRenderBatch {
 
 #if defined(__STDC__) && __STDC_VERSION__ >= 199901L
     #include <stdbool.h>
-#elif !defined(__cplusplus) && !defined(bool)
+#elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE)
     // Boolean type
     typedef enum bool { false, true } bool;
 #endif
@@ -617,15 +653,6 @@ RLAPI void rlLoadDrawQuad(void);     // Load and draw a quad
 
 #if defined(RLGL_IMPLEMENTATION)
 
-// Check if config flags have been externally provided on compilation line
-#if !defined(EXTERNAL_CONFIG_FLAGS)
-    #include "config.h"                 // Defines module configuration flags
-#endif
-
-#include <stdlib.h>                     // Required for: malloc(), free()
-#include <string.h>                     // Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading]
-#include <math.h>                       // Required for: sqrtf(), sinf(), cosf(), floor(), log()
-
 #if defined(GRAPHICS_API_OPENGL_11)
     #if defined(__APPLE__)
         #include <OpenGL/gl.h>          // OpenGL 1.1 library for OSX
@@ -676,6 +703,10 @@ RLAPI void rlLoadDrawQuad(void);     // Load and draw a quad
     #endif
 #endif
 
+#include <stdlib.h>                     // Required for: malloc(), free()
+#include <string.h>                     // Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading]
+#include <math.h>                       // Required for: sqrtf(), sinf(), cosf(), floor(), log()
+
 //----------------------------------------------------------------------------------
 // Defines and Macros
 //----------------------------------------------------------------------------------
@@ -814,11 +845,11 @@ typedef struct rlglData {
         Matrix projection;                // Default projection matrix
         Matrix transform;                 // Transform matrix to be used with rlTranslate, rlRotate, rlScale
         bool transformRequired;             // Require transform matrix application to current draw-call vertex (if required)
-        Matrix stack[MAX_MATRIX_STACK_SIZE];// Matrix stack for push/pop
+        Matrix stack[RL_MAX_MATRIX_STACK_SIZE];// Matrix stack for push/pop
         int stackCounter;                   // Matrix stack counter
 
         unsigned int defaultTextureId;      // Default texture used on shapes/poly drawing (required by shader)
-        unsigned int activeTextureId[MAX_BATCH_ACTIVE_TEXTURES];    // Active texture ids to be enabled on batch drawing (0 active by default)
+        unsigned int activeTextureId[RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS];    // Active texture ids to be enabled on batch drawing (0 active by default)
         unsigned int defaultVShaderId;      // Default vertex shader id (used by default shader program)
         unsigned int defaultFShaderId;      // Default fragment shader id (used by default shader program)
         unsigned int defaultShaderId;       // Default shader program id, supports vertex color and diffuse texture
@@ -886,8 +917,8 @@ static PFNGLVERTEXATTRIBDIVISOREXTPROC glVertexAttribDivisor = NULL;
 // Module specific Functions Declaration
 //----------------------------------------------------------------------------------
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
-static void rlLoadShaderDefault(void);      // Load default shader (RLGL.State.defaultShader)
+static void rlLoadShaderDefault(void);      // Load default shader
-static void rlUnloadShaderDefault(void);    // Unload default shader (RLGL.State.defaultShader)
+static void rlUnloadShaderDefault(void);    // Unload default shader
 #if defined(SUPPORT_GL_DETAILS_INFO)
 static char *rlGetCompressedFormatName(int format); // Get compressed format official GL identifier name
 #endif  // SUPPORT_GL_DETAILS_INFO
@@ -951,7 +982,7 @@ void rlMatrixMode(int mode)
 // Push the current matrix into RLGL.State.stack
 void rlPushMatrix(void)
 {
-    if (RLGL.State.stackCounter >= MAX_MATRIX_STACK_SIZE) TRACELOG(RL_LOG_ERROR, "RLGL: Matrix stack overflow (MAX_MATRIX_STACK_SIZE)");
+    if (RLGL.State.stackCounter >= RL_MAX_MATRIX_STACK_SIZE) TRACELOG(RL_LOG_ERROR, "RLGL: Matrix stack overflow (RL_MAX_MATRIX_STACK_SIZE)");
 
     if (RLGL.State.currentMatrixMode == RL_MODELVIEW)
     {
@@ -1197,7 +1228,7 @@ void rlBegin(int mode)
             }
         }
 
-        if (RLGL.currentBatch->drawsCounter >= DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch);
+        if (RLGL.currentBatch->drawsCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch);
 
         RLGL.currentBatch->draws[RLGL.currentBatch->drawsCounter - 1].mode = mode;
         RLGL.currentBatch->draws[RLGL.currentBatch->drawsCounter - 1].vertexCount = 0;
@@ -1388,7 +1419,7 @@ void rlSetTexture(unsigned int id)
                 }
             }
 
-            if (RLGL.currentBatch->drawsCounter >= DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch);
+            if (RLGL.currentBatch->drawsCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch);
 
             RLGL.currentBatch->draws[RLGL.currentBatch->drawsCounter - 1].textureId = id;
             RLGL.currentBatch->draws[RLGL.currentBatch->drawsCounter - 1].vertexCount = 0;
@@ -1712,11 +1743,11 @@ void rlglInit(int width, int height)
     RLGL.State.currentShaderLocs = RLGL.State.defaultShaderLocs;
 
     // Init default vertex arrays buffers
-    RLGL.defaultBatch = rlLoadRenderBatch(DEFAULT_BATCH_BUFFERS, DEFAULT_BATCH_BUFFER_ELEMENTS);
+    RLGL.defaultBatch = rlLoadRenderBatch(RL_DEFAULT_BATCH_BUFFERS, RL_DEFAULT_BATCH_BUFFER_ELEMENTS);
     RLGL.currentBatch = &RLGL.defaultBatch;
 
     // Init stack matrices (emulating OpenGL 1.1)
-    for (int i = 0; i < MAX_MATRIX_STACK_SIZE; i++) RLGL.State.stack[i] = rlMatrixIdentity();
+    for (int i = 0; i < RL_MAX_MATRIX_STACK_SIZE; i++) RLGL.State.stack[i] = rlMatrixIdentity();
 
     // Init internal matrices
     RLGL.State.transform = rlMatrixIdentity();
@@ -2183,9 +2214,9 @@ rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements)
 
     // Init draw calls tracking system
     //--------------------------------------------------------------------------------------------
-    batch.draws = (rlDrawCall *)RL_MALLOC(DEFAULT_BATCH_DRAWCALLS*sizeof(rlDrawCall));
+    batch.draws = (rlDrawCall *)RL_MALLOC(RL_DEFAULT_BATCH_DRAWCALLS*sizeof(rlDrawCall));
 
-    for (int i = 0; i < DEFAULT_BATCH_DRAWCALLS; i++)
+    for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++)
     {
         batch.draws[i].mode = RL_QUADS;
         batch.draws[i].vertexCount = 0;
@@ -2357,7 +2388,7 @@ void rlDrawRenderBatch(rlRenderBatch *batch)
 
             // Activate additional sampler textures
             // Those additional textures will be common for all draw calls of the batch
-            for (int i = 0; i < MAX_BATCH_ACTIVE_TEXTURES; i++)
+            for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++)
             {
                 if (RLGL.State.activeTextureId[i] > 0)
                 {
@@ -2422,7 +2453,7 @@ void rlDrawRenderBatch(rlRenderBatch *batch)
     RLGL.State.modelview = matModelView;
 
     // Reset RLGL.currentBatch->draws array
-    for (int i = 0; i < DEFAULT_BATCH_DRAWCALLS; i++)
+    for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++)
     {
         batch->draws[i].mode = RL_QUADS;
         batch->draws[i].vertexCount = 0;
@@ -2430,7 +2461,7 @@ void rlDrawRenderBatch(rlRenderBatch *batch)
     }
 
     // Reset active texture units for next batch
-    for (int i = 0; i < MAX_BATCH_ACTIVE_TEXTURES; i++) RLGL.State.activeTextureId[i] = 0;
+    for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) RLGL.State.activeTextureId[i] = 0;
 
     // Reset draws counter to one draw for the batch
     batch->drawsCounter = 1;
@@ -3571,11 +3602,11 @@ void rlSetUniformSampler(int locIndex, unsigned int textureId)
 {
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
     // Check if texture is already active
-    for (int i = 0; i < MAX_BATCH_ACTIVE_TEXTURES; i++) if (RLGL.State.activeTextureId[i] == textureId) return;
+    for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) if (RLGL.State.activeTextureId[i] == textureId) return;
 
     // Register a new active texture for the internal batch system
     // NOTE: Default texture is always activated as GL_TEXTURE0
-    for (int i = 0; i < MAX_BATCH_ACTIVE_TEXTURES; i++)
+    for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++)
     {
         if (RLGL.State.activeTextureId[i] == 0)
         {
@@ -3883,13 +3914,13 @@ const char *rlGetPixelFormatName(unsigned int format)
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 // Load default shader (just vertex positioning and texture coloring)
 // NOTE: This shader program is used for internal buffers
-// NOTE: It uses global variable: RLGL.State.defaultShader
+// NOTE: Loaded: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs
 static void rlLoadShaderDefault(void)
 {
-    RLGL.State.defaultShaderLocs = (int *)RL_CALLOC(MAX_SHADER_LOCATIONS, sizeof(int));
+    RLGL.State.defaultShaderLocs = (int *)RL_CALLOC(RL_MAX_SHADER_LOCATIONS, sizeof(int));
 
     // NOTE: All locations must be reseted to -1 (no location)
-    for (int i = 0; i < MAX_SHADER_LOCATIONS; i++) RLGL.State.defaultShaderLocs[i] = -1;
+    for (int i = 0; i < RL_MAX_SHADER_LOCATIONS; i++) RLGL.State.defaultShaderLocs[i] = -1;
 
     // Vertex shader directly defined, no external file required
     const char *defaultVShaderCode =
@@ -3988,7 +4019,7 @@ static void rlLoadShaderDefault(void)
 }
 
 // Unload default shader
-// NOTE: It uses global variable: RLGL.State.defaultShader
+// NOTE: Unloads: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs
 static void rlUnloadShaderDefault(void)
 {
     glUseProgram(0);

src/text.c

@@ -266,7 +266,7 @@ extern void LoadFontDefault(void)
 
     defaultFont.baseSize = (int)defaultFont.recs[0].height;
 
-    TRACELOG(LOG_INFO, "FONT: Default font loaded successfully");
+    TRACELOG(LOG_INFO, "FONT: [ID %i] Default font texture loaded successfully", defaultFont.texture.id);
 }
 
 // Unload raylib default font