rlgl.h

/**********************************************************************************************
 *
 *   rlgl v4.5 - 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) 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 initialized on rlglInit() to accumulate vertex data.
 *
 *       When an internal state change is required all the stored vertex data is
 *renderer in 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_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 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
 *           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
 *           Enable debug context (only available on OpenGL 4.3)
 *
 *       rlgl capabilities could be customized just defining some internal
 *       values before library inclusion (default values listed):
 *
 *       #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS   8192    // Default internal
 *render batch elements limits #define RL_DEFAULT_BATCH_BUFFERS              1
 *// Default number of batch buffers (multi-buffering) #define
 *RL_DEFAULT_BATCH_DRAWCALLS          256    // Default number of batch draw
 *calls (by state changes: mode, texture) #define
 *RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS    4    // Maximum number of textures units
 *that can be activated on batch drawing (SetShaderValueTexture())
 *
 *       #define RL_MAX_MATRIX_STACK_SIZE             32    // Maximum size of
 *internal Matrix stack #define RL_MAX_SHADER_LOCATIONS              32    //
 *Maximum number of shader locations supported #define RL_CULL_DISTANCE_NEAR
 *0.01    // Default projection matrix near cull distance #define
 *RL_CULL_DISTANCE_FAR             1000.0    // Default projection matrix far
 *cull distance
 *
 *       When loading a shader, the following vertex 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: 0 #define
 *RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Bound by
 *default to shader location: 1 #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL
 *"vertexNormal"      // Bound by default to shader location: 2 #define
 *RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR        "vertexColor"       // Bound by
 *default to shader location: 3 #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT
 *"vertexTangent"     // Bound by default to shader location: 4 #define
 *RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Bound by
 *default to shader location: 5 #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp"
 *// model-view-projection matrix #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW
 *"matView"           // view matrix #define
 *RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION  "matProjection"     // projection
 *matrix #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL       "matModel"  // model
 *matrix #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL      "matNormal"  //
 *normal matrix (transpose(inverse(matModelView)) #define
 *RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR       "colDiffuse"        // color
 *diffuse (base tint color, multiplied by texture color) #define
 *RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0  "texture0"          // texture0
 *(texture slot active 0) #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1
 *"texture1"          // texture1 (texture slot active 1) #define
 *RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2  "texture2"          // texture2
 *(texture slot active 2)
 *
 *   DEPENDENCIES:
 *      - OpenGL libraries (depending on platform and OpenGL version selected)
 *      - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core, 4.3
 *Core)
 *
 *
 *   LICENSE: zlib/libpng
 *
 *   Copyright (c) 2014-2023 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 applications, and to alter it and redistribute it freely,
 *subject to the following restrictions:
 *
 *     1. The origin of this software must not be misrepresented; you must not
 *claim that you wrote the original software. If you use this software in a
 *product, an acknowledgment in the product documentation would be appreciated
 *but is not required.
 *
 *     2. Altered source versions must be plainly marked as such, and must not
 *be misrepresented as being the original software.
 *
 *     3. This notice may not be removed or altered from any source
 *distribution.
 *
 **********************************************************************************************/

#ifndef RLGL_H
#define RLGL_H

#define RLGL_VERSION "4.5"

// Function specifiers in case library is build/used as a shared library
// (Windows) NOTE: Microsoft specifiers to tell compiler that symbols are
// imported/exported from a .dll
#if defined(_WIN32)
#if defined(BUILD_LIBTYPE_SHARED)
#define RLAPI                                                                  \
  __declspec(dllexport) // We are building the library as a Win32 shared library
                        // (.dll)
#elif defined(USE_LIBTYPE_SHARED)
#define RLAPI                                                                  \
  __declspec(                                                                  \
      dllimport) // We are using the library as a Win32 shared library (.dll)
#endif
#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)
#endif
#ifndef RL_CALLOC
#define RL_CALLOC(n, sz) calloc(n, sz)
#endif
#ifndef RL_REALLOC
#define RL_REALLOC(n, sz) realloc(n, sz)
#endif
#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) && !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_21)
#undef GRAPHICS_API_OPENGL_21
#endif
#if defined(GRAPHICS_API_OPENGL_33)
#undef GRAPHICS_API_OPENGL_33
#endif
#if defined(GRAPHICS_API_OPENGL_43)
#undef GRAPHICS_API_OPENGL_43
#endif
#if defined(GRAPHICS_API_OPENGL_ES2)
#undef GRAPHICS_API_OPENGL_ES2
#endif
#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 4.3 uses OpenGL 3.3 Core functionality
#if defined(GRAPHICS_API_OPENGL_43)
#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
//----------------------------------------------------------------------------------

// Default internal render batch elements limits
#ifndef RL_DEFAULT_BATCH_BUFFER_ELEMENTS
#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
// This is the maximum amount of elements (quads) per batch
// NOTE: Be careful with text, every letter maps to a quad
#define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192
#endif
#if defined(GRAPHICS_API_OPENGL_ES2)
// We reduce memory sizes for embedded systems (RPI and HTML5)
// NOTE: On HTML5 (emscripten) this is allocated on heap,
// by default it's only 16MB!...just take care...
#define 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)
#endif
#ifndef RL_DEFAULT_BATCH_DRAWCALLS
#define RL_DEFAULT_BATCH_DRAWCALLS                                             \
  256 // Default number of batch draw calls (by state changes: mode, texture)
#endif
#ifndef RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS
#define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS                                     \
  4 // Maximum number of textures units that can be activated on batch drawing
    // (SetShaderValueTexture())
#endif

// Internal Matrix stack
#ifndef RL_MAX_MATRIX_STACK_SIZE
#define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of Matrix stack
#endif

// Shader limits
#ifndef RL_MAX_SHADER_LOCATIONS
#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
#endif
#ifndef RL_CULL_DISTANCE_FAR
#define RL_CULL_DISTANCE_FAR 1000.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_TEXTURE_MAG_FILTER 0x2800 // GL_TEXTURE_MAG_FILTER
#define RL_TEXTURE_MIN_FILTER 0x2801 // GL_TEXTURE_MIN_FILTER

#define RL_TEXTURE_FILTER_NEAREST 0x2600            // GL_NEAREST
#define RL_TEXTURE_FILTER_LINEAR 0x2601             // GL_LINEAR
#define RL_TEXTURE_FILTER_MIP_NEAREST 0x2700        // GL_NEAREST_MIPMAP_NEAREST
#define RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR 0x2702 // GL_NEAREST_MIPMAP_LINEAR
#define RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST 0x2701 // GL_LINEAR_MIPMAP_NEAREST
#define RL_TEXTURE_FILTER_MIP_LINEAR 0x2703         // GL_LINEAR_MIPMAP_LINEAR
#define RL_TEXTURE_FILTER_ANISOTROPIC                                          \
  0x3000 // Anisotropic filter (custom identifier)
#define RL_TEXTURE_MIPMAP_BIAS_RATIO                                           \
  0x4000 // Texture mipmap bias, percentage ratio (custom identifier)

#define RL_TEXTURE_WRAP_REPEAT 0x2901        // GL_REPEAT
#define RL_TEXTURE_WRAP_CLAMP 0x812F         // GL_CLAMP_TO_EDGE
#define RL_TEXTURE_WRAP_MIRROR_REPEAT 0x8370 // GL_MIRRORED_REPEAT
#define RL_TEXTURE_WRAP_MIRROR_CLAMP 0x8742  // GL_MIRROR_CLAMP_EXT

// Matrix modes (equivalent to OpenGL)
#define RL_MODELVIEW 0x1700  // GL_MODELVIEW
#define RL_PROJECTION 0x1701 // GL_PROJECTION
#define RL_TEXTURE 0x1702    // GL_TEXTURE

// Primitive assembly draw modes
#define RL_LINES 0x0001     // GL_LINES
#define RL_TRIANGLES 0x0004 // GL_TRIANGLES
#define RL_QUADS 0x0007     // GL_QUADS

// GL equivalent data types
#define RL_UNSIGNED_BYTE 0x1401 // GL_UNSIGNED_BYTE
#define RL_FLOAT 0x1406         // GL_FLOAT

// GL buffer usage hint
#define RL_STREAM_DRAW 0x88E0  // GL_STREAM_DRAW
#define RL_STREAM_READ 0x88E1  // GL_STREAM_READ
#define RL_STREAM_COPY 0x88E2  // GL_STREAM_COPY
#define RL_STATIC_DRAW 0x88E4  // GL_STATIC_DRAW
#define RL_STATIC_READ 0x88E5  // GL_STATIC_READ
#define RL_STATIC_COPY 0x88E6  // GL_STATIC_COPY
#define RL_DYNAMIC_DRAW 0x88E8 // GL_DYNAMIC_DRAW
#define RL_DYNAMIC_READ 0x88E9 // GL_DYNAMIC_READ
#define RL_DYNAMIC_COPY 0x88EA // GL_DYNAMIC_COPY

// GL Shader type
#define RL_FRAGMENT_SHADER 0x8B30 // GL_FRAGMENT_SHADER
#define RL_VERTEX_SHADER 0x8B31   // GL_VERTEX_SHADER
#define RL_COMPUTE_SHADER 0x91B9  // GL_COMPUTE_SHADER

// GL blending factors
#define RL_ZERO 0                          // GL_ZERO
#define RL_ONE 1                           // GL_ONE
#define RL_SRC_COLOR 0x0300                // GL_SRC_COLOR
#define RL_ONE_MINUS_SRC_COLOR 0x0301      // GL_ONE_MINUS_SRC_COLOR
#define RL_SRC_ALPHA 0x0302                // GL_SRC_ALPHA
#define RL_ONE_MINUS_SRC_ALPHA 0x0303      // GL_ONE_MINUS_SRC_ALPHA
#define RL_DST_ALPHA 0x0304                // GL_DST_ALPHA
#define RL_ONE_MINUS_DST_ALPHA 0x0305      // GL_ONE_MINUS_DST_ALPHA
#define RL_DST_COLOR 0x0306                // GL_DST_COLOR
#define RL_ONE_MINUS_DST_COLOR 0x0307      // GL_ONE_MINUS_DST_COLOR
#define RL_SRC_ALPHA_SATURATE 0x0308       // GL_SRC_ALPHA_SATURATE
#define RL_CONSTANT_COLOR 0x8001           // GL_CONSTANT_COLOR
#define RL_ONE_MINUS_CONSTANT_COLOR 0x8002 // GL_ONE_MINUS_CONSTANT_COLOR
#define RL_CONSTANT_ALPHA 0x8003           // GL_CONSTANT_ALPHA
#define RL_ONE_MINUS_CONSTANT_ALPHA 0x8004 // GL_ONE_MINUS_CONSTANT_ALPHA

// GL blending functions/equations
#define RL_FUNC_ADD 0x8006              // GL_FUNC_ADD
#define RL_MIN 0x8007                   // GL_MIN
#define RL_MAX 0x8008                   // GL_MAX
#define RL_FUNC_SUBTRACT 0x800A         // GL_FUNC_SUBTRACT
#define RL_FUNC_REVERSE_SUBTRACT 0x800B // GL_FUNC_REVERSE_SUBTRACT
#define RL_BLEND_EQUATION 0x8009        // GL_BLEND_EQUATION
#define RL_BLEND_EQUATION_RGB                                                  \
  0x8009 // GL_BLEND_EQUATION_RGB   // (Same as BLEND_EQUATION)
#define RL_BLEND_EQUATION_ALPHA 0x883D // GL_BLEND_EQUATION_ALPHA
#define RL_BLEND_DST_RGB 0x80C8        // GL_BLEND_DST_RGB
#define RL_BLEND_SRC_RGB 0x80C9        // GL_BLEND_SRC_RGB
#define RL_BLEND_DST_ALPHA 0x80CA      // GL_BLEND_DST_ALPHA
#define RL_BLEND_SRC_ALPHA 0x80CB      // GL_BLEND_SRC_ALPHA
#define RL_BLEND_COLOR 0x8005          // GL_BLEND_COLOR

//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------
#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) ||                      \
    (defined(_MSC_VER) && _MSC_VER >= 1800)
#include <stdbool.h>
#elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE)
// Boolean type
typedef enum bool {
  false = 0, true = !false } bool;
#endif

#if !defined(RL_MATRIX_TYPE)
// Matrix, 4x4 components, column major, OpenGL style, right handed
typedef struct Matrix {
  float m0, m4, m8, m12;  // Matrix first row (4 components)
  float m1, m5, m9, m13;  // Matrix second row (4 components)
  float m2, m6, m10, m14; // Matrix third row (4 components)
  float m3, m7, m11, m15; // Matrix fourth row (4 components)
} Matrix;
#define RL_MATRIX_TYPE
#endif

// Dynamic vertex buffers (position + texcoords + colors + indices arrays)
typedef struct rlVertexBuffer {
  int elementCount; // Number of elements in the buffer (QUADS)

  float *vertices;  // Vertex position (XYZ - 3 components per vertex)
                    // (shader-location = 0)
  float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex)
                    // (shader-location = 1)
  unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex)
                         // (shader-location = 3)
#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
  unsigned int *indices; // Vertex indices (in case vertex data comes indexed)
                         // (6 indices per quad)
#endif
#if defined(GRAPHICS_API_OPENGL_ES2)
  unsigned short *indices; // Vertex indices (in case vertex data comes indexed)
                           // (6 indices per quad)
#endif
  unsigned int vaoId; // OpenGL Vertex Array Object id
  unsigned int
      vboId[4]; // OpenGL Vertex Buffer Objects id (4 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 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)
  // unsigned int vaoId;       // Vertex array id to be used on the draw ->
  // Using RLGL.currentBatch->vertexBuffer.vaoId unsigned int shaderId;    //
  // Shader id to be used on the draw -> Using RLGL.currentShaderId
  unsigned int textureId; // Texture id to be used on the draw -> Use to create
                          // new draw call if changes

  // Matrix projection;        // Projection matrix for this draw -> Using
  // RLGL.projection by default Matrix modelview;         // Modelview matrix
  // for this draw -> Using RLGL.modelview by default
} rlDrawCall;

// rlRenderBatch type
typedef struct rlRenderBatch {
  int bufferCount;   // Number of vertex buffers (multi-buffering support)
  int currentBuffer; // Current buffer tracking in case of multi-buffering
  rlVertexBuffer *vertexBuffer; // Dynamic buffer(s) for vertex data

  rlDrawCall *draws;  // Draw calls array, depends on textureId
  int drawCounter;    // Draw calls counter
  float currentDepth; // Current depth value for next draw
} rlRenderBatch;

// OpenGL version
typedef enum {
  RL_OPENGL_11 = 1, // 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)
} rlGlVersion;

// Trace log level
// NOTE: Organized by priority level
typedef enum {
  RL_LOG_ALL = 0, // Display all logs
  RL_LOG_TRACE,   // Trace logging, intended for internal use only
  RL_LOG_DEBUG,   // Debug logging, used for internal debugging, it should be
                  // disabled on release builds
  RL_LOG_INFO,    // Info logging, used for program execution info
  RL_LOG_WARNING, // Warning logging, used on recoverable failures
  RL_LOG_ERROR,   // Error logging, used on unrecoverable failures
  RL_LOG_FATAL,   // Fatal logging, used to abort program: exit(EXIT_FAILURE)
  RL_LOG_NONE     // Disable logging
} rlTraceLogLevel;

// Texture pixel formats
// NOTE: Support depends on OpenGL version
typedef enum {
  RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
  RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA,    // 8*2 bpp (2 channels)
  RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5,        // 16 bpp
  RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8,        // 24 bpp
  RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1,      // 16 bpp (1 bit alpha)
  RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4,      // 16 bpp (4 bit alpha)
  RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,      // 32 bpp
  RL_PIXELFORMAT_UNCOMPRESSED_R32,           // 32 bpp (1 channel - float)
  RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32,     // 32*3 bpp (3 channels - float)
  RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32,  // 32*4 bpp (4 channels - float)
  RL_PIXELFORMAT_UNCOMPRESSED_R16,           // 16 bpp (1 channel - half float)
  RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16, // 16*3 bpp (3 channels - half float)
  RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16, // 16*4 bpp (4 channels - half
                                            // float)
  RL_PIXELFORMAT_COMPRESSED_DXT1_RGB,       // 4 bpp (no alpha)
  RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA,      // 4 bpp (1 bit alpha)
  RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA,      // 8 bpp
  RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA,      // 8 bpp
  RL_PIXELFORMAT_COMPRESSED_ETC1_RGB,       // 4 bpp
  RL_PIXELFORMAT_COMPRESSED_ETC2_RGB,       // 4 bpp
  RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA,  // 8 bpp
  RL_PIXELFORMAT_COMPRESSED_PVRT_RGB,       // 4 bpp
  RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA,      // 4 bpp
  RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA,  // 8 bpp
  RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA   // 2 bpp
} rlPixelFormat;

// 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_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
} rlTextureFilter;

// Color blending modes (pre-defined)
typedef enum {
  RL_BLEND_ALPHA = 0,         // Blend textures considering alpha (default)
  RL_BLEND_ADDITIVE,          // Blend textures adding colors
  RL_BLEND_MULTIPLIED,        // Blend textures multiplying colors
  RL_BLEND_ADD_COLORS,        // Blend textures adding colors (alternative)
  RL_BLEND_SUBTRACT_COLORS,   // Blend textures subtracting colors (alternative)
  RL_BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha
  RL_BLEND_CUSTOM,         // Blend textures using custom src/dst factors (use
                           // rlSetBlendFactors())
  RL_BLEND_CUSTOM_SEPARATE // Blend textures using custom src/dst factors (use
                           // rlSetBlendFactorsSeparate())
} rlBlendMode;

// Shader location point type
typedef enum {
  RL_SHADER_LOC_VERTEX_POSITION =
      0, // Shader location: vertex attribute: position
  RL_SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute:
                                   // texcoord01
  RL_SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute:
                                   // texcoord02
  RL_SHADER_LOC_VERTEX_NORMAL,     // Shader location: vertex attribute: normal
  RL_SHADER_LOC_VERTEX_TANGENT,    // Shader location: vertex attribute: tangent
  RL_SHADER_LOC_VERTEX_COLOR,      // Shader location: vertex attribute: color
  RL_SHADER_LOC_MATRIX_MVP,        // Shader location: matrix uniform:
                                   // model-view-projection
  RL_SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera
                             // transform)
  RL_SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform:
                                   // projection
  RL_SHADER_LOC_MATRIX_MODEL,      // Shader location: matrix uniform: model
                                   // (transform)
  RL_SHADER_LOC_MATRIX_NORMAL,     // Shader location: matrix uniform: normal
  RL_SHADER_LOC_VECTOR_VIEW,       // Shader location: vector uniform: view
  RL_SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color
  RL_SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular
                                // color
  RL_SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color
  RL_SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same
                            // as: RL_SHADER_LOC_MAP_DIFFUSE)
  RL_SHADER_LOC_MAP_METALNESS,  // Shader location: sampler2d texture: metalness
                                // (same as: RL_SHADER_LOC_MAP_SPECULAR)
  RL_SHADER_LOC_MAP_NORMAL,     // Shader location: sampler2d texture: normal
  RL_SHADER_LOC_MAP_ROUGHNESS,  // Shader location: sampler2d texture: roughness
  RL_SHADER_LOC_MAP_OCCLUSION,  // Shader location: sampler2d texture: occlusion
  RL_SHADER_LOC_MAP_EMISSION,   // Shader location: sampler2d texture: emission
  RL_SHADER_LOC_MAP_HEIGHT,     // Shader location: sampler2d texture: height
  RL_SHADER_LOC_MAP_CUBEMAP,    // Shader location: samplerCube texture: cubemap
  RL_SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture:
                                // irradiance
  RL_SHADER_LOC_MAP_PREFILTER,  // Shader location: samplerCube texture:
                                // prefilter
  RL_SHADER_LOC_MAP_BRDF        // Shader location: sampler2d texture: brdf
} rlShaderLocationIndex;

#define RL_SHADER_LOC_MAP_DIFFUSE RL_SHADER_LOC_MAP_ALBEDO
#define RL_SHADER_LOC_MAP_SPECULAR RL_SHADER_LOC_MAP_METALNESS

// Shader uniform data type
typedef enum {
  RL_SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float
  RL_SHADER_UNIFORM_VEC2,      // Shader uniform type: vec2 (2 float)
  RL_SHADER_UNIFORM_VEC3,      // Shader uniform type: vec3 (3 float)
  RL_SHADER_UNIFORM_VEC4,      // Shader uniform type: vec4 (4 float)
  RL_SHADER_UNIFORM_INT,       // Shader uniform type: int
  RL_SHADER_UNIFORM_IVEC2,     // Shader uniform type: ivec2 (2 int)
  RL_SHADER_UNIFORM_IVEC3,     // Shader uniform type: ivec3 (3 int)
  RL_SHADER_UNIFORM_IVEC4,     // Shader uniform type: ivec4 (4 int)
  RL_SHADER_UNIFORM_SAMPLER2D  // Shader uniform type: sampler2d
} rlShaderUniformDataType;

