Updated some code

examples/oculus_glfw_sample/oculus_glfw_sample.c

@@ -28,7 +28,7 @@
 #include <GLFW/glfw3.h>         // Windows/Context and inputs management
 
 #define RLGL_STANDALONE
-#include "rlgl.h"
+#include "rlgl.h"               // rlgl library: OpenGL 1.1 immediate-mode style coding
 
 #define PLATFORM_OCULUS
 
@@ -79,14 +79,11 @@ typedef struct OculusLayer {
 } OculusLayer;
 #endif
 
-typedef enum { LOG_INFO = 0, LOG_ERROR, LOG_WARNING, LOG_DEBUG, LOG_OTHER } TraceLogType;
-
 //----------------------------------------------------------------------------------
 // Module specific Functions Declaration
 //----------------------------------------------------------------------------------
 static void ErrorCallback(int error, const char* description);
 static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
-static void TraceLog(int msgType, const char *text, ...);
 
 // Drawing functions (uses rlgl functionality)
 static void DrawGrid(int slices, float spacing);
@@ -125,10 +122,10 @@ int main(void)
     
     if (!glfwInit())
     {
-        TraceLog(LOG_WARNING, "GLFW3: Can not initialize GLFW");
-        exit(EXIT_FAILURE);
+        TraceLog(WARNING, "GLFW3: Can not initialize GLFW");
+        return 1;
     }
-    else TraceLog(LOG_INFO, "GLFW3: GLFW initialized successfully");
+    else TraceLog(INFO, "GLFW3: GLFW initialized successfully");
     
     glfwWindowHint(GLFW_DEPTH_BITS, 16);
     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
@@ -141,9 +138,9 @@ int main(void)
     if (!window)
     {
         glfwTerminate();
-        exit(EXIT_FAILURE);
+        return 2;
     }
-    else TraceLog(LOG_INFO, "GLFW3: Window created successfully");
+    else TraceLog(INFO, "GLFW3: Window created successfully");
     
     glfwSetKeyCallback(window, KeyCallback);
     
@@ -153,10 +150,10 @@ int main(void)
     // Load OpenGL 3.3 extensions
     if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
     {
-        TraceLog(LOG_WARNING, "GLAD: Cannot load OpenGL extensions");
-        exit(1);
+        TraceLog(WARNING, "GLAD: Cannot load OpenGL extensions");
+        return 3;
     }
-    else TraceLog(LOG_INFO, "GLAD: OpenGL extensions loaded successfully");
+    else TraceLog(INFO, "GLAD: OpenGL extensions loaded successfully");
     //--------------------------------------------------------
     
 #if defined(PLATFORM_OCULUS)
@@ -198,7 +195,6 @@ int main(void)
     rlClearColor(245, 245, 245, 255);   // Define clear color
     rlEnableDepthTest();                // Enable DEPTH_TEST for 3D
     
-    Vector2 size = { 200, 200 };
     Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
     
     Camera camera;
@@ -257,8 +253,8 @@ int main(void)
             Matrix matProj = MatrixPerspective(camera.fovy, (double)screenWidth/(double)screenHeight, 0.01, 1000.0);
             MatrixTranspose(&matProj);
 			
-			SetMatrixModelview(matView);    // Replace internal modelview matrix by a custom one
-			SetMatrixProjection(matProj);   // Replace internal projection matrix by a custom one
+            SetMatrixModelview(matView);    // Replace internal modelview matrix by a custom one
+            SetMatrixProjection(matProj);   // Replace internal projection matrix by a custom one
 #endif
             DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
             DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, RAYWHITE);
@@ -332,7 +328,7 @@ int main(void)
 // GLFW3: Error callback
 static void ErrorCallback(int error, const char* description)
 {
-    TraceLog(LOG_ERROR, description);
+    TraceLog(ERROR, description);
 }
 
 // GLFW3: Keyboard callback
@@ -344,29 +340,6 @@ static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, i
     }
 }
 
