/home/mrjunejune/zenbu: third_party/raylib/include/rlgl.h comparison

comparison third_party/raylib/include/rlgl.h @ 276:b55c22cff335

Add interactive infinite canvas prototype

author	MrJuneJune <me@mrjunejune.com>
date	Mon, 17 Aug 2026 16:57:56 -0700
parents	f33d9ff8b6e8
children

comparison

equal deleted inserted replaced

-:c9be578316a6
+:b55c22cff335
 /**********************************************************************************************
 *
-*   rlgl v5.0 - A multi-OpenGL abstraction layer with an immediate-mode style API
+*   rlgl v6.0 - A multi-OpenGL abstraction layer with an immediate-mode style API
 *
 *   DESCRIPTION:
-*       An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0)
+*       An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0, ES 3.0)
 *       that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...)
 *
 *   ADDITIONAL NOTES:
-*       When choosing an OpenGL backend different than OpenGL 1.1, some internal buffer are
+*       When choosing an OpenGL backend different than OpenGL 1.1, some internal buffers are
 *       initialized on rlglInit() to accumulate vertex data
 *
-*       When an internal state change is required all the stored vertex data is renderer in batch,
+*       When an internal state change is required all the stored vertex data is rendered in a batch,
 *       additionally, rlDrawRenderBatchActive() could be called to force flushing of the batch
 *
 *       Some 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 resources) must be manually unloaded calling rlglClose()
 *
 *   CONFIGURATION:
+*       #define GRAPHICS_API_OPENGL_SOFTWARE
 *       #define GRAPHICS_API_OPENGL_11
 *       #define GRAPHICS_API_OPENGL_21
 *       #define GRAPHICS_API_OPENGL_33
 *       #define GRAPHICS_API_OPENGL_43
 *       #define GRAPHICS_API_OPENGL_ES2
 *       #define GRAPHICS_API_OPENGL_ES3
 *           Use selected OpenGL graphics backend, should be supported by platform
-*           Those preprocessor defines are only used on rlgl module, if OpenGL version is
+*           Those preprocessor defines are only used on the rlgl module, if OpenGL version is
 *           required by any other module, use rlGetVersion() to check it
 *
 *       #define RLGL_IMPLEMENTATION
 *           Generates the implementation of the library into the included file
 *           If not defined, the library is in header only mode and can be included in other headers
 *           or source files without problems. But only ONE file should hold the implementation
 *
-*       #define RLGL_RENDER_TEXTURES_HINT
+*       #if RLGL_SHOW_GL_DETAILS_INFO
-*           Enable framebuffer objects (fbo) support (enabled by default)
-*           Some GPUs could not support them despite the OpenGL version
-*
-*       #define RLGL_SHOW_GL_DETAILS_INFO
 *           Show OpenGL extensions and capabilities detailed logs on init
 *
-*       #define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT
+*       #if RLGL_ENABLE_OPENGL_DEBUG_CONTEXT
 *           Enable debug context (only available on OpenGL 4.3)
 *
-*       rlgl capabilities could be customized just defining some internal
+*       rlgl capabilities could be customized 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_DEFAULT_BATCH_MAX_TEXTURE_UNITS    4    // Maximum number of texture 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_NEAR              0.05    // Default projection matrix near cull distance
-*       #define RL_CULL_DISTANCE_FAR             1000.0    // Default projection matrix far cull distance
+*       #define RL_CULL_DISTANCE_FAR             4000.0    // Default projection matrix far cull distance
 *
 *       When loading a shader, the following vertex attributes and uniform
 *       location names are tried to be set automatically:
 *
 *       #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION
 *       #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD
 *       #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL       "vertexNormal"      // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL
 *       #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR        "vertexColor"       // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR
 *       #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT      "vertexTangent"     // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT
 *       #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2
-*       #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEIDS      "vertexBoneIds"     // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEIDS
+*       #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES  "vertexBoneIndices" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES
 *       #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS  "vertexBoneWeights" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS
 *       #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_UNIFORM_NAME_BONE_MATRICES  "boneMatrices"   // bone matrices
+*       #define RL_DEFAULT_SHADER_UNIFORM_NAME_BONEMATRICES "boneMatrices"     // bone matrices
 *       #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 library (only for OpenGL 3.3 Core, 4.3 Core)
 *
 *
 *   LICENSE: zlib/libpng
 *
-*   Copyright (c) 2014-2024 Ramon Santamaria (@raysan5)
+*   Copyright (c) 2014-2026 Ramon Santamaria (@raysan5)
 *
 *   This software is provided "as-is", without any express or implied warranty. In no event
 *   will the authors be held liable for any damages arising from the use of this software.
 *
 *   Permission is granted to anyone to use this software for any purpose, including commercial
 **********************************************************************************************/
 #ifndef RLGL_H
 #define RLGL_H
-#define RLGL_VERSION  "5.0"
+#define RLGL_VERSION  "6.0"
 // Function specifiers in case library is build/used as a shared library
 // NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
 // NOTE: visibility(default) attribute makes symbols "visible" when compiled with -fvisibility=hidden
 #if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED)
-#define RLAPI __declspec(dllexport)     // We are building the library as a Win32 shared library (.dll)
+#define RLAPI __declspec(dllexport)     // Building the library as a Win32 shared library (.dll)
 #elif defined(BUILD_LIBTYPE_SHARED)
-#define RLAPI __attribute__((visibility("default"))) // We are building the library as a Unix shared library (.so/.dylib)
+#define RLAPI __attribute__((visibility("default"))) // Building the library as a Unix shared library (.so/.dylib)
 #elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED)
-#define RLAPI __declspec(dllimport)     // We are using the library as a Win32 shared library (.dll)
+#define RLAPI __declspec(dllimport)     // Using the library as a Win32 shared library (.dll)
 #endif
 // Function specifiers definition
 #ifndef RLAPI
 #define RLAPI       // Functions defined as 'extern' by default (implicit specifiers)
 #endif
 // Support TRACELOG macros
 #ifndef TRACELOG
 #define TRACELOG(level, ...) (void)0
-#define TRACELOGD(...) (void)0
 #endif
 // Allow custom memory allocators
 #ifndef RL_MALLOC
 #define RL_MALLOC(sz)     malloc(sz)
 #ifndef RL_FREE
 #define RL_FREE(p)        free(p)
 #endif
 // Security check in case no GRAPHICS_API_OPENGL_* defined
-#if !defined(GRAPHICS_API_OPENGL_11) && \
+#if !defined(GRAPHICS_API_OPENGL_SOFTWARE) && \
+!defined(GRAPHICS_API_OPENGL_11) && \
 !defined(GRAPHICS_API_OPENGL_21) && \
 !defined(GRAPHICS_API_OPENGL_33) && \
 !defined(GRAPHICS_API_OPENGL_43) && \
 !defined(GRAPHICS_API_OPENGL_ES2) && \
 !defined(GRAPHICS_API_OPENGL_ES3)
 #define GRAPHICS_API_OPENGL_33
 #endif
 // Security check in case multiple GRAPHICS_API_OPENGL_* defined
-#if defined(GRAPHICS_API_OPENGL_11)
+#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_SOFTWARE)
 #if defined(GRAPHICS_API_OPENGL_21)
 #undef GRAPHICS_API_OPENGL_21
 #endif
 #if defined(GRAPHICS_API_OPENGL_33)
 #undef GRAPHICS_API_OPENGL_33
 #if defined(GRAPHICS_API_OPENGL_ES2)
 #undef GRAPHICS_API_OPENGL_ES2
 #endif
 #endif
+// Software implementation uses OpenGL 1.1 functionality
+#if defined(GRAPHICS_API_OPENGL_SOFTWARE)
+#define GRAPHICS_API_OPENGL_11
+#endif
 // OpenGL 2.1 uses most of OpenGL 3.3 Core functionality
 // WARNING: Specific parts are checked with #if defines
 #if defined(GRAPHICS_API_OPENGL_21)
 #define GRAPHICS_API_OPENGL_33
 #endif
 // OpenGL ES 3.0 uses OpenGL ES 2.0 functionality (and more)
 #if defined(GRAPHICS_API_OPENGL_ES3)
 #define GRAPHICS_API_OPENGL_ES2
 #endif
-// Support framebuffer objects by default
-// NOTE: Some driver implementation do not support it, despite they should
-#define RLGL_RENDER_TEXTURES_HINT
 //----------------------------------------------------------------------------------
 // Defines and Macros
 //----------------------------------------------------------------------------------
 // This is the maximum amount of elements (quads) per batch
 // NOTE: Be careful with text, every letter maps to a quad
 #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS  8192
 #endif
 #if defined(GRAPHICS_API_OPENGL_ES2)
-// We reduce memory sizes for embedded systems (RPI and HTML5)
+// Reducing 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...
+// by default heap is only 16MB!...just take care...
 #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS  2048
 #endif
 #endif
 #ifndef RL_DEFAULT_BATCH_BUFFERS
 #define RL_DEFAULT_BATCH_BUFFERS                 1      // Default number of batch buffers (multi-buffering)
 #define RL_MAX_SHADER_LOCATIONS                 32      // Maximum number of shader locations 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.05      // 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                4000.0      // Default far cull distance
 #endif
 // Texture parameters (equivalent to OpenGL defines)
 #define RL_TEXTURE_WRAP_S                       0x2802      // GL_TEXTURE_WRAP_S
 #define RL_TEXTURE_WRAP_T                       0x2803      // GL_TEXTURE_WRAP_T
 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2   5
 #endif
 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_INDICES
 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_INDICES     6
 #endif
-#ifdef RL_SUPPORT_MESH_GPU_SKINNING
+#ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES
-#ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEIDS
+#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES 7
-#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEIDS     7
 #endif
 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS
 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS 8
 #endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM
+#define RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM 9
 #endif
 //----------------------------------------------------------------------------------
 // Types and Structures Definition
 //----------------------------------------------------------------------------------
 unsigned int vboId[5];      // OpenGL Vertex Buffer Objects id (5 types of vertex data)
 } rlVertexBuffer;
 // Draw call type
 // NOTE: Only texture changes register a new draw, other state-change-related elements are not
