/********************************************************************************************** * * rlgl v5.0 - A multi-OpenGL abstraction layer with an immediate-mode style API * * DESCRIPTION: * An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0) * 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: RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION * #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD * #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL * #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR * #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT * #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2 * #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEIDS "vertexBoneIds" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEIDS * #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS "vertexBoneWeights" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS * #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix * #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix * #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix * #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix * #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView))) * #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color) * #define RL_DEFAULT_SHADER_UNIFORM_NAME_BONE_MATRICES "boneMatrices" // bone matrices * #define RL_DEFAULT_SHADER_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-2024 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. * **********************************************************************************************/ // Function specifiers in case library is build/used as a shared library // NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll // NOTE: visibility(default) attribute makes symbols "visible" when compiled with -fvisibility=hidden // Function specifiers definition // Support TRACELOG macros // Allow custom memory allocators // Security check in case no GRAPHICS_API_OPENGL_* defined // Security check in case multiple GRAPHICS_API_OPENGL_* defined // OpenGL 2.1 uses most of OpenGL 3.3 Core functionality // WARNING: Specific parts are checked with #if defines // OpenGL 4.3 uses OpenGL 3.3 Core functionality // OpenGL ES 3.0 uses OpenGL ES 2.0 functionality (and more) // Support framebuffer objects by default // NOTE: Some driver implementation do not support it, despite they should //---------------------------------------------------------------------------------- // Defines and Macros //---------------------------------------------------------------------------------- // Default internal render batch elements limits // This is the maximum amount of elements (quads) per batch // NOTE: Be careful with text, every letter maps to a quad // Internal Matrix stack // Shader limits // Projection matrix culling // Texture parameters (equivalent to OpenGL defines) // Matrix modes (equivalent to OpenGL) // Primitive assembly draw modes // GL equivalent data types // GL buffer usage hint // GL Shader type // GL blending factors // GL blending functions/equations // Default shader vertex attribute locations //---------------------------------------------------------------------------------- // Types and Structures Definition //---------------------------------------------------------------------------------- // 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) float *normals; // Vertex normal (XYZ - 3 components per vertex) (shader-location = 2) unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) unsigned int *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad) unsigned int vaoId; // OpenGL Vertex Array Object id unsigned int vboId[5]; // OpenGL Vertex Buffer Objects id (5 types of vertex data) } rlVertexBuffer; // Draw call type // NOTE: Only texture changes register a new draw, other state-change-related elements are not // used at this moment (vaoId, shaderId, matrices), raylib just forces a batch draw call if any // 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; // 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_UINT, // Shader uniform type: unsigned int RL_SHADER_UNIFORM_UIVEC2, // Shader uniform type: uivec2 (2 unsigned int) RL_SHADER_UNIFORM_UIVEC3, // Shader uniform type: uivec3 (3 unsigned int) RL_SHADER_UNIFORM_UIVEC4, // Shader uniform type: uivec4 (4 unsigned 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 //------------------------------------------------------------------------------------ void rlMatrixMode(int mode); // Choose the current matrix to be transformed void rlPushMatrix(void); // Push the current matrix to stack void rlPopMatrix(void); // Pop latest inserted matrix from stack void rlLoadIdentity(void); // Reset current matrix to identity matrix void rlTranslatef(float x, float y, float z); // Multiply the current matrix by a translation matrix void rlRotatef(float angle, float x, float y, float z); // Multiply the current matrix by a rotation matrix void rlScalef(float x, float y, float z); // Multiply the current matrix by a scaling matrix void rlMultMatrixf(const float *matf); // Multiply the current matrix by another matrix void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar); void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar); void rlViewport(int x, int y, int width, int height); // Set the viewport area void rlSetClipPlanes(double nearPlane, double farPlane); // Set clip planes distances double rlGetCullDistanceNear(void); // Get cull plane distance near double rlGetCullDistanceFar(void); // Get cull plane distance far //------------------------------------------------------------------------------------ // Functions Declaration - Vertex level operations //------------------------------------------------------------------------------------ void rlBegin(int mode); // Initialize drawing mode (how to organize vertex) void rlEnd(void); // Finish vertex providing void rlVertex2i(int x, int y); // Define one vertex (position) - 2 int void rlVertex2f(float x, float y); // Define one vertex (position) - 2 float void rlVertex3f(float x, float y, float z); // Define one vertex (position) - 3 float void rlTexCoord2f(float x, float y); // Define one vertex (texture coordinate) - 2 float void rlNormal3f(float x, float y, float z); // Define one vertex (normal) - 3 float void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Define one vertex (color) - 4 byte void rlColor3f(float x, float y, float z); // Define one vertex (color) - 3 float 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 bool rlEnableVertexArray(unsigned int vaoId); // Enable vertex array (VAO, if supported) void rlDisableVertexArray(void); // Disable vertex array (VAO, if supported) void rlEnableVertexBuffer(unsigned int id); // Enable vertex buffer (VBO) void rlDisableVertexBuffer(void); // Disable vertex buffer (VBO) void rlEnableVertexBufferElement(unsigned int id); // Enable vertex buffer element (VBO element) void rlDisableVertexBufferElement(void); // Disable vertex buffer element (VBO element) void rlEnableVertexAttribute(unsigned int index); // Enable vertex attribute index void rlDisableVertexAttribute(unsigned int index); // Disable vertex attribute index // Textures state void rlActiveTextureSlot(int slot); // Select and active a texture slot void rlEnableTexture(unsigned int id); // Enable texture void rlDisableTexture(void); // Disable texture void rlEnableTextureCubemap(unsigned int id); // Enable texture cubemap void rlDisableTextureCubemap(void); // Disable texture cubemap void rlTextureParameters(unsigned int id, int param, int value); // Set texture parameters (filter, wrap) void rlCubemapParameters(unsigned int id, int param, int value); // Set cubemap parameters (filter, wrap) // Shader state void rlEnableShader(unsigned int id); // Enable shader program void rlDisableShader(void); // Disable shader program // Framebuffer state void rlEnableFramebuffer(unsigned int id); // Enable render texture (fbo) void rlDisableFramebuffer(void); // Disable render texture (fbo), return to default framebuffer unsigned int rlGetActiveFramebuffer(void); // Get the currently active render texture (fbo), 0 for default framebuffer void rlActiveDrawBuffers(int count); // Activate multiple draw color buffers 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 void rlBindFramebuffer(unsigned int target, unsigned int framebuffer); // Bind framebuffer (FBO) // General render state void rlEnableColorBlend(void); // Enable color blending void rlDisableColorBlend(void); // Disable color blending void rlEnableDepthTest(void); // Enable depth test void rlDisableDepthTest(void); // Disable depth test void rlEnableDepthMask(void); // Enable depth write void rlDisableDepthMask(void); // Disable depth write void rlEnableBackfaceCulling(void); // Enable backface culling void rlDisableBackfaceCulling(void); // Disable backface culling void rlColorMask(bool r, bool g, bool b, bool a); // Color mask control void rlSetCullFace(int mode); // Set face culling mode void rlEnableScissorTest(void); // Enable scissor test void rlDisableScissorTest(void); // Disable scissor test void rlScissor(int x, int y, int width, int height); // Scissor test void rlEnableWireMode(void); // Enable wire mode void rlEnablePointMode(void); // Enable point mode void rlDisableWireMode(void); // Disable wire (and point) mode void rlSetLineWidth(float width); // Set the line drawing width float rlGetLineWidth(void); // Get the line drawing width void rlEnableSmoothLines(void); // Enable line aliasing void rlDisableSmoothLines(void); // Disable line aliasing void rlEnableStereoRender(void); // Enable stereo rendering void rlDisableStereoRender(void); // Disable stereo rendering bool rlIsStereoRenderEnabled(void); // Check if stereo render is enabled void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Clear color buffer with color void rlClearScreenBuffers(void); // Clear used screen buffers (color and depth) void rlCheckErrors(void); // Check and log OpenGL error codes void rlSetBlendMode(int mode); // Set blending mode void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation); // Set blending mode factor and equation (using OpenGL factors) 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 void rlglInit(int width, int height); // Initialize rlgl (buffers, shaders, textures, states) void rlglClose(void); // De-initialize rlgl (buffers, shaders, textures) void rlLoadExtensions(void *loader); // Load OpenGL extensions (loader function required) int rlGetVersion(void); // Get current OpenGL version void rlSetFramebufferWidth(int width); // Set current framebuffer width int rlGetFramebufferWidth(void); // Get default framebuffer width void rlSetFramebufferHeight(int height); // Set current framebuffer height int rlGetFramebufferHeight(void); // Get default framebuffer height unsigned int rlGetTextureIdDefault(void); // Get default texture id unsigned int rlGetShaderIdDefault(void); // Get default shader id 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 rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements); // Load a render batch system void rlUnloadRenderBatch(rlRenderBatch batch); // Unload render batch system void rlDrawRenderBatch(rlRenderBatch *batch); // Draw render batch data (Update->Draw->Reset) void rlSetRenderBatchActive(rlRenderBatch *batch); // Set the active render batch for rlgl (NULL for default internal) void rlDrawRenderBatchActive(void); // Update and draw internal render batch bool rlCheckRenderBatchLimit(int vCount); // Check internal buffer overflow for a given number of vertex void rlSetTexture(unsigned int id); // Set current texture for render batch and check buffers limits //------------------------------------------------------------------------------------------------------------------------ // Vertex buffers management unsigned int rlLoadVertexArray(void); // Load vertex array (vao) if supported unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic); // Load a vertex buffer object unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic); // Load vertex buffer elements object void rlUpdateVertexBuffer(unsigned int bufferId, const void *data, int dataSize, int offset); // Update vertex buffer object data on GPU buffer void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset); // Update vertex buffer elements data on GPU buffer void rlUnloadVertexArray(unsigned int vaoId); // Unload vertex array (vao) void rlUnloadVertexBuffer(unsigned int vboId); // Unload vertex buffer object void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, int offset); // Set vertex attribute data configuration void rlSetVertexAttributeDivisor(unsigned int index, int divisor); // Set vertex attribute data divisor void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count); // Set vertex attribute default value, when attribute to provided void rlDrawVertexArray(int offset, int count); // Draw vertex array (currently active vao) void rlDrawVertexArrayElements(int offset, int count, const void *buffer); // Draw vertex array elements void rlDrawVertexArrayInstanced(int offset, int count, int instances); // Draw vertex array (currently active vao) with instancing void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances); // Draw vertex array elements with instancing // Textures management unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount); // Load texture data unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer); // Load depth texture/renderbuffer (to be attached to fbo) unsigned int rlLoadTextureCubemap(const void *data, int size, int format, int mipmapCount); // Load texture cubemap data void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data); // Update texture with new data on GPU void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType); // Get OpenGL internal formats const char *rlGetPixelFormatName(unsigned int format); // Get name string for pixel format void rlUnloadTexture(unsigned int id); // Unload texture from GPU memory void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps); // Generate mipmap data for selected texture void *rlReadTexturePixels(unsigned int id, int width, int height, int format); // Read texture pixel data unsigned char *rlReadScreenPixels(int width, int height); // Read screen pixel data (color buffer) // Framebuffer management (fbo) unsigned int rlLoadFramebuffer(void); // Load an empty framebuffer void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel); // Attach texture/renderbuffer to a framebuffer bool rlFramebufferComplete(unsigned int id); // Verify framebuffer is complete void rlUnloadFramebuffer(unsigned int id); // Delete framebuffer from GPU // Shaders management unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode); // Load shader from code strings 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) unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId); // Load custom shader program void rlUnloadShaderProgram(unsigned int id); // Unload shader program int rlGetLocationUniform(unsigned int shaderId, const char *uniformName); // Get shader location uniform int rlGetLocationAttrib(unsigned int shaderId, const char *attribName); // Get shader location attribute void rlSetUniform(int locIndex, const void *value, int uniformType, int count); // Set shader value uniform void rlSetUniformMatrix(int locIndex, Matrix mat); // Set shader value matrix void rlSetUniformMatrices(int locIndex, const Matrix *mat, int count); // Set shader value matrices void rlSetUniformSampler(int locIndex, unsigned int textureId); // Set shader value sampler void rlSetShader(unsigned int id, int *locs); // Set shader currently active (id and locations) // Compute shader management unsigned int rlLoadComputeShaderProgram(unsigned int shaderId); // Load compute shader program 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) unsigned int rlLoadShaderBuffer(unsigned int size, const void *data, int usageHint); // Load shader storage buffer object (SSBO) void rlUnloadShaderBuffer(unsigned int ssboId); // Unload shader storage buffer object (SSBO) void rlUpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset); // Update SSBO buffer data void rlBindShaderBuffer(unsigned int id, unsigned int index); // Bind SSBO buffer void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset); // Read SSBO buffer data (GPU->CPU) void rlCopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count); // Copy SSBO data between buffers unsigned int rlGetShaderBufferSize(unsigned int id); // Get SSBO buffer size // Buffer management void rlBindImageTexture(unsigned int id, unsigned int index, int format, bool readonly); // Bind image texture // Matrix state management Matrix rlGetMatrixModelview(void); // Get internal modelview matrix Matrix rlGetMatrixProjection(void); // Get internal projection matrix Matrix rlGetMatrixTransform(void); // Get internal accumulated transform matrix Matrix rlGetMatrixProjectionStereo(int eye); // Get internal projection matrix for stereo render (selected eye) Matrix rlGetMatrixViewOffsetStereo(int eye); // Get internal view offset matrix for stereo render (selected eye) void rlSetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix) void rlSetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix) void rlSetMatrixProjectionStereo(Matrix right, Matrix left); // Set eyes projection matrices for stereo rendering void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left); // Set eyes view offsets matrices for stereo rendering // Quick and dirty cube/quad buffers load->draw->unload void rlLoadDrawCube(void); // Load and draw a cube void rlLoadDrawQuad(void); // Load and draw a quad /*********************************************************************************** * * RLGL IMPLEMENTATION * ************************************************************************************/