-// Output a trace log message
-static void TraceLog(int msgType, const char *text, ...)
-{
-    va_list args;
-    va_start(args, text);
-
-    switch(msgType)
-    {
-        case LOG_INFO: fprintf(stdout, "INFO: "); break;
-        case LOG_ERROR: fprintf(stdout, "ERROR: "); break;
-        case LOG_WARNING: fprintf(stdout, "WARNING: "); break;
-        case LOG_DEBUG: fprintf(stdout, "DEBUG: "); break;
-        default: break;
-    }
-
-    vfprintf(stdout, text, args);
-    fprintf(stdout, "\n");
-
-    va_end(args);
-
-    //if (msgType == LOG_ERROR) exit(1);
-}
-
 // Draw rectangle using rlgl OpenGL 1.1 style coding (translated to OpenGL 3.3 internally)
 static void DrawRectangleV(Vector2 position, Vector2 size, Color color)
 {

examples/oculus_glfw_sample/raylib_rlgl_standalone.c

@@ -18,30 +18,23 @@
 *
 ********************************************************************************************/
 
-#define GLAD_IMPLEMENTATION
 #include "glad.h"               // Extensions loading library
 #include <GLFW/glfw3.h>         // Windows/Context and inputs management
 
 #define RLGL_STANDALONE
-#include "rlgl.h"
+#include "rlgl.h"               // rlgl library: OpenGL 1.1 immediate-mode style coding
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
 
 #define RED        (Color){ 230, 41, 55, 255 }     // Red
 #define MAROON     (Color){ 190, 33, 55, 255 }     // Maroon
 #define RAYWHITE   (Color){ 245, 245, 245, 255 }   // My own White (raylib logo)
 #define DARKGRAY   (Color){ 80, 80, 80, 255 }      // Dark Gray
-//----------------------------------------------------------------------------------
-typedef enum { LOG_INFO = 0, LOG_ERROR, LOG_WARNING, LOG_DEBUG, LOG_OTHER } TraceLogType;
 
 //----------------------------------------------------------------------------------
 // Module specific Functions Declaration
 //----------------------------------------------------------------------------------
 static void ErrorCallback(int error, const char* description);
 static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
-static void TraceLog(int msgType, const char *text, ...);
 
 // Drawing functions (uses rlgl functionality)
 static void DrawGrid(int slices, float spacing);
@@ -66,10 +59,10 @@ int main(void)
     
     if (!glfwInit())
     {
-        TraceLog(LOG_WARNING, "GLFW3: Can not initialize GLFW");
-        exit(EXIT_FAILURE);
+        TraceLog(WARNING, "GLFW3: Can not initialize GLFW");
+        return 1;
     }
-    else TraceLog(LOG_INFO, "GLFW3: GLFW initialized successfully");
+    else TraceLog(INFO, "GLFW3: GLFW initialized successfully");
     
     glfwWindowHint(GLFW_SAMPLES, 4);
     glfwWindowHint(GLFW_DEPTH_BITS, 16);
@@ -83,9 +76,9 @@ int main(void)
     if (!window)
     {
         glfwTerminate();
-        exit(EXIT_FAILURE);
+        return 2;
     }
-    else TraceLog(LOG_INFO, "GLFW3: Window created successfully");
+    else TraceLog(INFO, "GLFW3: Window created successfully");
     
     glfwSetKeyCallback(window, KeyCallback);
     
@@ -95,10 +88,10 @@ int main(void)
     // Load OpenGL 3.3 extensions
     if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
     {
-        TraceLog(LOG_WARNING, "GLAD: Cannot load OpenGL extensions");
-        exit(1);
+        TraceLog(WARNING, "GLAD: Cannot load OpenGL extensions");
+        return 3;
     }
-    else TraceLog(LOG_INFO, "GLAD: OpenGL extensions loaded successfully");
+    else TraceLog(INFO, "GLAD: OpenGL extensions loaded successfully");
     //--------------------------------------------------------
     
     // Initialize rlgl internal buffers and OpenGL state
@@ -107,7 +100,6 @@ int main(void)
     rlClearColor(245, 245, 245, 255);   // Define clear color
     rlEnableDepthTest();                // Enable DEPTH_TEST for 3D
     
-    Vector2 size = { 200, 200 };
     Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
     
     Camera camera;
@@ -128,29 +120,45 @@ int main(void)
         // Draw
         //----------------------------------------------------------------------------------
         rlClearScreenBuffers();             // Clear current framebuffer
+        
             // Calculate projection matrix (from perspective) and view matrix from camera look at
             Matrix matProj = MatrixPerspective(camera.fovy, (double)screenWidth/(double)screenHeight, 0.01, 1000.0);
             MatrixTranspose(&matProj);
             Matrix matView = MatrixLookAt(camera.position, camera.target, camera.up);
-            Matrix mvp = MatrixMultiply(matView, matProj);
+
+            SetMatrixModelview(matView);    // Replace internal modelview matrix by a custom one
+            SetMatrixProjection(matProj);   // Replace internal projection matrix by a custom one
 
             DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
             DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, RAYWHITE);
             DrawGrid(10, 1.0f);
 
             // NOTE: Internal buffers drawing (3D data)