// Shader attribute data types
typedef enum {
  RL_SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float
  RL_SHADER_ATTRIB_VEC2,      // Shader attribute type: vec2 (2 float)
  RL_SHADER_ATTRIB_VEC3,      // Shader attribute type: vec3 (3 float)
  RL_SHADER_ATTRIB_VEC4       // Shader attribute type: vec4 (4 float)
} rlShaderAttributeDataType;

// Framebuffer attachment type
// NOTE: By default up to 8 color channels defined, but it can be more
typedef enum {
  RL_ATTACHMENT_COLOR_CHANNEL0 = 0, // Framebuffer attachment type: color 0
  RL_ATTACHMENT_COLOR_CHANNEL1 = 1, // Framebuffer attachment type: color 1
  RL_ATTACHMENT_COLOR_CHANNEL2 = 2, // Framebuffer attachment type: color 2
  RL_ATTACHMENT_COLOR_CHANNEL3 = 3, // Framebuffer attachment type: color 3
  RL_ATTACHMENT_COLOR_CHANNEL4 = 4, // Framebuffer attachment type: color 4
  RL_ATTACHMENT_COLOR_CHANNEL5 = 5, // Framebuffer attachment type: color 5
  RL_ATTACHMENT_COLOR_CHANNEL6 = 6, // Framebuffer attachment type: color 6
  RL_ATTACHMENT_COLOR_CHANNEL7 = 7, // Framebuffer attachment type: color 7
  RL_ATTACHMENT_DEPTH = 100,        // Framebuffer attachment type: depth
  RL_ATTACHMENT_STENCIL = 200,      // Framebuffer attachment type: stencil
} rlFramebufferAttachType;

// Framebuffer texture attachment type
typedef enum {
  RL_ATTACHMENT_CUBEMAP_POSITIVE_X =
      0, // Framebuffer texture attachment type: cubemap, +X side
  RL_ATTACHMENT_CUBEMAP_NEGATIVE_X =
      1, // Framebuffer texture attachment type: cubemap, -X side
  RL_ATTACHMENT_CUBEMAP_POSITIVE_Y =
      2, // Framebuffer texture attachment type: cubemap, +Y side
  RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y =
      3, // Framebuffer texture attachment type: cubemap, -Y side
  RL_ATTACHMENT_CUBEMAP_POSITIVE_Z =
      4, // Framebuffer texture attachment type: cubemap, +Z side
  RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z =
      5, // Framebuffer texture attachment type: cubemap, -Z side
  RL_ATTACHMENT_TEXTURE2D =
      100, // Framebuffer texture attachment type: texture2d
  RL_ATTACHMENT_RENDERBUFFER =
      200, // Framebuffer texture attachment type: renderbuffer
} rlFramebufferAttachTextureType;

// Face culling mode
typedef enum { RL_CULL_FACE_FRONT = 0, RL_CULL_FACE_BACK } rlCullMode;

//------------------------------------------------------------------------------------
// Functions Declaration - Matrix operations
//------------------------------------------------------------------------------------

#if defined(__cplusplus)
extern "C" { // Prevents name mangling of functions
#endif
  RLAPI void rlMatrixMode(
      int mode);                 // Choose the current matrix to be transformed
  RLAPI void rlPushMatrix(void); // Push the current matrix to stack
  RLAPI void rlPopMatrix(void);  // Pop latest inserted matrix from stack
  RLAPI void rlLoadIdentity(void); // Reset current matrix to identity matrix
  RLAPI void rlTranslatef(
      float x, float y,
      float z); // Multiply the current matrix by a translation matrix
  RLAPI void rlRotatef(
      float angle, float x, float y,
      float z); // Multiply the current matrix by a rotation matrix
  RLAPI void rlScalef(
      float x, float y,
      float z); // Multiply the current matrix by a scaling matrix
  RLAPI void rlMultMatrixf(
      const float *matf); // Multiply the current matrix by another matrix
  RLAPI void rlFrustum(double left, double right, double bottom, double top,
                       double znear, double zfar);
  RLAPI void rlOrtho(double left, double right, double bottom, double top,
                     double znear, double zfar);
  RLAPI void rlViewport(int x, int y, int width,
                        int height); // Set the viewport area

  //------------------------------------------------------------------------------------
  // Functions Declaration - Vertex level operations
  //------------------------------------------------------------------------------------
  RLAPI void rlBegin(
      int mode);          // Initialize drawing mode (how to organize vertex)
  RLAPI void rlEnd(void); // Finish vertex providing
  RLAPI void rlVertex2i(int x, int y); // Define one vertex (position) - 2 int
  RLAPI void rlVertex2f(float x,
                        float y); // Define one vertex (position) - 2 float
  RLAPI void rlVertex3f(float x, float y,
                        float z); // Define one vertex (position) - 3 float
  RLAPI void rlTexCoord2f(
      float x,
      float y); // Define one vertex (texture coordinate) - 2 float
  RLAPI void rlNormal3f(float x, float y,
                        float z); // Define one vertex (normal) - 3 float
  RLAPI void rlColor4ub(unsigned char r, unsigned char g, unsigned char b,
                        unsigned char a); // Define one vertex (color) - 4 byte
  RLAPI void rlColor3f(float x, float y,
                       float z); // Define one vertex (color) - 3 float
  RLAPI void rlColor4f(float x, float y, float z,
                       float w); // Define one vertex (color) - 4 float

  //------------------------------------------------------------------------------------
  // Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2)
  // NOTE: This functions are used to completely abstract raylib code from
  // OpenGL layer, some of them are direct wrappers over OpenGL calls, some
  // others are custom
  //------------------------------------------------------------------------------------

  // Vertex buffers state
  RLAPI bool rlEnableVertexArray(
      unsigned int vaoId); // Enable vertex array (VAO, if supported)
  RLAPI void rlDisableVertexArray(
      void); // Disable vertex array (VAO, if supported)
  RLAPI void rlEnableVertexBuffer(
      unsigned int id);                   // Enable vertex buffer (VBO)
  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 rlEnableTextureCubemap(unsigned int id); // Enable texture cubemap
  RLAPI void rlDisableTextureCubemap(void);           // Disable texture cubemap
  RLAPI void rlTextureParameters(
      unsigned int id, int param,
      int value); // Set texture parameters (filter, wrap)
  RLAPI void rlCubemapParameters(
      unsigned int id, int param,
      int value); // Set cubemap parameters (filter, wrap)

  // Shader state
  RLAPI void rlEnableShader(unsigned int id); // Enable shader program
  RLAPI void rlDisableShader(void);           // Disable shader program

  // Framebuffer state
  RLAPI void rlEnableFramebuffer(
      unsigned int id); // Enable render texture (fbo)
  RLAPI void rlDisableFramebuffer(
      void); // Disable render texture (fbo), return to default framebuffer
  RLAPI void rlActiveDrawBuffers(
      int count); // Activate multiple draw color buffers
  RLAPI void rlBlitFramebuffer(
      int srcX, int srcY, int srcWidth, int srcHeight, int dstX, int dstY,
      int dstWidth, int dstHeight,
      int bufferMask); // Blit active framebuffer to main framebuffer

  // General render state
  RLAPI void rlEnableColorBlend(void);       // Enable color blending
  RLAPI void rlDisableColorBlend(void);      // Disable color blending
  RLAPI void rlEnableDepthTest(void);        // Enable depth test
  RLAPI void rlDisableDepthTest(void);       // Disable depth test
  RLAPI void rlEnableDepthMask(void);        // Enable depth write
  RLAPI void rlDisableDepthMask(void);       // Disable depth write
  RLAPI void rlEnableBackfaceCulling(void);  // Enable backface culling
  RLAPI void rlDisableBackfaceCulling(void); // Disable backface culling
  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 rlEnableWireMode(void);                         // Enable wire mode
  RLAPI void rlEnablePointMode(void); //  Enable point mode
  RLAPI void rlDisableWireMode(
      void); // Disable wire mode ( and point ) maybe rename
  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
  RLAPI void rlDisableStereoRender(void);   // Disable stereo rendering
  RLAPI bool rlIsStereoRenderEnabled(void); // Check if stereo render is enabled

  RLAPI void rlClearColor(unsigned char r, unsigned char g, unsigned char b,
                          unsigned char a); // Clear color buffer with color
  RLAPI void rlClearScreenBuffers(
      void);                      // Clear used screen buffers (color and depth)
  RLAPI void rlCheckErrors(void); // Check and log OpenGL error codes
  RLAPI void rlSetBlendMode(int mode); // Set blending mode
  RLAPI void rlSetBlendFactors(
      int glSrcFactor, int glDstFactor,
      int glEquation); // Set blending mode factor and
                       // equation (using OpenGL factors)
  RLAPI void rlSetBlendFactorsSeparate(
      int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB,
      int glEqAlpha); // Set blending mode factors and equations separately
                      // (using OpenGL factors)

  //------------------------------------------------------------------------------------
  // Functions Declaration - rlgl functionality
  //------------------------------------------------------------------------------------
  // 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 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 unsigned int rlGetTextureIdDefault(void); // Get default texture id
  RLAPI unsigned int rlGetShaderIdDefault(void);  // Get default shader id
  RLAPI int *rlGetShaderLocsDefault(void); // Get default shader locations

  // Render batch management
  // NOTE: rlgl provides a default render batch to behave like OpenGL 1.1
  // immediate mode but this render batch API is exposed in case of custom
  // batches are required
  RLAPI rlRenderBatch rlLoadRenderBatch(
      int numBuffers, int bufferElements); // Load a render batch system
  RLAPI void rlUnloadRenderBatch(
      rlRenderBatch batch); // Unload render batch system
  RLAPI void rlDrawRenderBatch(
      rlRenderBatch * batch); // Draw render batch data (Update->Draw->Reset)
  RLAPI void rlSetRenderBatchActive(rlRenderBatch *
                                    batch); // Set the active render batch for
                                            // rlgl (NULL for default internal)
  RLAPI void rlDrawRenderBatchActive(
      void); // Update and draw internal render batch
  RLAPI bool rlCheckRenderBatchLimit(
      int vCount); // Check internal buffer overflow for a given number of
                   // vertex

  RLAPI void rlSetTexture(unsigned int id); // Set current texture for render
                                            // batch and check buffers limits

  //------------------------------------------------------------------------------------------------------------------------

  // Vertex buffers management
  RLAPI unsigned int rlLoadVertexArray(
      void); // Load vertex array (vao) if supported
  RLAPI unsigned int rlLoadVertexBuffer(
      const void *buffer, int size,
      bool dynamic); // Load a vertex buffer attribute
  RLAPI unsigned int rlLoadVertexBufferElement(
      const void *buffer, int size,
      bool dynamic); // Load a new attributes element buffer
  RLAPI void rlUpdateVertexBuffer(
      unsigned int bufferId, const void *data, int dataSize,
      int offset); // Update GPU buffer with new data
  RLAPI void rlUpdateVertexBufferElements(
      unsigned int id, const void *data, int dataSize,
      int offset); // Update vertex buffer elements with new data
  RLAPI void rlUnloadVertexArray(unsigned int vaoId);
  RLAPI void rlUnloadVertexBuffer(unsigned int vboId);
  RLAPI void rlSetVertexAttribute(unsigned int index, int compSize, int type,
                                  bool normalized, int stride,
                                  const void *pointer);
  RLAPI void rlSetVertexAttributeDivisor(unsigned int index, int divisor);
  RLAPI void rlSetVertexAttributeDefault(
      int locIndex, const void *value, int attribType,
      int count); // Set vertex attribute default value
  RLAPI void rlDrawVertexArray(int offset, int count);
  RLAPI void rlDrawVertexArrayElements(int offset, int count,
                                       const void *buffer);
  RLAPI void rlDrawVertexArrayInstanced(int offset, int count, int instances);
  RLAPI void rlDrawVertexArrayElementsInstanced(
      int offset, int count, const void *buffer, int instances);

  // Textures management
  RLAPI unsigned int rlLoadTexture(const void *data, int width, int height,
                                   int format,
                                   int mipmapCount); // Load texture in GPU
  RLAPI unsigned int rlLoadTextureDepth(
      int width, int height,
      bool useRenderBuffer); // Load depth texture/renderbuffer (to
                             // be attached to fbo)
  RLAPI unsigned int rlLoadTextureCubemap(const void *data, int size,
                                          int format); // Load texture cubemap
  RLAPI void rlUpdateTexture(
      unsigned int id, int offsetX, int offsetY, int width, int height,
      int format,
      const void *data); // Update GPU texture with new data
  RLAPI void rlGetGlTextureFormats(
      int format, unsigned int *glInternalFormat, unsigned int *glFormat,
      unsigned int *glType); // Get OpenGL internal formats
  RLAPI const char *rlGetPixelFormatName(
      unsigned int format); // Get name string for pixel format
  RLAPI void rlUnloadTexture(unsigned int id); // Unload texture from GPU memory
  RLAPI void rlGenTextureMipmaps(
      unsigned int id, int width, int height, int format,
      int *mipmaps); // Generate mipmap data for selected texture
  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(int width,
                                       int height); // 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 bool rlFramebufferComplete(
      unsigned int id); // Verify framebuffer is complete
  RLAPI void rlUnloadFramebuffer(
      unsigned int id); // Delete framebuffer from GPU

  // Shaders management
  RLAPI unsigned int rlLoadShaderCode(
      const char *vsCode,
      const char *fsCode); // Load shader from code strings
  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(
      unsigned int vShaderId,
      unsigned int fShaderId); // Load custom shader program
  RLAPI void rlUnloadShaderProgram(unsigned int id); // Unload shader program
  RLAPI int rlGetLocationUniform(
      unsigned int shaderId,
      const char *uniformName); // Get shader location uniform
  RLAPI int rlGetLocationAttrib(
      unsigned int shaderId,
      const char *attribName); // Get shader location attribute
  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 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)
  RLAPI void rlUpdateShaderBuffer(
      unsigned int id, const void *data, unsigned int dataSize,
      unsigned int offset); // Update SSBO buffer data
  RLAPI void rlBindShaderBuffer(unsigned int id,
                                unsigned int index); // Bind SSBO buffer
  RLAPI void rlReadShaderBuffer(
      unsigned int id, void *dest, unsigned int count,
      unsigned int offset); // Read SSBO buffer data (GPU->CPU)
  RLAPI void rlCopyShaderBuffer(
      unsigned int destId, unsigned int srcId, unsigned int destOffset,
      unsigned int srcOffset,
      unsigned int count); // Copy SSBO data between buffers
  RLAPI unsigned int rlGetShaderBufferSize(
      unsigned int id); // Get SSBO buffer size

  // Buffer management
  RLAPI void rlBindImageTexture(unsigned int id, unsigned int index, int format,
                                bool readonly); // Bind image texture

  // Matrix state management
  RLAPI Matrix rlGetMatrixModelview(void);  // Get internal modelview matrix
  RLAPI Matrix rlGetMatrixProjection(void); // Get internal projection matrix
  RLAPI Matrix rlGetMatrixTransform(
      void); // Get internal accumulated transform matrix
  RLAPI Matrix rlGetMatrixProjectionStereo(
      int eye); // Get internal projection matrix for stereo render (selected
                // eye)
  RLAPI Matrix rlGetMatrixViewOffsetStereo(
      int eye); // Get internal view offset matrix for
                // stereo render (selected eye)
  RLAPI void rlSetMatrixProjection(
      Matrix proj); // Set a custom projection matrix (replaces
                    // internal projection matrix)
  RLAPI void rlSetMatrixModelview(
      Matrix view); // Set a custom modelview matrix (replaces
                    // internal modelview matrix)
  RLAPI void rlSetMatrixProjectionStereo(
      Matrix right,
      Matrix left); // Set eyes projection matrices for stereo rendering
  RLAPI void rlSetMatrixViewOffsetStereo(
      Matrix right,
      Matrix left); // Set eyes view offsets matrices for stereo rendering

  // Quick and dirty cube/quad buffers load->draw->unload
  RLAPI void rlLoadDrawCube(void); // Load and draw a cube
  RLAPI void rlLoadDrawQuad(void); // Load and draw a quad

#if defined(__cplusplus)
}
#endif

#endif // RLGL_H

/***********************************************************************************
 *
 *   RLGL IMPLEMENTATION
 *
 ************************************************************************************/

#if defined(RLGL_IMPLEMENTATION)

#if defined(GRAPHICS_API_OPENGL_11)
#if defined(__APPLE__)
#include <OpenGL/gl.h>    // OpenGL 1.1 library for OSX
#include <OpenGL/glext.h> // OpenGL extensions library
#else
// APIENTRY for OpenGL function pointer declarations is required
#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
#endif

#if defined(GRAPHICS_API_OPENGL_33)
#define GLAD_MALLOC RL_MALLOC
#define GLAD_FREE RL_FREE

#define GLAD_GL_IMPLEMENTATION
#include "external/glad.h" // GLAD extensions loading library, includes OpenGL headers
#endif

#if defined(GRAPHICS_API_OPENGL_ES3)
#include <GLES3/gl3.h> // OpenGL ES 3.0 library
#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
                                 // PLATFORM_DESKTOP,
// in that case, functions are loaded from a custom glad for OpenGL ES 2.0
#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL)
#define GLAD_GLES2_IMPLEMENTATION
#include "external/glad_gles2.h"
#else
#define GL_GLEXT_PROTOTYPES
                                 // #include <EGL/egl.h>          // EGL library
                                 // -> not required, platform layer
#include <GLES2/gl2.h>    // OpenGL ES 2.0 library
#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)
#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 <math.h>   // Required for: sqrtf(), sinf(), cosf(), floor(), log()
#include <stdlib.h> // Required for: malloc(), free()
#include <string.h> // Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading]

//----------------------------------------------------------------------------------
// Defines and Macros
//----------------------------------------------------------------------------------
#ifndef PI
#define PI 3.14159265358979323846f
#endif
#ifndef DEG2RAD
#define DEG2RAD (PI / 180.0f)
#endif
#ifndef RAD2DEG
#define RAD2DEG (180.0f / PI)
#endif

#ifndef GL_SHADING_LANGUAGE_VERSION
#define GL_SHADING_LANGUAGE_VERSION 0x8B8C
#endif

#ifndef GL_COMPRESSED_RGB_S3TC_DXT1_EXT
#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0
#endif
#ifndef GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
#endif
#ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2
#endif
#ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
#endif
#ifndef GL_ETC1_RGB8_OES
#define GL_ETC1_RGB8_OES 0x8D64
#endif
#ifndef GL_COMPRESSED_RGB8_ETC2
#define GL_COMPRESSED_RGB8_ETC2 0x9274
#endif
#ifndef GL_COMPRESSED_RGBA8_ETC2_EAC
#define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278
#endif
#ifndef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG
#define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00
#endif
#ifndef GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
#define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02
#endif
#ifndef GL_COMPRESSED_RGBA_ASTC_4x4_KHR
#define GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93b0
#endif
#ifndef GL_COMPRESSED_RGBA_ASTC_8x8_KHR
#define GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93b7
#endif

#ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
#endif
#ifndef GL_TEXTURE_MAX_ANISOTROPY_EXT
#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
#endif

#if defined(GRAPHICS_API_OPENGL_11)
#define GL_UNSIGNED_SHORT_5_6_5 0x8363
#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
#endif

#if defined(GRAPHICS_API_OPENGL_21)
#define GL_LUMINANCE 0x1909
#define GL_LUMINANCE_ALPHA 0x190A
#endif

#if defined(GRAPHICS_API_OPENGL_ES2)
#define glClearDepth glClearDepthf
#if !defined(GRAPHICS_API_OPENGL_ES3)
#define GL_READ_FRAMEBUFFER GL_FRAMEBUFFER
#define GL_DRAW_FRAMEBUFFER GL_FRAMEBUFFER
#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: 0
#endif
#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD
#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD                                 \
  "vertexTexCoord" // Bound by default to shader location: 1
#endif
#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL
#define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL                                   \
  "vertexNormal" // Bound by default to shader location: 2
#endif
#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR
#define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR                                    \
  "vertexColor" // Bound by default to shader location: 3
#endif
#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT
#define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT                                  \
  "vertexTangent" // Bound by default to shader location: 4
#endif
#ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2
#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2                                \
  "vertexTexCoord2" // Bound by default to shader location: 5
#endif