-// used at this moment (vaoId, shaderId, matrices), raylib just forces a batch draw call if any
+// used at this moment (vaoId, shaderId, matrices), raylib forces a batch draw call if any
 // of those state-change happens (this is done in core module)
 typedef struct rlDrawCall {
 int mode;                   // Drawing mode: LINES, TRIANGLES, QUADS
 int vertexCount;            // Number of vertex of the draw
 int vertexAlignment;        // Number of vertex required for index alignment (LINES, TRIANGLES)
 float currentDepth;         // Current depth value for next draw
 } rlRenderBatch;
 // OpenGL version
 typedef enum {
-RL_OPENGL_11 = 1,           // OpenGL 1.1
+RL_OPENGL_SOFTWARE = 0,  // Software rendering
+RL_OPENGL_11,               // OpenGL 1.1
 RL_OPENGL_21,               // OpenGL 2.1 (GLSL 120)
 RL_OPENGL_33,               // OpenGL 3.3 (GLSL 330)
 RL_OPENGL_43,               // OpenGL 4.3 (using GLSL 330)
 RL_OPENGL_ES_20,            // OpenGL ES 2.0 (GLSL 100)
 RL_OPENGL_ES_30             // OpenGL ES 3.0 (GLSL 300 es)
 // Texture parameters: filter mode
 // NOTE 1: Filtering considers mipmaps if available in the texture
 // NOTE 2: Filter is accordingly set for minification and magnification
 typedef enum {
-RL_TEXTURE_FILTER_POINT = 0,        // No filter, just pixel approximation
+RL_TEXTURE_FILTER_POINT = 0,        // No filter, pixel approximation
 RL_TEXTURE_FILTER_BILINEAR,         // Linear filtering
 RL_TEXTURE_FILTER_TRILINEAR,        // Trilinear filtering (linear with mipmaps)
 RL_TEXTURE_FILTER_ANISOTROPIC_4X,   // Anisotropic filtering 4x
 RL_TEXTURE_FILTER_ANISOTROPIC_8X,   // Anisotropic filtering 8x
 RL_TEXTURE_FILTER_ANISOTROPIC_16X,  // Anisotropic filtering 16x
 RLAPI void rlDisableVertexBuffer(void);                 // Disable vertex buffer (VBO)
 RLAPI void rlEnableVertexBufferElement(unsigned int id); // Enable vertex buffer element (VBO element)
 RLAPI void rlDisableVertexBufferElement(void);          // Disable vertex buffer element (VBO element)
 RLAPI void rlEnableVertexAttribute(unsigned int index); // Enable vertex attribute index
 RLAPI void rlDisableVertexAttribute(unsigned int index); // Disable vertex attribute index
-#if defined(GRAPHICS_API_OPENGL_11)
 RLAPI void rlEnableStatePointer(int vertexAttribType, void *buffer); // Enable attribute state pointer
 RLAPI void rlDisableStatePointer(int vertexAttribType); // Disable attribute state pointer
-#endif
 // Textures state
 RLAPI void rlActiveTextureSlot(int slot);               // Select and active a texture slot
 RLAPI void rlEnableTexture(unsigned int id);            // Enable texture
 RLAPI void rlDisableTexture(void);                      // Disable texture
 RLAPI void rlColorMask(bool r, bool g, bool b, bool a); // Color mask control
 RLAPI void rlSetCullFace(int mode);                     // Set face culling mode
 RLAPI void rlEnableScissorTest(void);                   // Enable scissor test
 RLAPI void rlDisableScissorTest(void);                  // Disable scissor test
 RLAPI void rlScissor(int x, int y, int width, int height); // Scissor test
+RLAPI void rlEnablePointMode(void);                     // Enable point mode
+RLAPI void rlDisablePointMode(void);                    // Disable point mode
+RLAPI void rlSetPointSize(float size);                  // Set the point drawing size
+RLAPI float rlGetPointSize(void);                       // Get the point drawing size
 RLAPI void rlEnableWireMode(void);                      // Enable wire mode
-RLAPI void rlEnablePointMode(void);                     // Enable point mode
+RLAPI void rlDisableWireMode(void);                     // Disable wire mode
-RLAPI void rlDisableWireMode(void);                     // Disable wire (and point) mode
 RLAPI void rlSetLineWidth(float width);                 // Set the line drawing width
 RLAPI float rlGetLineWidth(void);                       // Get the line drawing width
 RLAPI void rlEnableSmoothLines(void);                   // Enable line aliasing
 RLAPI void rlDisableSmoothLines(void);                  // Disable line aliasing
 RLAPI void rlEnableStereoRender(void);                  // Enable stereo rendering
 //------------------------------------------------------------------------------------
 // rlgl initialization functions
 RLAPI void rlglInit(int width, int height);             // Initialize rlgl (buffers, shaders, textures, states)
 RLAPI void rlglClose(void);                             // De-initialize rlgl (buffers, shaders, textures)
 RLAPI void rlLoadExtensions(void *loader);              // Load OpenGL extensions (loader function required)
+RLAPI void *rlGetProcAddress(const char *procName);     // Get OpenGL procedure address
 RLAPI int rlGetVersion(void);                           // Get current OpenGL version
 RLAPI void rlSetFramebufferWidth(int width);            // Set current framebuffer width
 RLAPI int rlGetFramebufferWidth(void);                  // Get default framebuffer width
 RLAPI void rlSetFramebufferHeight(int height);          // Set current framebuffer height
 RLAPI int rlGetFramebufferHeight(void);                 // Get default framebuffer height
 RLAPI void *rlReadTexturePixels(unsigned int id, int width, int height, int format); // Read texture pixel data
 RLAPI unsigned char *rlReadScreenPixels(int width, int height);           // Read screen pixel data (color buffer)
 // Framebuffer management (fbo)
 RLAPI unsigned int rlLoadFramebuffer(void);                               // Load an empty framebuffer
-RLAPI void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel); // Attach texture/renderbuffer to a framebuffer
+RLAPI void rlFramebufferAttach(unsigned int id, unsigned int texId, int attachType, int texType, int mipLevel); // Attach texture/renderbuffer to a framebuffer
 RLAPI bool rlFramebufferComplete(unsigned int id);                        // Verify framebuffer is complete
 RLAPI void rlUnloadFramebuffer(unsigned int id);                          // Delete framebuffer from GPU
+// WARNING: Copy and resize framebuffer functionality only defined for software backend
+RLAPI void rlCopyFramebuffer(int x, int y, int width, int height, int format, void *pixels); // Copy framebuffer pixel data to internal buffer
+RLAPI void rlResizeFramebuffer(int width, int height);                    // Resize internal framebuffer
 // Shaders management
-RLAPI unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode);    // Load shader from code strings
+RLAPI unsigned int rlLoadShader(const char *code, int type);                    // Load (compile) shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER)
-RLAPI unsigned int rlCompileShader(const char *shaderCode, int type);           // Compile custom shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER)
+RLAPI unsigned int rlLoadShaderProgram(const char *vsCode, const char *fsCode); // Load shader from code strings
-RLAPI unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId); // Load custom shader program
+RLAPI unsigned int rlLoadShaderProgramEx(unsigned int vsId, unsigned int fsId); // Load shader program, using already loaded shader ids
+RLAPI unsigned int rlLoadShaderProgramCompute(unsigned int csId);               // Load compute shader program
+RLAPI void rlUnloadShader(unsigned int id);                                     // Unload shader, loaded with rlLoadShader()
 RLAPI void rlUnloadShaderProgram(unsigned int id);                              // Unload shader program
-RLAPI int rlGetLocationUniform(unsigned int shaderId, const char *uniformName); // Get shader location uniform
+RLAPI int rlGetLocationUniform(unsigned int id, const char *uniformName);       // Get shader location uniform, requires shader program id
-RLAPI int rlGetLocationAttrib(unsigned int shaderId, const char *attribName);   // Get shader location attribute
+RLAPI int rlGetLocationAttrib(unsigned int id, const char *attribName);         // Get shader location attribute, requires shader program id
 RLAPI void rlSetUniform(int locIndex, const void *value, int uniformType, int count); // Set shader value uniform
 RLAPI void rlSetUniformMatrix(int locIndex, Matrix mat);                        // Set shader value matrix
 RLAPI void rlSetUniformMatrices(int locIndex, const Matrix *mat, int count);    // Set shader value matrices
 RLAPI void rlSetUniformSampler(int locIndex, unsigned int textureId);           // Set shader value sampler
 RLAPI void rlSetShader(unsigned int id, int *locs);                             // Set shader currently active (id and locations)
 // Compute shader management
-RLAPI unsigned int rlLoadComputeShaderProgram(unsigned int shaderId);           // Load compute shader program
 RLAPI void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ); // Dispatch compute shader (equivalent to *draw* for graphics pipeline)
 // Shader buffer storage object management (ssbo)
 RLAPI unsigned int rlLoadShaderBuffer(unsigned int size, const void *data, int usageHint); // Load shader storage buffer object (SSBO)
 RLAPI void rlUnloadShaderBuffer(unsigned int ssboId);                           // Unload shader storage buffer object (SSBO)
 #define GLAD_API_CALL_EXPORT
 #define GLAD_API_CALL_EXPORT_BUILD
 #endif
 #if defined(GRAPHICS_API_OPENGL_11)
-#if defined(__APPLE__)
+#if defined(GRAPHICS_API_OPENGL_SOFTWARE)
-#include <OpenGL/gl.h>          // OpenGL 1.1 library for OSX
+#define RLSW_IMPLEMENTATION
-#include <OpenGL/glext.h>       // OpenGL extensions library
+#define SW_MALLOC(sz) RL_MALLOC(sz)
+#define SW_CALLOC(n,sz) RL_CALLOC(n, sz)
+#define SW_REALLOC(ptr, newSz) RL_REALLOC(ptr, newSz)
+#define SW_FREE(ptr) RL_FREE(ptr)
+#include "external/rlsw.h"          // OpenGL 1.1 software implementation
 #else
-// APIENTRY for OpenGL function pointer declarations is required
+#if defined(__APPLE__)
-#if !defined(APIENTRY)
+#include <OpenGL/gl.h>          // OpenGL 1.1 library for OSX
-#if defined(_WIN32)
+#include <OpenGL/glext.h>       // OpenGL extensions library
-#define APIENTRY __stdcall
+#else
-#else
+// APIENTRY for OpenGL function pointer declarations is required
-#define APIENTRY
+#if !defined(APIENTRY)
+#if defined(_WIN32)
+#define APIENTRY __stdcall
+#else
+#define APIENTRY
+#endif
 #endif
+// WINGDIAPI definition. Some Windows OpenGL headers need it
+#if !defined(WINGDIAPI) && defined(_WIN32)
+#define WINGDIAPI __declspec(dllimport)
+#endif
+#include <GL/gl.h>              // OpenGL 1.1 library
 #endif
-// WINGDIAPI definition. Some Windows OpenGL headers need it
-#if !defined(WINGDIAPI) && defined(_WIN32)
-#define WINGDIAPI __declspec(dllimport)
-#endif
-#include <GL/gl.h>              // OpenGL 1.1 library
 #endif
 #endif
 #if defined(GRAPHICS_API_OPENGL_33)
 #define GLAD_MALLOC RL_MALLOC
 #define GL_GLEXT_PROTOTYPES
 #include <GLES2/gl2ext.h>           // OpenGL ES 2.0 extensions library
 #elif defined(GRAPHICS_API_OPENGL_ES2)
 // NOTE: OpenGL ES 2.0 can be enabled on Desktop platforms,
 // in that case, functions are loaded from a custom glad for OpenGL ES 2.0
+// TODO: OpenGL ES 2.0 support shouldn't be platform-dependent, neither require GLAD
 #if defined(PLATFORM_DESKTOP_GLFW) || defined(PLATFORM_DESKTOP_SDL)
 #define GLAD_GLES2_IMPLEMENTATION
 #include "external/glad_gles2.h"
 #else
 #define GL_GLEXT_PROTOTYPES
 #include <GLES2/gl2ext.h>       // OpenGL ES 2.0 extensions library
 #endif
 // It seems OpenGL ES 2.0 instancing entry points are not defined on Raspberry Pi
 // provided headers (despite being defined in official Khronos GLES2 headers)
+// TODO: Avoid raylib platform-dependent code on rlgl, it should be a completely portable library
 #if defined(PLATFORM_DRM)
 typedef void (GL_APIENTRYP PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount);
 typedef void (GL_APIENTRYP PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount);
 typedef void (GL_APIENTRYP PFNGLVERTEXATTRIBDIVISOREXTPROC) (GLuint index, GLuint divisor);
 #endif
 #endif
-#include <stdlib.h>                     // Required for: malloc(), free()
+#include <stdlib.h>                     // Required for: calloc(), 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
 #endif
 #endif
 // Default shader vertex attribute names to set location points
 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION
 #endif
 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD
 #endif
 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL       "vertexNormal"      // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL       "vertexNormal"      // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL
 #endif
 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR        "vertexColor"       // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR        "vertexColor"       // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR
 #endif
 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT      "vertexTangent"     // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT      "vertexTangent"     // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT
 #endif
 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2
 #endif
-#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_BONEIDS
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEIDS      "vertexBoneIds"     // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_NAME_BONEIDS
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES  "vertexBoneIndices" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES
 #endif
 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS
-#define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS  "vertexBoneWeights" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS  "vertexBoneWeights" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS
+#endif
+#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCETRANSFORM
+#define RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCETRANSFORM "instanceTransform" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM
 #endif
 #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MVP
 #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP         "mvp"               // model-view-projection matrix
 #endif
 #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL      "matNormal"         // normal matrix (transpose(inverse(matModelView))
 #endif
 #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR
 #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR       "colDiffuse"        // color diffuse (base tint color, multiplied by texture color)
 #endif
-#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_BONE_MATRICES
-#define RL_DEFAULT_SHADER_UNIFORM_NAME_BONE_MATRICES  "boneMatrices"   // bone matrices
-#endif
 #ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0
 #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0  "texture0"          // texture0 (texture slot active 0)
 #endif
 #ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1
 #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1  "texture1"          // texture1 (texture slot active 1)
 #endif
 #ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2
 #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2  "texture2"          // texture2 (texture slot active 2)
 #endif
+#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_BONEMATRICES
+#define RL_DEFAULT_SHADER_UNIFORM_NAME_BONEMATRICES "boneMatrices"     // bone matrices (required for GPU skinning)
+#endif
 //----------------------------------------------------------------------------------
-// Types and Structures Definition
+// Module Types and Structures Definition
 //----------------------------------------------------------------------------------
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+typedef void *(*rlglLoadProc)(const char *name);   // OpenGL extension functions loader signature (same as GLADloadproc)
 typedef struct rlglData {
 rlRenderBatch *currentBatch;            // Current render batch
 rlRenderBatch defaultBatch;             // Default internal render batch
+rlglLoadProc loader;                    // OpenGL function loader
 struct {
 int vertexCounter;                  // Current active render batch vertex counter (generic, used for all batches)
 float texcoordx, texcoordy;         // Current active texture coordinate (added on glVertex*())
 float normalx, normaly, normalz;    // Current active normal (added on glVertex*())
 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[RL_MAX_MATRIX_STACK_SIZE];// Matrix stack for push/pop
 int stackCounter;                   // Matrix stack counter
+unsigned int currentTextureId;      // Current texture id to be used on glBegin
 unsigned int defaultTextureId;      // Default texture used on shapes/poly drawing (required by shader)
 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
 int maxDepthBits;                   // Maximum bits for depth component
 } ExtSupported;     // Extensions supported flags
 } rlglData;
-typedef void *(*rlglLoadProc)(const char *name);   // OpenGL extension functions loader signature (same as GLADloadproc)
+#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
-#endif  // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
 //----------------------------------------------------------------------------------
 // Global Variables Definition
 //----------------------------------------------------------------------------------
+static bool isGpuReady = false;
 static double rlCullDistanceNear = RL_CULL_DISTANCE_NEAR;
 static double rlCullDistanceFar = RL_CULL_DISTANCE_FAR;
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 static rlglData RLGL = { 0 };
-#endif  // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+#endif
 #if defined(GRAPHICS_API_OPENGL_ES2) && !defined(GRAPHICS_API_OPENGL_ES3)
+// VAO functions entry points
 // NOTE: VAO functionality is exposed through extensions (OES)
 static PFNGLGENVERTEXARRAYSOESPROC glGenVertexArrays = NULL;
 static PFNGLBINDVERTEXARRAYOESPROC glBindVertexArray = NULL;
 static PFNGLDELETEVERTEXARRAYSOESPROC glDeleteVertexArrays = NULL;
-// NOTE: Instancing functionality could also be available through extension
+// Instancing functionality entry points
+// NOTE: Instancing functionality could be available through extensions
 static PFNGLDRAWARRAYSINSTANCEDEXTPROC glDrawArraysInstanced = NULL;
 static PFNGLDRAWELEMENTSINSTANCEDEXTPROC glDrawElementsInstanced = NULL;
 static PFNGLVERTEXATTRIBDIVISOREXTPROC glVertexAttribDivisor = NULL;
 #endif
 //----------------------------------------------------------------------------------