-            rlglDraw(mvp);
+            rlglDraw();
             
+            // Draw '2D' elements in the scene (GUI)
+#define RLGL_CREATE_MATRIX_MANUALLY
+#if defined(RLGL_CREATE_MATRIX_MANUALLY)
+
             matProj = MatrixOrtho(0.0, screenWidth, screenHeight, 0.0, 0.0, 1.0);
             MatrixTranspose(&matProj);
             matView = MatrixIdentity();
-            mvp = MatrixMultiply(matView, matProj);
             
-            // TODO: 2D drawing on Oculus Rift: requires an ovrLayerQuad layer
-            DrawRectangleV((Vector2){ 10.0f, 10.0f }, (Vector2){ 300.0f, 20.0f }, DARKGRAY);
+            SetMatrixModelview(matView);    // Replace internal modelview matrix by a custom one
+            SetMatrixProjection(matProj);   // Replace internal projection matrix by a custom one
+
+#else   // Let rlgl generate and multiply matrix internally
+
+            rlMatrixMode(RL_PROJECTION);                            // Enable internal projection matrix
+            rlLoadIdentity();                                       // Reset internal projection matrix
+            rlOrtho(0.0, screenWidth, screenHeight, 0.0, 0.0, 1.0); // Recalculate internal projection matrix
+            rlMatrixMode(RL_MODELVIEW);                             // Enable internal modelview matrix
+            rlLoadIdentity();                                       // Reset internal modelview matrix
+#endif
+            DrawRectangleV((Vector2){ 10.0f, 10.0f }, (Vector2){ 600.0f, 20.0f }, DARKGRAY);
 
             // NOTE: Internal buffers drawing (2D data)
-            rlglDraw(mvp);
+            rlglDraw();
             
         glfwSwapBuffers(window);
         glfwPollEvents();
@@ -163,7 +171,6 @@ int main(void)
     
     glfwDestroyWindow(window);
     glfwTerminate();
-    
     //--------------------------------------------------------------------------------------
     
     return 0;
@@ -176,7 +183,7 @@ int main(void)
 // GLFW3: Error callback
 static void ErrorCallback(int error, const char* description)
 {
-    TraceLog(LOG_ERROR, description);
+    TraceLog(ERROR, description);
 }
 
 // GLFW3: Keyboard callback
@@ -188,29 +195,6 @@ static void KeyCallback(GLFWwindow* window, int key, int scancode, int action, i
     }
 }
 
-// Output a trace log message
-static void TraceLog(int msgType, const char *text, ...)
-{
-    va_list args;
-    va_start(args, text);
-
-    switch(msgType)
-    {
-        case LOG_INFO: fprintf(stdout, "INFO: "); break;
-        case LOG_ERROR: fprintf(stdout, "ERROR: "); break;
-        case LOG_WARNING: fprintf(stdout, "WARNING: "); break;
-        case LOG_DEBUG: fprintf(stdout, "DEBUG: "); break;
-        default: break;
-    }
-
-    vfprintf(stdout, text, args);
-    fprintf(stdout, "\n");
-
-    va_end(args);
-
-    //if (msgType == LOG_ERROR) exit(1);
-}
-
 // Draw rectangle using rlgl OpenGL 1.1 style coding (translated to OpenGL 3.3 internally)
 static void DrawRectangleV(Vector2 position, Vector2 size, Color color)
 {

examples/oculus_glfw_sample/raymath.h

@@ -151,7 +151,6 @@ RMDEF Matrix MatrixFrustum(double left, double right, double bottom, double top,
 RMDEF Matrix MatrixPerspective(double fovy, double aspect, double near, double far);                        // Returns perspective projection matrix
 RMDEF Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far);    // Returns orthographic projection matrix
 RMDEF Matrix MatrixLookAt(Vector3 position, Vector3 target, Vector3 up);  // Returns camera look-at matrix (view matrix)
-RMDEF void PrintMatrix(Matrix m);                             // Print matrix utility
 
 //------------------------------------------------------------------------------------
 // Functions Declaration to work with Quaternions
@@ -178,9 +177,7 @@ RMDEF void QuaternionTransform(Quaternion *q, Matrix mat);            // Transfo
 
 #if defined(RAYMATH_IMPLEMENTATION) || defined(RAYMATH_EXTERN_INLINE)
 
-#include <stdio.h>      // Used only on PrintMatrix()
-#include <math.h>       // Standard math libary: sin(), cos(), tan()...
-#include <stdlib.h>     // Used for abs()
+#include <math.h>       // Required for: sinf(), cosf(), tan(), fabs()
 
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Vector3 math
@@ -342,15 +339,14 @@ RMDEF Vector3 VectorReflect(Vector3 vector, Vector3 normal)
     return result;
 }
 