#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MVP
#define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix
#endif
#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW
#define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix
#endif
#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION
#define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION                              \
  "matProjection" // projection matrix
#endif
#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL
#define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix
#endif
#ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL
#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_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

//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
typedef struct rlglData {
  rlRenderBatch *currentBatch; // Current render batch
  rlRenderBatch defaultBatch;  // Default internal render batch

  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*())
    unsigned char colorr, colorg, colorb,
        colora; // Current active color (added on glVertex*())

    int currentMatrixMode; // Current matrix mode
    Matrix *currentMatrix; // Current matrix pointer
    Matrix modelview;      // Default modelview matrix
    Matrix projection;     // Default projection matrix
    Matrix transform; // Transform matrix to be used with rlTranslate, rlRotate,
                      // rlScale
    bool transformRequired; // Require transform matrix application to current
                            // draw-call vertex (if required)
    Matrix stack[RL_MAX_MATRIX_STACK_SIZE]; // Matrix stack for push/pop
    int stackCounter;                       // Matrix stack counter

    unsigned int defaultTextureId; // Default texture used on shapes/poly
                                   // drawing (required by shader)
    unsigned int activeTextureId
        [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 *defaultShaderLocs; // Default shader locations pointer to be used on
                            // rendering
    unsigned int currentShaderId; // Current shader id to be used on rendering
                                  // (by default, defaultShaderId)
    int *currentShaderLocs; // Current shader locations pointer to be used on
                            // rendering (by default, defaultShaderLocs)

    bool stereoRender;          // Stereo rendering flag
    Matrix projectionStereo[2]; // VR stereo rendering eyes projection matrices
    Matrix viewOffsetStereo[2]; // VR stereo rendering eyes view offset matrices

    // Blending variables
    int currentBlendMode;           // Blending mode active
    int glBlendSrcFactor;           // Blending source factor
    int glBlendDstFactor;           // Blending destination factor
    int glBlendEquation;            // Blending equation
    int glBlendSrcFactorRGB;        // Blending source RGB factor
    int glBlendDestFactorRGB;       // Blending destination RGB factor
    int glBlendSrcFactorAlpha;      // Blending source alpha factor
    int glBlendDestFactorAlpha;     // Blending destination alpha factor
    int glBlendEquationRGB;         // Blending equation for RGB
    int glBlendEquationAlpha;       // Blending equation for alpha
    bool glCustomBlendModeModified; // Custom blending factor and equation
                                    // modification status

    int framebufferWidth;  // Current framebuffer width
    int framebufferHeight; // Current framebuffer height

  } State; // Renderer state
  struct {
    bool vao;        // VAO support (OpenGL ES2 could not support VAO extension)
                     // (GL_ARB_vertex_array_object)
    bool instancing; // Instancing supported (GL_ANGLE_instanced_arrays,
                     // GL_EXT_draw_instanced + GL_EXT_instanced_arrays)
    bool texNPOT;    // NPOT textures full support
                     // (GL_ARB_texture_non_power_of_two, GL_OES_texture_npot)
    bool texDepth;   // Depth textures supported (GL_ARB_depth_texture,
                     // GL_OES_depth_texture)
    bool texDepthWebGL;  // Depth textures supported WebGL specific
                         // (GL_WEBGL_depth_texture)
    bool texFloat32;     // float textures support (32 bit per channel)
                         // (GL_OES_texture_float)
    bool texFloat16;     // half float textures support (16 bit per channel)
                         // (GL_OES_texture_half_float)
    bool texCompDXT;     // DDS texture compression support
                         // (GL_EXT_texture_compression_s3tc,
                         // GL_WEBGL_compressed_texture_s3tc,
                         // GL_WEBKIT_WEBGL_compressed_texture_s3tc)
    bool texCompETC1;    // ETC1 texture compression support
                         // (GL_OES_compressed_ETC1_RGB8_texture,
                         // GL_WEBGL_compressed_texture_etc1)
    bool texCompETC2;    // ETC2/EAC texture compression support
                         // (GL_ARB_ES3_compatibility)
    bool texCompPVRT;    // PVR texture compression support
                         // (GL_IMG_texture_compression_pvrtc)
    bool texCompASTC;    // ASTC texture compression support
                         // (GL_KHR_texture_compression_astc_hdr,
                         // GL_KHR_texture_compression_astc_ldr)
    bool texMirrorClamp; // Clamp mirror wrap mode supported
                         // (GL_EXT_texture_mirror_clamp)
    bool texAnisoFilter; // Anisotropic texture filtering support
                         // (GL_EXT_texture_filter_anisotropic)
    bool computeShader;  // Compute shaders support (GL_ARB_compute_shader)
    bool ssbo;           // Shader storage buffer object support
                         // (GL_ARB_shader_storage_buffer_object)

    float maxAnisotropyLevel; // Maximum anisotropy level supported (minimum
                              // is 2.0f)
    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

//----------------------------------------------------------------------------------
// Global Variables Definition
//----------------------------------------------------------------------------------
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
static rlglData RLGL = {0};
#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2

#if defined(GRAPHICS_API_OPENGL_ES2) && !defined(GRAPHICS_API_OPENGL_ES3)
// 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
static PFNGLDRAWARRAYSINSTANCEDEXTPROC glDrawArraysInstanced = NULL;
static PFNGLDRAWELEMENTSINSTANCEDEXTPROC glDrawElementsInstanced = NULL;
static PFNGLVERTEXATTRIBDIVISOREXTPROC glVertexAttribDivisor = NULL;
#endif

//----------------------------------------------------------------------------------
// Module specific 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)
static const char *rlGetCompressedFormatName(
    int format); // Get compressed format official GL identifier name
#endif           // RLGL_SHOW_GL_DETAILS_INFO
#endif           // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2

static int rlGetPixelDataSize(
    int width, int height,
    int format); // Get pixel data size in bytes (image or texture)

// Auxiliar matrix math functions
static Matrix rlMatrixIdentity(void); // Get identity matrix
static Matrix rlMatrixMultiply(Matrix left,
                               Matrix right); // Multiply two matrices

//----------------------------------------------------------------------------------
// Module Functions Definition - Matrix operations
//----------------------------------------------------------------------------------

#if defined(GRAPHICS_API_OPENGL_11)
// Fallback to OpenGL 1.1 function calls
//---------------------------------------
void rlMatrixMode(int mode) {
  switch (mode) {
  case RL_PROJECTION:
    glMatrixMode(GL_PROJECTION);
    break;
  case RL_MODELVIEW:
    glMatrixMode(GL_MODELVIEW);
    break;
  case RL_TEXTURE:
    glMatrixMode(GL_TEXTURE);
    break;
  default:
    break;
  }
}

void rlFrustum(double left, double right, double bottom, double top,
               double znear, double zfar) {
  glFrustum(left, right, bottom, top, znear, zfar);
}

void rlOrtho(double left, double right, double bottom, double top, double znear,
             double zfar) {
  glOrtho(left, right, bottom, top, znear, zfar);
}

void rlPushMatrix(void) {
  glPushMatrix(); }
void rlPopMatrix(void) {
  glPopMatrix(); }
void rlLoadIdentity(void) {
  glLoadIdentity(); }
void rlTranslatef(float x, float y, float z) {
  glTranslatef(x, y, z); }
void rlRotatef(float angle, float x, float y, float z) {
  glRotatef(angle, x, y, z);
}
void rlScalef(float x, float y, float z) {
  glScalef(x, y, z); }
void rlMultMatrixf(const float *matf) {
  glMultMatrixf(matf); }
#endif
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
// Choose the current matrix to be transformed
void rlMatrixMode(int mode) {
  if (mode == RL_PROJECTION)
    RLGL.State.currentMatrix = &RLGL.State.projection;
  else if (mode == RL_MODELVIEW)
    RLGL.State.currentMatrix = &RLGL.State.modelview;
  // else if (mode == RL_TEXTURE) // Not supported

  RLGL.State.currentMatrixMode = mode;
}

// Push the current matrix into RLGL.State.stack
void rlPushMatrix(void) {
  if (RLGL.State.stackCounter >= RL_MAX_MATRIX_STACK_SIZE)
    TRACELOG(RL_LOG_ERROR,
             "RLGL: Matrix stack overflow (RL_MAX_MATRIX_STACK_SIZE)");

  if (RLGL.State.currentMatrixMode == RL_MODELVIEW) {
    RLGL.State.transformRequired = true;
    RLGL.State.currentMatrix = &RLGL.State.transform;
  }

  RLGL.State.stack[RLGL.State.stackCounter] = *RLGL.State.currentMatrix;
  RLGL.State.stackCounter++;
}

// Pop lattest inserted matrix from RLGL.State.stack
void rlPopMatrix(void) {
  if (RLGL.State.stackCounter > 0) {
    Matrix mat = RLGL.State.stack[RLGL.State.stackCounter - 1];
    *RLGL.State.currentMatrix = mat;
    RLGL.State.stackCounter--;
  }

  if ((RLGL.State.stackCounter == 0) &&
      (RLGL.State.currentMatrixMode == RL_MODELVIEW)) {
    RLGL.State.currentMatrix = &RLGL.State.modelview;
    RLGL.State.transformRequired = false;
  }
}

// Reset current matrix to identity matrix
void rlLoadIdentity(void) {
  *RLGL.State.currentMatrix = rlMatrixIdentity(); }

// Multiply the current matrix by a translation matrix
void rlTranslatef(float x, float y, float z) {
  Matrix matTranslation = {1.0f, 0.0f, 0.0f, x, 0.0f, 1.0f, 0.0f, y,
                           0.0f, 0.0f, 1.0f, z, 0.0f, 0.0f, 0.0f, 1.0f};

  // NOTE: We transpose matrix with 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
void rlRotatef(float angle, float x, float y, float z) {
  Matrix matRotation = rlMatrixIdentity();

  // Axis vector (x, y, z) normalization
  float lengthSquared = x * x + y * y + z * z;
  if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f)) {
    float inverseLength = 1.0f / sqrtf(lengthSquared);
    x *= inverseLength;
    y *= inverseLength;
    z *= inverseLength;
  }

  // Rotation matrix generation
  float sinres = sinf(DEG2RAD * angle);
  float cosres = cosf(DEG2RAD * angle);
  float t = 1.0f - cosres;

  matRotation.m0 = x * x * t + cosres;
  matRotation.m1 = y * x * t + z * sinres;
  matRotation.m2 = z * x * t - y * sinres;
  matRotation.m3 = 0.0f;

  matRotation.m4 = x * y * t - z * sinres;
  matRotation.m5 = y * y * t + cosres;
  matRotation.m6 = z * y * t + x * sinres;
  matRotation.m7 = 0.0f;

  matRotation.m8 = x * z * t + y * sinres;
  matRotation.m9 = y * z * t - x * sinres;
  matRotation.m10 = z * z * t + cosres;
  matRotation.m11 = 0.0f;

  matRotation.m12 = 0.0f;
  matRotation.m13 = 0.0f;
  matRotation.m14 = 0.0f;
  matRotation.m15 = 1.0f;

  // NOTE: We transpose matrix with 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 = {x,    0.0f, 0.0f, 0.0f, 0.0f, y,    0.0f, 0.0f,
                     0.0f, 0.0f, z,    0.0f, 0.0f, 0.0f, 0.0f, 1.0f};

  // NOTE: We transpose matrix with 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
  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]};

  *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, mat);
}

// Multiply the current matrix by a perspective matrix generated by parameters
void rlFrustum(double left, double right, double bottom, double top,
               double znear, double zfar) {
  Matrix matFrustum = {0};

  float rl = (float)(right - left);
  float tb = (float)(top - bottom);
  float fn = (float)(zfar - znear);

  matFrustum.m0 = ((float)znear * 2.0f) / rl;
  matFrustum.m1 = 0.0f;
  matFrustum.m2 = 0.0f;
  matFrustum.m3 = 0.0f;

  matFrustum.m4 = 0.0f;
  matFrustum.m5 = ((float)znear * 2.0f) / tb;
  matFrustum.m6 = 0.0f;
  matFrustum.m7 = 0.0f;

  matFrustum.m8 = ((float)right + (float)left) / rl;
  matFrustum.m9 = ((float)top + (float)bottom) / tb;
  matFrustum.m10 = -((float)zfar + (float)znear) / fn;
  matFrustum.m11 = -1.0f;

  matFrustum.m12 = 0.0f;
  matFrustum.m13 = 0.0f;
  matFrustum.m14 = -((float)zfar * (float)znear * 2.0f) / fn;
  matFrustum.m15 = 0.0f;

  *RLGL.State.currentMatrix =
      rlMatrixMultiply(*RLGL.State.currentMatrix, matFrustum);
}

// 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
  Matrix matOrtho = {0};

  float rl = (float)(right - left);
  float tb = (float)(top - bottom);
  float fn = (float)(zfar - znear);

  matOrtho.m0 = 2.0f / rl;
  matOrtho.m1 = 0.0f;
  matOrtho.m2 = 0.0f;
  matOrtho.m3 = 0.0f;
  matOrtho.m4 = 0.0f;
  matOrtho.m5 = 2.0f / tb;
  matOrtho.m6 = 0.0f;
  matOrtho.m7 = 0.0f;
  matOrtho.m8 = 0.0f;
  matOrtho.m9 = 0.0f;
  matOrtho.m10 = -2.0f / fn;
  matOrtho.m11 = 0.0f;
  matOrtho.m12 = -((float)left + (float)right) / rl;
  matOrtho.m13 = -((float)top + (float)bottom) / tb;
  matOrtho.m14 = -((float)zfar + (float)znear) / fn;
  matOrtho.m15 = 1.0f;

  *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);
}

//----------------------------------------------------------------------------------
// Module Functions Definition - Vertex level operations
//----------------------------------------------------------------------------------
#if defined(GRAPHICS_API_OPENGL_11)
// Fallback to OpenGL 1.1 function calls
//---------------------------------------
void rlBegin(int mode) {
  switch (mode) {
  case RL_LINES:
    glBegin(GL_LINES);
    break;
  case RL_TRIANGLES:
    glBegin(GL_TRIANGLES);
    break;
  case RL_QUADS:
    glBegin(GL_QUADS);
    break;
  default:
    break;
  }
}

void rlEnd() {
  glEnd(); }
void rlVertex2i(int x, int y) {
  glVertex2i(x, y); }
void rlVertex2f(float x, float y) {
  glVertex2f(x, y); }
void rlVertex3f(float x, float y, float z) {
  glVertex3f(x, y, z); }
void rlTexCoord2f(float x, float y) {
  glTexCoord2f(x, y); }
void rlNormal3f(float x, float y, float z) {
  glNormal3f(x, y, z); }
void rlColor4ub(unsigned char r, unsigned char g, unsigned char b,
                unsigned char a) {
  glColor4ub(r, g, b, a);
}
void rlColor3f(float x, float y, float z) {
  glColor3f(x, y, z); }
void rlColor4f(float x, float y, float z, float w) {
  glColor4f(x, y, z, w); }
#endif
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
// Initialize drawing mode (how to organize vertex)
void rlBegin(int mode) {
  // Draw mode can be RL_LINES, RL_TRIANGLES and RL_QUADS
  // NOTE: In all three cases, vertex are accumulated over default internal
  // vertex buffer
  if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode !=
      mode) {
    if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
            .vertexCount > 0) {
      // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a
      // multiple of 4, that way, following QUADS drawing will keep aligned with
      // index processing It implies adding some extra alignment vertex at the
      // end of the draw, those vertex are not processed but they are considered
      // as an additional offset for the next set of vertex to be drawn
      if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode ==
          RL_LINES)
        RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
            .vertexAlignment =
            ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                  .vertexCount < 4)
                 ? RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                       .vertexCount
                 : RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                           .vertexCount %
                       4);
      else if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                   .mode == RL_TRIANGLES)
        RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
            .vertexAlignment =
            ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                  .vertexCount < 4)
                 ? 1
                 : (4 - (RLGL.currentBatch
                             ->draws[RLGL.currentBatch->drawCounter - 1]
                             .vertexCount %
                         4)));
      else
        RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
            .vertexAlignment = 0;

      if (!rlCheckRenderBatchLimit(
              RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                  .vertexAlignment)) {
        RLGL.State.vertexCounter +=
            RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                .vertexAlignment;
        RLGL.currentBatch->drawCounter++;
      }
    }

    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.defaultTextureId;
  }
}

// Finish vertex providing
void rlEnd(void) {
  // NOTE: Depth increment is dependant 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);
}

// Define one vertex (position)
// NOTE: Vertex position data is the basic information required for drawing
void rlVertex3f(float x, float y, float z) {
  float tx = x;
  float ty = y;
  float tz = z;

  // Transform provided vector if required
  if (RLGL.State.transformRequired) {
    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.
  // 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
  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
      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)) {
      rlCheckRenderBatchLimit(3 + 1);
    } else if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                    .mode == RL_QUADS) &&
               (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                        .vertexCount %
                    4 ==
                0)) {
      rlCheckRenderBatchLimit(4 + 1);
    }
  }

  // Add vertices
  RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer]
      .vertices[3 * RLGL.State.vertexCounter] = tx;
  RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer]
      .vertices[3 * RLGL.State.vertexCounter + 1] = ty;
  RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer]
      .vertices[3 * RLGL.State.vertexCounter + 2] = tz;

  // Add current texcoord
  RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer]
      .texcoords[2 * RLGL.State.vertexCounter] = RLGL.State.texcoordx;
  RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer]
      .texcoords[2 * RLGL.State.vertexCounter + 1] = RLGL.State.texcoordy;

  // WARNING: By default rlVertexBuffer struct does not store normals

  // Add current color
  RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer]
      .colors[4 * RLGL.State.vertexCounter] = RLGL.State.colorr;
  RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer]
      .colors[4 * RLGL.State.vertexCounter + 1] = RLGL.State.colorg;
  RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer]
      .colors[4 * RLGL.State.vertexCounter + 2] = RLGL.State.colorb;
  RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer]
      .colors[4 * RLGL.State.vertexCounter + 3] = RLGL.State.colora;

  RLGL.State.vertexCounter++;
  RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount++;
}

// Define one vertex (position)
void rlVertex2f(float x, float y) {
  rlVertex3f(x, y, RLGL.currentBatch->currentDepth);
}

// Define one vertex (position)
void rlVertex2i(int x, int y) {
  rlVertex3f((float)x, (float)y, RLGL.currentBatch->currentDepth);
}

// Define one vertex (texture coordinate)
// NOTE: Texture coordinates are limited to QUADS only
void rlTexCoord2f(float x, float y) {
  RLGL.State.texcoordx = x;
  RLGL.State.texcoordy = y;
}

// Define one vertex (normal)
// NOTE: Normals limited to TRIANGLES only?
void rlNormal3f(float x, float y, float z) {
  RLGL.State.normalx = x;
  RLGL.State.normaly = y;
  RLGL.State.normalz = z;
}

// Define one vertex (color)
void rlColor4ub(unsigned char x, unsigned char y, unsigned char z,
                unsigned char w) {
  RLGL.State.colorr = x;
  RLGL.State.colorg = y;
  RLGL.State.colorb = z;
  RLGL.State.colora = w;
}

// Define one vertex (color)
void rlColor4f(float r, float g, float b, float a) {
  rlColor4ub((unsigned char)(r * 255), (unsigned char)(g * 255),
             (unsigned char)(b * 255), (unsigned char)(a * 255));
}

// Define one vertex (color)
void rlColor3f(float x, float y, float z) {
  rlColor4ub((unsigned char)(x * 255), (unsigned char)(y * 255),
             (unsigned char)(z * 255), 255);
}

#endif

//--------------------------------------------------------------------------------------
// Module Functions Definition - OpenGL style functions (common to 1.1, 3.3+,
// ES2)
//--------------------------------------------------------------------------------------

// Set current texture to use
void rlSetTexture(unsigned int id) {
  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
    if (RLGL.State.vertexCounter >=
        RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer]
                .elementCount *
            4) {
      rlDrawRenderBatch(RLGL.currentBatch);
    }