-// Module specific Functions Declaration
+// Module Functions Declaration
 //----------------------------------------------------------------------------------
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 static void rlLoadShaderDefault(void);      // Load default shader
 static void rlUnloadShaderDefault(void);    // Unload default shader
-#if defined(RLGL_SHOW_GL_DETAILS_INFO)
+#if RLGL_SHOW_GL_DETAILS_INFO
 static const char *rlGetCompressedFormatName(int format); // Get compressed format official GL identifier name
-#endif  // RLGL_SHOW_GL_DETAILS_INFO
+#endif
-#endif  // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+#endif
 static int rlGetPixelDataSize(int width, int height, int format);   // Get pixel data size in bytes (image or texture)
+static Matrix rlMatrixIdentity(void);                       // Get identity matrix
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 // Auxiliar matrix math functions
-typedef struct rl_float16 {
+typedef struct rl_float16 { float v[16]; } rl_float16;
-float v[16];
-} rl_float16;
 static rl_float16 rlMatrixToFloatV(Matrix mat);             // Get float array of matrix data
 #define rlMatrixToFloat(mat) (rlMatrixToFloatV(mat).v)      // Get float vector for Matrix
-static Matrix rlMatrixIdentity(void);                       // Get identity matrix
 static Matrix rlMatrixMultiply(Matrix left, Matrix right);  // Multiply two matrices
 static Matrix rlMatrixTranspose(Matrix mat);                // Transposes provided matrix
 static Matrix rlMatrixInvert(Matrix mat);                   // Invert provided matrix
+#endif
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Matrix operations
 //----------------------------------------------------------------------------------
 RLGL.State.stack[RLGL.State.stackCounter] = *RLGL.State.currentMatrix;
 RLGL.State.stackCounter++;
 }
-// Pop lattest inserted matrix from RLGL.State.stack
+// Pop latest inserted matrix from RLGL.State.stack
 void rlPopMatrix(void)
 {
 if (RLGL.State.stackCounter > 0)
 {
 Matrix mat = RLGL.State.stack[RLGL.State.stackCounter - 1];
 }
 // Multiply the current matrix by a translation matrix
 void rlTranslatef(float x, float y, float z)
 {
-Matrix matTranslation = {
+Matrix matTranslation = rlMatrixIdentity();
-1.0f, 0.0f, 0.0f, x,
-0.0f, 1.0f, 0.0f, y,
+// Set translation component of matrix
-0.0f, 0.0f, 1.0f, z,
+matTranslation.m12 = x;
-0.0f, 0.0f, 0.0f, 1.0f
+matTranslation.m13 = y;
-};
+matTranslation.m14 = z;
-// NOTE: We transpose matrix with multiplication order
+// NOTE: Transposing matrix by multiplication order
 *RLGL.State.currentMatrix = rlMatrixMultiply(matTranslation, *RLGL.State.currentMatrix);
 }
 // Multiply the current matrix by a rotation matrix
 // NOTE: The provided angle must be in degrees
 matRotation.m12 = 0.0f;
 matRotation.m13 = 0.0f;
 matRotation.m14 = 0.0f;
 matRotation.m15 = 1.0f;
-// NOTE: We transpose matrix with multiplication order
+// NOTE: Transposing matrix by multiplication order
 *RLGL.State.currentMatrix = rlMatrixMultiply(matRotation, *RLGL.State.currentMatrix);
 }
 // Multiply the current matrix by a scaling matrix
 void rlScalef(float x, float y, float z)
 {
-Matrix matScale = {
+Matrix matScale = rlMatrixIdentity();
-x, 0.0f, 0.0f, 0.0f,
-0.0f, y, 0.0f, 0.0f,
+// Set scale component of matrix
-0.0f, 0.0f, z, 0.0f,
+matScale.m0 = x;
-0.0f, 0.0f, 0.0f, 1.0f
+matScale.m5 = y;
-};
+matScale.m10 = z;
-// NOTE: We transpose matrix with multiplication order
+// NOTE: Transposing matrix by multiplication order
 *RLGL.State.currentMatrix = rlMatrixMultiply(matScale, *RLGL.State.currentMatrix);
 }
 // Multiply the current matrix by another matrix
 void rlMultMatrixf(const float *matf)
 {
 // Matrix creation from array
+// Conversion from column-major to row-major memory order
 Matrix mat = { matf[0], matf[4], matf[8], matf[12],
 matf[1], matf[5], matf[9], matf[13],
 matf[2], matf[6], matf[10], matf[14],
 matf[3], matf[7], matf[11], matf[15] };
 // Multiply the current matrix by an orthographic matrix generated by parameters
 void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar)
 {
 // NOTE: If left-right and top-botton values are equal it could create a division by zero,
-// response to it is platform/compiler dependant
+// response to it is platform/compiler dependent
 Matrix matOrtho = { 0 };
 float rl = (float)(right - left);
 float tb = (float)(top - bottom);
 float fn = (float)(zfar - znear);
 *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matOrtho);
 }
 #endif
 // Set the viewport area (transformation from normalized device coordinates to window coordinates)
-// NOTE: We store current viewport dimensions
 void rlViewport(int x, int y, int width, int height)
 {
 glViewport(x, y, width, height);
 }
 }
 if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch);
 RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = mode;
-RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount = 0;
+RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = RLGL.State.currentTextureId;
-RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = RLGL.State.defaultTextureId;
+RLGL.State.currentTextureId = RLGL.State.defaultTextureId;
 }
 }
 // Finish vertex providing
 void rlEnd(void)
 {
-// NOTE: Depth increment is dependant on rlOrtho(): z-near and z-far values,
+// NOTE: Depth increment is dependent on rlOrtho(): z-near and z-far values,
 // as well as depth buffer bit-depth (16bit or 24bit or 32bit)
 // Correct increment formula would be: depthInc = (zfar - znear)/pow(2, bits)
 RLGL.currentBatch->currentDepth += (1.0f/20000.0f);
 }
 tx = RLGL.State.transform.m0*x + RLGL.State.transform.m4*y + RLGL.State.transform.m8*z + RLGL.State.transform.m12;
 ty = RLGL.State.transform.m1*x + RLGL.State.transform.m5*y + RLGL.State.transform.m9*z + RLGL.State.transform.m13;
 tz = RLGL.State.transform.m2*x + RLGL.State.transform.m6*y + RLGL.State.transform.m10*z + RLGL.State.transform.m14;
 }
-// WARNING: We can't break primitives when launching a new batch
+// WARNING: Be careful with primitives breaking when launching a new batch!
 // RL_LINES comes in pairs, RL_TRIANGLES come in groups of 3 vertices and RL_QUADS come in groups of 4 vertices
-// We must check current draw.mode when a new vertex is required and finish the batch only if the draw.mode draw.vertexCount is %2, %3 or %4
+// Checking current draw.mode when a new vertex is required and finish the batch only if the draw.mode draw.vertexCount is %2, %3 or %4
 if (RLGL.State.vertexCounter > (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4 - 4))
 {
 if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) &&
 (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%2 == 0))
 {
 // Reached the maximum number of vertices for RL_LINES drawing
 // Launch a draw call but keep current state for next vertices comming
-// NOTE: We add +1 vertex to the check for security
+// NOTE: Adding +1 vertex to the check for some safety
 rlCheckRenderBatchLimit(2 + 1);
 }
 else if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) &&
 (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%3 == 0))
 {
 {
 normalx = RLGL.State.transform.m0*x + RLGL.State.transform.m4*y + RLGL.State.transform.m8*z;
 normaly = RLGL.State.transform.m1*x + RLGL.State.transform.m5*y + RLGL.State.transform.m9*z;
 normalz = RLGL.State.transform.m2*x + RLGL.State.transform.m6*y + RLGL.State.transform.m10*z;
 }
+// NOTE: Default behavior assumes the normal vector is in the correct space for what the shader expects,
+// it could be not normalized to 0.0f..1.0f, magnitud can be useed for some effects
+/*
+// WARNING: Vector normalization if required
 float length = sqrtf(normalx*normalx + normaly*normaly + normalz*normalz);
 if (length != 0.0f)
 {
 float ilength = 1.0f/length;
 normalx *= ilength;
 normaly *= ilength;
 normalz *= ilength;
 }
+*/
 RLGL.State.normalx = normalx;
 RLGL.State.normaly = normaly;
 RLGL.State.normalz = normalz;
 }
 if (id == 0)
 {
 #if defined(GRAPHICS_API_OPENGL_11)
 rlDisableTexture();
 #else
-// NOTE: If quads batch limit is reached, we force a draw call and next batch starts
+// NOTE: If quads batch limit is reached, force a draw call and next batch starts
 if (RLGL.State.vertexCounter >=
 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4)
 {
 rlDrawRenderBatch(RLGL.currentBatch);
 }
+RLGL.State.currentTextureId = RLGL.State.defaultTextureId;
 #endif
 }
 else
 {
 #if defined(GRAPHICS_API_OPENGL_11)
 rlEnableTexture(id);
 #else
+RLGL.State.currentTextureId = id;
 if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId != id)
 {
 if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0)
 {
 // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4,
 if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment))
 {
 RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment;
 RLGL.currentBatch->drawCounter++;
+RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 2].mode;
 }
 }
 if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch);
 // Set texture parameters (wrap mode/filter mode)
 void rlTextureParameters(unsigned int id, int param, int value)
 {
 glBindTexture(GL_TEXTURE_2D, id);
-#if !defined(GRAPHICS_API_OPENGL_11)
-// Reset anisotropy filter, in case it was set
-glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
-#endif
 switch (param)
 {
 case RL_TEXTURE_WRAP_S:
 case RL_TEXTURE_WRAP_T:
 if (RLGL.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_2D, param, value);
 else TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)");
 #endif
 }
 else glTexParameteri(GL_TEXTURE_2D, param, value);
 } break;
 case RL_TEXTURE_MAG_FILTER:
 case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_2D, param, value); break;
 case RL_TEXTURE_FILTER_ANISOTROPIC:
 {
 #if !defined(GRAPHICS_API_OPENGL_11)
+// Reset anisotropy filter, in case it was set
+glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
 if (value <= RLGL.ExtSupported.maxAnisotropyLevel) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value);
 else if (RLGL.ExtSupported.maxAnisotropyLevel > 0.0f)
 {
 TRACELOG(RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, (int)RLGL.ExtSupported.maxAnisotropyLevel);
 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value);
 {
 if (RLGL.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value);
 else TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)");
 }
 else glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value);
 } break;
 case RL_TEXTURE_MAG_FILTER:
 case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); break;
 case RL_TEXTURE_FILTER_ANISOTROPIC:
 {
 }
 // Enable rendering to texture (fbo)
 void rlEnableFramebuffer(unsigned int id)
 {
-#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
 glBindFramebuffer(GL_FRAMEBUFFER, id);
 #endif
 }
 // return the active render texture (fbo)
 unsigned int rlGetActiveFramebuffer(void)
 {
 GLint fboId = 0;
-#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3)) && defined(RLGL_RENDER_TEXTURES_HINT)
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
 glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &fboId);
 #endif
 return fboId;
 }
 // Disable rendering to texture
 void rlDisableFramebuffer(void)
 {
-#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
 glBindFramebuffer(GL_FRAMEBUFFER, 0);
 #endif
 }
 // Blit active framebuffer to main framebuffer
 void rlBlitFramebuffer(int srcX, int srcY, int srcWidth, int srcHeight, int dstX, int dstY, int dstWidth, int dstHeight, int bufferMask)
 {
-#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3)) && defined(RLGL_RENDER_TEXTURES_HINT)
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3))
 glBlitFramebuffer(srcX, srcY, srcWidth, srcHeight, dstX, dstY, dstWidth, dstHeight, bufferMask, GL_NEAREST);
 #endif
 }
 // Bind framebuffer object (fbo)
 void rlBindFramebuffer(unsigned int target, unsigned int framebuffer)
 {
-#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
 glBindFramebuffer(target, framebuffer);
 #endif
 }
 // Activate multiple draw color buffers
 // NOTE: One color buffer is always active by default
 void rlActiveDrawBuffers(int count)
 {
-#if ((defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3)) && defined(RLGL_RENDER_TEXTURES_HINT))
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3))
-// NOTE: Maximum number of draw buffers supported is implementation dependant,
+// NOTE: Maximum number of draw buffers supported is implementation dependent,
 // it can be queried with glGet*() but it must be at least 8
 //GLint maxDrawBuffers = 0;
 //glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
 if (count > 0)
 {
-if (count > 8) TRACELOG(LOG_WARNING, "GL: Max color buffers limited to 8");
+if (count > 8) TRACELOG(RL_LOG_WARNING, "GL: Max color buffers limited to 8");
 else
 {
 unsigned int buffers[8] = {
-#if defined(GRAPHICS_API_OPENGL_ES3)
-GL_COLOR_ATTACHMENT0_EXT,
-GL_COLOR_ATTACHMENT1_EXT,
-GL_COLOR_ATTACHMENT2_EXT,
-GL_COLOR_ATTACHMENT3_EXT,
-GL_COLOR_ATTACHMENT4_EXT,
-GL_COLOR_ATTACHMENT5_EXT,
-GL_COLOR_ATTACHMENT6_EXT,
-GL_COLOR_ATTACHMENT7_EXT,
-#else
 GL_COLOR_ATTACHMENT0,
 GL_COLOR_ATTACHMENT1,
 GL_COLOR_ATTACHMENT2,
 GL_COLOR_ATTACHMENT3,
 GL_COLOR_ATTACHMENT4,
 GL_COLOR_ATTACHMENT5,
 GL_COLOR_ATTACHMENT6,
 GL_COLOR_ATTACHMENT7,
-#endif
 };
-#if defined(GRAPHICS_API_OPENGL_ES3)
-glDrawBuffersEXT(count, buffers);
-#else
 glDrawBuffers(count, buffers);
-#endif
 }
 }