-// Transforms a Vector3 with a given Matrix
+// Transforms a Vector3 by a given Matrix
+// TODO: Review math (matrix transpose required?)
 RMDEF void VectorTransform(Vector3 *v, Matrix mat)
 {
     float x = v->x;
     float y = v->y;
     float z = v->z;
 
-    //MatrixTranspose(&mat);
-
     v->x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12;
     v->y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13;
     v->z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14;
@@ -871,17 +867,6 @@ RMDEF Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up)
     return result;
 }
 
-// Print matrix utility (for debug)
-RMDEF void PrintMatrix(Matrix m)
-{
-    printf("----------------------\n");
-    printf("%2.2f %2.2f %2.2f %2.2f\n", m.m0, m.m4, m.m8, m.m12);
-    printf("%2.2f %2.2f %2.2f %2.2f\n", m.m1, m.m5, m.m9, m.m13);
-    printf("%2.2f %2.2f %2.2f %2.2f\n", m.m2, m.m6, m.m10, m.m14);
-    printf("%2.2f %2.2f %2.2f %2.2f\n", m.m3, m.m7, m.m11, m.m15);
-    printf("----------------------\n");
-}
-
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Quaternion math
 //----------------------------------------------------------------------------------

examples/oculus_glfw_sample/rlgl.c

@@ -48,7 +48,13 @@
     #ifdef __APPLE__ 
         #include <OpenGL/gl3.h>     // OpenGL 3 library for OSX
     #else
-        #include "glad.h"           // GLAD library, includes OpenGL headers
+    #define GLAD_IMPLEMENTATION
+#if defined(RLGL_STANDALONE)
+    #include "glad.h"               // GLAD extensions loading library, includes OpenGL headers
+#else
+    #include "external/glad.h"      // GLAD extensions loading library, includes OpenGL headers
+#endif
+
     #endif
 #endif
 
@@ -62,6 +68,10 @@
     #include <stdarg.h>             // Required for: va_list, va_start(), vfprintf(), va_end() [Used only on TraceLog()]
 #endif
 
+#if !defined(GRAPHICS_API_OPENGL_11)
+    #include "standard_shader.h"    // Standard shader to embed
+#endif
+
 //----------------------------------------------------------------------------------
 // Defines and Macros
 //----------------------------------------------------------------------------------
@@ -154,10 +164,6 @@ typedef struct {
     // TODO: Store draw state -> blending mode, shader
 } DrawCall;
 
-#if defined(RLGL_STANDALONE)
-typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType;
-#endif
-
 //----------------------------------------------------------------------------------
 // Global Variables Definition
 //----------------------------------------------------------------------------------
@@ -189,26 +195,27 @@ static bool useTempBuffer = false;
 
 // Shader Programs
 static Shader defaultShader;
-static Shader standardShader;
-static Shader currentShader;            // By default, defaultShader
+static Shader standardShader;               // Lazy initialization when GetStandardShader()
+static Shader currentShader;                // By default, defaultShader
+static bool standardShaderLoaded = false;   
 
 // Flags for supported extensions
-static bool vaoSupported = false;   // VAO support (OpenGL ES2 could not support VAO extension)
+static bool vaoSupported = false;           // VAO support (OpenGL ES2 could not support VAO extension)
 
 // Compressed textures support flags