#endif
  } else {
#if defined(GRAPHICS_API_OPENGL_11)
    rlEnableTexture(id);
#else
    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, that way, following QUADS drawing will keep aligned
        // with index processing It implies adding some extra alignment vertex
        // at the end of the draw, those vertex are not processed but they are
        // considered as an additional offset for the next set of vertex to be
        // drawn
        if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode ==
            RL_LINES)
          RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
              .vertexAlignment =
              ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                    .vertexCount < 4)
                   ? RLGL.currentBatch
                         ->draws[RLGL.currentBatch->drawCounter - 1]
                         .vertexCount
                   : RLGL.currentBatch
                             ->draws[RLGL.currentBatch->drawCounter - 1]
                             .vertexCount %
                         4);
        else if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                     .mode == RL_TRIANGLES)
          RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
              .vertexAlignment =
              ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                    .vertexCount < 4)
                   ? 1
                   : (4 - (RLGL.currentBatch
                               ->draws[RLGL.currentBatch->drawCounter - 1]
                               .vertexCount %
                           4)));
        else
          RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
              .vertexAlignment = 0;

        if (!rlCheckRenderBatchLimit(
                RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                    .vertexAlignment)) {
          RLGL.State.vertexCounter +=
              RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1]
                  .vertexAlignment;

          RLGL.currentBatch->drawCounter++;
        }
      }

      if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS)
        rlDrawRenderBatch(RLGL.currentBatch);

      RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId =
          id;
      RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount =
          0;
    }
#endif
  }
}

// Select and active a texture slot
void rlActiveTextureSlot(int slot) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glActiveTexture(GL_TEXTURE0 + slot);
#endif
}

// Enable texture
void rlEnableTexture(unsigned int id) {
#if defined(GRAPHICS_API_OPENGL_11)
  glEnable(GL_TEXTURE_2D);
#endif
  glBindTexture(GL_TEXTURE_2D, id);
}

// Disable texture
void rlDisableTexture(void) {
#if defined(GRAPHICS_API_OPENGL_11)
  glDisable(GL_TEXTURE_2D);
#endif
  glBindTexture(GL_TEXTURE_2D, 0);
}

// Enable texture cubemap
void rlEnableTextureCubemap(unsigned int id) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glBindTexture(GL_TEXTURE_CUBE_MAP, id);
#endif
}

// Disable texture cubemap
void rlDisableTextureCubemap(void) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
#endif
}

// 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 (value == RL_TEXTURE_WRAP_MIRROR_CLAMP) {
#if !defined(GRAPHICS_API_OPENGL_11)
      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)
    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);
    } else
      TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported");
#endif
  } break;
#if defined(GRAPHICS_API_OPENGL_33)
  case RL_TEXTURE_MIPMAP_BIAS_RATIO:
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, value / 100.0f);
#endif
  default:
    break;
  }

  glBindTexture(GL_TEXTURE_2D, 0);
}

// Set cubemap parameters (wrap mode/filter mode)
void rlCubemapParameters(unsigned int id, int param, int value) {
#if !defined(GRAPHICS_API_OPENGL_11)
  glBindTexture(GL_TEXTURE_CUBE_MAP, id);

  // Reset anisotropy filter, in case it was set
  glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);

  switch (param) {
  case RL_TEXTURE_WRAP_S:
  case RL_TEXTURE_WRAP_T: {
    if (value == RL_TEXTURE_WRAP_MIRROR_CLAMP) {
      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: {
    if (value <= RLGL.ExtSupported.maxAnisotropyLevel)
      glTexParameterf(GL_TEXTURE_CUBE_MAP, 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_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT,
                      (float)value);
    } else
      TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported");
  } break;
#if defined(GRAPHICS_API_OPENGL_33)
  case RL_TEXTURE_MIPMAP_BIAS_RATIO:
    glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_LOD_BIAS, value / 100.0f);
#endif
  default:
    break;
  }

  glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
#endif
}

// Enable shader program
void rlEnableShader(unsigned int id) {
#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
  glUseProgram(id);
#endif
}

// Disable shader program
void rlDisableShader(void) {
#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
  glUseProgram(0);
#endif
}

// 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)
  glBindFramebuffer(GL_FRAMEBUFFER, id);
#endif
}

// Disable rendering to texture
void rlDisableFramebuffer(void) {
#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) &&   \
    defined(RLGL_RENDER_TEXTURES_HINT)
  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)
  glBlitFramebuffer(srcX, srcY, srcWidth, srcHeight, dstX, dstY, dstWidth,
                    dstHeight, bufferMask, GL_NEAREST);
#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))
  // NOTE: Maximum number of draw buffers supported is implementation dependant,
  // 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");
    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");
#endif
}

//----------------------------------------------------------------------------------
// General render state configuration
//----------------------------------------------------------------------------------

// Enable color blending
void rlEnableColorBlend(void) {
  glEnable(GL_BLEND); }

// Disable color blending
void rlDisableColorBlend(void) {
  glDisable(GL_BLEND); }

// Enable depth test
void rlEnableDepthTest(void) {
  glEnable(GL_DEPTH_TEST); }

// Disable depth test
void rlDisableDepthTest(void) {
  glDisable(GL_DEPTH_TEST); }

// Enable depth write
void rlEnableDepthMask(void) {
  glDepthMask(GL_TRUE); }

// Disable depth write
void rlDisableDepthMask(void) {
  glDepthMask(GL_FALSE); }

// Enable backface culling
void rlEnableBackfaceCulling(void) {
  glEnable(GL_CULL_FACE); }

// Disable backface culling
void rlDisableBackfaceCulling(void) {
  glDisable(GL_CULL_FACE); }

// Set face culling mode
void rlSetCullFace(int mode) {
  switch (mode) {
  case RL_CULL_FACE_BACK:
    glCullFace(GL_BACK);
    break;
  case RL_CULL_FACE_FRONT:
    glCullFace(GL_FRONT);
    break;
  default:
    break;
  }
}

// Enable scissor test
void rlEnableScissorTest(void) {
  glEnable(GL_SCISSOR_TEST); }

// Disable scissor test
void rlDisableScissorTest(void) {
  glDisable(GL_SCISSOR_TEST); }

// Scissor test
void rlScissor(int x, int y, int width, int height) {
  glScissor(x, y, width, height);
}

// Enable wire mode
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
}

void rlEnablePointMode(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_POINT);
  glEnable(GL_PROGRAM_POINT_SIZE);
#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
}

// Set the line drawing width
void rlSetLineWidth(float width) {
  glLineWidth(width); }

// Get the line drawing width
float rlGetLineWidth(void) {
  float width = 0;
  glGetFloatv(GL_LINE_WIDTH, &width);
  return width;
}

// Enable line aliasing
void rlEnableSmoothLines(void) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11)
  glEnable(GL_LINE_SMOOTH);
#endif
}

// Disable line aliasing
void rlDisableSmoothLines(void) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11)
  glDisable(GL_LINE_SMOOTH);
#endif
}

// Enable stereo rendering
void rlEnableStereoRender(void) {
#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
  RLGL.State.stereoRender = true;
#endif
}

// Disable stereo rendering
void rlDisableStereoRender(void) {
#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
  RLGL.State.stereoRender = false;
#endif
}

// Check if stereo render is enabled
bool rlIsStereoRenderEnabled(void) {
#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
  return RLGL.State.stereoRender;
#else
  return false;
#endif
}

// Clear color buffer with color
void rlClearColor(unsigned char r, unsigned char g, unsigned char b,
                  unsigned char a) {
  // Color values clamp to 0.0f(0) and 1.0f(255)
  float cr = (float)r / 255;
  float cg = (float)g / 255;
  float cb = (float)b / 255;
  float ca = (float)a / 255;

  glClearColor(cr, cg, cb, ca);
}

// Clear used screen buffers (color and depth)
void rlClearScreenBuffers(void) {
  glClear(GL_COLOR_BUFFER_BIT |
          GL_DEPTH_BUFFER_BIT); // Clear used buffers: Color and Depth (Depth is
                                // used for 3D)
  // glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
  // // Stencil buffer not used...
}

// Check and log OpenGL error codes
void rlCheckErrors() {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  int check = 1;
  while (check) {
    const GLenum err = glGetError();
    switch (err) {
    case GL_NO_ERROR:
      check = 0;
      break;
    case 0x0500:
      TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_ENUM");
      break;
    case 0x0501:
      TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_VALUE");
      break;
    case 0x0502:
      TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_OPERATION");
      break;
    case 0x0503:
      TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_OVERFLOW");
      break;
    case 0x0504:
      TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_UNDERFLOW");
      break;
    case 0x0505:
      TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_OUT_OF_MEMORY");
      break;
    case 0x0506:
      TRACELOG(RL_LOG_WARNING,
               "GL: Error detected: GL_INVALID_FRAMEBUFFER_OPERATION");
      break;
    default:
      TRACELOG(RL_LOG_WARNING, "GL: Error detected: Unknown error code: %x",
               err);
      break;
    }
  }
#endif
}

// Set blend mode
void rlSetBlendMode(int mode) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  if ((RLGL.State.currentBlendMode != mode) ||
      ((mode == RL_BLEND_CUSTOM || mode == RL_BLEND_CUSTOM_SEPARATE) &&
       RLGL.State.glCustomBlendModeModified)) {
    rlDrawRenderBatch(RLGL.currentBatch);

    switch (mode) {
    case RL_BLEND_ALPHA:
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
      glBlendEquation(GL_FUNC_ADD);
      break;
    case RL_BLEND_ADDITIVE:
      glBlendFunc(GL_SRC_ALPHA, GL_ONE);
      glBlendEquation(GL_FUNC_ADD);
      break;
    case RL_BLEND_MULTIPLIED:
      glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA);
      glBlendEquation(GL_FUNC_ADD);
      break;
    case RL_BLEND_ADD_COLORS:
      glBlendFunc(GL_ONE, GL_ONE);
      glBlendEquation(GL_FUNC_ADD);
      break;
    case RL_BLEND_SUBTRACT_COLORS:
      glBlendFunc(GL_ONE, GL_ONE);
      glBlendEquation(GL_FUNC_SUBTRACT);
      break;
    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;
    RLGL.State.glCustomBlendModeModified = false;
  }
#endif
}

// Set blending mode factor and equation
void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  if ((RLGL.State.glBlendSrcFactor != glSrcFactor) ||
      (RLGL.State.glBlendDstFactor != glDstFactor) ||
      (RLGL.State.glBlendEquation != glEquation)) {
    RLGL.State.glBlendSrcFactor = glSrcFactor;
    RLGL.State.glBlendDstFactor = glDstFactor;
    RLGL.State.glBlendEquation = glEquation;

    RLGL.State.glCustomBlendModeModified = true;
  }
#endif
}

// Set blending mode factor and equation separately for RGB and alpha
void rlSetBlendFactorsSeparate(int glSrcRGB, int glDstRGB, int glSrcAlpha,
                               int glDstAlpha, int glEqRGB, int glEqAlpha) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  if ((RLGL.State.glBlendSrcFactorRGB != glSrcRGB) ||
      (RLGL.State.glBlendDestFactorRGB != glDstRGB) ||
      (RLGL.State.glBlendSrcFactorAlpha != glSrcAlpha) ||
      (RLGL.State.glBlendDestFactorAlpha != glDstAlpha) ||
      (RLGL.State.glBlendEquationRGB != glEqRGB) ||
      (RLGL.State.glBlendEquationAlpha != glEqAlpha)) {
    RLGL.State.glBlendSrcFactorRGB = glSrcRGB;
    RLGL.State.glBlendDestFactorRGB = glDstRGB;
    RLGL.State.glBlendSrcFactorAlpha = glSrcAlpha;
    RLGL.State.glBlendDestFactorAlpha = glDstAlpha;
    RLGL.State.glBlendEquationRGB = glEqRGB;
    RLGL.State.glBlendEquationAlpha = glEqAlpha;

    RLGL.State.glCustomBlendModeModified = true;
  }
#endif
}

//----------------------------------------------------------------------------------
// Module Functions Definition - OpenGL Debug
//----------------------------------------------------------------------------------
#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43)
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)
  // - #131185 - Buffer detailed info: Buffer object 1 (bound to
  // GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_ENUM_88e4)
  //             will use VIDEO memory as the source for buffer object
  //             operations. (severity: low)
  // - #131218 - Program/shader state performance warning: Vertex shader in
  // program 7 is being recompiled based on GL state. (severity: medium)
  // - #131204 - Texture state usage warning: The texture object (0) bound to
  // texture image unit 0 does not have
  //             a defined base level and cannot be used for texture mapping.
  //             (severity: low)
  if ((id == 131169) || (id == 131185) || (id == 131218) || (id == 131204))
    return;

  const char *msgSource = NULL;
  switch (source) {
  case GL_DEBUG_SOURCE_API:
    msgSource = "API";
    break;
  case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
    msgSource = "WINDOW_SYSTEM";
    break;
  case GL_DEBUG_SOURCE_SHADER_COMPILER:
    msgSource = "SHADER_COMPILER";
    break;
  case GL_DEBUG_SOURCE_THIRD_PARTY:
    msgSource = "THIRD_PARTY";
    break;
  case GL_DEBUG_SOURCE_APPLICATION:
    msgSource = "APPLICATION";
    break;
  case GL_DEBUG_SOURCE_OTHER:
    msgSource = "OTHER";
    break;
  default:
    break;
  }

  const char *msgType = NULL;
  switch (type) {
  case GL_DEBUG_TYPE_ERROR:
    msgType = "ERROR";
    break;
  case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
    msgType = "DEPRECATED_BEHAVIOR";
    break;
  case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
    msgType = "UNDEFINED_BEHAVIOR";
    break;
  case GL_DEBUG_TYPE_PORTABILITY:
    msgType = "PORTABILITY";
    break;
  case GL_DEBUG_TYPE_PERFORMANCE:
    msgType = "PERFORMANCE";
    break;
  case GL_DEBUG_TYPE_MARKER:
    msgType = "MARKER";
    break;
  case GL_DEBUG_TYPE_PUSH_GROUP:
    msgType = "PUSH_GROUP";
    break;
  case GL_DEBUG_TYPE_POP_GROUP:
    msgType = "POP_GROUP";
    break;
  case GL_DEBUG_TYPE_OTHER:
    msgType = "OTHER";
    break;
  default:
    break;
  }

  const char *msgSeverity = "DEFAULT";
  switch (severity) {
  case GL_DEBUG_SEVERITY_LOW:
    msgSeverity = "LOW";
    break;
  case GL_DEBUG_SEVERITY_MEDIUM:
    msgSeverity = "MEDIUM";
    break;
  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(LOG_WARNING, "    > Type: %s", msgType);
  TRACELOG(LOG_WARNING, "    > Source = %s", msgSource);
  TRACELOG(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
#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43)
  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);

    // Debug context options:
    //  - GL_DEBUG_OUTPUT - Faster version but not useful for breakpoints
    //  - GL_DEBUG_OUTPUT_SYNCHRONUS - Callback is in sync with errors, so a
    //  breakpoint can be placed on the callback in order to get a stacktrace
    //  for the GL error
    glEnable(GL_DEBUG_OUTPUT);
    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
  }
#endif

#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);

  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)
  // Loaded: RLGL.State.defaultShaderId + RLGL.State.defaultShaderLocs
  rlLoadShaderDefault();
  RLGL.State.currentShaderId = RLGL.State.defaultShaderId;
  RLGL.State.currentShaderLocs = RLGL.State.defaultShaderLocs;

  // Init default vertex arrays buffers
  RLGL.defaultBatch = rlLoadRenderBatch(RL_DEFAULT_BATCH_BUFFERS,
                                        RL_DEFAULT_BATCH_BUFFER_ELEMENTS);
  RLGL.currentBatch = &RLGL.defaultBatch;

  // Init stack matrices (emulating OpenGL 1.1)
  for (int i = 0; i < RL_MAX_MATRIX_STACK_SIZE; i++)
    RLGL.State.stack[i] = rlMatrixIdentity();

  // 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

  // Initialize OpenGL default states
  //----------------------------------------------------------
  // Init state: Depth test
  glDepthFunc(GL_LEQUAL);   // Type of depth testing to apply
  glDisable(GL_DEPTH_TEST); // Disable depth testing for 2D (only used for 3D)

  // Init state: Blending mode
  glBlendFunc(
      GL_SRC_ALPHA,
      GL_ONE_MINUS_SRC_ALPHA); // Color blending function (how colors are mixed)
  glEnable(
      GL_BLEND); // Enable color blending (required to work with transparencies)

  // Init state: Culling
  // 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) || 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)
}

// 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

  glDeleteTextures(1, &RLGL.State.defaultTextureId); // Unload default texture
  TRACELOG(RL_LOG_INFO,
           "TEXTURE: [ID %i] Default texture unloaded successfully",
           RLGL.State.defaultTextureId);
#endif
}

// Load OpenGL extensions
// NOTE: External loader function must be provided
void rlLoadExtensions(void *loader) {
#if defined(GRAPHICS_API_OPENGL_33) // Also defined for GRAPHICS_API_OPENGL_21
  // NOTE: glad is generated and contains only required OpenGL 3.3 Core
  // extensions (and lower versions)
  if (gladLoadGL((GLADloadfunc)loader) == 0)
    TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL extensions");
  else
    TRACELOG(RL_LOG_INFO, "GLAD: OpenGL extensions loaded successfully");

  // 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)
  // 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_21)
  // Register supported extensions flags
  // Optional OpenGL 2.1 extensions
  RLGL.ExtSupported.vao = GLAD_GL_ARB_vertex_array_object;
  RLGL.ExtSupported.instancing =
      (GLAD_GL_EXT_draw_instanced && GLAD_GL_ARB_instanced_arrays);
  RLGL.ExtSupported.texNPOT = GLAD_GL_ARB_texture_non_power_of_two;
  RLGL.ExtSupported.texFloat32 = GLAD_GL_ARB_texture_float;
  RLGL.ExtSupported.texFloat16 = GLAD_GL_ARB_texture_float;
  RLGL.ExtSupported.texDepth = GLAD_GL_ARB_depth_texture;
  RLGL.ExtSupported.maxDepthBits = 32;
  RLGL.ExtSupported.texAnisoFilter = GLAD_GL_EXT_texture_filter_anisotropic;
  RLGL.ExtSupported.texMirrorClamp = GLAD_GL_EXT_texture_mirror_clamp;
#else
  // Register supported extensions flags
  // OpenGL 3.3 extensions supported by default (core)
  RLGL.ExtSupported.vao = true;
  RLGL.ExtSupported.instancing = true;
  RLGL.ExtSupported.texNPOT = true;
  RLGL.ExtSupported.texFloat32 = true;
  RLGL.ExtSupported.texFloat16 = true;
  RLGL.ExtSupported.texDepth = true;
  RLGL.ExtSupported.maxDepthBits = 32;
  RLGL.ExtSupported.texAnisoFilter = true;
  RLGL.ExtSupported.texMirrorClamp = true;
#endif

  // Optional OpenGL 3.3 extensions
  RLGL.ExtSupported.texCompASTC = GLAD_GL_KHR_texture_compression_astc_hdr &&
                                  GLAD_GL_KHR_texture_compression_astc_ldr;
  RLGL.ExtSupported.texCompDXT =
      GLAD_GL_EXT_texture_compression_s3tc; // Texture compression: DXT
  RLGL.ExtSupported.texCompETC2 =
      GLAD_GL_ARB_ES3_compatibility; // Texture compression: ETC2/EAC
#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

#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;
  RLGL.ExtSupported.instancing = true;
  RLGL.ExtSupported.texNPOT = true;
  RLGL.ExtSupported.texFloat32 = true;
  RLGL.ExtSupported.texFloat16 = true;
  RLGL.ExtSupported.texDepth = true;
  RLGL.ExtSupported.texDepthWebGL = true;
  RLGL.ExtSupported.maxDepthBits = 24;
  RLGL.ExtSupported.texAnisoFilter = true;
  RLGL.ExtSupported.texMirrorClamp = true;
  // TODO: Check for additional OpenGL ES 3.0 supported extensions:
  // RLGL.ExtSupported.texCompDXT = true;
  // RLGL.ExtSupported.texCompETC1 = true;
  // RLGL.ExtSupported.texCompETC2 = true;
  // RLGL.ExtSupported.texCompPVRT = true;
  // RLGL.ExtSupported.texCompASTC = true;
  // RLGL.ExtSupported.maxAnisotropyLevel = true;
  // RLGL.ExtSupported.computeShader = true;
  // RLGL.ExtSupported.ssbo = true;

#elif defined(GRAPHICS_API_OPENGL_ES2)

#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL)
  // TODO: Support GLAD loader for OpenGL ES 3.0
  if (gladLoadGLES2((GLADloadfunc)loader) == 0)
    TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL ES2.0 functions");
  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 *extensions =
      (const char *)glGetString(GL_EXTENSIONS); // One big const string

  // NOTE: We have to duplicate string because glGetString() returns a const
  // string
  int size = strlen(extensions) + 1; // Get extensions string size in bytes
  char *extensionsDup = (char *)RL_CALLOC(size, sizeof(char));
  strcpy(extensionsDup, extensions);
  extList[numExt] = extensionsDup;

  for (int i = 0; i < size; i++) {
    if (extensionsDup[i] == ' ') {
      extensionsDup[i] = '\0';
      numExt++;
      extList[numExt] = &extensionsDup[i + 1];
    }
  }

  TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt);