-else TRACELOG(LOG_WARNING, "GL: One color buffer active by default");
+else TRACELOG(RL_LOG_WARNING, "GL: One color buffer active by default");
 #endif
 }
 //----------------------------------------------------------------------------------
 // General render state configuration
 void rlEnableWireMode(void)
 {
 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
 // NOTE: glPolygonMode() not available on OpenGL ES
 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+#endif
+}
+// Disable wire mode
+void rlDisableWireMode(void)
+{
+#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
+// NOTE: glPolygonMode() not available on OpenGL ES
+glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 #endif
 }
 // Enable point mode
 void rlEnablePointMode(void)
 glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
 glEnable(GL_PROGRAM_POINT_SIZE);
 #endif
 }
-// Disable wire mode
+// Disable point mode
-void rlDisableWireMode(void)
+void rlDisablePointMode(void)
 {
 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
 // NOTE: glPolygonMode() not available on OpenGL ES
 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 #endif
 float rlGetLineWidth(void)
 {
 float width = 0;
 glGetFloatv(GL_LINE_WIDTH, &width);
 return width;
+}
+// Set the point drawing size
+void rlSetPointSize(float size)
+{
+#if defined(GRAPHICS_API_OPENGL_11)
+glPointSize(size);
+#endif
+}
+// Get the point drawing size
+float rlGetPointSize(void)
+{
+float size = 1;
+#if defined(GRAPHICS_API_OPENGL_11)
+glGetFloatv(GL_POINT_SIZE, &size);
+#endif
+return size;
 }
 // Enable line aliasing
 void rlEnableSmoothLines(void)
 {
 case RL_BLEND_ALPHA_PREMULTIPLY: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
 case RL_BLEND_CUSTOM:
 {
 // NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactors()
 glBlendFunc(RLGL.State.glBlendSrcFactor, RLGL.State.glBlendDstFactor); glBlendEquation(RLGL.State.glBlendEquation);
 } break;
 case RL_BLEND_CUSTOM_SEPARATE:
 {
 // NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactorsSeparate()
 glBlendFuncSeparate(RLGL.State.glBlendSrcFactorRGB, RLGL.State.glBlendDestFactorRGB, RLGL.State.glBlendSrcFactorAlpha, RLGL.State.glBlendDestFactorAlpha);
 glBlendEquationSeparate(RLGL.State.glBlendEquationRGB, RLGL.State.glBlendEquationAlpha);
 } break;
 default: break;
 }
 RLGL.State.currentBlendMode = mode;
 }
 //----------------------------------------------------------------------------------
 // Module Functions Definition - OpenGL Debug
 //----------------------------------------------------------------------------------
-#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43)
+#if defined(GRAPHICS_API_OPENGL_43) && RLGL_ENABLE_OPENGL_DEBUG_CONTEXT
 static void GLAPIENTRY rlDebugMessageCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam)
 {
 // Ignore non-significant error/warning codes (NVidia drivers)
 // NOTE: Here there are the details with a sample output:
 // - #131169 - Framebuffer detailed info: The driver allocated storage for renderbuffer 2. (severity: low)
 case GL_DEBUG_SEVERITY_HIGH: msgSeverity = "HIGH"; break;
 case GL_DEBUG_SEVERITY_NOTIFICATION: msgSeverity = "NOTIFICATION"; break;
 default: break;
 }
-TRACELOG(LOG_WARNING, "GL: OpenGL debug message: %s", message);
+TRACELOG(RL_LOG_WARNING, "GL: OpenGL debug message: %s", message);
-TRACELOG(LOG_WARNING, "    > Type: %s", msgType);
+TRACELOG(RL_LOG_WARNING, "    > Type: %s", msgType);
-TRACELOG(LOG_WARNING, "    > Source = %s", msgSource);
+TRACELOG(RL_LOG_WARNING, "    > Source = %s", msgSource);
-TRACELOG(LOG_WARNING, "    > Severity = %s", msgSeverity);
+TRACELOG(RL_LOG_WARNING, "    > Severity = %s", msgSeverity);
 }
 #endif
 //----------------------------------------------------------------------------------
 // Module Functions Definition - rlgl functionality
 //----------------------------------------------------------------------------------
 // Initialize rlgl: OpenGL extensions, default buffers/shaders/textures, OpenGL states
 void rlglInit(int width, int height)
 {
-// Enable OpenGL debug context if required
+isGpuReady = true;
-#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43)
+// Enable OpenGL debug context if requested (and supported)
+#if defined(GRAPHICS_API_OPENGL_43) && RLGL_ENABLE_OPENGL_DEBUG_CONTEXT
 if ((glDebugMessageCallback != NULL) && (glDebugMessageControl != NULL))
 {
 glDebugMessageCallback(rlDebugMessageCallback, 0);
 // glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, GL_DEBUG_SEVERITY_HIGH, 0, 0, GL_TRUE);
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 // Init default white texture
 unsigned char pixels[4] = { 255, 255, 255, 255 };   // 1 pixel RGBA (4 bytes)
 RLGL.State.defaultTextureId = rlLoadTexture(pixels, 1, 1, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1);
+RLGL.State.currentTextureId = RLGL.State.defaultTextureId;
 if (RLGL.State.defaultTextureId != 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture loaded successfully", RLGL.State.defaultTextureId);
 else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load default texture");
 // Init default Shader (customized for GL 3.3 and ES2)
 // Init internal matrices
 RLGL.State.transform = rlMatrixIdentity();
 RLGL.State.projection = rlMatrixIdentity();
 RLGL.State.modelview = rlMatrixIdentity();
 RLGL.State.currentMatrix = &RLGL.State.modelview;
-#endif  // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+#if defined(GRAPHICS_API_OPENGL_SOFTWARE)
+// Initialize software renderer backend
+int result = swInit(width, height);
+if (result == 0)
+{
+TRACELOG(RL_LOG_ERROR, "RLSW: Software renderer initialization failed!");
+exit(-1);
+}
+#endif
 // Initialize OpenGL default states
 //----------------------------------------------------------
 // Init state: Depth test
 glDepthFunc(GL_LEQUAL);                                 // Type of depth testing to apply
 // NOTE: All shapes/models triangles are drawn CCW
 glCullFace(GL_BACK);                                    // Cull the back face (default)
 glFrontFace(GL_CCW);                                    // Front face are defined counter clockwise (default)
 glEnable(GL_CULL_FACE);                                 // Enable backface culling
-// Init state: Cubemap seamless
-#if defined(GRAPHICS_API_OPENGL_33)
-glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);                 // Seamless cubemaps (not supported on OpenGL ES 2.0)
-#endif
 #if defined(GRAPHICS_API_OPENGL_11)
 // Init state: Color hints (deprecated in OpenGL 3.0+)
 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);      // Improve quality of color and texture coordinate interpolation
 glShadeModel(GL_SMOOTH);                                // Smooth shading between vertex (vertex colors interpolation)
 #endif
+#if defined(GRAPHICS_API_OPENGL_33)
+// Init state: Cubemap seamless
+glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);                 // Seamless cubemaps (not supported on OpenGL ES 2.0)
+#endif
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 // Store screen size into global variables
 RLGL.State.framebufferWidth = width;
 RLGL.State.framebufferHeight = height;
-TRACELOG(RL_LOG_INFO, "RLGL: Default OpenGL state initialized successfully");
-//----------------------------------------------------------
 #endif
 // Init state: Color/Depth buffers clear
 glClearColor(0.0f, 0.0f, 0.0f, 1.0f);                   // Set clear color (black)
 glClearDepth(1.0f);                                     // Set clear depth value (default)
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);     // Clear color and depth buffers (depth buffer required for 3D)
+TRACELOG(RL_LOG_INFO, "RLGL: Default OpenGL state initialized successfully");
+//----------------------------------------------------------
 }
 // Vertex Buffer Object deinitialization (memory free)
 void rlglClose(void)
 {
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 rlUnloadRenderBatch(RLGL.defaultBatch);
-rlUnloadShaderDefault();          // Unload default shader
+rlUnloadShaderDefault(); // Unload default shader
 glDeleteTextures(1, &RLGL.State.defaultTextureId); // Unload default texture
 TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture unloaded successfully", RLGL.State.defaultTextureId);
 #endif
+#if defined(GRAPHICS_API_OPENGL_SOFTWARE)
+swClose(); // Unload sofware renderer resources
+#endif
+isGpuReady = false;
 }
 // Load OpenGL extensions
 // NOTE: External loader function must be provided
 void rlLoadExtensions(void *loader)
 // Get number of supported extensions
 GLint numExt = 0;
 glGetIntegerv(GL_NUM_EXTENSIONS, &numExt);
 TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt);
-#if defined(RLGL_SHOW_GL_DETAILS_INFO)
+#if RLGL_SHOW_GL_DETAILS_INFO
 // Get supported extensions list
 // WARNING: glGetStringi() not available on OpenGL 2.1
 TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:");
 for (int i = 0; i < numExt; i++) TRACELOG(RL_LOG_INFO, "    %s", glGetStringi(GL_EXTENSIONS, i));
 #endif
 #if defined(GRAPHICS_API_OPENGL_43)
 RLGL.ExtSupported.computeShader = GLAD_GL_ARB_compute_shader;
 RLGL.ExtSupported.ssbo = GLAD_GL_ARB_shader_storage_buffer_object;
 #endif
-#endif  // GRAPHICS_API_OPENGL_33
+#endif // GRAPHICS_API_OPENGL_33
 #if defined(GRAPHICS_API_OPENGL_ES3)
 // Register supported extensions flags
 // OpenGL ES 3.0 extensions supported by default (or it should be)
 RLGL.ExtSupported.vao = true;
 else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL ES 2.0 loaded successfully");
 #endif
 // Get supported extensions list
 GLint numExt = 0;
-const char **extList = RL_MALLOC(512*sizeof(const char *)); // Allocate 512 strings pointers (2 KB)
+const char **extList = (const char **)RL_CALLOC(512, sizeof(const char *)); // Allocate 512 strings pointers (2 KB)
 const char *extensions = (const char *)glGetString(GL_EXTENSIONS);  // One big const string
-// NOTE: We have to duplicate string because glGetString() returns a const string
+// NOTE: String duplication rquired because glGetString() returns a const string
-int size = strlen(extensions) + 1;      // Get extensions string size in bytes
+int extensionsLength = (int)strlen(extensions); // Get extensions string size in bytes
-char *extensionsDup = (char *)RL_CALLOC(size, sizeof(char));
+char *extensionsDup = (char *)RL_CALLOC(extensionsLength + 1, sizeof(char)); // Allocate space for copy with additional EOL byte
-strcpy(extensionsDup, extensions);
+strncpy(extensionsDup, extensions, extensionsLength);
 extList[numExt] = extensionsDup;
-for (int i = 0; i < size; i++)
+for (int i = 0; i < extensionsLength; i++)
 {
 if (extensionsDup[i] == ' ')
 {
 extensionsDup[i] = '\0';
 numExt++;
 }
 }
 TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt);
-#if defined(RLGL_SHOW_GL_DETAILS_INFO)
+#if RLGL_SHOW_GL_DETAILS_INFO
 TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:");
 for (int i = 0; i < numExt; i++) TRACELOG(RL_LOG_INFO, "    %s", extList[i]);
 #endif
 // Check required extensions
 if ((glGenVertexArrays != NULL) && (glBindVertexArray != NULL) && (glDeleteVertexArrays != NULL)) RLGL.ExtSupported.vao = true;
 }
 // Check instanced rendering support