-static bool texCompETC1Supported = false;    // ETC1 texture compression support
-static bool texCompETC2Supported = false;    // ETC2/EAC texture compression support
-static bool texCompPVRTSupported = false;    // PVR texture compression support
-static bool texCompASTCSupported = false;    // ASTC texture compression support
+static bool texCompETC1Supported = false;   // ETC1 texture compression support
+static bool texCompETC2Supported = false;   // ETC2/EAC texture compression support
+static bool texCompPVRTSupported = false;   // PVR texture compression support
+static bool texCompASTCSupported = false;   // ASTC texture compression support
 
 // Lighting data
-static Light lights[MAX_LIGHTS];             // Lights pool
-static int lightsCount;                      // Counts current enabled physic objects
+static Light lights[MAX_LIGHTS];            // Lights pool
+static int lightsCount;                     // Counts current enabled physic objects
 #endif
 
 // Compressed textures support flags
-static bool texCompDXTSupported = false;     // DDS texture compression support
-static bool npotSupported = false;           // NPOT textures full support
+static bool texCompDXTSupported = false;    // DDS texture compression support
+static bool npotSupported = false;          // NPOT textures full support
 
 #if defined(GRAPHICS_API_OPENGL_ES2)
 // NOTE: VAO functionality is exposed through extensions (OES)
@@ -253,7 +260,6 @@ static Color *GenNextMipmap(Color *srcData, int srcWidth, int srcHeight);
 #endif
 
 #if defined(RLGL_STANDALONE)
-static void TraceLog(int msgType, const char *text, ...);
 float *MatrixToFloat(Matrix mat);           // Converts Matrix to float array
 #endif
 
@@ -355,7 +361,6 @@ void rlRotatef(float angleDeg, float x, float y, float z)
     Vector3 axis = (Vector3){ x, y, z };
     VectorNormalize(&axis);
     matRotation = MatrixRotate(axis, angleDeg*DEG2RAD);
-
     MatrixTranspose(&matRotation);
 
     *currentMatrix = MatrixMultiply(*currentMatrix, matRotation);
@@ -1032,7 +1037,6 @@ void rlglInit(void)
 
     // Init default Shader (customized for GL 3.3 and ES2)
     defaultShader = LoadDefaultShader();
-    standardShader = LoadStandardShader();
     currentShader = defaultShader;
 
     LoadDefaultBuffers();        // Initialize default vertex arrays buffers (lines, triangles, quads)
@@ -2185,14 +2189,22 @@ Shader GetDefaultShader(void)
 }
 
 // Get default shader
+// NOTE: Inits global variable standardShader
 Shader GetStandardShader(void)
 {
-#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
-    return standardShader;
-#else
     Shader shader = { 0 };
-    return shader;
+    
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+    if (standardShaderLoaded) shader = standardShader;
+    else
+    {
+        // Lazy initialization of standard shader
+        standardShader = LoadStandardShader();
+        shader = standardShader;
+    }
 #endif
+
+    return shader;
 }
 
 // Get shader uniform location
@@ -2254,13 +2266,17 @@ void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat)
 // Set a custom projection matrix (replaces internal projection matrix)
 void SetMatrixProjection(Matrix proj)
 {
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
     projection = proj;
+#endif
 }
 
 // Set a custom modelview matrix (replaces internal modelview matrix)
 void SetMatrixModelview(Matrix view)
 {
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
     modelview = view;
+#endif
 }
 
 // Begin blending mode (alpha, additive, multiplied)
@@ -2564,18 +2580,28 @@ static Shader LoadDefaultShader(void)
 
 // Load standard shader
 // NOTE: This shader supports: 