#if defined(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
  for (int i = 0; i < numExt; i++) {
    // Check VAO support
    // NOTE: Only check on OpenGL ES, OpenGL 3.3 has VAO support as core feature
    if (strcmp(extList[i], (const char *)"GL_OES_vertex_array_object") == 0) {
      // The extension is supported by our hardware and driver, try to get
      // related functions pointers NOTE: emscripten does not support VAOs
      // natively, it uses emulation and it reduces overall performance...
      glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)((rlglLoadProc)loader)(
          "glGenVertexArraysOES");
      glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)((rlglLoadProc)loader)(
          "glBindVertexArrayOES");
      glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)((
          rlglLoadProc)loader)("glDeleteVertexArraysOES");
      // glIsVertexArray =
      // (PFNGLISVERTEXARRAYOESPROC)loader("glIsVertexArrayOES");     // NOTE:
      // Fails in WebGL, omitted

      if ((glGenVertexArrays != NULL) && (glBindVertexArray != NULL) &&
          (glDeleteVertexArrays != NULL))
        RLGL.ExtSupported.vao = true;
    }

    // Check instanced rendering support
    if (strcmp(extList[i], (const char *)"GL_ANGLE_instanced_arrays") ==
        0) // Web ANGLE
    {
      glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((
          rlglLoadProc)loader)("glDrawArraysInstancedANGLE");
      glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((
          rlglLoadProc)loader)("glDrawElementsInstancedANGLE");
      glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((
          rlglLoadProc)loader)("glVertexAttribDivisorANGLE");

      if ((glDrawArraysInstanced != NULL) &&
          (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL))
        RLGL.ExtSupported.instancing = true;
    } else {
      if ((strcmp(extList[i], (const char *)"GL_EXT_draw_instanced") ==
           0) && // Standard EXT
          (strcmp(extList[i], (const char *)"GL_EXT_instanced_arrays") == 0)) {
        glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((
            rlglLoadProc)loader)("glDrawArraysInstancedEXT");
        glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((
            rlglLoadProc)loader)("glDrawElementsInstancedEXT");
        glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((
            rlglLoadProc)loader)("glVertexAttribDivisorEXT");

        if ((glDrawArraysInstanced != NULL) &&
            (glDrawElementsInstanced != NULL) &&
            (glVertexAttribDivisor != NULL))
          RLGL.ExtSupported.instancing = true;
      }
    }

    // Check NPOT textures support
    // NOTE: Only check on OpenGL ES, OpenGL 3.3 has NPOT textures full support
    // as core feature
    if (strcmp(extList[i], (const char *)"GL_OES_texture_npot") == 0)
      RLGL.ExtSupported.texNPOT = true;

    // Check texture float support
    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 (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_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;

    // Check texture compression support: ETC1
    if ((strcmp(extList[i],
                (const char *)"GL_OES_compressed_ETC1_RGB8_texture") == 0) ||
        (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_etc1") ==
         0))
      RLGL.ExtSupported.texCompETC1 = true;

    // Check texture compression support: ETC2/EAC
    if (strcmp(extList[i], (const char *)"GL_ARB_ES3_compatibility") == 0)
      RLGL.ExtSupported.texCompETC2 = true;

    // Check texture compression support: PVR
    if (strcmp(extList[i], (const char *)"GL_IMG_texture_compression_pvrtc") ==
        0)
      RLGL.ExtSupported.texCompPVRT = true;

    // Check texture compression support: ASTC
    if (strcmp(extList[i],
               (const char *)"GL_KHR_texture_compression_astc_hdr") == 0)
      RLGL.ExtSupported.texCompASTC = true;

    // Check anisotropic texture filter support
    if (strcmp(extList[i], (const char *)"GL_EXT_texture_filter_anisotropic") ==
        0)
      RLGL.ExtSupported.texAnisoFilter = true;

    // Check clamp mirror wrap mode support
    if (strcmp(extList[i], (const char *)"GL_EXT_texture_mirror_clamp") == 0)
      RLGL.ExtSupported.texMirrorClamp = true;
  }

  // Free extensions pointers
  RL_FREE(extList);
  RL_FREE(extensionsDup); // Duplicated string must be deallocated
#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, "    > Vendor:   %s", glGetString(GL_VENDOR));
  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)
// 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)
  // 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);
  glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &capability);
  TRACELOG(RL_LOG_INFO, "    GL_MAX_CUBE_MAP_TEXTURE_SIZE: %i", capability);
  glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &capability);
  TRACELOG(RL_LOG_INFO, "    GL_MAX_TEXTURE_IMAGE_UNITS: %i", capability);
  glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &capability);
  TRACELOG(RL_LOG_INFO, "    GL_MAX_VERTEX_ATTRIBS: %i", capability);
#if !defined(GRAPHICS_API_OPENGL_ES2)
  glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &capability);
  TRACELOG(RL_LOG_INFO, "    GL_MAX_UNIFORM_BLOCK_SIZE: %i", capability);
  glGetIntegerv(GL_MAX_DRAW_BUFFERS, &capability);
  TRACELOG(RL_LOG_INFO, "    GL_MAX_DRAW_BUFFERS: %i", capability);
  if (RLGL.ExtSupported.texAnisoFilter)
    TRACELOG(RL_LOG_INFO, "    GL_MAX_TEXTURE_MAX_ANISOTROPY: %.0f",
             RLGL.ExtSupported.maxAnisotropyLevel);
#endif
  glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &capability);
  TRACELOG(RL_LOG_INFO, "    GL_NUM_COMPRESSED_TEXTURE_FORMATS: %i",
           capability);
  GLint *compFormats = (GLint *)RL_CALLOC(capability, sizeof(GLint));
  glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, compFormats);
  for (int i = 0; i < capability; i++)
    TRACELOG(RL_LOG_INFO, "        %s",
             rlGetCompressedFormatName(compFormats[i]));
  RL_FREE(compFormats);

#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
#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");
  else
    TRACELOG(RL_LOG_WARNING, "GL: NPOT textures extension not found, limited "
                             "NPOT support (no-mipmaps, no-repeat)");
  if (RLGL.ExtSupported.texCompDXT)
    TRACELOG(RL_LOG_INFO, "GL: DXT compressed textures supported");
  if (RLGL.ExtSupported.texCompETC1)
    TRACELOG(RL_LOG_INFO, "GL: ETC1 compressed 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 // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
}

// Get current OpenGL version
int rlGetVersion(void) {
  int glVersion = 0;
#if 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)
  glVersion = RL_OPENGL_43;
#elif defined(GRAPHICS_API_OPENGL_33)
  glVersion = RL_OPENGL_33;
#endif
#if defined(GRAPHICS_API_OPENGL_ES3)
  glVersion = RL_OPENGL_ES_30;
#elif defined(GRAPHICS_API_OPENGL_ES2)
  glVersion = RL_OPENGL_ES_20;
#endif

  return glVersion;
}

// Set current framebuffer width
void rlSetFramebufferWidth(int width) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  RLGL.State.framebufferWidth = width;
#endif
}

// Set current framebuffer height
void rlSetFramebufferHeight(int height) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  RLGL.State.framebufferHeight = height;
#endif
}

// Get default framebuffer width
int rlGetFramebufferWidth(void) {
  int width = 0;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  width = RLGL.State.framebufferWidth;
#endif
  return width;
}

// Get default framebuffer height
int rlGetFramebufferHeight(void) {
  int height = 0;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  height = RLGL.State.framebufferHeight;
#endif
  return height;
}

// Get default internal texture (white texture)
// NOTE: Default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8
unsigned int rlGetTextureIdDefault(void) {
  unsigned int id = 0;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  id = RLGL.State.defaultTextureId;
#endif
  return id;
}

// Get default shader id
unsigned int rlGetShaderIdDefault(void) {
  unsigned int id = 0;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  id = RLGL.State.defaultShaderId;
#endif
  return id;
}

// Get default shader locs
int *rlGetShaderLocsDefault(void) {
  int *locs = NULL;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  locs = RLGL.State.defaultShaderLocs;
#endif
  return locs;
}

// Render batch management
//------------------------------------------------------------------------------------------------
// Load render batch
rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements) {
  rlRenderBatch batch = {0};

#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));

  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].texcoords = (float *)RL_MALLOC(
        bufferElements * 2 * 4 *
        sizeof(float)); // 2 float by texcoord, 4 texcoord by quad
    batch.vertexBuffer[i].colors = (unsigned char *)RL_MALLOC(
        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)
#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)
#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 < (4 * 4 * bufferElements); j++)
      batch.vertexBuffer[i].colors[j] = 0;

    int k = 0;

    // Indices can be initialized right now
    for (int j = 0; j < (6 * bufferElements); j += 6) {
      batch.vertexBuffer[i].indices[j] = 4 * k;
      batch.vertexBuffer[i].indices[j + 1] = 4 * k + 1;
      batch.vertexBuffer[i].indices[j + 2] = 4 * k + 2;
      batch.vertexBuffer[i].indices[j + 3] = 4 * k;
      batch.vertexBuffer[i].indices[j + 4] = 4 * k + 2;
      batch.vertexBuffer[i].indices[j + 5] = 4 * k + 3;

      k++;
    }

    RLGL.State.vertexCounter = 0;
  }

  TRACELOG(
      RL_LOG_INFO,
      "RLGL: Render batch vertex buffers loaded successfully in RAM (CPU)");
  //--------------------------------------------------------------------------------------------

  // Upload to GPU (VRAM) vertex data and initialize VAOs/VBOs
  //--------------------------------------------------------------------------------------------
  for (int i = 0; i < numBuffers; i++) {
    if (RLGL.ExtSupported.vao) {
      // Initialize Quads VAO
      glGenVertexArrays(1, &batch.vertexBuffer[i].vaoId);
      glBindVertexArray(batch.vertexBuffer[i].vaoId);
    }

    // Quads - Vertex buffers binding and attributes enable
    // Vertex position buffer (shader-location = 0)
    glGenBuffers(1, &batch.vertexBuffer[i].vboId[0]);
    glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[0]);
    glBufferData(GL_ARRAY_BUFFER, bufferElements * 3 * 4 * sizeof(float),
                 batch.vertexBuffer[i].vertices, GL_DYNAMIC_DRAW);
    glEnableVertexAttribArray(
        RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]);
    glVertexAttribPointer(
        RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3,
        GL_FLOAT, 0, 0, 0);

    // Vertex texcoord buffer (shader-location = 1)
    glGenBuffers(1, &batch.vertexBuffer[i].vboId[1]);
    glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[1]);
    glBufferData(GL_ARRAY_BUFFER, bufferElements * 2 * 4 * sizeof(float),
                 batch.vertexBuffer[i].texcoords, GL_DYNAMIC_DRAW);
    glEnableVertexAttribArray(
        RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]);
    glVertexAttribPointer(
        RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2,
        GL_FLOAT, 0, 0, 0);

    // Vertex color buffer (shader-location = 3)
    glGenBuffers(1, &batch.vertexBuffer[i].vboId[2]);
    glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[2]);
    glBufferData(GL_ARRAY_BUFFER,
                 bufferElements * 4 * 4 * sizeof(unsigned char),
                 batch.vertexBuffer[i].colors, GL_DYNAMIC_DRAW);
    glEnableVertexAttribArray(
        RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]);
    glVertexAttribPointer(
        RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4,
        GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);

    // Fill index buffer
    glGenBuffers(1, &batch.vertexBuffer[i].vboId[3]);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[3]);
#if defined(GRAPHICS_API_OPENGL_33)
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements * 6 * sizeof(int),
                 batch.vertexBuffer[i].indices, GL_STATIC_DRAW);
#endif
#if defined(GRAPHICS_API_OPENGL_ES2)
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements * 6 * sizeof(short),
                 batch.vertexBuffer[i].indices, GL_STATIC_DRAW);
#endif
  }

  TRACELOG(
      RL_LOG_INFO,
      "RLGL: Render batch vertex buffers loaded successfully in VRAM (GPU)");

  // Unbind the current VAO
  if (RLGL.ExtSupported.vao)
    glBindVertexArray(0);
  //--------------------------------------------------------------------------------------------

  // Init draw calls tracking system
  //--------------------------------------------------------------------------------------------
  batch.draws =
      (rlDrawCall *)RL_MALLOC(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].vertexAlignment = 0;
    // batch.draws[i].vaoId = 0;
    // batch.draws[i].shaderId = 0;
    batch.draws[i].textureId = RLGL.State.defaultTextureId;
    // batch.draws[i].RLGL.State.projection = rlMatrixIdentity();
    // 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
  //--------------------------------------------------------------------------------------------
#endif

  return batch;
}

// Unload default internal buffers vertex data from CPU and GPU
void rlUnloadRenderBatch(rlRenderBatch batch) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  // Unbind everything
  glBindBuffer(GL_ARRAY_BUFFER, 0);
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

  // Unload all vertex buffers data
  for (int i = 0; i < batch.bufferCount; i++) {
    // Unbind VAO attribs data
    if (RLGL.ExtSupported.vao) {
      glBindVertexArray(batch.vertexBuffer[i].vaoId);
      glDisableVertexAttribArray(0);
      glDisableVertexAttribArray(1);
      glDisableVertexAttribArray(2);
      glDisableVertexAttribArray(3);
      glBindVertexArray(0);
    }

    // Delete VBOs from GPU (VRAM)
    glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[0]);
    glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[1]);
    glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[2]);
    glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[3]);

    // Delete VAOs from GPU (VRAM)
    if (RLGL.ExtSupported.vao)
      glDeleteVertexArrays(1, &batch.vertexBuffer[i].vaoId);

    // Free vertex arrays memory from CPU (RAM)
    RL_FREE(batch.vertexBuffer[i].vertices);
    RL_FREE(batch.vertexBuffer[i].texcoords);
    RL_FREE(batch.vertexBuffer[i].colors);
    RL_FREE(batch.vertexBuffer[i].indices);
  }

  // Unload arrays
  RL_FREE(batch.vertexBuffer);
  RL_FREE(batch.draws);
#endif
}

// Draw render batch
// NOTE: We require a pointer to reset batch and increase current buffer
// (multi-buffer)
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);

    // 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

    // Texture coordinates buffer
    glBindBuffer(GL_ARRAY_BUFFER,
                 batch->vertexBuffer[batch->currentBuffer].vboId[1]);
    glBufferSubData(GL_ARRAY_BUFFER, 0,
                    RLGL.State.vertexCounter * 2 * sizeof(float),
                    batch->vertexBuffer[batch->currentBuffer].texcoords);
    // glBufferData(GL_ARRAY_BUFFER,
    // sizeof(float)*2*4*batch->vertexBuffer[batch->currentBuffer].elementCount,
    // batch->vertexBuffer[batch->currentBuffer].texcoords, GL_DYNAMIC_DRAW); //
    // Update all buffer

    // Colors buffer
    glBindBuffer(GL_ARRAY_BUFFER,
                 batch->vertexBuffer[batch->currentBuffer].vboId[2]);
    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(). If you do 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); if
    // (batch->vertexBuffer[batch->currentBuffer].vertices)
    // {
    // Update vertex data
    // }
    // glUnmapBuffer(GL_ARRAY_BUFFER);

    // Unbind the current VAO
    if (RLGL.ExtSupported.vao)
      glBindVertexArray(0);
  }
  //------------------------------------------------------------------------------------------------------------

  // Draw batch vertex buffers (considering VR stereo if required)
  //------------------------------------------------------------------------------------------------------------
  Matrix matProjection = RLGL.State.projection;
  Matrix matModelView = RLGL.State.modelview;

  int eyeCount = 1;
  if (RLGL.State.stereoRender)
    eyeCount = 2;

  for (int eye = 0; eye < eyeCount; eye++) {
    if (eyeCount == 2) {
      // Setup current eye viewport (half screen width)
      rlViewport(eye * RLGL.State.framebufferWidth / 2, 0,
                 RLGL.State.framebufferWidth / 2, RLGL.State.framebufferHeight);

      // Set current eye view offset to modelview matrix
      rlSetMatrixModelview(
          rlMatrixMultiply(matModelView, RLGL.State.viewOffsetStereo[eye]));
      // Set current eye projection matrix
      rlSetMatrixProjection(RLGL.State.projectionStereo[eye]);
    }

    // Draw buffers
    if (RLGL.State.vertexCounter > 0) {
      // Set current shader and upload current MVP matrix
      glUseProgram(RLGL.State.currentShaderId);

      // Create modelview-projection matrix and upload to shader
      Matrix matMVP =
          rlMatrixMultiply(RLGL.State.modelview, RLGL.State.projection);
      float matMVPfloat[16] = {matMVP.m0,  matMVP.m1,  matMVP.m2,  matMVP.m3,
                               matMVP.m4,  matMVP.m5,  matMVP.m6,  matMVP.m7,
                               matMVP.m8,  matMVP.m9,  matMVP.m10, matMVP.m11,
                               matMVP.m12, matMVP.m13, matMVP.m14, matMVP.m15};
      glUniformMatrix4fv(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_MVP],
                         1, false, matMVPfloat);

      if (RLGL.ExtSupported.vao)
        glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId);
      else {
        // Bind vertex attrib: position (shader-location = 0)
        glBindBuffer(GL_ARRAY_BUFFER,
                     batch->vertexBuffer[batch->currentBuffer].vboId[0]);
        glVertexAttribPointer(
            RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3,
            GL_FLOAT, 0, 0, 0);
        glEnableVertexAttribArray(
            RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]);

        // Bind vertex attrib: texcoord (shader-location = 1)
        glBindBuffer(GL_ARRAY_BUFFER,
                     batch->vertexBuffer[batch->currentBuffer].vboId[1]);
        glVertexAttribPointer(
            RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2,
            GL_FLOAT, 0, 0, 0);
        glEnableVertexAttribArray(
            RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]);

        // Bind vertex attrib: color (shader-location = 3)
        glBindBuffer(GL_ARRAY_BUFFER,
                     batch->vertexBuffer[batch->currentBuffer].vboId[2]);
        glVertexAttribPointer(
            RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4,
            GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
        glEnableVertexAttribArray(
            RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]);

        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
                     batch->vertexBuffer[batch->currentBuffer].vboId[3]);
      }

      // Setup some default shader values
      glUniform4f(RLGL.State.currentShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE],
                  1.0f, 1.0f, 1.0f, 1.0f);
      glUniform1i(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE],
                  0); // Active default sampler2D: texture0

      // Activate additional sampler textures
      // Those additional textures will be common for all draw calls of the
      // batch
      for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) {
        if (RLGL.State.activeTextureId[i] > 0) {
          glActiveTexture(GL_TEXTURE0 + 1 + i);
          glBindTexture(GL_TEXTURE_2D, RLGL.State.activeTextureId[i]);
        }
      }

      // Activate default sampler2D texture0 (one texture is always active for
      // default batch shader) 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
        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 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)
          glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount / 4 * 6,
                         GL_UNSIGNED_SHORT,
                         (GLvoid *)(vertexOffset / 4 * 6 * sizeof(GLushort)));
#endif
        }

        vertexOffset +=
            (batch->draws[i].vertexCount + batch->draws[i].vertexAlignment);
      }

      if (!RLGL.ExtSupported.vao) {
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
      }

      glBindTexture(GL_TEXTURE_2D, 0); // Unbind textures
    }

    if (RLGL.ExtSupported.vao)
      glBindVertexArray(0); // Unbind VAO

    glUseProgram(0); // Unbind shader program
  }

  // Restore viewport to default measures
  if (eyeCount == 2)
    rlViewport(0, 0, RLGL.State.framebufferWidth, RLGL.State.framebufferHeight);
  //------------------------------------------------------------------------------------------------------------

  // Reset batch buffers
  //------------------------------------------------------------------------------------------------------------
  // Reset vertex counter for next frame
  RLGL.State.vertexCounter = 0;

  // Reset depth for next draw
  batch->currentDepth = -1.0f;

  // Restore projection/modelview matrices
  RLGL.State.projection = matProjection;
  RLGL.State.modelview = matModelView;

  // Reset RLGL.currentBatch->draws array
  for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++) {
    batch->draws[i].mode = RL_QUADS;
    batch->draws[i].vertexCount = 0;
    batch->draws[i].textureId = RLGL.State.defaultTextureId;
  }

  // Reset active texture units for next batch
  for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++)
    RLGL.State.activeTextureId[i] = 0;

  // Reset draws counter to one draw for the batch
  batch->drawCounter = 1;
  //------------------------------------------------------------------------------------------------------------

  // Change to next buffer in the list (in case of multi-buffering)
  batch->currentBuffer++;
  if (batch->currentBuffer >= batch->bufferCount)
    batch->currentBuffer = 0;