-if (strstr(extList[i], (const char*)"instanced_arrays") != NULL)   // Broad check for instanced_arrays
+if (strstr(extList[i], (const char *)"instanced_arrays") != NULL)   // Broad check for instanced_arrays
 {
 // Specific check
 if (strcmp(extList[i], (const char *)"GL_ANGLE_instanced_arrays") == 0)      // ANGLE
 {
 glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedANGLE");
 if (strcmp(extList[i], (const char *)"GL_EXT_draw_instanced") == 0)
 {
 glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedEXT");
 glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedEXT");
 }
-else if (strcmp(extList[i], (const char*)"GL_NV_draw_instanced") == 0)
+else if (strcmp(extList[i], (const char *)"GL_NV_draw_instanced") == 0)
 {
 glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedNV");
 glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedNV");
 }
 if (strcmp(extList[i], (const char *)"GL_OES_texture_float") == 0) RLGL.ExtSupported.texFloat32 = true;
 if (strcmp(extList[i], (const char *)"GL_OES_texture_half_float") == 0) RLGL.ExtSupported.texFloat16 = true;
 // Check depth texture support
 if (strcmp(extList[i], (const char *)"GL_OES_depth_texture") == 0) RLGL.ExtSupported.texDepth = true;
-if (strcmp(extList[i], (const char *)"GL_WEBGL_depth_texture") == 0) RLGL.ExtSupported.texDepthWebGL = true;    // WebGL requires unsized internal format
+if (strcmp(extList[i], (const char *)"GL_WEBGL_depth_texture") == 0) RLGL.ExtSupported.texDepthWebGL = true; // WebGL requires unsized internal format
 if (RLGL.ExtSupported.texDepthWebGL) RLGL.ExtSupported.texDepth = true;
-if (strcmp(extList[i], (const char *)"GL_OES_depth24") == 0) RLGL.ExtSupported.maxDepthBits = 24;   // Not available on WebGL
+if (strcmp(extList[i], (const char *)"GL_OES_depth24") == 0) RLGL.ExtSupported.maxDepthBits = 24; // Not available on WebGL
-if (strcmp(extList[i], (const char *)"GL_OES_depth32") == 0) RLGL.ExtSupported.maxDepthBits = 32;   // Not available on WebGL
+if (strcmp(extList[i], (const char *)"GL_OES_depth32") == 0) RLGL.ExtSupported.maxDepthBits = 32; // Not available on WebGL
 // Check texture compression support: DXT
 if ((strcmp(extList[i], (const char *)"GL_EXT_texture_compression_s3tc") == 0) ||
 (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_s3tc") == 0) ||
 (strcmp(extList[i], (const char *)"GL_WEBKIT_WEBGL_compressed_texture_s3tc") == 0)) RLGL.ExtSupported.texCompDXT = true;
 }
 // Free extensions pointers
 RL_FREE(extList);
 RL_FREE(extensionsDup);    // Duplicated string must be deallocated
-#endif  // GRAPHICS_API_OPENGL_ES2
+#endif // GRAPHICS_API_OPENGL_ES2
 // Check OpenGL information and capabilities
 //------------------------------------------------------------------------------
 // Show current OpenGL and GLSL version
 TRACELOG(RL_LOG_INFO, "GL: OpenGL device information:");
 TRACELOG(RL_LOG_INFO, "    > Renderer: %s", glGetString(GL_RENDERER));
 TRACELOG(RL_LOG_INFO, "    > Version:  %s", glGetString(GL_VERSION));
 TRACELOG(RL_LOG_INFO, "    > GLSL:     %s", glGetString(GL_SHADING_LANGUAGE_VERSION));
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+RLGL.loader = (rlglLoadProc)loader;
 // NOTE: Anisotropy levels capability is an extension
 #ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
 #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
 #endif
 glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &RLGL.ExtSupported.maxAnisotropyLevel);
-#if defined(RLGL_SHOW_GL_DETAILS_INFO)
+#if RLGL_SHOW_GL_DETAILS_INFO
 // Show some OpenGL GPU capabilities
 TRACELOG(RL_LOG_INFO, "GL: OpenGL capabilities:");
 GLint capability = 0;
 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &capability);
 TRACELOG(RL_LOG_INFO, "    GL_MAX_TEXTURE_SIZE: %i", capability);
 #if defined(GRAPHICS_API_OPENGL_43)
 glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &capability);
 TRACELOG(RL_LOG_INFO, "    GL_MAX_VERTEX_ATTRIB_BINDINGS: %i", capability);
 glGetIntegerv(GL_MAX_UNIFORM_LOCATIONS, &capability);
 TRACELOG(RL_LOG_INFO, "    GL_MAX_UNIFORM_LOCATIONS: %i", capability);
-#endif  // GRAPHICS_API_OPENGL_43
+#endif
-#else   // RLGL_SHOW_GL_DETAILS_INFO
+#else   // !RLGL_SHOW_GL_DETAILS_INFO
 // Show some basic info about GL supported features
 if (RLGL.ExtSupported.vao) TRACELOG(RL_LOG_INFO, "GL: VAO extension detected, VAO functions loaded successfully");
 else TRACELOG(RL_LOG_WARNING, "GL: VAO extension not found, VAO not supported");
 if (RLGL.ExtSupported.texNPOT) TRACELOG(RL_LOG_INFO, "GL: NPOT textures extension detected, full NPOT textures supported");
 if (RLGL.ExtSupported.texCompETC2) TRACELOG(RL_LOG_INFO, "GL: ETC2/EAC compressed textures supported");
 if (RLGL.ExtSupported.texCompPVRT) TRACELOG(RL_LOG_INFO, "GL: PVRT compressed textures supported");
 if (RLGL.ExtSupported.texCompASTC) TRACELOG(RL_LOG_INFO, "GL: ASTC compressed textures supported");
 if (RLGL.ExtSupported.computeShader) TRACELOG(RL_LOG_INFO, "GL: Compute shaders supported");
 if (RLGL.ExtSupported.ssbo) TRACELOG(RL_LOG_INFO, "GL: Shader storage buffer objects supported");
-#endif  // RLGL_SHOW_GL_DETAILS_INFO
+#endif
-#endif  // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+}
+// Get OpenGL procedure address
+void *rlGetProcAddress(const char *procName)
+{
+void *func = NULL;
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+func = RLGL.loader(procName);
+#endif
+return func;
 }
 // Get current OpenGL version
 int rlGetVersion(void)
 {
 int glVersion = 0;
-#if defined(GRAPHICS_API_OPENGL_11)
+#if defined(GRAPHICS_API_OPENGL_SOFTWARE)
+glVersion = RL_OPENGL_SOFTWARE;
+#elif defined(GRAPHICS_API_OPENGL_11)
 glVersion = RL_OPENGL_11;
 #endif
 #if defined(GRAPHICS_API_OPENGL_21)
 glVersion = RL_OPENGL_21;
 #elif defined(GRAPHICS_API_OPENGL_43)
 //------------------------------------------------------------------------------------------------
 // Load render batch
 rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements)
 {
 rlRenderBatch batch = { 0 };
+if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return batch; }
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 // Initialize CPU (RAM) vertex buffers (position, texcoord, color data and indexes)
 //--------------------------------------------------------------------------------------------
-batch.vertexBuffer = (rlVertexBuffer *)RL_MALLOC(numBuffers*sizeof(rlVertexBuffer));
+batch.vertexBuffer = (rlVertexBuffer *)RL_CALLOC(numBuffers, sizeof(rlVertexBuffer));
 for (int i = 0; i < numBuffers; i++)
 {
 batch.vertexBuffer[i].elementCount = bufferElements;
-batch.vertexBuffer[i].vertices = (float *)RL_MALLOC(bufferElements*3*4*sizeof(float));        // 3 float by vertex, 4 vertex by quad
+batch.vertexBuffer[i].vertices = (float *)RL_CALLOC(bufferElements*3*4, sizeof(float));     // 3 float by vertex, 4 vertex by quad
-batch.vertexBuffer[i].texcoords = (float *)RL_MALLOC(bufferElements*2*4*sizeof(float));       // 2 float by texcoord, 4 texcoord by quad
+batch.vertexBuffer[i].texcoords = (float *)RL_CALLOC(bufferElements*2*4, sizeof(float));    // 2 float by texcoord, 4 texcoord by quad
-batch.vertexBuffer[i].normals = (float *)RL_MALLOC(bufferElements*3*4*sizeof(float));        // 3 float by vertex, 4 vertex by quad
+batch.vertexBuffer[i].normals = (float *)RL_CALLOC(bufferElements*3*4, sizeof(float));      // 3 float by vertex, 4 vertex by quad
-batch.vertexBuffer[i].colors = (unsigned char *)RL_MALLOC(bufferElements*4*4*sizeof(unsigned char));   // 4 float by color, 4 colors by quad
+batch.vertexBuffer[i].colors = (unsigned char *)RL_CALLOC(bufferElements*4*4, sizeof(unsigned char));   // 4 float by color, 4 colors by quad
 #if defined(GRAPHICS_API_OPENGL_33)
-batch.vertexBuffer[i].indices = (unsigned int *)RL_MALLOC(bufferElements*6*sizeof(unsigned int));      // 6 int by quad (indices)
+batch.vertexBuffer[i].indices = (unsigned int *)RL_CALLOC(bufferElements*6, sizeof(unsigned int));      // 6 int by quad (indices)
 #endif
 #if defined(GRAPHICS_API_OPENGL_ES2)
-batch.vertexBuffer[i].indices = (unsigned short *)RL_MALLOC(bufferElements*6*sizeof(unsigned short));  // 6 int by quad (indices)
+batch.vertexBuffer[i].indices = (unsigned short *)RL_CALLOC(bufferElements*6, sizeof(unsigned short));  // 6 int by quad (indices)
 #endif
 for (int j = 0; j < (3*4*bufferElements); j++) batch.vertexBuffer[i].vertices[j] = 0.0f;
 for (int j = 0; j < (2*4*bufferElements); j++) batch.vertexBuffer[i].texcoords[j] = 0.0f;
 for (int j = 0; j < (3*4*bufferElements); j++) batch.vertexBuffer[i].normals[j] = 0.0f;
 if (RLGL.ExtSupported.vao) glBindVertexArray(0);
 //--------------------------------------------------------------------------------------------
 // Init draw calls tracking system
 //--------------------------------------------------------------------------------------------
-batch.draws = (rlDrawCall *)RL_MALLOC(RL_DEFAULT_BATCH_DRAWCALLS*sizeof(rlDrawCall));
+batch.draws = (rlDrawCall *)RL_CALLOC(RL_DEFAULT_BATCH_DRAWCALLS, sizeof(rlDrawCall));
 for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++)
 {
 batch.draws[i].mode = RL_QUADS;
 batch.draws[i].vertexCount = 0;
 //batch.draws[i].RLGL.State.modelview = rlMatrixIdentity();
 }
 batch.bufferCount = numBuffers;    // Record buffer count
 batch.drawCounter = 1;             // Reset draws counter
-batch.currentDepth = -1.0f;         // Reset depth value
+batch.currentDepth = -1.0f;        // Reset depth value
 //--------------------------------------------------------------------------------------------
 #endif
 return batch;
 }
 RL_FREE(batch.draws);
 #endif
 }
 // Draw render batch
-// NOTE: We require a pointer to reset batch and increase current buffer (multi-buffer)
+// NOTE: Batch is reseted and current buffer is updated (for multi-buffer config)
 void rlDrawRenderBatch(rlRenderBatch *batch)
 {
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 // Update batch vertex buffers
 //------------------------------------------------------------------------------------------------------------
 // NOTE: If there is not vertex data, buffers doesn't need to be updated (vertexCount > 0)
-// TODO: If no data changed on the CPU arrays --> No need to re-update GPU arrays (use a change detector flag?)
 if (RLGL.State.vertexCounter > 0)
 {
 // Activate elements VAO
 if (RLGL.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId);
+// TODO: If no data changed on the CPU arrays there is no need to re-upload data to GPU,
+// a flag can be used to detect changes but it would imply keeping a copy buffer and memcmp() both, does it worth it?
 // Vertex positions buffer
 glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]);
 glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*3*sizeof(float), batch->vertexBuffer[batch->currentBuffer].vertices);
 //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].vertices, GL_DYNAMIC_DRAW);  // Update all buffer
 glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*4*sizeof(unsigned char), batch->vertexBuffer[batch->currentBuffer].colors);
 //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].colors, GL_DYNAMIC_DRAW);    // Update all buffer
 // NOTE: glMapBuffer() causes sync issue
 // If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job
-// To avoid waiting (idle), you can call first glBufferData() with NULL pointer before glMapBuffer()
+// To avoid waiting (idle), glBufferData() can bee called first with NULL pointer before glMapBuffer()
-// If you do that, the previous data in PBO will be discarded and glMapBuffer() returns a new
+// Doing that, the previous data in PBO will be discarded and glMapBuffer() returns a new
 // allocated pointer immediately even if GPU is still working with the previous data
 // Another option: map the buffer object into client's memory
-// Probably this code could be moved somewhere else...
+//batch->vertexBuffer[batch->currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
-// batch->vertexBuffer[batch->currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
+//if (batch->vertexBuffer[batch->currentBuffer].vertices)
-// if (batch->vertexBuffer[batch->currentBuffer].vertices)
+//{
-// {
+//    Update vertex data
-// Update vertex data
+//}
-// }
+//glUnmapBuffer(GL_ARRAY_BUFFER);
-// glUnmapBuffer(GL_ARRAY_BUFFER);
 // Unbind the current VAO
 if (RLGL.ExtSupported.vao) glBindVertexArray(0);
 }
 //------------------------------------------------------------------------------------------------------------
 // NOTE: Batch system accumulates calls by texture0 changes, additional textures are enabled for all the draw calls
 glActiveTexture(GL_TEXTURE0);
 for (int i = 0, vertexOffset = 0; i < batch->drawCounter; i++)
 {
-// Bind current draw call texture, activated as GL_TEXTURE0 and Bound to sampler2D texture0 by default
+// Bind current draw call texture, activated as GL_TEXTURE0 and bound to sampler2D texture0 by default
 glBindTexture(GL_TEXTURE_2D, batch->draws[i].textureId);
 if ((batch->draws[i].mode == RL_LINES) || (batch->draws[i].mode == RL_TRIANGLES)) glDrawArrays(batch->draws[i].mode, vertexOffset, batch->draws[i].vertexCount);
 else
 {
 #if defined(GRAPHICS_API_OPENGL_33)
-// We need to define the number of indices to be processed: elementCount*6
+// The number of indices to be processed needs to be defined: elementCount*6
 // NOTE: The final parameter tells the GPU the offset in bytes from the
 // start of the index buffer to the location of the first index to process
 glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_INT, (GLvoid *)(vertexOffset/4*6*sizeof(GLuint)));
 #endif
 #if defined(GRAPHICS_API_OPENGL_ES2)
 int currentMode = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode;
 int currentTexture = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId;
 rlDrawRenderBatch(RLGL.currentBatch);    // NOTE: Stereo rendering is checked inside
-// Restore state of last batch so we can continue adding vertices
+// Restore state of last batch so new vertices can be added
 RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = currentMode;
 RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = currentTexture;
 }
 #endif
 //-----------------------------------------------------------------------------------------
 // Convert image data to OpenGL texture (returns OpenGL valid Id)
 unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount)
 {
 unsigned int id = 0;
+if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return id; }
 glBindTexture(GL_TEXTURE_2D, 0);    // Free any old binding
 // Check texture format support by OpenGL 1.1 (compressed textures not supported)
 #if defined(GRAPHICS_API_OPENGL_11)
 if (format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)
 {
+// TODO: Support texture data decompression
 TRACELOG(RL_LOG_WARNING, "GL: OpenGL 1.1 does not support GPU compressed texture formats");
 return id;
 }
 #else
 if ((!RLGL.ExtSupported.texCompDXT) && ((format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA) ||
 {
 TRACELOG(RL_LOG_WARNING, "GL: ASTC compressed texture format not supported");
 return id;
 }
 #endif
-#endif  // GRAPHICS_API_OPENGL_11
+#endif // GRAPHICS_API_OPENGL_11
 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 glGenTextures(1, &id);              // Generate texture id
 glBindTexture(GL_TEXTURE_2D, id);
 int mipWidth = width;
 int mipHeight = height;
 int mipOffset = 0;          // Mipmap data offset, only used for tracelog
+(void)mipOffset;            // Used to avoid gcc warnings about unused variable
 // NOTE: Added pointer math separately from function to avoid UBSAN complaining
 unsigned char *dataPtr = NULL;
 if (data != NULL) dataPtr = (unsigned char *)data;
 unsigned int mipSize = rlGetPixelDataSize(mipWidth, mipHeight, format);
 unsigned int glInternalFormat, glFormat, glType;
 rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
-TRACELOGD("TEXTURE: Load mipmap level %i (%i x %i), size: %i, offset: %i", i, mipWidth, mipHeight, mipSize, mipOffset);
+TRACELOG(RL_LOG_DEBUG, "TEXTURE: Load mipmap level %i (%i x %i), size: %i, offset: %i", i, mipWidth, mipHeight, mipSize, mipOffset);
 if (glInternalFormat != 0)
 {
 if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, glFormat, glType, dataPtr);
 #if !defined(GRAPHICS_API_OPENGL_11)
 #endif
 }
 mipWidth /= 2;
 mipHeight /= 2;
-mipOffset += mipSize;       // Increment offset position to next mipmap
+mipOffset += mipSize; // Increment offset position to next mipmap
-if (data != NULL) dataPtr += mipSize;         // Increment data pointer to next mipmap
+if (data != NULL) dataPtr += mipSize; // Increment data pointer to next mipmap
 // Security check for NPOT textures
 if (mipWidth < 1) mipWidth = 1;
 if (mipHeight < 1) mipHeight = 1;
 }
 // Texture parameters configuration