-//      - Up to 3 different maps: diffuse, normal, specular
-//      - Material properties: colAmbient, colDiffuse, colSpecular, glossiness
-//      - Up to 8 lights: Point, Directional or Spot
+//     - Up to 3 different maps: diffuse, normal, specular
+//     - Material properties: colAmbient, colDiffuse, colSpecular, glossiness
+//     - Up to 8 lights: Point, Directional or Spot
 static Shader LoadStandardShader(void)
 {
-    // Load standard shader (TODO: rewrite as char pointers)
-    Shader shader = { 0 }; //LoadShader("resources/shaders/standard.vs", "resources/shaders/standard.fs");
-
-    if (shader.id != 0) TraceLog(INFO, "[SHDR ID %i] Standard shader loaded successfully", shader.id);
-    else TraceLog(WARNING, "[SHDR ID %i] Standard shader could not be loaded", shader.id);
+    Shader shader;
+    
+    // Load standard shader (embeded in standard_shader.h)
+    shader.id = LoadShaderProgram(vStandardShaderStr, fStandardShaderStr);
 
-    if (shader.id != 0) LoadDefaultShaderLocations(&shader);
+    if (shader.id != 0)
+    {
+        LoadDefaultShaderLocations(&shader);
+        TraceLog(INFO, "[SHDR ID %i] Standard shader loaded successfully", shader.id);
+        
+        standardShaderLoaded = true;
+    }
+    else
+    {
+        TraceLog(WARNING, "[SHDR ID %i] Standard shader could not be loaded, using default shader", shader.id);
+        shader = GetDefaultShader();
+    }
 
     return shader;
 }
@@ -3318,7 +3344,7 @@ static Color *GenNextMipmap(Color *srcData, int srcWidth, int srcHeight)
 #if defined(RLGL_STANDALONE)
 // Output a trace log message
 // NOTE: Expected msgType: (0)Info, (1)Error, (2)Warning