#endif
}

// Set the active render batch for rlgl
void rlSetRenderBatchActive(rlRenderBatch *batch) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  rlDrawRenderBatch(RLGL.currentBatch);

  if (batch != NULL)
    RLGL.currentBatch = batch;
  else
    RLGL.currentBatch = &RLGL.defaultBatch;
#endif
}

// Update and draw internal render batch
void rlDrawRenderBatchActive(void) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  rlDrawRenderBatch(
      RLGL.currentBatch); // NOTE: Stereo rendering is checked inside
#endif
}

// Check internal buffer overflow for a given number of vertex
// and force a rlRenderBatch draw call if required
bool rlCheckRenderBatchLimit(int vCount) {
  bool overflow = false;

#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  if ((RLGL.State.vertexCounter + vCount) >=
      (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer]
           .elementCount *
       4)) {
    overflow = true;

    // Store current primitive drawing mode and texture id
    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
    RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode =
        currentMode;
    RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId =
        currentTexture;
  }
#endif

  return overflow;
}

// Textures data management
//-----------------------------------------------------------------------------------------
// 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;

  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) {
    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) ||
       (format == RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) ||
       (format == RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA))) {
    TRACELOG(RL_LOG_WARNING, "GL: DXT compressed texture format not supported");
    return id;
  }
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  if ((!RLGL.ExtSupported.texCompETC1) &&
      (format == RL_PIXELFORMAT_COMPRESSED_ETC1_RGB)) {
    TRACELOG(RL_LOG_WARNING,
             "GL: ETC1 compressed texture format not supported");
    return id;
  }

  if ((!RLGL.ExtSupported.texCompETC2) &&
      ((format == RL_PIXELFORMAT_COMPRESSED_ETC2_RGB) ||
       (format == RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA))) {
    TRACELOG(RL_LOG_WARNING,
             "GL: ETC2 compressed texture format not supported");
    return id;
  }

  if ((!RLGL.ExtSupported.texCompPVRT) &&
      ((format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGB) ||
       (format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA))) {
    TRACELOG(RL_LOG_WARNING,
             "GL: PVRT compressed texture format not supported");
    return id;
  }

  if ((!RLGL.ExtSupported.texCompASTC) &&
      ((format == RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA) ||
       (format == RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA))) {
    TRACELOG(RL_LOG_WARNING,
             "GL: ASTC compressed texture format not supported");
    return id;
  }
#endif
#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

  // NOTE: Added pointer math separately from function to avoid UBSAN
  // complaining
  unsigned char *dataPtr = NULL;
  if (data != NULL)
    dataPtr = (unsigned char *)data;

  // Load the different mipmap levels
  for (int i = 0; i < mipmapCount; i++) {
    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);

    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)
      else
        glCompressedTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth,
                               mipHeight, 0, mipSize, dataPtr);
#endif

#if defined(GRAPHICS_API_OPENGL_33)
      if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) {
        GLint swizzleMask[] = {GL_RED, GL_RED, GL_RED, GL_ONE};
        glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
      } else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) {
#if defined(GRAPHICS_API_OPENGL_21)
        GLint swizzleMask[] = {GL_RED, GL_RED, GL_RED, GL_ALPHA};
#elif defined(GRAPHICS_API_OPENGL_33)
        GLint swizzleMask[] = {GL_RED, GL_RED, GL_RED, GL_GREEN};
#endif
        glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
      }
#endif
    }

    mipWidth /= 2;
    mipHeight /= 2;
    mipOffset += mipSize; // Increment offset position 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
#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_WRAP_T,
                    GL_REPEAT); // Set texture to repeat on y-axis
  } else {
    // NOTE: If using negative texture coordinates (LoadOBJ()), it does not
    // work!
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
                    GL_CLAMP_TO_EDGE); // Set texture to clamp on x-axis
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
                    GL_CLAMP_TO_EDGE); // Set texture to clamp on y-axis
  }
#else
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
                  GL_REPEAT); // Set texture to repeat on x-axis
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
                  GL_REPEAT); // Set texture to repeat on y-axis
#endif

  // Magnification and minification filters
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                  GL_NEAREST); // Alternative: GL_LINEAR
  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
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                    GL_LINEAR_MIPMAP_LINEAR);
  }
#endif

  // At this point we have the texture 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);

  if (id > 0)
    TRACELOG(RL_LOG_INFO,
             "TEXTURE: [ID %i] Texture loaded successfully (%ix%i | %s | %i "
             "mipmaps)",
             id, width, height, rlGetPixelFormatName(format), mipmapCount);
  else
    TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load texture");

  return id;
}

// 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 defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  // In case depth textures not supported, we force renderbuffer usage
  if (!RLGL.ExtSupported.texDepth)
    useRenderBuffer = true;

  // NOTE: We let 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))
  // 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 (!useRenderBuffer && RLGL.ExtSupported.texDepth) {
    glGenTextures(1, &id);
    glBindTexture(GL_TEXTURE_2D, id);
    glTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat, width, height, 0,
                 GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glBindTexture(GL_TEXTURE_2D, 0);

    TRACELOG(RL_LOG_INFO, "TEXTURE: Depth texture loaded successfully");
  } else {
    // Create the renderbuffer that will serve as the depth attachment for the
    // framebuffer NOTE: A renderbuffer is simpler than a texture and could
    // offer better performance on embedded devices
    glGenRenderbuffers(1, &id);
    glBindRenderbuffer(GL_RENDERBUFFER, id);
    glRenderbufferStorage(GL_RENDERBUFFER, glInternalFormat, width, height);

    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);
  }
#endif

  return id;
}

// Load texture cubemap
// 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) {
  unsigned int id = 0;

#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  unsigned int dataSize = rlGetPixelDataSize(size, size, format);

  glGenTextures(1, &id);
  glBindTexture(GL_TEXTURE_CUBE_MAP, id);

  unsigned int glInternalFormat, glFormat, glType;
  rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);

  if (glInternalFormat != 0) {
    // Load cubemap faces
    for (unsigned int i = 0; i < 6; i++) {
      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 + i, 0,
                         glInternalFormat, size, size, 0, glFormat, glType,
                         NULL);
        } else
          TRACELOG(RL_LOG_WARNING, "TEXTURES: Empty cubemap creation does not "
                                   "support compressed format");
      } else {
        if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)
          glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat,
                       size, size, 0, glFormat, glType,
                       (unsigned char *)data + i * dataSize);
        else
          glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0,
                                 glInternalFormat, size, size, 0, dataSize,
                                 (unsigned char *)data + i * dataSize);
      }

#if defined(GRAPHICS_API_OPENGL_33)
      if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) {
        GLint swizzleMask[] = {GL_RED, GL_RED, GL_RED, GL_ONE};
        glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA,
                         swizzleMask);
      } else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) {
#if defined(GRAPHICS_API_OPENGL_21)
        GLint swizzleMask[] = {GL_RED, GL_RED, GL_RED, GL_ALPHA};
#elif defined(GRAPHICS_API_OPENGL_33)
        GLint swizzleMask[] = {GL_RED, GL_RED, GL_RED, GL_GREEN};
#endif
        glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA,
                         swizzleMask);
      }
#endif
    }
  }

  // Set cubemap texture sampling parameters
  glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
#if defined(GRAPHICS_API_OPENGL_33)
  glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R,
                  GL_CLAMP_TO_EDGE); // Flag not supported on OpenGL ES 2.0
#endif

  glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
#endif

  if (id > 0)
    TRACELOG(RL_LOG_INFO,
             "TEXTURE: [ID %i] Cubemap texture loaded successfully (%ix%i)", id,
             size, size);
  else
    TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load cubemap texture");

  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...
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;
  rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);

  if ((glInternalFormat != 0) &&
      (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)) {
    glTexSubImage2D(GL_TEXTURE_2D, 0, offsetX, offsetY, width, height, glFormat,
                    glType, data);
  } else
    TRACELOG(
        RL_LOG_WARNING,
        "TEXTURE: [ID %i] Failed to update for current texture format (%i)", id,
        format);
}

// Get OpenGL internal formats and data type from raylib PixelFormat
void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat,
                           unsigned int *glFormat, unsigned int *glType) {
  *glInternalFormat = 0;
  *glFormat = 0;
  *glType = 0;

  switch (format) {
#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_21) ||      \
    defined(GRAPHICS_API_OPENGL_ES2)
  // NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and
  // options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA
  case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE:
    *glInternalFormat = GL_LUMINANCE;
    *glFormat = GL_LUMINANCE;
    *glType = GL_UNSIGNED_BYTE;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
    *glInternalFormat = GL_LUMINANCE_ALPHA;
    *glFormat = GL_LUMINANCE_ALPHA;
    *glType = GL_UNSIGNED_BYTE;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5:
    *glInternalFormat = GL_RGB;
    *glFormat = GL_RGB;
    *glType = GL_UNSIGNED_SHORT_5_6_5;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8:
    *glInternalFormat = GL_RGB;
    *glFormat = GL_RGB;
    *glType = GL_UNSIGNED_BYTE;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
    *glInternalFormat = GL_RGBA;
    *glFormat = GL_RGBA;
    *glType = GL_UNSIGNED_SHORT_5_5_5_1;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4:
    *glInternalFormat = GL_RGBA;
    *glFormat = GL_RGBA;
    *glType = GL_UNSIGNED_SHORT_4_4_4_4;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8:
    *glInternalFormat = GL_RGBA;
    *glFormat = GL_RGBA;
    *glType = GL_UNSIGNED_BYTE;
    break;
#if !defined(GRAPHICS_API_OPENGL_11)
#if defined(GRAPHICS_API_OPENGL_ES3)
  case RL_PIXELFORMAT_UNCOMPRESSED_R32:
    if (RLGL.ExtSupported.texFloat32)
      *glInternalFormat = GL_R32F_EXT;
    *glFormat = GL_RED_EXT;
    *glType = GL_FLOAT;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32:
    if (RLGL.ExtSupported.texFloat32)
      *glInternalFormat = GL_RGB32F_EXT;
    *glFormat = GL_RGB;
    *glType = GL_FLOAT;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32:
    if (RLGL.ExtSupported.texFloat32)
      *glInternalFormat = GL_RGBA32F_EXT;
    *glFormat = GL_RGBA;
    *glType = GL_FLOAT;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R16:
    if (RLGL.ExtSupported.texFloat16)
      *glInternalFormat = GL_R16F_EXT;
    *glFormat = GL_RED_EXT;
    *glType = GL_HALF_FLOAT;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16:
    if (RLGL.ExtSupported.texFloat16)
      *glInternalFormat = GL_RGB16F_EXT;
    *glFormat = GL_RGB;
    *glType = GL_HALF_FLOAT;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16:
    if (RLGL.ExtSupported.texFloat16)
      *glInternalFormat = GL_RGBA16F_EXT;
    *glFormat = GL_RGBA;
    *glType = GL_HALF_FLOAT;
    break;
#else
  case RL_PIXELFORMAT_UNCOMPRESSED_R32:
    if (RLGL.ExtSupported.texFloat32)
      *glInternalFormat = GL_LUMINANCE;
    *glFormat = GL_LUMINANCE;
    *glType = GL_FLOAT;
    break; // NOTE: Requires extension OES_texture_float
  case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32:
    if (RLGL.ExtSupported.texFloat32)
      *glInternalFormat = GL_RGB;
    *glFormat = GL_RGB;
    *glType = GL_FLOAT;
    break; // NOTE: Requires extension OES_texture_float
  case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32:
    if (RLGL.ExtSupported.texFloat32)
      *glInternalFormat = GL_RGBA;
    *glFormat = GL_RGBA;
    *glType = GL_FLOAT;
    break; // NOTE: Requires extension OES_texture_float
#if defined(GRAPHICS_API_OPENGL_21)
  case RL_PIXELFORMAT_UNCOMPRESSED_R16:
    if (RLGL.ExtSupported.texFloat16)
      *glInternalFormat = GL_LUMINANCE;
    *glFormat = GL_LUMINANCE;
    *glType = GL_HALF_FLOAT_ARB;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16:
    if (RLGL.ExtSupported.texFloat16)
      *glInternalFormat = GL_RGB;
    *glFormat = GL_RGB;
    *glType = GL_HALF_FLOAT_ARB;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16:
    if (RLGL.ExtSupported.texFloat16)
      *glInternalFormat = GL_RGBA;
    *glFormat = GL_RGBA;
    *glType = GL_HALF_FLOAT_ARB;
    break;
#else // defined(GRAPHICS_API_OPENGL_ES2)
  case RL_PIXELFORMAT_UNCOMPRESSED_R16:
    if (RLGL.ExtSupported.texFloat16)
      *glInternalFormat = GL_LUMINANCE;
    *glFormat = GL_LUMINANCE;
    *glType = GL_HALF_FLOAT_OES;
    break; // NOTE: Requires extension OES_texture_half_float
  case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16:
    if (RLGL.ExtSupported.texFloat16)
      *glInternalFormat = GL_RGB;
    *glFormat = GL_RGB;
    *glType = GL_HALF_FLOAT_OES;
    break; // NOTE: Requires extension OES_texture_half_float
  case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16:
    if (RLGL.ExtSupported.texFloat16)
      *glInternalFormat = GL_RGBA;
    *glFormat = GL_RGBA;
    *glType = GL_HALF_FLOAT_OES;
    break; // NOTE: Requires extension OES_texture_half_float
#endif
#endif
#endif
#elif defined(GRAPHICS_API_OPENGL_33)
  case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE:
    *glInternalFormat = GL_R8;
    *glFormat = GL_RED;
    *glType = GL_UNSIGNED_BYTE;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
    *glInternalFormat = GL_RG8;
    *glFormat = GL_RG;
    *glType = GL_UNSIGNED_BYTE;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5:
    *glInternalFormat = GL_RGB565;
    *glFormat = GL_RGB;
    *glType = GL_UNSIGNED_SHORT_5_6_5;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8:
    *glInternalFormat = GL_RGB8;
    *glFormat = GL_RGB;
    *glType = GL_UNSIGNED_BYTE;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
    *glInternalFormat = GL_RGB5_A1;
    *glFormat = GL_RGBA;
    *glType = GL_UNSIGNED_SHORT_5_5_5_1;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4:
    *glInternalFormat = GL_RGBA4;
    *glFormat = GL_RGBA;
    *glType = GL_UNSIGNED_SHORT_4_4_4_4;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8:
    *glInternalFormat = GL_RGBA8;
    *glFormat = GL_RGBA;
    *glType = GL_UNSIGNED_BYTE;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R32:
    if (RLGL.ExtSupported.texFloat32)
      *glInternalFormat = GL_R32F;
    *glFormat = GL_RED;
    *glType = GL_FLOAT;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32:
    if (RLGL.ExtSupported.texFloat32)
      *glInternalFormat = GL_RGB32F;
    *glFormat = GL_RGB;
    *glType = GL_FLOAT;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32:
    if (RLGL.ExtSupported.texFloat32)
      *glInternalFormat = GL_RGBA32F;
    *glFormat = GL_RGBA;
    *glType = GL_FLOAT;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R16:
    if (RLGL.ExtSupported.texFloat16)
      *glInternalFormat = GL_R16F;
    *glFormat = GL_RED;
    *glType = GL_HALF_FLOAT;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16:
    if (RLGL.ExtSupported.texFloat16)
      *glInternalFormat = GL_RGB16F;
    *glFormat = GL_RGB;
    *glType = GL_HALF_FLOAT;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16:
    if (RLGL.ExtSupported.texFloat16)
      *glInternalFormat = GL_RGBA16F;
    *glFormat = GL_RGBA;
    *glType = GL_HALF_FLOAT;
    break;
#endif
#if !defined(GRAPHICS_API_OPENGL_11)
  case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB:
    if (RLGL.ExtSupported.texCompDXT)
      *glInternalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
    break;
  case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA:
    if (RLGL.ExtSupported.texCompDXT)
      *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
    break;
  case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA:
    if (RLGL.ExtSupported.texCompDXT)
      *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
    break;
  case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA:
    if (RLGL.ExtSupported.texCompDXT)
      *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
    break;
  case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB:
    if (RLGL.ExtSupported.texCompETC1)
      *glInternalFormat = GL_ETC1_RGB8_OES;
    break; // NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3
  case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB:
    if (RLGL.ExtSupported.texCompETC2)
      *glInternalFormat = GL_COMPRESSED_RGB8_ETC2;
    break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
  case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA:
    if (RLGL.ExtSupported.texCompETC2)
      *glInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC;
    break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
  case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB:
    if (RLGL.ExtSupported.texCompPVRT)
      *glInternalFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
    break; // NOTE: Requires PowerVR GPU
  case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA:
    if (RLGL.ExtSupported.texCompPVRT)
      *glInternalFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
    break; // NOTE: Requires PowerVR GPU
  case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA:
    if (RLGL.ExtSupported.texCompASTC)
      *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR;
    break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
  case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA:
    if (RLGL.ExtSupported.texCompASTC)
      *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR;
    break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
#endif
  default:
    TRACELOG(RL_LOG_WARNING, "TEXTURE: Current format not supported (%i)",
             format);
    break;
  }
}

// Unload texture from GPU memory
void rlUnloadTexture(unsigned int id) {
  glDeleteTextures(1, &id); }

// 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 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;

  if (((width > 0) && ((width & (width - 1)) == 0)) &&
      ((height > 0) && ((height & (height - 1)) == 0)))
    texIsPOT = true;

  if ((texIsPOT) || (RLGL.ExtSupported.texNPOT)) {
    // glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE);   // Hint for mipmaps
    // generation algorithm: GL_FASTEST, GL_NICEST, GL_DONT_CARE
    glGenerateMipmap(GL_TEXTURE_2D); // Generate mipmaps automatically

#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define MAX(a, b) (((a) > (b)) ? (a) : (b))

    *mipmaps = 1 + (int)floor(log(MAX(width, height)) / log(2));
    TRACELOG(RL_LOG_INFO,
             "TEXTURE: [ID %i] Mipmaps generated automatically, total: %i", id,
             *mipmaps);
  } else
    TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to generate mipmaps", id);

  glBindTexture(GL_TEXTURE_2D, 0);
#else
  TRACELOG(RL_LOG_WARNING,
           "TEXTURE: [ID %i] GPU mipmap generation not supported", id);
#endif
}

// Read texture pixel data
void *rlReadTexturePixels(unsigned int id, int width, int height, int format) {
  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) 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);

  // NOTE: Each row written to or read from by OpenGL pixel operations like
  // glGetTexImage are aligned to a 4 byte boundary by default, which may add
  // some padding. Use glPixelStorei to modify padding with the
  // GL_[UN]PACK_ALIGNMENT setting. GL_PACK_ALIGNMENT affects operations that
  // read from OpenGL memory (glReadPixels, glGetTexImage, etc.)
  // GL_UNPACK_ALIGNMENT affects operations that write to OpenGL memory
  // (glTexImage, etc.)
  glPixelStorei(GL_PACK_ALIGNMENT, 1);

  unsigned int glInternalFormat, glFormat, glType;
  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);
    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);
#endif

#if defined(GRAPHICS_API_OPENGL_ES2)
  // 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 NOTE: This behaviour could be conditioned by
  // graphic driver...
  unsigned int fboId = rlLoadFramebuffer(width, height);

  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
  pixels = (unsigned char *)RL_MALLOC(
      rlGetPixelDataSize(width, height, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8));
  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);

  glBindFramebuffer(GL_FRAMEBUFFER, 0);

  // Clean up temporal fbo
  rlUnloadFramebuffer(fboId);
#endif

  return pixels;
}

// 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));

  // NOTE 1: 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!
  glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, screenData);

  // Flip image vertically!
  unsigned char *imgData =
      (unsigned char *)RL_MALLOC(width * height * 4 * sizeof(unsigned char));

  for (int y = height - 1; y >= 0; y--) {
    for (int x = 0; x < (width * 4); x++) {
      imgData[((height - 1) - y) * width * 4 + x] =
          screenData[(y * width * 4) + x]; // Flip line

      // 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!
      if (((x + 1) % 4) == 0)
        imgData[((height - 1) - y) * width * 4 + x] = 255;
    }
  }

  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(int width, int height) {
  unsigned int fboId = 0;

#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) &&   \
    defined(RLGL_RENDER_TEXTURES_HINT)
  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)