-// NOTE: glTexParameteri does NOT affect texture uploading, just the way it's used
+// NOTE: glTexParameteri does NOT affect texture uploading
 #if defined(GRAPHICS_API_OPENGL_ES2)
 // NOTE: OpenGL ES 2.0 with no GL_OES_texture_npot support (i.e. WebGL) has limited NPOT support, so CLAMP_TO_EDGE must be used
 if (RLGL.ExtSupported.texNPOT)
 {
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);       // Set texture to repeat on x-axis
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);  // Alternative: GL_LINEAR
 #if defined(GRAPHICS_API_OPENGL_33)
 if (mipmapCount > 1)
 {
-// Activate Trilinear filtering if mipmaps are available
+// Activate trilinear filtering if mipmaps are available
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-}
-#endif
+// Define the maximum number of mipmap levels to be used, 0 is base texture size
+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
-// At this point we have the texture loaded in GPU and texture parameters configured
+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, mipmapCount - 1);
+// Check if the loaded texture with mipmaps is complete,
+// uncomplete textures will draw in black if mipmap filtering is required
+//GLint complete = 0;
+//glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_FORMAT, &complete);
+}
+#endif
+// At this point texture is loaded in GPU and texture parameters configured
 // NOTE: If mipmaps were not in data, they are not generated automatically
 // Unbind current texture
 glBindTexture(GL_TEXTURE_2D, 0);
 // Load depth texture/renderbuffer (to be attached to fbo)
 // WARNING: OpenGL ES 2.0 requires GL_OES_depth_texture and WebGL requires WEBGL_depth_texture extensions
 unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer)
 {
 unsigned int id = 0;
+if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return id; }
-#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
-// In case depth textures not supported, we force renderbuffer usage
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+// In case depth textures were not supported, force renderbuffer usage
 if (!RLGL.ExtSupported.texDepth) useRenderBuffer = true;
-// NOTE: We let the implementation to choose the best bit-depth
+// NOTE: Letting the implementation to choose the best bit-depth
 // Possible formats: GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32 and GL_DEPTH_COMPONENT32F
 unsigned int glInternalFormat = GL_DEPTH_COMPONENT;
-#if (defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_ES3))
+#if defined(GRAPHICS_API_OPENGL_ES2)
 // WARNING: WebGL platform requires unsized internal format definition (GL_DEPTH_COMPONENT)
 // while other platforms using OpenGL ES 2.0 require/support sized internal formats depending on the GPU capabilities
 if (!RLGL.ExtSupported.texDepthWebGL || useRenderBuffer)
 {
 if (RLGL.ExtSupported.maxDepthBits == 32) glInternalFormat = GL_DEPTH_COMPONENT32_OES;
 else if (RLGL.ExtSupported.maxDepthBits == 24) glInternalFormat = GL_DEPTH_COMPONENT24_OES;
 else glInternalFormat = GL_DEPTH_COMPONENT16;
 }
+#endif
+#if defined(GRAPHICS_API_OPENGL_ES3)
+// NOTE: This sized internal format should also work for WebGL 2.0
+// WARNING: Specification only allows GL_DEPTH_COMPONENT32F for GL_FLOAT type
+// REF: https://registry.khronos.org/OpenGL-Refpages/es3.0/html/glTexImage2D.xhtml
+if (RLGL.ExtSupported.maxDepthBits == 24) glInternalFormat = GL_DEPTH_COMPONENT24;
+else glInternalFormat = GL_DEPTH_COMPONENT16;
 #endif
 if (!useRenderBuffer && RLGL.ExtSupported.texDepth)
 {
 glGenTextures(1, &id);
 glBindRenderbuffer(GL_RENDERBUFFER, 0);
 TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Depth renderbuffer loaded successfully (%i bits)", id, (RLGL.ExtSupported.maxDepthBits >= 24)? RLGL.ExtSupported.maxDepthBits : 16);
 }
+#elif defined(GRAPHICS_API_OPENGL_SOFTWARE)
+// NOTE: Renderbuffers are the same type of object as textures in rlsw
+// WARNING: Ensure that the depth format is the one specified at rlsw compilation
+glGenRenderbuffers(1, &id);
+glBindRenderbuffer(GL_RENDERBUFFER, id);
+glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT32, width, height);
+glBindRenderbuffer(GL_RENDERBUFFER, 0);
 #endif
 return id;
 }
 // NOTE: Cubemap data is expected to be 6 images in a single data array (one after the other),
 // expected the following convention: +X, -X, +Y, -Y, +Z, -Z
 unsigned int rlLoadTextureCubemap(const void *data, int size, int format, int mipmapCount)
 {
 unsigned int id = 0;
+if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return id; }
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 int mipSize = size;
 // NOTE: Added pointer math separately from function to avoid UBSAN complaining
 if (data == NULL)
 {
 if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)
 {
 if ((format == RL_PIXELFORMAT_UNCOMPRESSED_R32) ||
 (format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32) ||
 (format == RL_PIXELFORMAT_UNCOMPRESSED_R16) ||
 (format == RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16)) TRACELOG(RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported");
 else glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mipmapLevel, glInternalFormat, mipSize, mipSize, 0, glFormat, glType, NULL);
 }
 else TRACELOG(RL_LOG_WARNING, "TEXTURES: Empty cubemap creation does not support compressed format");
 }
 return id;
 }
 // Update already loaded texture in GPU with new data
-// NOTE: We don't know safely if internal texture format is the expected one...
+// WARNING: Not possible to know safely if internal texture format is the expected one...
 void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data)
 {
 glBindTexture(GL_TEXTURE_2D, id);
 unsigned int glInternalFormat, glFormat, glType;
 // Generate mipmap data for selected texture
 // NOTE: Only supports GPU mipmap generation
 void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps)
 {
+if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return; }
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 glBindTexture(GL_TEXTURE_2D, id);
 // Check if texture is power-of-two (POT)
 bool texIsPOT = false;
 void *pixels = NULL;
 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
 glBindTexture(GL_TEXTURE_2D, id);
-// NOTE: Using texture id, we can retrieve some texture info (but not on OpenGL ES 2.0)
+// NOTE: Using texture id, some texture info can be retrieved (but not on OpenGL ES 2.0)
 // Possible texture info: GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE
 //int width, height, format;
 //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
 //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height);
 //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format);
 rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
 unsigned int size = rlGetPixelDataSize(width, height, format);
 if ((glInternalFormat != 0) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB))
 {
-pixels = RL_MALLOC(size);
+pixels = RL_CALLOC(size, 1);
 glGetTexImage(GL_TEXTURE_2D, 0, glFormat, glType, pixels);
 }
 else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Data retrieval not suported for pixel format (%i)", id, format);
 glBindTexture(GL_TEXTURE_2D, 0);
 // glGetTexImage() is not available on OpenGL ES 2.0
 // Texture width and height are required on OpenGL ES 2.0, there is no way to get it from texture id
 // Two possible Options:
 // 1 - Bind texture to color fbo attachment and glReadPixels()
 // 2 - Create an fbo, activate it, render quad with texture, glReadPixels()
-// We are using Option 1, just need to care for texture format on retrieval
+// Using Option 1, care for texture format on retrieval
 // NOTE: This behaviour could be conditioned by graphic driver...
 unsigned int fboId = rlLoadFramebuffer();
 glBindFramebuffer(GL_FRAMEBUFFER, fboId);
 glBindTexture(GL_TEXTURE_2D, 0);
 // Attach our texture to FBO
 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id, 0);
-// We read data as RGBA because FBO texture is configured as RGBA, despite binding another texture format
+// Reading data as RGBA because FBO texture is configured as RGBA, despite binding another texture format
-pixels = (unsigned char *)RL_MALLOC(rlGetPixelDataSize(width, height, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8));
+pixels = RL_CALLOC(rlGetPixelDataSize(width, height, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8), 1);
 glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 glBindFramebuffer(GL_FRAMEBUFFER, 0);
 // Clean up temporal fbo
 #endif
 return pixels;
 }
+// Copy framebuffer pixel data to internal buffer
+void rlCopyFramebuffer(int x, int y, int width, int height, int format, void *pixels)
+{
+#if defined(GRAPHICS_API_OPENGL_SOFTWARE)
+unsigned int glInternalFormat, glFormat, glType;
+rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); // Get OpenGL texture format
+swReadPixels(x, y, width, height, glFormat, glType, pixels);
+#endif
+}
+// Resize internal framebuffer
+void rlResizeFramebuffer(int width, int height)
+{
+#if defined(GRAPHICS_API_OPENGL_SOFTWARE)
+swResize(width, height);
+#endif
+}
 // Read screen pixel data (color buffer)
 unsigned char *rlReadScreenPixels(int width, int height)
 {
-unsigned char *screenData = (unsigned char *)RL_CALLOC(width*height*4, sizeof(unsigned char));
+unsigned char *imgData = (unsigned char *)RL_CALLOC(width*height*4, sizeof(unsigned char));
-// NOTE 1: glReadPixels returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer
+// NOTE: glReadPixels() returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer
-// NOTE 2: We are getting alpha channel! Be careful, it can be transparent if not cleared properly!
+// WARNING: Getting alpha channel! Be careful, it can be transparent if not cleared properly!
-glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, screenData);
+glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, imgData);
-// Flip image vertically!
+// Flip image vertically
-unsigned char *imgData = (unsigned char *)RL_MALLOC(width*height*4*sizeof(unsigned char));
+// NOTE: Alpha value has already been applied to RGB in framebuffer, not needed anymore
+for (int y = height - 1; y >= height/2; y--)
-for (int y = height - 1; y >= 0; y--)
+{
-{
+for (int x = 0; x < (width*4); x += 4)
-for (int x = 0; x < (width*4); x++)
 {
-imgData[((height - 1) - y)*width*4 + x] = screenData[(y*width*4) + x];  // Flip line
+unsigned int s = ((height - 1) - y)*width*4 + x;
+unsigned int e = y*width*4 + x;
-// Set alpha component value to 255 (no trasparent image retrieval)
-// NOTE: Alpha value has already been applied to RGB in framebuffer, we don't need it!
+unsigned char r = imgData[s];
-if (((x + 1)%4) == 0) imgData[((height - 1) - y)*width*4 + x] = 255;
+unsigned char g = imgData[s+1];
+unsigned char b = imgData[s+2];
+imgData[s] = imgData[e];
+imgData[s+1] = imgData[e+1];
+imgData[s+2] = imgData[e+2];
+imgData[s+3] = 255; // Set alpha component value to 255 (no trasparent image retrieval)
+imgData[e] = r;
+imgData[e+1] = g;
+imgData[e+2] = b;
+imgData[e+3] = 255; // Ditto
 }
 }
-RL_FREE(screenData);
 return imgData;     // NOTE: image data should be freed
 }
 // Framebuffer management (fbo)
 // Load a framebuffer to be used for rendering
 // NOTE: No textures attached
 unsigned int rlLoadFramebuffer(void)
 {
 unsigned int fboId = 0;
+if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return fboId; }
-#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
-glGenFramebuffers(1, &fboId);       // Create the framebuffer object
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
-glBindFramebuffer(GL_FRAMEBUFFER, 0);   // Unbind any framebuffer
+glGenFramebuffers(1, &fboId);         // Create the framebuffer object
+glBindFramebuffer(GL_FRAMEBUFFER, 0); // Unbind any framebuffer
 #endif
 return fboId;
 }
