Mercurial

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

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add interactive infinite canvas prototype
author MrJuneJune <me@mrjunejune.com>
date Mon, 17 Aug 2026 16:57:56 -0700
parents
children
comparison
equal deleted inserted replaced
274:c9be578316a6 276:b55c22cff335
1 /**********************************************************************************************
2 *
3 * rlgl v6.0 - A multi-OpenGL abstraction layer with an immediate-mode style API
4 *
5 * DESCRIPTION:
6 * An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0, ES 3.0)
7 * that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...)
8 *
9 * ADDITIONAL NOTES:
10 * When choosing an OpenGL backend different than OpenGL 1.1, some internal buffers are
11 * initialized on rlglInit() to accumulate vertex data
12 *
13 * When an internal state change is required all the stored vertex data is rendered in a batch,
14 * additionally, rlDrawRenderBatchActive() could be called to force flushing of the batch
15 *
16 * Some resources are also loaded for convenience, here the complete list:
17 * - Default batch (RLGL.defaultBatch): RenderBatch system to accumulate vertex data
18 * - Default texture (RLGL.defaultTextureId): 1x1 white pixel R8G8B8A8
19 * - Default shader (RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs)
20 *
21 * Internal buffer (and resources) must be manually unloaded calling rlglClose()
22 *
23 * CONFIGURATION:
24 * #define GRAPHICS_API_OPENGL_SOFTWARE
25 * #define GRAPHICS_API_OPENGL_11
26 * #define GRAPHICS_API_OPENGL_21
27 * #define GRAPHICS_API_OPENGL_33
28 * #define GRAPHICS_API_OPENGL_43
29 * #define GRAPHICS_API_OPENGL_ES2
30 * #define GRAPHICS_API_OPENGL_ES3
31 * Use selected OpenGL graphics backend, should be supported by platform
32 * Those preprocessor defines are only used on the rlgl module, if OpenGL version is
33 * required by any other module, use rlGetVersion() to check it
34 *
35 * #define RLGL_IMPLEMENTATION
36 * Generates the implementation of the library into the included file
37 * If not defined, the library is in header only mode and can be included in other headers
38 * or source files without problems. But only ONE file should hold the implementation
39 *
40 * #if RLGL_SHOW_GL_DETAILS_INFO
41 * Show OpenGL extensions and capabilities detailed logs on init
42 *
43 * #if RLGL_ENABLE_OPENGL_DEBUG_CONTEXT
44 * Enable debug context (only available on OpenGL 4.3)
45 *
46 * rlgl capabilities could be customized defining some internal
47 * values before library inclusion (default values listed):
48 *
49 * #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192 // Default internal render batch elements limits
50 * #define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering)
51 * #define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture)
52 * #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of texture units that can be activated on batch drawing (SetShaderValueTexture())
53 *
54 * #define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of internal Matrix stack
55 * #define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported
56 * #define RL_CULL_DISTANCE_NEAR 0.05 // Default projection matrix near cull distance
57 * #define RL_CULL_DISTANCE_FAR 4000.0 // Default projection matrix far cull distance
58 *
59 * When loading a shader, the following vertex attributes and uniform
60 * location names are tried to be set automatically:
61 *
62 * #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION
63 * #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD
64 * #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL
65 * #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR
66 * #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT
67 * #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2
68 * #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES "vertexBoneIndices" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES
69 * #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS "vertexBoneWeights" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS
70 * #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix
71 * #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix
72 * #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix
73 * #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix
74 * #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView)))
75 * #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color)
76 * #define RL_DEFAULT_SHADER_UNIFORM_NAME_BONEMATRICES "boneMatrices" // bone matrices
77 * #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0)
78 * #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1)
79 * #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2)
80 *
81 * DEPENDENCIES:
82 * - OpenGL libraries (depending on platform and OpenGL version selected)
83 * - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core, 4.3 Core)
84 *
85 *
86 * LICENSE: zlib/libpng
87 *
88 * Copyright (c) 2014-2026 Ramon Santamaria (@raysan5)
89 *
90 * This software is provided "as-is", without any express or implied warranty. In no event
91 * will the authors be held liable for any damages arising from the use of this software.
92 *
93 * Permission is granted to anyone to use this software for any purpose, including commercial
94 * applications, and to alter it and redistribute it freely, subject to the following restrictions:
95 *
96 * 1. The origin of this software must not be misrepresented; you must not claim that you
97 * wrote the original software. If you use this software in a product, an acknowledgment
98 * in the product documentation would be appreciated but is not required.
99 *
100 * 2. Altered source versions must be plainly marked as such, and must not be misrepresented
101 * as being the original software.
102 *
103 * 3. This notice may not be removed or altered from any source distribution.
104 *
105 **********************************************************************************************/
106
107 #ifndef RLGL_H
108 #define RLGL_H
109
110 #define RLGL_VERSION "6.0"
111
112 // Function specifiers in case library is build/used as a shared library
113 // NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
114 // NOTE: visibility(default) attribute makes symbols "visible" when compiled with -fvisibility=hidden
115 #if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED)
116 #define RLAPI __declspec(dllexport) // Building the library as a Win32 shared library (.dll)
117 #elif defined(BUILD_LIBTYPE_SHARED)
118 #define RLAPI __attribute__((visibility("default"))) // Building the library as a Unix shared library (.so/.dylib)
119 #elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED)
120 #define RLAPI __declspec(dllimport) // Using the library as a Win32 shared library (.dll)
121 #endif
122
123 // Function specifiers definition
124 #ifndef RLAPI
125 #define RLAPI // Functions defined as 'extern' by default (implicit specifiers)
126 #endif
127
128 // Support TRACELOG macros
129 #ifndef TRACELOG
130 #define TRACELOG(level, ...) (void)0
131 #endif
132
133 // Allow custom memory allocators
134 #ifndef RL_MALLOC
135 #define RL_MALLOC(sz) malloc(sz)
136 #endif
137 #ifndef RL_CALLOC
138 #define RL_CALLOC(n,sz) calloc(n,sz)
139 #endif
140 #ifndef RL_REALLOC
141 #define RL_REALLOC(n,sz) realloc(n,sz)
142 #endif
143 #ifndef RL_FREE
144 #define RL_FREE(p) free(p)
145 #endif
146
147 // Security check in case no GRAPHICS_API_OPENGL_* defined
148 #if !defined(GRAPHICS_API_OPENGL_SOFTWARE) && \
149 !defined(GRAPHICS_API_OPENGL_11) && \
150 !defined(GRAPHICS_API_OPENGL_21) && \
151 !defined(GRAPHICS_API_OPENGL_33) && \
152 !defined(GRAPHICS_API_OPENGL_43) && \
153 !defined(GRAPHICS_API_OPENGL_ES2) && \
154 !defined(GRAPHICS_API_OPENGL_ES3)
155 #define GRAPHICS_API_OPENGL_33
156 #endif
157
158 // Security check in case multiple GRAPHICS_API_OPENGL_* defined
159 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_SOFTWARE)
160 #if defined(GRAPHICS_API_OPENGL_21)
161 #undef GRAPHICS_API_OPENGL_21
162 #endif
163 #if defined(GRAPHICS_API_OPENGL_33)
164 #undef GRAPHICS_API_OPENGL_33
165 #endif
166 #if defined(GRAPHICS_API_OPENGL_43)
167 #undef GRAPHICS_API_OPENGL_43
168 #endif
169 #if defined(GRAPHICS_API_OPENGL_ES2)
170 #undef GRAPHICS_API_OPENGL_ES2
171 #endif
172 #endif
173
174 // Software implementation uses OpenGL 1.1 functionality
175 #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
176 #define GRAPHICS_API_OPENGL_11
177 #endif
178
179 // OpenGL 2.1 uses most of OpenGL 3.3 Core functionality
180 // WARNING: Specific parts are checked with #if defines
181 #if defined(GRAPHICS_API_OPENGL_21)
182 #define GRAPHICS_API_OPENGL_33
183 #endif
184
185 // OpenGL 4.3 uses OpenGL 3.3 Core functionality
186 #if defined(GRAPHICS_API_OPENGL_43)
187 #define GRAPHICS_API_OPENGL_33
188 #endif
189
190 // OpenGL ES 3.0 uses OpenGL ES 2.0 functionality (and more)
191 #if defined(GRAPHICS_API_OPENGL_ES3)
192 #define GRAPHICS_API_OPENGL_ES2
193 #endif
194
195 //----------------------------------------------------------------------------------
196 // Defines and Macros
197 //----------------------------------------------------------------------------------
198
199 // Default internal render batch elements limits
200 #ifndef RL_DEFAULT_BATCH_BUFFER_ELEMENTS
201 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
202 // This is the maximum amount of elements (quads) per batch
203 // NOTE: Be careful with text, every letter maps to a quad
204 #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192
205 #endif
206 #if defined(GRAPHICS_API_OPENGL_ES2)
207 // Reducing memory sizes for embedded systems (RPI and HTML5)
208 // NOTE: On HTML5 (emscripten) this is allocated on heap,
209 // by default heap is only 16MB!...just take care...
210 #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 2048
211 #endif
212 #endif
213 #ifndef RL_DEFAULT_BATCH_BUFFERS
214 #define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering)
215 #endif
216 #ifndef RL_DEFAULT_BATCH_DRAWCALLS
217 #define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture)
218 #endif
219 #ifndef RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS
220 #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
221 #endif
222
223 // Internal Matrix stack
224 #ifndef RL_MAX_MATRIX_STACK_SIZE
225 #define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of Matrix stack
226 #endif
227
228 // Shader limits
229 #ifndef RL_MAX_SHADER_LOCATIONS
230 #define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported
231 #endif
232
233 // Projection matrix culling
234 #ifndef RL_CULL_DISTANCE_NEAR
235 #define RL_CULL_DISTANCE_NEAR 0.05 // Default near cull distance
236 #endif
237 #ifndef RL_CULL_DISTANCE_FAR
238 #define RL_CULL_DISTANCE_FAR 4000.0 // Default far cull distance
239 #endif
240
241 // Texture parameters (equivalent to OpenGL defines)
242 #define RL_TEXTURE_WRAP_S 0x2802 // GL_TEXTURE_WRAP_S
243 #define RL_TEXTURE_WRAP_T 0x2803 // GL_TEXTURE_WRAP_T
244 #define RL_TEXTURE_MAG_FILTER 0x2800 // GL_TEXTURE_MAG_FILTER
245 #define RL_TEXTURE_MIN_FILTER 0x2801 // GL_TEXTURE_MIN_FILTER
246
247 #define RL_TEXTURE_FILTER_NEAREST 0x2600 // GL_NEAREST
248 #define RL_TEXTURE_FILTER_LINEAR 0x2601 // GL_LINEAR
249 #define RL_TEXTURE_FILTER_MIP_NEAREST 0x2700 // GL_NEAREST_MIPMAP_NEAREST
250 #define RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR 0x2702 // GL_NEAREST_MIPMAP_LINEAR
251 #define RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST 0x2701 // GL_LINEAR_MIPMAP_NEAREST
252 #define RL_TEXTURE_FILTER_MIP_LINEAR 0x2703 // GL_LINEAR_MIPMAP_LINEAR
253 #define RL_TEXTURE_FILTER_ANISOTROPIC 0x3000 // Anisotropic filter (custom identifier)
254 #define RL_TEXTURE_MIPMAP_BIAS_RATIO 0x4000 // Texture mipmap bias, percentage ratio (custom identifier)
255
256 #define RL_TEXTURE_WRAP_REPEAT 0x2901 // GL_REPEAT
257 #define RL_TEXTURE_WRAP_CLAMP 0x812F // GL_CLAMP_TO_EDGE
258 #define RL_TEXTURE_WRAP_MIRROR_REPEAT 0x8370 // GL_MIRRORED_REPEAT
259 #define RL_TEXTURE_WRAP_MIRROR_CLAMP 0x8742 // GL_MIRROR_CLAMP_EXT
260
261 // Matrix modes (equivalent to OpenGL)
262 #define RL_MODELVIEW 0x1700 // GL_MODELVIEW
263 #define RL_PROJECTION 0x1701 // GL_PROJECTION
264 #define RL_TEXTURE 0x1702 // GL_TEXTURE
265
266 // Primitive assembly draw modes
267 #define RL_LINES 0x0001 // GL_LINES
268 #define RL_TRIANGLES 0x0004 // GL_TRIANGLES
269 #define RL_QUADS 0x0007 // GL_QUADS
270
271 // GL equivalent data types
272 #define RL_UNSIGNED_BYTE 0x1401 // GL_UNSIGNED_BYTE
273 #define RL_FLOAT 0x1406 // GL_FLOAT
274
275 // GL buffer usage hint
276 #define RL_STREAM_DRAW 0x88E0 // GL_STREAM_DRAW
277 #define RL_STREAM_READ 0x88E1 // GL_STREAM_READ
278 #define RL_STREAM_COPY 0x88E2 // GL_STREAM_COPY
279 #define RL_STATIC_DRAW 0x88E4 // GL_STATIC_DRAW
280 #define RL_STATIC_READ 0x88E5 // GL_STATIC_READ
281 #define RL_STATIC_COPY 0x88E6 // GL_STATIC_COPY
282 #define RL_DYNAMIC_DRAW 0x88E8 // GL_DYNAMIC_DRAW
283 #define RL_DYNAMIC_READ 0x88E9 // GL_DYNAMIC_READ
284 #define RL_DYNAMIC_COPY 0x88EA // GL_DYNAMIC_COPY
285
286 // GL Shader type
287 #define RL_FRAGMENT_SHADER 0x8B30 // GL_FRAGMENT_SHADER
288 #define RL_VERTEX_SHADER 0x8B31 // GL_VERTEX_SHADER
289 #define RL_COMPUTE_SHADER 0x91B9 // GL_COMPUTE_SHADER
290
291 // GL blending factors
292 #define RL_ZERO 0 // GL_ZERO
293 #define RL_ONE 1 // GL_ONE
294 #define RL_SRC_COLOR 0x0300 // GL_SRC_COLOR
295 #define RL_ONE_MINUS_SRC_COLOR 0x0301 // GL_ONE_MINUS_SRC_COLOR
296 #define RL_SRC_ALPHA 0x0302 // GL_SRC_ALPHA
297 #define RL_ONE_MINUS_SRC_ALPHA 0x0303 // GL_ONE_MINUS_SRC_ALPHA
298 #define RL_DST_ALPHA 0x0304 // GL_DST_ALPHA
299 #define RL_ONE_MINUS_DST_ALPHA 0x0305 // GL_ONE_MINUS_DST_ALPHA
300 #define RL_DST_COLOR 0x0306 // GL_DST_COLOR
301 #define RL_ONE_MINUS_DST_COLOR 0x0307 // GL_ONE_MINUS_DST_COLOR
302 #define RL_SRC_ALPHA_SATURATE 0x0308 // GL_SRC_ALPHA_SATURATE
303 #define RL_CONSTANT_COLOR 0x8001 // GL_CONSTANT_COLOR
304 #define RL_ONE_MINUS_CONSTANT_COLOR 0x8002 // GL_ONE_MINUS_CONSTANT_COLOR
305 #define RL_CONSTANT_ALPHA 0x8003 // GL_CONSTANT_ALPHA
306 #define RL_ONE_MINUS_CONSTANT_ALPHA 0x8004 // GL_ONE_MINUS_CONSTANT_ALPHA
307
308 // GL blending functions/equations
309 #define RL_FUNC_ADD 0x8006 // GL_FUNC_ADD
310 #define RL_MIN 0x8007 // GL_MIN
311 #define RL_MAX 0x8008 // GL_MAX
312 #define RL_FUNC_SUBTRACT 0x800A // GL_FUNC_SUBTRACT
313 #define RL_FUNC_REVERSE_SUBTRACT 0x800B // GL_FUNC_REVERSE_SUBTRACT
314 #define RL_BLEND_EQUATION 0x8009 // GL_BLEND_EQUATION
315 #define RL_BLEND_EQUATION_RGB 0x8009 // GL_BLEND_EQUATION_RGB // (Same as BLEND_EQUATION)
316 #define RL_BLEND_EQUATION_ALPHA 0x883D // GL_BLEND_EQUATION_ALPHA
317 #define RL_BLEND_DST_RGB 0x80C8 // GL_BLEND_DST_RGB
318 #define RL_BLEND_SRC_RGB 0x80C9 // GL_BLEND_SRC_RGB
319 #define RL_BLEND_DST_ALPHA 0x80CA // GL_BLEND_DST_ALPHA
320 #define RL_BLEND_SRC_ALPHA 0x80CB // GL_BLEND_SRC_ALPHA
321 #define RL_BLEND_COLOR 0x8005 // GL_BLEND_COLOR
322
323 #define RL_READ_FRAMEBUFFER 0x8CA8 // GL_READ_FRAMEBUFFER
324 #define RL_DRAW_FRAMEBUFFER 0x8CA9 // GL_DRAW_FRAMEBUFFER
325
326 // Default shader vertex attribute locations
327 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION
328 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION 0
329 #endif
330 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD
331 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD 1
332 #endif
333 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL
334 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL 2
335 #endif
336 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR
337 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR 3
338 #endif
339 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT
340 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT 4
341 #endif
342 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2
343 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2 5
344 #endif
345 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_INDICES
346 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_INDICES 6
347 #endif
348 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES
349 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES 7
350 #endif
351 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS
352 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS 8
353 #endif
354 #ifndef RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM
355 #define RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM 9
356 #endif
357
358 //----------------------------------------------------------------------------------
359 // Types and Structures Definition
360 //----------------------------------------------------------------------------------
361 #if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
362 #include <stdbool.h>
363 #elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE)
364 // Boolean type
365 typedef enum bool { false = 0, true = !false } bool;
366 #endif
367
368 #if !defined(RL_MATRIX_TYPE)
369 // Matrix, 4x4 components, column major, OpenGL style, right handed
370 typedef struct Matrix {
371 float m0, m4, m8, m12; // Matrix first row (4 components)
372 float m1, m5, m9, m13; // Matrix second row (4 components)
373 float m2, m6, m10, m14; // Matrix third row (4 components)
374 float m3, m7, m11, m15; // Matrix fourth row (4 components)
375 } Matrix;
376 #define RL_MATRIX_TYPE
377 #endif
378
379 // Dynamic vertex buffers (position + texcoords + colors + indices arrays)
380 typedef struct rlVertexBuffer {
381 int elementCount; // Number of elements in the buffer (QUADS)
382
383 float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
384 float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
385 float *normals; // Vertex normal (XYZ - 3 components per vertex) (shader-location = 2)
386 unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
387 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
388 unsigned int *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad)
389 #endif
390 #if defined(GRAPHICS_API_OPENGL_ES2)
391 unsigned short *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad)
392 #endif
393 unsigned int vaoId; // OpenGL Vertex Array Object id
394 unsigned int vboId[5]; // OpenGL Vertex Buffer Objects id (5 types of vertex data)
395 } rlVertexBuffer;
396
397 // Draw call type
398 // NOTE: Only texture changes register a new draw, other state-change-related elements are not
399 // used at this moment (vaoId, shaderId, matrices), raylib forces a batch draw call if any
400 // of those state-change happens (this is done in core module)
401 typedef struct rlDrawCall {
402 int mode; // Drawing mode: LINES, TRIANGLES, QUADS
403 int vertexCount; // Number of vertex of the draw
404 int vertexAlignment; // Number of vertex required for index alignment (LINES, TRIANGLES)
405 //unsigned int vaoId; // Vertex array id to be used on the draw -> Using RLGL.currentBatch->vertexBuffer.vaoId
406 //unsigned int shaderId; // Shader id to be used on the draw -> Using RLGL.currentShaderId
407 unsigned int textureId; // Texture id to be used on the draw -> Use to create new draw call if changes
408
409 //Matrix projection; // Projection matrix for this draw -> Using RLGL.projection by default
410 //Matrix modelview; // Modelview matrix for this draw -> Using RLGL.modelview by default
411 } rlDrawCall;
412
413 // rlRenderBatch type
414 typedef struct rlRenderBatch {
415 int bufferCount; // Number of vertex buffers (multi-buffering support)
416 int currentBuffer; // Current buffer tracking in case of multi-buffering
417 rlVertexBuffer *vertexBuffer; // Dynamic buffer(s) for vertex data
418
419 rlDrawCall *draws; // Draw calls array, depends on textureId
420 int drawCounter; // Draw calls counter
421 float currentDepth; // Current depth value for next draw
422 } rlRenderBatch;
423
424 // OpenGL version
425 typedef enum {
426 RL_OPENGL_SOFTWARE = 0, // Software rendering
427 RL_OPENGL_11, // OpenGL 1.1
428 RL_OPENGL_21, // OpenGL 2.1 (GLSL 120)
429 RL_OPENGL_33, // OpenGL 3.3 (GLSL 330)
430 RL_OPENGL_43, // OpenGL 4.3 (using GLSL 330)
431 RL_OPENGL_ES_20, // OpenGL ES 2.0 (GLSL 100)
432 RL_OPENGL_ES_30 // OpenGL ES 3.0 (GLSL 300 es)
433 } rlGlVersion;
434
435 // Trace log level
436 // NOTE: Organized by priority level
437 typedef enum {
438 RL_LOG_ALL = 0, // Display all logs
439 RL_LOG_TRACE, // Trace logging, intended for internal use only
440 RL_LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds
441 RL_LOG_INFO, // Info logging, used for program execution info
442 RL_LOG_WARNING, // Warning logging, used on recoverable failures
443 RL_LOG_ERROR, // Error logging, used on unrecoverable failures
444 RL_LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE)
445 RL_LOG_NONE // Disable logging
446 } rlTraceLogLevel;
447
448 // Texture pixel formats
449 // NOTE: Support depends on OpenGL version
450 typedef enum {
451 RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
452 RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels)
453 RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp
454 RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp
455 RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha)
456 RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha)
457 RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp
458 RL_PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float)
459 RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float)
460 RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float)
461 RL_PIXELFORMAT_UNCOMPRESSED_R16, // 16 bpp (1 channel - half float)
462 RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16, // 16*3 bpp (3 channels - half float)
463 RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16, // 16*4 bpp (4 channels - half float)
464 RL_PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha)
465 RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha)
466 RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp
467 RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp
468 RL_PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp
469 RL_PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp
470 RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp
471 RL_PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp
472 RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp
473 RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp
474 RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp
475 } rlPixelFormat;
476
477 // Texture parameters: filter mode
478 // NOTE 1: Filtering considers mipmaps if available in the texture
479 // NOTE 2: Filter is accordingly set for minification and magnification
480 typedef enum {
481 RL_TEXTURE_FILTER_POINT = 0, // No filter, pixel approximation
482 RL_TEXTURE_FILTER_BILINEAR, // Linear filtering
483 RL_TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps)
484 RL_TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x
485 RL_TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x
486 RL_TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x
487 } rlTextureFilter;
488
489 // Color blending modes (pre-defined)
490 typedef enum {
491 RL_BLEND_ALPHA = 0, // Blend textures considering alpha (default)
492 RL_BLEND_ADDITIVE, // Blend textures adding colors
493 RL_BLEND_MULTIPLIED, // Blend textures multiplying colors
494 RL_BLEND_ADD_COLORS, // Blend textures adding colors (alternative)
495 RL_BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative)
496 RL_BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha
497 RL_BLEND_CUSTOM, // Blend textures using custom src/dst factors (use rlSetBlendFactors())
498 RL_BLEND_CUSTOM_SEPARATE // Blend textures using custom src/dst factors (use rlSetBlendFactorsSeparate())
499 } rlBlendMode;
500
501 // Shader location point type
502 typedef enum {
503 RL_SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position
504 RL_SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01
505 RL_SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02
506 RL_SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal
507 RL_SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent
508 RL_SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color
509 RL_SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection
510 RL_SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform)
511 RL_SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection
512 RL_SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform)
513 RL_SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal
514 RL_SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view
515 RL_SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color
516 RL_SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color
517 RL_SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color
518 RL_SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE)
519 RL_SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR)
520 RL_SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal
521 RL_SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness
522 RL_SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion
523 RL_SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission
524 RL_SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height
525 RL_SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap
526 RL_SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance
527 RL_SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter
528 RL_SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf
529 } rlShaderLocationIndex;
530
531 #define RL_SHADER_LOC_MAP_DIFFUSE RL_SHADER_LOC_MAP_ALBEDO
532 #define RL_SHADER_LOC_MAP_SPECULAR RL_SHADER_LOC_MAP_METALNESS
533
534 // Shader uniform data type
535 typedef enum {
536 RL_SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float
537 RL_SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float)
538 RL_SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float)
539 RL_SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float)
540 RL_SHADER_UNIFORM_INT, // Shader uniform type: int
541 RL_SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int)
542 RL_SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int)
543 RL_SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int)
544 RL_SHADER_UNIFORM_UINT, // Shader uniform type: unsigned int
545 RL_SHADER_UNIFORM_UIVEC2, // Shader uniform type: uivec2 (2 unsigned int)
546 RL_SHADER_UNIFORM_UIVEC3, // Shader uniform type: uivec3 (3 unsigned int)
547 RL_SHADER_UNIFORM_UIVEC4, // Shader uniform type: uivec4 (4 unsigned int)
548 RL_SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d
549 } rlShaderUniformDataType;
550
551 // Shader attribute data types
552 typedef enum {
553 RL_SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float
554 RL_SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float)
555 RL_SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float)
556 RL_SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float)
557 } rlShaderAttributeDataType;
558
559 // Framebuffer attachment type
560 // NOTE: By default up to 8 color channels defined, but it can be more
561 typedef enum {
562 RL_ATTACHMENT_COLOR_CHANNEL0 = 0, // Framebuffer attachment type: color 0
563 RL_ATTACHMENT_COLOR_CHANNEL1 = 1, // Framebuffer attachment type: color 1
564 RL_ATTACHMENT_COLOR_CHANNEL2 = 2, // Framebuffer attachment type: color 2
565 RL_ATTACHMENT_COLOR_CHANNEL3 = 3, // Framebuffer attachment type: color 3
566 RL_ATTACHMENT_COLOR_CHANNEL4 = 4, // Framebuffer attachment type: color 4
567 RL_ATTACHMENT_COLOR_CHANNEL5 = 5, // Framebuffer attachment type: color 5
568 RL_ATTACHMENT_COLOR_CHANNEL6 = 6, // Framebuffer attachment type: color 6
569 RL_ATTACHMENT_COLOR_CHANNEL7 = 7, // Framebuffer attachment type: color 7
570 RL_ATTACHMENT_DEPTH = 100, // Framebuffer attachment type: depth
571 RL_ATTACHMENT_STENCIL = 200, // Framebuffer attachment type: stencil
572 } rlFramebufferAttachType;
573
574 // Framebuffer texture attachment type
575 typedef enum {
576 RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0, // Framebuffer texture attachment type: cubemap, +X side
577 RL_ATTACHMENT_CUBEMAP_NEGATIVE_X = 1, // Framebuffer texture attachment type: cubemap, -X side
578 RL_ATTACHMENT_CUBEMAP_POSITIVE_Y = 2, // Framebuffer texture attachment type: cubemap, +Y side
579 RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y = 3, // Framebuffer texture attachment type: cubemap, -Y side
580 RL_ATTACHMENT_CUBEMAP_POSITIVE_Z = 4, // Framebuffer texture attachment type: cubemap, +Z side
581 RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z = 5, // Framebuffer texture attachment type: cubemap, -Z side
582 RL_ATTACHMENT_TEXTURE2D = 100, // Framebuffer texture attachment type: texture2d
583 RL_ATTACHMENT_RENDERBUFFER = 200, // Framebuffer texture attachment type: renderbuffer
584 } rlFramebufferAttachTextureType;
585
586 // Face culling mode
587 typedef enum {
588 RL_CULL_FACE_FRONT = 0,
589 RL_CULL_FACE_BACK
590 } rlCullMode;
591
592 //------------------------------------------------------------------------------------
593 // Functions Declaration - Matrix operations
594 //------------------------------------------------------------------------------------
595
596 #if defined(__cplusplus)
597 extern "C" { // Prevents name mangling of functions
598 #endif
599
600 RLAPI void rlMatrixMode(int mode); // Choose the current matrix to be transformed
601 RLAPI void rlPushMatrix(void); // Push the current matrix to stack
602 RLAPI void rlPopMatrix(void); // Pop latest inserted matrix from stack
603 RLAPI void rlLoadIdentity(void); // Reset current matrix to identity matrix
604 RLAPI void rlTranslatef(float x, float y, float z); // Multiply the current matrix by a translation matrix
605 RLAPI void rlRotatef(float angle, float x, float y, float z); // Multiply the current matrix by a rotation matrix
606 RLAPI void rlScalef(float x, float y, float z); // Multiply the current matrix by a scaling matrix
607 RLAPI void rlMultMatrixf(const float *matf); // Multiply the current matrix by another matrix
608 RLAPI void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar);
609 RLAPI void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar);
610 RLAPI void rlViewport(int x, int y, int width, int height); // Set the viewport area
611 RLAPI void rlSetClipPlanes(double nearPlane, double farPlane); // Set clip planes distances
612 RLAPI double rlGetCullDistanceNear(void); // Get cull plane distance near
613 RLAPI double rlGetCullDistanceFar(void); // Get cull plane distance far
614
615 //------------------------------------------------------------------------------------
616 // Functions Declaration - Vertex level operations
617 //------------------------------------------------------------------------------------
618 RLAPI void rlBegin(int mode); // Initialize drawing mode (how to organize vertex)
619 RLAPI void rlEnd(void); // Finish vertex providing
620 RLAPI void rlVertex2i(int x, int y); // Define one vertex (position) - 2 int
621 RLAPI void rlVertex2f(float x, float y); // Define one vertex (position) - 2 float
622 RLAPI void rlVertex3f(float x, float y, float z); // Define one vertex (position) - 3 float
623 RLAPI void rlTexCoord2f(float x, float y); // Define one vertex (texture coordinate) - 2 float
624 RLAPI void rlNormal3f(float x, float y, float z); // Define one vertex (normal) - 3 float
625 RLAPI void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Define one vertex (color) - 4 byte
626 RLAPI void rlColor3f(float x, float y, float z); // Define one vertex (color) - 3 float
627 RLAPI void rlColor4f(float x, float y, float z, float w); // Define one vertex (color) - 4 float
628
629 //------------------------------------------------------------------------------------
630 // Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2)
631 // NOTE: This functions are used to completely abstract raylib code from OpenGL layer,
632 // some of them are direct wrappers over OpenGL calls, some others are custom
633 //------------------------------------------------------------------------------------
634
635 // Vertex buffers state
636 RLAPI bool rlEnableVertexArray(unsigned int vaoId); // Enable vertex array (VAO, if supported)
637 RLAPI void rlDisableVertexArray(void); // Disable vertex array (VAO, if supported)
638 RLAPI void rlEnableVertexBuffer(unsigned int id); // Enable vertex buffer (VBO)
639 RLAPI void rlDisableVertexBuffer(void); // Disable vertex buffer (VBO)
640 RLAPI void rlEnableVertexBufferElement(unsigned int id); // Enable vertex buffer element (VBO element)
641 RLAPI void rlDisableVertexBufferElement(void); // Disable vertex buffer element (VBO element)
642 RLAPI void rlEnableVertexAttribute(unsigned int index); // Enable vertex attribute index
643 RLAPI void rlDisableVertexAttribute(unsigned int index); // Disable vertex attribute index
644 RLAPI void rlEnableStatePointer(int vertexAttribType, void *buffer); // Enable attribute state pointer
645 RLAPI void rlDisableStatePointer(int vertexAttribType); // Disable attribute state pointer
646
647 // Textures state
648 RLAPI void rlActiveTextureSlot(int slot); // Select and active a texture slot
649 RLAPI void rlEnableTexture(unsigned int id); // Enable texture
650 RLAPI void rlDisableTexture(void); // Disable texture
651 RLAPI void rlEnableTextureCubemap(unsigned int id); // Enable texture cubemap
652 RLAPI void rlDisableTextureCubemap(void); // Disable texture cubemap
653 RLAPI void rlTextureParameters(unsigned int id, int param, int value); // Set texture parameters (filter, wrap)
654 RLAPI void rlCubemapParameters(unsigned int id, int param, int value); // Set cubemap parameters (filter, wrap)
655
656 // Shader state
657 RLAPI void rlEnableShader(unsigned int id); // Enable shader program
658 RLAPI void rlDisableShader(void); // Disable shader program
659
660 // Framebuffer state
661 RLAPI void rlEnableFramebuffer(unsigned int id); // Enable render texture (fbo)
662 RLAPI void rlDisableFramebuffer(void); // Disable render texture (fbo), return to default framebuffer
663 RLAPI unsigned int rlGetActiveFramebuffer(void); // Get the currently active render texture (fbo), 0 for default framebuffer
664 RLAPI void rlActiveDrawBuffers(int count); // Activate multiple draw color buffers
665 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
666 RLAPI void rlBindFramebuffer(unsigned int target, unsigned int framebuffer); // Bind framebuffer (FBO)
667
668 // General render state
669 RLAPI void rlEnableColorBlend(void); // Enable color blending
670 RLAPI void rlDisableColorBlend(void); // Disable color blending
671 RLAPI void rlEnableDepthTest(void); // Enable depth test
672 RLAPI void rlDisableDepthTest(void); // Disable depth test
673 RLAPI void rlEnableDepthMask(void); // Enable depth write
674 RLAPI void rlDisableDepthMask(void); // Disable depth write
675 RLAPI void rlEnableBackfaceCulling(void); // Enable backface culling
676 RLAPI void rlDisableBackfaceCulling(void); // Disable backface culling
677 RLAPI void rlColorMask(bool r, bool g, bool b, bool a); // Color mask control
678 RLAPI void rlSetCullFace(int mode); // Set face culling mode
679 RLAPI void rlEnableScissorTest(void); // Enable scissor test
680 RLAPI void rlDisableScissorTest(void); // Disable scissor test
681 RLAPI void rlScissor(int x, int y, int width, int height); // Scissor test
682 RLAPI void rlEnablePointMode(void); // Enable point mode
683 RLAPI void rlDisablePointMode(void); // Disable point mode
684 RLAPI void rlSetPointSize(float size); // Set the point drawing size
685 RLAPI float rlGetPointSize(void); // Get the point drawing size
686 RLAPI void rlEnableWireMode(void); // Enable wire mode
687 RLAPI void rlDisableWireMode(void); // Disable wire mode
688 RLAPI void rlSetLineWidth(float width); // Set the line drawing width
689 RLAPI float rlGetLineWidth(void); // Get the line drawing width
690 RLAPI void rlEnableSmoothLines(void); // Enable line aliasing
691 RLAPI void rlDisableSmoothLines(void); // Disable line aliasing
692 RLAPI void rlEnableStereoRender(void); // Enable stereo rendering
693 RLAPI void rlDisableStereoRender(void); // Disable stereo rendering
694 RLAPI bool rlIsStereoRenderEnabled(void); // Check if stereo render is enabled
695
696 RLAPI void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Clear color buffer with color
697 RLAPI void rlClearScreenBuffers(void); // Clear used screen buffers (color and depth)
698 RLAPI void rlCheckErrors(void); // Check and log OpenGL error codes
699 RLAPI void rlSetBlendMode(int mode); // Set blending mode
700 RLAPI void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation); // Set blending mode factor and equation (using OpenGL factors)
701 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)
702
703 //------------------------------------------------------------------------------------
704 // Functions Declaration - rlgl functionality
705 //------------------------------------------------------------------------------------
706 // rlgl initialization functions
707 RLAPI void rlglInit(int width, int height); // Initialize rlgl (buffers, shaders, textures, states)
708 RLAPI void rlglClose(void); // De-initialize rlgl (buffers, shaders, textures)
709 RLAPI void rlLoadExtensions(void *loader); // Load OpenGL extensions (loader function required)
710 RLAPI void *rlGetProcAddress(const char *procName); // Get OpenGL procedure address
711 RLAPI int rlGetVersion(void); // Get current OpenGL version
712 RLAPI void rlSetFramebufferWidth(int width); // Set current framebuffer width
713 RLAPI int rlGetFramebufferWidth(void); // Get default framebuffer width
714 RLAPI void rlSetFramebufferHeight(int height); // Set current framebuffer height
715 RLAPI int rlGetFramebufferHeight(void); // Get default framebuffer height
716
717 RLAPI unsigned int rlGetTextureIdDefault(void); // Get default texture id
718 RLAPI unsigned int rlGetShaderIdDefault(void); // Get default shader id
719 RLAPI int *rlGetShaderLocsDefault(void); // Get default shader locations
720
721 // Render batch management
722 // NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode
723 // but this render batch API is exposed in case of custom batches are required
724 RLAPI rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements); // Load a render batch system
725 RLAPI void rlUnloadRenderBatch(rlRenderBatch batch); // Unload render batch system
726 RLAPI void rlDrawRenderBatch(rlRenderBatch *batch); // Draw render batch data (Update->Draw->Reset)
727 RLAPI void rlSetRenderBatchActive(rlRenderBatch *batch); // Set the active render batch for rlgl (NULL for default internal)
728 RLAPI void rlDrawRenderBatchActive(void); // Update and draw internal render batch
729 RLAPI bool rlCheckRenderBatchLimit(int vCount); // Check internal buffer overflow for a given number of vertex
730
731 RLAPI void rlSetTexture(unsigned int id); // Set current texture for render batch and check buffers limits
732
733 //------------------------------------------------------------------------------------------------------------------------
734
735 // Vertex buffers management
736 RLAPI unsigned int rlLoadVertexArray(void); // Load vertex array (vao) if supported
737 RLAPI unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic); // Load a vertex buffer object
738 RLAPI unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic); // Load vertex buffer elements object
739 RLAPI void rlUpdateVertexBuffer(unsigned int bufferId, const void *data, int dataSize, int offset); // Update vertex buffer object data on GPU buffer
740 RLAPI void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset); // Update vertex buffer elements data on GPU buffer
741 RLAPI void rlUnloadVertexArray(unsigned int vaoId); // Unload vertex array (vao)
742 RLAPI void rlUnloadVertexBuffer(unsigned int vboId); // Unload vertex buffer object
743 RLAPI void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, int offset); // Set vertex attribute data configuration
744 RLAPI void rlSetVertexAttributeDivisor(unsigned int index, int divisor); // Set vertex attribute data divisor
745 RLAPI void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count); // Set vertex attribute default value, when attribute to provided
746 RLAPI void rlDrawVertexArray(int offset, int count); // Draw vertex array (currently active vao)
747 RLAPI void rlDrawVertexArrayElements(int offset, int count, const void *buffer); // Draw vertex array elements
748 RLAPI void rlDrawVertexArrayInstanced(int offset, int count, int instances); // Draw vertex array (currently active vao) with instancing
749 RLAPI void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances); // Draw vertex array elements with instancing
750
751 // Textures management
752 RLAPI unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount); // Load texture data
753 RLAPI unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer); // Load depth texture/renderbuffer (to be attached to fbo)
754 RLAPI unsigned int rlLoadTextureCubemap(const void *data, int size, int format, int mipmapCount); // Load texture cubemap data
755 RLAPI 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
756 RLAPI void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType); // Get OpenGL internal formats
757 RLAPI const char *rlGetPixelFormatName(unsigned int format); // Get name string for pixel format
758 RLAPI void rlUnloadTexture(unsigned int id); // Unload texture from GPU memory
759 RLAPI void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps); // Generate mipmap data for selected texture
760 RLAPI void *rlReadTexturePixels(unsigned int id, int width, int height, int format); // Read texture pixel data
761 RLAPI unsigned char *rlReadScreenPixels(int width, int height); // Read screen pixel data (color buffer)
762
763 // Framebuffer management (fbo)
764 RLAPI unsigned int rlLoadFramebuffer(void); // Load an empty framebuffer
765 RLAPI void rlFramebufferAttach(unsigned int id, unsigned int texId, int attachType, int texType, int mipLevel); // Attach texture/renderbuffer to a framebuffer
766 RLAPI bool rlFramebufferComplete(unsigned int id); // Verify framebuffer is complete
767 RLAPI void rlUnloadFramebuffer(unsigned int id); // Delete framebuffer from GPU
768 // WARNING: Copy and resize framebuffer functionality only defined for software backend
769 RLAPI void rlCopyFramebuffer(int x, int y, int width, int height, int format, void *pixels); // Copy framebuffer pixel data to internal buffer
770 RLAPI void rlResizeFramebuffer(int width, int height); // Resize internal framebuffer
771
772 // Shaders management
773 RLAPI unsigned int rlLoadShader(const char *code, int type); // Load (compile) shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER)
774 RLAPI unsigned int rlLoadShaderProgram(const char *vsCode, const char *fsCode); // Load shader from code strings
775 RLAPI unsigned int rlLoadShaderProgramEx(unsigned int vsId, unsigned int fsId); // Load shader program, using already loaded shader ids
776 RLAPI unsigned int rlLoadShaderProgramCompute(unsigned int csId); // Load compute shader program
777 RLAPI void rlUnloadShader(unsigned int id); // Unload shader, loaded with rlLoadShader()
778 RLAPI void rlUnloadShaderProgram(unsigned int id); // Unload shader program
779 RLAPI int rlGetLocationUniform(unsigned int id, const char *uniformName); // Get shader location uniform, requires shader program id
780 RLAPI int rlGetLocationAttrib(unsigned int id, const char *attribName); // Get shader location attribute, requires shader program id
781 RLAPI void rlSetUniform(int locIndex, const void *value, int uniformType, int count); // Set shader value uniform
782 RLAPI void rlSetUniformMatrix(int locIndex, Matrix mat); // Set shader value matrix
783 RLAPI void rlSetUniformMatrices(int locIndex, const Matrix *mat, int count); // Set shader value matrices
784 RLAPI void rlSetUniformSampler(int locIndex, unsigned int textureId); // Set shader value sampler
785 RLAPI void rlSetShader(unsigned int id, int *locs); // Set shader currently active (id and locations)
786
787 // Compute shader management
788 RLAPI void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ); // Dispatch compute shader (equivalent to *draw* for graphics pipeline)
789
790 // Shader buffer storage object management (ssbo)
791 RLAPI unsigned int rlLoadShaderBuffer(unsigned int size, const void *data, int usageHint); // Load shader storage buffer object (SSBO)
792 RLAPI void rlUnloadShaderBuffer(unsigned int ssboId); // Unload shader storage buffer object (SSBO)
793 RLAPI void rlUpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset); // Update SSBO buffer data
794 RLAPI void rlBindShaderBuffer(unsigned int id, unsigned int index); // Bind SSBO buffer
795 RLAPI void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset); // Read SSBO buffer data (GPU->CPU)
796 RLAPI void rlCopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count); // Copy SSBO data between buffers
797 RLAPI unsigned int rlGetShaderBufferSize(unsigned int id); // Get SSBO buffer size
798
799 // Buffer management
800 RLAPI void rlBindImageTexture(unsigned int id, unsigned int index, int format, bool readonly); // Bind image texture
801
802 // Matrix state management
803 RLAPI Matrix rlGetMatrixModelview(void); // Get internal modelview matrix
804 RLAPI Matrix rlGetMatrixProjection(void); // Get internal projection matrix
805 RLAPI Matrix rlGetMatrixTransform(void); // Get internal accumulated transform matrix
806 RLAPI Matrix rlGetMatrixProjectionStereo(int eye); // Get internal projection matrix for stereo render (selected eye)
807 RLAPI Matrix rlGetMatrixViewOffsetStereo(int eye); // Get internal view offset matrix for stereo render (selected eye)
808 RLAPI void rlSetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix)
809 RLAPI void rlSetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix)
810 RLAPI void rlSetMatrixProjectionStereo(Matrix right, Matrix left); // Set eyes projection matrices for stereo rendering
811 RLAPI void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left); // Set eyes view offsets matrices for stereo rendering
812
813 // Quick and dirty cube/quad buffers load->draw->unload
814 RLAPI void rlLoadDrawCube(void); // Load and draw a cube
815 RLAPI void rlLoadDrawQuad(void); // Load and draw a quad
816
817 #if defined(__cplusplus)
818 }
819 #endif
820
821 #endif // RLGL_H
822
823 /***********************************************************************************
824 *
825 * RLGL IMPLEMENTATION
826 *
827 ************************************************************************************/
828
829 #if defined(RLGL_IMPLEMENTATION)
830
831 // Expose OpenGL functions from glad in raylib
832 #if defined(BUILD_LIBTYPE_SHARED)
833 #define GLAD_API_CALL_EXPORT
834 #define GLAD_API_CALL_EXPORT_BUILD
835 #endif
836
837 #if defined(GRAPHICS_API_OPENGL_11)
838 #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
839 #define RLSW_IMPLEMENTATION
840 #define SW_MALLOC(sz) RL_MALLOC(sz)
841 #define SW_CALLOC(n,sz) RL_CALLOC(n, sz)
842 #define SW_REALLOC(ptr, newSz) RL_REALLOC(ptr, newSz)
843 #define SW_FREE(ptr) RL_FREE(ptr)
844 #include "external/rlsw.h" // OpenGL 1.1 software implementation
845 #else
846 #if defined(__APPLE__)
847 #include <OpenGL/gl.h> // OpenGL 1.1 library for OSX
848 #include <OpenGL/glext.h> // OpenGL extensions library
849 #else
850 // APIENTRY for OpenGL function pointer declarations is required
851 #if !defined(APIENTRY)
852 #if defined(_WIN32)
853 #define APIENTRY __stdcall
854 #else
855 #define APIENTRY
856 #endif
857 #endif
858 // WINGDIAPI definition. Some Windows OpenGL headers need it
859 #if !defined(WINGDIAPI) && defined(_WIN32)
860 #define WINGDIAPI __declspec(dllimport)
861 #endif
862
863 #include <GL/gl.h> // OpenGL 1.1 library
864 #endif
865 #endif
866 #endif
867
868 #if defined(GRAPHICS_API_OPENGL_33)
869 #define GLAD_MALLOC RL_MALLOC
870 #define GLAD_FREE RL_FREE
871
872 #define GLAD_GL_IMPLEMENTATION
873 #include "external/glad.h" // GLAD extensions loading library, includes OpenGL headers
874 #endif
875
876 #if defined(GRAPHICS_API_OPENGL_ES3)
877 #include <GLES3/gl3.h> // OpenGL ES 3.0 library
878 #define GL_GLEXT_PROTOTYPES
879 #include <GLES2/gl2ext.h> // OpenGL ES 2.0 extensions library
880 #elif defined(GRAPHICS_API_OPENGL_ES2)
881 // NOTE: OpenGL ES 2.0 can be enabled on Desktop platforms,
882 // in that case, functions are loaded from a custom glad for OpenGL ES 2.0
883 // TODO: OpenGL ES 2.0 support shouldn't be platform-dependent, neither require GLAD
884 #if defined(PLATFORM_DESKTOP_GLFW) || defined(PLATFORM_DESKTOP_SDL)
885 #define GLAD_GLES2_IMPLEMENTATION
886 #include "external/glad_gles2.h"
887 #else
888 #define GL_GLEXT_PROTOTYPES
889 //#include <EGL/egl.h> // EGL library -> not required, platform layer
890 #include <GLES2/gl2.h> // OpenGL ES 2.0 library
891 #include <GLES2/gl2ext.h> // OpenGL ES 2.0 extensions library
892 #endif
893
894 // It seems OpenGL ES 2.0 instancing entry points are not defined on Raspberry Pi
895 // provided headers (despite being defined in official Khronos GLES2 headers)
896 // TODO: Avoid raylib platform-dependent code on rlgl, it should be a completely portable library
897 #if defined(PLATFORM_DRM)
898 typedef void (GL_APIENTRYP PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount);
899 typedef void (GL_APIENTRYP PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount);
900 typedef void (GL_APIENTRYP PFNGLVERTEXATTRIBDIVISOREXTPROC) (GLuint index, GLuint divisor);
901 #endif
902 #endif
903
904 #include <stdlib.h> // Required for: calloc(), free()
905 #include <string.h> // Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading]
906 #include <math.h> // Required for: sqrtf(), sinf(), cosf(), floor(), log()
907
908 //----------------------------------------------------------------------------------
909 // Defines and Macros
910 //----------------------------------------------------------------------------------
911 #ifndef PI
912 #define PI 3.14159265358979323846f
913 #endif
914 #ifndef DEG2RAD
915 #define DEG2RAD (PI/180.0f)
916 #endif
917 #ifndef RAD2DEG
918 #define RAD2DEG (180.0f/PI)
919 #endif
920
921 #ifndef GL_SHADING_LANGUAGE_VERSION
922 #define GL_SHADING_LANGUAGE_VERSION 0x8B8C
923 #endif
924
925 #ifndef GL_COMPRESSED_RGB_S3TC_DXT1_EXT
926 #define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0
927 #endif
928 #ifndef GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
929 #define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
930 #endif
931 #ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
932 #define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2
933 #endif
934 #ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
935 #define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
936 #endif
937 #ifndef GL_ETC1_RGB8_OES
938 #define GL_ETC1_RGB8_OES 0x8D64
939 #endif
940 #ifndef GL_COMPRESSED_RGB8_ETC2
941 #define GL_COMPRESSED_RGB8_ETC2 0x9274
942 #endif
943 #ifndef GL_COMPRESSED_RGBA8_ETC2_EAC
944 #define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278
945 #endif
946 #ifndef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG
947 #define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00
948 #endif
949 #ifndef GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
950 #define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02
951 #endif
952 #ifndef GL_COMPRESSED_RGBA_ASTC_4x4_KHR
953 #define GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93b0
954 #endif
955 #ifndef GL_COMPRESSED_RGBA_ASTC_8x8_KHR
956 #define GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93b7
957 #endif
958
959 #ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
960 #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
961 #endif
962 #ifndef GL_TEXTURE_MAX_ANISOTROPY_EXT
963 #define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE
964 #endif
965
966 #ifndef GL_PROGRAM_POINT_SIZE
967 #define GL_PROGRAM_POINT_SIZE 0x8642
968 #endif
969
970 #ifndef GL_LINE_WIDTH
971 #define GL_LINE_WIDTH 0x0B21
972 #endif
973
974 #if defined(GRAPHICS_API_OPENGL_11)
975 #define GL_UNSIGNED_SHORT_5_6_5 0x8363
976 #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034
977 #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033
978 #endif
979
980 #if defined(GRAPHICS_API_OPENGL_21)
981 #define GL_LUMINANCE 0x1909
982 #define GL_LUMINANCE_ALPHA 0x190A
983 #endif
984
985 #if defined(GRAPHICS_API_OPENGL_ES2)
986 #define glClearDepth glClearDepthf
987 #if !defined(GRAPHICS_API_OPENGL_ES3)
988 #define GL_READ_FRAMEBUFFER GL_FRAMEBUFFER
989 #define GL_DRAW_FRAMEBUFFER GL_FRAMEBUFFER
990 #endif
991 #endif
992
993 // Default shader vertex attribute names to set location points
994 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION
995 #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION
996 #endif
997 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD
998 #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD
999 #endif
1000 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL
1001 #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL
1002 #endif
1003 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR
1004 #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR
1005 #endif
1006 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT
1007 #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT
1008 #endif
1009 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2
1010 #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2
1011 #endif
1012 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES
1013 #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES "vertexBoneIndices" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES
1014 #endif
1015 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS
1016 #define RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS "vertexBoneWeights" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS
1017 #endif
1018
1019 #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCETRANSFORM
1020 #define RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCETRANSFORM "instanceTransform" // Bound by default to shader location: RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM
1021 #endif
1022
1023 #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MVP
1024 #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix
1025 #endif
1026 #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW
1027 #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix
1028 #endif
1029 #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION
1030 #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix
1031 #endif
1032 #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL
1033 #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix
1034 #endif
1035 #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL
1036 #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView))
1037 #endif
1038 #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR
1039 #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color)
1040 #endif
1041 #ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0
1042 #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0)
1043 #endif
1044 #ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1
1045 #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1)
1046 #endif
1047 #ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2
1048 #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2)
1049 #endif
1050 #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_BONEMATRICES
1051 #define RL_DEFAULT_SHADER_UNIFORM_NAME_BONEMATRICES "boneMatrices" // bone matrices (required for GPU skinning)
1052 #endif
1053
1054 //----------------------------------------------------------------------------------
1055 // Module Types and Structures Definition
1056 //----------------------------------------------------------------------------------
1057 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
1058
1059 typedef void *(*rlglLoadProc)(const char *name); // OpenGL extension functions loader signature (same as GLADloadproc)
1060
1061 typedef struct rlglData {
1062 rlRenderBatch *currentBatch; // Current render batch
1063 rlRenderBatch defaultBatch; // Default internal render batch
1064
1065 rlglLoadProc loader; // OpenGL function loader
1066
1067 struct {
1068 int vertexCounter; // Current active render batch vertex counter (generic, used for all batches)
1069 float texcoordx, texcoordy; // Current active texture coordinate (added on glVertex*())
1070 float normalx, normaly, normalz; // Current active normal (added on glVertex*())
1071 unsigned char colorr, colorg, colorb, colora; // Current active color (added on glVertex*())
1072
1073 int currentMatrixMode; // Current matrix mode
1074 Matrix *currentMatrix; // Current matrix pointer
1075 Matrix modelview; // Default modelview matrix
1076 Matrix projection; // Default projection matrix
1077 Matrix transform; // Transform matrix to be used with rlTranslate, rlRotate, rlScale
1078 bool transformRequired; // Require transform matrix application to current draw-call vertex (if required)
1079 Matrix stack[RL_MAX_MATRIX_STACK_SIZE];// Matrix stack for push/pop
1080 int stackCounter; // Matrix stack counter
1081
1082 unsigned int currentTextureId; // Current texture id to be used on glBegin
1083 unsigned int defaultTextureId; // Default texture used on shapes/poly drawing (required by shader)
1084 unsigned int activeTextureId[RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS]; // Active texture ids to be enabled on batch drawing (0 active by default)
1085 unsigned int defaultVShaderId; // Default vertex shader id (used by default shader program)
1086 unsigned int defaultFShaderId; // Default fragment shader id (used by default shader program)
1087 unsigned int defaultShaderId; // Default shader program id, supports vertex color and diffuse texture
1088 int *defaultShaderLocs; // Default shader locations pointer to be used on rendering
1089 unsigned int currentShaderId; // Current shader id to be used on rendering (by default, defaultShaderId)
1090 int *currentShaderLocs; // Current shader locations pointer to be used on rendering (by default, defaultShaderLocs)
1091
1092 bool stereoRender; // Stereo rendering flag
1093 Matrix projectionStereo[2]; // VR stereo rendering eyes projection matrices
1094 Matrix viewOffsetStereo[2]; // VR stereo rendering eyes view offset matrices
1095
1096 // Blending variables
1097 int currentBlendMode; // Blending mode active
1098 int glBlendSrcFactor; // Blending source factor
1099 int glBlendDstFactor; // Blending destination factor
1100 int glBlendEquation; // Blending equation
1101 int glBlendSrcFactorRGB; // Blending source RGB factor
1102 int glBlendDestFactorRGB; // Blending destination RGB factor
1103 int glBlendSrcFactorAlpha; // Blending source alpha factor
1104 int glBlendDestFactorAlpha; // Blending destination alpha factor
1105 int glBlendEquationRGB; // Blending equation for RGB
1106 int glBlendEquationAlpha; // Blending equation for alpha
1107 bool glCustomBlendModeModified; // Custom blending factor and equation modification status
1108
1109 int framebufferWidth; // Current framebuffer width
1110 int framebufferHeight; // Current framebuffer height
1111
1112 } State; // Renderer state
1113 struct {
1114 bool vao; // VAO support (OpenGL ES2 could not support VAO extension) (GL_ARB_vertex_array_object)
1115 bool instancing; // Instancing supported (GL_ANGLE_instanced_arrays, GL_EXT_draw_instanced + GL_EXT_instanced_arrays)
1116 bool texNPOT; // NPOT textures full support (GL_ARB_texture_non_power_of_two, GL_OES_texture_npot)
1117 bool texDepth; // Depth textures supported (GL_ARB_depth_texture, GL_OES_depth_texture)
1118 bool texDepthWebGL; // Depth textures supported WebGL specific (GL_WEBGL_depth_texture)
1119 bool texFloat32; // float textures support (32 bit per channel) (GL_OES_texture_float)
1120 bool texFloat16; // half float textures support (16 bit per channel) (GL_OES_texture_half_float)
1121 bool texCompDXT; // DDS texture compression support (GL_EXT_texture_compression_s3tc, GL_WEBGL_compressed_texture_s3tc, GL_WEBKIT_WEBGL_compressed_texture_s3tc)
1122 bool texCompETC1; // ETC1 texture compression support (GL_OES_compressed_ETC1_RGB8_texture, GL_WEBGL_compressed_texture_etc1)
1123 bool texCompETC2; // ETC2/EAC texture compression support (GL_ARB_ES3_compatibility)
1124 bool texCompPVRT; // PVR texture compression support (GL_IMG_texture_compression_pvrtc)
1125 bool texCompASTC; // ASTC texture compression support (GL_KHR_texture_compression_astc_hdr, GL_KHR_texture_compression_astc_ldr)
1126 bool texMirrorClamp; // Clamp mirror wrap mode supported (GL_EXT_texture_mirror_clamp)
1127 bool texAnisoFilter; // Anisotropic texture filtering support (GL_EXT_texture_filter_anisotropic)
1128 bool computeShader; // Compute shaders support (GL_ARB_compute_shader)
1129 bool ssbo; // Shader storage buffer object support (GL_ARB_shader_storage_buffer_object)
1130
1131 float maxAnisotropyLevel; // Maximum anisotropy level supported (minimum is 2.0f)
1132 int maxDepthBits; // Maximum bits for depth component
1133
1134 } ExtSupported; // Extensions supported flags
1135 } rlglData;
1136
1137 #endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
1138
1139 //----------------------------------------------------------------------------------
1140 // Global Variables Definition
1141 //----------------------------------------------------------------------------------
1142 static bool isGpuReady = false;
1143 static double rlCullDistanceNear = RL_CULL_DISTANCE_NEAR;
1144 static double rlCullDistanceFar = RL_CULL_DISTANCE_FAR;
1145
1146 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
1147 static rlglData RLGL = { 0 };
1148 #endif
1149
1150 #if defined(GRAPHICS_API_OPENGL_ES2) && !defined(GRAPHICS_API_OPENGL_ES3)
1151 // VAO functions entry points
1152 // NOTE: VAO functionality is exposed through extensions (OES)
1153 static PFNGLGENVERTEXARRAYSOESPROC glGenVertexArrays = NULL;
1154 static PFNGLBINDVERTEXARRAYOESPROC glBindVertexArray = NULL;
1155 static PFNGLDELETEVERTEXARRAYSOESPROC glDeleteVertexArrays = NULL;
1156
1157 // Instancing functionality entry points
1158 // NOTE: Instancing functionality could be available through extensions
1159 static PFNGLDRAWARRAYSINSTANCEDEXTPROC glDrawArraysInstanced = NULL;
1160 static PFNGLDRAWELEMENTSINSTANCEDEXTPROC glDrawElementsInstanced = NULL;
1161 static PFNGLVERTEXATTRIBDIVISOREXTPROC glVertexAttribDivisor = NULL;
1162 #endif
1163
1164 //----------------------------------------------------------------------------------
1165 // Module Functions Declaration
1166 //----------------------------------------------------------------------------------
1167 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
1168 static void rlLoadShaderDefault(void); // Load default shader
1169 static void rlUnloadShaderDefault(void); // Unload default shader
1170 #if RLGL_SHOW_GL_DETAILS_INFO
1171 static const char *rlGetCompressedFormatName(int format); // Get compressed format official GL identifier name
1172 #endif
1173 #endif
1174
1175 static int rlGetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes (image or texture)
1176
1177 static Matrix rlMatrixIdentity(void); // Get identity matrix
1178 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
1179 // Auxiliar matrix math functions
1180 typedef struct rl_float16 { float v[16]; } rl_float16;
1181 static rl_float16 rlMatrixToFloatV(Matrix mat); // Get float array of matrix data
1182 #define rlMatrixToFloat(mat) (rlMatrixToFloatV(mat).v) // Get float vector for Matrix
1183 static Matrix rlMatrixMultiply(Matrix left, Matrix right); // Multiply two matrices
1184 static Matrix rlMatrixTranspose(Matrix mat); // Transposes provided matrix
1185 static Matrix rlMatrixInvert(Matrix mat); // Invert provided matrix
1186 #endif
1187
1188 //----------------------------------------------------------------------------------
1189 // Module Functions Definition - Matrix operations
1190 //----------------------------------------------------------------------------------
1191
1192 #if defined(GRAPHICS_API_OPENGL_11)
1193 // Fallback to OpenGL 1.1 function calls
1194 //---------------------------------------
1195 void rlMatrixMode(int mode)
1196 {
1197 switch (mode)
1198 {
1199 case RL_PROJECTION: glMatrixMode(GL_PROJECTION); break;
1200 case RL_MODELVIEW: glMatrixMode(GL_MODELVIEW); break;
1201 case RL_TEXTURE: glMatrixMode(GL_TEXTURE); break;
1202 default: break;
1203 }
1204 }
1205
1206 void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar)
1207 {
1208 glFrustum(left, right, bottom, top, znear, zfar);
1209 }
1210
1211 void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar)
1212 {
1213 glOrtho(left, right, bottom, top, znear, zfar);
1214 }
1215
1216 void rlPushMatrix(void) { glPushMatrix(); }
1217 void rlPopMatrix(void) { glPopMatrix(); }
1218 void rlLoadIdentity(void) { glLoadIdentity(); }
1219 void rlTranslatef(float x, float y, float z) { glTranslatef(x, y, z); }
1220 void rlRotatef(float angle, float x, float y, float z) { glRotatef(angle, x, y, z); }
1221 void rlScalef(float x, float y, float z) { glScalef(x, y, z); }
1222 void rlMultMatrixf(const float *matf) { glMultMatrixf(matf); }
1223 #endif
1224 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
1225 // Choose the current matrix to be transformed
1226 void rlMatrixMode(int mode)
1227 {
1228 if (mode == RL_PROJECTION) RLGL.State.currentMatrix = &RLGL.State.projection;
1229 else if (mode == RL_MODELVIEW) RLGL.State.currentMatrix = &RLGL.State.modelview;
1230 //else if (mode == RL_TEXTURE) // Not supported
1231
1232 RLGL.State.currentMatrixMode = mode;
1233 }
1234
1235 // Push the current matrix into RLGL.State.stack
1236 void rlPushMatrix(void)
1237 {
1238 if (RLGL.State.stackCounter >= RL_MAX_MATRIX_STACK_SIZE) TRACELOG(RL_LOG_ERROR, "RLGL: Matrix stack overflow (RL_MAX_MATRIX_STACK_SIZE)");
1239
1240 if (RLGL.State.currentMatrixMode == RL_MODELVIEW)
1241 {
1242 RLGL.State.transformRequired = true;
1243 RLGL.State.currentMatrix = &RLGL.State.transform;
1244 }
1245
1246 RLGL.State.stack[RLGL.State.stackCounter] = *RLGL.State.currentMatrix;
1247 RLGL.State.stackCounter++;
1248 }
1249
1250 // Pop latest inserted matrix from RLGL.State.stack
1251 void rlPopMatrix(void)
1252 {
1253 if (RLGL.State.stackCounter > 0)
1254 {
1255 Matrix mat = RLGL.State.stack[RLGL.State.stackCounter - 1];
1256 *RLGL.State.currentMatrix = mat;
1257 RLGL.State.stackCounter--;
1258 }
1259
1260 if ((RLGL.State.stackCounter == 0) && (RLGL.State.currentMatrixMode == RL_MODELVIEW))
1261 {
1262 RLGL.State.currentMatrix = &RLGL.State.modelview;
1263 RLGL.State.transformRequired = false;
1264 }
1265 }
1266
1267 // Reset current matrix to identity matrix
1268 void rlLoadIdentity(void)
1269 {
1270 *RLGL.State.currentMatrix = rlMatrixIdentity();
1271 }
1272
1273 // Multiply the current matrix by a translation matrix
1274 void rlTranslatef(float x, float y, float z)
1275 {
1276 Matrix matTranslation = rlMatrixIdentity();
1277
1278 // Set translation component of matrix
1279 matTranslation.m12 = x;
1280 matTranslation.m13 = y;
1281 matTranslation.m14 = z;
1282
1283 // NOTE: Transposing matrix by multiplication order
1284 *RLGL.State.currentMatrix = rlMatrixMultiply(matTranslation, *RLGL.State.currentMatrix);
1285 }
1286
1287 // Multiply the current matrix by a rotation matrix
1288 // NOTE: The provided angle must be in degrees
1289 void rlRotatef(float angle, float x, float y, float z)
1290 {
1291 Matrix matRotation = rlMatrixIdentity();
1292
1293 // Axis vector (x, y, z) normalization
1294 float lengthSquared = x*x + y*y + z*z;
1295 if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f))
1296 {
1297 float inverseLength = 1.0f/sqrtf(lengthSquared);
1298 x *= inverseLength;
1299 y *= inverseLength;
1300 z *= inverseLength;
1301 }
1302
1303 // Rotation matrix generation
1304 float sinres = sinf(DEG2RAD*angle);
1305 float cosres = cosf(DEG2RAD*angle);
1306 float t = 1.0f - cosres;
1307
1308 matRotation.m0 = x*x*t + cosres;
1309 matRotation.m1 = y*x*t + z*sinres;
1310 matRotation.m2 = z*x*t - y*sinres;
1311 matRotation.m3 = 0.0f;
1312
1313 matRotation.m4 = x*y*t - z*sinres;
1314 matRotation.m5 = y*y*t + cosres;
1315 matRotation.m6 = z*y*t + x*sinres;
1316 matRotation.m7 = 0.0f;
1317
1318 matRotation.m8 = x*z*t + y*sinres;
1319 matRotation.m9 = y*z*t - x*sinres;
1320 matRotation.m10 = z*z*t + cosres;
1321 matRotation.m11 = 0.0f;
1322
1323 matRotation.m12 = 0.0f;
1324 matRotation.m13 = 0.0f;
1325 matRotation.m14 = 0.0f;
1326 matRotation.m15 = 1.0f;
1327
1328 // NOTE: Transposing matrix by multiplication order
1329 *RLGL.State.currentMatrix = rlMatrixMultiply(matRotation, *RLGL.State.currentMatrix);
1330 }
1331
1332 // Multiply the current matrix by a scaling matrix
1333 void rlScalef(float x, float y, float z)
1334 {
1335 Matrix matScale = rlMatrixIdentity();
1336
1337 // Set scale component of matrix
1338 matScale.m0 = x;
1339 matScale.m5 = y;
1340 matScale.m10 = z;
1341
1342 // NOTE: Transposing matrix by multiplication order
1343 *RLGL.State.currentMatrix = rlMatrixMultiply(matScale, *RLGL.State.currentMatrix);
1344 }
1345
1346 // Multiply the current matrix by another matrix
1347 void rlMultMatrixf(const float *matf)
1348 {
1349 // Matrix creation from array
1350 // Conversion from column-major to row-major memory order
1351 Matrix mat = { matf[0], matf[4], matf[8], matf[12],
1352 matf[1], matf[5], matf[9], matf[13],
1353 matf[2], matf[6], matf[10], matf[14],
1354 matf[3], matf[7], matf[11], matf[15] };
1355
1356 *RLGL.State.currentMatrix = rlMatrixMultiply(mat, *RLGL.State.currentMatrix);
1357 }
1358
1359 // Multiply the current matrix by a perspective matrix generated by parameters
1360 void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar)
1361 {
1362 Matrix matFrustum = { 0 };
1363
1364 float rl = (float)(right - left);
1365 float tb = (float)(top - bottom);
1366 float fn = (float)(zfar - znear);
1367
1368 matFrustum.m0 = ((float) znear*2.0f)/rl;
1369 matFrustum.m1 = 0.0f;
1370 matFrustum.m2 = 0.0f;
1371 matFrustum.m3 = 0.0f;
1372
1373 matFrustum.m4 = 0.0f;
1374 matFrustum.m5 = ((float) znear*2.0f)/tb;
1375 matFrustum.m6 = 0.0f;
1376 matFrustum.m7 = 0.0f;
1377
1378 matFrustum.m8 = ((float)right + (float)left)/rl;
1379 matFrustum.m9 = ((float)top + (float)bottom)/tb;
1380 matFrustum.m10 = -((float)zfar + (float)znear)/fn;
1381 matFrustum.m11 = -1.0f;
1382
1383 matFrustum.m12 = 0.0f;
1384 matFrustum.m13 = 0.0f;
1385 matFrustum.m14 = -((float)zfar*(float)znear*2.0f)/fn;
1386 matFrustum.m15 = 0.0f;
1387
1388 *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matFrustum);
1389 }
1390
1391 // Multiply the current matrix by an orthographic matrix generated by parameters
1392 void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar)
1393 {
1394 // NOTE: If left-right and top-botton values are equal it could create a division by zero,
1395 // response to it is platform/compiler dependent
1396 Matrix matOrtho = { 0 };
1397
1398 float rl = (float)(right - left);
1399 float tb = (float)(top - bottom);
1400 float fn = (float)(zfar - znear);
1401
1402 matOrtho.m0 = 2.0f/rl;
1403 matOrtho.m1 = 0.0f;
1404 matOrtho.m2 = 0.0f;
1405 matOrtho.m3 = 0.0f;
1406 matOrtho.m4 = 0.0f;
1407 matOrtho.m5 = 2.0f/tb;
1408 matOrtho.m6 = 0.0f;
1409 matOrtho.m7 = 0.0f;
1410 matOrtho.m8 = 0.0f;
1411 matOrtho.m9 = 0.0f;
1412 matOrtho.m10 = -2.0f/fn;
1413 matOrtho.m11 = 0.0f;
1414 matOrtho.m12 = -((float)left + (float)right)/rl;
1415 matOrtho.m13 = -((float)top + (float)bottom)/tb;
1416 matOrtho.m14 = -((float)zfar + (float)znear)/fn;
1417 matOrtho.m15 = 1.0f;
1418
1419 *RLGL.State.currentMatrix = rlMatrixMultiply(*RLGL.State.currentMatrix, matOrtho);
1420 }
1421 #endif
1422
1423 // Set the viewport area (transformation from normalized device coordinates to window coordinates)
1424 void rlViewport(int x, int y, int width, int height)
1425 {
1426 glViewport(x, y, width, height);
1427 }
1428
1429 // Set clip planes distances
1430 void rlSetClipPlanes(double nearPlane, double farPlane)
1431 {
1432 rlCullDistanceNear = nearPlane;
1433 rlCullDistanceFar = farPlane;
1434 }
1435
1436 // Get cull plane distance near
1437 double rlGetCullDistanceNear(void)
1438 {
1439 return rlCullDistanceNear;
1440 }
1441
1442 // Get cull plane distance far
1443 double rlGetCullDistanceFar(void)
1444 {
1445 return rlCullDistanceFar;
1446 }
1447
1448 //----------------------------------------------------------------------------------
1449 // Module Functions Definition - Vertex level operations
1450 //----------------------------------------------------------------------------------
1451 #if defined(GRAPHICS_API_OPENGL_11)
1452 // Fallback to OpenGL 1.1 function calls
1453 //---------------------------------------
1454 void rlBegin(int mode)
1455 {
1456 switch (mode)
1457 {
1458 case RL_LINES: glBegin(GL_LINES); break;
1459 case RL_TRIANGLES: glBegin(GL_TRIANGLES); break;
1460 case RL_QUADS: glBegin(GL_QUADS); break;
1461 default: break;
1462 }
1463 }
1464
1465 void rlEnd(void) { glEnd(); }
1466 void rlVertex2i(int x, int y) { glVertex2i(x, y); }
1467 void rlVertex2f(float x, float y) { glVertex2f(x, y); }
1468 void rlVertex3f(float x, float y, float z) { glVertex3f(x, y, z); }
1469 void rlTexCoord2f(float x, float y) { glTexCoord2f(x, y); }
1470 void rlNormal3f(float x, float y, float z) { glNormal3f(x, y, z); }
1471 void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a) { glColor4ub(r, g, b, a); }
1472 void rlColor3f(float x, float y, float z) { glColor3f(x, y, z); }
1473 void rlColor4f(float x, float y, float z, float w) { glColor4f(x, y, z, w); }
1474 #endif
1475 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
1476 // Initialize drawing mode (how to organize vertex)
1477 void rlBegin(int mode)
1478 {
1479 // Draw mode can be RL_LINES, RL_TRIANGLES and RL_QUADS
1480 // NOTE: In all three cases, vertex are accumulated over default internal vertex buffer
1481 if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode != mode)
1482 {
1483 if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0)
1484 {
1485 // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4,
1486 // that way, following QUADS drawing will keep aligned with index processing
1487 // It implies adding some extra alignment vertex at the end of the draw,
1488 // those vertex are not processed but they are considered as an additional offset
1489 // for the next set of vertex to be drawn
1490 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);
1491 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)));
1492 else RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = 0;
1493
1494 if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment))
1495 {
1496 RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment;
1497 RLGL.currentBatch->drawCounter++;
1498 }
1499 }
1500
1501 if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch);
1502
1503 RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = mode;
1504 RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = RLGL.State.currentTextureId;
1505 RLGL.State.currentTextureId = RLGL.State.defaultTextureId;
1506 }
1507 }
1508
1509 // Finish vertex providing
1510 void rlEnd(void)
1511 {
1512 // NOTE: Depth increment is dependent on rlOrtho(): z-near and z-far values,
1513 // as well as depth buffer bit-depth (16bit or 24bit or 32bit)
1514 // Correct increment formula would be: depthInc = (zfar - znear)/pow(2, bits)
1515 RLGL.currentBatch->currentDepth += (1.0f/20000.0f);
1516 }
1517
1518 // Define one vertex (position)
1519 // NOTE: Vertex position data is the basic information required for drawing
1520 void rlVertex3f(float x, float y, float z)
1521 {
1522 float tx = x;
1523 float ty = y;
1524 float tz = z;
1525
1526 // Transform provided vector if required
1527 if (RLGL.State.transformRequired)
1528 {
1529 tx = RLGL.State.transform.m0*x + RLGL.State.transform.m4*y + RLGL.State.transform.m8*z + RLGL.State.transform.m12;
1530 ty = RLGL.State.transform.m1*x + RLGL.State.transform.m5*y + RLGL.State.transform.m9*z + RLGL.State.transform.m13;
1531 tz = RLGL.State.transform.m2*x + RLGL.State.transform.m6*y + RLGL.State.transform.m10*z + RLGL.State.transform.m14;
1532 }
1533
1534 // WARNING: Be careful with primitives breaking when launching a new batch!
1535 // RL_LINES comes in pairs, RL_TRIANGLES come in groups of 3 vertices and RL_QUADS come in groups of 4 vertices
1536 // Checking current draw.mode when a new vertex is required and finish the batch only if the draw.mode draw.vertexCount is %2, %3 or %4
1537 if (RLGL.State.vertexCounter > (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4 - 4))
1538 {
1539 if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) &&
1540 (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%2 == 0))
1541 {
1542 // Reached the maximum number of vertices for RL_LINES drawing
1543 // Launch a draw call but keep current state for next vertices comming
1544 // NOTE: Adding +1 vertex to the check for some safety
1545 rlCheckRenderBatchLimit(2 + 1);
1546 }
1547 else if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) &&
1548 (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%3 == 0))
1549 {
1550 rlCheckRenderBatchLimit(3 + 1);
1551 }
1552 else if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_QUADS) &&
1553 (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4 == 0))
1554 {
1555 rlCheckRenderBatchLimit(4 + 1);
1556 }
1557 }
1558
1559 // Add vertices
1560 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter] = tx;
1561 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter + 1] = ty;
1562 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].vertices[3*RLGL.State.vertexCounter + 2] = tz;
1563
1564 // Add current texcoord
1565 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].texcoords[2*RLGL.State.vertexCounter] = RLGL.State.texcoordx;
1566 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].texcoords[2*RLGL.State.vertexCounter + 1] = RLGL.State.texcoordy;
1567
1568 // Add current normal
1569 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].normals[3*RLGL.State.vertexCounter] = RLGL.State.normalx;
1570 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].normals[3*RLGL.State.vertexCounter + 1] = RLGL.State.normaly;
1571 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].normals[3*RLGL.State.vertexCounter + 2] = RLGL.State.normalz;
1572
1573 // Add current color
1574 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter] = RLGL.State.colorr;
1575 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 1] = RLGL.State.colorg;
1576 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 2] = RLGL.State.colorb;
1577 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].colors[4*RLGL.State.vertexCounter + 3] = RLGL.State.colora;
1578
1579 RLGL.State.vertexCounter++;
1580 RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount++;
1581 }
1582
1583 // Define one vertex (position)
1584 void rlVertex2f(float x, float y)
1585 {
1586 rlVertex3f(x, y, RLGL.currentBatch->currentDepth);
1587 }
1588
1589 // Define one vertex (position)
1590 void rlVertex2i(int x, int y)
1591 {
1592 rlVertex3f((float)x, (float)y, RLGL.currentBatch->currentDepth);
1593 }
1594
1595 // Define one vertex (texture coordinate)
1596 // NOTE: Texture coordinates are limited to QUADS only
1597 void rlTexCoord2f(float x, float y)
1598 {
1599 RLGL.State.texcoordx = x;
1600 RLGL.State.texcoordy = y;
1601 }
1602
1603 // Define one vertex (normal)
1604 // NOTE: Normals limited to TRIANGLES only?
1605 void rlNormal3f(float x, float y, float z)
1606 {
1607 float normalx = x;
1608 float normaly = y;
1609 float normalz = z;
1610 if (RLGL.State.transformRequired)
1611 {
1612 normalx = RLGL.State.transform.m0*x + RLGL.State.transform.m4*y + RLGL.State.transform.m8*z;
1613 normaly = RLGL.State.transform.m1*x + RLGL.State.transform.m5*y + RLGL.State.transform.m9*z;
1614 normalz = RLGL.State.transform.m2*x + RLGL.State.transform.m6*y + RLGL.State.transform.m10*z;
1615 }
1616
1617 // NOTE: Default behavior assumes the normal vector is in the correct space for what the shader expects,
1618 // it could be not normalized to 0.0f..1.0f, magnitud can be useed for some effects
1619 /*
1620 // WARNING: Vector normalization if required
1621 float length = sqrtf(normalx*normalx + normaly*normaly + normalz*normalz);
1622 if (length != 0.0f)
1623 {
1624 float ilength = 1.0f/length;
1625 normalx *= ilength;
1626 normaly *= ilength;
1627 normalz *= ilength;
1628 }
1629 */
1630 RLGL.State.normalx = normalx;
1631 RLGL.State.normaly = normaly;
1632 RLGL.State.normalz = normalz;
1633 }
1634
1635 // Define one vertex (color)
1636 void rlColor4ub(unsigned char x, unsigned char y, unsigned char z, unsigned char w)
1637 {
1638 RLGL.State.colorr = x;
1639 RLGL.State.colorg = y;
1640 RLGL.State.colorb = z;
1641 RLGL.State.colora = w;
1642 }
1643
1644 // Define one vertex (color)
1645 void rlColor4f(float r, float g, float b, float a)
1646 {
1647 rlColor4ub((unsigned char)(r*255), (unsigned char)(g*255), (unsigned char)(b*255), (unsigned char)(a*255));
1648 }
1649
1650 // Define one vertex (color)
1651 void rlColor3f(float x, float y, float z)
1652 {
1653 rlColor4ub((unsigned char)(x*255), (unsigned char)(y*255), (unsigned char)(z*255), 255);
1654 }
1655
1656 #endif
1657
1658 //--------------------------------------------------------------------------------------
1659 // Module Functions Definition - OpenGL style functions (common to 1.1, 3.3+, ES2)
1660 //--------------------------------------------------------------------------------------
1661
1662 // Set current texture to use
1663 void rlSetTexture(unsigned int id)
1664 {
1665 if (id == 0)
1666 {
1667 #if defined(GRAPHICS_API_OPENGL_11)
1668 rlDisableTexture();
1669 #else
1670 // NOTE: If quads batch limit is reached, force a draw call and next batch starts
1671 if (RLGL.State.vertexCounter >=
1672 RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4)
1673 {
1674 rlDrawRenderBatch(RLGL.currentBatch);
1675 }
1676 RLGL.State.currentTextureId = RLGL.State.defaultTextureId;
1677 #endif
1678 }
1679 else
1680 {
1681 #if defined(GRAPHICS_API_OPENGL_11)
1682 rlEnableTexture(id);
1683 #else
1684 RLGL.State.currentTextureId = id;
1685 if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId != id)
1686 {
1687 if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0)
1688 {
1689 // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4,
1690 // that way, following QUADS drawing will keep aligned with index processing
1691 // It implies adding some extra alignment vertex at the end of the draw,
1692 // those vertex are not processed but they are considered as an additional offset
1693 // for the next set of vertex to be drawn
1694 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);
1695 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)));
1696 else RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = 0;
1697
1698 if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment))
1699 {
1700 RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment;
1701
1702 RLGL.currentBatch->drawCounter++;
1703
1704 RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 2].mode;
1705
1706 }
1707 }
1708
1709 if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch);
1710
1711 RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = id;
1712 RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount = 0;
1713 }
1714 #endif
1715 }
1716 }
1717
1718 // Select and active a texture slot
1719 void rlActiveTextureSlot(int slot)
1720 {
1721 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
1722 glActiveTexture(GL_TEXTURE0 + slot);
1723 #endif
1724 }
1725
1726 // Enable texture
1727 void rlEnableTexture(unsigned int id)
1728 {
1729 #if defined(GRAPHICS_API_OPENGL_11)
1730 glEnable(GL_TEXTURE_2D);
1731 #endif
1732 glBindTexture(GL_TEXTURE_2D, id);
1733 }
1734
1735 // Disable texture
1736 void rlDisableTexture(void)
1737 {
1738 #if defined(GRAPHICS_API_OPENGL_11)
1739 glDisable(GL_TEXTURE_2D);
1740 #endif
1741 glBindTexture(GL_TEXTURE_2D, 0);
1742 }
1743
1744 // Enable texture cubemap
1745 void rlEnableTextureCubemap(unsigned int id)
1746 {
1747 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
1748 glBindTexture(GL_TEXTURE_CUBE_MAP, id);
1749 #endif
1750 }
1751
1752 // Disable texture cubemap
1753 void rlDisableTextureCubemap(void)
1754 {
1755 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
1756 glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
1757 #endif
1758 }
1759
1760 // Set texture parameters (wrap mode/filter mode)
1761 void rlTextureParameters(unsigned int id, int param, int value)
1762 {
1763 glBindTexture(GL_TEXTURE_2D, id);
1764
1765 switch (param)
1766 {
1767 case RL_TEXTURE_WRAP_S:
1768 case RL_TEXTURE_WRAP_T:
1769 {
1770 if (value == RL_TEXTURE_WRAP_MIRROR_CLAMP)
1771 {
1772 #if !defined(GRAPHICS_API_OPENGL_11)
1773 if (RLGL.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_2D, param, value);
1774 else TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)");
1775 #endif
1776 }
1777 else glTexParameteri(GL_TEXTURE_2D, param, value);
1778 } break;
1779 case RL_TEXTURE_MAG_FILTER:
1780 case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_2D, param, value); break;
1781 case RL_TEXTURE_FILTER_ANISOTROPIC:
1782 {
1783 #if !defined(GRAPHICS_API_OPENGL_11)
1784 // Reset anisotropy filter, in case it was set
1785 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
1786
1787 if (value <= RLGL.ExtSupported.maxAnisotropyLevel) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value);
1788 else if (RLGL.ExtSupported.maxAnisotropyLevel > 0.0f)
1789 {
1790 TRACELOG(RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, (int)RLGL.ExtSupported.maxAnisotropyLevel);
1791 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value);
1792 }
1793 else TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported");
1794 #endif
1795 } break;
1796 #if defined(GRAPHICS_API_OPENGL_33)
1797 case RL_TEXTURE_MIPMAP_BIAS_RATIO: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, value/100.0f);
1798 #endif
1799 default: break;
1800 }
1801
1802 glBindTexture(GL_TEXTURE_2D, 0);
1803 }
1804
1805 // Set cubemap parameters (wrap mode/filter mode)
1806 void rlCubemapParameters(unsigned int id, int param, int value)
1807 {
1808 #if !defined(GRAPHICS_API_OPENGL_11)
1809 glBindTexture(GL_TEXTURE_CUBE_MAP, id);
1810
1811 // Reset anisotropy filter, in case it was set
1812 glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
1813
1814 switch (param)
1815 {
1816 case RL_TEXTURE_WRAP_S:
1817 case RL_TEXTURE_WRAP_T:
1818 {
1819 if (value == RL_TEXTURE_WRAP_MIRROR_CLAMP)
1820 {
1821 if (RLGL.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value);
1822 else TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)");
1823 }
1824 else glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value);
1825 } break;
1826 case RL_TEXTURE_MAG_FILTER:
1827 case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); break;
1828 case RL_TEXTURE_FILTER_ANISOTROPIC:
1829 {
1830 if (value <= RLGL.ExtSupported.maxAnisotropyLevel) glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value);
1831 else if (RLGL.ExtSupported.maxAnisotropyLevel > 0.0f)
1832 {
1833 TRACELOG(RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, (int)RLGL.ExtSupported.maxAnisotropyLevel);
1834 glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value);
1835 }
1836 else TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported");
1837 } break;
1838 #if defined(GRAPHICS_API_OPENGL_33)
1839 case RL_TEXTURE_MIPMAP_BIAS_RATIO: glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_LOD_BIAS, value/100.0f);
1840 #endif
1841 default: break;
1842 }
1843
1844 glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
1845 #endif
1846 }
1847
1848 // Enable shader program
1849 void rlEnableShader(unsigned int id)
1850 {
1851 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
1852 glUseProgram(id);
1853 #endif
1854 }
1855
1856 // Disable shader program
1857 void rlDisableShader(void)
1858 {
1859 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
1860 glUseProgram(0);
1861 #endif
1862 }
1863
1864 // Enable rendering to texture (fbo)
1865 void rlEnableFramebuffer(unsigned int id)
1866 {
1867 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
1868 glBindFramebuffer(GL_FRAMEBUFFER, id);
1869 #endif
1870 }
1871
1872 // return the active render texture (fbo)
1873 unsigned int rlGetActiveFramebuffer(void)
1874 {
1875 GLint fboId = 0;
1876 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
1877 glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &fboId);
1878 #endif
1879 return fboId;
1880 }
1881
1882 // Disable rendering to texture
1883 void rlDisableFramebuffer(void)
1884 {
1885 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
1886 glBindFramebuffer(GL_FRAMEBUFFER, 0);
1887 #endif
1888 }
1889
1890 // Blit active framebuffer to main framebuffer
1891 void rlBlitFramebuffer(int srcX, int srcY, int srcWidth, int srcHeight, int dstX, int dstY, int dstWidth, int dstHeight, int bufferMask)
1892 {
1893 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3))
1894 glBlitFramebuffer(srcX, srcY, srcWidth, srcHeight, dstX, dstY, dstWidth, dstHeight, bufferMask, GL_NEAREST);
1895 #endif
1896 }
1897
1898 // Bind framebuffer object (fbo)
1899 void rlBindFramebuffer(unsigned int target, unsigned int framebuffer)
1900 {
1901 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
1902 glBindFramebuffer(target, framebuffer);
1903 #endif
1904 }
1905
1906 // Activate multiple draw color buffers
1907 // NOTE: One color buffer is always active by default
1908 void rlActiveDrawBuffers(int count)
1909 {
1910 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3))
1911 // NOTE: Maximum number of draw buffers supported is implementation dependent,
1912 // it can be queried with glGet*() but it must be at least 8
1913 //GLint maxDrawBuffers = 0;
1914 //glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
1915
1916 if (count > 0)
1917 {
1918 if (count > 8) TRACELOG(RL_LOG_WARNING, "GL: Max color buffers limited to 8");
1919 else
1920 {
1921 unsigned int buffers[8] = {
1922 GL_COLOR_ATTACHMENT0,
1923 GL_COLOR_ATTACHMENT1,
1924 GL_COLOR_ATTACHMENT2,
1925 GL_COLOR_ATTACHMENT3,
1926 GL_COLOR_ATTACHMENT4,
1927 GL_COLOR_ATTACHMENT5,
1928 GL_COLOR_ATTACHMENT6,
1929 GL_COLOR_ATTACHMENT7,
1930 };
1931
1932 glDrawBuffers(count, buffers);
1933 }
1934 }
1935 else TRACELOG(RL_LOG_WARNING, "GL: One color buffer active by default");
1936 #endif
1937 }
1938
1939 //----------------------------------------------------------------------------------
1940 // General render state configuration
1941 //----------------------------------------------------------------------------------
1942
1943 // Enable color blending
1944 void rlEnableColorBlend(void) { glEnable(GL_BLEND); }
1945
1946 // Disable color blending
1947 void rlDisableColorBlend(void) { glDisable(GL_BLEND); }
1948
1949 // Enable depth test
1950 void rlEnableDepthTest(void) { glEnable(GL_DEPTH_TEST); }
1951
1952 // Disable depth test
1953 void rlDisableDepthTest(void) { glDisable(GL_DEPTH_TEST); }
1954
1955 // Enable depth write
1956 void rlEnableDepthMask(void) { glDepthMask(GL_TRUE); }
1957
1958 // Disable depth write
1959 void rlDisableDepthMask(void) { glDepthMask(GL_FALSE); }
1960
1961 // Enable backface culling
1962 void rlEnableBackfaceCulling(void) { glEnable(GL_CULL_FACE); }
1963
1964 // Disable backface culling
1965 void rlDisableBackfaceCulling(void) { glDisable(GL_CULL_FACE); }
1966
1967 // Set color mask active for screen read/draw
1968 void rlColorMask(bool r, bool g, bool b, bool a) { glColorMask(r, g, b, a); }
1969
1970 // Set face culling mode
1971 void rlSetCullFace(int mode)
1972 {
1973 switch (mode)
1974 {
1975 case RL_CULL_FACE_BACK: glCullFace(GL_BACK); break;
1976 case RL_CULL_FACE_FRONT: glCullFace(GL_FRONT); break;
1977 default: break;
1978 }
1979 }
1980
1981 // Enable scissor test
1982 void rlEnableScissorTest(void) { glEnable(GL_SCISSOR_TEST); }
1983
1984 // Disable scissor test
1985 void rlDisableScissorTest(void) { glDisable(GL_SCISSOR_TEST); }
1986
1987 // Scissor test
1988 void rlScissor(int x, int y, int width, int height) { glScissor(x, y, width, height); }
1989
1990 // Enable wire mode
1991 void rlEnableWireMode(void)
1992 {
1993 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
1994 // NOTE: glPolygonMode() not available on OpenGL ES
1995 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
1996 #endif
1997 }
1998
1999 // Disable wire mode
2000 void rlDisableWireMode(void)
2001 {
2002 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
2003 // NOTE: glPolygonMode() not available on OpenGL ES
2004 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
2005 #endif
2006 }
2007
2008 // Enable point mode
2009 void rlEnablePointMode(void)
2010 {
2011 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
2012 // NOTE: glPolygonMode() not available on OpenGL ES
2013 glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
2014 glEnable(GL_PROGRAM_POINT_SIZE);
2015 #endif
2016 }
2017
2018 // Disable point mode
2019 void rlDisablePointMode(void)
2020 {
2021 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
2022 // NOTE: glPolygonMode() not available on OpenGL ES
2023 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
2024 #endif
2025 }
2026
2027 // Set the line drawing width
2028 void rlSetLineWidth(float width) { glLineWidth(width); }
2029
2030 // Get the line drawing width
2031 float rlGetLineWidth(void)
2032 {
2033 float width = 0;
2034 glGetFloatv(GL_LINE_WIDTH, &width);
2035 return width;
2036 }
2037
2038 // Set the point drawing size
2039 void rlSetPointSize(float size)
2040 {
2041 #if defined(GRAPHICS_API_OPENGL_11)
2042 glPointSize(size);
2043 #endif
2044 }
2045
2046 // Get the point drawing size
2047 float rlGetPointSize(void)
2048 {
2049 float size = 1;
2050 #if defined(GRAPHICS_API_OPENGL_11)
2051 glGetFloatv(GL_POINT_SIZE, &size);
2052 #endif
2053 return size;
2054
2055 }
2056
2057 // Enable line aliasing
2058 void rlEnableSmoothLines(void)
2059 {
2060 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11)
2061 glEnable(GL_LINE_SMOOTH);
2062 #endif
2063 }
2064
2065 // Disable line aliasing
2066 void rlDisableSmoothLines(void)
2067 {
2068 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11)
2069 glDisable(GL_LINE_SMOOTH);
2070 #endif
2071 }
2072
2073 // Enable stereo rendering
2074 void rlEnableStereoRender(void)
2075 {
2076 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
2077 RLGL.State.stereoRender = true;
2078 #endif
2079 }
2080
2081 // Disable stereo rendering
2082 void rlDisableStereoRender(void)
2083 {
2084 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
2085 RLGL.State.stereoRender = false;
2086 #endif
2087 }
2088
2089 // Check if stereo render is enabled
2090 bool rlIsStereoRenderEnabled(void)
2091 {
2092 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2))
2093 return RLGL.State.stereoRender;
2094 #else
2095 return false;
2096 #endif
2097 }
2098
2099 // Clear color buffer with color
2100 void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
2101 {
2102 // Color values clamp to 0.0f(0) and 1.0f(255)
2103 float cr = (float)r/255;
2104 float cg = (float)g/255;
2105 float cb = (float)b/255;
2106 float ca = (float)a/255;
2107
2108 glClearColor(cr, cg, cb, ca);
2109 }
2110
2111 // Clear used screen buffers (color and depth)
2112 void rlClearScreenBuffers(void)
2113 {
2114 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear used buffers: Color and Depth (Depth is used for 3D)
2115 //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); // Stencil buffer not used...
2116 }
2117
2118 // Check and log OpenGL error codes
2119 void rlCheckErrors(void)
2120 {
2121 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2122 int check = 1;
2123 while (check)
2124 {
2125 const GLenum err = glGetError();
2126 switch (err)
2127 {
2128 case GL_NO_ERROR: check = 0; break;
2129 case 0x0500: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_ENUM"); break;
2130 case 0x0501: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_VALUE"); break;
2131 case 0x0502: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_OPERATION"); break;
2132 case 0x0503: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_OVERFLOW"); break;
2133 case 0x0504: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_UNDERFLOW"); break;
2134 case 0x0505: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_OUT_OF_MEMORY"); break;
2135 case 0x0506: TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_FRAMEBUFFER_OPERATION"); break;
2136 default: TRACELOG(RL_LOG_WARNING, "GL: Error detected: Unknown error code: %x", err); break;
2137 }
2138 }
2139 #endif
2140 }
2141
2142 // Set blend mode
2143 void rlSetBlendMode(int mode)
2144 {
2145 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2146 if ((RLGL.State.currentBlendMode != mode) || ((mode == RL_BLEND_CUSTOM || mode == RL_BLEND_CUSTOM_SEPARATE) && RLGL.State.glCustomBlendModeModified))
2147 {
2148 rlDrawRenderBatch(RLGL.currentBatch);
2149
2150 switch (mode)
2151 {
2152 case RL_BLEND_ALPHA: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
2153 case RL_BLEND_ADDITIVE: glBlendFunc(GL_SRC_ALPHA, GL_ONE); glBlendEquation(GL_FUNC_ADD); break;
2154 case RL_BLEND_MULTIPLIED: glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
2155 case RL_BLEND_ADD_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_ADD); break;
2156 case RL_BLEND_SUBTRACT_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_SUBTRACT); break;
2157 case RL_BLEND_ALPHA_PREMULTIPLY: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break;
2158 case RL_BLEND_CUSTOM:
2159 {
2160 // NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactors()
2161 glBlendFunc(RLGL.State.glBlendSrcFactor, RLGL.State.glBlendDstFactor); glBlendEquation(RLGL.State.glBlendEquation);
2162 } break;
2163 case RL_BLEND_CUSTOM_SEPARATE:
2164 {
2165 // NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactorsSeparate()
2166 glBlendFuncSeparate(RLGL.State.glBlendSrcFactorRGB, RLGL.State.glBlendDestFactorRGB, RLGL.State.glBlendSrcFactorAlpha, RLGL.State.glBlendDestFactorAlpha);
2167 glBlendEquationSeparate(RLGL.State.glBlendEquationRGB, RLGL.State.glBlendEquationAlpha);
2168 } break;
2169 default: break;
2170 }
2171
2172 RLGL.State.currentBlendMode = mode;
2173 RLGL.State.glCustomBlendModeModified = false;
2174 }
2175 #endif
2176 }
2177
2178 // Set blending mode factor and equation
2179 void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation)
2180 {
2181 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2182 if ((RLGL.State.glBlendSrcFactor != glSrcFactor) ||
2183 (RLGL.State.glBlendDstFactor != glDstFactor) ||
2184 (RLGL.State.glBlendEquation != glEquation))
2185 {
2186 RLGL.State.glBlendSrcFactor = glSrcFactor;
2187 RLGL.State.glBlendDstFactor = glDstFactor;
2188 RLGL.State.glBlendEquation = glEquation;
2189
2190 RLGL.State.glCustomBlendModeModified = true;
2191 }
2192 #endif
2193 }
2194
2195 // Set blending mode factor and equation separately for RGB and alpha
2196 void rlSetBlendFactorsSeparate(int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB, int glEqAlpha)
2197 {
2198 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2199 if ((RLGL.State.glBlendSrcFactorRGB != glSrcRGB) ||
2200 (RLGL.State.glBlendDestFactorRGB != glDstRGB) ||
2201 (RLGL.State.glBlendSrcFactorAlpha != glSrcAlpha) ||
2202 (RLGL.State.glBlendDestFactorAlpha != glDstAlpha) ||
2203 (RLGL.State.glBlendEquationRGB != glEqRGB) ||
2204 (RLGL.State.glBlendEquationAlpha != glEqAlpha))
2205 {
2206 RLGL.State.glBlendSrcFactorRGB = glSrcRGB;
2207 RLGL.State.glBlendDestFactorRGB = glDstRGB;
2208 RLGL.State.glBlendSrcFactorAlpha = glSrcAlpha;
2209 RLGL.State.glBlendDestFactorAlpha = glDstAlpha;
2210 RLGL.State.glBlendEquationRGB = glEqRGB;
2211 RLGL.State.glBlendEquationAlpha = glEqAlpha;
2212
2213 RLGL.State.glCustomBlendModeModified = true;
2214 }
2215 #endif
2216 }
2217
2218 //----------------------------------------------------------------------------------
2219 // Module Functions Definition - OpenGL Debug
2220 //----------------------------------------------------------------------------------
2221 #if defined(GRAPHICS_API_OPENGL_43) && RLGL_ENABLE_OPENGL_DEBUG_CONTEXT
2222 static void GLAPIENTRY rlDebugMessageCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam)
2223 {
2224 // Ignore non-significant error/warning codes (NVidia drivers)
2225 // NOTE: Here there are the details with a sample output:
2226 // - #131169 - Framebuffer detailed info: The driver allocated storage for renderbuffer 2. (severity: low)
2227 // - #131185 - Buffer detailed info: Buffer object 1 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_ENUM_88e4)
2228 // will use VIDEO memory as the source for buffer object operations. (severity: low)
2229 // - #131218 - Program/shader state performance warning: Vertex shader in program 7 is being recompiled based on GL state. (severity: medium)
2230 // - #131204 - Texture state usage warning: The texture object (0) bound to texture image unit 0 does not have
2231 // a defined base level and cannot be used for texture mapping. (severity: low)
2232 if ((id == 131169) || (id == 131185) || (id == 131218) || (id == 131204)) return;
2233
2234 const char *msgSource = NULL;
2235 switch (source)
2236 {
2237 case GL_DEBUG_SOURCE_API: msgSource = "API"; break;
2238 case GL_DEBUG_SOURCE_WINDOW_SYSTEM: msgSource = "WINDOW_SYSTEM"; break;
2239 case GL_DEBUG_SOURCE_SHADER_COMPILER: msgSource = "SHADER_COMPILER"; break;
2240 case GL_DEBUG_SOURCE_THIRD_PARTY: msgSource = "THIRD_PARTY"; break;
2241 case GL_DEBUG_SOURCE_APPLICATION: msgSource = "APPLICATION"; break;
2242 case GL_DEBUG_SOURCE_OTHER: msgSource = "OTHER"; break;
2243 default: break;
2244 }
2245
2246 const char *msgType = NULL;
2247 switch (type)
2248 {
2249 case GL_DEBUG_TYPE_ERROR: msgType = "ERROR"; break;
2250 case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: msgType = "DEPRECATED_BEHAVIOR"; break;
2251 case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: msgType = "UNDEFINED_BEHAVIOR"; break;
2252 case GL_DEBUG_TYPE_PORTABILITY: msgType = "PORTABILITY"; break;
2253 case GL_DEBUG_TYPE_PERFORMANCE: msgType = "PERFORMANCE"; break;
2254 case GL_DEBUG_TYPE_MARKER: msgType = "MARKER"; break;
2255 case GL_DEBUG_TYPE_PUSH_GROUP: msgType = "PUSH_GROUP"; break;
2256 case GL_DEBUG_TYPE_POP_GROUP: msgType = "POP_GROUP"; break;
2257 case GL_DEBUG_TYPE_OTHER: msgType = "OTHER"; break;
2258 default: break;
2259 }
2260
2261 const char *msgSeverity = "DEFAULT";
2262 switch (severity)
2263 {
2264 case GL_DEBUG_SEVERITY_LOW: msgSeverity = "LOW"; break;
2265 case GL_DEBUG_SEVERITY_MEDIUM: msgSeverity = "MEDIUM"; break;
2266 case GL_DEBUG_SEVERITY_HIGH: msgSeverity = "HIGH"; break;
2267 case GL_DEBUG_SEVERITY_NOTIFICATION: msgSeverity = "NOTIFICATION"; break;
2268 default: break;
2269 }
2270
2271 TRACELOG(RL_LOG_WARNING, "GL: OpenGL debug message: %s", message);
2272 TRACELOG(RL_LOG_WARNING, " > Type: %s", msgType);
2273 TRACELOG(RL_LOG_WARNING, " > Source = %s", msgSource);
2274 TRACELOG(RL_LOG_WARNING, " > Severity = %s", msgSeverity);
2275 }
2276 #endif
2277
2278 //----------------------------------------------------------------------------------
2279 // Module Functions Definition - rlgl functionality
2280 //----------------------------------------------------------------------------------
2281
2282 // Initialize rlgl: OpenGL extensions, default buffers/shaders/textures, OpenGL states
2283 void rlglInit(int width, int height)
2284 {
2285 isGpuReady = true;
2286
2287 // Enable OpenGL debug context if requested (and supported)
2288 #if defined(GRAPHICS_API_OPENGL_43) && RLGL_ENABLE_OPENGL_DEBUG_CONTEXT
2289 if ((glDebugMessageCallback != NULL) && (glDebugMessageControl != NULL))
2290 {
2291 glDebugMessageCallback(rlDebugMessageCallback, 0);
2292 // glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, GL_DEBUG_SEVERITY_HIGH, 0, 0, GL_TRUE);
2293
2294 // Debug context options:
2295 // - GL_DEBUG_OUTPUT - Faster version but not useful for breakpoints
2296 // - 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
2297 glEnable(GL_DEBUG_OUTPUT);
2298 glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
2299 }
2300 #endif
2301
2302 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2303 // Init default white texture
2304 unsigned char pixels[4] = { 255, 255, 255, 255 }; // 1 pixel RGBA (4 bytes)
2305 RLGL.State.defaultTextureId = rlLoadTexture(pixels, 1, 1, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1);
2306 RLGL.State.currentTextureId = RLGL.State.defaultTextureId;
2307
2308 if (RLGL.State.defaultTextureId != 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture loaded successfully", RLGL.State.defaultTextureId);
2309 else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load default texture");
2310
2311 // Init default Shader (customized for GL 3.3 and ES2)
2312 // Loaded: RLGL.State.defaultShaderId + RLGL.State.defaultShaderLocs
2313 rlLoadShaderDefault();
2314 RLGL.State.currentShaderId = RLGL.State.defaultShaderId;
2315 RLGL.State.currentShaderLocs = RLGL.State.defaultShaderLocs;
2316
2317 // Init default vertex arrays buffers
2318 // Simulate that the default shader has the location RL_SHADER_LOC_VERTEX_NORMAL to bind the normal buffer for the default render batch
2319 RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_NORMAL] = RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL;
2320 RLGL.defaultBatch = rlLoadRenderBatch(RL_DEFAULT_BATCH_BUFFERS, RL_DEFAULT_BATCH_BUFFER_ELEMENTS);
2321 RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_NORMAL] = -1;
2322 RLGL.currentBatch = &RLGL.defaultBatch;
2323
2324 // Init stack matrices (emulating OpenGL 1.1)
2325 for (int i = 0; i < RL_MAX_MATRIX_STACK_SIZE; i++) RLGL.State.stack[i] = rlMatrixIdentity();
2326
2327 // Init internal matrices
2328 RLGL.State.transform = rlMatrixIdentity();
2329 RLGL.State.projection = rlMatrixIdentity();
2330 RLGL.State.modelview = rlMatrixIdentity();
2331 RLGL.State.currentMatrix = &RLGL.State.modelview;
2332 #endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
2333
2334 #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
2335 // Initialize software renderer backend
2336 int result = swInit(width, height);
2337 if (result == 0)
2338 {
2339 TRACELOG(RL_LOG_ERROR, "RLSW: Software renderer initialization failed!");
2340 exit(-1);
2341 }
2342 #endif
2343
2344 // Initialize OpenGL default states
2345 //----------------------------------------------------------
2346 // Init state: Depth test
2347 glDepthFunc(GL_LEQUAL); // Type of depth testing to apply
2348 glDisable(GL_DEPTH_TEST); // Disable depth testing for 2D (only used for 3D)
2349
2350 // Init state: Blending mode
2351 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Color blending function (how colors are mixed)
2352 glEnable(GL_BLEND); // Enable color blending (required to work with transparencies)
2353
2354 // Init state: Culling
2355 // NOTE: All shapes/models triangles are drawn CCW
2356 glCullFace(GL_BACK); // Cull the back face (default)
2357 glFrontFace(GL_CCW); // Front face are defined counter clockwise (default)
2358 glEnable(GL_CULL_FACE); // Enable backface culling
2359
2360 #if defined(GRAPHICS_API_OPENGL_11)
2361 // Init state: Color hints (deprecated in OpenGL 3.0+)
2362 glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Improve quality of color and texture coordinate interpolation
2363 glShadeModel(GL_SMOOTH); // Smooth shading between vertex (vertex colors interpolation)
2364 #endif
2365 #if defined(GRAPHICS_API_OPENGL_33)
2366 // Init state: Cubemap seamless
2367 glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS); // Seamless cubemaps (not supported on OpenGL ES 2.0)
2368 #endif
2369 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2370 // Store screen size into global variables
2371 RLGL.State.framebufferWidth = width;
2372 RLGL.State.framebufferHeight = height;
2373 #endif
2374
2375 // Init state: Color/Depth buffers clear
2376 glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Set clear color (black)
2377 glClearDepth(1.0f); // Set clear depth value (default)
2378 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear color and depth buffers (depth buffer required for 3D)
2379
2380 TRACELOG(RL_LOG_INFO, "RLGL: Default OpenGL state initialized successfully");
2381 //----------------------------------------------------------
2382 }
2383
2384 // Vertex Buffer Object deinitialization (memory free)
2385 void rlglClose(void)
2386 {
2387 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2388 rlUnloadRenderBatch(RLGL.defaultBatch);
2389
2390 rlUnloadShaderDefault(); // Unload default shader
2391
2392 glDeleteTextures(1, &RLGL.State.defaultTextureId); // Unload default texture
2393 TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture unloaded successfully", RLGL.State.defaultTextureId);
2394 #endif
2395
2396 #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
2397 swClose(); // Unload sofware renderer resources
2398 #endif
2399 isGpuReady = false;
2400 }
2401
2402 // Load OpenGL extensions
2403 // NOTE: External loader function must be provided
2404 void rlLoadExtensions(void *loader)
2405 {
2406 #if defined(GRAPHICS_API_OPENGL_33) // Also defined for GRAPHICS_API_OPENGL_21
2407 // NOTE: glad is generated and contains only required OpenGL 3.3 Core extensions (and lower versions)
2408 if (gladLoadGL((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL extensions");
2409 else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL extensions loaded successfully");
2410
2411 // Get number of supported extensions
2412 GLint numExt = 0;
2413 glGetIntegerv(GL_NUM_EXTENSIONS, &numExt);
2414 TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt);
2415
2416 #if RLGL_SHOW_GL_DETAILS_INFO
2417 // Get supported extensions list
2418 // WARNING: glGetStringi() not available on OpenGL 2.1
2419 TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:");
2420 for (int i = 0; i < numExt; i++) TRACELOG(RL_LOG_INFO, " %s", glGetStringi(GL_EXTENSIONS, i));
2421 #endif
2422
2423 #if defined(GRAPHICS_API_OPENGL_21)
2424 // Register supported extensions flags
2425 // Optional OpenGL 2.1 extensions
2426 RLGL.ExtSupported.vao = GLAD_GL_ARB_vertex_array_object;
2427 RLGL.ExtSupported.instancing = (GLAD_GL_EXT_draw_instanced && GLAD_GL_ARB_instanced_arrays);
2428 RLGL.ExtSupported.texNPOT = GLAD_GL_ARB_texture_non_power_of_two;
2429 RLGL.ExtSupported.texFloat32 = GLAD_GL_ARB_texture_float;
2430 RLGL.ExtSupported.texFloat16 = GLAD_GL_ARB_texture_float;
2431 RLGL.ExtSupported.texDepth = GLAD_GL_ARB_depth_texture;
2432 RLGL.ExtSupported.maxDepthBits = 32;
2433 RLGL.ExtSupported.texAnisoFilter = GLAD_GL_EXT_texture_filter_anisotropic;
2434 RLGL.ExtSupported.texMirrorClamp = GLAD_GL_EXT_texture_mirror_clamp;
2435 #else
2436 // Register supported extensions flags
2437 // OpenGL 3.3 extensions supported by default (core)
2438 RLGL.ExtSupported.vao = true;
2439 RLGL.ExtSupported.instancing = true;
2440 RLGL.ExtSupported.texNPOT = true;
2441 RLGL.ExtSupported.texFloat32 = true;
2442 RLGL.ExtSupported.texFloat16 = true;
2443 RLGL.ExtSupported.texDepth = true;
2444 RLGL.ExtSupported.maxDepthBits = 32;
2445 RLGL.ExtSupported.texAnisoFilter = true;
2446 RLGL.ExtSupported.texMirrorClamp = true;
2447 #endif
2448
2449 // Optional OpenGL 3.3 extensions
2450 RLGL.ExtSupported.texCompASTC = GLAD_GL_KHR_texture_compression_astc_hdr && GLAD_GL_KHR_texture_compression_astc_ldr;
2451 RLGL.ExtSupported.texCompDXT = GLAD_GL_EXT_texture_compression_s3tc; // Texture compression: DXT
2452 RLGL.ExtSupported.texCompETC2 = GLAD_GL_ARB_ES3_compatibility; // Texture compression: ETC2/EAC
2453 #if defined(GRAPHICS_API_OPENGL_43)
2454 RLGL.ExtSupported.computeShader = GLAD_GL_ARB_compute_shader;
2455 RLGL.ExtSupported.ssbo = GLAD_GL_ARB_shader_storage_buffer_object;
2456 #endif
2457
2458 #endif // GRAPHICS_API_OPENGL_33
2459
2460 #if defined(GRAPHICS_API_OPENGL_ES3)
2461 // Register supported extensions flags
2462 // OpenGL ES 3.0 extensions supported by default (or it should be)
2463 RLGL.ExtSupported.vao = true;
2464 RLGL.ExtSupported.instancing = true;
2465 RLGL.ExtSupported.texNPOT = true;
2466 RLGL.ExtSupported.texFloat32 = true;
2467 RLGL.ExtSupported.texFloat16 = true;
2468 RLGL.ExtSupported.texDepth = true;
2469 RLGL.ExtSupported.texDepthWebGL = true;
2470 RLGL.ExtSupported.maxDepthBits = 24;
2471 RLGL.ExtSupported.texAnisoFilter = true;
2472 RLGL.ExtSupported.texMirrorClamp = true;
2473 // TODO: Check for additional OpenGL ES 3.0 supported extensions:
2474 //RLGL.ExtSupported.texCompDXT = true;
2475 //RLGL.ExtSupported.texCompETC1 = true;
2476 //RLGL.ExtSupported.texCompETC2 = true;
2477 //RLGL.ExtSupported.texCompPVRT = true;
2478 //RLGL.ExtSupported.texCompASTC = true;
2479 //RLGL.ExtSupported.maxAnisotropyLevel = true;
2480 //RLGL.ExtSupported.computeShader = true;
2481 //RLGL.ExtSupported.ssbo = true;
2482
2483 #elif defined(GRAPHICS_API_OPENGL_ES2)
2484
2485 #if defined(PLATFORM_DESKTOP_GLFW) || defined(PLATFORM_DESKTOP_SDL)
2486 // TODO: Support GLAD loader for OpenGL ES 3.0
2487 if (gladLoadGLES2((GLADloadfunc)loader) == 0) TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL ES2.0 functions");
2488 else TRACELOG(RL_LOG_INFO, "GLAD: OpenGL ES 2.0 loaded successfully");
2489 #endif
2490
2491 // Get supported extensions list
2492 GLint numExt = 0;
2493 const char **extList = (const char **)RL_CALLOC(512, sizeof(const char *)); // Allocate 512 strings pointers (2 KB)
2494 const char *extensions = (const char *)glGetString(GL_EXTENSIONS); // One big const string
2495
2496 // NOTE: String duplication rquired because glGetString() returns a const string
2497 int extensionsLength = (int)strlen(extensions); // Get extensions string size in bytes
2498 char *extensionsDup = (char *)RL_CALLOC(extensionsLength + 1, sizeof(char)); // Allocate space for copy with additional EOL byte
2499 strncpy(extensionsDup, extensions, extensionsLength);
2500 extList[numExt] = extensionsDup;
2501
2502 for (int i = 0; i < extensionsLength; i++)
2503 {
2504 if (extensionsDup[i] == ' ')
2505 {
2506 extensionsDup[i] = '\0';
2507 numExt++;
2508 extList[numExt] = &extensionsDup[i + 1];
2509 }
2510 }
2511
2512 TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt);
2513
2514 #if RLGL_SHOW_GL_DETAILS_INFO
2515 TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:");
2516 for (int i = 0; i < numExt; i++) TRACELOG(RL_LOG_INFO, " %s", extList[i]);
2517 #endif
2518
2519 // Check required extensions
2520 for (int i = 0; i < numExt; i++)
2521 {
2522 // Check VAO support
2523 // NOTE: Only check on OpenGL ES, OpenGL 3.3 has VAO support as core feature
2524 if (strcmp(extList[i], (const char *)"GL_OES_vertex_array_object") == 0)
2525 {
2526 // The extension is supported by our hardware and driver, try to get related functions pointers
2527 // NOTE: emscripten does not support VAOs natively, it uses emulation and it reduces overall performance...
2528 glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)((rlglLoadProc)loader)("glGenVertexArraysOES");
2529 glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)((rlglLoadProc)loader)("glBindVertexArrayOES");
2530 glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)((rlglLoadProc)loader)("glDeleteVertexArraysOES");
2531 //glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)loader("glIsVertexArrayOES"); // NOTE: Fails in WebGL, omitted
2532
2533 if ((glGenVertexArrays != NULL) && (glBindVertexArray != NULL) && (glDeleteVertexArrays != NULL)) RLGL.ExtSupported.vao = true;
2534 }
2535
2536 // Check instanced rendering support
2537 if (strstr(extList[i], (const char *)"instanced_arrays") != NULL) // Broad check for instanced_arrays
2538 {
2539 // Specific check
2540 if (strcmp(extList[i], (const char *)"GL_ANGLE_instanced_arrays") == 0) // ANGLE
2541 {
2542 glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedANGLE");
2543 glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedANGLE");
2544 glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((rlglLoadProc)loader)("glVertexAttribDivisorANGLE");
2545 }
2546 else if (strcmp(extList[i], (const char *)"GL_EXT_instanced_arrays") == 0) // EXT
2547 {
2548 glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedEXT");
2549 glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedEXT");
2550 glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((rlglLoadProc)loader)("glVertexAttribDivisorEXT");
2551 }
2552 else if (strcmp(extList[i], (const char *)"GL_NV_instanced_arrays") == 0) // NVIDIA GLES
2553 {
2554 glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedNV");
2555 glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedNV");
2556 glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((rlglLoadProc)loader)("glVertexAttribDivisorNV");
2557 }
2558
2559 // The feature will only be marked as supported if the elements from GL_XXX_instanced_arrays are present
2560 if ((glDrawArraysInstanced != NULL) && (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL)) RLGL.ExtSupported.instancing = true;
2561 }
2562 else if (strstr(extList[i], (const char *)"draw_instanced") != NULL)
2563 {
2564 // GL_ANGLE_draw_instanced doesn't exist
2565 if (strcmp(extList[i], (const char *)"GL_EXT_draw_instanced") == 0)
2566 {
2567 glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedEXT");
2568 glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedEXT");
2569 }
2570 else if (strcmp(extList[i], (const char *)"GL_NV_draw_instanced") == 0)
2571 {
2572 glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawArraysInstancedNV");
2573 glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((rlglLoadProc)loader)("glDrawElementsInstancedNV");
2574 }
2575
2576 // But the functions will at least be loaded if only GL_XX_EXT_draw_instanced exist
2577 if ((glDrawArraysInstanced != NULL) && (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL)) RLGL.ExtSupported.instancing = true;
2578 }
2579
2580 // Check NPOT textures support
2581 // NOTE: Only check on OpenGL ES, OpenGL 3.3 has NPOT textures full support as core feature
2582 if (strcmp(extList[i], (const char *)"GL_OES_texture_npot") == 0) RLGL.ExtSupported.texNPOT = true;
2583
2584 // Check texture float support
2585 if (strcmp(extList[i], (const char *)"GL_OES_texture_float") == 0) RLGL.ExtSupported.texFloat32 = true;
2586 if (strcmp(extList[i], (const char *)"GL_OES_texture_half_float") == 0) RLGL.ExtSupported.texFloat16 = true;
2587
2588 // Check depth texture support
2589 if (strcmp(extList[i], (const char *)"GL_OES_depth_texture") == 0) RLGL.ExtSupported.texDepth = true;
2590 if (strcmp(extList[i], (const char *)"GL_WEBGL_depth_texture") == 0) RLGL.ExtSupported.texDepthWebGL = true; // WebGL requires unsized internal format
2591 if (RLGL.ExtSupported.texDepthWebGL) RLGL.ExtSupported.texDepth = true;
2592
2593 if (strcmp(extList[i], (const char *)"GL_OES_depth24") == 0) RLGL.ExtSupported.maxDepthBits = 24; // Not available on WebGL
2594 if (strcmp(extList[i], (const char *)"GL_OES_depth32") == 0) RLGL.ExtSupported.maxDepthBits = 32; // Not available on WebGL
2595
2596 // Check texture compression support: DXT
2597 if ((strcmp(extList[i], (const char *)"GL_EXT_texture_compression_s3tc") == 0) ||
2598 (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_s3tc") == 0) ||
2599 (strcmp(extList[i], (const char *)"GL_WEBKIT_WEBGL_compressed_texture_s3tc") == 0)) RLGL.ExtSupported.texCompDXT = true;
2600
2601 // Check texture compression support: ETC1
2602 if ((strcmp(extList[i], (const char *)"GL_OES_compressed_ETC1_RGB8_texture") == 0) ||
2603 (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_etc1") == 0)) RLGL.ExtSupported.texCompETC1 = true;
2604
2605 // Check texture compression support: ETC2/EAC
2606 if (strcmp(extList[i], (const char *)"GL_ARB_ES3_compatibility") == 0) RLGL.ExtSupported.texCompETC2 = true;
2607
2608 // Check texture compression support: PVR
2609 if (strcmp(extList[i], (const char *)"GL_IMG_texture_compression_pvrtc") == 0) RLGL.ExtSupported.texCompPVRT = true;
2610
2611 // Check texture compression support: ASTC
2612 if (strcmp(extList[i], (const char *)"GL_KHR_texture_compression_astc_hdr") == 0) RLGL.ExtSupported.texCompASTC = true;
2613
2614 // Check anisotropic texture filter support
2615 if (strcmp(extList[i], (const char *)"GL_EXT_texture_filter_anisotropic") == 0) RLGL.ExtSupported.texAnisoFilter = true;
2616
2617 // Check clamp mirror wrap mode support
2618 if (strcmp(extList[i], (const char *)"GL_EXT_texture_mirror_clamp") == 0) RLGL.ExtSupported.texMirrorClamp = true;
2619 }
2620
2621 // Free extensions pointers
2622 RL_FREE(extList);
2623 RL_FREE(extensionsDup); // Duplicated string must be deallocated
2624 #endif // GRAPHICS_API_OPENGL_ES2
2625
2626 // Check OpenGL information and capabilities
2627 //------------------------------------------------------------------------------
2628 // Show current OpenGL and GLSL version
2629 TRACELOG(RL_LOG_INFO, "GL: OpenGL device information:");
2630 TRACELOG(RL_LOG_INFO, " > Vendor: %s", glGetString(GL_VENDOR));
2631 TRACELOG(RL_LOG_INFO, " > Renderer: %s", glGetString(GL_RENDERER));
2632 TRACELOG(RL_LOG_INFO, " > Version: %s", glGetString(GL_VERSION));
2633 TRACELOG(RL_LOG_INFO, " > GLSL: %s", glGetString(GL_SHADING_LANGUAGE_VERSION));
2634
2635 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2636 RLGL.loader = (rlglLoadProc)loader;
2637
2638 // NOTE: Anisotropy levels capability is an extension
2639 #ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
2640 #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF
2641 #endif
2642 glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &RLGL.ExtSupported.maxAnisotropyLevel);
2643
2644 #if RLGL_SHOW_GL_DETAILS_INFO
2645 // Show some OpenGL GPU capabilities
2646 TRACELOG(RL_LOG_INFO, "GL: OpenGL capabilities:");
2647 GLint capability = 0;
2648 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &capability);
2649 TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_SIZE: %i", capability);
2650 glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &capability);
2651 TRACELOG(RL_LOG_INFO, " GL_MAX_CUBE_MAP_TEXTURE_SIZE: %i", capability);
2652 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &capability);
2653 TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_IMAGE_UNITS: %i", capability);
2654 glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &capability);
2655 TRACELOG(RL_LOG_INFO, " GL_MAX_VERTEX_ATTRIBS: %i", capability);
2656 #if !defined(GRAPHICS_API_OPENGL_ES2)
2657 glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &capability);
2658 TRACELOG(RL_LOG_INFO, " GL_MAX_UNIFORM_BLOCK_SIZE: %i", capability);
2659 glGetIntegerv(GL_MAX_DRAW_BUFFERS, &capability);
2660 TRACELOG(RL_LOG_INFO, " GL_MAX_DRAW_BUFFERS: %i", capability);
2661 if (RLGL.ExtSupported.texAnisoFilter) TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_MAX_ANISOTROPY: %.0f", RLGL.ExtSupported.maxAnisotropyLevel);
2662 #endif
2663 glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &capability);
2664 TRACELOG(RL_LOG_INFO, " GL_NUM_COMPRESSED_TEXTURE_FORMATS: %i", capability);
2665 GLint *compFormats = (GLint *)RL_CALLOC(capability, sizeof(GLint));
2666 glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, compFormats);
2667 for (int i = 0; i < capability; i++) TRACELOG(RL_LOG_INFO, " %s", rlGetCompressedFormatName(compFormats[i]));
2668 RL_FREE(compFormats);
2669
2670 #if defined(GRAPHICS_API_OPENGL_43)
2671 glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &capability);
2672 TRACELOG(RL_LOG_INFO, " GL_MAX_VERTEX_ATTRIB_BINDINGS: %i", capability);
2673 glGetIntegerv(GL_MAX_UNIFORM_LOCATIONS, &capability);
2674 TRACELOG(RL_LOG_INFO, " GL_MAX_UNIFORM_LOCATIONS: %i", capability);
2675 #endif
2676
2677 #else // !RLGL_SHOW_GL_DETAILS_INFO
2678
2679 // Show some basic info about GL supported features
2680 if (RLGL.ExtSupported.vao) TRACELOG(RL_LOG_INFO, "GL: VAO extension detected, VAO functions loaded successfully");
2681 else TRACELOG(RL_LOG_WARNING, "GL: VAO extension not found, VAO not supported");
2682 if (RLGL.ExtSupported.texNPOT) TRACELOG(RL_LOG_INFO, "GL: NPOT textures extension detected, full NPOT textures supported");
2683 else TRACELOG(RL_LOG_WARNING, "GL: NPOT textures extension not found, limited NPOT support (no-mipmaps, no-repeat)");
2684 if (RLGL.ExtSupported.texCompDXT) TRACELOG(RL_LOG_INFO, "GL: DXT compressed textures supported");
2685 if (RLGL.ExtSupported.texCompETC1) TRACELOG(RL_LOG_INFO, "GL: ETC1 compressed textures supported");
2686 if (RLGL.ExtSupported.texCompETC2) TRACELOG(RL_LOG_INFO, "GL: ETC2/EAC compressed textures supported");
2687 if (RLGL.ExtSupported.texCompPVRT) TRACELOG(RL_LOG_INFO, "GL: PVRT compressed textures supported");
2688 if (RLGL.ExtSupported.texCompASTC) TRACELOG(RL_LOG_INFO, "GL: ASTC compressed textures supported");
2689 if (RLGL.ExtSupported.computeShader) TRACELOG(RL_LOG_INFO, "GL: Compute shaders supported");
2690 if (RLGL.ExtSupported.ssbo) TRACELOG(RL_LOG_INFO, "GL: Shader storage buffer objects supported");
2691 #endif
2692
2693 #endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
2694 }
2695
2696 // Get OpenGL procedure address
2697 void *rlGetProcAddress(const char *procName)
2698 {
2699 void *func = NULL;
2700 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2701 func = RLGL.loader(procName);
2702 #endif
2703 return func;
2704 }
2705
2706 // Get current OpenGL version
2707 int rlGetVersion(void)
2708 {
2709 int glVersion = 0;
2710
2711 #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
2712 glVersion = RL_OPENGL_SOFTWARE;
2713 #elif defined(GRAPHICS_API_OPENGL_11)
2714 glVersion = RL_OPENGL_11;
2715 #endif
2716 #if defined(GRAPHICS_API_OPENGL_21)
2717 glVersion = RL_OPENGL_21;
2718 #elif defined(GRAPHICS_API_OPENGL_43)
2719 glVersion = RL_OPENGL_43;
2720 #elif defined(GRAPHICS_API_OPENGL_33)
2721 glVersion = RL_OPENGL_33;
2722 #endif
2723 #if defined(GRAPHICS_API_OPENGL_ES3)
2724 glVersion = RL_OPENGL_ES_30;
2725 #elif defined(GRAPHICS_API_OPENGL_ES2)
2726 glVersion = RL_OPENGL_ES_20;
2727 #endif
2728
2729 return glVersion;
2730 }
2731
2732 // Set current framebuffer width
2733 void rlSetFramebufferWidth(int width)
2734 {
2735 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2736 RLGL.State.framebufferWidth = width;
2737 #endif
2738 }
2739
2740 // Set current framebuffer height
2741 void rlSetFramebufferHeight(int height)
2742 {
2743 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2744 RLGL.State.framebufferHeight = height;
2745 #endif
2746 }
2747
2748 // Get default framebuffer width
2749 int rlGetFramebufferWidth(void)
2750 {
2751 int width = 0;
2752 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2753 width = RLGL.State.framebufferWidth;
2754 #endif
2755 return width;
2756 }
2757
2758 // Get default framebuffer height
2759 int rlGetFramebufferHeight(void)
2760 {
2761 int height = 0;
2762 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2763 height = RLGL.State.framebufferHeight;
2764 #endif
2765 return height;
2766 }
2767
2768 // Get default internal texture (white texture)
2769 // NOTE: Default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8
2770 unsigned int rlGetTextureIdDefault(void)
2771 {
2772 unsigned int id = 0;
2773 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2774 id = RLGL.State.defaultTextureId;
2775 #endif
2776 return id;
2777 }
2778
2779 // Get default shader id
2780 unsigned int rlGetShaderIdDefault(void)
2781 {
2782 unsigned int id = 0;
2783 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2784 id = RLGL.State.defaultShaderId;
2785 #endif
2786 return id;
2787 }
2788
2789 // Get default shader locs
2790 int *rlGetShaderLocsDefault(void)
2791 {
2792 int *locs = NULL;
2793 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2794 locs = RLGL.State.defaultShaderLocs;
2795 #endif
2796 return locs;
2797 }
2798
2799 // Render batch management
2800 //------------------------------------------------------------------------------------------------
2801 // Load render batch
2802 rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements)
2803 {
2804 rlRenderBatch batch = { 0 };
2805 if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return batch; }
2806
2807 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2808 // Initialize CPU (RAM) vertex buffers (position, texcoord, color data and indexes)
2809 //--------------------------------------------------------------------------------------------
2810 batch.vertexBuffer = (rlVertexBuffer *)RL_CALLOC(numBuffers, sizeof(rlVertexBuffer));
2811
2812 for (int i = 0; i < numBuffers; i++)
2813 {
2814 batch.vertexBuffer[i].elementCount = bufferElements;
2815
2816 batch.vertexBuffer[i].vertices = (float *)RL_CALLOC(bufferElements*3*4, sizeof(float)); // 3 float by vertex, 4 vertex by quad
2817 batch.vertexBuffer[i].texcoords = (float *)RL_CALLOC(bufferElements*2*4, sizeof(float)); // 2 float by texcoord, 4 texcoord by quad
2818 batch.vertexBuffer[i].normals = (float *)RL_CALLOC(bufferElements*3*4, sizeof(float)); // 3 float by vertex, 4 vertex by quad
2819 batch.vertexBuffer[i].colors = (unsigned char *)RL_CALLOC(bufferElements*4*4, sizeof(unsigned char)); // 4 float by color, 4 colors by quad
2820 #if defined(GRAPHICS_API_OPENGL_33)
2821 batch.vertexBuffer[i].indices = (unsigned int *)RL_CALLOC(bufferElements*6, sizeof(unsigned int)); // 6 int by quad (indices)
2822 #endif
2823 #if defined(GRAPHICS_API_OPENGL_ES2)
2824 batch.vertexBuffer[i].indices = (unsigned short *)RL_CALLOC(bufferElements*6, sizeof(unsigned short)); // 6 int by quad (indices)
2825 #endif
2826
2827 for (int j = 0; j < (3*4*bufferElements); j++) batch.vertexBuffer[i].vertices[j] = 0.0f;
2828 for (int j = 0; j < (2*4*bufferElements); j++) batch.vertexBuffer[i].texcoords[j] = 0.0f;
2829 for (int j = 0; j < (3*4*bufferElements); j++) batch.vertexBuffer[i].normals[j] = 0.0f;
2830 for (int j = 0; j < (4*4*bufferElements); j++) batch.vertexBuffer[i].colors[j] = 0;
2831
2832 int k = 0;
2833
2834 // Indices can be initialized right now
2835 for (int j = 0; j < (6*bufferElements); j += 6)
2836 {
2837 batch.vertexBuffer[i].indices[j] = 4*k;
2838 batch.vertexBuffer[i].indices[j + 1] = 4*k + 1;
2839 batch.vertexBuffer[i].indices[j + 2] = 4*k + 2;
2840 batch.vertexBuffer[i].indices[j + 3] = 4*k;
2841 batch.vertexBuffer[i].indices[j + 4] = 4*k + 2;
2842 batch.vertexBuffer[i].indices[j + 5] = 4*k + 3;
2843
2844 k++;
2845 }
2846
2847 RLGL.State.vertexCounter = 0;
2848 }
2849
2850 TRACELOG(RL_LOG_INFO, "RLGL: Render batch vertex buffers loaded successfully in RAM (CPU)");
2851 //--------------------------------------------------------------------------------------------
2852
2853 // Upload to GPU (VRAM) vertex data and initialize VAOs/VBOs
2854 //--------------------------------------------------------------------------------------------
2855 for (int i = 0; i < numBuffers; i++)
2856 {
2857 if (RLGL.ExtSupported.vao)
2858 {
2859 // Initialize Quads VAO
2860 glGenVertexArrays(1, &batch.vertexBuffer[i].vaoId);
2861 glBindVertexArray(batch.vertexBuffer[i].vaoId);
2862 }
2863
2864 // Quads - Vertex buffers binding and attributes enable
2865 // Vertex position buffer (shader-location = 0)
2866 glGenBuffers(1, &batch.vertexBuffer[i].vboId[0]);
2867 glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[0]);
2868 glBufferData(GL_ARRAY_BUFFER, bufferElements*3*4*sizeof(float), batch.vertexBuffer[i].vertices, GL_DYNAMIC_DRAW);
2869 glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]);
2870 glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0);
2871
2872 // Vertex texcoord buffer (shader-location = 1)
2873 glGenBuffers(1, &batch.vertexBuffer[i].vboId[1]);
2874 glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[1]);
2875 glBufferData(GL_ARRAY_BUFFER, bufferElements*2*4*sizeof(float), batch.vertexBuffer[i].texcoords, GL_DYNAMIC_DRAW);
2876 glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]);
2877 glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0);
2878
2879 // Vertex normal buffer (shader-location = 2)
2880 glGenBuffers(1, &batch.vertexBuffer[i].vboId[2]);
2881 glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[2]);
2882 glBufferData(GL_ARRAY_BUFFER, bufferElements*3*4*sizeof(float), batch.vertexBuffer[i].normals, GL_DYNAMIC_DRAW);
2883 glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_NORMAL]);
2884 glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_NORMAL], 3, GL_FLOAT, 0, 0, 0);
2885
2886 // Vertex color buffer (shader-location = 3)
2887 glGenBuffers(1, &batch.vertexBuffer[i].vboId[3]);
2888 glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[3]);
2889 glBufferData(GL_ARRAY_BUFFER, bufferElements*4*4*sizeof(unsigned char), batch.vertexBuffer[i].colors, GL_DYNAMIC_DRAW);
2890 glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]);
2891 glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
2892
2893 // Fill index buffer
2894 glGenBuffers(1, &batch.vertexBuffer[i].vboId[4]);
2895 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[4]);
2896 #if defined(GRAPHICS_API_OPENGL_33)
2897 glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements*6*sizeof(int), batch.vertexBuffer[i].indices, GL_STATIC_DRAW);
2898 #endif
2899 #if defined(GRAPHICS_API_OPENGL_ES2)
2900 glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements*6*sizeof(short), batch.vertexBuffer[i].indices, GL_STATIC_DRAW);
2901 #endif
2902 }
2903
2904 TRACELOG(RL_LOG_INFO, "RLGL: Render batch vertex buffers loaded successfully in VRAM (GPU)");
2905
2906 // Unbind the current VAO
2907 if (RLGL.ExtSupported.vao) glBindVertexArray(0);
2908 //--------------------------------------------------------------------------------------------
2909
2910 // Init draw calls tracking system
2911 //--------------------------------------------------------------------------------------------
2912 batch.draws = (rlDrawCall *)RL_CALLOC(RL_DEFAULT_BATCH_DRAWCALLS, sizeof(rlDrawCall));
2913
2914 for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++)
2915 {
2916 batch.draws[i].mode = RL_QUADS;
2917 batch.draws[i].vertexCount = 0;
2918 batch.draws[i].vertexAlignment = 0;
2919 //batch.draws[i].vaoId = 0;
2920 //batch.draws[i].shaderId = 0;
2921 batch.draws[i].textureId = RLGL.State.defaultTextureId;
2922 //batch.draws[i].RLGL.State.projection = rlMatrixIdentity();
2923 //batch.draws[i].RLGL.State.modelview = rlMatrixIdentity();
2924 }
2925
2926 batch.bufferCount = numBuffers; // Record buffer count
2927 batch.drawCounter = 1; // Reset draws counter
2928 batch.currentDepth = -1.0f; // Reset depth value
2929 //--------------------------------------------------------------------------------------------
2930 #endif
2931
2932 return batch;
2933 }
2934
2935 // Unload default internal buffers vertex data from CPU and GPU
2936 void rlUnloadRenderBatch(rlRenderBatch batch)
2937 {
2938 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2939 // Unbind everything
2940 glBindBuffer(GL_ARRAY_BUFFER, 0);
2941 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
2942
2943 // Unload all vertex buffers data
2944 for (int i = 0; i < batch.bufferCount; i++)
2945 {
2946 // Unbind VAO attribs data
2947 if (RLGL.ExtSupported.vao)
2948 {
2949 glBindVertexArray(batch.vertexBuffer[i].vaoId);
2950 glDisableVertexAttribArray(RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION);
2951 glDisableVertexAttribArray(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD);
2952 glDisableVertexAttribArray(RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL);
2953 glDisableVertexAttribArray(RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR);
2954 glBindVertexArray(0);
2955 }
2956
2957 // Delete VBOs from GPU (VRAM)
2958 glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[0]);
2959 glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[1]);
2960 glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[2]);
2961 glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[3]);
2962 glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[4]);
2963
2964 // Delete VAOs from GPU (VRAM)
2965 if (RLGL.ExtSupported.vao) glDeleteVertexArrays(1, &batch.vertexBuffer[i].vaoId);
2966
2967 // Free vertex arrays memory from CPU (RAM)
2968 RL_FREE(batch.vertexBuffer[i].vertices);
2969 RL_FREE(batch.vertexBuffer[i].texcoords);
2970 RL_FREE(batch.vertexBuffer[i].normals);
2971 RL_FREE(batch.vertexBuffer[i].colors);
2972 RL_FREE(batch.vertexBuffer[i].indices);
2973 }
2974
2975 // Unload arrays
2976 RL_FREE(batch.vertexBuffer);
2977 RL_FREE(batch.draws);
2978 #endif
2979 }
2980
2981 // Draw render batch
2982 // NOTE: Batch is reseted and current buffer is updated (for multi-buffer config)
2983 void rlDrawRenderBatch(rlRenderBatch *batch)
2984 {
2985 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
2986 // Update batch vertex buffers
2987 //------------------------------------------------------------------------------------------------------------
2988 // NOTE: If there is not vertex data, buffers doesn't need to be updated (vertexCount > 0)
2989 if (RLGL.State.vertexCounter > 0)
2990 {
2991 // Activate elements VAO
2992 if (RLGL.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId);
2993
2994 // TODO: If no data changed on the CPU arrays there is no need to re-upload data to GPU,
2995 // a flag can be used to detect changes but it would imply keeping a copy buffer and memcmp() both, does it worth it?
2996
2997 // Vertex positions buffer
2998 glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]);
2999 glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*3*sizeof(float), batch->vertexBuffer[batch->currentBuffer].vertices);
3000 //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].vertices, GL_DYNAMIC_DRAW); // Update all buffer
3001
3002 // Texture coordinates buffer
3003 glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]);
3004 glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*2*sizeof(float), batch->vertexBuffer[batch->currentBuffer].texcoords);
3005 //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].texcoords, GL_DYNAMIC_DRAW); // Update all buffer
3006
3007 // Normals buffer
3008 glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]);
3009 glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*3*sizeof(float), batch->vertexBuffer[batch->currentBuffer].normals);
3010 //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].normals, GL_DYNAMIC_DRAW); // Update all buffer
3011
3012 // Colors buffer
3013 glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[3]);
3014 glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter*4*sizeof(unsigned char), batch->vertexBuffer[batch->currentBuffer].colors);
3015 //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].colors, GL_DYNAMIC_DRAW); // Update all buffer
3016
3017 // NOTE: glMapBuffer() causes sync issue
3018 // If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job
3019 // To avoid waiting (idle), glBufferData() can bee called first with NULL pointer before glMapBuffer()
3020 // Doing that, the previous data in PBO will be discarded and glMapBuffer() returns a new
3021 // allocated pointer immediately even if GPU is still working with the previous data
3022
3023 // Another option: map the buffer object into client's memory
3024 //batch->vertexBuffer[batch->currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
3025 //if (batch->vertexBuffer[batch->currentBuffer].vertices)
3026 //{
3027 // Update vertex data
3028 //}
3029 //glUnmapBuffer(GL_ARRAY_BUFFER);
3030
3031 // Unbind the current VAO
3032 if (RLGL.ExtSupported.vao) glBindVertexArray(0);
3033 }
3034 //------------------------------------------------------------------------------------------------------------
3035
3036 // Draw batch vertex buffers (considering VR stereo if required)
3037 //------------------------------------------------------------------------------------------------------------
3038 Matrix matProjection = RLGL.State.projection;
3039 Matrix matModelView = RLGL.State.modelview;
3040
3041 int eyeCount = 1;
3042 if (RLGL.State.stereoRender) eyeCount = 2;
3043
3044 for (int eye = 0; eye < eyeCount; eye++)
3045 {
3046 if (eyeCount == 2)
3047 {
3048 // Setup current eye viewport (half screen width)
3049 rlViewport(eye*RLGL.State.framebufferWidth/2, 0, RLGL.State.framebufferWidth/2, RLGL.State.framebufferHeight);
3050
3051 // Set current eye view offset to modelview matrix
3052 rlSetMatrixModelview(rlMatrixMultiply(matModelView, RLGL.State.viewOffsetStereo[eye]));
3053 // Set current eye projection matrix
3054 rlSetMatrixProjection(RLGL.State.projectionStereo[eye]);
3055 }
3056
3057 // Draw buffers
3058 if (RLGL.State.vertexCounter > 0)
3059 {
3060 // Set current shader and upload current MVP matrix
3061 glUseProgram(RLGL.State.currentShaderId);
3062
3063 // Create modelview-projection matrix and upload to shader
3064 Matrix matMVP = rlMatrixMultiply(RLGL.State.modelview, RLGL.State.projection);
3065 glUniformMatrix4fv(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_MVP], 1, false, rlMatrixToFloat(matMVP));
3066
3067 if (RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_PROJECTION] != -1)
3068 {
3069 glUniformMatrix4fv(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_PROJECTION], 1, false, rlMatrixToFloat(RLGL.State.projection));
3070 }
3071
3072 // WARNING: For the following setup of the view, model, and normal matrices, it is expected that
3073 // transformations and rendering occur between rlPushMatrix() and rlPopMatrix()
3074
3075 if (RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_VIEW] != -1)
3076 {
3077 glUniformMatrix4fv(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_VIEW], 1, false, rlMatrixToFloat(RLGL.State.modelview));
3078 }
3079
3080 if (RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_MODEL] != -1)
3081 {
3082 glUniformMatrix4fv(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_MODEL], 1, false, rlMatrixToFloat(RLGL.State.transform));
3083 }
3084
3085 if (RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_NORMAL] != -1)
3086 {
3087 glUniformMatrix4fv(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_NORMAL], 1, false, rlMatrixToFloat(rlMatrixTranspose(rlMatrixInvert(RLGL.State.transform))));
3088 }
3089
3090 if (RLGL.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId);
3091 else
3092 {
3093 // Bind vertex attrib: position (shader-location = 0)
3094 glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]);
3095 glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0);
3096 glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]);
3097
3098 // Bind vertex attrib: texcoord (shader-location = 1)
3099 glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]);
3100 glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0);
3101 glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]);
3102
3103 // Bind vertex attrib: normal (shader-location = 2)
3104 glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]);
3105 glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_NORMAL], 3, GL_FLOAT, 0, 0, 0);
3106 glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_NORMAL]);
3107
3108 // Bind vertex attrib: color (shader-location = 3)
3109 glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[3]);
3110 glVertexAttribPointer(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0);
3111 glEnableVertexAttribArray(RLGL.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]);
3112
3113 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[4]);
3114 }
3115
3116 // Setup some default shader values
3117 glUniform4f(RLGL.State.currentShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE], 1.0f, 1.0f, 1.0f, 1.0f);
3118 glUniform1i(RLGL.State.currentShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE], 0); // Active default sampler2D: texture0
3119
3120 // Activate additional sampler textures
3121 // Those additional textures will be common for all draw calls of the batch
3122 for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++)
3123 {
3124 if (RLGL.State.activeTextureId[i] > 0)
3125 {
3126 glActiveTexture(GL_TEXTURE0 + 1 + i);
3127 glBindTexture(GL_TEXTURE_2D, RLGL.State.activeTextureId[i]);
3128 }
3129 }
3130
3131 // Activate default sampler2D texture0 (one texture is always active for default batch shader)
3132 // NOTE: Batch system accumulates calls by texture0 changes, additional textures are enabled for all the draw calls
3133 glActiveTexture(GL_TEXTURE0);
3134
3135 for (int i = 0, vertexOffset = 0; i < batch->drawCounter; i++)
3136 {
3137 // Bind current draw call texture, activated as GL_TEXTURE0 and bound to sampler2D texture0 by default
3138 glBindTexture(GL_TEXTURE_2D, batch->draws[i].textureId);
3139
3140 if ((batch->draws[i].mode == RL_LINES) || (batch->draws[i].mode == RL_TRIANGLES)) glDrawArrays(batch->draws[i].mode, vertexOffset, batch->draws[i].vertexCount);
3141 else
3142 {
3143 #if defined(GRAPHICS_API_OPENGL_33)
3144 // The number of indices to be processed needs to be defined: elementCount*6
3145 // NOTE: The final parameter tells the GPU the offset in bytes from the
3146 // start of the index buffer to the location of the first index to process
3147 glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_INT, (GLvoid *)(vertexOffset/4*6*sizeof(GLuint)));
3148 #endif
3149 #if defined(GRAPHICS_API_OPENGL_ES2)
3150 glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_SHORT, (GLvoid *)(vertexOffset/4*6*sizeof(GLushort)));
3151 #endif
3152 }
3153
3154 vertexOffset += (batch->draws[i].vertexCount + batch->draws[i].vertexAlignment);
3155 }
3156
3157 if (!RLGL.ExtSupported.vao)
3158 {
3159 glBindBuffer(GL_ARRAY_BUFFER, 0);
3160 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
3161 }
3162
3163 glBindTexture(GL_TEXTURE_2D, 0); // Unbind textures
3164 }
3165
3166 if (RLGL.ExtSupported.vao) glBindVertexArray(0); // Unbind VAO
3167
3168 glUseProgram(0); // Unbind shader program
3169 }
3170
3171 // Restore viewport to default measures
3172 if (eyeCount == 2) rlViewport(0, 0, RLGL.State.framebufferWidth, RLGL.State.framebufferHeight);
3173 //------------------------------------------------------------------------------------------------------------
3174
3175 // Reset batch buffers
3176 //------------------------------------------------------------------------------------------------------------
3177 // Reset vertex counter for next frame
3178 RLGL.State.vertexCounter = 0;
3179
3180 // Reset depth for next draw
3181 batch->currentDepth = -1.0f;
3182
3183 // Restore projection/modelview matrices
3184 RLGL.State.projection = matProjection;
3185 RLGL.State.modelview = matModelView;
3186
3187 // Reset RLGL.currentBatch->draws array
3188 for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++)
3189 {
3190 batch->draws[i].mode = RL_QUADS;
3191 batch->draws[i].vertexCount = 0;
3192 batch->draws[i].textureId = RLGL.State.defaultTextureId;
3193 }
3194
3195 // Reset active texture units for next batch
3196 for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) RLGL.State.activeTextureId[i] = 0;
3197
3198 // Reset draws counter to one draw for the batch
3199 batch->drawCounter = 1;
3200 //------------------------------------------------------------------------------------------------------------
3201
3202 // Change to next buffer in the list (in case of multi-buffering)
3203 batch->currentBuffer++;
3204 if (batch->currentBuffer >= batch->bufferCount) batch->currentBuffer = 0;
3205 #endif
3206 }
3207
3208 // Set the active render batch for rlgl
3209 void rlSetRenderBatchActive(rlRenderBatch *batch)
3210 {
3211 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
3212 rlDrawRenderBatch(RLGL.currentBatch);
3213
3214 if (batch != NULL) RLGL.currentBatch = batch;
3215 else RLGL.currentBatch = &RLGL.defaultBatch;
3216 #endif
3217 }
3218
3219 // Update and draw internal render batch
3220 void rlDrawRenderBatchActive(void)
3221 {
3222 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
3223 rlDrawRenderBatch(RLGL.currentBatch); // NOTE: Stereo rendering is checked inside
3224 #endif
3225 }
3226
3227 // Check internal buffer overflow for a given number of vertex
3228 // and force a rlRenderBatch draw call if required
3229 bool rlCheckRenderBatchLimit(int vCount)
3230 {
3231 bool overflow = false;
3232
3233 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
3234 if ((RLGL.State.vertexCounter + vCount) >=
3235 (RLGL.currentBatch->vertexBuffer[RLGL.currentBatch->currentBuffer].elementCount*4))
3236 {
3237 overflow = true;
3238
3239 // Store current primitive drawing mode and texture id
3240 int currentMode = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode;
3241 int currentTexture = RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId;
3242
3243 rlDrawRenderBatch(RLGL.currentBatch); // NOTE: Stereo rendering is checked inside
3244
3245 // Restore state of last batch so new vertices can be added
3246 RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = currentMode;
3247 RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = currentTexture;
3248 }
3249 #endif
3250
3251 return overflow;
3252 }
3253
3254 // Textures data management
3255 //-----------------------------------------------------------------------------------------
3256 // Convert image data to OpenGL texture (returns OpenGL valid Id)
3257 unsigned int rlLoadTexture(const void *data, int width, int height, int format, int mipmapCount)
3258 {
3259 unsigned int id = 0;
3260 if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return id; }
3261
3262 glBindTexture(GL_TEXTURE_2D, 0); // Free any old binding
3263
3264 // Check texture format support by OpenGL 1.1 (compressed textures not supported)
3265 #if defined(GRAPHICS_API_OPENGL_11)
3266 if (format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)
3267 {
3268 // TODO: Support texture data decompression
3269 TRACELOG(RL_LOG_WARNING, "GL: OpenGL 1.1 does not support GPU compressed texture formats");
3270 return id;
3271 }
3272 #else
3273 if ((!RLGL.ExtSupported.texCompDXT) && ((format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA) ||
3274 (format == RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) || (format == RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA)))
3275 {
3276 TRACELOG(RL_LOG_WARNING, "GL: DXT compressed texture format not supported");
3277 return id;
3278 }
3279 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
3280 if ((!RLGL.ExtSupported.texCompETC1) && (format == RL_PIXELFORMAT_COMPRESSED_ETC1_RGB))
3281 {
3282 TRACELOG(RL_LOG_WARNING, "GL: ETC1 compressed texture format not supported");
3283 return id;
3284 }
3285
3286 if ((!RLGL.ExtSupported.texCompETC2) && ((format == RL_PIXELFORMAT_COMPRESSED_ETC2_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA)))
3287 {
3288 TRACELOG(RL_LOG_WARNING, "GL: ETC2 compressed texture format not supported");
3289 return id;
3290 }
3291
3292 if ((!RLGL.ExtSupported.texCompPVRT) && ((format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA)))
3293 {
3294 TRACELOG(RL_LOG_WARNING, "GL: PVRT compressed texture format not supported");
3295 return id;
3296 }
3297
3298 if ((!RLGL.ExtSupported.texCompASTC) && ((format == RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA) || (format == RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)))
3299 {
3300 TRACELOG(RL_LOG_WARNING, "GL: ASTC compressed texture format not supported");
3301 return id;
3302 }
3303 #endif
3304 #endif // GRAPHICS_API_OPENGL_11
3305
3306 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
3307
3308 glGenTextures(1, &id); // Generate texture id
3309
3310 glBindTexture(GL_TEXTURE_2D, id);
3311
3312 int mipWidth = width;
3313 int mipHeight = height;
3314 int mipOffset = 0; // Mipmap data offset, only used for tracelog
3315 (void)mipOffset; // Used to avoid gcc warnings about unused variable
3316
3317 // NOTE: Added pointer math separately from function to avoid UBSAN complaining
3318 unsigned char *dataPtr = NULL;
3319 if (data != NULL) dataPtr = (unsigned char *)data;
3320
3321 // Load the different mipmap levels
3322 for (int i = 0; i < mipmapCount; i++)
3323 {
3324 unsigned int mipSize = rlGetPixelDataSize(mipWidth, mipHeight, format);
3325
3326 unsigned int glInternalFormat, glFormat, glType;
3327 rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
3328
3329 TRACELOG(RL_LOG_DEBUG, "TEXTURE: Load mipmap level %i (%i x %i), size: %i, offset: %i", i, mipWidth, mipHeight, mipSize, mipOffset);
3330
3331 if (glInternalFormat != 0)
3332 {
3333 if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, glFormat, glType, dataPtr);
3334 #if !defined(GRAPHICS_API_OPENGL_11)
3335 else glCompressedTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, mipSize, dataPtr);
3336 #endif
3337
3338 #if defined(GRAPHICS_API_OPENGL_33)
3339 if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE)
3340 {
3341 GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE };
3342 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
3343 }
3344 else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA)
3345 {
3346 #if defined(GRAPHICS_API_OPENGL_21)
3347 GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA };
3348 #elif defined(GRAPHICS_API_OPENGL_33)
3349 GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN };
3350 #endif
3351 glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
3352 }
3353 #endif
3354 }
3355
3356 mipWidth /= 2;
3357 mipHeight /= 2;
3358 mipOffset += mipSize; // Increment offset position to next mipmap
3359 if (data != NULL) dataPtr += mipSize; // Increment data pointer to next mipmap
3360
3361 // Security check for NPOT textures
3362 if (mipWidth < 1) mipWidth = 1;
3363 if (mipHeight < 1) mipHeight = 1;
3364 }
3365
3366 // Texture parameters configuration
3367 // NOTE: glTexParameteri does NOT affect texture uploading
3368 #if defined(GRAPHICS_API_OPENGL_ES2)
3369 // 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
3370 if (RLGL.ExtSupported.texNPOT)
3371 {
3372 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture to repeat on x-axis
3373 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture to repeat on y-axis
3374 }
3375 else
3376 {
3377 // NOTE: If using negative texture coordinates (LoadOBJ()), it does not work!
3378 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // Set texture to clamp on x-axis
3379 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // Set texture to clamp on y-axis
3380 }
3381 #else
3382 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture to repeat on x-axis
3383 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture to repeat on y-axis
3384 #endif
3385
3386 // Magnification and minification filters
3387 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Alternative: GL_LINEAR
3388 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // Alternative: GL_LINEAR
3389
3390 #if defined(GRAPHICS_API_OPENGL_33)
3391 if (mipmapCount > 1)
3392 {
3393 // Activate trilinear filtering if mipmaps are available
3394 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
3395 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
3396
3397 // Define the maximum number of mipmap levels to be used, 0 is base texture size
3398 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
3399 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, mipmapCount - 1);
3400
3401 // Check if the loaded texture with mipmaps is complete,
3402 // uncomplete textures will draw in black if mipmap filtering is required
3403 //GLint complete = 0;
3404 //glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_FORMAT, &complete);
3405 }
3406 #endif
3407
3408 // At this point texture is loaded in GPU and texture parameters configured
3409
3410 // NOTE: If mipmaps were not in data, they are not generated automatically
3411
3412 // Unbind current texture
3413 glBindTexture(GL_TEXTURE_2D, 0);
3414
3415 if (id > 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Texture loaded successfully (%ix%i | %s | %i mipmaps)", id, width, height, rlGetPixelFormatName(format), mipmapCount);
3416 else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load texture");
3417
3418 return id;
3419 }
3420
3421 // Load depth texture/renderbuffer (to be attached to fbo)
3422 // WARNING: OpenGL ES 2.0 requires GL_OES_depth_texture and WebGL requires WEBGL_depth_texture extensions
3423 unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer)
3424 {
3425 unsigned int id = 0;
3426 if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return id; }
3427
3428 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
3429 // In case depth textures were not supported, force renderbuffer usage
3430 if (!RLGL.ExtSupported.texDepth) useRenderBuffer = true;
3431
3432 // NOTE: Letting the implementation to choose the best bit-depth
3433 // Possible formats: GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32 and GL_DEPTH_COMPONENT32F
3434 unsigned int glInternalFormat = GL_DEPTH_COMPONENT;
3435
3436 #if defined(GRAPHICS_API_OPENGL_ES2)
3437 // WARNING: WebGL platform requires unsized internal format definition (GL_DEPTH_COMPONENT)
3438 // while other platforms using OpenGL ES 2.0 require/support sized internal formats depending on the GPU capabilities
3439 if (!RLGL.ExtSupported.texDepthWebGL || useRenderBuffer)
3440 {
3441 if (RLGL.ExtSupported.maxDepthBits == 32) glInternalFormat = GL_DEPTH_COMPONENT32_OES;
3442 else if (RLGL.ExtSupported.maxDepthBits == 24) glInternalFormat = GL_DEPTH_COMPONENT24_OES;
3443 else glInternalFormat = GL_DEPTH_COMPONENT16;
3444 }
3445 #endif
3446 #if defined(GRAPHICS_API_OPENGL_ES3)
3447 // NOTE: This sized internal format should also work for WebGL 2.0
3448 // WARNING: Specification only allows GL_DEPTH_COMPONENT32F for GL_FLOAT type
3449 // REF: https://registry.khronos.org/OpenGL-Refpages/es3.0/html/glTexImage2D.xhtml
3450 if (RLGL.ExtSupported.maxDepthBits == 24) glInternalFormat = GL_DEPTH_COMPONENT24;
3451 else glInternalFormat = GL_DEPTH_COMPONENT16;
3452 #endif
3453
3454 if (!useRenderBuffer && RLGL.ExtSupported.texDepth)
3455 {
3456 glGenTextures(1, &id);
3457 glBindTexture(GL_TEXTURE_2D, id);
3458 glTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
3459
3460 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
3461 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
3462 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3463 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3464
3465 glBindTexture(GL_TEXTURE_2D, 0);
3466
3467 TRACELOG(RL_LOG_INFO, "TEXTURE: Depth texture loaded successfully");
3468 }
3469 else
3470 {
3471 // Create the renderbuffer that will serve as the depth attachment for the framebuffer
3472 // NOTE: A renderbuffer is simpler than a texture and could offer better performance on embedded devices
3473 glGenRenderbuffers(1, &id);
3474 glBindRenderbuffer(GL_RENDERBUFFER, id);
3475 glRenderbufferStorage(GL_RENDERBUFFER, glInternalFormat, width, height);
3476
3477 glBindRenderbuffer(GL_RENDERBUFFER, 0);
3478
3479 TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Depth renderbuffer loaded successfully (%i bits)", id, (RLGL.ExtSupported.maxDepthBits >= 24)? RLGL.ExtSupported.maxDepthBits : 16);
3480 }
3481 #elif defined(GRAPHICS_API_OPENGL_SOFTWARE)
3482 // NOTE: Renderbuffers are the same type of object as textures in rlsw
3483 // WARNING: Ensure that the depth format is the one specified at rlsw compilation
3484 glGenRenderbuffers(1, &id);
3485 glBindRenderbuffer(GL_RENDERBUFFER, id);
3486 glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT32, width, height);
3487 glBindRenderbuffer(GL_RENDERBUFFER, 0);
3488 #endif
3489
3490 return id;
3491 }
3492
3493 // Load texture cubemap
3494 // NOTE: Cubemap data is expected to be 6 images in a single data array (one after the other),
3495 // expected the following convention: +X, -X, +Y, -Y, +Z, -Z
3496 unsigned int rlLoadTextureCubemap(const void *data, int size, int format, int mipmapCount)
3497 {
3498 unsigned int id = 0;
3499 if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return id; }
3500
3501 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
3502 int mipSize = size;
3503
3504 // NOTE: Added pointer math separately from function to avoid UBSAN complaining
3505 unsigned char *dataPtr = NULL;
3506 if (data != NULL) dataPtr = (unsigned char *)data;
3507
3508 unsigned int dataSize = rlGetPixelDataSize(size, size, format);
3509
3510 glGenTextures(1, &id);
3511 glBindTexture(GL_TEXTURE_CUBE_MAP, id);
3512
3513 unsigned int glInternalFormat, glFormat, glType;
3514 rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
3515
3516 if (glInternalFormat != 0)
3517 {
3518 // Load cubemap faces/mipmaps
3519 for (int i = 0; i < 6*mipmapCount; i++)
3520 {
3521 int mipmapLevel = i/6;
3522 int face = i%6;
3523
3524 if (data == NULL)
3525 {
3526 if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)
3527 {
3528 if ((format == RL_PIXELFORMAT_UNCOMPRESSED_R32) ||
3529 (format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32) ||
3530 (format == RL_PIXELFORMAT_UNCOMPRESSED_R16) ||
3531 (format == RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16)) TRACELOG(RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported");
3532 else glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mipmapLevel, glInternalFormat, mipSize, mipSize, 0, glFormat, glType, NULL);
3533 }
3534 else TRACELOG(RL_LOG_WARNING, "TEXTURES: Empty cubemap creation does not support compressed format");
3535 }
3536 else
3537 {
3538 if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mipmapLevel, glInternalFormat, mipSize, mipSize, 0, glFormat, glType, (unsigned char *)dataPtr + face*dataSize);
3539 else glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, mipmapLevel, glInternalFormat, mipSize, mipSize, 0, dataSize, (unsigned char *)dataPtr + face*dataSize);
3540 }
3541
3542 #if defined(GRAPHICS_API_OPENGL_33)
3543 if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE)
3544 {
3545 GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE };
3546 glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
3547 }
3548 else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA)
3549 {
3550 #if defined(GRAPHICS_API_OPENGL_21)
3551 GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA };
3552 #elif defined(GRAPHICS_API_OPENGL_33)
3553 GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN };
3554 #endif
3555 glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask);
3556 }
3557 #endif
3558 if (face == 5)
3559 {
3560 mipSize /= 2;
3561 if (data != NULL) dataPtr += dataSize*6; // Increment data pointer to next mipmap
3562
3563 // Security check for NPOT textures
3564 if (mipSize < 1) mipSize = 1;
3565
3566 dataSize = rlGetPixelDataSize(mipSize, mipSize, format);
3567 }
3568 }
3569 }
3570
3571 // Set cubemap texture sampling parameters
3572 if (mipmapCount > 1) glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
3573 else glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
3574
3575 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
3576 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
3577 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
3578 #if defined(GRAPHICS_API_OPENGL_33)
3579 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); // Flag not supported on OpenGL ES 2.0
3580 #endif
3581
3582 glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
3583 #endif
3584
3585 if (id > 0) TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Cubemap texture loaded successfully (%ix%i)", id, size, size);
3586 else TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load cubemap texture");
3587
3588 return id;
3589 }
3590
3591 // Update already loaded texture in GPU with new data
3592 // WARNING: Not possible to know safely if internal texture format is the expected one...
3593 void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data)
3594 {
3595 glBindTexture(GL_TEXTURE_2D, id);
3596
3597 unsigned int glInternalFormat, glFormat, glType;
3598 rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
3599
3600 if ((glInternalFormat != 0) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB))
3601 {
3602 glTexSubImage2D(GL_TEXTURE_2D, 0, offsetX, offsetY, width, height, glFormat, glType, data);
3603 }
3604 else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to update for current texture format (%i)", id, format);
3605 }
3606
3607 // Get OpenGL internal formats and data type from raylib PixelFormat
3608 void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType)
3609 {
3610 *glInternalFormat = 0;
3611 *glFormat = 0;
3612 *glType = 0;
3613
3614 switch (format)
3615 {
3616 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_21) || defined(GRAPHICS_API_OPENGL_ES2)
3617 // NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA
3618 case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_UNSIGNED_BYTE; break;
3619 case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_LUMINANCE_ALPHA; *glFormat = GL_LUMINANCE_ALPHA; *glType = GL_UNSIGNED_BYTE; break;
3620 case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break;
3621 case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break;
3622 case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break;
3623 case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break;
3624 case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break;
3625 #if !defined(GRAPHICS_API_OPENGL_11)
3626 #if defined(GRAPHICS_API_OPENGL_ES3)
3627 case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_R32F_EXT; *glFormat = GL_RED_EXT; *glType = GL_FLOAT; break;
3628 case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB32F_EXT; *glFormat = GL_RGB; *glType = GL_FLOAT; break;
3629 case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA32F_EXT; *glFormat = GL_RGBA; *glType = GL_FLOAT; break;
3630 case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_R16F_EXT; *glFormat = GL_RED_EXT; *glType = GL_HALF_FLOAT; break;
3631 case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB16F_EXT; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT; break;
3632 case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA16F_EXT; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT; break;
3633 #else
3634 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
3635 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
3636 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
3637 #if defined(GRAPHICS_API_OPENGL_21)
3638 case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_HALF_FLOAT_ARB; break;
3639 case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT_ARB; break;
3640 case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT_ARB; break;
3641 #else // defined(GRAPHICS_API_OPENGL_ES2)
3642 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
3643 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
3644 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
3645 #endif
3646 #endif
3647 #endif
3648 #elif defined(GRAPHICS_API_OPENGL_33)
3649 case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_R8; *glFormat = GL_RED; *glType = GL_UNSIGNED_BYTE; break;
3650 case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_RG8; *glFormat = GL_RG; *glType = GL_UNSIGNED_BYTE; break;
3651 case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB565; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break;
3652 case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB8; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break;
3653 case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGB5_A1; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break;
3654 case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA4; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break;
3655 case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA8; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break;
3656 case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_R32F; *glFormat = GL_RED; *glType = GL_FLOAT; break;
3657 case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGB32F; *glFormat = GL_RGB; *glType = GL_FLOAT; break;
3658 case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA32F; *glFormat = GL_RGBA; *glType = GL_FLOAT; break;
3659 case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_R16F; *glFormat = GL_RED; *glType = GL_HALF_FLOAT; break;
3660 case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGB16F; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT; break;
3661 case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA16F; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT; break;
3662 #endif
3663 #if !defined(GRAPHICS_API_OPENGL_11)
3664 case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; break;
3665 case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break;
3666 case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; break;
3667 case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: if (RLGL.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break;
3668 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
3669 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
3670 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
3671 case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU
3672 case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: if (RLGL.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU
3673 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
3674 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
3675 #endif
3676 default: TRACELOG(RL_LOG_WARNING, "TEXTURE: Current format not supported (%i)", format); break;
3677 }
3678 }
3679
3680 // Unload texture from GPU memory
3681 void rlUnloadTexture(unsigned int id)
3682 {
3683 glDeleteTextures(1, &id);
3684 }
3685
3686 // Generate mipmap data for selected texture
3687 // NOTE: Only supports GPU mipmap generation
3688 void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps)
3689 {
3690 if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return; }
3691
3692 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
3693 glBindTexture(GL_TEXTURE_2D, id);
3694
3695 // Check if texture is power-of-two (POT)
3696 bool texIsPOT = false;
3697
3698 if (((width > 0) && ((width & (width - 1)) == 0)) &&
3699 ((height > 0) && ((height & (height - 1)) == 0))) texIsPOT = true;
3700
3701 if ((texIsPOT) || (RLGL.ExtSupported.texNPOT))
3702 {
3703 //glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE); // Hint for mipmaps generation algorithm: GL_FASTEST, GL_NICEST, GL_DONT_CARE
3704 glGenerateMipmap(GL_TEXTURE_2D); // Generate mipmaps automatically
3705
3706 #define MIN(a,b) (((a)<(b))? (a):(b))
3707 #define MAX(a,b) (((a)>(b))? (a):(b))
3708
3709 *mipmaps = 1 + (int)floor(log(MAX(width, height))/log(2));
3710 TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Mipmaps generated automatically, total: %i", id, *mipmaps);
3711 }
3712 else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to generate mipmaps", id);
3713
3714 glBindTexture(GL_TEXTURE_2D, 0);
3715 #else
3716 TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] GPU mipmap generation not supported", id);
3717 #endif
3718 }
3719
3720 // Read texture pixel data
3721 void *rlReadTexturePixels(unsigned int id, int width, int height, int format)
3722 {
3723 void *pixels = NULL;
3724
3725 #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33)
3726 glBindTexture(GL_TEXTURE_2D, id);
3727
3728 // NOTE: Using texture id, some texture info can be retrieved (but not on OpenGL ES 2.0)
3729 // Possible texture info: GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE
3730 //int width, height, format;
3731 //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
3732 //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height);
3733 //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format);
3734
3735 // 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
3736 // Use glPixelStorei to modify padding with the GL_[UN]PACK_ALIGNMENT setting
3737 // GL_PACK_ALIGNMENT affects operations that read from OpenGL memory (glReadPixels, glGetTexImage, etc.)
3738 // GL_UNPACK_ALIGNMENT affects operations that write to OpenGL memory (glTexImage, etc.)
3739 glPixelStorei(GL_PACK_ALIGNMENT, 1);
3740
3741 unsigned int glInternalFormat, glFormat, glType;
3742 rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
3743 unsigned int size = rlGetPixelDataSize(width, height, format);
3744
3745 if ((glInternalFormat != 0) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB))
3746 {
3747 pixels = RL_CALLOC(size, 1);
3748 glGetTexImage(GL_TEXTURE_2D, 0, glFormat, glType, pixels);
3749 }
3750 else TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Data retrieval not suported for pixel format (%i)", id, format);
3751
3752 glBindTexture(GL_TEXTURE_2D, 0);
3753 #endif
3754
3755 #if defined(GRAPHICS_API_OPENGL_ES2)
3756 // glGetTexImage() is not available on OpenGL ES 2.0
3757 // Texture width and height are required on OpenGL ES 2.0, there is no way to get it from texture id
3758 // Two possible Options:
3759 // 1 - Bind texture to color fbo attachment and glReadPixels()
3760 // 2 - Create an fbo, activate it, render quad with texture, glReadPixels()
3761 // Using Option 1, care for texture format on retrieval
3762 // NOTE: This behaviour could be conditioned by graphic driver...
3763 unsigned int fboId = rlLoadFramebuffer();
3764
3765 glBindFramebuffer(GL_FRAMEBUFFER, fboId);
3766 glBindTexture(GL_TEXTURE_2D, 0);
3767
3768 // Attach our texture to FBO
3769 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id, 0);
3770
3771 // Reading data as RGBA because FBO texture is configured as RGBA, despite binding another texture format
3772 pixels = RL_CALLOC(rlGetPixelDataSize(width, height, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8), 1);
3773 glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
3774
3775 glBindFramebuffer(GL_FRAMEBUFFER, 0);
3776
3777 // Clean up temporal fbo
3778 rlUnloadFramebuffer(fboId);
3779 #endif
3780
3781 return pixels;
3782 }
3783
3784 // Copy framebuffer pixel data to internal buffer
3785 void rlCopyFramebuffer(int x, int y, int width, int height, int format, void *pixels)
3786 {
3787 #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
3788 unsigned int glInternalFormat, glFormat, glType;
3789 rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); // Get OpenGL texture format
3790 swReadPixels(x, y, width, height, glFormat, glType, pixels);
3791 #endif
3792 }
3793
3794 // Resize internal framebuffer
3795 void rlResizeFramebuffer(int width, int height)
3796 {
3797 #if defined(GRAPHICS_API_OPENGL_SOFTWARE)
3798 swResize(width, height);
3799 #endif
3800 }
3801
3802 // Read screen pixel data (color buffer)
3803 unsigned char *rlReadScreenPixels(int width, int height)
3804 {
3805 unsigned char *imgData = (unsigned char *)RL_CALLOC(width*height*4, sizeof(unsigned char));
3806
3807 // NOTE: glReadPixels() returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer
3808 // WARNING: Getting alpha channel! Be careful, it can be transparent if not cleared properly!
3809 glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, imgData);
3810
3811 // Flip image vertically
3812 // NOTE: Alpha value has already been applied to RGB in framebuffer, not needed anymore
3813 for (int y = height - 1; y >= height/2; y--)
3814 {
3815 for (int x = 0; x < (width*4); x += 4)
3816 {
3817 unsigned int s = ((height - 1) - y)*width*4 + x;
3818 unsigned int e = y*width*4 + x;
3819
3820 unsigned char r = imgData[s];
3821 unsigned char g = imgData[s+1];
3822 unsigned char b = imgData[s+2];
3823
3824 imgData[s] = imgData[e];
3825 imgData[s+1] = imgData[e+1];
3826 imgData[s+2] = imgData[e+2];
3827 imgData[s+3] = 255; // Set alpha component value to 255 (no trasparent image retrieval)
3828
3829 imgData[e] = r;
3830 imgData[e+1] = g;
3831 imgData[e+2] = b;
3832 imgData[e+3] = 255; // Ditto
3833 }
3834 }
3835
3836 return imgData; // NOTE: image data should be freed
3837 }
3838
3839 // Framebuffer management (fbo)
3840 //-----------------------------------------------------------------------------------------
3841 // Load a framebuffer to be used for rendering
3842 // NOTE: No textures attached
3843 unsigned int rlLoadFramebuffer(void)
3844 {
3845 unsigned int fboId = 0;
3846 if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return fboId; }
3847
3848 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
3849 glGenFramebuffers(1, &fboId); // Create the framebuffer object
3850 glBindFramebuffer(GL_FRAMEBUFFER, 0); // Unbind any framebuffer
3851 #endif
3852
3853 return fboId;
3854 }
3855
3856 // Attach color buffer texture to a framebuffer object (unloads previous attachment)
3857 // NOTE: Attach type: 0-Color, 1-Depth renderbuffer, 2-Depth texture
3858 void rlFramebufferAttach(unsigned int id, unsigned int texId, int attachType, int texType, int mipLevel)
3859 {
3860 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
3861 glBindFramebuffer(GL_FRAMEBUFFER, id);
3862
3863 switch (attachType)
3864 {
3865 case RL_ATTACHMENT_COLOR_CHANNEL0:
3866 case RL_ATTACHMENT_COLOR_CHANNEL1:
3867 case RL_ATTACHMENT_COLOR_CHANNEL2:
3868 case RL_ATTACHMENT_COLOR_CHANNEL3:
3869 case RL_ATTACHMENT_COLOR_CHANNEL4:
3870 case RL_ATTACHMENT_COLOR_CHANNEL5:
3871 case RL_ATTACHMENT_COLOR_CHANNEL6:
3872 case RL_ATTACHMENT_COLOR_CHANNEL7:
3873 {
3874 if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_2D, texId, mipLevel);
3875 else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_RENDERBUFFER, texId);
3876 else if (texType >= RL_ATTACHMENT_CUBEMAP_POSITIVE_X) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_CUBE_MAP_POSITIVE_X + texType, texId, mipLevel);
3877 } break;
3878 case RL_ATTACHMENT_DEPTH:
3879 {
3880 if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel);
3881 else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, texId);
3882 } break;
3883 case RL_ATTACHMENT_STENCIL:
3884 {
3885 if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel);
3886 else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, texId);
3887 } break;
3888 default: break;
3889 }
3890
3891 glBindFramebuffer(GL_FRAMEBUFFER, 0);
3892 #endif
3893 }
3894
3895 // Verify render texture is complete
3896 bool rlFramebufferComplete(unsigned int id)
3897 {
3898 bool result = false;
3899
3900 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
3901 glBindFramebuffer(GL_FRAMEBUFFER, id);
3902
3903 GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
3904
3905 if (status != GL_FRAMEBUFFER_COMPLETE)
3906 {
3907 switch (status)
3908 {
3909 case GL_FRAMEBUFFER_UNSUPPORTED: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer is unsupported", id); break;
3910 case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete attachment", id); break;
3911 #if defined(GRAPHICS_API_OPENGL_ES2)
3912 case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete dimensions", id); break;
3913 #endif
3914 case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has a missing attachment", id); break;
3915 default: break;
3916 }
3917 }
3918
3919 glBindFramebuffer(GL_FRAMEBUFFER, 0);
3920
3921 result = (status == GL_FRAMEBUFFER_COMPLETE);
3922 #endif
3923
3924 return result;
3925 }
3926
3927 // Unload framebuffer from GPU memory
3928 // NOTE: All attached textures/cubemaps/renderbuffers are also deleted
3929 void rlUnloadFramebuffer(unsigned int id)
3930 {
3931 #if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_SOFTWARE))
3932 // Query depth attachment to automatically delete texture/renderbuffer
3933 int depthType = 0;
3934 glBindFramebuffer(GL_FRAMEBUFFER, id); // Bind framebuffer to query depth texture type
3935 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &depthType);
3936
3937 // WARNING: WebGL: INVALID_ENUM: getFramebufferAttachmentParameter: invalid parameter name
3938 // REF: https://registry.khronos.org/webgl/specs/latest/1.0/
3939 int depthId = 0;
3940 glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &depthId);
3941
3942 unsigned int depthIdU = (unsigned int)depthId;
3943 if (depthType == GL_RENDERBUFFER) glDeleteRenderbuffers(1, &depthIdU);
3944 else if (depthType == GL_TEXTURE) glDeleteTextures(1, &depthIdU);
3945
3946 // NOTE: If a texture object is deleted while its image is attached to the *currently bound* framebuffer,
3947 // the texture image is automatically detached from the currently bound framebuffer
3948
3949 glBindFramebuffer(GL_FRAMEBUFFER, 0);
3950 glDeleteFramebuffers(1, &id);
3951
3952 TRACELOG(RL_LOG_INFO, "FBO: [ID %i] Unloaded framebuffer from VRAM (GPU)", id);
3953 #endif
3954 }
3955
3956 // Vertex data management
3957 //-----------------------------------------------------------------------------------------
3958 // Load a new attributes buffer
3959 unsigned int rlLoadVertexBuffer(const void *buffer, int size, bool dynamic)
3960 {
3961 unsigned int id = 0;
3962 if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return id; }
3963
3964 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
3965 glGenBuffers(1, &id);
3966 glBindBuffer(GL_ARRAY_BUFFER, id);
3967 glBufferData(GL_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
3968 #endif
3969
3970 return id;
3971 }
3972
3973 // Load a new attributes element buffer
3974 unsigned int rlLoadVertexBufferElement(const void *buffer, int size, bool dynamic)
3975 {
3976 unsigned int id = 0;
3977 if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return id; }
3978
3979 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
3980 glGenBuffers(1, &id);
3981 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
3982 glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
3983 #endif
3984
3985 return id;
3986 }
3987
3988 // Enable vertex buffer (VBO)
3989 void rlEnableVertexBuffer(unsigned int id)
3990 {
3991 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
3992 glBindBuffer(GL_ARRAY_BUFFER, id);
3993 #endif
3994 }
3995
3996 // Disable vertex buffer (VBO)
3997 void rlDisableVertexBuffer(void)
3998 {
3999 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4000 glBindBuffer(GL_ARRAY_BUFFER, 0);
4001 #endif
4002 }
4003
4004 // Enable vertex buffer element (VBO element)
4005 void rlEnableVertexBufferElement(unsigned int id)
4006 {
4007 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4008 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
4009 #endif
4010 }
4011
4012 // Disable vertex buffer element (VBO element)
4013 void rlDisableVertexBufferElement(void)
4014 {
4015 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4016 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
4017 #endif
4018 }
4019
4020 // Update vertex buffer with new data
4021 // NOTE: dataSize and offset must be provided in bytes
4022 void rlUpdateVertexBuffer(unsigned int id, const void *data, int dataSize, int offset)
4023 {
4024 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4025 glBindBuffer(GL_ARRAY_BUFFER, id);
4026 glBufferSubData(GL_ARRAY_BUFFER, offset, dataSize, data);
4027 #endif
4028 }
4029
4030 // Update vertex buffer elements with new data
4031 // NOTE: dataSize and offset must be provided in bytes
4032 void rlUpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset)
4033 {
4034 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4035 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id);
4036 glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, dataSize, data);
4037 #endif
4038 }
4039
4040 // Enable vertex array object (VAO)
4041 bool rlEnableVertexArray(unsigned int vaoId)
4042 {
4043 bool result = false;
4044 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4045 if (RLGL.ExtSupported.vao)
4046 {
4047 glBindVertexArray(vaoId);
4048 result = true;
4049 }
4050 #endif
4051 return result;
4052 }
4053
4054 // Disable vertex array object (VAO)
4055 void rlDisableVertexArray(void)
4056 {
4057 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4058 if (RLGL.ExtSupported.vao) glBindVertexArray(0);
4059 #endif
4060 }
4061
4062 // Enable vertex attribute index
4063 void rlEnableVertexAttribute(unsigned int index)
4064 {
4065 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4066 glEnableVertexAttribArray(index);
4067 #endif
4068 }
4069
4070 // Disable vertex attribute index
4071 void rlDisableVertexAttribute(unsigned int index)
4072 {
4073 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4074 glDisableVertexAttribArray(index);
4075 #endif
4076 }
4077
4078 // Draw vertex array
4079 void rlDrawVertexArray(int offset, int count)
4080 {
4081 glDrawArrays(GL_TRIANGLES, offset, count);
4082 }
4083
4084 // Draw vertex array elements
4085 void rlDrawVertexArrayElements(int offset, int count, const void *buffer)
4086 {
4087 // NOTE: Added pointer math separately from function to avoid UBSAN complaining
4088 unsigned short *bufferPtr = (unsigned short *)buffer;
4089 if (offset > 0) bufferPtr += offset;
4090
4091 glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)bufferPtr);
4092 }
4093
4094 // Draw vertex array instanced
4095 void rlDrawVertexArrayInstanced(int offset, int count, int instances)
4096 {
4097 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4098 glDrawArraysInstanced(GL_TRIANGLES, offset, count, instances);
4099 #endif
4100 }
4101
4102 // Draw vertex array elements instanced
4103 void rlDrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances)
4104 {
4105 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4106 // NOTE: Added pointer math separately from function to avoid UBSAN complaining
4107 unsigned short *bufferPtr = (unsigned short *)buffer;
4108 if (offset > 0) bufferPtr += offset;
4109
4110 glDrawElementsInstanced(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)bufferPtr, instances);
4111 #endif
4112 }
4113
4114 // Enable vertex state pointer
4115 void rlEnableStatePointer(int vertexAttribType, void *buffer)
4116 {
4117 #if defined(GRAPHICS_API_OPENGL_11)
4118 if (buffer != NULL) glEnableClientState(vertexAttribType);
4119 switch (vertexAttribType)
4120 {
4121 case GL_VERTEX_ARRAY: glVertexPointer(3, GL_FLOAT, 0, buffer); break;
4122 case GL_TEXTURE_COORD_ARRAY: glTexCoordPointer(2, GL_FLOAT, 0, buffer); break;
4123 case GL_NORMAL_ARRAY: if (buffer != NULL) glNormalPointer(GL_FLOAT, 0, buffer); break;
4124 case GL_COLOR_ARRAY: if (buffer != NULL) glColorPointer(4, GL_UNSIGNED_BYTE, 0, buffer); break;
4125 //case GL_INDEX_ARRAY: if (buffer != NULL) glIndexPointer(GL_SHORT, 0, buffer); break; // Indexed colors
4126 default: break;
4127 }
4128 #endif
4129 }
4130
4131 // Disable vertex state pointer
4132 void rlDisableStatePointer(int vertexAttribType)
4133 {
4134 #if defined(GRAPHICS_API_OPENGL_11)
4135 glDisableClientState(vertexAttribType);
4136 #endif
4137 }
4138
4139 // Load vertex array object (VAO)
4140 unsigned int rlLoadVertexArray(void)
4141 {
4142 unsigned int vaoId = 0;
4143 if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return vaoId; }
4144
4145 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4146 if (RLGL.ExtSupported.vao) glGenVertexArrays(1, &vaoId);
4147 #endif
4148
4149 return vaoId;
4150 }
4151
4152 // Set vertex attribute
4153 void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, int offset)
4154 {
4155 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4156 // NOTE: Data type could be: GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT
4157 // Additional types (depends on OpenGL version or extensions):
4158 // - GL_HALF_FLOAT, GL_FLOAT, GL_DOUBLE, GL_FIXED,
4159 // - GL_INT_2_10_10_10_REV, GL_UNSIGNED_INT_2_10_10_10_REV, GL_UNSIGNED_INT_10F_11F_11F_REV
4160
4161 size_t offsetNative = offset;
4162 glVertexAttribPointer(index, compSize, type, normalized, stride, (void *)offsetNative);
4163 #endif
4164 }
4165
4166 // Set vertex attribute divisor
4167 void rlSetVertexAttributeDivisor(unsigned int index, int divisor)
4168 {
4169 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4170 glVertexAttribDivisor(index, divisor);
4171 #endif
4172 }
4173
4174 // Unload vertex array object (VAO)
4175 void rlUnloadVertexArray(unsigned int vaoId)
4176 {
4177 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4178 if (RLGL.ExtSupported.vao)
4179 {
4180 glBindVertexArray(0);
4181 glDeleteVertexArrays(1, &vaoId);
4182 TRACELOG(RL_LOG_INFO, "VAO: [ID %i] Unloaded vertex array data from VRAM (GPU)", vaoId);
4183 }
4184 #endif
4185 }
4186
4187 // Unload vertex buffer (VBO)
4188 void rlUnloadVertexBuffer(unsigned int vboId)
4189 {
4190 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4191 glDeleteBuffers(1, &vboId);
4192 //TRACELOG(RL_LOG_INFO, "VBO: Unloaded vertex data from VRAM (GPU)");
4193 #endif
4194 }
4195
4196 // Shaders management
4197 //-----------------------------------------------------------------------------------------------
4198 // Load (compile) shader and return shader id
4199 unsigned int rlLoadShader(const char *code, int type)
4200 {
4201 unsigned int shaderId = 0;
4202
4203 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4204 shaderId = glCreateShader(type);
4205 glShaderSource(shaderId, 1, &code, NULL);
4206
4207 GLint success = 0;
4208 glCompileShader(shaderId);
4209 glGetShaderiv(shaderId, GL_COMPILE_STATUS, &success);
4210
4211 if (success == GL_FALSE)
4212 {
4213 switch (type)
4214 {
4215 case GL_VERTEX_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile vertex shader code", shaderId); break;
4216 case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile fragment shader code", shaderId); break;
4217 //case GL_GEOMETRY_SHADER:
4218 #if defined(GRAPHICS_API_OPENGL_43)
4219 case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile compute shader code", shaderId); break;
4220 #elif defined(GRAPHICS_API_OPENGL_33)
4221 case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", shaderId); break;
4222 #endif
4223 default: break;
4224 }
4225
4226 int maxLength = 0;
4227 glGetShaderiv(shaderId, GL_INFO_LOG_LENGTH, &maxLength);
4228
4229 if (maxLength > 0)
4230 {
4231 int length = 0;
4232 char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
4233 glGetShaderInfoLog(shaderId, maxLength, &length, log);
4234 TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shaderId, log);
4235 RL_FREE(log);
4236 }
4237
4238 // Unload object allocated by glCreateShader(),
4239 // despite failing in the compilation process
4240 glDeleteShader(shaderId);
4241 shaderId = 0;
4242 }
4243 else
4244 {
4245 switch (type)
4246 {
4247 case GL_VERTEX_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Vertex shader compiled successfully", shaderId); break;
4248 case GL_FRAGMENT_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Fragment shader compiled successfully", shaderId); break;
4249 //case GL_GEOMETRY_SHADER:
4250 #if defined(GRAPHICS_API_OPENGL_43)
4251 case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader compiled successfully", shaderId); break;
4252 #elif defined(GRAPHICS_API_OPENGL_33)
4253 case GL_COMPUTE_SHADER: TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not enabled. Define GRAPHICS_API_OPENGL_43", shaderId); break;
4254 #endif
4255 default: break;
4256 }
4257 }
4258 #endif
4259
4260 return shaderId;
4261 }
4262
4263 // Load shader program from code strings
4264 // NOTE: If shader string is NULL, using default vertex/fragment shaders
4265 unsigned int rlLoadShaderProgram(const char *vsCode, const char *fsCode)
4266 {
4267 unsigned int id = 0; // Shader program id
4268 if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return id; }
4269
4270 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4271 unsigned int vertexShaderId = 0;
4272 unsigned int fragmentShaderId = 0;
4273
4274 // Compile vertex shader (if provided)
4275 // NOTE: If not vertex shader is provided, use default one
4276 if (vsCode != NULL) vertexShaderId = rlLoadShader(vsCode, GL_VERTEX_SHADER);
4277 else vertexShaderId = RLGL.State.defaultVShaderId;
4278
4279 // Compile fragment shader (if provided)
4280 // NOTE: If not vertex shader is provided, use default one
4281 if (fsCode != NULL) fragmentShaderId = rlLoadShader(fsCode, GL_FRAGMENT_SHADER);
4282 else fragmentShaderId = RLGL.State.defaultFShaderId;
4283
4284 // In case vertex and fragment shader are the default ones, no need to recompile, assign the default shader program id
4285 if ((vertexShaderId == RLGL.State.defaultVShaderId) && (fragmentShaderId == RLGL.State.defaultFShaderId)) id = RLGL.State.defaultShaderId;
4286 else if ((vertexShaderId > 0) && (fragmentShaderId > 0))
4287 {
4288 // One of or both shader are new, a new shader program needs to be compiled
4289 id = rlLoadShaderProgramEx(vertexShaderId, fragmentShaderId);
4290
4291 // Detaching and deleting vertex/fragment shaders (if not default ones)
4292 // WARNING: Detach shader before deletion to make sure memory is freed
4293 if (vertexShaderId != RLGL.State.defaultVShaderId)
4294 {
4295 // WARNING: Shader program linkage could fail and returned id is 0
4296 if (id > 0) glDetachShader(id, vertexShaderId);
4297 glDeleteShader(vertexShaderId);
4298 }
4299 if (fragmentShaderId != RLGL.State.defaultFShaderId)
4300 {
4301 // WARNING: Shader program linkage could fail and returned id is 0
4302 if (id > 0) glDetachShader(id, fragmentShaderId);
4303 glDeleteShader(fragmentShaderId);
4304 }
4305
4306 // In case shader program loading failed, assign default shader
4307 if (id == 0)
4308 {
4309 // In case shader loading fails, reassigning default shader
4310 TRACELOG(RL_LOG_WARNING, "SHADER: Failed to load custom shader code, using default shader");
4311 id = RLGL.State.defaultShaderId;
4312 }
4313 /*
4314 else
4315 {
4316 // Get available shader uniforms
4317 // NOTE: This information is useful for debug...
4318 int uniformCount = -1;
4319 glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &uniformCount);
4320
4321 for (int i = 0; i < uniformCount; i++)
4322 {
4323 int namelen = -1;
4324 int num = -1;
4325 char name[256] = { 0 }; // Assume no variable names longer than 256
4326 GLenum type = GL_ZERO;
4327
4328 // Get the name of the uniforms
4329 glGetActiveUniform(id, i, sizeof(name) - 1, &namelen, &num, &type, name);
4330
4331 name[namelen] = 0;
4332 TRACELOG(RL_LOG_DEBUG, "SHADER: [ID %i] Active uniform (%s) set at location: %i", id, name, glGetUniformLocation(id, name));
4333 }
4334 }
4335 */
4336 }
4337 #endif
4338
4339 return id;
4340 }
4341
4342 // Load shader program from already loaded shader ids
4343 unsigned int rlLoadShaderProgramEx(unsigned int vsId, unsigned int fsId)
4344 {
4345 unsigned int programId = 0;
4346 if (!isGpuReady) { TRACELOG(RL_LOG_WARNING, "GL: GPU is not ready to load data, trying to load before InitWindow()?"); return programId; }
4347
4348 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4349 GLint success = 0;
4350 programId = glCreateProgram();
4351
4352 glAttachShader(programId, vsId);
4353 glAttachShader(programId, fsId);
4354
4355 // Default attribute shader locations must be bound before linking
4356 // NOTE: There is no problem with binding a generic attribute index to an attribute variable name
4357 // that is never used; if some attrib name is no found on the shader, it locations becomes -1
4358 glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION, RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION);
4359 glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD);
4360 glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL, RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL);
4361 glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_COLOR, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR);
4362 glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_TANGENT, RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT);
4363 glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD2, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2);
4364 glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_INSTANCETRANSFORM, RL_DEFAULT_SHADER_ATTRIB_NAME_INSTANCETRANSFORM);
4365 glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEINDICES, RL_DEFAULT_SHADER_ATTRIB_NAME_BONEINDICES);
4366 glBindAttribLocation(programId, RL_DEFAULT_SHADER_ATTRIB_LOCATION_BONEWEIGHTS, RL_DEFAULT_SHADER_ATTRIB_NAME_BONEWEIGHTS);
4367
4368 glLinkProgram(programId);
4369
4370 // NOTE: All uniform variables are intitialised to 0 when a program links
4371
4372 glGetProgramiv(programId, GL_LINK_STATUS, &success);
4373
4374 if (success == GL_FALSE)
4375 {
4376 TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link shader program", programId);
4377
4378 int maxLength = 0;
4379 glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &maxLength);
4380
4381 if (maxLength > 0)
4382 {
4383 int length = 0;
4384 char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
4385 glGetProgramInfoLog(programId, maxLength, &length, log);
4386 TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", programId, log);
4387 RL_FREE(log);
4388 }
4389
4390 glDeleteProgram(programId);
4391
4392 programId = 0;
4393 }
4394 else
4395 {
4396 // Get the size of compiled shader program (not available on OpenGL ES 2.0)
4397 // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero
4398 //GLint binarySize = 0;
4399 //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize);
4400
4401 TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Program shader loaded successfully", programId);
4402 }
4403 #endif
4404 return programId;
4405 }
4406
4407 // Load compute shader program
4408 unsigned int rlLoadShaderProgramCompute(unsigned int csId)
4409 {
4410 unsigned int programId = 0;
4411
4412 #if defined(GRAPHICS_API_OPENGL_43)
4413 GLint success = 0;
4414 programId = glCreateProgram();
4415
4416 glAttachShader(programId, csId);
4417
4418 glLinkProgram(programId);
4419
4420 // NOTE: All uniform variables are intitialised to 0 when a program links
4421
4422 glGetProgramiv(programId, GL_LINK_STATUS, &success);
4423
4424 if (success == GL_FALSE)
4425 {
4426 TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link compute shader program", programId);
4427
4428 int maxLength = 0;
4429 glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &maxLength);
4430
4431 if (maxLength > 0)
4432 {
4433 int length = 0;
4434 char *log = (char *)RL_CALLOC(maxLength, sizeof(char));
4435 glGetProgramInfoLog(programId, maxLength, &length, log);
4436 TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", programId, log);
4437 RL_FREE(log);
4438 }
4439
4440 glDeleteProgram(programId);
4441
4442 programId = 0;
4443 }
4444 else
4445 {
4446 // Get the size of compiled shader program (not available on OpenGL ES 2.0)
4447 // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero
4448 //GLint binarySize = 0;
4449 //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize);
4450
4451 TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader program loaded successfully", programId);
4452 }
4453 #else
4454 TRACELOG(RL_LOG_WARNING, "SHADER: Compute shaders not supported, enable GRAPHICS_API_OPENGL_43");
4455 #endif
4456
4457 return programId;
4458 }
4459
4460 // Delete shader
4461 void rlUnloadShader(unsigned int id)
4462 {
4463 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4464 glDeleteShader(id);
4465
4466 TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Unloaded shader data from VRAM (GPU)", id);
4467 #endif
4468 }
4469
4470 // Unload shader program
4471 void rlUnloadShaderProgram(unsigned int id)
4472 {
4473 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4474 glDeleteProgram(id);
4475
4476 TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Unloaded shader program data from VRAM (GPU)", id);
4477 #endif
4478 }
4479
4480 // Get shader location uniform
4481 // NOTE: First parameter refers to shader program id
4482 int rlGetLocationUniform(unsigned int id, const char *uniformName)
4483 {
4484 int location = -1;
4485 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4486 location = glGetUniformLocation(id, uniformName);
4487
4488 //if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader uniform: %s", shaderId, uniformName);
4489 //else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader uniform (%s) set at location: %i", shaderId, uniformName, location);
4490 #endif
4491 return location;
4492 }
4493
4494 // Get shader location attribute
4495 // NOTE: First parameter refers to shader program id
4496 int rlGetLocationAttrib(unsigned int id, const char *attribName)
4497 {
4498 int location = -1;
4499 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4500 location = glGetAttribLocation(id, attribName);
4501
4502 //if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader attribute: %s", shaderId, attribName);
4503 //else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader attribute (%s) set at location: %i", shaderId, attribName, location);
4504 #endif
4505 return location;
4506 }
4507
4508 // Set shader value uniform
4509 void rlSetUniform(int locIndex, const void *value, int uniformType, int count)
4510 {
4511 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4512 switch (uniformType)
4513 {
4514 case RL_SHADER_UNIFORM_FLOAT: glUniform1fv(locIndex, count, (float *)value); break;
4515 case RL_SHADER_UNIFORM_VEC2: glUniform2fv(locIndex, count, (float *)value); break;
4516 case RL_SHADER_UNIFORM_VEC3: glUniform3fv(locIndex, count, (float *)value); break;
4517 case RL_SHADER_UNIFORM_VEC4: glUniform4fv(locIndex, count, (float *)value); break;
4518 case RL_SHADER_UNIFORM_INT: glUniform1iv(locIndex, count, (int *)value); break;
4519 case RL_SHADER_UNIFORM_IVEC2: glUniform2iv(locIndex, count, (int *)value); break;
4520 case RL_SHADER_UNIFORM_IVEC3: glUniform3iv(locIndex, count, (int *)value); break;
4521 case RL_SHADER_UNIFORM_IVEC4: glUniform4iv(locIndex, count, (int *)value); break;
4522 #if !defined(GRAPHICS_API_OPENGL_ES2)
4523 case RL_SHADER_UNIFORM_UINT: glUniform1uiv(locIndex, count, (unsigned int *)value); break;
4524 case RL_SHADER_UNIFORM_UIVEC2: glUniform2uiv(locIndex, count, (unsigned int *)value); break;
4525 case RL_SHADER_UNIFORM_UIVEC3: glUniform3uiv(locIndex, count, (unsigned int *)value); break;
4526 case RL_SHADER_UNIFORM_UIVEC4: glUniform4uiv(locIndex, count, (unsigned int *)value); break;
4527 #endif
4528 case RL_SHADER_UNIFORM_SAMPLER2D: glUniform1iv(locIndex, count, (int *)value); break;
4529 default: TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set uniform value, data type not recognized");
4530 }
4531 #endif
4532 }
4533
4534 // Set shader value attribute
4535 void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count)
4536 {
4537 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4538 switch (attribType)
4539 {
4540 case RL_SHADER_ATTRIB_FLOAT: if (count == 1) glVertexAttrib1fv(locIndex, (float *)value); break;
4541 case RL_SHADER_ATTRIB_VEC2: if (count == 2) glVertexAttrib2fv(locIndex, (float *)value); break;
4542 case RL_SHADER_ATTRIB_VEC3: if (count == 3) glVertexAttrib3fv(locIndex, (float *)value); break;
4543 case RL_SHADER_ATTRIB_VEC4: if (count == 4) glVertexAttrib4fv(locIndex, (float *)value); break;
4544 default: TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set attrib default value, data type not recognized");
4545 }
4546 #endif
4547 }
4548
4549 // Set shader value uniform matrix
4550 void rlSetUniformMatrix(int locIndex, Matrix mat)
4551 {
4552 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4553 glUniformMatrix4fv(locIndex, 1, false, rlMatrixToFloat(mat));
4554 #endif
4555 }
4556
4557 // Set shader value uniform matrix
4558 void rlSetUniformMatrices(int locIndex, const Matrix *matrices, int count)
4559 {
4560 #if defined(GRAPHICS_API_OPENGL_33)
4561 glUniformMatrix4fv(locIndex, count, true, (const float *)matrices);
4562 #elif defined(GRAPHICS_API_OPENGL_ES2)
4563 // WARNING: WebGL does not support Matrix transpose ("true" parameter)
4564 // REF: https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/uniformMatrix
4565 glUniformMatrix4fv(locIndex, count, false, (const float *)matrices);
4566 #endif
4567 }
4568
4569 // Set shader value uniform sampler
4570 void rlSetUniformSampler(int locIndex, unsigned int textureId)
4571 {
4572 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4573 // Check if texture is already active
4574 for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++)
4575 {
4576 if (RLGL.State.activeTextureId[i] == textureId)
4577 {
4578 glUniform1i(locIndex, 1 + i);
4579 return;
4580 }
4581 }
4582
4583 // Register a new active texture for the internal batch system
4584 // NOTE: Default texture is always activated as GL_TEXTURE0
4585 for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++)
4586 {
4587 if (RLGL.State.activeTextureId[i] == 0)
4588 {
4589 glUniform1i(locIndex, 1 + i); // Activate new texture unit
4590 RLGL.State.activeTextureId[i] = textureId; // Save texture id for binding on drawing
4591 break;
4592 }
4593 }
4594 #endif
4595 }
4596
4597 // Set shader currently active (id and locations)
4598 void rlSetShader(unsigned int id, int *locs)
4599 {
4600 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4601 if (RLGL.State.currentShaderId != id)
4602 {
4603 rlDrawRenderBatch(RLGL.currentBatch);
4604 RLGL.State.currentShaderId = id;
4605 RLGL.State.currentShaderLocs = locs;
4606 }
4607 #endif
4608 }
4609
4610 // Dispatch compute shader (equivalent to *draw* for graphics pilepine)
4611 void rlComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ)
4612 {
4613 #if defined(GRAPHICS_API_OPENGL_43)
4614 glDispatchCompute(groupX, groupY, groupZ);
4615 #endif
4616 }
4617
4618 // Load shader storage buffer object (SSBO)
4619 unsigned int rlLoadShaderBuffer(unsigned int size, const void *data, int usageHint)
4620 {
4621 unsigned int ssbo = 0;
4622
4623 #if defined(GRAPHICS_API_OPENGL_43)
4624 glGenBuffers(1, &ssbo);
4625 glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo);
4626 glBufferData(GL_SHADER_STORAGE_BUFFER, size, data, usageHint? usageHint : RL_STREAM_COPY);
4627 if (data == NULL) glClearBufferData(GL_SHADER_STORAGE_BUFFER, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, NULL); // Clear buffer data to 0
4628 glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
4629 #else
4630 TRACELOG(RL_LOG_WARNING, "SSBO: SSBO not enabled. Define GRAPHICS_API_OPENGL_43");
4631 #endif
4632
4633 return ssbo;
4634 }
4635
4636 // Unload shader storage buffer object (SSBO)
4637 void rlUnloadShaderBuffer(unsigned int ssboId)
4638 {
4639 #if defined(GRAPHICS_API_OPENGL_43)
4640 glDeleteBuffers(1, &ssboId);
4641 #else
4642 TRACELOG(RL_LOG_WARNING, "SSBO: SSBO not enabled. Define GRAPHICS_API_OPENGL_43");
4643 #endif
4644 }
4645
4646 // Update SSBO buffer data
4647 void rlUpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset)
4648 {
4649 #if defined(GRAPHICS_API_OPENGL_43)
4650 glBindBuffer(GL_SHADER_STORAGE_BUFFER, id);
4651 glBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, dataSize, data);
4652 #endif
4653 }
4654
4655 // Get SSBO buffer size
4656 unsigned int rlGetShaderBufferSize(unsigned int id)
4657 {
4658 unsigned int result = 0;
4659 #if defined(GRAPHICS_API_OPENGL_43)
4660 GLint64 size = 0;
4661 glBindBuffer(GL_SHADER_STORAGE_BUFFER, id);
4662 glGetBufferParameteri64v(GL_SHADER_STORAGE_BUFFER, GL_BUFFER_SIZE, &size);
4663 if (size > 0) result = (unsigned int)size;
4664 #endif
4665 return result;
4666 }
4667
4668 // Read SSBO buffer data (GPU->CPU)
4669 void rlReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset)
4670 {
4671 #if defined(GRAPHICS_API_OPENGL_43)
4672 glBindBuffer(GL_SHADER_STORAGE_BUFFER, id);
4673 glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, count, dest);
4674 #endif
4675 }
4676
4677 // Bind SSBO buffer
4678 void rlBindShaderBuffer(unsigned int id, unsigned int index)
4679 {
4680 #if defined(GRAPHICS_API_OPENGL_43)
4681 glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, id);
4682 #endif
4683 }
4684
4685 // Copy SSBO buffer data
4686 void rlCopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count)
4687 {
4688 #if defined(GRAPHICS_API_OPENGL_43)
4689 glBindBuffer(GL_COPY_READ_BUFFER, srcId);
4690 glBindBuffer(GL_COPY_WRITE_BUFFER, destId);
4691 glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, srcOffset, destOffset, count);
4692 #endif
4693 }
4694
4695 // Bind image texture
4696 void rlBindImageTexture(unsigned int id, unsigned int index, int format, bool readonly)
4697 {
4698 #if defined(GRAPHICS_API_OPENGL_43)
4699 unsigned int glInternalFormat = 0, glFormat = 0, glType = 0;
4700
4701 rlGetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType);
4702 glBindImageTexture(index, id, 0, 0, 0, readonly? GL_READ_ONLY : GL_READ_WRITE, glInternalFormat);
4703 #else
4704 TRACELOG(RL_LOG_WARNING, "TEXTURE: Image texture binding not enabled. Define GRAPHICS_API_OPENGL_43");
4705 #endif
4706 }
4707
4708 // Matrix state management
4709 //-----------------------------------------------------------------------------------------
4710 // Get internal modelview matrix
4711 Matrix rlGetMatrixModelview(void)
4712 {
4713 Matrix matrix = rlMatrixIdentity();
4714 #if defined(GRAPHICS_API_OPENGL_11)
4715 float mat[16];
4716 glGetFloatv(GL_MODELVIEW_MATRIX, mat);
4717 matrix.m0 = mat[0];
4718 matrix.m1 = mat[1];
4719 matrix.m2 = mat[2];
4720 matrix.m3 = mat[3];
4721 matrix.m4 = mat[4];
4722 matrix.m5 = mat[5];
4723 matrix.m6 = mat[6];
4724 matrix.m7 = mat[7];
4725 matrix.m8 = mat[8];
4726 matrix.m9 = mat[9];
4727 matrix.m10 = mat[10];
4728 matrix.m11 = mat[11];
4729 matrix.m12 = mat[12];
4730 matrix.m13 = mat[13];
4731 matrix.m14 = mat[14];
4732 matrix.m15 = mat[15];
4733 #else
4734 matrix = RLGL.State.modelview;
4735 #endif
4736 return matrix;
4737 }
4738
4739 // Get internal projection matrix
4740 Matrix rlGetMatrixProjection(void)
4741 {
4742 #if defined(GRAPHICS_API_OPENGL_11)
4743 float mat[16];
4744 glGetFloatv(GL_PROJECTION_MATRIX,mat);
4745 Matrix m;
4746 m.m0 = mat[0];
4747 m.m1 = mat[1];
4748 m.m2 = mat[2];
4749 m.m3 = mat[3];
4750 m.m4 = mat[4];
4751 m.m5 = mat[5];
4752 m.m6 = mat[6];
4753 m.m7 = mat[7];
4754 m.m8 = mat[8];
4755 m.m9 = mat[9];
4756 m.m10 = mat[10];
4757 m.m11 = mat[11];
4758 m.m12 = mat[12];
4759 m.m13 = mat[13];
4760 m.m14 = mat[14];
4761 m.m15 = mat[15];
4762 return m;
4763 #else
4764 return RLGL.State.projection;
4765 #endif
4766 }
4767
4768 // Get internal accumulated transform matrix
4769 Matrix rlGetMatrixTransform(void)
4770 {
4771 Matrix mat = rlMatrixIdentity();
4772 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4773 // TODO: Consider possible transform matrices in the RLGL.State.stack
4774 //Matrix matStackTransform = rlMatrixIdentity();
4775 //for (int i = RLGL.State.stackCounter; i > 0; i--) matStackTransform = rlMatrixMultiply(RLGL.State.stack[i], matStackTransform);
4776
4777 mat = RLGL.State.transform;
4778 #endif
4779 return mat;
4780 }
4781
4782 // Get internal projection matrix for stereo render (selected eye)
4783 Matrix rlGetMatrixProjectionStereo(int eye)
4784 {
4785 Matrix mat = rlMatrixIdentity();
4786 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4787 mat = RLGL.State.projectionStereo[eye];
4788 #endif
4789 return mat;
4790 }
4791
4792 // Get internal view offset matrix for stereo render (selected eye)
4793 Matrix rlGetMatrixViewOffsetStereo(int eye)
4794 {
4795 Matrix mat = rlMatrixIdentity();
4796 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4797 mat = RLGL.State.viewOffsetStereo[eye];
4798 #endif
4799 return mat;
4800 }
4801
4802 // Set a custom modelview matrix (replaces internal modelview matrix)
4803 void rlSetMatrixModelview(Matrix view)
4804 {
4805 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4806 RLGL.State.modelview = view;
4807 #endif
4808 }
4809
4810 // Set a custom projection matrix (replaces internal projection matrix)
4811 void rlSetMatrixProjection(Matrix projection)
4812 {
4813 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4814 RLGL.State.projection = projection;
4815 #endif
4816 }
4817
4818 // Set eyes projection matrices for stereo rendering
4819 void rlSetMatrixProjectionStereo(Matrix right, Matrix left)
4820 {
4821 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4822 RLGL.State.projectionStereo[0] = right;
4823 RLGL.State.projectionStereo[1] = left;
4824 #endif
4825 }
4826
4827 // Set eyes view offsets matrices for stereo rendering
4828 void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left)
4829 {
4830 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4831 RLGL.State.viewOffsetStereo[0] = right;
4832 RLGL.State.viewOffsetStereo[1] = left;
4833 #endif
4834 }
4835
4836 // Load and draw a quad in NDC
4837 void rlLoadDrawQuad(void)
4838 {
4839 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4840 unsigned int quadVAO = 0;
4841 unsigned int quadVBO = 0;
4842
4843 float vertices[] = {
4844 // Positions Texcoords
4845 -1.0f, 1.0f, 0.0f, 0.0f, 1.0f,
4846 -1.0f, -1.0f, 0.0f, 0.0f, 0.0f,
4847 1.0f, 1.0f, 0.0f, 1.0f, 1.0f,
4848 1.0f, -1.0f, 0.0f, 1.0f, 0.0f,
4849 };
4850
4851 // Gen VAO to contain VBO
4852 glGenVertexArrays(1, &quadVAO);
4853 glBindVertexArray(quadVAO);
4854
4855 // Gen and fill vertex buffer (VBO)
4856 glGenBuffers(1, &quadVBO);
4857 glBindBuffer(GL_ARRAY_BUFFER, quadVBO);
4858 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW);
4859
4860 // Bind vertex attributes (position, texcoords)
4861 glEnableVertexAttribArray(RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION);
4862 glVertexAttribPointer(RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION, 3, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void *)0); // Positions
4863 glEnableVertexAttribArray(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD);
4864 glVertexAttribPointer(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void *)(3*sizeof(float))); // Texcoords
4865
4866 // Draw quad
4867 glBindVertexArray(quadVAO);
4868 glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
4869 glBindVertexArray(0);
4870
4871 // Delete buffers (VBO and VAO)
4872 glDeleteBuffers(1, &quadVBO);
4873 glDeleteVertexArrays(1, &quadVAO);
4874 #endif
4875 }
4876
4877 // Load and draw a cube in NDC
4878 void rlLoadDrawCube(void)
4879 {
4880 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4881 unsigned int cubeVAO = 0;
4882 unsigned int cubeVBO = 0;
4883
4884 float vertices[] = {
4885 // Positions Normals Texcoords
4886 -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
4887 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
4888 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f,
4889 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f,
4890 -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f,
4891 -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f,
4892 -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
4893 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f,
4894 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
4895 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
4896 -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f,
4897 -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
4898 -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
4899 -1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
4900 -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
4901 -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
4902 -1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
4903 -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
4904 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
4905 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
4906 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f,
4907 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,
4908 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,
4909 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f,
4910 -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
4911 1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f,
4912 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
4913 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f,
4914 -1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f,
4915 -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f,
4916 -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
4917 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
4918 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,
4919 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f,
4920 -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,
4921 -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f
4922 };
4923
4924 // Gen VAO to contain VBO
4925 glGenVertexArrays(1, &cubeVAO);
4926 glBindVertexArray(cubeVAO);
4927
4928 // Gen and fill vertex buffer (VBO)
4929 glGenBuffers(1, &cubeVBO);
4930 glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
4931 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
4932
4933 // Bind vertex attributes (position, normals, texcoords)
4934 glBindVertexArray(cubeVAO);
4935 glEnableVertexAttribArray(RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION);
4936 glVertexAttribPointer(RL_DEFAULT_SHADER_ATTRIB_LOCATION_POSITION, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)0); // Positions
4937 glEnableVertexAttribArray(RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL);
4938 glVertexAttribPointer(RL_DEFAULT_SHADER_ATTRIB_LOCATION_NORMAL, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)(3*sizeof(float))); // Normals
4939 glEnableVertexAttribArray(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD);
4940 glVertexAttribPointer(RL_DEFAULT_SHADER_ATTRIB_LOCATION_TEXCOORD, 2, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)(6*sizeof(float))); // Texcoords
4941 glBindBuffer(GL_ARRAY_BUFFER, 0);
4942 glBindVertexArray(0);
4943
4944 // Draw cube
4945 glBindVertexArray(cubeVAO);
4946 glDrawArrays(GL_TRIANGLES, 0, 36);
4947 glBindVertexArray(0);
4948
4949 // Delete VBO and VAO
4950 glDeleteBuffers(1, &cubeVBO);
4951 glDeleteVertexArrays(1, &cubeVAO);
4952 #endif
4953 }
4954
4955 // Get name string for pixel format
4956 const char *rlGetPixelFormatName(unsigned int format)
4957 {
4958 switch (format)
4959 {
4960 case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: return "GRAYSCALE"; break; // 8 bit per pixel (no alpha)
4961 case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: return "GRAY_ALPHA"; break; // 8*2 bpp (2 channels)
4962 case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: return "R5G6B5"; break; // 16 bpp
4963 case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: return "R8G8B8"; break; // 24 bpp
4964 case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: return "R5G5B5A1"; break; // 16 bpp (1 bit alpha)
4965 case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: return "R4G4B4A4"; break; // 16 bpp (4 bit alpha)
4966 case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: return "R8G8B8A8"; break; // 32 bpp
4967 case RL_PIXELFORMAT_UNCOMPRESSED_R32: return "R32"; break; // 32 bpp (1 channel - float)
4968 case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: return "R32G32B32"; break; // 32*3 bpp (3 channels - float)
4969 case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: return "R32G32B32A32"; break; // 32*4 bpp (4 channels - float)
4970 case RL_PIXELFORMAT_UNCOMPRESSED_R16: return "R16"; break; // 16 bpp (1 channel - half float)
4971 case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: return "R16G16B16"; break; // 16*3 bpp (3 channels - half float)
4972 case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: return "R16G16B16A16"; break; // 16*4 bpp (4 channels - half float)
4973 case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: return "DXT1_RGB"; break; // 4 bpp (no alpha)
4974 case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: return "DXT1_RGBA"; break; // 4 bpp (1 bit alpha)
4975 case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: return "DXT3_RGBA"; break; // 8 bpp
4976 case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: return "DXT5_RGBA"; break; // 8 bpp
4977 case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: return "ETC1_RGB"; break; // 4 bpp
4978 case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: return "ETC2_RGB"; break; // 4 bpp
4979 case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: return "ETC2_RGBA"; break; // 8 bpp
4980 case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: return "PVRT_RGB"; break; // 4 bpp
4981 case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: return "PVRT_RGBA"; break; // 4 bpp
4982 case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: return "ASTC_4x4_RGBA"; break; // 8 bpp
4983 case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: return "ASTC_8x8_RGBA"; break; // 2 bpp
4984 default: return "UNKNOWN"; break;
4985 }
4986 }
4987
4988 //----------------------------------------------------------------------------------
4989 // Module Functions Definition
4990 //----------------------------------------------------------------------------------
4991 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
4992 // Load default shader (just vertex positioning and texture coloring)
4993 // NOTE: This shader program is used for internal buffers
4994 // NOTE: Loaded: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs
4995 static void rlLoadShaderDefault(void)
4996 {
4997 RLGL.State.defaultShaderLocs = (int *)RL_CALLOC(RL_MAX_SHADER_LOCATIONS, sizeof(int));
4998
4999 // NOTE: All locations must be reseted to -1 (no location)
5000 for (int i = 0; i < RL_MAX_SHADER_LOCATIONS; i++) RLGL.State.defaultShaderLocs[i] = -1;
5001
5002 // Vertex shader directly defined, no external file required
5003 const char *defaultVShaderCode =
5004 #if defined(GRAPHICS_API_OPENGL_21)
5005 "#version 120 \n"
5006 "attribute vec3 vertexPosition; \n"
5007 "attribute vec2 vertexTexCoord; \n"
5008 "attribute vec4 vertexColor; \n"
5009 "varying vec2 fragTexCoord; \n"
5010 "varying vec4 fragColor; \n"
5011 #elif defined(GRAPHICS_API_OPENGL_33)
5012 "#version 330 \n"
5013 "in vec3 vertexPosition; \n"
5014 "in vec2 vertexTexCoord; \n"
5015 "in vec4 vertexColor; \n"
5016 "out vec2 fragTexCoord; \n"
5017 "out vec4 fragColor; \n"
5018 #endif
5019
5020 #if defined(GRAPHICS_API_OPENGL_ES3)
5021 "#version 300 es \n"
5022 "precision mediump float; \n" // Precision required for OpenGL ES3 (WebGL 2) (on some browsers)
5023 "in vec3 vertexPosition; \n"
5024 "in vec2 vertexTexCoord; \n"
5025 "in vec4 vertexColor; \n"
5026 "out vec2 fragTexCoord; \n"
5027 "out vec4 fragColor; \n"
5028 #elif defined(GRAPHICS_API_OPENGL_ES2)
5029 "#version 100 \n"
5030 "precision mediump float; \n" // Precision required for OpenGL ES2 (WebGL) (on some browsers)
5031 "attribute vec3 vertexPosition; \n"
5032 "attribute vec2 vertexTexCoord; \n"
5033 "attribute vec4 vertexColor; \n"
5034 "varying vec2 fragTexCoord; \n"
5035 "varying vec4 fragColor; \n"
5036 #endif
5037
5038 "uniform mat4 mvp; \n"
5039 "void main() \n"
5040 "{ \n"
5041 " fragTexCoord = vertexTexCoord; \n"
5042 " fragColor = vertexColor; \n"
5043 " gl_Position = mvp*vec4(vertexPosition, 1.0); \n"
5044 "} \n";
5045
5046 // Fragment shader directly defined, no external file required
5047 const char *defaultFShaderCode =
5048 #if defined(GRAPHICS_API_OPENGL_21)
5049 "#version 120 \n"
5050 "varying vec2 fragTexCoord; \n"
5051 "varying vec4 fragColor; \n"
5052 "uniform sampler2D texture0; \n"
5053 "uniform vec4 colDiffuse; \n"
5054 "void main() \n"
5055 "{ \n"
5056 " vec4 texelColor = texture2D(texture0, fragTexCoord); \n"
5057 " gl_FragColor = texelColor*colDiffuse*fragColor; \n"
5058 "} \n";
5059 #elif defined(GRAPHICS_API_OPENGL_33)
5060 "#version 330 \n"
5061 "in vec2 fragTexCoord; \n"
5062 "in vec4 fragColor; \n"
5063 "out vec4 finalColor; \n"
5064 "uniform sampler2D texture0; \n"
5065 "uniform vec4 colDiffuse; \n"
5066 "void main() \n"
5067 "{ \n"
5068 " vec4 texelColor = texture(texture0, fragTexCoord); \n"
5069 " finalColor = texelColor*colDiffuse*fragColor; \n"
5070 "} \n";
5071 #endif
5072
5073 #if defined(GRAPHICS_API_OPENGL_ES3)
5074 "#version 300 es \n"
5075 "precision mediump float; \n" // Precision required for OpenGL ES3 (WebGL 2)
5076 "in vec2 fragTexCoord; \n"
5077 "in vec4 fragColor; \n"
5078 "out vec4 finalColor; \n"
5079 "uniform sampler2D texture0; \n"
5080 "uniform vec4 colDiffuse; \n"
5081 "void main() \n"
5082 "{ \n"
5083 " vec4 texelColor = texture(texture0, fragTexCoord); \n"
5084 " finalColor = texelColor*colDiffuse*fragColor; \n"
5085 "} \n";
5086 #elif defined(GRAPHICS_API_OPENGL_ES2)
5087 "#version 100 \n"
5088 "precision mediump float; \n" // Precision required for OpenGL ES2 (WebGL)
5089 "varying vec2 fragTexCoord; \n"
5090 "varying vec4 fragColor; \n"
5091 "uniform sampler2D texture0; \n"
5092 "uniform vec4 colDiffuse; \n"
5093 "void main() \n"
5094 "{ \n"
5095 " vec4 texelColor = texture2D(texture0, fragTexCoord); \n"
5096 " gl_FragColor = texelColor*colDiffuse*fragColor; \n"
5097 "} \n";
5098 #endif
5099
5100 // NOTE: Compiled vertex/fragment shaders are not deleted,
5101 // they are kept for re-use as default shaders in case some shader loading fails
5102 RLGL.State.defaultVShaderId = rlLoadShader(defaultVShaderCode, GL_VERTEX_SHADER); // Compile default vertex shader
5103 RLGL.State.defaultFShaderId = rlLoadShader(defaultFShaderCode, GL_FRAGMENT_SHADER); // Compile default fragment shader
5104
5105 RLGL.State.defaultShaderId = rlLoadShaderProgramEx(RLGL.State.defaultVShaderId, RLGL.State.defaultFShaderId);
5106
5107 if (RLGL.State.defaultShaderId > 0)
5108 {
5109 TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader loaded successfully", RLGL.State.defaultShaderId);
5110
5111 // Set default shader locations: attributes locations
5112 RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_POSITION] = glGetAttribLocation(RLGL.State.defaultShaderId, RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION);
5113 RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01] = glGetAttribLocation(RLGL.State.defaultShaderId, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD);
5114 RLGL.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_COLOR] = glGetAttribLocation(RLGL.State.defaultShaderId, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR);
5115
5116 // Set default shader locations: uniform locations
5117 RLGL.State.defaultShaderLocs[RL_SHADER_LOC_MATRIX_MVP] = glGetUniformLocation(RLGL.State.defaultShaderId, RL_DEFAULT_SHADER_UNIFORM_NAME_MVP);
5118 RLGL.State.defaultShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE] = glGetUniformLocation(RLGL.State.defaultShaderId, RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR);
5119 RLGL.State.defaultShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE] = glGetUniformLocation(RLGL.State.defaultShaderId, RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0);
5120 }
5121 else TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to load default shader", RLGL.State.defaultShaderId);
5122 }
5123
5124 // Unload default shader
5125 // NOTE: Unloads: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs
5126 static void rlUnloadShaderDefault(void)
5127 {
5128 glUseProgram(0);
5129
5130 glDetachShader(RLGL.State.defaultShaderId, RLGL.State.defaultVShaderId);
5131 glDetachShader(RLGL.State.defaultShaderId, RLGL.State.defaultFShaderId);
5132 glDeleteShader(RLGL.State.defaultVShaderId);
5133 glDeleteShader(RLGL.State.defaultFShaderId);
5134
5135 glDeleteProgram(RLGL.State.defaultShaderId);
5136
5137 RL_FREE(RLGL.State.defaultShaderLocs);
5138
5139 TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader unloaded successfully", RLGL.State.defaultShaderId);
5140 }
5141
5142 #if RLGL_SHOW_GL_DETAILS_INFO
5143 // Get compressed format official GL identifier name
5144 static const char *rlGetCompressedFormatName(int format)
5145 {
5146 switch (format)
5147 {
5148 // GL_EXT_texture_compression_s3tc
5149 case 0x83F0: return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; break;
5150 case 0x83F1: return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; break;
5151 case 0x83F2: return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT"; break;
5152 case 0x83F3: return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT"; break;
5153 // GL_3DFX_texture_compression_FXT1
5154 case 0x86B0: return "GL_COMPRESSED_RGB_FXT1_3DFX"; break;
5155 case 0x86B1: return "GL_COMPRESSED_RGBA_FXT1_3DFX"; break;
5156 // GL_IMG_texture_compression_pvrtc
5157 case 0x8C00: return "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG"; break;
5158 case 0x8C01: return "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG"; break;
5159 case 0x8C02: return "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"; break;
5160 case 0x8C03: return "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"; break;
5161 // GL_OES_compressed_ETC1_RGB8_texture
5162 case 0x8D64: return "GL_ETC1_RGB8_OES"; break;
5163 // GL_ARB_texture_compression_rgtc
5164 case 0x8DBB: return "GL_COMPRESSED_RED_RGTC1"; break;
5165 case 0x8DBC: return "GL_COMPRESSED_SIGNED_RED_RGTC1"; break;
5166 case 0x8DBD: return "GL_COMPRESSED_RG_RGTC2"; break;
5167 case 0x8DBE: return "GL_COMPRESSED_SIGNED_RG_RGTC2"; break;
5168 // GL_ARB_texture_compression_bptc
5169 case 0x8E8C: return "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB"; break;
5170 case 0x8E8D: return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB"; break;
5171 case 0x8E8E: return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB"; break;
5172 case 0x8E8F: return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB"; break;
5173 // GL_ARB_ES3_compatibility
5174 case 0x9274: return "GL_COMPRESSED_RGB8_ETC2"; break;
5175 case 0x9275: return "GL_COMPRESSED_SRGB8_ETC2"; break;
5176 case 0x9276: return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; break;
5177 case 0x9277: return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; break;
5178 case 0x9278: return "GL_COMPRESSED_RGBA8_ETC2_EAC"; break;
5179 case 0x9279: return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; break;
5180 case 0x9270: return "GL_COMPRESSED_R11_EAC"; break;
5181 case 0x9271: return "GL_COMPRESSED_SIGNED_R11_EAC"; break;
5182 case 0x9272: return "GL_COMPRESSED_RG11_EAC"; break;
5183 case 0x9273: return "GL_COMPRESSED_SIGNED_RG11_EAC"; break;
5184 // GL_KHR_texture_compression_astc_hdr
5185 case 0x93B0: return "GL_COMPRESSED_RGBA_ASTC_4x4_KHR"; break;
5186 case 0x93B1: return "GL_COMPRESSED_RGBA_ASTC_5x4_KHR"; break;
5187 case 0x93B2: return "GL_COMPRESSED_RGBA_ASTC_5x5_KHR"; break;
5188 case 0x93B3: return "GL_COMPRESSED_RGBA_ASTC_6x5_KHR"; break;
5189 case 0x93B4: return "GL_COMPRESSED_RGBA_ASTC_6x6_KHR"; break;
5190 case 0x93B5: return "GL_COMPRESSED_RGBA_ASTC_8x5_KHR"; break;
5191 case 0x93B6: return "GL_COMPRESSED_RGBA_ASTC_8x6_KHR"; break;
5192 case 0x93B7: return "GL_COMPRESSED_RGBA_ASTC_8x8_KHR"; break;
5193 case 0x93B8: return "GL_COMPRESSED_RGBA_ASTC_10x5_KHR"; break;
5194 case 0x93B9: return "GL_COMPRESSED_RGBA_ASTC_10x6_KHR"; break;
5195 case 0x93BA: return "GL_COMPRESSED_RGBA_ASTC_10x8_KHR"; break;
5196 case 0x93BB: return "GL_COMPRESSED_RGBA_ASTC_10x10_KHR"; break;
5197 case 0x93BC: return "GL_COMPRESSED_RGBA_ASTC_12x10_KHR"; break;
5198 case 0x93BD: return "GL_COMPRESSED_RGBA_ASTC_12x12_KHR"; break;
5199 case 0x93D0: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; break;
5200 case 0x93D1: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; break;
5201 case 0x93D2: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; break;
5202 case 0x93D3: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; break;
5203 case 0x93D4: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; break;
5204 case 0x93D5: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; break;
5205 case 0x93D6: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; break;
5206 case 0x93D7: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; break;
5207 case 0x93D8: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; break;
5208 case 0x93D9: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; break;
5209 case 0x93DA: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; break;
5210 case 0x93DB: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; break;
5211 case 0x93DC: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; break;
5212 case 0x93DD: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; break;
5213 default: return "GL_COMPRESSED_UNKNOWN"; break;
5214 }
5215 }
5216 #endif
5217
5218 #endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
5219
5220 // Get pixel data size in bytes (image or texture)
5221 // NOTE: Size depends on pixel format
5222 static int rlGetPixelDataSize(int width, int height, int format)
5223 {
5224 int dataSize = 0; // Size in bytes
5225 int bpp = 0; // Bits per pixel
5226
5227 switch (format)
5228 {
5229 case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: bpp = 8; break;
5230 case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA:
5231 case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5:
5232 case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1:
5233 case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: bpp = 16; break;
5234 case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: bpp = 32; break;
5235 case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: bpp = 24; break;
5236 case RL_PIXELFORMAT_UNCOMPRESSED_R32: bpp = 32; break;
5237 case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: bpp = 32*3; break;
5238 case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: bpp = 32*4; break;
5239 case RL_PIXELFORMAT_UNCOMPRESSED_R16: bpp = 16; break;
5240 case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: bpp = 16*3; break;
5241 case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: bpp = 16*4; break;
5242 case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB:
5243 case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA:
5244 case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB:
5245 case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB:
5246 case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB:
5247 case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: // 8 bytes per each 4x4 block
5248 {
5249 int blockWidth = (width + 3)/4;
5250 int blockHeight = (height + 3)/4;
5251 dataSize = blockWidth*blockHeight*8;
5252 } break;
5253 case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA:
5254 case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA:
5255 case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA:
5256 case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: // 16 bytes per each 4x4 block
5257 {
5258 int blockWidth = (width + 3)/4;
5259 int blockHeight = (height + 3)/4;
5260 dataSize = blockWidth*blockHeight*16;
5261 } break;
5262 case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: // 4 bytes per each 4x4 block
5263 {
5264 int blockWidth = (width + 3)/4;
5265 int blockHeight = (height + 3)/4;
5266 dataSize = blockWidth*blockHeight*4;
5267 } break;
5268 default: break;
5269 }
5270
5271 // Compute dataSize for uncompressed texture data (no blocks)
5272 if ((format >= RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) &&
5273 (format <= RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16))
5274 {
5275 double bytesPerPixel = (double)bpp/8.0;
5276 dataSize = (int)(bytesPerPixel*width*height); // Total data size in bytes
5277 }
5278
5279 return dataSize;
5280 }
5281
5282 // Auxiliar math functions
5283 //-------------------------------------------------------------------------------
5284 // Get identity matrix
5285 static Matrix rlMatrixIdentity(void)
5286 {
5287 Matrix matIdentity = { 0 };
5288 matIdentity.m0 = 1.0f;
5289 matIdentity.m5 = 1.0f;
5290 matIdentity.m10 = 1.0f;
5291 matIdentity.m15 = 1.0f;
5292
5293 return matIdentity;
5294 }
5295 #if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
5296 // Get float array of matrix data
5297 // Explicit conversion to column-major memory layout
5298 static rl_float16 rlMatrixToFloatV(Matrix mat)
5299 {
5300 rl_float16 result = { 0 };
5301
5302 result.v[0] = mat.m0;
5303 result.v[1] = mat.m1;
5304 result.v[2] = mat.m2;
5305 result.v[3] = mat.m3;
5306 result.v[4] = mat.m4;
5307 result.v[5] = mat.m5;
5308 result.v[6] = mat.m6;
5309 result.v[7] = mat.m7;
5310 result.v[8] = mat.m8;
5311 result.v[9] = mat.m9;
5312 result.v[10] = mat.m10;
5313 result.v[11] = mat.m11;
5314 result.v[12] = mat.m12;
5315 result.v[13] = mat.m13;
5316 result.v[14] = mat.m14;
5317 result.v[15] = mat.m15;
5318
5319 return result;
5320 }
5321
5322 // Get two matrix multiplication
5323 // NOTE: When multiplying matrices... the order matters!
5324 static Matrix rlMatrixMultiply(Matrix left, Matrix right)
5325 {
5326 Matrix result = { 0 };
5327
5328 result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12;
5329 result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13;
5330 result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14;
5331 result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15;
5332 result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12;
5333 result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13;
5334 result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14;
5335 result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15;
5336 result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12;
5337 result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13;
5338 result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14;
5339 result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15;
5340 result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12;
5341 result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13;
5342 result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14;
5343 result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15;
5344
5345 return result;
5346 }
5347
5348 // Transposes provided matrix
5349 static Matrix rlMatrixTranspose(Matrix mat)
5350 {
5351 Matrix result = { 0 };
5352
5353 result.m0 = mat.m0;
5354 result.m1 = mat.m4;
5355 result.m2 = mat.m8;
5356 result.m3 = mat.m12;
5357 result.m4 = mat.m1;
5358 result.m5 = mat.m5;
5359 result.m6 = mat.m9;
5360 result.m7 = mat.m13;
5361 result.m8 = mat.m2;
5362 result.m9 = mat.m6;
5363 result.m10 = mat.m10;
5364 result.m11 = mat.m14;
5365 result.m12 = mat.m3;
5366 result.m13 = mat.m7;
5367 result.m14 = mat.m11;
5368 result.m15 = mat.m15;
5369
5370 return result;
5371 }
5372
5373 // Invert provided matrix
5374 static Matrix rlMatrixInvert(Matrix mat)
5375 {
5376 Matrix result = { 0 };
5377
5378 // Cache the matrix values (speed optimization)
5379 float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3;
5380 float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7;
5381 float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11;
5382 float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15;
5383
5384 float b00 = a00*a11 - a01*a10;
5385 float b01 = a00*a12 - a02*a10;
5386 float b02 = a00*a13 - a03*a10;
5387 float b03 = a01*a12 - a02*a11;
5388 float b04 = a01*a13 - a03*a11;
5389 float b05 = a02*a13 - a03*a12;
5390 float b06 = a20*a31 - a21*a30;
5391 float b07 = a20*a32 - a22*a30;
5392 float b08 = a20*a33 - a23*a30;
5393 float b09 = a21*a32 - a22*a31;
5394 float b10 = a21*a33 - a23*a31;
5395 float b11 = a22*a33 - a23*a32;
5396
5397 // Calculate the invert determinant (inlined to avoid double-caching)
5398 float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06);
5399
5400 result.m0 = (a11*b11 - a12*b10 + a13*b09)*invDet;
5401 result.m1 = (-a01*b11 + a02*b10 - a03*b09)*invDet;
5402 result.m2 = (a31*b05 - a32*b04 + a33*b03)*invDet;
5403 result.m3 = (-a21*b05 + a22*b04 - a23*b03)*invDet;
5404 result.m4 = (-a10*b11 + a12*b08 - a13*b07)*invDet;
5405 result.m5 = (a00*b11 - a02*b08 + a03*b07)*invDet;
5406 result.m6 = (-a30*b05 + a32*b02 - a33*b01)*invDet;
5407 result.m7 = (a20*b05 - a22*b02 + a23*b01)*invDet;
5408 result.m8 = (a10*b10 - a11*b08 + a13*b06)*invDet;
5409 result.m9 = (-a00*b10 + a01*b08 - a03*b06)*invDet;
5410 result.m10 = (a30*b04 - a31*b02 + a33*b00)*invDet;
5411 result.m11 = (-a20*b04 + a21*b02 - a23*b00)*invDet;
5412 result.m12 = (-a10*b09 + a11*b07 - a12*b06)*invDet;
5413 result.m13 = (a00*b09 - a01*b07 + a02*b06)*invDet;
5414 result.m14 = (-a30*b03 + a31*b01 - a32*b00)*invDet;
5415 result.m15 = (a20*b03 - a21*b01 + a22*b00)*invDet;
5416
5417 return result;
5418 }
5419 #endif
5420
5421 #endif // RLGL_IMPLEMENTATION