// 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) {
#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) &&   \
    defined(RLGL_RENDER_TEXTURES_HINT)
  glBindFramebuffer(GL_FRAMEBUFFER, fboId);

  switch (attachType) {
  case RL_ATTACHMENT_COLOR_CHANNEL0:
  case RL_ATTACHMENT_COLOR_CHANNEL1:
  case RL_ATTACHMENT_COLOR_CHANNEL2:
  case RL_ATTACHMENT_COLOR_CHANNEL3:
  case RL_ATTACHMENT_COLOR_CHANNEL4:
  case RL_ATTACHMENT_COLOR_CHANNEL5:
  case RL_ATTACHMENT_COLOR_CHANNEL6:
  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);
#endif
}

// 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)
  glBindFramebuffer(GL_FRAMEBUFFER, id);

  GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);

  if (status != GL_FRAMEBUFFER_COMPLETE) {
    switch (status) {
    case GL_FRAMEBUFFER_UNSUPPORTED:
      TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer is unsupported", id);
      break;
    case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
      TRACELOG(RL_LOG_WARNING,
               "FBO: [ID %i] Framebuffer has incomplete attachment", id);
      break;
#if defined(GRAPHICS_API_OPENGL_ES2)
    case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
      TRACELOG(RL_LOG_WARNING,
               "FBO: [ID %i] Framebuffer has incomplete dimensions", id);
      break;
#endif
    case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
      TRACELOG(RL_LOG_WARNING,
               "FBO: [ID %i] Framebuffer has a missing attachment", id);
      break;
    default:
      break;
    }
  }

  glBindFramebuffer(GL_FRAMEBUFFER, 0);

  result = (status == GL_FRAMEBUFFER_COMPLETE);
#endif

  return result;
}

// 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)
  // Query depth attachment to automatically delete texture/renderbuffer
  int depthType = 0, depthId = 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/
  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);

  // NOTE: If a texture object is deleted while its image is attached to the
  // *currently bound* framebuffer, the texture image is automatically detached
  // from the currently bound framebuffer.

  glBindFramebuffer(GL_FRAMEBUFFER, 0);
  glDeleteFramebuffers(1, &id);

  TRACELOG(RL_LOG_INFO, "FBO: [ID %i] Unloaded framebuffer from VRAM (GPU)",
           id);
#endif
}

// Vertex data management
//-----------------------------------------------------------------------------------------
// Load a new attributes buffer
unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic) {
  unsigned int id = 0;

#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);
#endif

  return id;
}

// Load a new attributes element buffer
unsigned int rlLoadVertexBufferElement(const void *buffer, int size,
                                       bool dynamic) {
  unsigned int id = 0;

#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);
#endif

  return id;
}

// Enable vertex buffer (VBO)
void rlEnableVertexBuffer(unsigned int id) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glBindBuffer(GL_ARRAY_BUFFER, id);
#endif
}

// Disable vertex buffer (VBO)
void rlDisableVertexBuffer(void) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glBindBuffer(GL_ARRAY_BUFFER, 0);
#endif
}

// Enable vertex buffer element (VBO element)
void rlEnableVertexBufferElement(unsigned int id) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
#endif
}

// Disable vertex buffer element (VBO element)
void rlDisableVertexBufferElement(void) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
#endif
}

// Update vertex buffer with new data
// NOTE: dataSize and offset must be provided in bytes
void rlUpdateVertexBuffer(unsigned int id, const void *data, int dataSize,
                          int offset) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glBindBuffer(GL_ARRAY_BUFFER, id);
  glBufferSubData(GL_ARRAY_BUFFER, offset, dataSize, data);
#endif
}

// Update vertex buffer elements with new data
// NOTE: dataSize and offset must be provided in bytes
void rlUpdateVertexBufferElements(unsigned int id, const void *data,
                                  int dataSize, int offset) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
  glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, dataSize, data);
#endif
}

// Enable vertex array object (VAO)
bool rlEnableVertexArray(unsigned int vaoId) {
  bool result = false;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  if (RLGL.ExtSupported.vao) {
    glBindVertexArray(vaoId);
    result = true;
  }
#endif
  return result;
}

// Disable vertex array object (VAO)
void rlDisableVertexArray(void) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  if (RLGL.ExtSupported.vao)
    glBindVertexArray(0);
#endif
}

// Enable vertex attribute index
void rlEnableVertexAttribute(unsigned int index) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glEnableVertexAttribArray(index);
#endif
}

// Disable vertex attribute index
void rlDisableVertexAttribute(unsigned int index) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glDisableVertexAttribArray(index);
#endif
}

// Draw vertex array
void rlDrawVertexArray(int offset, int count) {
  glDrawArrays(GL_TRIANGLES, offset, count);
}

// Draw vertex array elements
void rlDrawVertexArrayElements(int offset, int count, const void *buffer) {
  // NOTE: Added pointer math separately from function to avoid UBSAN
  // complaining
  unsigned short *bufferPtr = (unsigned short *)buffer;
  if (offset > 0)
    bufferPtr += offset;

  glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT,
                 (const unsigned short *)bufferPtr);
}

// 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);
#endif
}

// Draw vertex array elements instanced
void rlDrawVertexArrayElementsInstanced(int offset, int count,
                                        const void *buffer, int instances) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  // NOTE: Added pointer math separately from function to avoid UBSAN
  // complaining
  unsigned short *bufferPtr = (unsigned short *)buffer;
  if (offset > 0)
    bufferPtr += offset;

  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 (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;
  }
}

// Disable vertex state pointer
void rlDisableStatePointer(int vertexAttribType) {
  glDisableClientState(vertexAttribType);
}
#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 (RLGL.ExtSupported.vao) {
    glGenVertexArrays(1, &vaoId);
  }
#endif
  return vaoId;
}

// Set vertex attribute
void rlSetVertexAttribute(unsigned int index, int compSize, int type,
                          bool normalized, int stride, const void *pointer) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glVertexAttribPointer(index, compSize, type, normalized, stride, pointer);
#endif
}

// Set vertex attribute divisor
void rlSetVertexAttributeDivisor(unsigned int index, int divisor) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glVertexAttribDivisor(index, divisor);
#endif
}

// Unload vertex array object (VAO)
void rlUnloadVertexArray(unsigned int vaoId) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  if (RLGL.ExtSupported.vao) {
    glBindVertexArray(0);
    glDeleteVertexArrays(1, &vaoId);
    TRACELOG(RL_LOG_INFO,
             "VAO: [ID %i] Unloaded vertex array data from VRAM (GPU)", vaoId);
  }
#endif
}

// Unload vertex buffer (VBO)
void rlUnloadVertexBuffer(unsigned int vboId) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glDeleteBuffers(1, &vboId);
  // TRACELOG(RL_LOG_INFO, "VBO: Unloaded vertex data from VRAM (GPU)");
#endif
}

// Shaders management
//-----------------------------------------------------------------------------------------------
// Load shader 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 id = 0;

#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  unsigned int vertexShaderId = 0;
  unsigned int fragmentShaderId = 0;

  // Compile vertex shader (if provided)
  if (vsCode != NULL)
    vertexShaderId = rlCompileShader(vsCode, GL_VERTEX_SHADER);
  // In case no vertex shader was provided or compilation failed, we use default
  // vertex shader
  if (vertexShaderId == 0)
    vertexShaderId = RLGL.State.defaultVShaderId;

  // Compile fragment shader (if provided)
  if (fsCode != NULL)
    fragmentShaderId = rlCompileShader(fsCode, GL_FRAGMENT_SHADER);
  // In case no fragment shader was provided or compilation failed, we use
  // default fragment shader
  if (fragmentShaderId == 0)
    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
  if ((vertexShaderId == RLGL.State.defaultVShaderId) &&
      (fragmentShaderId == RLGL.State.defaultFShaderId))
    id = RLGL.State.defaultShaderId;
  else {
    // One of or both shader are new, we need to compile a new shader program
    id = rlLoadShaderProgram(vertexShaderId, fragmentShaderId);

    // We can detach and delete vertex/fragment shaders (if not default ones)
    // NOTE: We 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);
    }
    if (fragmentShaderId != RLGL.State.defaultFShaderId) {
      // 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
    if (id == 0) {
      // In case shader loading fails, we return the default shader
      TRACELOG(
          RL_LOG_WARNING,
          "SHADER: Failed to load custom shader code, using default shader");
      id = RLGL.State.defaultShaderId;
    }
    /*
    else
    {
        // Get available shader uniforms
        // NOTE: This information is useful for debug...
        int uniformCount = -1;
        glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &uniformCount);

        for (int i = 0; i < uniformCount; i++)
        {
            int namelen = -1;
            int num = -1;
            char name[256] = { 0 };     // Assume no variable names longer than
    256 GLenum type = GL_ZERO;

            // 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));
        }
    }
    */
  }
#endif

  return id;
}

// Compile custom shader and return shader id
unsigned int rlCompileShader(const char *shaderCode, int type) {
  unsigned int shader = 0;

#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  shader = glCreateShader(type);
  glShaderSource(shader, 1, &shaderCode, NULL);

  GLint success = 0;
  glCompileShader(shader);
  glGetShaderiv(shader, 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", 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;
#endif
    default:
      break;
    }

    int maxLength = 0;
    glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);

    if (maxLength > 0) {
      int length = 0;
      char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
      glGetShaderInfoLog(shader, maxLength, &length, log);
      TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shader,
               log);
      RL_FREE(log);
    }
  } else {
    switch (type) {
    case GL_VERTEX_SHADER:
      TRACELOG(RL_LOG_INFO,
               "SHADER: [ID %i] Vertex shader compiled successfully", shader);
      break;
    case GL_FRAGMENT_SHADER:
      TRACELOG(RL_LOG_INFO,
               "SHADER: [ID %i] Fragment shader compiled successfully", shader);
      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", shader);
      break;
#endif
    default:
      break;
    }
  }
#endif

  return shader;
}

// 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();

  glAttachShader(program, vShaderId);
  glAttachShader(program, fShaderId);

  // NOTE: Default attribute shader locations must be Bound before linking
  glBindAttribLocation(program, 0, RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION);
  glBindAttribLocation(program, 1, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD);
  glBindAttribLocation(program, 2, RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL);
  glBindAttribLocation(program, 3, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR);
  glBindAttribLocation(program, 4, RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT);
  glBindAttribLocation(program, 5, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2);

  // 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);

  if (success == GL_FALSE) {
    TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link 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] Program shader loaded successfully",
             program);
  }
#endif
  return program;
}

// Unload shader program
void rlUnloadShaderProgram(unsigned int id) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  glDeleteProgram(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) {
  int location = -1;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  location = glGetUniformLocation(shaderId, 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) {
  int location = -1;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  location = glGetAttribLocation(shaderId, 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;
}

// Set shader value uniform
void rlSetUniform(int locIndex, const void *value, int uniformType, int count) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  switch (uniformType) {
  case RL_SHADER_UNIFORM_FLOAT:
    glUniform1fv(locIndex, count, (float *)value);
    break;
  case RL_SHADER_UNIFORM_VEC2:
    glUniform2fv(locIndex, count, (float *)value);
    break;
  case RL_SHADER_UNIFORM_VEC3:
    glUniform3fv(locIndex, count, (float *)value);
    break;
  case RL_SHADER_UNIFORM_VEC4:
    glUniform4fv(locIndex, count, (float *)value);
    break;
  case RL_SHADER_UNIFORM_INT:
    glUniform1iv(locIndex, count, (int *)value);
    break;
  case RL_SHADER_UNIFORM_IVEC2:
    glUniform2iv(locIndex, count, (int *)value);
    break;
  case RL_SHADER_UNIFORM_IVEC3:
    glUniform3iv(locIndex, count, (int *)value);
    break;
  case RL_SHADER_UNIFORM_IVEC4:
    glUniform4iv(locIndex, count, (int *)value);
    break;
  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");
  }
#endif
}

// Set shader value attribute
void rlSetVertexAttributeDefault(int locIndex, const void *value,
                                 int attribType, int count) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  switch (attribType) {
  case RL_SHADER_ATTRIB_FLOAT:
    if (count == 1)
      glVertexAttrib1fv(locIndex, (float *)value);
    break;
  case RL_SHADER_ATTRIB_VEC2:
    if (count == 2)
      glVertexAttrib2fv(locIndex, (float *)value);
    break;
  case RL_SHADER_ATTRIB_VEC3:
    if (count == 3)
      glVertexAttrib3fv(locIndex, (float *)value);
    break;
  case RL_SHADER_ATTRIB_VEC4:
    if (count == 4)
      glVertexAttrib4fv(locIndex, (float *)value);
    break;
  default:
    TRACELOG(
        RL_LOG_WARNING,
        "SHADER: Failed to set attrib default value, data type not recognized");
  }
#endif
}

// 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] = {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 sampler
void rlSetUniformSampler(int locIndex, unsigned int textureId) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  // Check if texture is already active
  for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++)
    if (RLGL.State.activeTextureId[i] == textureId)
      return;

  // Register a new active texture for the internal batch system
  // NOTE: Default texture is always activated as GL_TEXTURE0
  for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) {
    if (RLGL.State.activeTextureId[i] == 0) {
      glUniform1i(locIndex, 1 + i); // Activate new texture unit
      RLGL.State.activeTextureId[i] =
          textureId; // Save texture id for binding on drawing
      break;
    }
  }
#endif
}

// Set shader currently active (id and locations)
void rlSetShader(unsigned int id, int *locs) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  if (RLGL.State.currentShaderId != id) {
    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);
  }
#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)
  glDispatchCompute(groupX, groupY, groupZ);
#endif
}

// Load shader storage buffer object (SSBO)
unsigned int rlLoadShaderBuffer(unsigned int size, const void *data,
                                int usageHint) {
  unsigned int ssbo = 0;

#if defined(GRAPHICS_API_OPENGL_43)
  glGenBuffers(1, &ssbo);
  glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo);
  glBufferData(GL_SHADER_STORAGE_BUFFER, size, data,
               usageHint ? usageHint : RL_STREAM_COPY);
  if (data == NULL)
    glClearBufferData(GL_SHADER_STORAGE_BUFFER, GL_R8UI, GL_RED_INTEGER,
                      GL_UNSIGNED_BYTE, NULL); // Clear buffer data to 0
  glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
#endif

  return ssbo;
}

// Unload shader storage buffer object (SSBO)
void rlUnloadShaderBuffer(unsigned int ssboId) {
#if defined(GRAPHICS_API_OPENGL_43)
  glDeleteBuffers(1, &ssboId);
#endif
}

// Update SSBO buffer data
void rlUpdateShaderBuffer(unsigned int id, const void *data,
                          unsigned int dataSize, unsigned int offset) {
#if defined(GRAPHICS_API_OPENGL_43)
  glBindBuffer(GL_SHADER_STORAGE_BUFFER, id);
  glBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, dataSize, data);
#endif
}

// Get SSBO buffer size
unsigned int rlGetShaderBufferSize(unsigned int id) {
  long long size = 0;

#if defined(GRAPHICS_API_OPENGL_43)
  glBindBuffer(GL_SHADER_STORAGE_BUFFER, id);
  glGetInteger64v(GL_SHADER_STORAGE_BUFFER_SIZE, &size);
#endif

  return (size > 0) ? (unsigned int)size : 0;
}

// Read SSBO buffer data (GPU->CPU)
void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count,
                        unsigned int offset) {
#if defined(GRAPHICS_API_OPENGL_43)
  glBindBuffer(GL_SHADER_STORAGE_BUFFER, id);
  glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, count, dest);
#endif
}

// Bind SSBO buffer
void rlBindShaderBuffer(unsigned int id, unsigned int index) {
#if defined(GRAPHICS_API_OPENGL_43)
  glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, id);
#endif
}

// Copy SSBO buffer data
void rlCopyShaderBuffer(unsigned int destId, unsigned int srcId,
                        unsigned int destOffset, unsigned int srcOffset,
                        unsigned int count) {
#if defined(GRAPHICS_API_OPENGL_43)
  glBindBuffer(GL_COPY_READ_BUFFER, srcId);
  glBindBuffer(GL_COPY_WRITE_BUFFER, destId);
  glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, srcOffset,
                      destOffset, count);
#endif
}

// Bind image texture
void rlBindImageTexture(unsigned int id, unsigned int index, int format,
                        bool readonly) {
#if defined(GRAPHICS_API_OPENGL_43)
  unsigned int glInternalFormat = 0, glFormat = 0, glType = 0;

  rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
  glBindImageTexture(index, id, 0, 0, 0,
                     readonly ? GL_READ_ONLY : GL_READ_WRITE, glInternalFormat);
#endif
}

// Matrix state management
//-----------------------------------------------------------------------------------------
// Get internal modelview matrix
Matrix rlGetMatrixModelview(void) {
  Matrix matrix = rlMatrixIdentity();
#if defined(GRAPHICS_API_OPENGL_11)
  float mat[16];
  glGetFloatv(GL_MODELVIEW_MATRIX, mat);
  matrix.m0 = mat[0];
  matrix.m1 = mat[1];
  matrix.m2 = mat[2];
  matrix.m3 = mat[3];
  matrix.m4 = mat[4];
  matrix.m5 = mat[5];
  matrix.m6 = mat[6];
  matrix.m7 = mat[7];
  matrix.m8 = mat[8];
  matrix.m9 = mat[9];
  matrix.m10 = mat[10];
  matrix.m11 = mat[11];
  matrix.m12 = mat[12];
  matrix.m13 = mat[13];
  matrix.m14 = mat[14];
  matrix.m15 = mat[15];
#else
  matrix = RLGL.State.modelview;
#endif
  return matrix;
}

// Get internal projection matrix
Matrix rlGetMatrixProjection(void) {
#if defined(GRAPHICS_API_OPENGL_11)
  float mat[16];
  glGetFloatv(GL_PROJECTION_MATRIX, mat);
  Matrix m;
  m.m0 = mat[0];
  m.m1 = mat[1];
  m.m2 = mat[2];
  m.m3 = mat[3];
  m.m4 = mat[4];
  m.m5 = mat[5];
  m.m6 = mat[6];
  m.m7 = mat[7];
  m.m8 = mat[8];
  m.m9 = mat[9];
  m.m10 = mat[10];
  m.m11 = mat[11];
  m.m12 = mat[12];
  m.m13 = mat[13];
  m.m14 = mat[14];
  m.m15 = mat[15];
  return m;
#else
  return RLGL.State.projection;
#endif
}

// Get internal accumulated transform matrix
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;
}

// Get internal projection matrix for stereo render (selected eye)
RLAPI Matrix rlGetMatrixProjectionStereo(int eye) {
  Matrix mat = rlMatrixIdentity();
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  mat = RLGL.State.projectionStereo[eye];
#endif
  return mat;
}

// Get internal view offset matrix for stereo render (selected eye)
RLAPI Matrix rlGetMatrixViewOffsetStereo(int eye) {
  Matrix mat = rlMatrixIdentity();
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  mat = RLGL.State.viewOffsetStereo[eye];
#endif
  return mat;
}

// Set a custom modelview matrix (replaces internal modelview matrix)
void rlSetMatrixModelview(Matrix view) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  RLGL.State.modelview = view;
#endif
}

// Set a custom projection matrix (replaces internal projection matrix)
void rlSetMatrixProjection(Matrix projection) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  RLGL.State.projection = projection;
#endif
}

// Set eyes projection matrices for stereo rendering
void rlSetMatrixProjectionStereo(Matrix right, Matrix left) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  RLGL.State.projectionStereo[0] = right;
  RLGL.State.projectionStereo[1] = left;
#endif
}

// Set eyes view offsets matrices for stereo rendering
void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  RLGL.State.viewOffsetStereo[0] = right;
  RLGL.State.viewOffsetStereo[1] = left;
#endif
}

// Load and draw a quad in NDC
void rlLoadDrawQuad(void) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  unsigned int quadVAO = 0;
  unsigned int quadVBO = 0;

  float vertices[] = {
      // Positions         Texcoords
      -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
      1.0f,  1.0f, 0.0f, 1.0f, 1.0f, 1.0f,  -1.0f, 0.0f, 1.0f, 0.0f,
  };

  // Gen VAO to contain VBO
  glGenVertexArrays(1, &quadVAO);
  glBindVertexArray(quadVAO);

  // Gen and fill vertex buffer (VBO)
  glGenBuffers(1, &quadVBO);
  glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW);

  // Bind vertex attributes (position, texcoords)
  glEnableVertexAttribArray(0);
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float),
                        (void *)0); // Positions
  glEnableVertexAttribArray(1);
  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float),
                        (void *)(3 * sizeof(float))); // Texcoords

  // Draw quad
  glBindVertexArray(quadVAO);
  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
  glBindVertexArray(0);

  // Delete buffers (VBO and VAO)
  glDeleteBuffers(1, &quadVBO);
  glDeleteVertexArrays(1, &quadVAO);
#endif
}