-// Attach color buffer texture to an fbo (unloads previous attachment)
+// Attach color buffer texture to a framebuffer object (unloads previous attachment)
 // NOTE: Attach type: 0-Color, 1-Depth renderbuffer, 2-Depth texture
-void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel)
+void rlFramebufferAttach(unsigned int id, unsigned int texId, int attachType, int texType, int mipLevel)
 {
-#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
-glBindFramebuffer(GL_FRAMEBUFFER, fboId);
+glBindFramebuffer(GL_FRAMEBUFFER, id);
 switch (attachType)
 {
 case RL_ATTACHMENT_COLOR_CHANNEL0:
 case RL_ATTACHMENT_COLOR_CHANNEL1:
 case RL_ATTACHMENT_COLOR_CHANNEL7:
 {
 if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_2D, texId, mipLevel);
 else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_RENDERBUFFER, texId);
 else if (texType >= RL_ATTACHMENT_CUBEMAP_POSITIVE_X) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_CUBE_MAP_POSITIVE_X + texType, texId, mipLevel);
 } break;
 case RL_ATTACHMENT_DEPTH:
 {
 if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel);
 else if (texType == RL_ATTACHMENT_RENDERBUFFER)  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, texId);
 } break;
 case RL_ATTACHMENT_STENCIL:
 {
 if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel);
 else if (texType == RL_ATTACHMENT_RENDERBUFFER)  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, texId);
 } break;
 default: break;
 }
 glBindFramebuffer(GL_FRAMEBUFFER, 0);
 // Verify render texture is complete
 bool rlFramebufferComplete(unsigned int id)
 {
 bool result = false;
-#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
 glBindFramebuffer(GL_FRAMEBUFFER, id);
 GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
 if (status != GL_FRAMEBUFFER_COMPLETE)
 // Unload framebuffer from GPU memory
 // NOTE: All attached textures/cubemaps/renderbuffers are also deleted
 void rlUnloadFramebuffer(unsigned int id)
 {
-#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT)
+#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
 // Query depth attachment to automatically delete texture/renderbuffer
-int depthType = 0, depthId = 0;
+int depthType = 0;
 glBindFramebuffer(GL_FRAMEBUFFER, id);   // Bind framebuffer to query depth texture type
 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &depthType);
-// TODO: Review warning retrieving object name in WebGL
 // WARNING: WebGL: INVALID_ENUM: getFramebufferAttachmentParameter: invalid parameter name
-// https://registry.khronos.org/webgl/specs/latest/1.0/
+// REF: https://registry.khronos.org/webgl/specs/latest/1.0/
+int depthId = 0;
 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &depthId);
 unsigned int depthIdU = (unsigned int)depthId;
 if (depthType == GL_RENDERBUFFER) glDeleteRenderbuffers(1, &depthIdU);
 else if (depthType == GL_TEXTURE) glDeleteTextures(1, &depthIdU);
 //-----------------------------------------------------------------------------------------
 // Load a new attributes buffer
 unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic)
 {
 unsigned int id = 0;
+if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return id; }
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 glGenBuffers(1, &id);
 glBindBuffer(GL_ARRAY_BUFFER, id);
 glBufferData(GL_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
 // Load a new attributes element buffer
 unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic)
 {
 unsigned int id = 0;
+if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return id; }
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 glGenBuffers(1, &id);
 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
 glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
 // Draw vertex array instanced
 void rlDrawVertexArrayInstanced(int offset, int count, int instances)
 {
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
-glDrawArraysInstanced(GL_TRIANGLES, 0, count, instances);
+glDrawArraysInstanced(GL_TRIANGLES, offset, count, instances);
 #endif
 }
 // Draw vertex array elements instanced
 void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances)
 glDrawElementsInstanced(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)bufferPtr, instances);
 #endif
 }
-#if defined(GRAPHICS_API_OPENGL_11)
 // Enable vertex state pointer
 void rlEnableStatePointer(int vertexAttribType, void *buffer)
 {
+#if defined(GRAPHICS_API_OPENGL_11)
 if (buffer != NULL) glEnableClientState(vertexAttribType);
 switch (vertexAttribType)
 {
 case GL_VERTEX_ARRAY: glVertexPointer(3, GL_FLOAT, 0, buffer); break;
 case GL_TEXTURE_COORD_ARRAY: glTexCoordPointer(2, GL_FLOAT, 0, buffer); break;
 case GL_NORMAL_ARRAY: if (buffer != NULL) glNormalPointer(GL_FLOAT, 0, buffer); break;
 case GL_COLOR_ARRAY: if (buffer != NULL) glColorPointer(4, GL_UNSIGNED_BYTE, 0, buffer); break;
 //case GL_INDEX_ARRAY: if (buffer != NULL) glIndexPointer(GL_SHORT, 0, buffer); break; // Indexed colors
 default: break;
 }
+#endif
 }
 // Disable vertex state pointer
 void rlDisableStatePointer(int vertexAttribType)
 {
+#if defined(GRAPHICS_API_OPENGL_11)
 glDisableClientState(vertexAttribType);
-}
+#endif
-#endif
+}
 // Load vertex array object (VAO)
 unsigned int rlLoadVertexArray(void)
 {
 unsigned int vaoId = 0;
-#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return vaoId; }
-if (RLGL.ExtSupported.vao)
-{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
-glGenVertexArrays(1, &vaoId);
+if (RLGL.ExtSupported.vao) glGenVertexArrays(1, &vaoId);
-}
+#endif
-#endif
 return vaoId;
 }
 // Set vertex attribute
 void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, int offset)
 #endif
 }
 // Shaders management
 //-----------------------------------------------------------------------------------------------
-// Load shader from code strings
+// Load (compile) shader and return shader id
+unsigned int rlLoadShader(const char *code, int type)
+{
+unsigned int shaderId = 0;
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+shaderId = glCreateShader(type);
+glShaderSource(shaderId, 1, &code, NULL);
+GLint success = 0;
+glCompileShader(shaderId);
+glGetShaderiv(shaderId, GL_COMPILE_STATUS, &success);
+if (success == GL_FALSE)
+{
+switch (type)
+{
+case GL_VERTEX_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile vertex shader code", shaderId); break;
+case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile fragment shader code", shaderId); break;
+//case GL_GEOMETRY_SHADER:
+#if defined(GRAPHICS_API_OPENGL_43)
+case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile compute shader code", shaderId); break;
+#elif defined(GRAPHICS_API_OPENGL_33)
+case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", shaderId); break;
+#endif
+default: break;
+}
+int maxLength = 0;
+glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &maxLength);
+if (maxLength > 0)
+{
+int length = 0;
+char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
+glGetShaderInfoLog(shaderId, maxLength, &length, log);
+TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shaderId, log);
+RL_FREE(log);
+}
+// Unload object allocated by glCreateShader(),
+// despite failing in the compilation process
+glDeleteShader(shaderId);
+shaderId = 0;
+}
+else
+{
+switch (type)
+{
+case GL_VERTEX_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Vertex shader compiled successfully", shaderId); break;
+case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Fragment shader compiled successfully", shaderId); break;
+//case GL_GEOMETRY_SHADER:
+#if defined(GRAPHICS_API_OPENGL_43)
+case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader compiled successfully", shaderId); break;
+#elif defined(GRAPHICS_API_OPENGL_33)
+case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", shaderId); break;
+#endif
+default: break;
+}
+}
+#endif
+return shaderId;
+}
+// Load shader program from code strings
 // NOTE: If shader string is NULL, using default vertex/fragment shaders
-unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode)
+unsigned int rlLoadShaderProgram(const char *vsCode, const char *fsCode)
 {
-unsigned int id = 0;
+unsigned int id = 0; // Shader program id
+if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return id; }
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 unsigned int vertexShaderId = 0;
 unsigned int fragmentShaderId = 0;
 // Compile vertex shader (if provided)
 // NOTE: If not vertex shader is provided, use default one
-if (vsCode != NULL) vertexShaderId = rlCompileShader(vsCode, GL_VERTEX_SHADER);
+if (vsCode != NULL) vertexShaderId = rlLoadShader(vsCode, GL_VERTEX_SHADER);
 else vertexShaderId = RLGL.State.defaultVShaderId;
 // Compile fragment shader (if provided)
 // NOTE: If not vertex shader is provided, use default one
-if (fsCode != NULL) fragmentShaderId = rlCompileShader(fsCode, GL_FRAGMENT_SHADER);
+if (fsCode != NULL) fragmentShaderId = rlLoadShader(fsCode, GL_FRAGMENT_SHADER);
 else fragmentShaderId = RLGL.State.defaultFShaderId;
-// In case vertex and fragment shader are the default ones, no need to recompile, we can just assign the default shader program id
+// In case vertex and fragment shader are the default ones, no need to recompile, assign the default shader program id
 if ((vertexShaderId == RLGL.State.defaultVShaderId) && (fragmentShaderId == RLGL.State.defaultFShaderId)) id = RLGL.State.defaultShaderId;
 else if ((vertexShaderId > 0) && (fragmentShaderId > 0))
 {
-// One of or both shader are new, we need to compile a new shader program
+// One of or both shader are new, a new shader program needs to be compiled
-id = rlLoadShaderProgram(vertexShaderId, fragmentShaderId);
+id = rlLoadShaderProgramEx(vertexShaderId, fragmentShaderId);
-// We can detach and delete vertex/fragment shaders (if not default ones)
+// Detaching and deleting vertex/fragment shaders (if not default ones)
-// NOTE: We detach shader before deletion to make sure memory is freed
+// WARNING: Detach shader before deletion to make sure memory is freed
 if (vertexShaderId != RLGL.State.defaultVShaderId)
 {
 // WARNING: Shader program linkage could fail and returned id is 0
 if (id > 0) glDetachShader(id, vertexShaderId);
 glDeleteShader(vertexShaderId);
 // WARNING: Shader program linkage could fail and returned id is 0
 if (id > 0) glDetachShader(id, fragmentShaderId);
 glDeleteShader(fragmentShaderId);
 }
-// In case shader program loading failed, we assign default shader
+// In case shader program loading failed, assign default shader
 if (id == 0)
 {
-// In case shader loading fails, we return the default shader
+// In case shader loading fails, reassigning default shader
 TRACELOG(RL_LOG_WARNING, "SHADER: Failed to load custom shader code, using default shader");
 id = RLGL.State.defaultShaderId;
 }
 /*
 else
 // Get the name of the uniforms
 glGetActiveUniform(id, i, sizeof(name) - 1, &namelen, &num, &type, name);
 name[namelen] = 0;
-TRACELOGD("SHADER: [ID %i] Active uniform (%s) set at location: %i", id, name, glGetUniformLocation(id, name));
+TRACELOG(RL_LOG_DEBUG, "SHADER: [ID %i] Active uniform (%s) set at location: %i", id, name, glGetUniformLocation(id, name));
 }
 }
 */
 }
 #endif
 return id;
 }
-// Compile custom shader and return shader id
+// Load shader program from already loaded shader ids
-unsigned int rlCompileShader(const char *shaderCode, int type)
+unsigned int rlLoadShaderProgramEx(unsigned int vsId, unsigned int fsId)
 {
-unsigned int shader = 0;
+unsigned int programId = 0;
+if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return programId; }
-#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
-shader = glCreateShader(type);
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
-glShaderSource(shader, 1, &shaderCode, NULL);
 GLint success = 0;
-glCompileShader(shader);
+programId = glCreateProgram();
-glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
+glAttachShader(programId, vsId);
+glAttachShader(programId, fsId);
+// Default attribute shader locations must be bound before linking
+// NOTE: There is no problem with binding a generic attribute index to an attribute variable name
+// that is never used; if some attrib name is no found on the shader, it locations becomes -1
+glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION, RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION);
+glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD);
+glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL, RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL);
+glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR);
+glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT, RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT);
+glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2);
+glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM, RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCETRANSFORM);
+glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES, RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES);
+glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS, RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS);
+glLinkProgram(programId);
+// NOTE: All uniform variables are intitialised to 0 when a program links
+glGetProgramiv(programId, GL_LINK_STATUS, &success);
 if (success == GL_FALSE)
 {
-switch (type)
+TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link shader program", programId);
-{
-case GL_VERTEX_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile vertex shader code", shader); break;
-case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile fragment shader code", shader); break;
-//case GL_GEOMETRY_SHADER:
-#if defined(GRAPHICS_API_OPENGL_43)
-case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile compute shader code", shader); break;
-#elif defined(GRAPHICS_API_OPENGL_33)
-case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", shader); break;
-#endif
-default: break;
-}
 int maxLength = 0;
-glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
+glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &maxLength);
 if (maxLength > 0)
 {
 int length = 0;
 char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
-glGetShaderInfoLog(shader, maxLength, &length, log);
+glGetProgramInfoLog(programId, maxLength, &length, log);
-TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shader, log);
+TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", programId, log);
 RL_FREE(log);
 }
