522 lines
No EOL
36 KiB
Text
522 lines
No EOL
36 KiB
Text
/**********************************************************************************************
|
|
*
|
|
* 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, ES 3.0)
|
|
* that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...)
|
|
*
|
|
* ADDITIONAL NOTES:
|
|
* When choosing an OpenGL backend different than OpenGL 1.1, some internal buffer are
|
|
* 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
|
|
*
|
|
************************************************************************************/ |