// Load and draw a cube in NDC
void rlLoadDrawCube(void) {
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
  unsigned int cubeVAO = 0;
  unsigned int cubeVBO = 0;

  float vertices[] = {
      // Positions          Normals               Texcoords
      -1.0f, -1.0f, -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,  1.0f,  1.0f,
      -1.0f, 0.0f,  0.0f,  -1.0f, 1.0f,  1.0f,  1.0f,  -1.0f, -1.0f, 0.0f,
      0.0f,  -1.0f, 1.0f,  0.0f,  1.0f,  1.0f,  -1.0f, 0.0f,  0.0f,  -1.0f,
      1.0f,  1.0f,  -1.0f, -1.0f, -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f,  0.0f,
      -1.0f, 1.0f,  -1.0f, 0.0f,  0.0f,  -1.0f, 0.0f,  1.0f,  -1.0f, -1.0f,
      1.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,  1.0f,  -1.0f, 1.0f,  0.0f,
      0.0f,  1.0f,  1.0f,  0.0f,  1.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f,
      1.0f,  1.0f,  1.0f,  1.0f,  1.0f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,
      -1.0f, 1.0f,  1.0f,  0.0f,  0.0f,  1.0f,  0.0f,  1.0f,  -1.0f, -1.0f,
      1.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f,  -1.0f, 1.0f,  1.0f,  -1.0f,
      0.0f,  0.0f,  1.0f,  0.0f,  -1.0f, 1.0f,  -1.0f, -1.0f, 0.0f,  0.0f,
      1.0f,  1.0f,  -1.0f, -1.0f, -1.0f, -1.0f, 0.0f,  0.0f,  0.0f,  1.0f,
      -1.0f, -1.0f, -1.0f, -1.0f, 0.0f,  0.0f,  0.0f,  1.0f,  -1.0f, -1.0f,
      1.0f,  -1.0f, 0.0f,  0.0f,  0.0f,  0.0f,  -1.0f, 1.0f,  1.0f,  -1.0f,
      0.0f,  0.0f,  1.0f,  0.0f,  1.0f,  1.0f,  1.0f,  1.0f,  0.0f,  0.0f,
      1.0f,  0.0f,  1.0f,  -1.0f, -1.0f, 1.0f,  0.0f,  0.0f,  0.0f,  1.0f,
      1.0f,  1.0f,  -1.0f, 1.0f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,  -1.0f,
      -1.0f, 1.0f,  0.0f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,  1.0f,  1.0f,
      0.0f,  0.0f,  1.0f,  0.0f,  1.0f,  -1.0f, 1.0f,  1.0f,  0.0f,  0.0f,
      0.0f,  0.0f,  -1.0f, -1.0f, -1.0f, 0.0f,  -1.0f, 0.0f,  0.0f,  1.0f,
      1.0f,  -1.0f, -1.0f, 0.0f,  -1.0f, 0.0f,  1.0f,  1.0f,  1.0f,  -1.0f,
      1.0f,  0.0f,  -1.0f, 0.0f,  1.0f,  0.0f,  1.0f,  -1.0f, 1.0f,  0.0f,
      -1.0f, 0.0f,  1.0f,  0.0f,  -1.0f, -1.0f, 1.0f,  0.0f,  -1.0f, 0.0f,
      0.0f,  0.0f,  -1.0f, -1.0f, -1.0f, 0.0f,  -1.0f, 0.0f,  0.0f,  1.0f,
      -1.0f, 1.0f,  -1.0f, 0.0f,  1.0f,  0.0f,  0.0f,  1.0f,  1.0f,  1.0f,
      1.0f,  0.0f,  1.0f,  0.0f,  1.0f,  0.0f,  1.0f,  1.0f,  -1.0f, 0.0f,
      1.0f,  0.0f,  1.0f,  1.0f,  1.0f,  1.0f,  1.0f,  0.0f,  1.0f,  0.0f,
      1.0f,  0.0f,  -1.0f, 1.0f,  -1.0f, 0.0f,  1.0f,  0.0f,  0.0f,  1.0f,
      -1.0f, 1.0f,  1.0f,  0.0f,  1.0f,  0.0f,  0.0f,  0.0f};

  // Gen VAO to contain VBO
  glGenVertexArrays(1, &cubeVAO);
  glBindVertexArray(cubeVAO);

  // Gen and fill vertex buffer (VBO)
  glGenBuffers(1, &cubeVBO);
  glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
  glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

  // Bind vertex attributes (position, normals, texcoords)
  glBindVertexArray(cubeVAO);
  glEnableVertexAttribArray(0);
  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float),
                        (void *)0); // Positions
  glEnableVertexAttribArray(1);
  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float),
                        (void *)(3 * sizeof(float))); // Normals
  glEnableVertexAttribArray(2);
  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float),
                        (void *)(6 * sizeof(float))); // Texcoords
  glBindBuffer(GL_ARRAY_BUFFER, 0);
  glBindVertexArray(0);

  // Draw cube
  glBindVertexArray(cubeVAO);
  glDrawArrays(GL_TRIANGLES, 0, 36);
  glBindVertexArray(0);

  // Delete VBO and VAO
  glDeleteBuffers(1, &cubeVBO);
  glDeleteVertexArrays(1, &cubeVAO);
#endif
}

// Get name string for pixel format
const char *rlGetPixelFormatName(unsigned int format) {
  switch (format) {
  case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE:
    return "GRAYSCALE";
    break; // 8 bit per pixel (no alpha)
  case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
    return "GRAY_ALPHA";
    break; // 8*2 bpp (2 channels)
  case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5:
    return "R5G6B5";
    break; // 16 bpp
  case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8:
    return "R8G8B8";
    break; // 24 bpp
  case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
    return "R5G5B5A1";
    break; // 16 bpp (1 bit alpha)
  case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4:
    return "R4G4B4A4";
    break; // 16 bpp (4 bit alpha)
  case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8:
    return "R8G8B8A8";
    break; // 32 bpp
  case RL_PIXELFORMAT_UNCOMPRESSED_R32:
    return "R32";
    break; // 32 bpp (1 channel - float)
  case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32:
    return "R32G32B32";
    break; // 32*3 bpp (3 channels - float)
  case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32:
    return "R32G32B32A32";
    break; // 32*4 bpp (4 channels - float)
  case RL_PIXELFORMAT_UNCOMPRESSED_R16:
    return "R16";
    break; // 16 bpp (1 channel - half float)
  case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16:
    return "R16G16B16";
    break; // 16*3 bpp (3 channels - half float)
  case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16:
    return "R16G16B16A16";
    break; // 16*4 bpp (4 channels - half float)
  case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB:
    return "DXT1_RGB";
    break; // 4 bpp (no alpha)
  case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA:
    return "DXT1_RGBA";
    break; // 4 bpp (1 bit alpha)
  case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA:
    return "DXT3_RGBA";
    break; // 8 bpp
  case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA:
    return "DXT5_RGBA";
    break; // 8 bpp
  case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB:
    return "ETC1_RGB";
    break; // 4 bpp
  case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB:
    return "ETC2_RGB";
    break; // 4 bpp
  case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA:
    return "ETC2_RGBA";
    break; // 8 bpp
  case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB:
    return "PVRT_RGB";
    break; // 4 bpp
  case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA:
    return "PVRT_RGBA";
    break; // 4 bpp
  case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA:
    return "ASTC_4x4_RGBA";
    break; // 8 bpp
  case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA:
    return "ASTC_8x8_RGBA";
    break; // 2 bpp
  default:
    return "UNKNOWN";
    break;
  }
}

//----------------------------------------------------------------------------------
// Module specific 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
static void rlLoadShaderDefault(void) {
  RLGL.State.defaultShaderLocs =
      (int *)RL_CALLOC(RL_MAX_SHADER_LOCATIONS, sizeof(int));

  // NOTE: All locations must be reseted to -1 (no location)
  for (int i = 0; i < RL_MAX_SHADER_LOCATIONS; i++)
    RLGL.State.defaultShaderLocs[i] = -1;

  // Vertex shader directly defined, no external file required
  const char *defaultVShaderCode =
#if defined(GRAPHICS_API_OPENGL_21)
      "#version 120                       \n"
      "attribute vec3 vertexPosition;     \n"
      "attribute vec2 vertexTexCoord;     \n"
      "attribute vec4 vertexColor;        \n"
      "varying vec2 fragTexCoord;         \n"
      "varying vec4 fragColor;            \n"
#elif defined(GRAPHICS_API_OPENGL_33)
      "#version 330                       \n"
      "in vec3 vertexPosition;            \n"
      "in vec2 vertexTexCoord;            \n"
      "in vec4 vertexColor;               \n"
      "out vec2 fragTexCoord;             \n"
      "out vec4 fragColor;                \n"
#endif
#if defined(GRAPHICS_API_OPENGL_ES2)
      "#version 100                       \n"
      "precision mediump float;           \n" // Precision required for OpenGL
                                              // ES2 (WebGL) (on some browsers)
      "attribute vec3 vertexPosition;     \n"
      "attribute vec2 vertexTexCoord;     \n"
      "attribute vec4 vertexColor;        \n"
      "varying vec2 fragTexCoord;         \n"
      "varying vec4 fragColor;            \n"
#endif
      "uniform mat4 mvp;                  \n"
      "void main()                        \n"
      "{                                  \n"
      "    fragTexCoord = vertexTexCoord; \n"
      "    fragColor = vertexColor;       \n"
      "    gl_Position = mvp*vec4(vertexPosition, 1.0); \n"
      "}                                  \n";

  // Fragment shader directly defined, no external file required
  const char *defaultFShaderCode =
#if defined(GRAPHICS_API_OPENGL_21)
      "#version 120                       \n"
      "varying vec2 fragTexCoord;         \n"
      "varying vec4 fragColor;            \n"
      "uniform sampler2D texture0;        \n"
      "uniform vec4 colDiffuse;           \n"
      "void main()                        \n"
      "{                                  \n"
      "    vec4 texelColor = texture2D(texture0, fragTexCoord); \n"
      "    gl_FragColor = texelColor*colDiffuse*fragColor;      \n"
      "}                                  \n";
#elif defined(GRAPHICS_API_OPENGL_33)
      "#version 330       \n"
      "in vec2 fragTexCoord;              \n"
      "in vec4 fragColor;                 \n"
      "out vec4 finalColor;               \n"
      "uniform sampler2D texture0;        \n"
      "uniform vec4 colDiffuse;           \n"
      "void main()                        \n"
      "{                                  \n"
      "    vec4 texelColor = texture(texture0, fragTexCoord);   \n"
      "    finalColor = texelColor*colDiffuse*fragColor;        \n"
      "}                                  \n";
#endif
#if defined(GRAPHICS_API_OPENGL_ES2)
  "#version 100                       \n"
  "precision mediump float;           \n" // Precision required for OpenGL ES2
                                          // (WebGL)
  "varying vec2 fragTexCoord;         \n"
  "varying vec4 fragColor;            \n"
  "uniform sampler2D texture0;        \n"
  "uniform vec4 colDiffuse;           \n"
  "void main()                        \n"
  "{                                  \n"
  "    vec4 texelColor = texture2D(texture0, fragTexCoord); \n"
  "    gl_FragColor = texelColor*colDiffuse*fragColor;      \n"
  "}                                  \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.defaultFShaderId =
      rlCompileShader(defaultFShaderCode,
                      GL_FRAGMENT_SHADER); // Compile default fragment shader

  RLGL.State.defaultShaderId = rlLoadShaderProgram(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);

    // Set default shader locations: attributes locations
    RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_POSITION] =
        glGetAttribLocation(RLGL.State.defaultShaderId, "vertexPosition");
    RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01] =
        glGetAttribLocation(RLGL.State.defaultShaderId, "vertexTexCoord");
    RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_COLOR] =
        glGetAttribLocation(RLGL.State.defaultShaderId, "vertexColor");

    // Set default shader locations: uniform locations
    RLGL.State.defaultShaderLocs[RL_SHADER_LOC_MATRIX_MVP] =
        glGetUniformLocation(RLGL.State.defaultShaderId, "mvp");
    RLGL.State.defaultShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE] =
        glGetUniformLocation(RLGL.State.defaultShaderId, "colDiffuse");
    RLGL.State.defaultShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE] =
        glGetUniformLocation(RLGL.State.defaultShaderId, "texture0");
  } else
    TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to load default shader",
             RLGL.State.defaultShaderId);
}

// Unload default shader
// NOTE: Unloads: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs
static void rlUnloadShaderDefault(void) {
  glUseProgram(0);

  glDetachShader(RLGL.State.defaultShaderId, RLGL.State.defaultVShaderId);
  glDetachShader(RLGL.State.defaultShaderId, RLGL.State.defaultFShaderId);
  glDeleteShader(RLGL.State.defaultVShaderId);
  glDeleteShader(RLGL.State.defaultFShaderId);

  glDeleteProgram(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)
// Get compressed format official GL identifier name
static const char *rlGetCompressedFormatName(int format) {
  switch (format) {
  // GL_EXT_texture_compression_s3tc
  case 0x83F0:
    return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT";
    break;
  case 0x83F1:
    return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT";
    break;
  case 0x83F2:
    return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT";
    break;
  case 0x83F3:
    return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT";
    break;
  // GL_3DFX_texture_compression_FXT1
  case 0x86B0:
    return "GL_COMPRESSED_RGB_FXT1_3DFX";
    break;
  case 0x86B1:
    return "GL_COMPRESSED_RGBA_FXT1_3DFX";
    break;
  // GL_IMG_texture_compression_pvrtc
  case 0x8C00:
    return "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG";
    break;
  case 0x8C01:
    return "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG";
    break;
  case 0x8C02:
    return "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG";
    break;
  case 0x8C03:
    return "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG";
    break;
  // GL_OES_compressed_ETC1_RGB8_texture
  case 0x8D64:
    return "GL_ETC1_RGB8_OES";
    break;
  // GL_ARB_texture_compression_rgtc
  case 0x8DBB:
    return "GL_COMPRESSED_RED_RGTC1";
    break;
  case 0x8DBC:
    return "GL_COMPRESSED_SIGNED_RED_RGTC1";
    break;
  case 0x8DBD:
    return "GL_COMPRESSED_RG_RGTC2";
    break;
  case 0x8DBE:
    return "GL_COMPRESSED_SIGNED_RG_RGTC2";
    break;
  // GL_ARB_texture_compression_bptc
  case 0x8E8C:
    return "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB";
    break;
  case 0x8E8D:
    return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB";
    break;
  case 0x8E8E:
    return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB";
    break;
  case 0x8E8F:
    return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB";
    break;
  // GL_ARB_ES3_compatibility
  case 0x9274:
    return "GL_COMPRESSED_RGB8_ETC2";
    break;
  case 0x9275:
    return "GL_COMPRESSED_SRGB8_ETC2";
    break;
  case 0x9276:
    return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2";
    break;
  case 0x9277:
    return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2";
    break;
  case 0x9278:
    return "GL_COMPRESSED_RGBA8_ETC2_EAC";
    break;
  case 0x9279:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC";
    break;
  case 0x9270:
    return "GL_COMPRESSED_R11_EAC";
    break;
  case 0x9271:
    return "GL_COMPRESSED_SIGNED_R11_EAC";
    break;
  case 0x9272:
    return "GL_COMPRESSED_RG11_EAC";
    break;
  case 0x9273:
    return "GL_COMPRESSED_SIGNED_RG11_EAC";
    break;
  // GL_KHR_texture_compression_astc_hdr
  case 0x93B0:
    return "GL_COMPRESSED_RGBA_ASTC_4x4_KHR";
    break;
  case 0x93B1:
    return "GL_COMPRESSED_RGBA_ASTC_5x4_KHR";
    break;
  case 0x93B2:
    return "GL_COMPRESSED_RGBA_ASTC_5x5_KHR";
    break;
  case 0x93B3:
    return "GL_COMPRESSED_RGBA_ASTC_6x5_KHR";
    break;
  case 0x93B4:
    return "GL_COMPRESSED_RGBA_ASTC_6x6_KHR";
    break;
  case 0x93B5:
    return "GL_COMPRESSED_RGBA_ASTC_8x5_KHR";
    break;
  case 0x93B6:
    return "GL_COMPRESSED_RGBA_ASTC_8x6_KHR";
    break;
  case 0x93B7:
    return "GL_COMPRESSED_RGBA_ASTC_8x8_KHR";
    break;
  case 0x93B8:
    return "GL_COMPRESSED_RGBA_ASTC_10x5_KHR";
    break;
  case 0x93B9:
    return "GL_COMPRESSED_RGBA_ASTC_10x6_KHR";
    break;
  case 0x93BA:
    return "GL_COMPRESSED_RGBA_ASTC_10x8_KHR";
    break;
  case 0x93BB:
    return "GL_COMPRESSED_RGBA_ASTC_10x10_KHR";
    break;
  case 0x93BC:
    return "GL_COMPRESSED_RGBA_ASTC_12x10_KHR";
    break;
  case 0x93BD:
    return "GL_COMPRESSED_RGBA_ASTC_12x12_KHR";
    break;
  case 0x93D0:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR";
    break;
  case 0x93D1:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR";
    break;
  case 0x93D2:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR";
    break;
  case 0x93D3:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR";
    break;
  case 0x93D4:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR";
    break;
  case 0x93D5:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR";
    break;
  case 0x93D6:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR";
    break;
  case 0x93D7:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR";
    break;
  case 0x93D8:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR";
    break;
  case 0x93D9:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR";
    break;
  case 0x93DA:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR";
    break;
  case 0x93DB:
    return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR";
    break;
  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 // 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) {
  int dataSize = 0; // Size in bytes
  int bpp = 0;      // Bits per pixel

  switch (format) {
  case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE:
    bpp = 8;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
  case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5:
  case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
  case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4:
    bpp = 16;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8:
    bpp = 32;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8:
    bpp = 24;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R32:
    bpp = 32;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32:
    bpp = 32 * 3;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32:
    bpp = 32 * 4;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R16:
    bpp = 16;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16:
    bpp = 16 * 3;
    break;
  case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16:
    bpp = 16 * 4;
    break;
  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_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_8x8_RGBA:
    bpp = 2;
    break;
  default:
    break;
  }

  dataSize = width * height * bpp / 8; // Total data size in bytes

  // Most compressed formats works on 4x4 blocks,
  // if texture is smaller, minimum dataSize is 8 or 16
  if ((width < 4) && (height < 4)) {
    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 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.m0 = left.m0 * right.m0 + left.m1 * right.m4 + left.m2 * right.m8 +
              left.m3 * right.m12;
  result.m1 = left.m0 * right.m1 + left.m1 * right.m5 + left.m2 * right.m9 +
              left.m3 * right.m13;
  result.m2 = left.m0 * right.m2 + left.m1 * right.m6 + left.m2 * right.m10 +
              left.m3 * right.m14;
  result.m3 = left.m0 * right.m3 + left.m1 * right.m7 + left.m2 * right.m11 +
              left.m3 * right.m15;
  result.m4 = left.m4 * right.m0 + left.m5 * right.m4 + left.m6 * right.m8 +
              left.m7 * right.m12;
  result.m5 = left.m4 * right.m1 + left.m5 * right.m5 + left.m6 * right.m9 +
              left.m7 * right.m13;
  result.m6 = left.m4 * right.m2 + left.m5 * right.m6 + left.m6 * right.m10 +
              left.m7 * right.m14;
  result.m7 = left.m4 * right.m3 + left.m5 * right.m7 + left.m6 * right.m11 +
              left.m7 * right.m15;
  result.m8 = left.m8 * right.m0 + left.m9 * right.m4 + left.m10 * right.m8 +
              left.m11 * right.m12;
  result.m9 = left.m8 * right.m1 + left.m9 * right.m5 + left.m10 * right.m9 +
              left.m11 * right.m13;
  result.m10 = left.m8 * right.m2 + left.m9 * right.m6 + left.m10 * right.m10 +
               left.m11 * right.m14;
  result.m11 = left.m8 * right.m3 + left.m9 * right.m7 + left.m10 * right.m11 +
               left.m11 * right.m15;
  result.m12 = left.m12 * right.m0 + left.m13 * right.m4 + left.m14 * right.m8 +
               left.m15 * right.m12;
  result.m13 = left.m12 * right.m1 + left.m13 * right.m5 + left.m14 * right.m9 +
               left.m15 * right.m13;
  result.m14 = left.m12 * right.m2 + left.m13 * right.m6 +
               left.m14 * right.m10 + left.m15 * right.m14;
  result.m15 = left.m12 * right.m3 + left.m13 * right.m7 +
               left.m14 * right.m11 + left.m15 * right.m15;

  return result;
}

#endif // RLGL_IMPLEMENTATION