-shader = 0;
+glDeleteProgram(programId);
+programId = 0;
 }
 else
 {
-switch (type)
+// Get the size of compiled shader program (not available on OpenGL ES 2.0)
-{
+// NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero
-case GL_VERTEX_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Vertex shader compiled successfully", shader); break;
+//GLint binarySize = 0;
-case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Fragment shader compiled successfully", shader); break;
+//glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize);
-//case GL_GEOMETRY_SHADER:
-#if defined(GRAPHICS_API_OPENGL_43)
+TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Program shader loaded successfully", programId);
-case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader compiled successfully", shader); break;
+}
-#elif defined(GRAPHICS_API_OPENGL_33)
+#endif
-case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", shader); break;
+return programId;
-#endif
+}
-default: break;
-}
+// Load compute shader program
-}
+unsigned int rlLoadShaderProgramCompute(unsigned int csId)
-#endif
+{
+unsigned int programId = 0;
-return shader;
-}
+#if defined(GRAPHICS_API_OPENGL_43)
-// Load custom shader strings and return program id
-unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId)
-{
-unsigned int program = 0;
-#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 GLint success = 0;
-program = glCreateProgram();
+programId = glCreateProgram();
-glAttachShader(program, vShaderId);
+glAttachShader(programId, csId);
-glAttachShader(program, fShaderId);
+glLinkProgram(programId);
-// NOTE: Default attribute shader locations must be Bound before linking
-glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION, RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION);
-glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD);
-glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL, RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL);
-glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR);
-glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT, RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT);
-glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2);
-#ifdef RL_SUPPORT_MESH_GPU_SKINNING
-glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEIDS, RL_DEFAULT_SHADER_ATTRIB_NAME_BONEIDS);
-glBindAttribLocation(program, RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS, RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS);
-#endif
-// NOTE: If some attrib name is no found on the shader, it locations becomes -1
-glLinkProgram(program);
 // NOTE: All uniform variables are intitialised to 0 when a program links
-glGetProgramiv(program, GL_LINK_STATUS, &success);
+glGetProgramiv(programId, GL_LINK_STATUS, &success);
 if (success == GL_FALSE)
 {
-TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link shader program", program);
+TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link compute shader program", programId);
 int maxLength = 0;
-glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
+glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &maxLength);
 if (maxLength > 0)
 {
 int length = 0;
 char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
-glGetProgramInfoLog(program, maxLength, &length, log);
+glGetProgramInfoLog(programId, maxLength, &length, log);
-TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log);
+TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", programId, log);
 RL_FREE(log);
 }
-glDeleteProgram(program);
+glDeleteProgram(programId);
-program = 0;
+programId = 0;
 }
 else
 {
 // Get the size of compiled shader program (not available on OpenGL ES 2.0)
 // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero
 //GLint binarySize = 0;
 //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize);
-TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Program shader loaded successfully", program);
+TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader program loaded successfully", programId);
 }
-#endif
+#else
-return program;
+TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not supported, enable GRAPHICS_API_OPENGL_43");
+#endif
+return programId;
+}
+// Delete shader
+void rlUnloadShader(unsigned int id)
+{
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
+glDeleteShader(id);
+TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Unloaded shader data from VRAM (GPU)", id);
+#endif
 }
 // Unload shader program
 void rlUnloadShaderProgram(unsigned int id)
 {
 TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Unloaded shader program data from VRAM (GPU)", id);
 #endif
 }
 // Get shader location uniform
-int rlGetLocationUniform(unsigned int shaderId, const char *uniformName)
+// NOTE: First parameter refers to shader program id
+int rlGetLocationUniform(unsigned int id, const char *uniformName)
 {
 int location = -1;
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
-location = glGetUniformLocation(shaderId, uniformName);
+location = glGetUniformLocation(id, uniformName);
 //if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader uniform: %s", shaderId, uniformName);
 //else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader uniform (%s) set at location: %i", shaderId, uniformName, location);
 #endif
 return location;
 }
 // Get shader location attribute
-int rlGetLocationAttrib(unsigned int shaderId, const char *attribName)
+// NOTE: First parameter refers to shader program id
+int rlGetLocationAttrib(unsigned int id, const char *attribName)
 {
 int location = -1;
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
-location = glGetAttribLocation(shaderId, attribName);
+location = glGetAttribLocation(id, attribName);
 //if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader attribute: %s", shaderId, attribName);
 //else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader attribute (%s) set at location: %i", shaderId, attribName, location);
 #endif
 return location;
 case RL_SHADER_UNIFORM_UIVEC3: glUniform3uiv(locIndex, count, (unsigned int *)value); break;
 case RL_SHADER_UNIFORM_UIVEC4: glUniform4uiv(locIndex, count, (unsigned int *)value); break;
 #endif
 case RL_SHADER_UNIFORM_SAMPLER2D: glUniform1iv(locIndex, count, (int *)value); break;
 default: TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set uniform value, data type not recognized");
-// TODO: Support glUniform1uiv(), glUniform2uiv(), glUniform3uiv(), glUniform4uiv()
 }
 #endif
 }
 // Set shader value attribute
 // Set shader value uniform matrix
 void rlSetUniformMatrix(int locIndex, Matrix mat)
 {
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
-float matfloat[16] = {
+glUniformMatrix4fv(locIndex, 1, false, rlMatrixToFloat(mat));
-mat.m0, mat.m1, mat.m2, mat.m3,
-mat.m4, mat.m5, mat.m6, mat.m7,
-mat.m8, mat.m9, mat.m10, mat.m11,
-mat.m12, mat.m13, mat.m14, mat.m15
-};
-glUniformMatrix4fv(locIndex, 1, false, matfloat);
 #endif
 }
 // Set shader value uniform matrix
 void rlSetUniformMatrices(int locIndex, const Matrix *matrices, int count)
 rlDrawRenderBatch(RLGL.currentBatch);
 RLGL.State.currentShaderId = id;
 RLGL.State.currentShaderLocs = locs;
 }
 #endif
-}
-// Load compute shader program
-unsigned int rlLoadComputeShaderProgram(unsigned int shaderId)
-{
-unsigned int program = 0;
-#if defined(GRAPHICS_API_OPENGL_43)
-GLint success = 0;
-program = glCreateProgram();
-glAttachShader(program, shaderId);
-glLinkProgram(program);
-// NOTE: All uniform variables are intitialised to 0 when a program links
-glGetProgramiv(program, GL_LINK_STATUS, &success);
-if (success == GL_FALSE)
-{
-TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link compute shader program", program);
-int maxLength = 0;
-glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
-if (maxLength > 0)
-{
-int length = 0;
-char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
-glGetProgramInfoLog(program, maxLength, &length, log);
-TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log);
-RL_FREE(log);
-}
-glDeleteProgram(program);
-program = 0;
-}
-else
-{
-// Get the size of compiled shader program (not available on OpenGL ES 2.0)
-// NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero
-//GLint binarySize = 0;
-//glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize);
-TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader program loaded successfully", program);
-}
-#else
-TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43");
-#endif
-return program;
 }
 // Dispatch compute shader (equivalent to *draw* for graphics pilepine)
 void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ)
 {
 #if defined(GRAPHICS_API_OPENGL_43)
 glDeleteBuffers(1, &ssboId);
 #else
 TRACELOG(RL_LOG_WARNING, "SSBO: SSBO not enabled. Define GRAPHICS_API_OPENGL_43");
 #endif
 }
 // Update SSBO buffer data
 void rlUpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset)
 {
 }
 // Get SSBO buffer size
 unsigned int rlGetShaderBufferSize(unsigned int id)
 {
+unsigned int result = 0;
 #if defined(GRAPHICS_API_OPENGL_43)
 GLint64 size = 0;
 glBindBuffer(GL_SHADER_STORAGE_BUFFER, id);
 glGetBufferParameteri64v(GL_SHADER_STORAGE_BUFFER, GL_BUFFER_SIZE, &size);
-return (size > 0)? (unsigned int)size : 0;
+if (size > 0) result = (unsigned int)size;
-#else
+#endif
-return 0;
+return result;
-#endif
 }
 // Read SSBO buffer data (GPU->CPU)
 void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset)
 {
 Matrix rlGetMatrixTransform(void)
 {
 Matrix mat = rlMatrixIdentity();
 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 // TODO: Consider possible transform matrices in the RLGL.State.stack
-// Is this the right order? or should we start with the first stored matrix instead of the last one?
 //Matrix matStackTransform = rlMatrixIdentity();
 //for (int i = RLGL.State.stackCounter; i > 0; i--) matStackTransform = rlMatrixMultiply(RLGL.State.stack[i], matStackTransform);
 mat = RLGL.State.transform;
 #endif
 return mat;
 }
 default: return "UNKNOWN"; break;
 }
 }
 //----------------------------------------------------------------------------------
-// Module specific Functions Definition
+// Module Functions Definition
 //----------------------------------------------------------------------------------
 #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: Loaded: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs
 "}                                  \n";
 #endif
 // NOTE: Compiled vertex/fragment shaders are not deleted,
 // they are kept for re-use as default shaders in case some shader loading fails
-RLGL.State.defaultVShaderId = rlCompileShader(defaultVShaderCode, GL_VERTEX_SHADER);     // Compile default vertex shader
+RLGL.State.defaultVShaderId = rlLoadShader(defaultVShaderCode, GL_VERTEX_SHADER);     // Compile default vertex shader
-RLGL.State.defaultFShaderId = rlCompileShader(defaultFShaderCode, GL_FRAGMENT_SHADER);   // Compile default fragment shader
+RLGL.State.defaultFShaderId = rlLoadShader(defaultFShaderCode, GL_FRAGMENT_SHADER);   // Compile default fragment shader
-RLGL.State.defaultShaderId = rlLoadShaderProgram(RLGL.State.defaultVShaderId, RLGL.State.defaultFShaderId);
+RLGL.State.defaultShaderId = rlLoadShaderProgramEx(RLGL.State.defaultVShaderId, RLGL.State.defaultFShaderId);
 if (RLGL.State.defaultShaderId > 0)
 {
 TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader loaded successfully", RLGL.State.defaultShaderId);
 RL_FREE(RLGL.State.defaultShaderLocs);
 TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader unloaded successfully", RLGL.State.defaultShaderId);
 }
-#if defined(RLGL_SHOW_GL_DETAILS_INFO)
+#if RLGL_SHOW_GL_DETAILS_INFO
 // Get compressed format official GL identifier name
 static const char *rlGetCompressedFormatName(int format)
 {
 switch (format)
 {
 case 0x93DC: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; break;
 case 0x93DD: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; break;
 default: return "GL_COMPRESSED_UNKNOWN"; break;
 }
 }
-#endif  // RLGL_SHOW_GL_DETAILS_INFO
+#endif
-#endif  // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
 // Get pixel data size in bytes (image or texture)
 // NOTE: Size depends on pixel format
 static int rlGetPixelDataSize(int width, int height, int format)
 {
 case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB:
 case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA:
 case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB:
 case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB:
 case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB:
-case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: bpp = 4; break;
+case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: // 8 bytes per each 4x4 block
+{
+int blockWidth = (width + 3)/4;
+int blockHeight = (height + 3)/4;
+dataSize = blockWidth*blockHeight*8;
+} break;
 case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA:
 case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA:
 case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA:
-case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: bpp = 8; break;
+case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: // 16 bytes per each 4x4 block
-case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: bpp = 2; break;
+{
+int blockWidth = (width + 3)/4;
+int blockHeight = (height + 3)/4;
+dataSize = blockWidth*blockHeight*16;
+} break;
+case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: // 4 bytes per each 4x4 block
+{
+int blockWidth = (width + 3)/4;
+int blockHeight = (height + 3)/4;
+dataSize = blockWidth*blockHeight*4;
+} break;
 default: break;
 }
-double bytesPerPixel = (double)bpp/8.0;
+// Compute dataSize for uncompressed texture data (no blocks)
-dataSize = (int)(bytesPerPixel*width*height); // Total data size in bytes
+if ((format >= RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) &&
+(format <= RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16))
-// Most compressed formats works on 4x4 blocks,
+{
-// if texture is smaller, minimum dataSize is 8 or 16
+double bytesPerPixel = (double)bpp/8.0;
-if ((width < 4) && (height < 4))
+dataSize = (int)(bytesPerPixel*width*height); // Total data size in bytes
-{
-if ((format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) && (format < RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA)) dataSize = 8;
-else if ((format >= RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) && (format < RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)) dataSize = 16;
 }
 return dataSize;
 }
 // Auxiliar math functions
+//-------------------------------------------------------------------------------
+// Get identity matrix
+static Matrix rlMatrixIdentity(void)
+{
+Matrix matIdentity = { 0 };
+matIdentity.m0 = 1.0f;
+matIdentity.m5 = 1.0f;
+matIdentity.m10 = 1.0f;
+matIdentity.m15 = 1.0f;
+return matIdentity;
+}
+#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
 // Get float array of matrix data
+// Explicit conversion to column-major memory layout
 static rl_float16 rlMatrixToFloatV(Matrix mat)
 {
 rl_float16 result = { 0 };
 result.v[0] = mat.m0;
 result.v[15] = mat.m15;
 return result;
 }
-// Get identity matrix
-static Matrix rlMatrixIdentity(void)
-{
-Matrix result = {
-1.0f, 0.0f, 0.0f, 0.0f,
-0.0f, 1.0f, 0.0f, 0.0f,
-0.0f, 0.0f, 1.0f, 0.0f,
-0.0f, 0.0f, 0.0f, 1.0f
-};
-return result;
-}
 // Get two matrix multiplication
 // NOTE: When multiplying matrices... the order matters!
 static Matrix rlMatrixMultiply(Matrix left, Matrix right)
 {
 Matrix result = { 0 };
 result.m14 = (-a30*b03 + a31*b01 - a32*b00)*invDet;
 result.m15 = (a20*b03 - a21*b01 + a22*b00)*invDet;
 return result;
 }
+#endif
-#endif  // RLGL_IMPLEMENTATION
+#endif // RLGL_IMPLEMENTATION

Mercurial

comparison third_party/raylib/include/rlgl.h @ 276:b55c22cff335