-static void TraceLog(int msgType, const char *text, ...)
+void TraceLog(int msgType, const char *text, ...)
 {
     va_list args;
     va_start(args, text);

examples/oculus_glfw_sample/rlgl.h

@@ -230,6 +230,9 @@ typedef enum { OPENGL_11 = 1, OPENGL_33, OPENGL_ES_20 } GlVersion;
 
     // Color blending modes (pre-defined)
     typedef enum { BLEND_ALPHA = 0, BLEND_ADDITIVE, BLEND_MULTIPLIED } BlendMode;
+    
+    // TraceLog message types
+    typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType;
 #endif
 
 #ifdef __cplusplus
@@ -339,6 +342,8 @@ void EndBlendMode(void);                                            // End blend
 
 Light CreateLight(int type, Vector3 position, Color diffuse);       // Create a new light, initialize it and add to pool
 void DestroyLight(Light light);                                     // Destroy a light and take it out of the list
+
+void TraceLog(int msgType, const char *text, ...);
 #endif
 
 #ifdef __cplusplus

examples/oculus_glfw_sample/standard_shader.h

@@ -0,0 +1,166 @@
+
+// Vertex shader definition to embed, no external file required
+const static unsigned char vStandardShaderStr[] = 
+#if defined(GRAPHICS_API_OPENGL_21)
+"#version 120                       \n"
+#elif defined(GRAPHICS_API_OPENGL_ES2)
+"#version 100                       \n"
+#endif
+#if defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_21)
+"attribute vec3 vertexPosition;     \n"
+"attribute vec3 vertexNormal;       \n"
+"attribute vec2 vertexTexCoord;     \n"
+"attribute vec4 vertexColor;        \n"
+"varying vec3 fragPosition;         \n"
+"varying vec3 fragNormal;           \n"
+"varying vec2 fragTexCoord;         \n"
+"varying vec4 fragColor;            \n"
+#elif defined(GRAPHICS_API_OPENGL_33)
+"#version 330                       \n"
+"in vec3 vertexPosition;            \n"
+"in vec3 vertexNormal;              \n"
+"in vec2 vertexTexCoord;            \n"
+"in vec4 vertexColor;               \n"
+"out vec3 fragPosition;             \n"
+"out vec3 fragNormal;               \n"
+"out vec2 fragTexCoord;             \n"
+"out vec4 fragColor;                \n"
+#endif
+"uniform mat4 mvpMatrix;            \n"
+"void main()                        \n"
+"{                                  \n"
+"    fragPosition = vertexPosition; \n"
+"    fragNormal = vertexNormal;     \n"
+"    fragTexCoord = vertexTexCoord; \n"
+"    fragColor = vertexColor;       \n"
+"    gl_Position = mvpMatrix*vec4(vertexPosition, 1.0); \n"
+"}                                  \n";
+
+// Fragment shader definition to embed, no external file required
+const static unsigned char fStandardShaderStr[] = 
+#if defined(GRAPHICS_API_OPENGL_21)
+"#version 120                       \n"
+#elif defined(GRAPHICS_API_OPENGL_ES2)
+"#version 100                       \n"
+"precision mediump float;           \n"     // precision required for OpenGL ES2 (WebGL)
+#endif
+#if defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_21)
+"varying vec3 fragPosition;         \n"
+"varying vec3 fragNormal;           \n"
+"varying vec2 fragTexCoord;         \n"
+"varying vec4 fragColor;            \n"
+#elif defined(GRAPHICS_API_OPENGL_33)
+"#version 330                       \n"
+"in vec3 fragPosition;              \n"
+"in vec3 fragNormal;                \n"
+"in vec2 fragTexCoord;              \n"
+"in vec4 fragColor;                 \n"
+"out vec4 finalColor;               \n"
+#endif
+"uniform sampler2D texture0;        \n"
+"uniform sampler2D texture1;        \n"
+"uniform sampler2D texture2;        \n"
+"uniform vec4 colAmbient;           \n"
+"uniform vec4 colDiffuse;           \n"
+"uniform vec4 colSpecular;          \n"
+"uniform float glossiness;          \n"
+"uniform int useNormal;             \n"
+"uniform int useSpecular;           \n"
+"uniform mat4 modelMatrix;          \n"
+"uniform vec3 viewDir;              \n"
+"struct Light {                     \n"
+"    int enabled;                   \n"
+"    int type;                      \n"
+"    vec3 position;                 \n"
+"    vec3 direction;                \n"
+"    vec4 diffuse;                  \n"
+"    float intensity;               \n"
+"    float radius;                  \n"
+"    float coneAngle; };            \n"
+"const int maxLights = 8;           \n"
+"uniform int lightsCount;           \n"
+"uniform Light lights[maxLights];   \n"
+"\n"  
+"vec3 CalcPointLight(Light l, vec3 n, vec3 v, float s)   \n"
+"{\n"
+"    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));\n"
+"    vec3 surfaceToLight = l.position - surfacePos;\n"
+"    float brightness = clamp(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n)), 0, 1);\n"
+"    float diff = 1.0/dot(surfaceToLight/l.radius, surfaceToLight/l.radius)*brightness*l.intensity;\n"
+"    float spec = 0.0;\n"
+"    if (diff > 0.0)\n"
+"    {\n"
+"        vec3 h = normalize(-l.direction + v);\n"
+"        spec = pow(dot(n, h), 3 + glossiness)*s;\n"
+"    }\n"
+"    return (diff*l.diffuse.rgb + spec*colSpecular.rgb);\n"
+"}\n"
+"\n"
+"vec3 CalcDirectionalLight(Light l, vec3 n, vec3 v, float s)\n"
+"{\n"
+"    vec3 lightDir = normalize(-l.direction);\n"
+"    float diff = clamp(dot(n, lightDir), 0.0, 1.0)*l.intensity;\n"
+"    float spec = 0.0;\n"
+"    if (diff > 0.0)\n"
+"    {\n"
+"        vec3 h = normalize(lightDir + v);\n"
+"        spec = pow(dot(n, h), 3 + glossiness)*s;\n"
+"    }\n"
+"    return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);\n"
+"}\n"
+"\n"
+"vec3 CalcSpotLight(Light l, vec3 n, vec3 v, float s)\n"
+"{\n"
+"    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));\n"
+"    vec3 lightToSurface = normalize(surfacePos - l.position);\n"
+"    vec3 lightDir = normalize(-l.direction);\n"
+"    float diff = clamp(dot(n, lightDir), 0.0, 1.0)*l.intensity;\n"
+"    float attenuation = clamp(dot(n, lightToSurface), 0.0, 1.0);\n"
+"    attenuation = dot(lightToSurface, -lightDir);\n"
+"    float lightToSurfaceAngle = degrees(acos(attenuation));\n"
+"    if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;\n"
+"    float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;\n"
+"    float diffAttenuation = diff*attenuation;\n"
+"    float spec = 0.0;\n"
+"    if (diffAttenuation > 0.0)\n"
+"    {\n"
+"        vec3 h = normalize(lightDir + v);\n"
+"        spec = pow(dot(n, h), 3 + glossiness)*s;\n"
+"    }\n"
+"    return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));\n"
+"}\n"
+"\n"
+"void main()\n"
+"{\n"
+"    mat3 normalMatrix = transpose(inverse(mat3(modelMatrix)));\n"
+"    vec3 normal = normalize(normalMatrix*fragNormal);\n"
+"    vec3 n = normalize(normal);\n"
+"    vec3 v = normalize(viewDir);\n"
+"    vec4 texelColor = texture(texture0, fragTexCoord);\n"
+"    vec3 lighting = colAmbient.rgb;\n"
+"    if (useNormal == 1)\n"
+"    {\n"
+"        n *= texture(texture1, fragTexCoord).rgb;\n"
+"        n = normalize(n);\n"
+"    }\n"
+"    float spec = 1.0;\n"
+"    if (useSpecular == 1) spec *= normalize(texture(texture2, fragTexCoord).r);\n"
+"    for (int i = 0; i < lightsCount; i++)\n"
+"    {\n"
+"        if (lights[i].enabled == 1)\n"
+"        {\n"
+"            switch (lights[i].type)\n"
+"            {\n"
+"                case 0: lighting += CalcPointLight(lights[i], n, v, spec); break;\n"
+"                case 1: lighting += CalcDirectionalLight(lights[i], n, v, spec); break;\n"
+"                case 2: lighting += CalcSpotLight(lights[i], n, v, spec); break;\n"
+"                default: break;\n"
+"            }\n"
+"        }\n"
+"    }\n"
+#if defined(GRAPHICS_API_OPENGL_33)
+"   finalColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a); \n"
+#elif defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_21)
+"   gl_FragColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a); \n"
+#endif
+"}                                                        \n";

src/rlgl.c

@@ -48,8 +48,13 @@
     #ifdef __APPLE__ 
         #include <OpenGL/gl3.h>     // OpenGL 3 library for OSX
     #else
-        #define GLAD_IMPLEMENTATION
-        #include "external/glad.h"  // GLAD extensions loading library, includes OpenGL headers
+    #define GLAD_IMPLEMENTATION
+#if defined(RLGL_STANDALONE)
+    #include "glad.h"               // GLAD extensions loading library, includes OpenGL headers
+#else
+    #include "external/glad.h"      // GLAD extensions loading library, includes OpenGL headers
+#endif
+
     #endif
 #endif
 
@@ -159,10 +164,6 @@ typedef struct {
     // TODO: Store draw state -> blending mode, shader
 } DrawCall;
 
-#if defined(RLGL_STANDALONE)
-typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType;
-#endif
-
 //----------------------------------------------------------------------------------
 // Global Variables Definition
 //----------------------------------------------------------------------------------
@@ -259,7 +260,6 @@ static Color *GenNextMipmap(Color *srcData, int srcWidth, int srcHeight);
 #endif
 
 #if defined(RLGL_STANDALONE)
-static void TraceLog(int msgType, const char *text, ...);
 float *MatrixToFloat(Matrix mat);           // Converts Matrix to float array
 #endif
 
@@ -3344,7 +3344,7 @@ static Color *GenNextMipmap(Color *srcData, int srcWidth, int srcHeight)
 #if defined(RLGL_STANDALONE)
 // Output a trace log message
 // NOTE: Expected msgType: (0)Info, (1)Error, (2)Warning
-static void TraceLog(int msgType, const char *text, ...)
+void TraceLog(int msgType, const char *text, ...)
 {
     va_list args;
     va_start(args, text);

src/rlgl.h

@@ -230,6 +230,9 @@ typedef enum { OPENGL_11 = 1, OPENGL_33, OPENGL_ES_20 } GlVersion;
 
     // Color blending modes (pre-defined)
     typedef enum { BLEND_ALPHA = 0, BLEND_ADDITIVE, BLEND_MULTIPLIED } BlendMode;
+    
+    // TraceLog message types
+    typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType;
 #endif
 
 #ifdef __cplusplus
@@ -339,6 +342,8 @@ void EndBlendMode(void);                                            // End blend
 
 Light CreateLight(int type, Vector3 position, Color diffuse);       // Create a new light, initialize it and add to pool
 void DestroyLight(Light light);                                     // Destroy a light and take it out of the list
+
+void TraceLog(int msgType, const char *text, ...);
 #endif
 
 #ifdef __cplusplus