diff --git a/.vscode/bookmarks.json b/.vscode/bookmarks.json new file mode 100644 index 0000000..124083b --- /dev/null +++ b/.vscode/bookmarks.json @@ -0,0 +1,14 @@ +{ + "files": [ + { + "path": "project/auxillary/vis_ast/dependencies/temp/raylib-master/src/rcamera.h", + "bookmarks": [ + { + "line": 140, + "column": 14, + "label": "" + } + ] + } + ] +} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json index e298a3c..a8ac376 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -30,7 +30,13 @@ "list": "cpp", "xhash": "cpp", "glfw3.h": "c", - "stdbool.h": "c" + "stdbool.h": "c", + "objbase.h": "c", + "mmreg.h": "c", + "mmsystem.h": "c", + "propidl.h": "c", + "android_native_app_glue.h": "c", + "raylib.h": "c" }, "C_Cpp.intelliSenseEngineFallback": "disabled", "mesonbuild.configureOnOpen": true, diff --git a/project/auxillary/vis_ast/code/platform/macros.hpp b/project/auxillary/vis_ast/code/platform/macros.hpp index 656bb0d..ab2e6e0 100644 --- a/project/auxillary/vis_ast/code/platform/macros.hpp +++ b/project/auxillary/vis_ast/code/platform/macros.hpp @@ -1,3 +1,4 @@ +#pragma once #if INTELLISENSE_DIRECTIVES #include "vendor/compiler.hpp" #endif diff --git a/project/auxillary/vis_ast/code/platform/vendor/arch.hpp b/project/auxillary/vis_ast/code/platform/vendor/arch.hpp index 076b6f7..9100bd0 100644 --- a/project/auxillary/vis_ast/code/platform/vendor/arch.hpp +++ b/project/auxillary/vis_ast/code/platform/vendor/arch.hpp @@ -1,4 +1,5 @@ // Platform architecture +#pragma once #if defined( _WIN64 ) || defined( __x86_64__ ) || defined( _M_X64 ) || defined( __64BIT__ ) || defined( __powerpc64__ ) || defined( __ppc64__ ) || defined( __aarch64__ ) # ifndef ARCH_64_BIT diff --git a/project/auxillary/vis_ast/code/platform/vendor/compiler.hpp b/project/auxillary/vis_ast/code/platform/vendor/compiler.hpp index 45244c6..bc6e264 100644 --- a/project/auxillary/vis_ast/code/platform/vendor/compiler.hpp +++ b/project/auxillary/vis_ast/code/platform/vendor/compiler.hpp @@ -1,4 +1,5 @@ // Platform compiler +#pragma once #if defined( _MSC_VER ) # define Compiler_MSVC 1 diff --git a/project/auxillary/vis_ast/code/platform/vendor/os.hpp b/project/auxillary/vis_ast/code/platform/vendor/os.hpp index e754a18..3408e17 100644 --- a/project/auxillary/vis_ast/code/platform/vendor/os.hpp +++ b/project/auxillary/vis_ast/code/platform/vendor/os.hpp @@ -1,4 +1,5 @@ // Platform OS detection +#pragma once #if defined( _WIN32 ) || defined( _WIN64 ) # ifndef System_Windows diff --git a/project/auxillary/vis_ast/code/platform/win32/types.hpp b/project/auxillary/vis_ast/code/platform/win32/types.hpp index f890f66..afbd47d 100644 --- a/project/auxillary/vis_ast/code/platform/win32/types.hpp +++ b/project/auxillary/vis_ast/code/platform/win32/types.hpp @@ -1 +1,3 @@ -using HINSTANCE = void*; \ No newline at end of file +#pragma once + +using HINSTANCE = void*; diff --git a/project/auxillary/vis_ast/dependencies/raylib/include/config.h b/project/auxillary/vis_ast/dependencies/raylib/include/config.h index 2663db4..af4d3c0 100644 --- a/project/auxillary/vis_ast/dependencies/raylib/include/config.h +++ b/project/auxillary/vis_ast/dependencies/raylib/include/config.h @@ -1,109 +1,134 @@ /********************************************************************************************** - * - * raylib configuration flags - * - * This file defines all the configuration flags for the different raylib modules - * - * LICENSE: zlib/libpng - * - * Copyright (c) 2018-2023 Ahmad Fatoum & Ramon Santamaria (@raysan5) - * - * This software is provided "as-is", without any express or implied warranty. In no event - * will the authors be held liable for any damages arising from the use of this software. - * - * Permission is granted to anyone to use this software for any purpose, including commercial - * applications, and to alter it and redistribute it freely, subject to the following restrictions: - * - * 1. The origin of this software must not be misrepresented; you must not claim that you - * wrote the original software. If you use this software in a product, an acknowledgment - * in the product documentation would be appreciated but is not required. - * - * 2. Altered source versions must be plainly marked as such, and must not be misrepresented - * as being the original software. - * - * 3. This notice may not be removed or altered from any source distribution. - * - **********************************************************************************************/ +* +* raylib configuration flags +* +* This file defines all the configuration flags for the different raylib modules +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2018-2023 Ahmad Fatoum & Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ -#ifndef CONFIG_H +#ifndef RL_CONFIG_H #define RL_CONFIG_H //------------------------------------------------------------------------------------ // Module selection - Some modules could be avoided -// Mandatory modules: rcore, rlgl, utils +// Mandatory modules: rcore, RLGL_, utils //------------------------------------------------------------------------------------ -#define RL_SUPPORT_MODULE_RSHAPES 1 -#define RL_SUPPORT_MODULE_RTEXTURES 1 -#define RL_SUPPORT_MODULE_RTEXT 1 // WARNING: It requires SUPPORT_MODULE_RTEXTURES to load sprite font textures -#define RL_SUPPORT_MODULE_RMODELS 1 -#define RL_SUPPORT_MODULE_RAUDIO 1 +#define RL_SUPPORT_MODULE_RSHAPES 1 +#define RL_SUPPORT_MODULE_RTEXTURES 1 +#define RL_SUPPORT_MODULE_RTEXT 1 // WARNING: It requires RL_SUPPORT_MODULE_RTEXTURES to load sprite font textures +#define RL_SUPPORT_MODULE_RMODELS 1 +#define RL_SUPPORT_MODULE_RAUDIO 1 //------------------------------------------------------------------------------------ // Module: rcore - Configuration Flags //------------------------------------------------------------------------------------ -// Camera module is included (rcamera.h) and multiple predefined cameras are available: free, 1st/3rd person, orbital -#define RL_SUPPORT_CAMERA_SYSTEM 1 +// RL_Camera module is included (rcamera.h) and multiple predefined cameras are available: free, 1st/3rd person, orbital +#define RL_SUPPORT_CAMERA_SYSTEM 1 // Gestures module is included (rgestures.h) to support gestures detection: tap, hold, swipe, drag -#define RL_SUPPORT_GESTURES_SYSTEM 1 +#define RL_SUPPORT_GESTURES_SYSTEM 1 +// Include pseudo-random numbers generator (rprand.h), based on Xoshiro128** and SplitMix64 +#define SUPPORT_RPRAND_GENERATOR 1 // Mouse gestures are directly mapped like touches and processed by gestures system -#define RL_SUPPORT_MOUSE_GESTURES 1 +#define RL_SUPPORT_MOUSE_GESTURES 1 // Reconfigure standard input to receive key inputs, works with SSH connection. -#define RL_SUPPORT_SSH_KEYBOARD_RPI 1 +#define RL_SUPPORT_SSH_KEYBOARD_RPI 1 // Setting a higher resolution can improve the accuracy of time-out intervals in wait functions. // However, it can also reduce overall system performance, because the thread scheduler switches tasks more often. -#define RL_SUPPORT_WINMM_HIGHRES_TIMER 1 +#define RL_SUPPORT_WINMM_HIGHRES_TIMER 1 // Use busy wait loop for timing sync, if not defined, a high-resolution timer is set up and used -// #define SUPPORT_BUSY_WAIT_LOOP 1 +//#define SUPPORT_BUSY_WAIT_LOOP 1 // Use a partial-busy wait loop, in this case frame sleeps for most of the time, but then runs a busy loop at the end for accuracy -#define RL_SUPPORT_PARTIALBUSY_WAIT_LOOP 1 +#define RL_SUPPORT_PARTIALBUSY_WAIT_LOOP 1 // Allow automatic screen capture of current screen pressing F12, defined in KeyCallback() -#define RL_SUPPORT_SCREEN_CAPTURE 1 +#define RL_SUPPORT_SCREEN_CAPTURE 1 // Allow automatic gif recording of current screen pressing CTRL+F12, defined in KeyCallback() -#define RL_SUPPORT_GIF_RECORDING 1 -// Support CompressData() and DecompressData() functions -#define RL_SUPPORT_COMPRESSION_API 1 +#define RL_SUPPORT_GIF_RECORDING 1 +// Support RL_CompressData() and RL_DecompressData() functions +#define RL_SUPPORT_COMPRESSION_API 1 // Support automatic generated events, loading and recording of those events when required -// #define SUPPORT_EVENTS_AUTOMATION 1 +#define RL_SUPPORT_AUTOMATION_EVENTS 1 // Support custom frame control, only for advance users -// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents() +// By default RL_EndDrawing() does this job: draws everything + RL_SwapScreenBuffer() + manage frame timing + RL_PollInputEvents() // Enabling this flag allows manual control of the frame processes, use at your own risk -// #define SUPPORT_CUSTOM_FRAME_CONTROL 1 +//#define SUPPORT_CUSTOM_FRAME_CONTROL 1 // rcore: Configuration values //------------------------------------------------------------------------------------ -#define RL_MAX_FILEPATH_CAPACITY 8192 // Maximum file paths capacity -#define RL_MAX_FILEPATH_LENGTH 4096 // Maximum length for filepaths (Linux PATH_MAX default value) +#define RL_MAX_FILEPATH_CAPACITY 8192 // Maximum file paths capacity +#define RL_MAX_FILEPATH_LENGTH 4096 // Maximum length for filepaths (Linux PATH_MAX default value) -#define RL_MAX_KEYBOARD_KEYS 512 // Maximum number of keyboard keys supported -#define RL_MAX_MOUSE_BUTTONS 8 // Maximum number of mouse buttons supported -#define RL_MAX_GAMEPADS 4 // Maximum number of gamepads supported -#define RL_MAX_GAMEPAD_AXIS 8 // Maximum number of axis supported (per gamepad) -#define RL_MAX_GAMEPAD_BUTTONS 32 // Maximum number of buttons supported (per gamepad) -#define RL_MAX_TOUCH_POINTS 8 // Maximum number of touch points supported -#define RL_MAX_KEY_PRESSED_QUEUE 16 // Maximum number of keys in the key input queue -#define RL_MAX_CHAR_PRESSED_QUEUE 16 // Maximum number of characters in the char input queue +#define RL_MAX_KEYBOARD_KEYS 512 // Maximum number of keyboard keys supported +#define RL_MAX_MOUSE_BUTTONS 8 // Maximum number of mouse buttons supported +#define RL_MAX_GAMEPADS 4 // Maximum number of gamepads supported +#define RL_MAX_GAMEPAD_AXIS 8 // Maximum number of axis supported (per gamepad) +#define RL_MAX_GAMEPAD_BUTTONS 32 // Maximum number of buttons supported (per gamepad) +#define RL_MAX_TOUCH_POINTS 8 // Maximum number of touch points supported +#define RL_MAX_KEY_PRESSED_QUEUE 16 // Maximum number of keys in the key input queue +#define RL_MAX_CHAR_PRESSED_QUEUE 16 // Maximum number of characters in the char input queue -#define RL_MAX_DECOMPRESSION_SIZE 64 // Max size allocated for decompression in MB +#define RL_MAX_DECOMPRESSION_SIZE 64 // Max size allocated for decompression in MB +#define RL_MAX_AUTOMATION_EVENTS 16384 // Maximum number of automation events to record //------------------------------------------------------------------------------------ -// Module: rlgl - Configuration values +// Module: RLGL_ - Configuration values //------------------------------------------------------------------------------------ // Enable OpenGL Debug Context (only available on OpenGL 4.3) -// #define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT 1 +//#define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT 1 // Show OpenGL extensions and capabilities detailed logs on init -// #define RLGL_SHOW_GL_DETAILS_INFO 1 +//#define RLGL_SHOW_GL_DETAILS_INFO 1 -// #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 4096 // Default internal render batch elements limits +//#define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 4096 // Default internal render batch elements limits +#define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering) +#define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture) +#define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (RL_SetShaderValueTexture()) +#define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of internal RL_Matrix stack +#define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported +#define RL_CULL_DISTANCE_NEAR 0.01 // Default projection matrix near cull distance +#define RL_CULL_DISTANCE_FAR 1000.0 // Default projection matrix far cull distance // Default shader vertex attribute names to set location points // NOTE: When a new shader is loaded, the following locations are tried to be set for convenience +#define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: 0 +#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: 1 +#define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: 2 +#define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: 3 +#define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: 4 +#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Bound by default to shader location: 5 +#define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix +#define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix +#define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix +#define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix +#define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView)) +#define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color) +#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0) +#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1) +#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2) //------------------------------------------------------------------------------------ @@ -111,36 +136,40 @@ //------------------------------------------------------------------------------------ // Use QUADS instead of TRIANGLES for drawing when possible // Some lines-based shapes could still use lines -#define RL_SUPPORT_QUADS_DRAW_MODE 1 +#define RL_SUPPORT_QUADS_DRAW_MODE 1 + +// rshapes: Configuration values +//------------------------------------------------------------------------------------ +#define SPLINE_SEGMENT_DIVISIONS 24 // Spline segments subdivisions //------------------------------------------------------------------------------------ // Module: rtextures - Configuration Flags //------------------------------------------------------------------------------------ // Selecte desired fileformats to be supported for image data loading -#define RL_SUPPORT_FILEFORMAT_PNG 1 -// #define SUPPORT_FILEFORMAT_BMP 1 -// #define SUPPORT_FILEFORMAT_TGA 1 -// #define SUPPORT_FILEFORMAT_JPG 1 -#define RL_SUPPORT_FILEFORMAT_GIF 1 -#define RL_SUPPORT_FILEFORMAT_QOI 1 -// #define SUPPORT_FILEFORMAT_PSD 1 -#define RL_SUPPORT_FILEFORMAT_DDS 1 -// #define SUPPORT_FILEFORMAT_HDR 1 -// #define SUPPORT_FILEFORMAT_PIC 1 -// #define SUPPORT_FILEFORMAT_KTX 1 -// #define SUPPORT_FILEFORMAT_ASTC 1 -// #define SUPPORT_FILEFORMAT_PKM 1 -// #define SUPPORT_FILEFORMAT_PVR 1 -// #define SUPPORT_FILEFORMAT_SVG 1 +#define RL_SUPPORT_FILEFORMAT_PNG 1 +//#define RL_SUPPORT_FILEFORMAT_BMP 1 +//#define RL_SUPPORT_FILEFORMAT_TGA 1 +//#define RL_SUPPORT_FILEFORMAT_JPG 1 +#define RL_SUPPORT_FILEFORMAT_GIF 1 +#define RL_SUPPORT_FILEFORMAT_QOI 1 +//#define RL_SUPPORT_FILEFORMAT_PSD 1 +#define RL_SUPPORT_FILEFORMAT_DDS 1 +//#define RL_SUPPORT_FILEFORMAT_HDR 1 +//#define RL_SUPPORT_FILEFORMAT_PIC 1 +//#define RL_SUPPORT_FILEFORMAT_KTX 1 +//#define RL_SUPPORT_FILEFORMAT_ASTC 1 +//#define RL_SUPPORT_FILEFORMAT_PKM 1 +//#define RL_SUPPORT_FILEFORMAT_PVR 1 +//#define RL_SUPPORT_FILEFORMAT_SVG 1 // Support image export functionality (.png, .bmp, .tga, .jpg, .qoi) -#define RL_SUPPORT_IMAGE_EXPORT 1 +#define RL_SUPPORT_IMAGE_EXPORT 1 // Support procedural image generation functionality (gradient, spot, perlin-noise, cellular) -#define RL_SUPPORT_IMAGE_GENERATION 1 +#define RL_SUPPORT_IMAGE_GENERATION 1 // Support multiple image editing functions to scale, adjust colors, flip, draw on images, crop... -// If not defined, still some functions are supported: ImageFormat(), ImageCrop(), ImageToPOT() -#define RL_SUPPORT_IMAGE_MANIPULATION 1 +// If not defined, still some functions are supported: RL_ImageFormat(), RL_ImageCrop(), RL_ImageToPOT() +#define RL_SUPPORT_IMAGE_MANIPULATION 1 //------------------------------------------------------------------------------------ @@ -148,79 +177,86 @@ //------------------------------------------------------------------------------------ // Default font is loaded on window initialization to be available for the user to render simple text // NOTE: If enabled, uses external module functions to load default raylib font -#define RL_SUPPORT_DEFAULT_FONT 1 +#define RL_SUPPORT_DEFAULT_FONT 1 // Selected desired font fileformats to be supported for loading -#define RL_SUPPORT_FILEFORMAT_FNT 1 -#define RL_SUPPORT_FILEFORMAT_TTF 1 +#define RL_SUPPORT_FILEFORMAT_FNT 1 +#define RL_SUPPORT_FILEFORMAT_TTF 1 // Support text management functions -// If not defined, still some functions are supported: TextLength(), TextFormat() -#define RL_SUPPORT_TEXT_MANIPULATION 1 +// If not defined, still some functions are supported: RL_TextLength(), RL_TextFormat() +#define RL_SUPPORT_TEXT_MANIPULATION 1 -// On font atlas image generation [GenImageFontAtlas()], add a 3x3 pixels white rectangle +// On font atlas image generation [RL_GenImageFontAtlas()], add a 3x3 pixels white rectangle // at the bottom-right corner of the atlas. It can be useful to for shapes drawing, to allow -// drawing text and shapes with a single draw call [SetShapesTexture()]. -#define RL_SUPPORT_FONT_ATLAS_WHITE_REC 1 +// drawing text and shapes with a single draw call [RL_SetShapesTexture()]. +#define RL_SUPPORT_FONT_ATLAS_WHITE_REC 1 // rtext: Configuration values //------------------------------------------------------------------------------------ -#define RL_MAX_TEXT_BUFFER_LENGTH 1024 // Size of internal static buffers used on some functions: -// TextFormat(), TextSubtext(), TextToUpper(), TextToLower(), TextToPascal(), TextSplit() -#define RL_MAX_TEXTSPLIT_COUNT 128 // Maximum number of substrings to split: TextSplit() +#define RL_MAX_TEXT_BUFFER_LENGTH 1024 // RL_Size of internal static buffers used on some functions: + // RL_TextFormat(), RL_TextSubtext(), RL_TextToUpper(), RL_TextToLower(), RL_TextToPascal(), TextSplit() +#define RL_MAX_TEXTSPLIT_COUNT 128 // Maximum number of substrings to split: TextSplit() //------------------------------------------------------------------------------------ // Module: rmodels - Configuration Flags //------------------------------------------------------------------------------------ // Selected desired model fileformats to be supported for loading -#define RL_SUPPORT_FILEFORMAT_OBJ 1 -#define RL_SUPPORT_FILEFORMAT_MTL 1 -#define RL_SUPPORT_FILEFORMAT_IQM 1 -#define RL_SUPPORT_FILEFORMAT_GLTF 1 -#define RL_SUPPORT_FILEFORMAT_VOX 1 -#define RL_SUPPORT_FILEFORMAT_M3D 1 +#define RL_SUPPORT_FILEFORMAT_OBJ 1 +#define RL_SUPPORT_FILEFORMAT_MTL 1 +#define RL_SUPPORT_FILEFORMAT_IQM 1 +#define RL_SUPPORT_FILEFORMAT_GLTF 1 +#define RL_SUPPORT_FILEFORMAT_VOX 1 +#define RL_SUPPORT_FILEFORMAT_M3D 1 // Support procedural mesh generation functions, uses external par_shapes.h library // NOTE: Some generated meshes DO NOT include generated texture coordinates -#define RL_SUPPORT_MESH_GENERATION 1 +#define RL_SUPPORT_MESH_GENERATION 1 // rmodels: Configuration values //------------------------------------------------------------------------------------ -#define RL_MAX_MATERIAL_MAPS 12 // Maximum number of shader maps supported -#define RL_MAX_MESH_VERTEX_BUFFERS 7 // Maximum vertex buffers (VBO) per mesh +#define RL_MAX_MATERIAL_MAPS 12 // Maximum number of shader maps supported +#define RL_MAX_MESH_VERTEX_BUFFERS 7 // Maximum vertex buffers (VBO) per mesh //------------------------------------------------------------------------------------ // Module: raudio - Configuration Flags //------------------------------------------------------------------------------------ // Desired audio fileformats to be supported for loading -#define RL_SUPPORT_FILEFORMAT_WAV 1 -#define RL_SUPPORT_FILEFORMAT_OGG 1 -#define RL_SUPPORT_FILEFORMAT_MP3 1 -#define RL_SUPPORT_FILEFORMAT_QOA 1 -// #define SUPPORT_FILEFORMAT_FLAC 1 -#define RL_SUPPORT_FILEFORMAT_XM 1 -#define RL_SUPPORT_FILEFORMAT_MOD 1 +#define RL_SUPPORT_FILEFORMAT_WAV 1 +#define RL_SUPPORT_FILEFORMAT_OGG 1 +#define RL_SUPPORT_FILEFORMAT_MP3 1 +#define RL_SUPPORT_FILEFORMAT_QOA 1 +//#define RL_SUPPORT_FILEFORMAT_FLAC 1 +#define RL_SUPPORT_FILEFORMAT_XM 1 +#define RL_SUPPORT_FILEFORMAT_MOD 1 // raudio: Configuration values //------------------------------------------------------------------------------------ -#define RL_AUDIO_DEVICE_FORMAT ma_format_f32 // Device output format (miniaudio: float-32bit) -#define RL_AUDIO_DEVICE_CHANNELS 2 // Device output channels: stereo -#define RL_AUDIO_DEVICE_SAMPLE_RATE 0 // Device sample rate (device default) +#define RL_AUDIO_DEVICE_FORMAT ma_format_f32 // Device output format (miniaudio: float-32bit) +#define RL_AUDIO_DEVICE_CHANNELS 2 // Device output channels: stereo +#define RL_AUDIO_DEVICE_SAMPLE_RATE 0 // Device sample rate (device default) -#define RL_MAX_AUDIO_BUFFER_POOL_CHANNELS 16 // Maximum number of audio pool channels +#define RL_MAX_AUDIO_BUFFER_POOL_CHANNELS 16 // Maximum number of audio pool channels //------------------------------------------------------------------------------------ // Module: utils - Configuration Flags //------------------------------------------------------------------------------------ // Standard file io library (stdio.h) included -#define RL_SUPPORT_STANDARD_FILEIO 1 -// Show TRACELOG() output messages -// NOTE: By default LOG_DEBUG traces not shown -#define RL_SUPPORT_TRACELOG 1 -// #define SUPPORT_TRACELOG_DEBUG 1 +#define RL_SUPPORT_STANDARD_FILEIO 1 +// Show RL_TRACELOG() output messages +// NOTE: By default RL_LOG_DEBUG traces not shown +#define RL_SUPPORT_TRACELOG 1 +//#define RL_SUPPORT_TRACELOG_DEBUG 1 // utils: Configuration values //------------------------------------------------------------------------------------ -#define RL_MAX_TRACELOG_MSG_LENGTH 256 // Max length of one trace-log message +#define RL_MAX_TRACELOG_MSG_LENGTH 256 // Max length of one trace-log message +#endif // RL_CONFIG_H + +#if defined(__cplusplus) + #define RL_NS_BEGIN namespace raylib { + #define RL_NS_END } +#else + #define RL_NS_BEGIN + #define RL_NS_END #endif -// CONFIG_H diff --git a/project/auxillary/vis_ast/dependencies/raylib/include/raylib.h b/project/auxillary/vis_ast/dependencies/raylib/include/raylib.h index 2bdcac2..4504fc2 100644 --- a/project/auxillary/vis_ast/dependencies/raylib/include/raylib.h +++ b/project/auxillary/vis_ast/dependencies/raylib/include/raylib.h @@ -1,663 +1,524 @@ /********************************************************************************************** - * - * raylib v4.6-dev - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com) - * - * FEATURES: - * - NO external dependencies, all required libraries included with raylib - * - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly, - * MacOS, Haiku, Android, Raspberry Pi, DRM native, HTML5. - * - Written in plain C code (C99) in PascalCase/camelCase notation - * - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3 or ES2 - choose at compile) - * - Unique OpenGL abstraction layer (usable as standalone module): [rlgl] - * - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts) - * - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC) - * - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more! - * - Flexible Materials system, supporting classic maps and PBR maps - * - Animated 3D models supported (skeletal bones animation) (IQM) - * - Shaders support, including Model shaders and Postprocessing shaders - * - Powerful math module for Vector, Matrix and Quaternion operations: [raymath] - * - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD) - * - VR stereo rendering with configurable HMD device parameters - * - Bindings to multiple programming languages available! - * - * NOTES: - * - One default Font is loaded on InitWindow()->LoadFontDefault() [core, text] - * - One default Texture2D is loaded on rlglInit(), 1x1 white pixel R8G8B8A8 [rlgl] (OpenGL 3.3 or ES2) - * - One default Shader is loaded on rlglInit()->rlLoadShaderDefault() [rlgl] (OpenGL 3.3 or ES2) - * - One default RenderBatch is loaded on rlglInit()->rlLoadRenderBatch() [rlgl] (OpenGL 3.3 or ES2) - * - * DEPENDENCIES (included): - * [rcore] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input (PLATFORM_DESKTOP) - * [rlgl] glad (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (PLATFORM_DESKTOP) - * [raudio] miniaudio (David Reid - github.com/mackron/miniaudio) for audio device/context management - * - * OPTIONAL DEPENDENCIES (included): - * [rcore] msf_gif (Miles Fogle) for GIF recording - * [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm - * [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm - * [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...) - * [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG) - * [rtextures] stb_image_resize (Sean Barret) for image resizing algorithms - * [rtext] stb_truetype (Sean Barret) for ttf fonts loading - * [rtext] stb_rect_pack (Sean Barret) for rectangles packing - * [rmodels] par_shapes (Philip Rideout) for parametric 3d shapes generation - * [rmodels] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL) - * [rmodels] cgltf (Johannes Kuhlmann) for models loading (glTF) - * [rmodels] Model3D (bzt) for models loading (M3D, https://bztsrc.gitlab.io/model3d) - * [raudio] dr_wav (David Reid) for WAV audio file loading - * [raudio] dr_flac (David Reid) for FLAC audio file loading - * [raudio] dr_mp3 (David Reid) for MP3 audio file loading - * [raudio] stb_vorbis (Sean Barret) for OGG audio loading - * [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading - * [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading - * - * - * LICENSE: zlib/libpng - * - * raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, - * BSD-like license that allows static linking with closed source software: - * - * Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) - * - * This software is provided "as-is", without any express or implied warranty. In no event - * will the authors be held liable for any damages arising from the use of this software. - * - * Permission is granted to anyone to use this software for any purpose, including commercial - * applications, and to alter it and redistribute it freely, subject to the following restrictions: - * - * 1. The origin of this software must not be misrepresented; you must not claim that you - * wrote the original software. If you use this software in a product, an acknowledgment - * in the product documentation would be appreciated but is not required. - * - * 2. Altered source versions must be plainly marked as such, and must not be misrepresented - * as being the original software. - * - * 3. This notice may not be removed or altered from any source distribution. - * - **********************************************************************************************/ +* +* raylib v5.0 - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com) +* +* FEATURES: +* - NO external dependencies, all required libraries included with raylib +* - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly, +* MacOS, Haiku, Android, Raspberry Pi, DRM native, HTML5. +* - Written in plain C code (C99) in PascalCase/camelCase notation +* - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3 or ES2 - choose at compile) +* - Unique OpenGL abstraction layer (usable as standalone module): [RLGL_] +* - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts) +* - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC) +* - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more! +* - Flexible Materials system, supporting classic maps and PBR maps +* - Animated 3D models supported (skeletal bones animation) (IQM) +* - Shaders support, including RL_Model shaders and Postprocessing shaders +* - Powerful math module for Vector, RL_Matrix and RL_Quaternion operations: [raymath] +* - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD) +* - VR stereo rendering with configurable HMD device parameters +* - Bindings to multiple programming languages available! +* +* NOTES: +* - One default RL_Font is loaded on RL_InitWindow()->LoadFontDefault() [core, text] +* - One default RL_Texture2D is loaded on RLGL_Init(), 1x1 white pixel R8G8B8A8 [RLGL_] (OpenGL 3.3 or ES2) +* - One default RL_Shader is loaded on RLGL_Init()->RLGL_LoadShaderDefault() [RLGL_] (OpenGL 3.3 or ES2) +* - One default RenderBatch is loaded on RLGL_Init()->RLGL_LoadRenderBatch() [RLGL_] (OpenGL 3.3 or ES2) +* +* DEPENDENCIES (included): +* [rcore] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input (PLATFORM_DESKTOP) +* [RLGL_] glad (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (PLATFORM_DESKTOP) +* [raudio] miniaudio (David Reid - github.com/mackron/miniaudio) for audio device/context management +* +* OPTIONAL DEPENDENCIES (included): +* [rcore] msf_gif (Miles Fogle) for GIF recording +* [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm +* [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm +* [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...) +* [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG) +* [rtextures] stb_image_resize (Sean Barret) for image resizing algorithms +* [rtext] stb_truetype (Sean Barret) for ttf fonts loading +* [rtext] stb_rect_pack (Sean Barret) for rectangles packing +* [rmodels] par_shapes (Philip Rideout) for parametric 3d shapes generation +* [rmodels] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL) +* [rmodels] cgltf (Johannes Kuhlmann) for models loading (glTF) +* [rmodels] Model3D (bzt) for models loading (M3D, https://bztsrc.gitlab.io/model3d) +* [raudio] dr_wav (David Reid) for WAV audio file loading +* [raudio] dr_flac (David Reid) for FLAC audio file loading +* [raudio] dr_mp3 (David Reid) for MP3 audio file loading +* [raudio] stb_vorbis (Sean Barret) for OGG audio loading +* [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading +* [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading +* +* +* LICENSE: zlib/libpng +* +* raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +* BSD-like license that allows static linking with closed source software: +* +* Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ #ifndef RAYLIB_H +#define RAYLIB_H -#include -// Required for: va_list - Only used by TraceLogCallback +#include // Required for: va_list - Only used by RL_TraceLogCallback +#define RAYLIB_VERSION_MAJOR 5 +#define RAYLIB_VERSION_MINOR 0 +#define RAYLIB_VERSION_PATCH 0 +#define RAYLIB_VERSION "5.0" // Function specifiers in case library is build/used as a shared library (Windows) // NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll -#if defined( _WIN32 ) -#if defined( BUILD_LIBTYPE_SHARED ) -#if defined( __TINYC__ ) -#define RL___declspec( x ) __attribute__( ( x ) ) -#endif -#elif defined( USE_LIBTYPE_SHARED ) -#endif +#if defined(_WIN32) + #if defined(RL_BUILD_LIBTYPE_SHARED) + #if defined(__TINYC__) + #define __declspec(x) __attribute__((x)) + #endif + #define RLAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(RL_USE_LIBTYPE_SHARED) + #define RLAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif #endif #ifndef RLAPI + #define RLAPI // Functions defined as 'extern' by default (implicit specifiers) #endif //---------------------------------------------------------------------------------- // Some basic Defines //---------------------------------------------------------------------------------- -#ifndef PI -#define RL_PI 3.14159265358979323846f +#ifndef RL_PI + #define RL_PI 3.14159265358979323846f #endif -#ifndef DEG2RAD -#define RL_DEG2RAD ( PI / 180.0f ) +#ifndef RL_DEG2RAD + #define RL_DEG2RAD (RL_PI/180.0f) #endif -#ifndef RAD2DEG -#define RL_RAD2DEG ( 180.0f / PI ) +#ifndef RL_RAD2DEG + #define RL_RAD2DEG (180.0f/RL_PI) #endif // Allow custom memory allocators // NOTE: Require recompiling raylib sources #ifndef RL_MALLOC + #define RL_MALLOC(sz) malloc(sz) #endif #ifndef RL_CALLOC + #define RL_CALLOC(n,sz) calloc(n,sz) #endif #ifndef RL_REALLOC + #define RL_REALLOC(ptr,sz) realloc(ptr,sz) #endif #ifndef RL_FREE + #define RL_FREE(ptr) free(ptr) #endif // NOTE: MSVC C++ compiler does not support compound literals (C99 feature) // Plain structures in C++ (without constructors) can be initialized with { } // This is called aggregate initialization (C++11 feature) -#if defined( __cplusplus ) -#define RL_CLITERAL( type ) type +#if defined(__cplusplus) + #define RL_CLITERAL(type) type #else -#define RL_CLITERAL( type ) ( type ) + #define RL_CLITERAL(type) (type) #endif // Some compilers (mostly macos clang) default to C++98, // where aggregate initialization can't be used // So, give a more clear error stating how to fix this -#if ! defined( _MSC_VER ) && ( defined( __cplusplus ) && __cplusplus < 201103L ) -#error "C++11 or later is required. Add -std=c++11" +#if !defined(_MSC_VER) && (defined(__cplusplus) && __cplusplus < 201103L) + #error "C++11 or later is required. Add -std=c++11" #endif // NOTE: We set some defines with some data types declared by raylib -// Other modules (raymath, rlgl) also require some of those types, so, +// Other modules (raymath, RLGL_) also require some of those types, so, // to be able to use those other modules as standalone (not depending on raylib) // this defines are very useful for internal check and avoid type (re)definitions +#define RL_COLOR_TYPE +#define RL_RECTANGLE_TYPE +#define RL_VECTOR2_TYPE +#define RL_VECTOR3_TYPE +#define RL_VECTOR4_TYPE +#define RL_QUATERNION_TYPE +#define RL_MATRIX_TYPE // Some Basic Colors -// NOTE: Custom raylib color palette for amazing visuals on WHITE background -#define RL_LIGHTGRAY \ - CLITERAL( Color ) \ - { \ - 200, 200, 200, 255 \ - } // Light Gray -#define RL_GRAY \ - CLITERAL( Color ) \ - { \ - 130, 130, 130, 255 \ - } // Gray -#define RL_DARKGRAY \ - CLITERAL( Color ) \ - { \ - 80, 80, 80, 255 \ - } // Dark Gray -#define RL_YELLOW \ - CLITERAL( Color ) \ - { \ - 253, 249, 0, 255 \ - } // Yellow -#define RL_GOLD \ - CLITERAL( Color ) \ - { \ - 255, 203, 0, 255 \ - } // Gold -#define RL_ORANGE \ - CLITERAL( Color ) \ - { \ - 255, 161, 0, 255 \ - } // Orange -#define RL_PINK \ - CLITERAL( Color ) \ - { \ - 255, 109, 194, 255 \ - } // Pink -#define RL_RED \ - CLITERAL( Color ) \ - { \ - 230, 41, 55, 255 \ - } // Red -#define RL_MAROON \ - CLITERAL( Color ) \ - { \ - 190, 33, 55, 255 \ - } // Maroon -#define RL_GREEN \ - CLITERAL( Color ) \ - { \ - 0, 228, 48, 255 \ - } // Green -#define RL_LIME \ - CLITERAL( Color ) \ - { \ - 0, 158, 47, 255 \ - } // Lime -#define RL_DARKGREEN \ - CLITERAL( Color ) \ - { \ - 0, 117, 44, 255 \ - } // Dark Green -#define RL_SKYBLUE \ - CLITERAL( Color ) \ - { \ - 102, 191, 255, 255 \ - } // Sky Blue -#define RL_BLUE \ - CLITERAL( Color ) \ - { \ - 0, 121, 241, 255 \ - } // Blue -#define RL_DARKBLUE \ - CLITERAL( Color ) \ - { \ - 0, 82, 172, 255 \ - } // Dark Blue -#define RL_PURPLE \ - CLITERAL( Color ) \ - { \ - 200, 122, 255, 255 \ - } // Purple -#define RL_VIOLET \ - CLITERAL( Color ) \ - { \ - 135, 60, 190, 255 \ - } // Violet -#define RL_DARKPURPLE \ - CLITERAL( Color ) \ - { \ - 112, 31, 126, 255 \ - } // Dark Purple -#define RL_BEIGE \ - CLITERAL( Color ) \ - { \ - 211, 176, 131, 255 \ - } // Beige -#define RL_BROWN \ - CLITERAL( Color ) \ - { \ - 127, 106, 79, 255 \ - } // Brown -#define RL_DARKBROWN \ - CLITERAL( Color ) \ - { \ - 76, 63, 47, 255 \ - } // Dark Brown +// NOTE: Custom raylib color palette for amazing visuals on RL_WHITE background +#define RL_LIGHTGRAY RL_CLITERAL(RL_Color){ 200, 200, 200, 255 } // Light Gray +#define RL_GRAY RL_CLITERAL(RL_Color){ 130, 130, 130, 255 } // Gray +#define RL_DARKGRAY RL_CLITERAL(RL_Color){ 80, 80, 80, 255 } // Dark Gray +#define RL_YELLOW RL_CLITERAL(RL_Color){ 253, 249, 0, 255 } // Yellow +#define RL_GOLD RL_CLITERAL(RL_Color){ 255, 203, 0, 255 } // Gold +#define RL_ORANGE RL_CLITERAL(RL_Color){ 255, 161, 0, 255 } // Orange +#define RL_PINK RL_CLITERAL(RL_Color){ 255, 109, 194, 255 } // Pink +#define RL_RED RL_CLITERAL(RL_Color){ 230, 41, 55, 255 } // Red +#define RL_MAROON RL_CLITERAL(RL_Color){ 190, 33, 55, 255 } // Maroon +#define RL_GREEN RL_CLITERAL(RL_Color){ 0, 228, 48, 255 } // Green +#define RL_LIME RL_CLITERAL(RL_Color){ 0, 158, 47, 255 } // Lime +#define RL_DARKGREEN RL_CLITERAL(RL_Color){ 0, 117, 44, 255 } // Dark Green +#define RL_SKYBLUE RL_CLITERAL(RL_Color){ 102, 191, 255, 255 } // Sky Blue +#define RL_BLUE RL_CLITERAL(RL_Color){ 0, 121, 241, 255 } // Blue +#define RL_DARKBLUE RL_CLITERAL(RL_Color){ 0, 82, 172, 255 } // Dark Blue +#define RL_PURPLE RL_CLITERAL(RL_Color){ 200, 122, 255, 255 } // Purple +#define RL_VIOLET RL_CLITERAL(RL_Color){ 135, 60, 190, 255 } // Violet +#define RL_DARKPURPLE RL_CLITERAL(RL_Color){ 112, 31, 126, 255 } // Dark Purple +#define RL_BEIGE RL_CLITERAL(RL_Color){ 211, 176, 131, 255 } // Beige +#define RL_BROWN RL_CLITERAL(RL_Color){ 127, 106, 79, 255 } // Brown +#define RL_DARKBROWN RL_CLITERAL(RL_Color){ 76, 63, 47, 255 } // Dark Brown -#define RL_WHITE \ - CLITERAL( Color ) \ - { \ - 255, 255, 255, 255 \ - } // White -#define RL_BLACK \ - CLITERAL( Color ) \ - { \ - 0, 0, 0, 255 \ - } // Black -#define RL_BLANK \ - CLITERAL( Color ) \ - { \ - 0, 0, 0, 0 \ - } // Blank (Transparent) -#define RL_MAGENTA \ - CLITERAL( Color ) \ - { \ - 255, 0, 255, 255 \ - } // Magenta -#define RL_RAYWHITE \ - CLITERAL( Color ) \ - { \ - 245, 245, 245, 255 \ - } // My own White (raylib logo) +#define RL_WHITE RL_CLITERAL(RL_Color){ 255, 255, 255, 255 } // White +#define RL_BLACK RL_CLITERAL(RL_Color){ 0, 0, 0, 255 } // Black +#define RL_BLANK RL_CLITERAL(RL_Color){ 0, 0, 0, 0 } // Blank (Transparent) +#define RL_MAGENTA RL_CLITERAL(RL_Color){ 255, 0, 255, 255 } // Magenta +#define RL_RAYWHITE RL_CLITERAL(RL_Color){ 245, 245, 245, 255 } // My own White (raylib logo) //---------------------------------------------------------------------------------- // Structures Definition //---------------------------------------------------------------------------------- // Boolean type -#if ( defined( __STDC__ ) && __STDC_VERSION__ >= 199901L ) || ( defined( _MSC_VER ) && _MSC_VER >= 1800 ) -#include -#elif ! defined( __cplusplus ) && ! defined( bool ) -typedef enum bool -{ - False = 0, - True = ! false -} bool; +#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800) + #include +#elif !defined(__cplusplus) && !defined(bool) + typedef enum bool { false = 0, true = !false } bool; + #define RL_BOOL_TYPE #endif -// Vector2, 2 components -typedef struct Vector2 -{ - f32 x; // Vector x component - f32 y; // Vector y component +// RL_Vector2, 2 components +typedef struct RL_Vector2 { + float x; // Vector x component + float y; // Vector y component +} RL_Vector2; -} Vector2; +// RL_Vector3, 3 components +typedef struct RL_Vector3 { + float x; // Vector x component + float y; // Vector y component + float z; // Vector z component +} RL_Vector3; -// Vector3, 3 components -typedef struct Vector3 -{ - f32 x; // Vector x component - f32 y; // Vector y component - f32 z; // Vector z component +// RL_Vector4, 4 components +typedef struct RL_Vector4 { + float x; // Vector x component + float y; // Vector y component + float z; // Vector z component + float w; // Vector w component +} RL_Vector4; -} Vector3; +// RL_Quaternion, 4 components (RL_Vector4 alias) +typedef RL_Vector4 RL_Quaternion; -// Vector4, 4 components -typedef struct Vector4 -{ - f32 x; // Vector x component - f32 y; // Vector y component - f32 z; // Vector z component - f32 w; // Vector w component +// RL_Matrix, 4x4 components, column major, OpenGL style, right-handed +typedef struct RL_Matrix { + float m0, m4, m8, m12; // RL_Matrix first row (4 components) + float m1, m5, m9, m13; // RL_Matrix second row (4 components) + float m2, m6, m10, m14; // RL_Matrix third row (4 components) + float m3, m7, m11, m15; // RL_Matrix fourth row (4 components) +} RL_Matrix; -} Vector4; +// RL_Color, 4 components, R8G8B8A8 (32bit) +typedef struct RL_Color { + unsigned char r; // RL_Color red value + unsigned char g; // RL_Color green value + unsigned char b; // RL_Color blue value + unsigned char a; // RL_Color alpha value +} RL_Color; -// Quaternion, 4 components (Vector4 alias) -typedef Vector4 Quaternion; +// RL_Rectangle, 4 components +typedef struct RL_Rectangle { + float x; // RL_Rectangle top-left corner position x + float y; // RL_Rectangle top-left corner position y + float width; // RL_Rectangle width + float height; // RL_Rectangle height +} RL_Rectangle; -// Matrix, 4x4 components, column major, OpenGL style, right-handed -typedef struct Matrix -{ - f32 m0, m4, m8, m12; // Matrix first row (4 components) - f32 m1, m5, m9, m13; // Matrix second row (4 components) - f32 m2, m6, m10, m14; // Matrix third row (4 components) - f32 m3, m7, m11, m15; // Matrix fourth row (4 components) +// RL_Image, pixel data stored in CPU memory (RAM) +typedef struct RL_Image { + void *data; // RL_Image raw data + int width; // RL_Image base width + int height; // RL_Image base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (RL_PixelFormat type) +} RL_Image; -} Matrix; +// RL_Texture, tex data stored in GPU memory (VRAM) +typedef struct RL_Texture { + unsigned int id; // OpenGL texture id + int width; // RL_Texture base width + int height; // RL_Texture base height + int mipmaps; // Mipmap levels, 1 by default + int format; // Data format (RL_PixelFormat type) +} RL_Texture; -// Color, 4 components, R8G8B8A8 (32bit) -typedef struct Color -{ - u8 r; // Color red value - u8 g; // Color green value - u8 b; // Color blue value - u8 a; // Color alpha value +// RL_Texture2D, same as RL_Texture +typedef RL_Texture RL_Texture2D; -} Color; +// RL_TextureCubemap, same as RL_Texture +typedef RL_Texture RL_TextureCubemap; -// Rectangle, 4 components -typedef struct Rectangle -{ - f32 x; // Rectangle top-left corner position x - f32 y; // Rectangle top-left corner position y - f32 width; // Rectangle width - f32 height; // Rectangle height +// RL_RenderTexture, fbo for texture rendering +typedef struct RL_RenderTexture { + unsigned int id; // OpenGL framebuffer object id + RL_Texture texture; // RL_Color buffer attachment texture + RL_Texture depth; // Depth buffer attachment texture +} RL_RenderTexture; -} Rectangle; +// RL_RenderTexture2D, same as RL_RenderTexture +typedef RL_RenderTexture RL_RenderTexture2D; -// Image, pixel data stored in CPU memory (RAM) -typedef struct Image -{ - void* data; // Image raw data - s32 width; // Image base width - s32 height; // Image base height - s32 mipmaps; // Mipmap levels, 1 by default - s32 format; // Data format (PixelFormat type) +// RL_NPatchInfo, n-patch layout info +typedef struct RL_NPatchInfo { + RL_Rectangle source; // RL_Texture source rectangle + int left; // Left border offset + int top; // Top border offset + int right; // Right border offset + int bottom; // Bottom border offset + int layout; // Layout of the n-patch: 3x3, 1x3 or 3x1 +} RL_NPatchInfo; -} Image; +// RL_GlyphInfo, font characters glyphs info +typedef struct RL_GlyphInfo { + int value; // Character value (Unicode) + int offsetX; // Character offset X when drawing + int offsetY; // Character offset Y when drawing + int advanceX; // Character advance position X + RL_Image image; // Character image data +} RL_GlyphInfo; -// Texture, tex data stored in GPU memory (VRAM) -typedef struct Texture -{ - u32 id; // OpenGL texture id - s32 width; // Texture base width - s32 height; // Texture base height - s32 mipmaps; // Mipmap levels, 1 by default - s32 format; // Data format (PixelFormat type) +// RL_Font, font texture and RL_GlyphInfo array data +typedef struct RL_Font { + int baseSize; // Base size (default chars height) + int glyphCount; // Number of glyph characters + int glyphPadding; // Padding around the glyph characters + RL_Texture2D texture; // RL_Texture atlas containing the glyphs + RL_Rectangle *recs; // Rectangles in texture for the glyphs + RL_GlyphInfo *glyphs; // Glyphs info data +} RL_Font; -} Texture; +// RL_Camera, defines position/orientation in 3d space +typedef struct RL_Camera3D { + RL_Vector3 position; // RL_Camera position + RL_Vector3 target; // RL_Camera target it looks-at + RL_Vector3 up; // RL_Camera up vector (rotation over its axis) + float fovy; // RL_Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic + int projection; // RL_Camera projection: RL_CAMERA_PERSPECTIVE or RL_CAMERA_ORTHOGRAPHIC +} RL_Camera3D; -// Texture2D, same as Texture -typedef Texture Texture2D; +typedef RL_Camera3D RL_Camera; // RL_Camera type fallback, defaults to RL_Camera3D -// TextureCubemap, same as Texture -typedef Texture TextureCubemap; +// RL_Camera2D, defines position/orientation in 2d space +typedef struct RL_Camera2D { + RL_Vector2 offset; // RL_Camera offset (displacement from target) + RL_Vector2 target; // RL_Camera target (rotation and zoom origin) + float rotation; // RL_Camera rotation in degrees + float zoom; // RL_Camera zoom (scaling), should be 1.0f by default +} RL_Camera2D; -// RenderTexture, fbo for texture rendering -typedef struct RenderTexture -{ - u32 id; // OpenGL framebuffer object id - Texture texture; // Color buffer attachment texture - Texture depth; // Depth buffer attachment texture +// RL_Mesh, vertex data and vao/vbo +typedef struct RL_Mesh { + int vertexCount; // Number of vertices stored in arrays + int triangleCount; // Number of triangles stored (indexed or not) -} RenderTexture; + // Vertex attributes data + float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0) + float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) + float *texcoords2; // Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5) + float *normals; // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2) + float *tangents; // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4) + unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) + unsigned short *indices; // Vertex indices (in case vertex data comes indexed) -// RenderTexture2D, same as RenderTexture -typedef RenderTexture RenderTexture2D; + // Animation vertex data + float *animVertices; // Animated vertex positions (after bones transformations) + float *animNormals; // Animated normals (after bones transformations) + unsigned char *boneIds; // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning) + float *boneWeights; // Vertex bone weight, up to 4 bones influence by vertex (skinning) -// NPatchInfo, n-patch layout info -typedef struct NPatchInfo -{ - Rectangle source; // Texture source rectangle - s32 left; // Left border offset - s32 top; // Top border offset - s32 right; // Right border offset - s32 bottom; // Bottom border offset - s32 layout; // Layout of the n-patch: 3x3, 1x3 or 3x1 + // OpenGL identifiers + unsigned int vaoId; // OpenGL Vertex Array Object id + unsigned int *vboId; // OpenGL Vertex Buffer Objects id (default vertex data) +} RL_Mesh; -} NPatchInfo; +// RL_Shader +typedef struct RL_Shader { + unsigned int id; // RL_Shader program id + int *locs; // RL_Shader locations array (RL_MAX_SHADER_LOCATIONS) +} RL_Shader; -// GlyphInfo, font characters glyphs info -typedef struct GlyphInfo -{ - s32 value; // Character value (Unicode) - s32 offsetX; // Character offset X when drawing - s32 offsetY; // Character offset Y when drawing - s32 advanceX; // Character advance position X - Image image; // Character image data +// RL_MaterialMap +typedef struct RL_MaterialMap { + RL_Texture2D texture; // RL_Material map texture + RL_Color color; // RL_Material map color + float value; // RL_Material map value +} RL_MaterialMap; -} GlyphInfo; +// RL_Material, includes shader and maps +typedef struct RL_Material { + RL_Shader shader; // RL_Material shader + RL_MaterialMap *maps; // RL_Material maps array (RL_MAX_MATERIAL_MAPS) + float params[4]; // RL_Material generic parameters (if required) +} RL_Material; -// Font, font texture and GlyphInfo array data -typedef struct Font -{ - s32 baseSize; // Base size (default chars height) - s32 glyphCount; // Number of glyph characters - s32 glyphPadding; // Padding around the glyph characters - Texture2D texture; // Texture atlas containing the glyphs - Rectangle* recs; // Rectangles in texture for the glyphs - GlyphInfo* glyphs; // Glyphs info data - -} Font; - -// Camera, defines position/orientation in 3d space -typedef struct Camera3D -{ - Vector3 position; // Camera position - Vector3 target; // Camera target it looks-at - Vector3 up; // Camera up vector (rotation over its axis) - f32 fovy; // Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic - s32 projection; // Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC - -} Camera3D; - -typedef Camera3D Camera; // Camera type fallback, defaults to Camera3D - -// Camera2D, defines position/orientation in 2d space -typedef struct Camera2D -{ - Vector2 offset; // Camera offset (displacement from target) - Vector2 target; // Camera target (rotation and zoom origin) - f32 rotation; // Camera rotation in degrees - f32 zoom; // Camera zoom (scaling), should be 1.0f by default - -} Camera2D; - -// Mesh, vertex data and vao/vbo -typedef struct Mesh -{ - s32 vertexCount; // Number of vertices stored in arrays - s32 triangleCount; // Number of triangles stored (indexed or not) - - // Vertex attributes data - f32* vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0) - f32* texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) - f32* texcoords2; // Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5) - f32* normals; // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2) - f32* tangents; // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4) - u8* colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) - u8* indices; // Vertex indices (in case vertex data comes indexed) - - // Animation vertex data - f32* animVertices; // Animated vertex positions (after bones transformations) - f32* animNormals; // Animated normals (after bones transformations) - u8* boneIds; // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning) - f32* boneWeights; // Vertex bone weight, up to 4 bones influence by vertex (skinning) - - // OpenGL identifiers - u32 vaoId; // OpenGL Vertex Array Object id - unsigned int* vboId; // OpenGL Vertex Buffer Objects id (default vertex data) - -} Mesh; - -// Shader -typedef struct Shader -{ - u32 id; // Shader program id - s32* locs; // Shader locations array (RL_MAX_SHADER_LOCATIONS) - -} Shader; - -// MaterialMap -typedef struct MaterialMap -{ - Texture2D texture; // Material map texture - Color color; // Material map color - f32 value; // Material map value - -} MaterialMap; - -// Material, includes shader and maps -typedef struct Material -{ - Shader shader; // Material shader - MaterialMap* maps; // Material maps array (MAX_MATERIAL_MAPS) - f32 params; // Material generic parameters (if required) - -} Material; - -// Transform, vertex transformation data -typedef struct Transform -{ - Vector3 translation; // Translation - Quaternion rotation; // Rotation - Vector3 scale; // Scale - -} Transform; +// RL_Transform, vertex transformation data +typedef struct RL_Transform { + RL_Vector3 translation; // Translation + RL_Quaternion rotation; // Rotation + RL_Vector3 scale; // Scale +} RL_Transform; // Bone, skeletal animation bone -typedef struct BoneInfo -{ - char name[ 32 ]; // Bone name - s32 parent; // Bone parent +typedef struct RL_BoneInfo { + char name[32]; // Bone name + int parent; // Bone parent +} RL_BoneInfo; -} BoneInfo; +// RL_Model, meshes, materials and animation data +typedef struct RL_Model { + RL_Matrix transform; // Local transform matrix -// Model, meshes, materials and animation data -typedef struct Model -{ - Matrix transform; // Local transform matrix + int meshCount; // Number of meshes + int materialCount; // Number of materials + RL_Mesh *meshes; // Meshes array + RL_Material *materials; // Materials array + int *meshMaterial; // RL_Mesh material number - s32 meshCount; // Number of meshes - s32 materialCount; // Number of materials - Mesh* meshes; // Meshes array - Material* materials; // Materials array - s32* meshMaterial; // Mesh material number + // Animation data + int boneCount; // Number of bones + RL_BoneInfo *bones; // Bones information (skeleton) + RL_Transform *bindPose; // Bones base transformation (pose) +} RL_Model; - // Animation data - s32 boneCount; // Number of bones - BoneInfo* bones; // Bones information (skeleton) - Transform* bindPose; // Bones base transformation (pose) +// RL_ModelAnimation +typedef struct RL_ModelAnimation { + int boneCount; // Number of bones + int frameCount; // Number of animation frames + RL_BoneInfo *bones; // Bones information (skeleton) + RL_Transform **framePoses; // Poses array by frame + char name[32]; // Animation name +} RL_ModelAnimation; -} Model; +// RL_Ray, ray for raycasting +typedef struct RL_Ray { + RL_Vector3 position; // RL_Ray position (origin) + RL_Vector3 direction; // RL_Ray direction +} RL_Ray; -// ModelAnimation -typedef struct ModelAnimation -{ - s32 boneCount; // Number of bones - s32 frameCount; // Number of animation frames - BoneInfo* bones; // Bones information (skeleton) - Transform** framePoses; // Poses array by frame - char name[ 32 ]; // Animation name +// RL_RayCollision, ray hit information +typedef struct RL_RayCollision { + bool hit; // Did the ray hit something? + float distance; // Distance to the nearest hit + RL_Vector3 point; // RL_Point of the nearest hit + RL_Vector3 normal; // Surface normal of hit +} RL_RayCollision; -} ModelAnimation; +// RL_BoundingBox +typedef struct RL_BoundingBox { + RL_Vector3 min; // Minimum vertex box-corner + RL_Vector3 max; // Maximum vertex box-corner +} RL_BoundingBox; -// Ray, ray for raycasting -typedef struct Ray -{ - Vector3 position; // Ray position (origin) - Vector3 direction; // Ray direction - -} Ray; - -// RayCollision, ray hit information -typedef struct RayCollision -{ - bool hit; // Did the ray hit something? - f32 distance; // Distance to the nearest hit - Vector3 point; // Point of the nearest hit - Vector3 normal; // Surface normal of hit - -} RayCollision; - -// BoundingBox -typedef struct BoundingBox -{ - Vector3 min; // Minimum vertex box-corner - Vector3 max; // Maximum vertex box-corner - -} BoundingBox; - -// Wave, audio wave data -typedef struct Wave -{ - u32 frameCount; // Total number of frames (considering channels) - u32 sampleRate; // Frequency (samples per second) - u32 sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) - u32 channels; // Number of channels (1-mono, 2-stereo, ...) - void* data; // Buffer data pointer - -} Wave; +// RL_Wave, audio wave data +typedef struct RL_Wave { + unsigned int frameCount; // Total number of frames (considering channels) + unsigned int sampleRate; // Frequency (samples per second) + unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) + unsigned int channels; // Number of channels (1-mono, 2-stereo, ...) + void *data; // Buffer data pointer +} RL_Wave; // Opaque structs declaration // NOTE: Actual structs are defined internally in raudio module -typedef struct rAudioBuffer rAudioBuffer; -typedef struct rAudioProcessor rAudioProcessor; +typedef struct RL_AudioBuffer RL_AudioBuffer; +typedef struct RL_AudioProcessor RL_AudioProcessor; -// AudioStream, custom audio stream -typedef struct AudioStream -{ - rAudioBuffer* buffer; // Pointer to internal data used by the audio system - rAudioProcessor* processor; // Pointer to internal data processor, useful for audio effects +// RL_AudioStream, custom audio stream +typedef struct RL_AudioStream { + RL_AudioBuffer *buffer; // Pointer to internal data used by the audio system + RL_AudioProcessor *processor; // Pointer to internal data processor, useful for audio effects - u32 sampleRate; // Frequency (samples per second) - u32 sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) - u32 channels; // Number of channels (1-mono, 2-stereo, ...) + unsigned int sampleRate; // Frequency (samples per second) + unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) + unsigned int channels; // Number of channels (1-mono, 2-stereo, ...) +} RL_AudioStream; -} AudioStream; +// RL_Sound +typedef struct RL_Sound { + RL_AudioStream stream; // Audio stream + unsigned int frameCount; // Total number of frames (considering channels) +} RL_Sound; -// Sound -typedef struct Sound -{ - AudioStream stream; // Audio stream - u32 frameCount; // Total number of frames (considering channels) +// RL_Music, audio stream, anything longer than ~10 seconds should be streamed +typedef struct RL_Music { + RL_AudioStream stream; // Audio stream + unsigned int frameCount; // Total number of frames (considering channels) + bool looping; // RL_Music looping enable -} Sound; + int ctxType; // Type of music context (audio filetype) + void *ctxData; // Audio context data, depends on type +} RL_Music; -// Music, audio stream, anything longer than ~10 seconds should be streamed -typedef struct Music -{ - AudioStream stream; // Audio stream - u32 frameCount; // Total number of frames (considering channels) - bool looping; // Music looping enable +// RL_VrDeviceInfo, Head-Mounted-Display device parameters +typedef struct RL_VrDeviceInfo { + int hResolution; // Horizontal resolution in pixels + int vResolution; // Vertical resolution in pixels + float hScreenSize; // Horizontal size in meters + float vScreenSize; // Vertical size in meters + float vScreenCenter; // Screen center in meters + float eyeToScreenDistance; // Distance between eye and display in meters + float lensSeparationDistance; // Lens separation distance in meters + float interpupillaryDistance; // IPD (distance between pupils) in meters + float lensDistortionValues[4]; // Lens distortion constant parameters + float chromaAbCorrection[4]; // Chromatic aberration correction parameters +} RL_VrDeviceInfo; - s32 ctxType; // Type of music context (audio filetype) - void* ctxData; // Audio context data, depends on type - -} Music; - -// VrDeviceInfo, Head-Mounted-Display device parameters -typedef struct VrDeviceInfo -{ - s32 hResolution; // Horizontal resolution in pixels - s32 vResolution; // Vertical resolution in pixels - f32 hScreenSize; // Horizontal size in meters - f32 vScreenSize; // Vertical size in meters - f32 vScreenCenter; // Screen center in meters - f32 eyeToScreenDistance; // Distance between eye and display in meters - f32 lensSeparationDistance; // Lens separation distance in meters - f32 interpupillaryDistance; // IPD (distance between pupils) in meters - f32 lensDistortionValues; // Lens distortion constant parameters - f32 chromaAbCorrection; // Chromatic aberration correction parameters - -} VrDeviceInfo; - -// VrStereoConfig, VR stereo rendering configuration for simulator -typedef struct VrStereoConfig -{ - Matrix projection[ 2 ]; // VR projection matrices (per eye) - Matrix viewOffset[ 2 ]; // VR view offset matrices (per eye) - f32 leftLensCenter; // VR left lens center - f32 rightLensCenter; // VR right lens center - f32 leftScreenCenter; // VR left screen center - f32 rightScreenCenter; // VR right screen center - f32 scale; // VR distortion scale - f32 scaleIn; // VR distortion scale in - -} VrStereoConfig; +// RL_VrStereoConfig, VR stereo rendering configuration for simulator +typedef struct RL_VrStereoConfig { + RL_Matrix projection[2]; // VR projection matrices (per eye) + RL_Matrix viewOffset[2]; // VR view offset matrices (per eye) + float leftLensCenter[2]; // VR left lens center + float rightLensCenter[2]; // VR right lens center + float leftScreenCenter[2]; // VR left screen center + float rightScreenCenter[2]; // VR right screen center + float scale[2]; // VR distortion scale + float scaleIn[2]; // VR distortion scale in +} RL_VrStereoConfig; // File path list -typedef struct FilePathList -{ - u32 capacity; // Filepaths max entries - u32 count; // Filepaths entries count - char** paths; // Filepaths entries +typedef struct RL_FilePathList { + unsigned int capacity; // Filepaths max entries + unsigned int count; // Filepaths entries count + char **paths; // Filepaths entries +} RL_FilePathList; -} FilePathList; +// Automation event +typedef struct RL_AutomationEvent { + unsigned int frame; // Event frame + unsigned int type; // Event type (AutomationEventType) + int params[4]; // Event parameters (if required) +} RL_AutomationEvent; + +// Automation event list +typedef struct RL_AutomationEventList { + unsigned int capacity; // Events max entries (RL_MAX_AUTOMATION_EVENTS) + unsigned int count; // Events entries count + RL_AutomationEvent *events; // Events entries +} RL_AutomationEventList; //---------------------------------------------------------------------------------- // Enumerators Definition @@ -665,458 +526,416 @@ typedef struct FilePathList // System/Window config flags // NOTE: Every bit registers one state (use it with bit masks) // By default all flags are set to 0 -typedef enum -{ - Flag_Vsync_Hint = 0x00000040, // Set to try enabling V-Sync on GPU - Flag_Fullscreen_Mode = 0x00000002, // Set to run program in fullscreen - Flag_Window_Resizable = 0x00000004, // Set to allow resizable window - Flag_Window_Undecorated = 0x00000008, // Set to disable window decoration (frame and buttons) - Flag_Window_Hidden = 0x00000080, // Set to hide window - Flag_Window_Minimized = 0x00000200, // Set to minimize window (iconify) - Flag_Window_Maximized = 0x00000400, // Set to maximize window (expanded to monitor) - Flag_Window_Unfocused = 0x00000800, // Set to window non focused - Flag_Window_Topmost = 0x00001000, // Set to window always on top - Flag_Window_Always_Run = 0x00000100, // Set to allow windows running while minimized - Flag_Window_Transparent = 0x00000010, // Set to allow transparent framebuffer - Flag_Window_Highdpi = 0x00002000, // Set to support HighDPI - Flag_Window_Mouse_Passthrough = 0x00004000, // Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED - Flag_Borderless_Windowed_Mode = 0x00008000, // Set to run program in borderless windowed mode - Flag_Msaa_4x_Hint = 0x00000020, // Set to try enabling MSAA 4X - Flag_Interlaced_Hint = 0x00010000 // set to try enabling interlaced video format (for v3d) - -} ConfigFlags; +typedef enum { + RL_FLAG_VSYNC_HINT = 0x00000040, // Set to try enabling V-Sync on GPU + RL_FLAG_FULLSCREEN_MODE = 0x00000002, // Set to run program in fullscreen + RL_FLAG_WINDOW_RESIZABLE = 0x00000004, // Set to allow resizable window + RL_FLAG_WINDOW_UNDECORATED = 0x00000008, // Set to disable window decoration (frame and buttons) + RL_FLAG_WINDOW_HIDDEN = 0x00000080, // Set to hide window + RL_FLAG_WINDOW_MINIMIZED = 0x00000200, // Set to minimize window (iconify) + RL_FLAG_WINDOW_MAXIMIZED = 0x00000400, // Set to maximize window (expanded to monitor) + RL_FLAG_WINDOW_UNFOCUSED = 0x00000800, // Set to window non focused + RL_FLAG_WINDOW_TOPMOST = 0x00001000, // Set to window always on top + RL_FLAG_WINDOW_ALWAYS_RUN = 0x00000100, // Set to allow windows running while minimized + RL_FLAG_WINDOW_TRANSPARENT = 0x00000010, // Set to allow transparent framebuffer + RL_FLAG_WINDOW_HIGHDPI = 0x00002000, // Set to support HighDPI + RL_FLAG_WINDOW_MOUSE_PASSTHROUGH = 0x00004000, // Set to support mouse passthrough, only supported when RL_FLAG_WINDOW_UNDECORATED + RL_FLAG_BORDERLESS_WINDOWED_MODE = 0x00008000, // Set to run program in borderless windowed mode + RL_FLAG_MSAA_4X_HINT = 0x00000020, // Set to try enabling MSAA 4X + RL_FLAG_INTERLACED_HINT = 0x00010000 // Set to try enabling interlaced video format (for V3D) +} RL_ConfigFlags; // Trace log level // NOTE: Organized by priority level -typedef enum -{ - Log_All = 0, // Display all logs - Log_Trace, // Trace logging, intended for internal use only - Log_Debug, // Debug logging, used for internal debugging, it should be disabled on release builds - Log_Info, // Info logging, used for program execution info - Log_Warning, // Warning logging, used on recoverable failures - Log_Error, // Error logging, used on unrecoverable failures - Log_Fatal, // Fatal logging, used to abort program: exit(EXIT_FAILURE) - Log_None // disable logging - -} TraceLogLevel; +typedef enum { + RL_LOG_ALL = 0, // Display all logs + RL_LOG_TRACE, // Trace logging, intended for internal use only + RL_LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds + RL_LOG_INFO, // Info logging, used for program execution info + RL_LOG_WARNING, // Warning logging, used on recoverable failures + RL_LOG_ERROR, // Error logging, used on unrecoverable failures + RL_LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE) + RL_LOG_NONE // Disable logging +} RL_TraceLogLevel; // Keyboard keys (US keyboard layout) -// NOTE: Use GetKeyPressed() to allow redefining +// NOTE: Use RL_GetKeyPressed() to allow redefining // required keys for alternative layouts -typedef enum -{ - Key_Null = 0, // Key: NULL, used for no key pressed - // Alphanumeric keys - Key_Apostrophe = 39, // Key: ' - Key_Comma = 44, // Key: , - Key_Minus = 45, // Key: - - Key_Period = 46, // Key: . - Key_Slash = 47, // Key: / - Key_Zero = 48, // Key: 0 - Key_One = 49, // Key: 1 - Key_Two = 50, // Key: 2 - Key_Three = 51, // Key: 3 - Key_Four = 52, // Key: 4 - Key_Five = 53, // Key: 5 - Key_Six = 54, // Key: 6 - Key_Seven = 55, // Key: 7 - Key_Eight = 56, // Key: 8 - Key_Nine = 57, // Key: 9 - Key_Semicolon = 59, // Key: ; - Key_Equal = 61, // Key: = - Key_A = 65, // Key: A | a - Key_B = 66, // Key: B | b - Key_C = 67, // Key: C | c - Key_D = 68, // Key: D | d - Key_E = 69, // Key: E | e - Key_F = 70, // Key: F | f - Key_G = 71, // Key: G | g - Key_H = 72, // Key: H | h - Key_I = 73, // Key: I | i - Key_J = 74, // Key: J | j - Key_K = 75, // Key: K | k - Key_L = 76, // Key: L | l - Key_M = 77, // Key: M | m - Key_N = 78, // Key: N | n - Key_O = 79, // Key: O | o - Key_P = 80, // Key: P | p - Key_Q = 81, // Key: Q | q - Key_R = 82, // Key: R | r - Key_S = 83, // Key: S | s - Key_T = 84, // Key: T | t - Key_U = 85, // Key: U | u - Key_V = 86, // Key: V | v - Key_W = 87, // Key: W | w - Key_X = 88, // Key: X | x - Key_Y = 89, // Key: Y | y - Key_Z = 90, // Key: Z | z - Key_Left_Bracket = 91, // Key: [ - Key_Backslash = 92, // Key: '\' - Key_Right_Bracket = 93, // Key: ] - Key_Grave = 96, // Key: ` - // Function keys - Key_Space = 32, // Key: Space - Key_Escape = 256, // Key: Esc - Key_Enter = 257, // Key: Enter - Key_Tab = 258, // Key: Tab - Key_Backspace = 259, // Key: Backspace - Key_Insert = 260, // Key: Ins - Key_Delete = 261, // Key: Del - Key_Right = 262, // Key: Cursor right - Key_Left = 263, // Key: Cursor left - Key_Down = 264, // Key: Cursor down - Key_Up = 265, // Key: Cursor up - Key_Page_Up = 266, // Key: Page up - Key_Page_Down = 267, // Key: Page down - Key_Home = 268, // Key: Home - Key_End = 269, // Key: End - Key_Caps_Lock = 280, // Key: Caps lock - Key_Scroll_Lock = 281, // Key: Scroll down - Key_Num_Lock = 282, // Key: Num lock - Key_Print_Screen = 283, // Key: Print screen - Key_Pause = 284, // Key: Pause - Key_F1 = 290, // Key: F1 - Key_F2 = 291, // Key: F2 - Key_F3 = 292, // Key: F3 - Key_F4 = 293, // Key: F4 - Key_F5 = 294, // Key: F5 - Key_F6 = 295, // Key: F6 - Key_F7 = 296, // Key: F7 - Key_F8 = 297, // Key: F8 - Key_F9 = 298, // Key: F9 - Key_F10 = 299, // Key: F10 - Key_F11 = 300, // Key: F11 - Key_F12 = 301, // Key: F12 - Key_Left_Shift = 340, // Key: Shift left - Key_Left_Control = 341, // Key: Control left - Key_Left_Alt = 342, // Key: Alt left - Key_Left_Super = 343, // Key: Super left - Key_Right_Shift = 344, // Key: Shift right - Key_Right_Control = 345, // Key: Control right - Key_Right_Alt = 346, // Key: Alt right - Key_Right_Super = 347, // Key: Super right - Key_Kb_Menu = 348, // Key: KB menu - // Keypad keys - Key_Kp_0 = 320, // Key: Keypad 0 - Key_Kp_1 = 321, // Key: Keypad 1 - Key_Kp_2 = 322, // Key: Keypad 2 - Key_Kp_3 = 323, // Key: Keypad 3 - Key_Kp_4 = 324, // Key: Keypad 4 - Key_Kp_5 = 325, // Key: Keypad 5 - Key_Kp_6 = 326, // Key: Keypad 6 - Key_Kp_7 = 327, // Key: Keypad 7 - Key_Kp_8 = 328, // Key: Keypad 8 - Key_Kp_9 = 329, // Key: Keypad 9 - Key_Kp_Decimal = 330, // Key: Keypad . - Key_Kp_Divide = 331, // Key: Keypad / - Key_Kp_Multiply = 332, // Key: Keypad * - Key_Kp_Subtract = 333, // Key: Keypad - - Key_Kp_Add = 334, // Key: Keypad + - Key_Kp_Enter = 335, // Key: Keypad Enter - Key_Kp_Equal = 336, // Key: Keypad = - // Android key buttons - Key_Back = 4, // Key: Android back button - Key_Menu = 82, // Key: Android menu button - Key_Volume_Up = 24, // Key: Android volume up button - Key_Volume_Down = 25 // key: android volume down button - -} KeyboardKey; +typedef enum { + RL_KEY_NULL = 0, // Key: NULL, used for no key pressed + // Alphanumeric keys + RL_KEY_APOSTROPHE = 39, // Key: ' + RL_KEY_COMMA = 44, // Key: , + RL_KEY_MINUS = 45, // Key: - + RL_KEY_PERIOD = 46, // Key: . + RL_KEY_SLASH = 47, // Key: / + RL_KEY_ZERO = 48, // Key: 0 + RL_KEY_ONE = 49, // Key: 1 + RL_KEY_TWO = 50, // Key: 2 + RL_KEY_THREE = 51, // Key: 3 + RL_KEY_FOUR = 52, // Key: 4 + RL_KEY_FIVE = 53, // Key: 5 + RL_KEY_SIX = 54, // Key: 6 + RL_KEY_SEVEN = 55, // Key: 7 + RL_KEY_EIGHT = 56, // Key: 8 + RL_KEY_NINE = 57, // Key: 9 + RL_KEY_SEMICOLON = 59, // Key: ; + RL_KEY_EQUAL = 61, // Key: = + RL_KEY_A = 65, // Key: A | a + RL_KEY_B = 66, // Key: B | b + RL_KEY_C = 67, // Key: C | c + RL_KEY_D = 68, // Key: D | d + RL_KEY_E = 69, // Key: E | e + RL_KEY_F = 70, // Key: F | f + RL_KEY_G = 71, // Key: G | g + RL_KEY_H = 72, // Key: H | h + RL_KEY_I = 73, // Key: I | i + RL_KEY_J = 74, // Key: J | j + RL_KEY_K = 75, // Key: K | k + RL_KEY_L = 76, // Key: L | l + RL_KEY_M = 77, // Key: M | m + RL_KEY_N = 78, // Key: N | n + RL_KEY_O = 79, // Key: O | o + RL_KEY_P = 80, // Key: P | p + RL_KEY_Q = 81, // Key: Q | q + RL_KEY_R = 82, // Key: R | r + RL_KEY_S = 83, // Key: S | s + RL_KEY_T = 84, // Key: T | t + RL_KEY_U = 85, // Key: U | u + RL_KEY_V = 86, // Key: V | v + RL_KEY_W = 87, // Key: W | w + RL_KEY_X = 88, // Key: X | x + RL_KEY_Y = 89, // Key: Y | y + RL_KEY_Z = 90, // Key: Z | z + RL_KEY_LEFT_BRACKET = 91, // Key: [ + KEY_BACKSLASH = 92, // Key: '\' + KEY_RIGHT_BRACKET = 93, // Key: ] + RL_KEY_GRAVE = 96, // Key: ` + // Function keys + RL_KEY_SPACE = 32, // Key: Space + RL_KEY_ESCAPE = 256, // Key: Esc + RL_KEY_ENTER = 257, // Key: Enter + RL_KEY_TAB = 258, // Key: Tab + RL_KEY_BACKSPACE = 259, // Key: Backspace + RL_KEY_INSERT = 260, // Key: Ins + RL_KEY_DELETE = 261, // Key: Del + RL_KEY_RIGHT = 262, // Key: Cursor right + RL_KEY_LEFT = 263, // Key: Cursor left + RL_KEY_DOWN = 264, // Key: Cursor down + RL_KEY_UP = 265, // Key: Cursor up + RL_KEY_PAGE_UP = 266, // Key: Page up + RL_KEY_PAGE_DOWN = 267, // Key: Page down + RL_KEY_HOME = 268, // Key: Home + RL_KEY_END = 269, // Key: End + RL_KEY_CAPS_LOCK = 280, // Key: Caps lock + RL_KEY_SCROLL_LOCK = 281, // Key: Scroll down + RL_KEY_NUM_LOCK = 282, // Key: Num lock + RL_KEY_PRINT_SCREEN = 283, // Key: Print screen + RL_KEY_PAUSE = 284, // Key: Pause + RL_KEY_F1 = 290, // Key: F1 + RL_KEY_F2 = 291, // Key: F2 + RL_KEY_F3 = 292, // Key: F3 + RL_KEY_F4 = 293, // Key: F4 + RL_KEY_F5 = 294, // Key: F5 + RL_KEY_F6 = 295, // Key: F6 + RL_KEY_F7 = 296, // Key: F7 + RL_KEY_F8 = 297, // Key: F8 + RL_KEY_F9 = 298, // Key: F9 + RL_KEY_F10 = 299, // Key: F10 + RL_KEY_F11 = 300, // Key: F11 + RL_KEY_F12 = 301, // Key: F12 + RL_KEY_LEFT_SHIFT = 340, // Key: Shift left + RL_KEY_LEFT_CONTROL = 341, // Key: Control left + RL_KEY_LEFT_ALT = 342, // Key: Alt left + RL_KEY_LEFT_SUPER = 343, // Key: Super left + RL_KEY_RIGHT_SHIFT = 344, // Key: Shift right + RL_KEY_RIGHT_CONTROL = 345, // Key: Control right + RL_KEY_RIGHT_ALT = 346, // Key: Alt right + RL_KEY_RIGHT_SUPER = 347, // Key: Super right + RL_KEY_KB_MENU = 348, // Key: KB menu + // Keypad keys + RL_KEY_KP_0 = 320, // Key: Keypad 0 + RL_KEY_KP_1 = 321, // Key: Keypad 1 + RL_KEY_KP_2 = 322, // Key: Keypad 2 + RL_KEY_KP_3 = 323, // Key: Keypad 3 + RL_KEY_KP_4 = 324, // Key: Keypad 4 + RL_KEY_KP_5 = 325, // Key: Keypad 5 + RL_KEY_KP_6 = 326, // Key: Keypad 6 + RL_KEY_KP_7 = 327, // Key: Keypad 7 + RL_KEY_KP_8 = 328, // Key: Keypad 8 + RL_KEY_KP_9 = 329, // Key: Keypad 9 + RL_KEY_KP_DECIMAL = 330, // Key: Keypad . + RL_KEY_KP_DIVIDE = 331, // Key: Keypad / + RL_KEY_KP_MULTIPLY = 332, // Key: Keypad * + RL_KEY_KP_SUBTRACT = 333, // Key: Keypad - + RL_KEY_KP_ADD = 334, // Key: Keypad + + RL_KEY_KP_ENTER = 335, // Key: Keypad Enter + RL_KEY_KP_EQUAL = 336, // Key: Keypad = + // Android key buttons + RL_KEY_BACK = 4, // Key: Android back button + RL_KEY_MENU = 82, // Key: Android menu button + RL_KEY_VOLUME_UP = 24, // Key: Android volume up button + RL_KEY_VOLUME_DOWN = 25 // Key: Android volume down button +} RL_KeyboardKey; // Add backwards compatibility support for deprecated names -#define RL_MOUSE_LEFT_BUTTON MOUSE_BUTTON_LEFT -#define RL_MOUSE_RIGHT_BUTTON MOUSE_BUTTON_RIGHT -#define RL_MOUSE_MIDDLE_BUTTON MOUSE_BUTTON_MIDDLE +#define RL_MOUSE_LEFT_BUTTON RL_MOUSE_BUTTON_LEFT +#define RL_MOUSE_RIGHT_BUTTON RL_MOUSE_BUTTON_RIGHT +#define RL_MOUSE_MIDDLE_BUTTON RL_MOUSE_BUTTON_MIDDLE // Mouse buttons -typedef enum -{ - Mouse_Button_Left = 0, // Mouse button left - Mouse_Button_Right = 1, // Mouse button right - Mouse_Button_Middle = 2, // Mouse button middle (pressed wheel) - Mouse_Button_Side = 3, // Mouse button side (advanced mouse device) - Mouse_Button_Extra = 4, // Mouse button extra (advanced mouse device) - Mouse_Button_Forward = 5, // Mouse button forward (advanced mouse device) - Mouse_Button_Back = 6, // Mouse button back (advanced mouse device) - -} MouseButton; +typedef enum { + RL_MOUSE_BUTTON_LEFT = 0, // Mouse button left + RL_MOUSE_BUTTON_RIGHT = 1, // Mouse button right + RL_MOUSE_BUTTON_MIDDLE = 2, // Mouse button middle (pressed wheel) + RL_MOUSE_BUTTON_SIDE = 3, // Mouse button side (advanced mouse device) + RL_MOUSE_BUTTON_EXTRA = 4, // Mouse button extra (advanced mouse device) + RL_MOUSE_BUTTON_FORWARD = 5, // Mouse button forward (advanced mouse device) + RL_MOUSE_BUTTON_BACK = 6, // Mouse button back (advanced mouse device) +} RL_MouseButton; // Mouse cursor -typedef enum -{ - Mouse_Cursor_Default = 0, // Default pointer shape - Mouse_Cursor_Arrow = 1, // Arrow shape - Mouse_Cursor_Ibeam = 2, // Text writing cursor shape - Mouse_Cursor_Crosshair = 3, // Cross shape - Mouse_Cursor_Pointing_Hand = 4, // Pointing hand cursor - Mouse_Cursor_Resize_Ew = 5, // Horizontal resize/move arrow shape - Mouse_Cursor_Resize_Ns = 6, // Vertical resize/move arrow shape - Mouse_Cursor_Resize_Nwse = 7, // Top-left to bottom-right diagonal resize/move arrow shape - Mouse_Cursor_Resize_Nesw = 8, // The top-right to bottom-left diagonal resize/move arrow shape - Mouse_Cursor_Resize_All = 9, // The omnidirectional resize/move cursor shape - Mouse_Cursor_Not_Allowed = 10 // the operation-not-allowed shape - -} MouseCursor; +typedef enum { + RL_MOUSE_CURSOR_DEFAULT = 0, // Default pointer shape + RL_MOUSE_CURSOR_ARROW = 1, // Arrow shape + RL_MOUSE_CURSOR_IBEAM = 2, // Text writing cursor shape + RL_MOUSE_CURSOR_CROSSHAIR = 3, // Cross shape + RL_MOUSE_CURSOR_POINTING_HAND = 4, // Pointing hand cursor + RL_MOUSE_CURSOR_RESIZE_EW = 5, // Horizontal resize/move arrow shape + RL_MOUSE_CURSOR_RESIZE_NS = 6, // Vertical resize/move arrow shape + RL_MOUSE_CURSOR_RESIZE_NWSE = 7, // Top-left to bottom-right diagonal resize/move arrow shape + RL_MOUSE_CURSOR_RESIZE_NESW = 8, // The top-right to bottom-left diagonal resize/move arrow shape + RL_MOUSE_CURSOR_RESIZE_ALL = 9, // The omnidirectional resize/move cursor shape + RL_MOUSE_CURSOR_NOT_ALLOWED = 10 // The operation-not-allowed shape +} RL_MouseCursor; // Gamepad buttons -typedef enum -{ - Gamepad_Button_Unknown = 0, // Unknown button, just for error checking - Gamepad_Button_Left_Face_Up, // Gamepad left DPAD up button - Gamepad_Button_Left_Face_Right, // Gamepad left DPAD right button - Gamepad_Button_Left_Face_Down, // Gamepad left DPAD down button - Gamepad_Button_Left_Face_Left, // Gamepad left DPAD left button - Gamepad_Button_Right_Face_Up, // Gamepad right button up (i.e. PS3: Triangle, Xbox: Y) - Gamepad_Button_Right_Face_Right, // Gamepad right button right (i.e. PS3: Square, Xbox: X) - Gamepad_Button_Right_Face_Down, // Gamepad right button down (i.e. PS3: Cross, Xbox: A) - Gamepad_Button_Right_Face_Left, // Gamepad right button left (i.e. PS3: Circle, Xbox: B) - Gamepad_Button_Left_Trigger_1, // Gamepad top/back trigger left (first), it could be a trailing button - Gamepad_Button_Left_Trigger_2, // Gamepad top/back trigger left (second), it could be a trailing button - Gamepad_Button_Right_Trigger_1, // Gamepad top/back trigger right (one), it could be a trailing button - Gamepad_Button_Right_Trigger_2, // Gamepad top/back trigger right (second), it could be a trailing button - Gamepad_Button_Middle_Left, // Gamepad center buttons, left one (i.e. PS3: Select) - Gamepad_Button_Middle, // Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX) - Gamepad_Button_Middle_Right, // Gamepad center buttons, right one (i.e. PS3: Start) - Gamepad_Button_Left_Thumb, // Gamepad joystick pressed button left - Gamepad_Button_Right_Thumb // gamepad joystick pressed button right - -} GamepadButton; +typedef enum { + RL_GAMEPAD_BUTTON_UNKNOWN = 0, // Unknown button, just for error checking + RL_GAMEPAD_BUTTON_LEFT_FACE_UP, // Gamepad left DPAD up button + RL_GAMEPAD_BUTTON_LEFT_FACE_RIGHT, // Gamepad left DPAD right button + RL_GAMEPAD_BUTTON_LEFT_FACE_DOWN, // Gamepad left DPAD down button + RL_GAMEPAD_BUTTON_LEFT_FACE_LEFT, // Gamepad left DPAD left button + RL_GAMEPAD_BUTTON_RIGHT_FACE_UP, // Gamepad right button up (i.e. PS3: Triangle, Xbox: Y) + RL_GAMEPAD_BUTTON_RIGHT_FACE_RIGHT, // Gamepad right button right (i.e. PS3: Square, Xbox: X) + RL_GAMEPAD_BUTTON_RIGHT_FACE_DOWN, // Gamepad right button down (i.e. PS3: Cross, Xbox: A) + RL_GAMEPAD_BUTTON_RIGHT_FACE_LEFT, // Gamepad right button left (i.e. PS3: Circle, Xbox: B) + RL_GAMEPAD_BUTTON_LEFT_TRIGGER_1, // Gamepad top/back trigger left (first), it could be a trailing button + RL_GAMEPAD_BUTTON_LEFT_TRIGGER_2, // Gamepad top/back trigger left (second), it could be a trailing button + RL_GAMEPAD_BUTTON_RIGHT_TRIGGER_1, // Gamepad top/back trigger right (one), it could be a trailing button + RL_GAMEPAD_BUTTON_RIGHT_TRIGGER_2, // Gamepad top/back trigger right (second), it could be a trailing button + RL_GAMEPAD_BUTTON_MIDDLE_LEFT, // Gamepad center buttons, left one (i.e. PS3: Select) + RL_GAMEPAD_BUTTON_MIDDLE, // Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX) + RL_GAMEPAD_BUTTON_MIDDLE_RIGHT, // Gamepad center buttons, right one (i.e. PS3: Start) + RL_GAMEPAD_BUTTON_LEFT_THUMB, // Gamepad joystick pressed button left + RL_GAMEPAD_BUTTON_RIGHT_THUMB // Gamepad joystick pressed button right +} RL_GamepadButton; // Gamepad axis -typedef enum -{ - Gamepad_Axis_Left_X = 0, // Gamepad left stick X axis - Gamepad_Axis_Left_Y = 1, // Gamepad left stick Y axis - Gamepad_Axis_Right_X = 2, // Gamepad right stick X axis - Gamepad_Axis_Right_Y = 3, // Gamepad right stick Y axis - Gamepad_Axis_Left_Trigger = 4, // Gamepad back trigger left, pressure level: [1..-1] - Gamepad_Axis_Right_Trigger = 5 // gamepad back trigger right, pressure level: [1..-1] +typedef enum { + RL_GAMEPAD_AXIS_LEFT_X = 0, // Gamepad left stick X axis + RL_GAMEPAD_AXIS_LEFT_Y = 1, // Gamepad left stick Y axis + RL_GAMEPAD_AXIS_RIGHT_X = 2, // Gamepad right stick X axis + RL_GAMEPAD_AXIS_RIGHT_Y = 3, // Gamepad right stick Y axis + RL_GAMEPAD_AXIS_LEFT_TRIGGER = 4, // Gamepad back trigger left, pressure level: [1..-1] + RL_GAMEPAD_AXIS_RIGHT_TRIGGER = 5 // Gamepad back trigger right, pressure level: [1..-1] +} RL_GamepadAxis; -} GamepadAxis; +// RL_Material map index +typedef enum { + RL_MATERIAL_MAP_ALBEDO = 0, // Albedo material (same as: RL_MATERIAL_MAP_DIFFUSE) + RL_MATERIAL_MAP_METALNESS, // Metalness material (same as: RL_MATERIAL_MAP_SPECULAR) + RL_MATERIAL_MAP_NORMAL, // Normal material + RL_MATERIAL_MAP_ROUGHNESS, // Roughness material + RL_MATERIAL_MAP_OCCLUSION, // Ambient occlusion material + RL_MATERIAL_MAP_EMISSION, // Emission material + RL_MATERIAL_MAP_HEIGHT, // Heightmap material + RL_MATERIAL_MAP_CUBEMAP, // Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + RL_MATERIAL_MAP_IRRADIANCE, // Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + RL_MATERIAL_MAP_PREFILTER, // Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + RL_MATERIAL_MAP_BRDF // Brdf material +} RL_MaterialMapIndex; -// Material map index -typedef enum -{ - Material_Map_Albedo = 0, // Albedo material (same as: MATERIAL_MAP_DIFFUSE) - Material_Map_Metalness, // Metalness material (same as: MATERIAL_MAP_SPECULAR) - Material_Map_Normal, // Normal material - Material_Map_Roughness, // Roughness material - Material_Map_Occlusion, // Ambient occlusion material - Material_Map_Emission, // Emission material - Material_Map_Height, // Heightmap material - Material_Map_Cubemap, // Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP) - Material_Map_Irradiance, // Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP) - Material_Map_Prefilter, // Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP) - Material_Map_Brdf // brdf material +#define RL_MATERIAL_MAP_DIFFUSE RL_MATERIAL_MAP_ALBEDO +#define RL_MATERIAL_MAP_SPECULAR RL_MATERIAL_MAP_METALNESS -} MaterialMapIndex; +// RL_Shader location index +typedef enum { + RL_SHADER_LOC_VERTEX_POSITION = 0, // RL_Shader location: vertex attribute: position + RL_SHADER_LOC_VERTEX_TEXCOORD01, // RL_Shader location: vertex attribute: texcoord01 + RL_SHADER_LOC_VERTEX_TEXCOORD02, // RL_Shader location: vertex attribute: texcoord02 + RL_SHADER_LOC_VERTEX_NORMAL, // RL_Shader location: vertex attribute: normal + RL_SHADER_LOC_VERTEX_TANGENT, // RL_Shader location: vertex attribute: tangent + RL_SHADER_LOC_VERTEX_COLOR, // RL_Shader location: vertex attribute: color + RL_SHADER_LOC_MATRIX_MVP, // RL_Shader location: matrix uniform: model-view-projection + RL_SHADER_LOC_MATRIX_VIEW, // RL_Shader location: matrix uniform: view (camera transform) + RL_SHADER_LOC_MATRIX_PROJECTION, // RL_Shader location: matrix uniform: projection + RL_SHADER_LOC_MATRIX_MODEL, // RL_Shader location: matrix uniform: model (transform) + RL_SHADER_LOC_MATRIX_NORMAL, // RL_Shader location: matrix uniform: normal + RL_SHADER_LOC_VECTOR_VIEW, // RL_Shader location: vector uniform: view + RL_SHADER_LOC_COLOR_DIFFUSE, // RL_Shader location: vector uniform: diffuse color + RL_SHADER_LOC_COLOR_SPECULAR, // RL_Shader location: vector uniform: specular color + RL_SHADER_LOC_COLOR_AMBIENT, // RL_Shader location: vector uniform: ambient color + RL_SHADER_LOC_MAP_ALBEDO, // RL_Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE) + RL_SHADER_LOC_MAP_METALNESS, // RL_Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR) + RL_SHADER_LOC_MAP_NORMAL, // RL_Shader location: sampler2d texture: normal + RL_SHADER_LOC_MAP_ROUGHNESS, // RL_Shader location: sampler2d texture: roughness + RL_SHADER_LOC_MAP_OCCLUSION, // RL_Shader location: sampler2d texture: occlusion + RL_SHADER_LOC_MAP_EMISSION, // RL_Shader location: sampler2d texture: emission + RL_SHADER_LOC_MAP_HEIGHT, // RL_Shader location: sampler2d texture: height + RL_SHADER_LOC_MAP_CUBEMAP, // RL_Shader location: samplerCube texture: cubemap + RL_SHADER_LOC_MAP_IRRADIANCE, // RL_Shader location: samplerCube texture: irradiance + RL_SHADER_LOC_MAP_PREFILTER, // RL_Shader location: samplerCube texture: prefilter + RL_SHADER_LOC_MAP_BRDF // RL_Shader location: sampler2d texture: brdf +} RL_ShaderLocationIndex; -#define RL_MATERIAL_MAP_DIFFUSE MATERIAL_MAP_ALBEDO -#define RL_MATERIAL_MAP_SPECULAR MATERIAL_MAP_METALNESS +#define RL_SHADER_LOC_MAP_DIFFUSE RL_SHADER_LOC_MAP_ALBEDO +#define RL_SHADER_LOC_MAP_SPECULAR RL_SHADER_LOC_MAP_METALNESS -// Shader location index -typedef enum -{ - Shader_Loc_Vertex_Position = 0, // Shader location: vertex attribute: position - Shader_Loc_Vertex_Texcoord01, // Shader location: vertex attribute: texcoord01 - Shader_Loc_Vertex_Texcoord02, // Shader location: vertex attribute: texcoord02 - Shader_Loc_Vertex_Normal, // Shader location: vertex attribute: normal - Shader_Loc_Vertex_Tangent, // Shader location: vertex attribute: tangent - Shader_Loc_Vertex_Color, // Shader location: vertex attribute: color - Shader_Loc_Matrix_Mvp, // Shader location: matrix uniform: model-view-projection - Shader_Loc_Matrix_View, // Shader location: matrix uniform: view (camera transform) - Shader_Loc_Matrix_Projection, // Shader location: matrix uniform: projection - Shader_Loc_Matrix_Model, // Shader location: matrix uniform: model (transform) - Shader_Loc_Matrix_Normal, // Shader location: matrix uniform: normal - Shader_Loc_Vector_View, // Shader location: vector uniform: view - Shader_Loc_Color_Diffuse, // Shader location: vector uniform: diffuse color - Shader_Loc_Color_Specular, // Shader location: vector uniform: specular color - Shader_Loc_Color_Ambient, // Shader location: vector uniform: ambient color - Shader_Loc_Map_Albedo, // Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE) - Shader_Loc_Map_Metalness, // Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR) - Shader_Loc_Map_Normal, // Shader location: sampler2d texture: normal - Shader_Loc_Map_Roughness, // Shader location: sampler2d texture: roughness - Shader_Loc_Map_Occlusion, // Shader location: sampler2d texture: occlusion - Shader_Loc_Map_Emission, // Shader location: sampler2d texture: emission - Shader_Loc_Map_Height, // Shader location: sampler2d texture: height - Shader_Loc_Map_Cubemap, // Shader location: samplerCube texture: cubemap - Shader_Loc_Map_Irradiance, // Shader location: samplerCube texture: irradiance - Shader_Loc_Map_Prefilter, // Shader location: samplerCube texture: prefilter - Shader_Loc_Map_Brdf // shader location: sampler2d texture: brdf +// RL_Shader uniform data type +typedef enum { + RL_SHADER_UNIFORM_FLOAT = 0, // RL_Shader uniform type: float + RL_SHADER_UNIFORM_VEC2, // RL_Shader uniform type: vec2 (2 float) + RL_SHADER_UNIFORM_VEC3, // RL_Shader uniform type: vec3 (3 float) + RL_SHADER_UNIFORM_VEC4, // RL_Shader uniform type: vec4 (4 float) + RL_SHADER_UNIFORM_INT, // RL_Shader uniform type: int + RL_SHADER_UNIFORM_IVEC2, // RL_Shader uniform type: ivec2 (2 int) + RL_SHADER_UNIFORM_IVEC3, // RL_Shader uniform type: ivec3 (3 int) + RL_SHADER_UNIFORM_IVEC4, // RL_Shader uniform type: ivec4 (4 int) + RL_SHADER_UNIFORM_SAMPLER2D // RL_Shader uniform type: sampler2d +} RL_ShaderUniformDataType; -} ShaderLocationIndex; - -#define RL_SHADER_LOC_MAP_DIFFUSE SHADER_LOC_MAP_ALBEDO -#define RL_SHADER_LOC_MAP_SPECULAR SHADER_LOC_MAP_METALNESS - -// Shader uniform data type -typedef enum -{ - Shader_Uniform_Float = 0, // Shader uniform type: float - Shader_Uniform_Vec2, // Shader uniform type: vec2 (2 float) - Shader_Uniform_Vec3, // Shader uniform type: vec3 (3 float) - Shader_Uniform_Vec4, // Shader uniform type: vec4 (4 float) - Shader_Uniform_Int, // Shader uniform type: int - Shader_Uniform_Ivec2, // Shader uniform type: ivec2 (2 int) - Shader_Uniform_Ivec3, // Shader uniform type: ivec3 (3 int) - Shader_Uniform_Ivec4, // Shader uniform type: ivec4 (4 int) - Shader_Uniform_Sampler2d // shader uniform type: sampler2d - -} ShaderUniformDataType; - -// Shader attribute data types -typedef enum -{ - Shader_Attrib_Float = 0, // Shader attribute type: float - Shader_Attrib_Vec2, // Shader attribute type: vec2 (2 float) - Shader_Attrib_Vec3, // Shader attribute type: vec3 (3 float) - Shader_Attrib_Vec4 // shader attribute type: vec4 (4 float) - -} ShaderAttributeDataType; +// RL_Shader attribute data types +typedef enum { + RL_SHADER_ATTRIB_FLOAT = 0, // RL_Shader attribute type: float + RL_SHADER_ATTRIB_VEC2, // RL_Shader attribute type: vec2 (2 float) + RL_SHADER_ATTRIB_VEC3, // RL_Shader attribute type: vec3 (3 float) + RL_SHADER_ATTRIB_VEC4 // RL_Shader attribute type: vec4 (4 float) +} RL_ShaderAttributeDataType; // Pixel formats // NOTE: Support depends on OpenGL version and platform -typedef enum -{ - Pixelformat_Uncompressed_Grayscale = 1, // 8 bit per pixel (no alpha) - Pixelformat_Uncompressed_Gray_Alpha, // 8*2 bpp (2 channels) - Pixelformat_Uncompressed_R5g6b5, // 16 bpp - Pixelformat_Uncompressed_R8g8b8, // 24 bpp - Pixelformat_Uncompressed_R5g5b5a1, // 16 bpp (1 bit alpha) - Pixelformat_Uncompressed_R4g4b4a4, // 16 bpp (4 bit alpha) - Pixelformat_Uncompressed_R8g8b8a8, // 32 bpp - Pixelformat_Uncompressed_R32, // 32 bpp (1 channel - float) - Pixelformat_Uncompressed_R32g32b32, // 32*3 bpp (3 channels - float) - Pixelformat_Uncompressed_R32g32b32a32, // 32*4 bpp (4 channels - float) - Pixelformat_Uncompressed_R16, // 16 bpp (1 channel - half float) - Pixelformat_Uncompressed_R16g16b16, // 16*3 bpp (3 channels - half float) - Pixelformat_Uncompressed_R16g16b16a16, // 16*4 bpp (4 channels - half float) - Pixelformat_Compressed_Dxt1_Rgb, // 4 bpp (no alpha) - Pixelformat_Compressed_Dxt1_Rgba, // 4 bpp (1 bit alpha) - Pixelformat_Compressed_Dxt3_Rgba, // 8 bpp - Pixelformat_Compressed_Dxt5_Rgba, // 8 bpp - Pixelformat_Compressed_Etc1_Rgb, // 4 bpp - Pixelformat_Compressed_Etc2_Rgb, // 4 bpp - Pixelformat_Compressed_Etc2_Eac_Rgba, // 8 bpp - Pixelformat_Compressed_Pvrt_Rgb, // 4 bpp - Pixelformat_Compressed_Pvrt_Rgba, // 4 bpp - Pixelformat_Compressed_Astc_4x4_Rgba, // 8 bpp - Pixelformat_Compressed_Astc_8x8_Rgba // 2 bpp +typedef enum { + RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha) + RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels) + RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha) + RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha) + RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float) + RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float) + RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float) + RL_PIXELFORMAT_UNCOMPRESSED_R16, // 16 bpp (1 channel - half float) + RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16, // 16*3 bpp (3 channels - half float) + RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16, // 16*4 bpp (4 channels - half float) + RL_PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha) + RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha) + RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp +} RL_PixelFormat; -} PixelFormat; - -// Texture parameters: filter mode +// RL_Texture parameters: filter mode // NOTE 1: Filtering considers mipmaps if available in the texture // NOTE 2: Filter is accordingly set for minification and magnification -typedef enum -{ - Texture_Filter_Point = 0, // No filter, just pixel approximation - Texture_Filter_Bilinear, // Linear filtering - Texture_Filter_Trilinear, // Trilinear filtering (linear with mipmaps) - Texture_Filter_Anisotropic_4x, // Anisotropic filtering 4x - Texture_Filter_Anisotropic_8x, // Anisotropic filtering 8x - Texture_Filter_Anisotropic_16x, // Anisotropic filtering 16x +typedef enum { + RL_TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation + RL_TEXTURE_FILTER_BILINEAR, // Linear filtering + RL_TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps) + RL_TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x + RL_TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x + RL_TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x +} RL_TextureFilter; -} TextureFilter; - -// Texture parameters: wrap mode -typedef enum -{ - Texture_Wrap_Repeat = 0, // Repeats texture in tiled mode - Texture_Wrap_Clamp, // Clamps texture to edge pixel in tiled mode - Texture_Wrap_Mirror_Repeat, // Mirrors and repeats the texture in tiled mode - Texture_Wrap_Mirror_Clamp // mirrors and clamps to border the texture in tiled mode - -} TextureWrap; +// RL_Texture parameters: wrap mode +typedef enum { + RL_TEXTURE_WRAP_REPEAT = 0, // Repeats texture in tiled mode + RL_TEXTURE_WRAP_CLAMP, // Clamps texture to edge pixel in tiled mode + RL_TEXTURE_WRAP_MIRROR_REPEAT, // Mirrors and repeats the texture in tiled mode + RL_TEXTURE_WRAP_MIRROR_CLAMP // Mirrors and clamps to border the texture in tiled mode +} RL_TextureWrap; // Cubemap layouts -typedef enum -{ - Cubemap_Layout_Auto_Detect = 0, // Automatically detect layout type - Cubemap_Layout_Line_Vertical, // Layout is defined by a vertical line with faces - Cubemap_Layout_Line_Horizontal, // Layout is defined by a horizontal line with faces - Cubemap_Layout_Cross_Three_By_Four, // Layout is defined by a 3x4 cross with cubemap faces - Cubemap_Layout_Cross_Four_By_Three, // Layout is defined by a 4x3 cross with cubemap faces - Cubemap_Layout_Panorama // layout is defined by a panorama image (equirrectangular map) +typedef enum { + RL_CUBEMAP_LAYOUT_AUTO_DETECT = 0, // Automatically detect layout type + RL_CUBEMAP_LAYOUT_LINE_VERTICAL, // Layout is defined by a vertical line with faces + RL_CUBEMAP_LAYOUT_LINE_HORIZONTAL, // Layout is defined by a horizontal line with faces + RL_CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR, // Layout is defined by a 3x4 cross with cubemap faces + RL_CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE, // Layout is defined by a 4x3 cross with cubemap faces + RL_CUBEMAP_LAYOUT_PANORAMA // Layout is defined by a panorama image (equirrectangular map) +} RL_CubemapLayout; -} CubemapLayout; +// RL_Font type, defines generation method +typedef enum { + RL_FONT_DEFAULT = 0, // Default font generation, anti-aliased + RL_FONT_BITMAP, // Bitmap font generation, no anti-aliasing + RL_FONT_SDF // SDF font generation, requires external shader +} RL_FontType; -// Font type, defines generation method -typedef enum -{ - Font_Default = 0, // Default font generation, anti-aliased - Font_Bitmap, // Bitmap font generation, no anti-aliasing - Font_Sdf // sdf font generation, requires external shader +// RL_Color blending modes (pre-defined) +typedef enum { + RL_BLEND_ALPHA = 0, // Blend textures considering alpha (default) + RL_BLEND_ADDITIVE, // Blend textures adding colors + RL_BLEND_MULTIPLIED, // Blend textures multiplying colors + RL_BLEND_ADD_COLORS, // Blend textures adding colors (alternative) + RL_BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative) + RL_BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha + RL_BLEND_CUSTOM, // Blend textures using custom src/dst factors (use RLGL_SetBlendFactors()) + RL_BLEND_CUSTOM_SEPARATE // Blend textures using custom rgb/alpha separate src/dst factors (use RLGL_SetBlendFactorsSeparate()) +} RL_BlendMode; -} FontType; - -// Color blending modes (pre-defined) -typedef enum -{ - Blend_Alpha = 0, // Blend textures considering alpha (default) - Blend_Additive, // Blend textures adding colors - Blend_Multiplied, // Blend textures multiplying colors - Blend_Add_Colors, // Blend textures adding colors (alternative) - Blend_Subtract_Colors, // Blend textures subtracting colors (alternative) - Blend_Alpha_Premultiply, // Blend premultiplied textures considering alpha - Blend_Custom, // Blend textures using custom src/dst factors (use rlSetBlendFactors()) - Blend_Custom_Separate // blend textures using custom rgb/alpha separate src/dst factors (use rlsetblendfactorsseparate()) - -} BlendMode; - -// Gesture +// RL_Gesture // NOTE: Provided as bit-wise flags to enable only desired gestures -typedef enum -{ - Gesture_None = 0, // No gesture - Gesture_Tap = 1, // Tap gesture - Gesture_Doubletap = 2, // Double tap gesture - Gesture_Hold = 4, // Hold gesture - Gesture_Drag = 8, // Drag gesture - Gesture_Swipe_Right = 16, // Swipe right gesture - Gesture_Swipe_Left = 32, // Swipe left gesture - Gesture_Swipe_Up = 64, // Swipe up gesture - Gesture_Swipe_Down = 128, // Swipe down gesture - Gesture_Pinch_In = 256, // Pinch in gesture - Gesture_Pinch_Out = 512 // pinch out gesture +typedef enum { + RL_GESTURE_NONE = 0, // No gesture + RL_GESTURE_TAP = 1, // Tap gesture + RL_GESTURE_DOUBLETAP = 2, // Double tap gesture + RL_GESTURE_HOLD = 4, // Hold gesture + RL_GESTURE_DRAG = 8, // Drag gesture + RL_GESTURE_SWIPE_RIGHT = 16, // Swipe right gesture + RL_GESTURE_SWIPE_LEFT = 32, // Swipe left gesture + RL_GESTURE_SWIPE_UP = 64, // Swipe up gesture + RL_GESTURE_SWIPE_DOWN = 128, // Swipe down gesture + RL_GESTURE_PINCH_IN = 256, // Pinch in gesture + RL_GESTURE_PINCH_OUT = 512 // Pinch out gesture +} RL_Gesture; -} Gesture; +// RL_Camera system modes +typedef enum { + RL_CAMERA_CUSTOM = 0, // Custom camera + RL_CAMERA_FREE, // Free camera + RL_CAMERA_ORBITAL, // Orbital camera + RL_CAMERA_FIRST_PERSON, // First person camera + RL_CAMERA_THIRD_PERSON // Third person camera +} RL_CameraMode; -// Camera system modes -typedef enum -{ - Camera_Custom = 0, // Custom camera - Camera_Free, // Free camera - Camera_Orbital, // Orbital camera - Camera_First_Person, // First person camera - Camera_Third_Person // third person camera - -} CameraMode; - -// Camera projection -typedef enum -{ - Camera_Perspective = 0, // Perspective projection - Camera_Orthographic // orthographic projection - -} CameraProjection; +// RL_Camera projection +typedef enum { + RL_CAMERA_PERSPECTIVE = 0, // Perspective projection + RL_CAMERA_ORTHOGRAPHIC // Orthographic projection +} RL_CameraProjection; // N-patch layout -typedef enum -{ - Npatch_Nine_Patch = 0, // Npatch layout: 3x3 tiles - Npatch_Three_Patch_Vertical, // Npatch layout: 1x3 tiles - Npatch_Three_Patch_Horizontal // npatch layout: 3x1 tiles - -} NPatchLayout; +typedef enum { + RL_NPATCH_NINE_PATCH = 0, // Npatch layout: 3x3 tiles + RL_NPATCH_THREE_PATCH_VERTICAL, // Npatch layout: 1x3 tiles + RL_NPATCH_THREE_PATCH_HORIZONTAL // Npatch layout: 3x1 tiles +} RL_NPatchLayout; // Callbacks to hook some internal functions // WARNING: These callbacks are intended for advance users -typedef void ( *TraceLogCallback )( int logLevel, char const* text, va_list args ); // Logging: Redirect trace log messages -typedef unsigned char* ( *LoadFileDataCallback )( char const* fileName, int* dataSize ); // FileIO: Load binary data -typedef bool ( *SaveFileDataCallback )( char const* fileName, void* data, int dataSize ); // FileIO: Save binary data -typedef char* ( *LoadFileTextCallback )( char const* fileName ); // FileIO: Load text data -typedef bool ( *SaveFileTextCallback )( char const* fileName, char* text ); // FileIO: Save text data +typedef void (*RL_TraceLogCallback)(int logLevel, const char *text, va_list args); // Logging: Redirect trace log messages +typedef unsigned char *(*RL_LoadFileDataCallback)(const char *fileName, int *dataSize); // FileIO: Load binary data +typedef bool (*RL_SaveFileDataCallback)(const char *fileName, void *data, int dataSize); // FileIO: Save binary data +typedef char *(*RL_LoadFileTextCallback)(const char *fileName); // FileIO: Load text data +typedef bool (*RL_SaveFileTextCallback)(const char *fileName, char *text); // FileIO: Save text data //------------------------------------------------------------------------------------ // Global Variables Definition @@ -1127,869 +946,717 @@ typedef bool ( *SaveFileTextCallback )( char const* fileName, char* te // Window and Graphics Device Functions (Module: core) //------------------------------------------------------------------------------------ -#if defined( __cplusplus ) -namespace raylib -{ - extern "C" - { -// Prevents name mangling of functions +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions #endif - // Window-related functions - RLAPI void init_window( s32 width, s32 height, char const* title ); // Initialize window and OpenGL context - RLAPI void close_window( void ); // Close window and unload OpenGL context - RLAPI bool window_should_close( void ); // Check if application should close (KEY_ESCAPE pressed or windows close icon clicked) - RLAPI bool is_window_ready( void ); // Check if window has been initialized successfully - RLAPI bool is_window_fullscreen( void ); // Check if window is currently fullscreen - RLAPI bool is_window_hidden( void ); // Check if window is currently hidden (only PLATFORM_DESKTOP) - RLAPI bool is_window_minimized( void ); // Check if window is currently minimized (only PLATFORM_DESKTOP) - RLAPI bool is_window_maximized( void ); // Check if window is currently maximized (only PLATFORM_DESKTOP) - RLAPI bool is_window_focused( void ); // Check if window is currently focused (only PLATFORM_DESKTOP) - RLAPI bool is_window_resized( void ); // Check if window has been resized last frame - RLAPI bool is_window_state( u32 flag ); // Check if one specific window flag is enabled - RLAPI void set_window_state( u32 flags ); // Set window configuration state using flags (only PLATFORM_DESKTOP) - RLAPI void clear_window_state( u32 flags ); // Clear window configuration state flags - RLAPI void toggle_fullscreen( void ); // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP) - RLAPI void toggle_borderless_windowed( void ); // Toggle window state: borderless windowed (only PLATFORM_DESKTOP) - RLAPI void maximize_window( void ); // Set window state: maximized, if resizable (only PLATFORM_DESKTOP) - RLAPI void minimize_window( void ); // Set window state: minimized, if resizable (only PLATFORM_DESKTOP) - RLAPI void restore_window( void ); // Set window state: not minimized/maximized (only PLATFORM_DESKTOP) - RLAPI void set_window_icon( Image image ); // Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP) - RLAPI void set_window_icons( Image* images, s32 count ); // Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP) - RLAPI void set_window_title( char const* title ); // Set title for window (only PLATFORM_DESKTOP and PLATFORM_WEB) - RLAPI void set_window_position( s32 x, s32 y ); // Set window position on screen (only PLATFORM_DESKTOP) - RLAPI void set_window_monitor( s32 monitor ); // Set monitor for the current window - RLAPI void set_window_min_size( s32 width, s32 height ); // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE) - RLAPI void set_window_max_size( s32 width, s32 height ); // Set window maximum dimensions (for FLAG_WINDOW_RESIZABLE) - RLAPI void set_window_size( s32 width, s32 height ); // Set window dimensions - RLAPI void set_window_opacity( f32 opacity ); // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP) - RLAPI void set_window_focused( void ); // Set window focused (only PLATFORM_DESKTOP) - RLAPI void* get_window_handle( void ); // Get native window handle - RLAPI int get_screen_width( void ); // Get current screen width - RLAPI int get_screen_height( void ); // Get current screen height - RLAPI int get_render_width( void ); // Get current render width (it considers HiDPI) - RLAPI int get_render_height( void ); // Get current render height (it considers HiDPI) - RLAPI int get_monitor_count( void ); // Get number of connected monitors - RLAPI int get_current_monitor( void ); // Get current connected monitor - RLAPI Vector2 get_monitor_position( s32 monitor ); // Get specified monitor position - RLAPI int get_monitor_width( s32 monitor ); // Get specified monitor width (current video mode used by monitor) - RLAPI int get_monitor_height( s32 monitor ); // Get specified monitor height (current video mode used by monitor) - RLAPI int get_monitor_physical_width( s32 monitor ); // Get specified monitor physical width in millimetres - RLAPI int get_monitor_physical_height( s32 monitor ); // Get specified monitor physical height in millimetres - RLAPI int get_monitor_refresh_rate( s32 monitor ); // Get specified monitor refresh rate - RLAPI Vector2 get_window_position( void ); // Get window position XY on monitor - RLAPI Vector2 get_window_scale_dpi( void ); // Get window scale DPI factor - RLAPI char const* get_monitor_name( s32 monitor ); // Get the human-readable, UTF-8 encoded name of the specified monitor - RLAPI void set_clipboard_text( char const* text ); // Set clipboard text content - RLAPI char const* get_clipboard_text( void ); // Get clipboard text content - RLAPI void enable_event_waiting( void ); // Enable waiting for events on EndDrawing(), no automatic event polling - RLAPI void disable_event_waiting( void ); // Disable waiting for events on EndDrawing(), automatic events polling +// Window-related functions +RLAPI void RL_InitWindow(int width, int height, const char *title); // Initialize window and OpenGL context +RLAPI void RL_CloseWindow(void); // Close window and unload OpenGL context +RLAPI bool RL_WindowShouldClose(void); // Check if application should close (RL_KEY_ESCAPE pressed or windows close icon clicked) +RLAPI bool RL_IsWindowReady(void); // Check if window has been initialized successfully +RLAPI bool RL_IsWindowFullscreen(void); // Check if window is currently fullscreen +RLAPI bool RL_IsWindowHidden(void); // Check if window is currently hidden (only PLATFORM_DESKTOP) +RLAPI bool RL_IsWindowMinimized(void); // Check if window is currently minimized (only PLATFORM_DESKTOP) +RLAPI bool RL_IsWindowMaximized(void); // Check if window is currently maximized (only PLATFORM_DESKTOP) +RLAPI bool RL_IsWindowFocused(void); // Check if window is currently focused (only PLATFORM_DESKTOP) +RLAPI bool RL_IsWindowResized(void); // Check if window has been resized last frame +RLAPI bool RL_IsWindowState(unsigned int flag); // Check if one specific window flag is enabled +RLAPI void RL_SetWindowState(unsigned int flags); // Set window configuration state using flags (only PLATFORM_DESKTOP) +RLAPI void RL_ClearWindowState(unsigned int flags); // Clear window configuration state flags +RLAPI void RL_ToggleFullscreen(void); // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP) +RLAPI void RL_ToggleBorderlessWindowed(void); // Toggle window state: borderless windowed (only PLATFORM_DESKTOP) +RLAPI void RL_MaximizeWindow(void); // Set window state: maximized, if resizable (only PLATFORM_DESKTOP) +RLAPI void RL_MinimizeWindow(void); // Set window state: minimized, if resizable (only PLATFORM_DESKTOP) +RLAPI void RL_RestoreWindow(void); // Set window state: not minimized/maximized (only PLATFORM_DESKTOP) +RLAPI void RL_SetWindowIcon(RL_Image image); // Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP) +RLAPI void RL_SetWindowIcons(RL_Image *images, int count); // Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP) +RLAPI void RL_SetWindowTitle(const char *title); // Set title for window (only PLATFORM_DESKTOP and PLATFORM_WEB) +RLAPI void RL_SetWindowPosition(int x, int y); // Set window position on screen (only PLATFORM_DESKTOP) +RLAPI void RL_SetWindowMonitor(int monitor); // Set monitor for the current window +RLAPI void RL_SetWindowMinSize(int width, int height); // Set window minimum dimensions (for RL_FLAG_WINDOW_RESIZABLE) +RLAPI void RL_SetWindowMaxSize(int width, int height); // Set window maximum dimensions (for RL_FLAG_WINDOW_RESIZABLE) +RLAPI void RL_SetWindowSize(int width, int height); // Set window dimensions +RLAPI void RL_SetWindowOpacity(float opacity); // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP) +RLAPI void RL_SetWindowFocused(void); // Set window focused (only PLATFORM_DESKTOP) +RLAPI void *RL_GetWindowHandle(void); // Get native window handle +RLAPI int RL_GetScreenWidth(void); // Get current screen width +RLAPI int RL_GetScreenHeight(void); // Get current screen height +RLAPI int RL_GetRenderWidth(void); // Get current render width (it considers HiDPI) +RLAPI int RL_GetRenderHeight(void); // Get current render height (it considers HiDPI) +RLAPI int RL_GetMonitorCount(void); // Get number of connected monitors +RLAPI int RL_GetCurrentMonitor(void); // Get current connected monitor +RLAPI RL_Vector2 RL_GetMonitorPosition(int monitor); // Get specified monitor position +RLAPI int RL_GetMonitorWidth(int monitor); // Get specified monitor width (current video mode used by monitor) +RLAPI int RL_GetMonitorHeight(int monitor); // Get specified monitor height (current video mode used by monitor) +RLAPI int RL_GetMonitorPhysicalWidth(int monitor); // Get specified monitor physical width in millimetres +RLAPI int RL_GetMonitorPhysicalHeight(int monitor); // Get specified monitor physical height in millimetres +RLAPI int RL_GetMonitorRefreshRate(int monitor); // Get specified monitor refresh rate +RLAPI RL_Vector2 RL_GetWindowPosition(void); // Get window position XY on monitor +RLAPI RL_Vector2 RL_GetWindowScaleDPI(void); // Get window scale DPI factor +RLAPI const char *RL_GetMonitorName(int monitor); // Get the human-readable, UTF-8 encoded name of the specified monitor +RLAPI void RL_SetClipboardText(const char *text); // Set clipboard text content +RLAPI const char *RL_GetClipboardText(void); // Get clipboard text content +RLAPI void RL_EnableEventWaiting(void); // Enable waiting for events on RL_EndDrawing(), no automatic event polling +RLAPI void RL_DisableEventWaiting(void); // Disable waiting for events on RL_EndDrawing(), automatic events polling - // Cursor-related functions - RLAPI void show_cursor( void ); // Shows cursor - RLAPI void hide_cursor( void ); // Hides cursor - RLAPI bool is_cursor_hidden( void ); // Check if cursor is not visible - RLAPI void enable_cursor( void ); // Enables cursor (unlock cursor) - RLAPI void disable_cursor( void ); // Disables cursor (lock cursor) - RLAPI bool is_cursor_on_screen( void ); // Check if cursor is on the screen +// Cursor-related functions +RLAPI void RL_ShowCursor(void); // Shows cursor +RLAPI void RL_HideCursor(void); // Hides cursor +RLAPI bool RL_IsCursorHidden(void); // Check if cursor is not visible +RLAPI void RL_EnableCursor(void); // Enables cursor (unlock cursor) +RLAPI void RL_DisableCursor(void); // Disables cursor (lock cursor) +RLAPI bool RL_IsCursorOnScreen(void); // Check if cursor is on the screen - // Drawing-related functions - RLAPI void clear_background( Color color ); // Set background color (framebuffer clear color) - RLAPI void begin_drawing( void ); // Setup canvas (framebuffer) to start drawing - RLAPI void end_drawing( void ); // End canvas drawing and swap buffers (double buffering) - RLAPI void begin_mode_2d( Camera2D camera ); // Begin 2D mode with custom camera (2D) - RLAPI void end_mode_2d( void ); // Ends 2D mode with custom camera - RLAPI void begin_mode_3d( Camera3D camera ); // Begin 3D mode with custom camera (3D) - RLAPI void end_mode_3d( void ); // Ends 3D mode and returns to default 2D orthographic mode - RLAPI void begin_texture_mode( RenderTexture2D target ); // Begin drawing to render texture - RLAPI void end_texture_mode( void ); // Ends drawing to render texture - RLAPI void begin_shader_mode( Shader shader ); // Begin custom shader drawing - RLAPI void end_shader_mode( void ); // End custom shader drawing (use default shader) - RLAPI void begin_blend_mode( s32 mode ); // Begin blending mode (alpha, additive, multiplied, subtract, custom) - RLAPI void end_blend_mode( void ); // End blending mode (reset to default: alpha blending) - RLAPI void begin_scissor_mode( s32 x, s32 y, s32 width, s32 height ); // Begin scissor mode (define screen area for following drawing) - RLAPI void end_scissor_mode( void ); // End scissor mode - RLAPI void begin_vr_stereo_mode( VrStereoConfig config ); // Begin stereo rendering (requires VR simulator) - RLAPI void end_vr_stereo_mode( void ); // End stereo rendering (requires VR simulator) +// Drawing-related functions +RLAPI void RL_ClearBackground(RL_Color color); // Set background color (framebuffer clear color) +RLAPI void RL_BeginDrawing(void); // Setup canvas (framebuffer) to start drawing +RLAPI void RL_EndDrawing(void); // End canvas drawing and swap buffers (double buffering) +RLAPI void RL_BeginMode2D(RL_Camera2D camera); // Begin 2D mode with custom camera (2D) +RLAPI void RL_EndMode2D(void); // Ends 2D mode with custom camera +RLAPI void RL_BeginMode3D(RL_Camera3D camera); // Begin 3D mode with custom camera (3D) +RLAPI void RL_EndMode3D(void); // Ends 3D mode and returns to default 2D orthographic mode +RLAPI void RL_BeginTextureMode(RL_RenderTexture2D target); // Begin drawing to render texture +RLAPI void RL_EndTextureMode(void); // Ends drawing to render texture +RLAPI void RL_BeginShaderMode(RL_Shader shader); // Begin custom shader drawing +RLAPI void RL_EndShaderMode(void); // End custom shader drawing (use default shader) +RLAPI void RL_BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied, subtract, custom) +RLAPI void RL_EndBlendMode(void); // End blending mode (reset to default: alpha blending) +RLAPI void RL_BeginScissorMode(int x, int y, int width, int height); // Begin scissor mode (define screen area for following drawing) +RLAPI void RL_EndScissorMode(void); // End scissor mode +RLAPI void RL_BeginVrStereoMode(RL_VrStereoConfig config); // Begin stereo rendering (requires VR simulator) +RLAPI void RL_EndVrStereoMode(void); // End stereo rendering (requires VR simulator) - // VR stereo config functions for VR simulator - RLAPI VrStereoConfig load_vr_stereo_config( VrDeviceInfo device ); // Load VR stereo config for VR simulator device parameters - RLAPI void unload_vr_stereo_config( VrStereoConfig config ); // Unload VR stereo config +// VR stereo config functions for VR simulator +RLAPI RL_VrStereoConfig RL_LoadVrStereoConfig(RL_VrDeviceInfo device); // Load VR stereo config for VR simulator device parameters +RLAPI void RL_UnloadVrStereoConfig(RL_VrStereoConfig config); // Unload VR stereo config - // Shader management functions - // NOTE: Shader functionality is not available on OpenGL 1.1 - RLAPI Shader load_shader( char const* vsFileName, char const* fsFileName ); // Load shader from files and bind default locations - RLAPI Shader load_shader_from_memory( char const* vsCode, char const* fsCode ); // Load shader from code strings and bind default locations - RLAPI bool is_shader_ready( Shader shader ); // Check if a shader is ready - RLAPI int get_shader_location( Shader shader, char const* uniformName ); // Get shader uniform location - RLAPI int get_shader_location_attrib( Shader shader, char const* attribName ); // Get shader attribute location - RLAPI void set_shader_value( Shader shader, s32 locIndex, void const* value, s32 uniformType ); // Set shader uniform value - RLAPI void set_shader_value_v( Shader shader, s32 locIndex, void const* value, s32 uniformType, s32 count ); // Set shader uniform value vector - RLAPI void set_shader_value_matrix( Shader shader, s32 locIndex, Matrix mat ); // Set shader uniform value (matrix 4x4) - RLAPI void set_shader_value_texture( Shader shader, s32 locIndex, Texture2D texture ); // Set shader uniform value for texture (sampler2d) - RLAPI void unload_shader( Shader shader ); // Unload shader from GPU memory (VRAM) +// RL_Shader management functions +// NOTE: RL_Shader functionality is not available on OpenGL 1.1 +RLAPI RL_Shader RL_LoadShader(const char *vsFileName, const char *fsFileName); // Load shader from files and bind default locations +RLAPI RL_Shader RL_LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations +RLAPI bool RL_IsShaderReady(RL_Shader shader); // Check if a shader is ready +RLAPI int RL_GetShaderLocation(RL_Shader shader, const char *uniformName); // Get shader uniform location +RLAPI int RL_GetShaderLocationAttrib(RL_Shader shader, const char *attribName); // Get shader attribute location +RLAPI void RL_SetShaderValue(RL_Shader shader, int locIndex, const void *value, int uniformType); // Set shader uniform value +RLAPI void RL_SetShaderValueV(RL_Shader shader, int locIndex, const void *value, int uniformType, int count); // Set shader uniform value vector +RLAPI void RL_SetShaderValueMatrix(RL_Shader shader, int locIndex, RL_Matrix mat); // Set shader uniform value (matrix 4x4) +RLAPI void RL_SetShaderValueTexture(RL_Shader shader, int locIndex, RL_Texture2D texture); // Set shader uniform value for texture (sampler2d) +RLAPI void RL_UnloadShader(RL_Shader shader); // Unload shader from GPU memory (VRAM) - // Screen-space-related functions - RLAPI Ray get_mouse_ray( Vector2 mousePosition, Camera camera ); // Get a ray trace from mouse position - RLAPI Matrix get_camera_matrix( Camera camera ); // Get camera transform matrix (view matrix) - RLAPI Matrix get_camera_matrix_2d( Camera2D camera ); // Get camera 2d transform matrix - RLAPI Vector2 get_world_to_screen( Vector3 position, Camera camera ); // Get the screen space position for a 3d world space position - RLAPI Vector2 get_screen_to_world_2d( Vector2 position, Camera2D camera ); // Get the world space position for a 2d camera screen space position - RLAPI Vector2 get_world_to_screen_ex( Vector3 position, Camera camera, s32 width, s32 height ); // Get size position for a 3d world space position - RLAPI Vector2 get_world_to_screen_2d( Vector2 position, Camera2D camera ); // Get the screen space position for a 2d camera world space position +// Screen-space-related functions +RLAPI RL_Ray RL_GetMouseRay(RL_Vector2 mousePosition, RL_Camera camera); // Get a ray trace from mouse position +RLAPI RL_Matrix RL_GetCameraMatrix(RL_Camera camera); // Get camera transform matrix (view matrix) +RLAPI RL_Matrix RL_GetCameraMatrix2D(RL_Camera2D camera); // Get camera 2d transform matrix +RLAPI RL_Vector2 RL_GetWorldToScreen(RL_Vector3 position, RL_Camera camera); // Get the screen space position for a 3d world space position +RLAPI RL_Vector2 RL_GetScreenToWorld2D(RL_Vector2 position, RL_Camera2D camera); // Get the world space position for a 2d camera screen space position +RLAPI RL_Vector2 RL_GetWorldToScreenEx(RL_Vector3 position, RL_Camera camera, int width, int height); // Get size position for a 3d world space position +RLAPI RL_Vector2 RL_GetWorldToScreen2D(RL_Vector2 position, RL_Camera2D camera); // Get the screen space position for a 2d camera world space position - // Timing-related functions - RLAPI void set_target_fps( s32 fps ); // Set target FPS (maximum) - RLAPI float get_frame_time( void ); // Get time in seconds for last frame drawn (delta time) - RLAPI double get_time( void ); // Get elapsed time in seconds since InitWindow() - RLAPI int get_fps( void ); // Get current FPS +// Timing-related functions +RLAPI void RL_SetTargetFPS(int fps); // Set target FPS (maximum) +RLAPI float RL_GetFrameTime(void); // Get time in seconds for last frame drawn (delta time) +RLAPI double RL_GetTime(void); // Get elapsed time in seconds since RL_InitWindow() +RLAPI int RL_GetFPS(void); // Get current FPS - // Custom frame control functions - // NOTE: Those functions are intended for advance users that want full control over the frame processing - // By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents() - // To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL - RLAPI void swap_screen_buffer( void ); // Swap back buffer with front buffer (screen drawing) - RLAPI void poll_input_events( void ); // Register all input events - RLAPI void wait_time( double seconds ); // Wait for some time (halt program execution) +// Custom frame control functions +// NOTE: Those functions are intended for advance users that want full control over the frame processing +// By default RL_EndDrawing() does this job: draws everything + RL_SwapScreenBuffer() + manage frame timing + RL_PollInputEvents() +// To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL +RLAPI void RL_SwapScreenBuffer(void); // Swap back buffer with front buffer (screen drawing) +RLAPI void RL_PollInputEvents(void); // Register all input events +RLAPI void RL_WaitTime(double seconds); // Wait for some time (halt program execution) - // Misc. functions - RLAPI int get_random_value( s32 min, s32 max ); // Get a random value between min and max (both included) - RLAPI void set_random_seed( u32 seed ); // Set the seed for the random number generator - RLAPI void take_screenshot( char const* fileName ); // Takes a screenshot of current screen (filename extension defines format) - RLAPI void set_config_flags( u32 flags ); // Setup init configuration flags (view FLAGS) - RLAPI void open_url( char const* url ); // Open URL with default system browser (if available) +// Random values generation functions +RLAPI void RL_SetRandomSeed(unsigned int seed); // Set the seed for the random number generator +RLAPI int RL_GetRandomValue(int min, int max); // Get a random value between min and max (both included) +RLAPI int *LoadRandomSequence(unsigned int count, int min, int max); // Load random values sequence, no values repeated +RLAPI void UnloadRandomSequence(int *sequence); // Unload random values sequence - // NOTE: Following functions implemented in module [utils] - //------------------------------------------------------------------ - RLAPI void trace_log( s32 logLevel, char const* text, ... ); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...) - RLAPI void set_trace_log_level( s32 logLevel ); // Set the current threshold (minimum) log level - RLAPI void* mem_alloc( u32 size ); // Internal memory allocator - RLAPI void* mem_realloc( void* ptr, u32 size ); // Internal memory reallocator - RLAPI void mem_free( void* ptr ); // Internal memory free +// Misc. functions +RLAPI void RL_TakeScreenshot(const char *fileName); // Takes a screenshot of current screen (filename extension defines format) +RLAPI void RL_SetConfigFlags(unsigned int flags); // Setup init configuration flags (view FLAGS) +RLAPI void RL_OpenURL(const char *url); // Open URL with default system browser (if available) - // Set custom callbacks - // WARNING: Callbacks setup is intended for advance users - RLAPI void set_trace_log_callback( TraceLogCallback callback ); // Set custom trace log - RLAPI void set_load_file_data_callback( LoadFileDataCallback callback ); // Set custom file binary data loader - RLAPI void set_save_file_data_callback( SaveFileDataCallback callback ); // Set custom file binary data saver - RLAPI void set_load_file_text_callback( LoadFileTextCallback callback ); // Set custom file text data loader - RLAPI void set_save_file_text_callback( SaveFileTextCallback callback ); // Set custom file text data saver +// NOTE: Following functions implemented in module [utils] +//------------------------------------------------------------------ +RLAPI void RL_TraceLog(int logLevel, const char *text, ...); // Show trace log messages (RL_LOG_DEBUG, RL_LOG_INFO, RL_LOG_WARNING, RL_LOG_ERROR...) +RLAPI void RL_SetTraceLogLevel(int logLevel); // Set the current threshold (minimum) log level +RLAPI void *RL_MemAlloc(unsigned int size); // Internal memory allocator +RLAPI void *RL_MemRealloc(void *ptr, unsigned int size); // Internal memory reallocator +RLAPI void RL_MemFree(void *ptr); // Internal memory free - // Files management functions - RLAPI unsigned char* load_file_data( char const* fileName, s32* dataSize ); // Load file data as byte array (read) - RLAPI void unload_file_data( u8* data ); // Unload file data allocated by LoadFileData() - RLAPI bool save_file_data( char const* fileName, void* data, s32 dataSize ); // Save data to file from byte array (write), returns true on success - RLAPI bool export_data_as_code( unsigned char const* data, s32 dataSize, char const* fileName ); // Export data to code (.h), returns true on success - RLAPI char* load_file_text( char const* fileName ); // Load text data from file (read), returns a '\0' terminated string - RLAPI void unload_file_text( char* text ); // Unload file text data allocated by LoadFileText() - RLAPI bool - save_file_text( char const* fileName, char* text ); // Save text data to file (write), string must be '\0' terminated, returns true on success - //------------------------------------------------------------------ +// Set custom callbacks +// WARNING: Callbacks setup is intended for advance users +RLAPI void RL_SetTraceLogCallback(RL_TraceLogCallback callback); // Set custom trace log +RLAPI void RL_SetLoadFileDataCallback(RL_LoadFileDataCallback callback); // Set custom file binary data loader +RLAPI void RL_SetSaveFileDataCallback(RL_SaveFileDataCallback callback); // Set custom file binary data saver +RLAPI void RL_SetLoadFileTextCallback(RL_LoadFileTextCallback callback); // Set custom file text data loader +RLAPI void RL_SetSaveFileTextCallback(RL_SaveFileTextCallback callback); // Set custom file text data saver - // File system functions - RLAPI bool file_exists( char const* fileName ); // Check if file exists - RLAPI bool directory_exists( char const* dirPath ); // Check if a directory path exists - RLAPI bool is_file_extension( char const* fileName, char const* ext ); // Check file extension (including point: .png, .wav) - RLAPI int get_file_length( char const* fileName ); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h) - RLAPI char const* get_file_extension( char const* fileName ); // Get pointer to extension for a filename string (includes dot: '.png') - RLAPI char const* get_file_name( char const* filePath ); // Get pointer to filename for a path string - RLAPI char const* get_file_name_without_ext( char const* filePath ); // Get filename string without extension (uses static string) - RLAPI char const* get_directory_path( char const* filePath ); // Get full path for a given fileName with path (uses static string) - RLAPI char const* get_prev_directory_path( char const* dirPath ); // Get previous directory path for a given path (uses static string) - RLAPI char const* get_working_directory( void ); // Get current working directory (uses static string) - RLAPI char const* get_application_directory( void ); // Get the directory of the running application (uses static string) - RLAPI bool change_directory( char const* dir ); // Change working directory, return true on success - RLAPI bool is_path_file( char const* path ); // Check if a given path is a file or a directory - RLAPI FilePathList load_directory_files( char const* dirPath ); // Load directory filepaths - RLAPI FilePathList load_directory_files_ex( - char const* basePath, - char const* filter, - bool scanSubdirs - ); // Load directory filepaths with extension filtering and recursive directory scan - RLAPI void unload_directory_files( FilePathList files ); // Unload filepaths - RLAPI bool is_file_dropped( void ); // Check if a file has been dropped into window - RLAPI FilePathList load_dropped_files( void ); // Load dropped filepaths - RLAPI void unload_dropped_files( FilePathList files ); // Unload dropped filepaths - RLAPI long get_file_mod_time( char const* fileName ); // Get file modification time (last write time) +// Files management functions +RLAPI unsigned char *RL_LoadFileData(const char *fileName, int *dataSize); // Load file data as byte array (read) +RLAPI void RL_UnloadFileData(unsigned char *data); // Unload file data allocated by RL_LoadFileData() +RLAPI bool RL_SaveFileData(const char *fileName, void *data, int dataSize); // Save data to file from byte array (write), returns true on success +RLAPI bool RL_ExportDataAsCode(const unsigned char *data, int dataSize, const char *fileName); // Export data to code (.h), returns true on success +RLAPI char *RL_LoadFileText(const char *fileName); // Load text data from file (read), returns a '\0' terminated string +RLAPI void RL_UnloadFileText(char *text); // Unload file text data allocated by RL_LoadFileText() +RLAPI bool RL_SaveFileText(const char *fileName, char *text); // Save text data to file (write), string must be '\0' terminated, returns true on success +//------------------------------------------------------------------ - // Compression/Encoding functionality - RLAPI unsigned char* - compress_data( unsigned char const* data, s32 dataSize, s32* compDataSize ); // Compress data (DEFLATE algorithm), memory must be MemFree() - RLAPI unsigned char* decompress_data( - unsigned char const* compData, - s32 compDataSize, - s32* dataSize - ); // Decompress data (DEFLATE algorithm), memory must be MemFree() - RLAPI char* encode_data_base64( unsigned char const* data, s32 dataSize, s32* outputSize ); // Encode data to Base64 string, memory must be MemFree() - RLAPI unsigned char* decode_data_base64( unsigned char const* data, s32* outputSize ); // Decode Base64 string data, memory must be MemFree() +// File system functions +RLAPI bool RL_FileExists(const char *fileName); // Check if file exists +RLAPI bool RL_DirectoryExists(const char *dirPath); // Check if a directory path exists +RLAPI bool RL_IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav) +RLAPI int RL_GetFileLength(const char *fileName); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h) +RLAPI const char *RL_GetFileExtension(const char *fileName); // Get pointer to extension for a filename string (includes dot: '.png') +RLAPI const char *RL_GetFileName(const char *filePath); // Get pointer to filename for a path string +RLAPI const char *RL_GetFileNameWithoutExt(const char *filePath); // Get filename string without extension (uses static string) +RLAPI const char *RL_GetDirectoryPath(const char *filePath); // Get full path for a given fileName with path (uses static string) +RLAPI const char *RL_GetPrevDirectoryPath(const char *dirPath); // Get previous directory path for a given path (uses static string) +RLAPI const char *RL_GetWorkingDirectory(void); // Get current working directory (uses static string) +RLAPI const char *RL_GetApplicationDirectory(void); // Get the directory of the running application (uses static string) +RLAPI bool RL_ChangeDirectory(const char *dir); // Change working directory, return true on success +RLAPI bool RL_IsPathFile(const char *path); // Check if a given path is a file or a directory +RLAPI RL_FilePathList RL_LoadDirectoryFiles(const char *dirPath); // Load directory filepaths +RLAPI RL_FilePathList RL_LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and recursive directory scan +RLAPI void RL_UnloadDirectoryFiles(RL_FilePathList files); // Unload filepaths +RLAPI bool RL_IsFileDropped(void); // Check if a file has been dropped into window +RLAPI RL_FilePathList RL_LoadDroppedFiles(void); // Load dropped filepaths +RLAPI void RL_UnloadDroppedFiles(RL_FilePathList files); // Unload dropped filepaths +RLAPI long RL_GetFileModTime(const char *fileName); // Get file modification time (last write time) - //------------------------------------------------------------------------------------ - // Input Handling Functions (Module: core) - //------------------------------------------------------------------------------------ +// Compression/Encoding functionality +RLAPI unsigned char *RL_CompressData(const unsigned char *data, int dataSize, int *compDataSize); // Compress data (DEFLATE algorithm), memory must be RL_MemFree() +RLAPI unsigned char *RL_DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // Decompress data (DEFLATE algorithm), memory must be RL_MemFree() +RLAPI char *RL_EncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize); // Encode data to Base64 string, memory must be RL_MemFree() +RLAPI unsigned char *RL_DecodeDataBase64(const unsigned char *data, int *outputSize); // Decode Base64 string data, memory must be RL_MemFree() - // Input-related functions: keyboard - RLAPI bool is_key_pressed( s32 key ); // Check if a key has been pressed once - RLAPI bool is_key_pressed_repeat( s32 key ); // Check if a key has been pressed again (Only PLATFORM_DESKTOP) - RLAPI bool is_key_down( s32 key ); // Check if a key is being pressed - RLAPI bool is_key_released( s32 key ); // Check if a key has been released once - RLAPI bool is_key_up( s32 key ); // Check if a key is NOT being pressed - RLAPI int get_key_pressed( void ); // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty - RLAPI int get_char_pressed( void ); // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty - RLAPI void set_exit_key( s32 key ); // Set a custom key to exit program (default is ESC) +// Automation events functionality +RLAPI RL_AutomationEventList RL_LoadAutomationEventList(const char *fileName); // Load automation events list from file, NULL for empty list, capacity = RL_MAX_AUTOMATION_EVENTS +RLAPI void RL_UnloadAutomationEventList(RL_AutomationEventList *list); // Unload automation events list from file +RLAPI bool RL_ExportAutomationEventList(RL_AutomationEventList list, const char *fileName); // Export automation events list as text file +RLAPI void RL_SetAutomationEventList(RL_AutomationEventList *list); // Set automation event list to record to +RLAPI void RL_SetAutomationEventBaseFrame(int frame); // Set automation event internal base frame to start recording +RLAPI void RL_StartAutomationEventRecording(void); // Start recording automation events (RL_AutomationEventList must be set) +RLAPI void RL_StopAutomationEventRecording(void); // Stop recording automation events +RLAPI void RL_PlayAutomationEvent(RL_AutomationEvent event); // Play a recorded automation event - // Input-related functions: gamepads - RLAPI bool is_gamepad_available( s32 gamepad ); // Check if a gamepad is available - RLAPI char const* get_gamepad_name( s32 gamepad ); // Get gamepad internal name id - RLAPI bool is_gamepad_button_pressed( s32 gamepad, s32 button ); // Check if a gamepad button has been pressed once - RLAPI bool is_gamepad_button_down( s32 gamepad, s32 button ); // Check if a gamepad button is being pressed - RLAPI bool is_gamepad_button_released( s32 gamepad, s32 button ); // Check if a gamepad button has been released once - RLAPI bool is_gamepad_button_up( s32 gamepad, s32 button ); // Check if a gamepad button is NOT being pressed - RLAPI int get_gamepad_button_pressed( void ); // Get the last gamepad button pressed - RLAPI int get_gamepad_axis_count( s32 gamepad ); // Get gamepad axis count for a gamepad - RLAPI float get_gamepad_axis_movement( s32 gamepad, s32 axis ); // Get axis movement value for a gamepad axis - RLAPI int set_gamepad_mappings( char const* mappings ); // Set internal gamepad mappings (SDL_GameControllerDB) +//------------------------------------------------------------------------------------ +// Input Handling Functions (Module: core) +//------------------------------------------------------------------------------------ - // Input-related functions: mouse - RLAPI bool is_mouse_button_pressed( s32 button ); // Check if a mouse button has been pressed once - RLAPI bool is_mouse_button_down( s32 button ); // Check if a mouse button is being pressed - RLAPI bool is_mouse_button_released( s32 button ); // Check if a mouse button has been released once - RLAPI bool is_mouse_button_up( s32 button ); // Check if a mouse button is NOT being pressed - RLAPI int get_mouse_x( void ); // Get mouse position X - RLAPI int get_mouse_y( void ); // Get mouse position Y - RLAPI Vector2 get_mouse_position( void ); // Get mouse position XY - RLAPI Vector2 get_mouse_delta( void ); // Get mouse delta between frames - RLAPI void set_mouse_position( s32 x, s32 y ); // Set mouse position XY - RLAPI void set_mouse_offset( s32 offsetX, s32 offsetY ); // Set mouse offset - RLAPI void set_mouse_scale( f32 scaleX, f32 scaleY ); // Set mouse scaling - RLAPI float get_mouse_wheel_move( void ); // Get mouse wheel movement for X or Y, whichever is larger - RLAPI Vector2 get_mouse_wheel_move_v( void ); // Get mouse wheel movement for both X and Y - RLAPI void set_mouse_cursor( s32 cursor ); // Set mouse cursor +// Input-related functions: keyboard +RLAPI bool RL_IsKeyPressed(int key); // Check if a key has been pressed once +RLAPI bool RL_IsKeyPressedRepeat(int key); // Check if a key has been pressed again (Only PLATFORM_DESKTOP) +RLAPI bool RL_IsKeyDown(int key); // Check if a key is being pressed +RLAPI bool RL_IsKeyReleased(int key); // Check if a key has been released once +RLAPI bool RL_IsKeyUp(int key); // Check if a key is NOT being pressed +RLAPI int RL_GetKeyPressed(void); // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty +RLAPI int RL_GetCharPressed(void); // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty +RLAPI void RL_SetExitKey(int key); // Set a custom key to exit program (default is ESC) - // Input-related functions: touch - RLAPI int get_touch_x( void ); // Get touch position X for touch point 0 (relative to screen size) - RLAPI int get_touch_y( void ); // Get touch position Y for touch point 0 (relative to screen size) - RLAPI Vector2 get_touch_position( s32 index ); // Get touch position XY for a touch point index (relative to screen size) - RLAPI int get_touch_point_id( s32 index ); // Get touch point identifier for given index - RLAPI int get_touch_point_count( void ); // Get number of touch points +// Input-related functions: gamepads +RLAPI bool RL_IsGamepadAvailable(int gamepad); // Check if a gamepad is available +RLAPI const char *RL_GetGamepadName(int gamepad); // Get gamepad internal name id +RLAPI bool RL_IsGamepadButtonPressed(int gamepad, int button); // Check if a gamepad button has been pressed once +RLAPI bool RL_IsGamepadButtonDown(int gamepad, int button); // Check if a gamepad button is being pressed +RLAPI bool RL_IsGamepadButtonReleased(int gamepad, int button); // Check if a gamepad button has been released once +RLAPI bool RL_IsGamepadButtonUp(int gamepad, int button); // Check if a gamepad button is NOT being pressed +RLAPI int RL_GetGamepadButtonPressed(void); // Get the last gamepad button pressed +RLAPI int RL_GetGamepadAxisCount(int gamepad); // Get gamepad axis count for a gamepad +RLAPI float RL_GetGamepadAxisMovement(int gamepad, int axis); // Get axis movement value for a gamepad axis +RLAPI int RL_SetGamepadMappings(const char *mappings); // Set internal gamepad mappings (SDL_GameControllerDB) - //------------------------------------------------------------------------------------ - // Gestures and Touch Handling Functions (Module: rgestures) - //------------------------------------------------------------------------------------ - RLAPI void set_gestures_enabled( u32 flags ); // Enable a set of gestures using flags - RLAPI bool is_gesture_detected( u32 gesture ); // Check if a gesture have been detected - RLAPI int get_gesture_detected( void ); // Get latest detected gesture - RLAPI float get_gesture_hold_duration( void ); // Get gesture hold time in milliseconds - RLAPI Vector2 get_gesture_drag_vector( void ); // Get gesture drag vector - RLAPI float get_gesture_drag_angle( void ); // Get gesture drag angle - RLAPI Vector2 get_gesture_pinch_vector( void ); // Get gesture pinch delta - RLAPI float get_gesture_pinch_angle( void ); // Get gesture pinch angle +// Input-related functions: mouse +RLAPI bool RL_IsMouseButtonPressed(int button); // Check if a mouse button has been pressed once +RLAPI bool RL_IsMouseButtonDown(int button); // Check if a mouse button is being pressed +RLAPI bool RL_IsMouseButtonReleased(int button); // Check if a mouse button has been released once +RLAPI bool RL_IsMouseButtonUp(int button); // Check if a mouse button is NOT being pressed +RLAPI int RL_GetMouseX(void); // Get mouse position X +RLAPI int RL_GetMouseY(void); // Get mouse position Y +RLAPI RL_Vector2 RL_GetMousePosition(void); // Get mouse position XY +RLAPI RL_Vector2 RL_GetMouseDelta(void); // Get mouse delta between frames +RLAPI void RL_SetMousePosition(int x, int y); // Set mouse position XY +RLAPI void RL_SetMouseOffset(int offsetX, int offsetY); // Set mouse offset +RLAPI void RL_SetMouseScale(float scaleX, float scaleY); // Set mouse scaling +RLAPI float RL_GetMouseWheelMove(void); // Get mouse wheel movement for X or Y, whichever is larger +RLAPI RL_Vector2 RL_GetMouseWheelMoveV(void); // Get mouse wheel movement for both X and Y +RLAPI void RL_SetMouseCursor(int cursor); // Set mouse cursor - //------------------------------------------------------------------------------------ - // Camera System Functions (Module: rcamera) - //------------------------------------------------------------------------------------ - RLAPI void update_camera( Camera* camera, s32 mode ); // Update camera position for selected mode - RLAPI void update_camera_pro( Camera* camera, Vector3 movement, Vector3 rotation, f32 zoom ); // Update camera movement/rotation +// Input-related functions: touch +RLAPI int RL_GetTouchX(void); // Get touch position X for touch point 0 (relative to screen size) +RLAPI int RL_GetTouchY(void); // Get touch position Y for touch point 0 (relative to screen size) +RLAPI RL_Vector2 RL_GetTouchPosition(int index); // Get touch position XY for a touch point index (relative to screen size) +RLAPI int RL_GetTouchPointId(int index); // Get touch point identifier for given index +RLAPI int RL_GetTouchPointCount(void); // Get number of touch points - //------------------------------------------------------------------------------------ - // Basic Shapes Drawing Functions (Module: shapes) - //------------------------------------------------------------------------------------ - // Set texture and rectangle to be used on shapes drawing - // NOTE: It can be useful when using basic shapes and one single font, - // defining a font char white rectangle would allow drawing everything in a single draw call - RLAPI void set_shapes_texture( Texture2D texture, Rectangle source ); // Set texture and rectangle to be used on shapes drawing +//------------------------------------------------------------------------------------ +// Gestures and Touch Handling Functions (Module: rgestures) +//------------------------------------------------------------------------------------ +RLAPI void RL_SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags +RLAPI bool RL_IsGestureDetected(unsigned int gesture); // Check if a gesture have been detected +RLAPI int RL_GetGestureDetected(void); // Get latest detected gesture +RLAPI float RL_GetGestureHoldDuration(void); // Get gesture hold time in milliseconds +RLAPI RL_Vector2 RL_GetGestureDragVector(void); // Get gesture drag vector +RLAPI float RL_GetGestureDragAngle(void); // Get gesture drag angle +RLAPI RL_Vector2 RL_GetGesturePinchVector(void); // Get gesture pinch delta +RLAPI float RL_GetGesturePinchAngle(void); // Get gesture pinch angle - // Basic shapes drawing functions - RLAPI void draw_pixel( s32 posX, s32 posY, Color color ); // Draw a pixel - RLAPI void draw_pixel_v( Vector2 position, Color color ); // Draw a pixel (Vector version) - RLAPI void draw_line( s32 startPosX, s32 startPosY, s32 endPosX, s32 endPosY, Color color ); // Draw a line - RLAPI void draw_line_v( Vector2 startPos, Vector2 endPos, Color color ); // Draw a line (Vector version) - RLAPI void draw_line_ex( Vector2 startPos, Vector2 endPos, f32 thick, Color color ); // Draw a line defining thickness - RLAPI void draw_line_bezier( Vector2 startPos, Vector2 endPos, f32 thick, Color color ); // Draw a line using cubic-bezier curves in-out - RLAPI void draw_line_bezier_quad( Vector2 startPos, Vector2 endPos, Vector2 controlPos, f32 thick, Color color ); // Draw line using quadratic bezier - // curves with a control point - RLAPI void draw_line_bezier_cubic( - Vector2 startPos, - Vector2 endPos, - Vector2 startControlPos, - Vector2 endControlPos, - f32 thick, - Color color - ); // Draw line using cubic bezier curves with 2 control points - RLAPI void draw_line_bspline( Vector2* points, s32 pointCount, f32 thick, Color color ); // Draw a B-Spline line, minimum 4 points - RLAPI void draw_line_catmull_rom( Vector2* points, s32 pointCount, f32 thick, Color color ); // Draw a Catmull Rom spline line, minimum 4 points - RLAPI void draw_line_strip( Vector2* points, s32 pointCount, Color color ); // Draw lines sequence - RLAPI void draw_circle( s32 centerX, s32 centerY, f32 radius, Color color ); // Draw a color-filled circle - RLAPI void draw_circle_sector( Vector2 center, f32 radius, f32 startAngle, f32 endAngle, s32 segments, Color color ); // Draw a piece of a circle - RLAPI void - draw_circle_sector_lines( Vector2 center, f32 radius, f32 startAngle, f32 endAngle, s32 segments, Color color ); // Draw circle sector outline - RLAPI void draw_circle_gradient( s32 centerX, s32 centerY, f32 radius, Color color1, Color color2 ); // Draw a gradient-filled circle - RLAPI void draw_circle_v( Vector2 center, f32 radius, Color color ); // Draw a color-filled circle (Vector version) - RLAPI void draw_circle_lines( s32 centerX, s32 centerY, f32 radius, Color color ); // Draw circle outline - RLAPI void draw_circle_lines_v( Vector2 center, f32 radius, Color color ); // Draw circle outline (Vector version) - RLAPI void draw_ellipse( s32 centerX, s32 centerY, f32 radiusH, f32 radiusV, Color color ); // Draw ellipse - RLAPI void draw_ellipse_lines( s32 centerX, s32 centerY, f32 radiusH, f32 radiusV, Color color ); // Draw ellipse outline - RLAPI void draw_ring( Vector2 center, f32 innerRadius, f32 outerRadius, f32 startAngle, f32 endAngle, s32 segments, Color color ); // Draw ring - RLAPI void draw_ring_lines( Vector2 center, f32 innerRadius, f32 outerRadius, f32 startAngle, f32 endAngle, s32 segments, Color color ); // Draw ring - // outline - RLAPI void draw_rectangle( s32 posX, s32 posY, s32 width, s32 height, Color color ); // Draw a color-filled rectangle - RLAPI void draw_rectangle_v( Vector2 position, Vector2 size, Color color ); // Draw a color-filled rectangle (Vector version) - RLAPI void draw_rectangle_rec( Rectangle rec, Color color ); // Draw a color-filled rectangle - RLAPI void draw_rectangle_pro( Rectangle rec, Vector2 origin, f32 rotation, Color color ); // Draw a color-filled rectangle with pro parameters - RLAPI void - draw_rectangle_gradient_v( s32 posX, s32 posY, s32 width, s32 height, Color color1, Color color2 ); // Draw a vertical-gradient-filled rectangle - RLAPI void draw_rectangle_gradient_h( s32 posX, s32 posY, s32 width, s32 height, Color color1, Color color2 ); // Draw a horizontal-gradient-filled - // rectangle - RLAPI void draw_rectangle_gradient_ex( Rectangle rec, Color col1, Color col2, Color col3, Color col4 ); // Draw a gradient-filled rectangle with - // custom vertex colors - RLAPI void draw_rectangle_lines( s32 posX, s32 posY, s32 width, s32 height, Color color ); // Draw rectangle outline - RLAPI void draw_rectangle_lines_ex( Rectangle rec, f32 lineThick, Color color ); // Draw rectangle outline with extended parameters - RLAPI void draw_rectangle_rounded( Rectangle rec, f32 roundness, s32 segments, Color color ); // Draw rectangle with rounded edges - RLAPI void draw_rectangle_rounded_lines( Rectangle rec, f32 roundness, s32 segments, f32 lineThick, Color color ); // Draw rectangle with rounded - // edges outline - RLAPI void draw_triangle( Vector2 v1, Vector2 v2, Vector2 v3, Color color ); // Draw a color-filled triangle (vertex in counter-clockwise order!) - RLAPI void draw_triangle_lines( Vector2 v1, Vector2 v2, Vector2 v3, Color color ); // Draw triangle outline (vertex in counter-clockwise order!) - RLAPI void draw_triangle_fan( Vector2* points, s32 pointCount, Color color ); // Draw a triangle fan defined by points (first vertex is the center) - RLAPI void draw_triangle_strip( Vector2* points, s32 pointCount, Color color ); // Draw a triangle strip defined by points - RLAPI void draw_poly( Vector2 center, s32 sides, f32 radius, f32 rotation, Color color ); // Draw a regular polygon (Vector version) - RLAPI void draw_poly_lines( Vector2 center, s32 sides, f32 radius, f32 rotation, Color color ); // Draw a polygon outline of n sides - RLAPI void draw_poly_lines_ex( Vector2 center, s32 sides, f32 radius, f32 rotation, f32 lineThick, Color color ); // Draw a polygon outline of n - // sides with extended parameters +//------------------------------------------------------------------------------------ +// RL_Camera System Functions (Module: rcamera) +//------------------------------------------------------------------------------------ +RLAPI void RL_UpdateCamera(RL_Camera *camera, int mode); // Update camera position for selected mode +RLAPI void RL_UpdateCameraPro(RL_Camera *camera, RL_Vector3 movement, RL_Vector3 rotation, float zoom); // Update camera movement/rotation - // Basic shapes collision detection functions - RLAPI bool check_collision_recs( Rectangle rec1, Rectangle rec2 ); // Check collision between two rectangles - RLAPI bool check_collision_circles( Vector2 center1, f32 radius1, Vector2 center2, f32 radius2 ); // Check collision between two circles - RLAPI bool check_collision_circle_rec( Vector2 center, f32 radius, Rectangle rec ); // Check collision between circle and rectangle - RLAPI bool check_collision_point_rec( Vector2 point, Rectangle rec ); // Check if point is inside rectangle - RLAPI bool check_collision_point_circle( Vector2 point, Vector2 center, f32 radius ); // Check if point is inside circle - RLAPI bool check_collision_point_triangle( Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3 ); // Check if point is inside a triangle - RLAPI bool check_collision_point_poly( - Vector2 point, - Vector2* points, - s32 pointCount - ); // Check if point is within a polygon described by array of vertices - RLAPI bool check_collision_lines( - Vector2 startPos1, - Vector2 endPos1, - Vector2 startPos2, - Vector2 endPos2, - Vector2* collisionPoint - ); // Check the collision between two lines defined by two points each, returns collision point by reference - RLAPI bool check_collision_point_line( - Vector2 point, - Vector2 p1, - Vector2 p2, - s32 threshold - ); // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold] - RLAPI Rectangle get_collision_rec( Rectangle rec1, Rectangle rec2 ); // Get collision rectangle for two rectangles collision +//------------------------------------------------------------------------------------ +// Basic Shapes Drawing Functions (Module: shapes) +//------------------------------------------------------------------------------------ +// Set texture and rectangle to be used on shapes drawing +// NOTE: It can be useful when using basic shapes and one single font, +// defining a font char white rectangle would allow drawing everything in a single draw call +RLAPI void RL_SetShapesTexture(RL_Texture2D texture, RL_Rectangle source); // Set texture and rectangle to be used on shapes drawing - //------------------------------------------------------------------------------------ - // Texture Loading and Drawing Functions (Module: textures) - //------------------------------------------------------------------------------------ +// Basic shapes drawing functions +RLAPI void RL_DrawPixel(int posX, int posY, RL_Color color); // Draw a pixel +RLAPI void RL_DrawPixelV(RL_Vector2 position, RL_Color color); // Draw a pixel (Vector version) +RLAPI void RL_DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, RL_Color color); // Draw a line +RLAPI void RL_DrawLineV(RL_Vector2 startPos, RL_Vector2 endPos, RL_Color color); // Draw a line (using gl lines) +RLAPI void RL_DrawLineEx(RL_Vector2 startPos, RL_Vector2 endPos, float thick, RL_Color color); // Draw a line (using triangles/quads) +RLAPI void RL_DrawLineStrip(RL_Vector2 *points, int pointCount, RL_Color color); // Draw lines sequence (using gl lines) +RLAPI void RL_DrawLineBezier(RL_Vector2 startPos, RL_Vector2 endPos, float thick, RL_Color color); // Draw line segment cubic-bezier in-out interpolation +RLAPI void RL_DrawCircle(int centerX, int centerY, float radius, RL_Color color); // Draw a color-filled circle +RLAPI void RL_DrawCircleSector(RL_Vector2 center, float radius, float startAngle, float endAngle, int segments, RL_Color color); // Draw a piece of a circle +RLAPI void RL_DrawCircleSectorLines(RL_Vector2 center, float radius, float startAngle, float endAngle, int segments, RL_Color color); // Draw circle sector outline +RLAPI void RL_DrawCircleGradient(int centerX, int centerY, float radius, RL_Color color1, RL_Color color2); // Draw a gradient-filled circle +RLAPI void RL_DrawCircleV(RL_Vector2 center, float radius, RL_Color color); // Draw a color-filled circle (Vector version) +RLAPI void RL_DrawCircleLines(int centerX, int centerY, float radius, RL_Color color); // Draw circle outline +RLAPI void RL_DrawCircleLinesV(RL_Vector2 center, float radius, RL_Color color); // Draw circle outline (Vector version) +RLAPI void RL_DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, RL_Color color); // Draw ellipse +RLAPI void RL_DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, RL_Color color); // Draw ellipse outline +RLAPI void RL_DrawRing(RL_Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, RL_Color color); // Draw ring +RLAPI void RL_DrawRingLines(RL_Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, RL_Color color); // Draw ring outline +RLAPI void RL_DrawRectangle(int posX, int posY, int width, int height, RL_Color color); // Draw a color-filled rectangle +RLAPI void RL_DrawRectangleV(RL_Vector2 position, RL_Vector2 size, RL_Color color); // Draw a color-filled rectangle (Vector version) +RLAPI void RL_DrawRectangleRec(RL_Rectangle rec, RL_Color color); // Draw a color-filled rectangle +RLAPI void RL_DrawRectanglePro(RL_Rectangle rec, RL_Vector2 origin, float rotation, RL_Color color); // Draw a color-filled rectangle with pro parameters +RLAPI void RL_DrawRectangleGradientV(int posX, int posY, int width, int height, RL_Color color1, RL_Color color2);// Draw a vertical-gradient-filled rectangle +RLAPI void RL_DrawRectangleGradientH(int posX, int posY, int width, int height, RL_Color color1, RL_Color color2);// Draw a horizontal-gradient-filled rectangle +RLAPI void RL_DrawRectangleGradientEx(RL_Rectangle rec, RL_Color col1, RL_Color col2, RL_Color col3, RL_Color col4); // Draw a gradient-filled rectangle with custom vertex colors +RLAPI void RL_DrawRectangleLines(int posX, int posY, int width, int height, RL_Color color); // Draw rectangle outline +RLAPI void RL_DrawRectangleLinesEx(RL_Rectangle rec, float lineThick, RL_Color color); // Draw rectangle outline with extended parameters +RLAPI void RL_DrawRectangleRounded(RL_Rectangle rec, float roundness, int segments, RL_Color color); // Draw rectangle with rounded edges +RLAPI void RL_DrawRectangleRoundedLines(RL_Rectangle rec, float roundness, int segments, float lineThick, RL_Color color); // Draw rectangle with rounded edges outline +RLAPI void RL_DrawTriangle(RL_Vector2 v1, RL_Vector2 v2, RL_Vector2 v3, RL_Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +RLAPI void RL_DrawTriangleLines(RL_Vector2 v1, RL_Vector2 v2, RL_Vector2 v3, RL_Color color); // Draw triangle outline (vertex in counter-clockwise order!) +RLAPI void RL_DrawTriangleFan(RL_Vector2 *points, int pointCount, RL_Color color); // Draw a triangle fan defined by points (first vertex is the center) +RLAPI void RL_DrawTriangleStrip(RL_Vector2 *points, int pointCount, RL_Color color); // Draw a triangle strip defined by points +RLAPI void RL_DrawPoly(RL_Vector2 center, int sides, float radius, float rotation, RL_Color color); // Draw a regular polygon (Vector version) +RLAPI void RL_DrawPolyLines(RL_Vector2 center, int sides, float radius, float rotation, RL_Color color); // Draw a polygon outline of n sides +RLAPI void RL_DrawPolyLinesEx(RL_Vector2 center, int sides, float radius, float rotation, float lineThick, RL_Color color); // Draw a polygon outline of n sides with extended parameters - // Image loading functions - // NOTE: These functions do not require GPU access - RLAPI Image load_image( char const* fileName ); // Load image from file into CPU memory (RAM) - RLAPI Image load_image_raw( char const* fileName, s32 width, s32 height, s32 format, s32 headerSize ); // Load image from RAW file data - RLAPI Image load_image_svg( char const* fileNameOrString, s32 width, s32 height ); // Load image from SVG file data or string with specified size - RLAPI Image load_image_anim( char const* fileName, s32* frames ); // Load image sequence from file (frames appended to image.data) - RLAPI Image load_image_from_memory( - char const* fileType, - unsigned char const* fileData, - s32 dataSize - ); // Load image from memory buffer, fileType refers to extension: i.e. '.png' - RLAPI Image load_image_from_texture( Texture2D texture ); // Load image from GPU texture data - RLAPI Image load_image_from_screen( void ); // Load image from screen buffer and (screenshot) - RLAPI bool is_image_ready( Image image ); // Check if an image is ready - RLAPI void unload_image( Image image ); // Unload image from CPU memory (RAM) - RLAPI bool export_image( Image image, char const* fileName ); // Export image data to file, returns true on success - RLAPI unsigned char* export_image_to_memory( Image image, char const* fileType, s32* fileSize ); // Export image to memory buffer - RLAPI bool - export_image_as_code( Image image, char const* fileName ); // Export image as code file defining an array of bytes, returns true on success +// Splines drawing functions +RLAPI void DrawSplineLinear(RL_Vector2 *points, int pointCount, float thick, RL_Color color); // Draw spline: Linear, minimum 2 points +RLAPI void DrawSplineBasis(RL_Vector2 *points, int pointCount, float thick, RL_Color color); // Draw spline: B-Spline, minimum 4 points +RLAPI void DrawSplineCatmullRom(RL_Vector2 *points, int pointCount, float thick, RL_Color color); // Draw spline: Catmull-Rom, minimum 4 points +RLAPI void DrawSplineBezierQuadratic(RL_Vector2 *points, int pointCount, float thick, RL_Color color); // Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...] +RLAPI void DrawSplineBezierCubic(RL_Vector2 *points, int pointCount, float thick, RL_Color color); // Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...] +RLAPI void DrawSplineSegmentLinear(RL_Vector2 p1, RL_Vector2 p2, float thick, RL_Color color); // Draw spline segment: Linear, 2 points +RLAPI void DrawSplineSegmentBasis(RL_Vector2 p1, RL_Vector2 p2, RL_Vector2 p3, RL_Vector2 p4, float thick, RL_Color color); // Draw spline segment: B-Spline, 4 points +RLAPI void DrawSplineSegmentCatmullRom(RL_Vector2 p1, RL_Vector2 p2, RL_Vector2 p3, RL_Vector2 p4, float thick, RL_Color color); // Draw spline segment: Catmull-Rom, 4 points +RLAPI void DrawSplineSegmentBezierQuadratic(RL_Vector2 p1, RL_Vector2 c2, RL_Vector2 p3, float thick, RL_Color color); // Draw spline segment: Quadratic Bezier, 2 points, 1 control point +RLAPI void DrawSplineSegmentBezierCubic(RL_Vector2 p1, RL_Vector2 c2, RL_Vector2 c3, RL_Vector2 p4, float thick, RL_Color color); // Draw spline segment: Cubic Bezier, 2 points, 2 control points - // Image generation functions - RLAPI Image gen_image_color( s32 width, s32 height, Color color ); // Generate image: plain color - RLAPI Image gen_image_gradient_linear( s32 width, s32 height, s32 direction, Color start, Color end ); // Generate image: linear gradient, direction - // in degrees [0..360], 0=Vertical gradient - RLAPI Image gen_image_gradient_radial( s32 width, s32 height, f32 density, Color inner, Color outer ); // Generate image: radial gradient - RLAPI Image gen_image_gradient_square( s32 width, s32 height, f32 density, Color inner, Color outer ); // Generate image: square gradient - RLAPI Image gen_image_checked( s32 width, s32 height, s32 checksX, s32 checksY, Color col1, Color col2 ); // Generate image: checked - RLAPI Image gen_image_white_noise( s32 width, s32 height, f32 factor ); // Generate image: white noise - RLAPI Image gen_image_perlin_noise( s32 width, s32 height, s32 offsetX, s32 offsetY, f32 scale ); // Generate image: perlin noise - RLAPI Image gen_image_cellular( s32 width, s32 height, s32 tileSize ); // Generate image: cellular algorithm, bigger tileSize means bigger cells - RLAPI Image gen_image_text( s32 width, s32 height, char const* text ); // Generate image: grayscale image from text data +// Spline segment point evaluation functions, for a given t [0.0f .. 1.0f] +RLAPI RL_Vector2 GetSplinePointLinear(RL_Vector2 startPos, RL_Vector2 endPos, float t); // Get (evaluate) spline point: Linear +RLAPI RL_Vector2 GetSplinePointBasis(RL_Vector2 p1, RL_Vector2 p2, RL_Vector2 p3, RL_Vector2 p4, float t); // Get (evaluate) spline point: B-Spline +RLAPI RL_Vector2 GetSplinePointCatmullRom(RL_Vector2 p1, RL_Vector2 p2, RL_Vector2 p3, RL_Vector2 p4, float t); // Get (evaluate) spline point: Catmull-Rom +RLAPI RL_Vector2 GetSplinePointBezierQuad(RL_Vector2 p1, RL_Vector2 c2, RL_Vector2 p3, float t); // Get (evaluate) spline point: Quadratic Bezier +RLAPI RL_Vector2 GetSplinePointBezierCubic(RL_Vector2 p1, RL_Vector2 c2, RL_Vector2 c3, RL_Vector2 p4, float t); // Get (evaluate) spline point: Cubic Bezier - // Image manipulation functions - RLAPI Image image_copy( Image image ); // Create an image duplicate (useful for transformations) - RLAPI Image image_from_image( Image image, Rectangle rec ); // Create an image from another image piece - RLAPI Image image_text( char const* text, s32 fontSize, Color color ); // Create an image from text (default font) - RLAPI Image image_text_ex( Font font, char const* text, f32 fontSize, f32 spacing, Color tint ); // Create an image from text (custom sprite font) - RLAPI void image_format( Image* image, s32 newFormat ); // Convert image data to desired format - RLAPI void image_to_pot( Image* image, Color fill ); // Convert image to POT (power-of-two) - RLAPI void image_crop( Image* image, Rectangle crop ); // Crop an image to a defined rectangle - RLAPI void image_alpha_crop( Image* image, f32 threshold ); // Crop image depending on alpha value - RLAPI void image_alpha_clear( Image* image, Color color, f32 threshold ); // Clear alpha channel to desired color - RLAPI void image_alpha_mask( Image* image, Image alphaMask ); // Apply alpha mask to image - RLAPI void image_alpha_premultiply( Image* image ); // Premultiply alpha channel - RLAPI void image_blur_gaussian( Image* image, s32 blurSize ); // Apply Gaussian blur using a box blur approximation - RLAPI void image_resize( Image* image, s32 newWidth, s32 newHeight ); // Resize image (Bicubic scaling algorithm) - RLAPI void image_resize_nn( Image* image, s32 newWidth, s32 newHeight ); // Resize image (Nearest-Neighbor scaling algorithm) - RLAPI void - image_resize_canvas( Image* image, s32 newWidth, s32 newHeight, s32 offsetX, s32 offsetY, Color fill ); // Resize canvas and fill with color - RLAPI void image_mipmaps( Image* image ); // Compute all mipmap levels for a provided image - RLAPI void image_dither( Image* image, s32 rBpp, s32 gBpp, s32 bBpp, s32 aBpp ); // Dither image data to 16bpp or lower (Floyd-Steinberg dithering) - RLAPI void image_flip_vertical( Image* image ); // Flip image vertically - RLAPI void image_flip_horizontal( Image* image ); // Flip image horizontally - RLAPI void image_rotate( Image* image, s32 degrees ); // Rotate image by input angle in degrees (-359 to 359) - RLAPI void image_rotate_cw( Image* image ); // Rotate image clockwise 90deg - RLAPI void image_rotate_ccw( Image* image ); // Rotate image counter-clockwise 90deg - RLAPI void image_color_tint( Image* image, Color color ); // Modify image color: tint - RLAPI void image_color_invert( Image* image ); // Modify image color: invert - RLAPI void image_color_grayscale( Image* image ); // Modify image color: grayscale - RLAPI void image_color_contrast( Image* image, f32 contrast ); // Modify image color: contrast (-100 to 100) - RLAPI void image_color_brightness( Image* image, s32 brightness ); // Modify image color: brightness (-255 to 255) - RLAPI void image_color_replace( Image* image, Color color, Color replace ); // Modify image color: replace color - RLAPI Color* load_image_colors( Image image ); // Load color data from image as a Color array (RGBA - 32bit) - RLAPI Color* - load_image_palette( Image image, s32 maxPaletteSize, s32* colorCount ); // Load colors palette from image as a Color array (RGBA - 32bit) - RLAPI void unload_image_colors( Color* colors ); // Unload color data loaded with LoadImageColors() - RLAPI void unload_image_palette( Color* colors ); // Unload colors palette loaded with LoadImagePalette() - RLAPI Rectangle get_image_alpha_border( Image image, f32 threshold ); // Get image alpha border rectangle - RLAPI Color get_image_color( Image image, s32 x, s32 y ); // Get image pixel color at (x, y) position +// Basic shapes collision detection functions +RLAPI bool RL_CheckCollisionRecs(RL_Rectangle rec1, RL_Rectangle rec2); // Check collision between two rectangles +RLAPI bool RL_CheckCollisionCircles(RL_Vector2 center1, float radius1, RL_Vector2 center2, float radius2); // Check collision between two circles +RLAPI bool RL_CheckCollisionCircleRec(RL_Vector2 center, float radius, RL_Rectangle rec); // Check collision between circle and rectangle +RLAPI bool RL_CheckCollisionPointRec(RL_Vector2 point, RL_Rectangle rec); // Check if point is inside rectangle +RLAPI bool RL_CheckCollisionPointCircle(RL_Vector2 point, RL_Vector2 center, float radius); // Check if point is inside circle +RLAPI bool RL_CheckCollisionPointTriangle(RL_Vector2 point, RL_Vector2 p1, RL_Vector2 p2, RL_Vector2 p3); // Check if point is inside a triangle +RLAPI bool RL_CheckCollisionPointPoly(RL_Vector2 point, RL_Vector2 *points, int pointCount); // Check if point is within a polygon described by array of vertices +RLAPI bool RL_CheckCollisionLines(RL_Vector2 startPos1, RL_Vector2 endPos1, RL_Vector2 startPos2, RL_Vector2 endPos2, RL_Vector2 *collisionPoint); // Check the collision between two lines defined by two points each, returns collision point by reference +RLAPI bool RL_CheckCollisionPointLine(RL_Vector2 point, RL_Vector2 p1, RL_Vector2 p2, int threshold); // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold] +RLAPI RL_Rectangle RL_GetCollisionRec(RL_Rectangle rec1, RL_Rectangle rec2); // Get collision rectangle for two rectangles collision - // Image drawing functions - // NOTE: Image software-rendering functions (CPU) - RLAPI void image_clear_background( Image* dst, Color color ); // Clear image background with given color - RLAPI void image_draw_pixel( Image* dst, s32 posX, s32 posY, Color color ); // Draw pixel within an image - RLAPI void image_draw_pixel_v( Image* dst, Vector2 position, Color color ); // Draw pixel within an image (Vector version) - RLAPI void image_draw_line( Image* dst, s32 startPosX, s32 startPosY, s32 endPosX, s32 endPosY, Color color ); // Draw line within an image - RLAPI void image_draw_line_v( Image* dst, Vector2 start, Vector2 end, Color color ); // Draw line within an image (Vector version) - RLAPI void image_draw_circle( Image* dst, s32 centerX, s32 centerY, s32 radius, Color color ); // Draw a filled circle within an image - RLAPI void image_draw_circle_v( Image* dst, Vector2 center, s32 radius, Color color ); // Draw a filled circle within an image (Vector version) - RLAPI void image_draw_circle_lines( Image* dst, s32 centerX, s32 centerY, s32 radius, Color color ); // Draw circle outline within an image - RLAPI void image_draw_circle_lines_v( Image* dst, Vector2 center, s32 radius, Color color ); // Draw circle outline within an image (Vector version) - RLAPI void image_draw_rectangle( Image* dst, s32 posX, s32 posY, s32 width, s32 height, Color color ); // Draw rectangle within an image - RLAPI void image_draw_rectangle_v( Image* dst, Vector2 position, Vector2 size, Color color ); // Draw rectangle within an image (Vector version) - RLAPI void image_draw_rectangle_rec( Image* dst, Rectangle rec, Color color ); // Draw rectangle within an image - RLAPI void image_draw_rectangle_lines( Image* dst, Rectangle rec, s32 thick, Color color ); // Draw rectangle lines within an image - RLAPI void image_draw( Image* dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint ); // Draw a source image within a destination image - // (tint applied to source) - RLAPI void image_draw_text( Image* dst, char const* text, s32 posX, s32 posY, s32 fontSize, Color color ); // Draw text (using default font) within - // an image (destination) - RLAPI void image_draw_text_ex( - Image* dst, - Font font, - char const* text, - Vector2 position, - f32 fontSize, - f32 spacing, - Color tint - ); // Draw text (custom sprite font) within an image (destination) +//------------------------------------------------------------------------------------ +// RL_Texture Loading and Drawing Functions (Module: textures) +//------------------------------------------------------------------------------------ - // Texture loading functions - // NOTE: These functions require GPU access - RLAPI Texture2D load_texture( char const* fileName ); // Load texture from file into GPU memory (VRAM) - RLAPI Texture2D load_texture_from_image( Image image ); // Load texture from image data - RLAPI TextureCubemap load_texture_cubemap( Image image, s32 layout ); // Load cubemap from image, multiple image cubemap layouts supported - RLAPI RenderTexture2D load_render_texture( s32 width, s32 height ); // Load texture for rendering (framebuffer) - RLAPI bool is_texture_ready( Texture2D texture ); // Check if a texture is ready - RLAPI void unload_texture( Texture2D texture ); // Unload texture from GPU memory (VRAM) - RLAPI bool is_render_texture_ready( RenderTexture2D target ); // Check if a render texture is ready - RLAPI void unload_render_texture( RenderTexture2D target ); // Unload render texture from GPU memory (VRAM) - RLAPI void update_texture( Texture2D texture, void const* pixels ); // Update GPU texture with new data - RLAPI void update_texture_rec( Texture2D texture, Rectangle rec, void const* pixels ); // Update GPU texture rectangle with new data +// RL_Image loading functions +// NOTE: These functions do not require GPU access +RLAPI RL_Image RL_LoadImage(const char *fileName); // Load image from file into CPU memory (RAM) +RLAPI RL_Image RL_LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize); // Load image from RAW file data +RLAPI RL_Image RL_LoadImageSvg(const char *fileNameOrString, int width, int height); // Load image from SVG file data or string with specified size +RLAPI RL_Image RL_LoadImageAnim(const char *fileName, int *frames); // Load image sequence from file (frames appended to image.data) +RLAPI RL_Image RL_LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load image from memory buffer, fileType refers to extension: i.e. '.png' +RLAPI RL_Image RL_LoadImageFromTexture(RL_Texture2D texture); // Load image from GPU texture data +RLAPI RL_Image RL_LoadImageFromScreen(void); // Load image from screen buffer and (screenshot) +RLAPI bool RL_IsImageReady(RL_Image image); // Check if an image is ready +RLAPI void RL_UnloadImage(RL_Image image); // Unload image from CPU memory (RAM) +RLAPI bool RL_ExportImage(RL_Image image, const char *fileName); // Export image data to file, returns true on success +RLAPI unsigned char *RL_ExportImageToMemory(RL_Image image, const char *fileType, int *fileSize); // Export image to memory buffer +RLAPI bool RL_ExportImageAsCode(RL_Image image, const char *fileName); // Export image as code file defining an array of bytes, returns true on success - // Texture configuration functions - RLAPI void gen_texture_mipmaps( Texture2D* texture ); // Generate GPU mipmaps for a texture - RLAPI void set_texture_filter( Texture2D texture, s32 filter ); // Set texture scaling filter mode - RLAPI void set_texture_wrap( Texture2D texture, s32 wrap ); // Set texture wrapping mode +// RL_Image generation functions +RLAPI RL_Image RL_GenImageColor(int width, int height, RL_Color color); // Generate image: plain color +RLAPI RL_Image RL_GenImageGradientLinear(int width, int height, int direction, RL_Color start, RL_Color end); // Generate image: linear gradient, direction in degrees [0..360], 0=Vertical gradient +RLAPI RL_Image RL_GenImageGradientRadial(int width, int height, float density, RL_Color inner, RL_Color outer); // Generate image: radial gradient +RLAPI RL_Image RL_GenImageGradientSquare(int width, int height, float density, RL_Color inner, RL_Color outer); // Generate image: square gradient +RLAPI RL_Image RL_GenImageChecked(int width, int height, int checksX, int checksY, RL_Color col1, RL_Color col2); // Generate image: checked +RLAPI RL_Image RL_GenImageWhiteNoise(int width, int height, float factor); // Generate image: white noise +RLAPI RL_Image RL_GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale); // Generate image: perlin noise +RLAPI RL_Image RL_GenImageCellular(int width, int height, int tileSize); // Generate image: cellular algorithm, bigger tileSize means bigger cells +RLAPI RL_Image RL_GenImageText(int width, int height, const char *text); // Generate image: grayscale image from text data - // Texture drawing functions - RLAPI void draw_texture( Texture2D texture, s32 posX, s32 posY, Color tint ); // Draw a Texture2D - RLAPI void draw_texture_v( Texture2D texture, Vector2 position, Color tint ); // Draw a Texture2D with position defined as Vector2 - RLAPI void draw_texture_ex( Texture2D texture, Vector2 position, f32 rotation, f32 scale, Color tint ); // Draw a Texture2D with extended parameters - RLAPI void draw_texture_rec( Texture2D texture, Rectangle source, Vector2 position, Color tint ); // Draw a part of a texture defined by a rectangle - RLAPI void draw_texture_pro( - Texture2D texture, - Rectangle source, - Rectangle dest, - Vector2 origin, - f32 rotation, - Color tint - ); // Draw a part of a texture defined by a rectangle with 'pro' parameters - RLAPI void draw_texture_npatch( - Texture2D texture, - NPatchInfo nPatchInfo, - Rectangle dest, - Vector2 origin, - f32 rotation, - Color tint - ); // Draws a texture (or part of it) that stretches or shrinks nicely +// RL_Image manipulation functions +RLAPI RL_Image RL_ImageCopy(RL_Image image); // Create an image duplicate (useful for transformations) +RLAPI RL_Image RL_ImageFromImage(RL_Image image, RL_Rectangle rec); // Create an image from another image piece +RLAPI RL_Image RL_ImageText(const char *text, int fontSize, RL_Color color); // Create an image from text (default font) +RLAPI RL_Image RL_ImageTextEx(RL_Font font, const char *text, float fontSize, float spacing, RL_Color tint); // Create an image from text (custom sprite font) +RLAPI void RL_ImageFormat(RL_Image *image, int newFormat); // Convert image data to desired format +RLAPI void RL_ImageToPOT(RL_Image *image, RL_Color fill); // Convert image to POT (power-of-two) +RLAPI void RL_ImageCrop(RL_Image *image, RL_Rectangle crop); // Crop an image to a defined rectangle +RLAPI void RL_ImageAlphaCrop(RL_Image *image, float threshold); // Crop image depending on alpha value +RLAPI void RL_ImageAlphaClear(RL_Image *image, RL_Color color, float threshold); // Clear alpha channel to desired color +RLAPI void RL_ImageAlphaMask(RL_Image *image, RL_Image alphaMask); // Apply alpha mask to image +RLAPI void RL_ImageAlphaPremultiply(RL_Image *image); // Premultiply alpha channel +RLAPI void RL_ImageBlurGaussian(RL_Image *image, int blurSize); // Apply Gaussian blur using a box blur approximation +RLAPI void RL_ImageResize(RL_Image *image, int newWidth, int newHeight); // Resize image (Bicubic scaling algorithm) +RLAPI void RL_ImageResizeNN(RL_Image *image, int newWidth,int newHeight); // Resize image (Nearest-Neighbor scaling algorithm) +RLAPI void RL_ImageResizeCanvas(RL_Image *image, int newWidth, int newHeight, int offsetX, int offsetY, RL_Color fill); // Resize canvas and fill with color +RLAPI void RL_ImageMipmaps(RL_Image *image); // Compute all mipmap levels for a provided image +RLAPI void RL_ImageDither(RL_Image *image, int rBpp, int gBpp, int bBpp, int aBpp); // Dither image data to 16bpp or lower (Floyd-Steinberg dithering) +RLAPI void RL_ImageFlipVertical(RL_Image *image); // Flip image vertically +RLAPI void RL_ImageFlipHorizontal(RL_Image *image); // Flip image horizontally +RLAPI void RL_ImageRotate(RL_Image *image, int degrees); // Rotate image by input angle in degrees (-359 to 359) +RLAPI void RL_ImageRotateCW(RL_Image *image); // Rotate image clockwise 90deg +RLAPI void RL_ImageRotateCCW(RL_Image *image); // Rotate image counter-clockwise 90deg +RLAPI void RL_ImageColorTint(RL_Image *image, RL_Color color); // Modify image color: tint +RLAPI void RL_ImageColorInvert(RL_Image *image); // Modify image color: invert +RLAPI void RL_ImageColorGrayscale(RL_Image *image); // Modify image color: grayscale +RLAPI void RL_ImageColorContrast(RL_Image *image, float contrast); // Modify image color: contrast (-100 to 100) +RLAPI void RL_ImageColorBrightness(RL_Image *image, int brightness); // Modify image color: brightness (-255 to 255) +RLAPI void RL_ImageColorReplace(RL_Image *image, RL_Color color, RL_Color replace); // Modify image color: replace color +RLAPI RL_Color *RL_LoadImageColors(RL_Image image); // Load color data from image as a RL_Color array (RGBA - 32bit) +RLAPI RL_Color *RL_LoadImagePalette(RL_Image image, int maxPaletteSize, int *colorCount); // Load colors palette from image as a RL_Color array (RGBA - 32bit) +RLAPI void RL_UnloadImageColors(RL_Color *colors); // Unload color data loaded with RL_LoadImageColors() +RLAPI void RL_UnloadImagePalette(RL_Color *colors); // Unload colors palette loaded with RL_LoadImagePalette() +RLAPI RL_Rectangle RL_GetImageAlphaBorder(RL_Image image, float threshold); // Get image alpha border rectangle +RLAPI RL_Color RL_GetImageColor(RL_Image image, int x, int y); // Get image pixel color at (x, y) position - // Color/pixel related functions - RLAPI Color fade( Color color, f32 alpha ); // Get color with alpha applied, alpha goes from 0.0f to 1.0f - RLAPI int color_to_int( Color color ); // Get hexadecimal value for a Color - RLAPI Vector4 color_normalize( Color color ); // Get Color normalized as float [0..1] - RLAPI Color color_from_normalized( Vector4 normalized ); // Get Color from normalized values [0..1] - RLAPI Vector3 color_to_hsv( Color color ); // Get HSV values for a Color, hue [0..360], saturation/value [0..1] - RLAPI Color color_from_hsv( f32 hue, f32 saturation, f32 value ); // Get a Color from HSV values, hue [0..360], saturation/value [0..1] - RLAPI Color color_tint( Color color, Color tint ); // Get color multiplied with another color - RLAPI Color color_brightness( Color color, f32 factor ); // Get color with brightness correction, brightness factor goes from -1.0f to 1.0f - RLAPI Color color_contrast( Color color, f32 contrast ); // Get color with contrast correction, contrast values between -1.0f and 1.0f - RLAPI Color color_alpha( Color color, f32 alpha ); // Get color with alpha applied, alpha goes from 0.0f to 1.0f - RLAPI Color color_alpha_blend( Color dst, Color src, Color tint ); // Get src alpha-blended into dst color with tint - RLAPI Color get_color( u32 hexValue ); // Get Color structure from hexadecimal value - RLAPI Color get_pixel_color( void* srcPtr, s32 format ); // Get Color from a source pixel pointer of certain format - RLAPI void set_pixel_color( void* dstPtr, Color color, s32 format ); // Set color formatted into destination pixel pointer - RLAPI int get_pixel_data_size( s32 width, s32 height, s32 format ); // Get pixel data size in bytes for certain format +// RL_Image drawing functions +// NOTE: RL_Image software-rendering functions (CPU) +RLAPI void RL_ImageClearBackground(RL_Image *dst, RL_Color color); // Clear image background with given color +RLAPI void RL_ImageDrawPixel(RL_Image *dst, int posX, int posY, RL_Color color); // Draw pixel within an image +RLAPI void RL_ImageDrawPixelV(RL_Image *dst, RL_Vector2 position, RL_Color color); // Draw pixel within an image (Vector version) +RLAPI void RL_ImageDrawLine(RL_Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, RL_Color color); // Draw line within an image +RLAPI void RL_ImageDrawLineV(RL_Image *dst, RL_Vector2 start, RL_Vector2 end, RL_Color color); // Draw line within an image (Vector version) +RLAPI void RL_ImageDrawCircle(RL_Image *dst, int centerX, int centerY, int radius, RL_Color color); // Draw a filled circle within an image +RLAPI void RL_ImageDrawCircleV(RL_Image *dst, RL_Vector2 center, int radius, RL_Color color); // Draw a filled circle within an image (Vector version) +RLAPI void RL_ImageDrawCircleLines(RL_Image *dst, int centerX, int centerY, int radius, RL_Color color); // Draw circle outline within an image +RLAPI void RL_ImageDrawCircleLinesV(RL_Image *dst, RL_Vector2 center, int radius, RL_Color color); // Draw circle outline within an image (Vector version) +RLAPI void RL_ImageDrawRectangle(RL_Image *dst, int posX, int posY, int width, int height, RL_Color color); // Draw rectangle within an image +RLAPI void RL_ImageDrawRectangleV(RL_Image *dst, RL_Vector2 position, RL_Vector2 size, RL_Color color); // Draw rectangle within an image (Vector version) +RLAPI void RL_ImageDrawRectangleRec(RL_Image *dst, RL_Rectangle rec, RL_Color color); // Draw rectangle within an image +RLAPI void RL_ImageDrawRectangleLines(RL_Image *dst, RL_Rectangle rec, int thick, RL_Color color); // Draw rectangle lines within an image +RLAPI void RL_ImageDraw(RL_Image *dst, RL_Image src, RL_Rectangle srcRec, RL_Rectangle dstRec, RL_Color tint); // Draw a source image within a destination image (tint applied to source) +RLAPI void RL_ImageDrawText(RL_Image *dst, const char *text, int posX, int posY, int fontSize, RL_Color color); // Draw text (using default font) within an image (destination) +RLAPI void RL_ImageDrawTextEx(RL_Image *dst, RL_Font font, const char *text, RL_Vector2 position, float fontSize, float spacing, RL_Color tint); // Draw text (custom sprite font) within an image (destination) - //------------------------------------------------------------------------------------ - // Font Loading and Text Drawing Functions (Module: text) - //------------------------------------------------------------------------------------ +// RL_Texture loading functions +// NOTE: These functions require GPU access +RLAPI RL_Texture2D RL_LoadTexture(const char *fileName); // Load texture from file into GPU memory (VRAM) +RLAPI RL_Texture2D RL_LoadTextureFromImage(RL_Image image); // Load texture from image data +RLAPI RL_TextureCubemap RL_LoadTextureCubemap(RL_Image image, int layout); // Load cubemap from image, multiple image cubemap layouts supported +RLAPI RL_RenderTexture2D RL_LoadRenderTexture(int width, int height); // Load texture for rendering (framebuffer) +RLAPI bool RL_IsTextureReady(RL_Texture2D texture); // Check if a texture is ready +RLAPI void RL_UnloadTexture(RL_Texture2D texture); // Unload texture from GPU memory (VRAM) +RLAPI bool RL_IsRenderTextureReady(RL_RenderTexture2D target); // Check if a render texture is ready +RLAPI void RL_UnloadRenderTexture(RL_RenderTexture2D target); // Unload render texture from GPU memory (VRAM) +RLAPI void RL_UpdateTexture(RL_Texture2D texture, const void *pixels); // Update GPU texture with new data +RLAPI void RL_UpdateTextureRec(RL_Texture2D texture, RL_Rectangle rec, const void *pixels); // Update GPU texture rectangle with new data - // Font loading/unloading functions - RLAPI Font get_font_default( void ); // Get the default Font - RLAPI Font load_font( char const* fileName ); // Load font from file into GPU memory (VRAM) - RLAPI Font load_font_ex( - char const* fileName, - s32 fontSize, - s32* codepoints, - s32 codepointCount - ); // Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set - RLAPI Font load_font_from_image( Image image, Color key, s32 firstChar ); // Load font from Image (XNA style) - RLAPI Font load_font_from_memory( - char const* fileType, - unsigned char const* fileData, - s32 dataSize, - s32 fontSize, - s32* codepoints, - s32 codepointCount - ); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf' - RLAPI bool is_font_ready( Font font ); // Check if a font is ready - RLAPI GlyphInfo* - load_font_data( unsigned char const* fileData, s32 dataSize, s32 fontSize, s32* codepoints, s32 codepointCount, s32 type ); // Load font data for - // further use - RLAPI Image gen_image_font_atlas( - GlyphInfo const* glyphs, - Rectangle** glyphRecs, - s32 glyphCount, - s32 fontSize, - s32 padding, - s32 packMethod - ); // Generate image font atlas using chars info - RLAPI void unload_font_data( GlyphInfo* glyphs, s32 glyphCount ); // Unload font chars info data (RAM) - RLAPI void unload_font( Font font ); // Unload font from GPU memory (VRAM) - RLAPI bool export_font_as_code( Font font, char const* fileName ); // Export font as code file, returns true on success +// RL_Texture configuration functions +RLAPI void RL_GenTextureMipmaps(RL_Texture2D *texture); // Generate GPU mipmaps for a texture +RLAPI void RL_SetTextureFilter(RL_Texture2D texture, int filter); // Set texture scaling filter mode +RLAPI void RL_SetTextureWrap(RL_Texture2D texture, int wrap); // Set texture wrapping mode - // Text drawing functions - RLAPI void draw_fps( s32 posX, s32 posY ); // Draw current FPS - RLAPI void draw_text( char const* text, s32 posX, s32 posY, s32 fontSize, Color color ); // Draw text (using default font) - RLAPI void draw_text_ex( Font font, char const* text, Vector2 position, f32 fontSize, f32 spacing, Color tint ); // Draw text using font and - // additional parameters - RLAPI void draw_text_pro( - Font font, - char const* text, - Vector2 position, - Vector2 origin, - f32 rotation, - f32 fontSize, - f32 spacing, - Color tint - ); // Draw text using Font and pro parameters (rotation) - RLAPI void draw_text_codepoint( Font font, s32 codepoint, Vector2 position, f32 fontSize, Color tint ); // Draw one character (codepoint) - RLAPI void draw_text_codepoints( - Font font, - int const* codepoints, - s32 codepointCount, - Vector2 position, - f32 fontSize, - f32 spacing, - Color tint - ); // Draw multiple character (codepoint) +// RL_Texture drawing functions +RLAPI void RL_DrawTexture(RL_Texture2D texture, int posX, int posY, RL_Color tint); // Draw a RL_Texture2D +RLAPI void RL_DrawTextureV(RL_Texture2D texture, RL_Vector2 position, RL_Color tint); // Draw a RL_Texture2D with position defined as RL_Vector2 +RLAPI void RL_DrawTextureEx(RL_Texture2D texture, RL_Vector2 position, float rotation, float scale, RL_Color tint); // Draw a RL_Texture2D with extended parameters +RLAPI void RL_DrawTextureRec(RL_Texture2D texture, RL_Rectangle source, RL_Vector2 position, RL_Color tint); // Draw a part of a texture defined by a rectangle +RLAPI void RL_DrawTexturePro(RL_Texture2D texture, RL_Rectangle source, RL_Rectangle dest, RL_Vector2 origin, float rotation, RL_Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters +RLAPI void RL_DrawTextureNPatch(RL_Texture2D texture, RL_NPatchInfo nPatchInfo, RL_Rectangle dest, RL_Vector2 origin, float rotation, RL_Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely - // Text font info functions - RLAPI void set_text_line_spacing( s32 spacing ); // Set vertical line spacing when drawing with line-breaks - RLAPI int measure_text( char const* text, s32 fontSize ); // Measure string width for default font - RLAPI Vector2 measure_text_ex( Font font, char const* text, f32 fontSize, f32 spacing ); // Measure string size for Font - RLAPI int get_glyph_index( - Font font, - s32 codepoint - ); // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found - RLAPI GlyphInfo - get_glyph_info( Font font, s32 codepoint ); // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found - RLAPI Rectangle get_glyph_atlas_rec( - Font font, - s32 codepoint - ); // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found +// RL_Color/pixel related functions +RLAPI RL_Color RL_Fade(RL_Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f +RLAPI int RL_ColorToInt(RL_Color color); // Get hexadecimal value for a RL_Color +RLAPI RL_Vector4 RL_ColorNormalize(RL_Color color); // Get RL_Color normalized as float [0..1] +RLAPI RL_Color RL_ColorFromNormalized(RL_Vector4 normalized); // Get RL_Color from normalized values [0..1] +RLAPI RL_Vector3 RL_ColorToHSV(RL_Color color); // Get HSV values for a RL_Color, hue [0..360], saturation/value [0..1] +RLAPI RL_Color RL_ColorFromHSV(float hue, float saturation, float value); // Get a RL_Color from HSV values, hue [0..360], saturation/value [0..1] +RLAPI RL_Color RL_ColorTint(RL_Color color, RL_Color tint); // Get color multiplied with another color +RLAPI RL_Color RL_ColorBrightness(RL_Color color, float factor); // Get color with brightness correction, brightness factor goes from -1.0f to 1.0f +RLAPI RL_Color RL_ColorContrast(RL_Color color, float contrast); // Get color with contrast correction, contrast values between -1.0f and 1.0f +RLAPI RL_Color RL_ColorAlpha(RL_Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f +RLAPI RL_Color RL_ColorAlphaBlend(RL_Color dst, RL_Color src, RL_Color tint); // Get src alpha-blended into dst color with tint +RLAPI RL_Color RL_GetColor(unsigned int hexValue); // Get RL_Color structure from hexadecimal value +RLAPI RL_Color RL_GetPixelColor(void *srcPtr, int format); // Get RL_Color from a source pixel pointer of certain format +RLAPI void RL_SetPixelColor(void *dstPtr, RL_Color color, int format); // Set color formatted into destination pixel pointer +RLAPI int RL_GetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes for certain format - // Text codepoints management functions (unicode characters) - RLAPI char* load_utf8( int const* codepoints, s32 length ); // Load UTF-8 text encoded from codepoints array - RLAPI void unload_utf8( char* text ); // Unload UTF-8 text encoded from codepoints array - RLAPI int* load_codepoints( char const* text, s32* count ); // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter - RLAPI void unload_codepoints( s32* codepoints ); // Unload codepoints data from memory - RLAPI int get_codepoint_count( char const* text ); // Get total number of codepoints in a UTF-8 encoded string - RLAPI int get_codepoint( char const* text, s32* codepointSize ); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure - RLAPI int - get_codepoint_next( char const* text, s32* codepointSize ); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure - RLAPI int get_codepoint_previous( - char const* text, - s32* codepointSize - ); // Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure - RLAPI char const* - codepoint_to_utf8( s32 codepoint, s32* utf8Size ); // Encode one codepoint into UTF-8 byte array (array length returned as parameter) +//------------------------------------------------------------------------------------ +// RL_Font Loading and Text Drawing Functions (Module: text) +//------------------------------------------------------------------------------------ - // Text strings management functions (no UTF-8 strings, only byte chars) - // NOTE: Some strings allocate memory internally for returned strings, just be careful! - RLAPI int text_copy( char* dst, char const* src ); // Copy one string to another, returns bytes copied - RLAPI bool text_is_equal( char const* text1, char const* text2 ); // Check if two text string are equal - RLAPI unsigned int text_length( char const* text ); // Get text length, checks for '\0' ending - RLAPI char const* text_format( char const* text, ... ); // Text formatting with variables (sprintf() style) - RLAPI char const* text_subtext( char const* text, s32 position, s32 length ); // Get a piece of a text string - RLAPI char* text_replace( char* text, char const* replace, char const* by ); // Replace text string (WARNING: memory must be freed!) - RLAPI char* text_insert( char const* text, char const* insert, s32 position ); // Insert text in a position (WARNING: memory must be freed!) - RLAPI char const* text_join( char const** textList, s32 count, char const* delimiter ); // Join text strings with delimiter - RLAPI char const** text_split( char const* text, char delimiter, s32* count ); // Split text into multiple strings - RLAPI void text_append( char* text, char const* append, s32* position ); // Append text at specific position and move cursor! - RLAPI int text_find_index( char const* text, char const* find ); // Find first text occurrence within a string - RLAPI char const* text_to_upper( char const* text ); // Get upper case version of provided string - RLAPI char const* text_to_lower( char const* text ); // Get lower case version of provided string - RLAPI char const* text_to_pascal( char const* text ); // Get Pascal case notation version of provided string - RLAPI int text_to_integer( char const* text ); // Get integer value from text (negative values not supported) +// RL_Font loading/unloading functions +RLAPI RL_Font RL_GetFontDefault(void); // Get the default RL_Font +RLAPI RL_Font RL_LoadFont(const char *fileName); // Load font from file into GPU memory (VRAM) +RLAPI RL_Font RL_LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set +RLAPI RL_Font RL_LoadFontFromImage(RL_Image image, RL_Color key, int firstChar); // Load font from RL_Image (XNA style) +RLAPI RL_Font RL_LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf' +RLAPI bool RL_IsFontReady(RL_Font font); // Check if a font is ready +RLAPI RL_GlyphInfo *RL_LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount, int type); // Load font data for further use +RLAPI RL_Image RL_GenImageFontAtlas(const RL_GlyphInfo *glyphs, RL_Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info +RLAPI void RL_UnloadFontData(RL_GlyphInfo *glyphs, int glyphCount); // Unload font chars info data (RAM) +RLAPI void RL_UnloadFont(RL_Font font); // Unload font from GPU memory (VRAM) +RLAPI bool RL_ExportFontAsCode(RL_Font font, const char *fileName); // Export font as code file, returns true on success - //------------------------------------------------------------------------------------ - // Basic 3d Shapes Drawing Functions (Module: models) - //------------------------------------------------------------------------------------ +// Text drawing functions +RLAPI void RL_DrawFPS(int posX, int posY); // Draw current FPS +RLAPI void RL_DrawText(const char *text, int posX, int posY, int fontSize, RL_Color color); // Draw text (using default font) +RLAPI void RL_DrawTextEx(RL_Font font, const char *text, RL_Vector2 position, float fontSize, float spacing, RL_Color tint); // Draw text using font and additional parameters +RLAPI void RL_DrawTextPro(RL_Font font, const char *text, RL_Vector2 position, RL_Vector2 origin, float rotation, float fontSize, float spacing, RL_Color tint); // Draw text using RL_Font and pro parameters (rotation) +RLAPI void RL_DrawTextCodepoint(RL_Font font, int codepoint, RL_Vector2 position, float fontSize, RL_Color tint); // Draw one character (codepoint) +RLAPI void RL_DrawTextCodepoints(RL_Font font, const int *codepoints, int codepointCount, RL_Vector2 position, float fontSize, float spacing, RL_Color tint); // Draw multiple character (codepoint) - // Basic geometric 3D shapes drawing functions - RLAPI void draw_line_3d( Vector3 startPos, Vector3 endPos, Color color ); // Draw a line in 3D world space - RLAPI void draw_point_3d( Vector3 position, Color color ); // Draw a point in 3D space, actually a small line - RLAPI void draw_circle_3d( Vector3 center, f32 radius, Vector3 rotationAxis, f32 rotationAngle, Color color ); // Draw a circle in 3D world space - RLAPI void draw_triangle_3d( Vector3 v1, Vector3 v2, Vector3 v3, Color color ); // Draw a color-filled triangle (vertex in counter-clockwise order!) - RLAPI void draw_triangle_strip_3d( Vector3* points, s32 pointCount, Color color ); // Draw a triangle strip defined by points - RLAPI void draw_cube( Vector3 position, f32 width, f32 height, f32 length, Color color ); // Draw cube - RLAPI void draw_cube_v( Vector3 position, Vector3 size, Color color ); // Draw cube (Vector version) - RLAPI void draw_cube_wires( Vector3 position, f32 width, f32 height, f32 length, Color color ); // Draw cube wires - RLAPI void draw_cube_wires_v( Vector3 position, Vector3 size, Color color ); // Draw cube wires (Vector version) - RLAPI void draw_sphere( Vector3 centerPos, f32 radius, Color color ); // Draw sphere - RLAPI void draw_sphere_ex( Vector3 centerPos, f32 radius, s32 rings, s32 slices, Color color ); // Draw sphere with extended parameters - RLAPI void draw_sphere_wires( Vector3 centerPos, f32 radius, s32 rings, s32 slices, Color color ); // Draw sphere wires - RLAPI void draw_cylinder( Vector3 position, f32 radiusTop, f32 radiusBottom, f32 height, s32 slices, Color color ); // Draw a cylinder/cone - RLAPI void - draw_cylinder_ex( Vector3 startPos, Vector3 endPos, f32 startRadius, f32 endRadius, s32 sides, Color color ); // Draw a cylinder with base at - // startPos and top at endPos - RLAPI void - draw_cylinder_wires( Vector3 position, f32 radiusTop, f32 radiusBottom, f32 height, s32 slices, Color color ); // Draw a cylinder/cone wires - RLAPI void draw_cylinder_wires_ex( - Vector3 startPos, - Vector3 endPos, - f32 startRadius, - f32 endRadius, - s32 sides, - Color color - ); // Draw a cylinder wires with base at startPos and top at endPos - RLAPI void draw_capsule( Vector3 startPos, Vector3 endPos, f32 radius, s32 slices, s32 rings, Color color ); // Draw a capsule with the center of its - // sphere caps at startPos and endPos - RLAPI void draw_capsule_wires( - Vector3 startPos, - Vector3 endPos, - f32 radius, - s32 slices, - s32 rings, - Color color - ); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos - RLAPI void draw_plane( Vector3 centerPos, Vector2 size, Color color ); // Draw a plane XZ - RLAPI void draw_ray( Ray ray, Color color ); // Draw a ray line - RLAPI void draw_grid( s32 slices, f32 spacing ); // Draw a grid (centered at (0, 0, 0)) +// Text font info functions +RLAPI void RL_SetTextLineSpacing(int spacing); // Set vertical line spacing when drawing with line-breaks +RLAPI int RL_MeasureText(const char *text, int fontSize); // Measure string width for default font +RLAPI RL_Vector2 RL_MeasureTextEx(RL_Font font, const char *text, float fontSize, float spacing); // Measure string size for RL_Font +RLAPI int RL_GetGlyphIndex(RL_Font font, int codepoint); // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found +RLAPI RL_GlyphInfo RL_GetGlyphInfo(RL_Font font, int codepoint); // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found +RLAPI RL_Rectangle RL_GetGlyphAtlasRec(RL_Font font, int codepoint); // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found - //------------------------------------------------------------------------------------ - // Model 3d Loading and Drawing Functions (Module: models) - //------------------------------------------------------------------------------------ +// Text codepoints management functions (unicode characters) +RLAPI char *RL_LoadUTF8(const int *codepoints, int length); // Load UTF-8 text encoded from codepoints array +RLAPI void RL_UnloadUTF8(char *text); // Unload UTF-8 text encoded from codepoints array +RLAPI int *RL_LoadCodepoints(const char *text, int *count); // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter +RLAPI void RL_UnloadCodepoints(int *codepoints); // Unload codepoints data from memory +RLAPI int RL_GetCodepointCount(const char *text); // Get total number of codepoints in a UTF-8 encoded string +RLAPI int RL_GetCodepoint(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +RLAPI int RL_GetCodepointNext(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +RLAPI int RL_GetCodepointPrevious(const char *text, int *codepointSize); // Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +RLAPI const char *RL_CodepointToUTF8(int codepoint, int *utf8Size); // Encode one codepoint into UTF-8 byte array (array length returned as parameter) - // Model management functions - RLAPI Model load_model( char const* fileName ); // Load model from files (meshes and materials) - RLAPI Model load_model_from_mesh( Mesh mesh ); // Load model from generated mesh (default material) - RLAPI bool is_model_ready( Model model ); // Check if a model is ready - RLAPI void unload_model( Model model ); // Unload model (including meshes) from memory (RAM and/or VRAM) - RLAPI BoundingBox get_model_bounding_box( Model model ); // Compute model bounding box limits (considers all meshes) +// Text strings management functions (no UTF-8 strings, only byte chars) +// NOTE: Some strings allocate memory internally for returned strings, just be careful! +RLAPI int RL_TextCopy(char *dst, const char *src); // Copy one string to another, returns bytes copied +RLAPI bool RL_TextIsEqual(const char *text1, const char *text2); // Check if two text string are equal +RLAPI unsigned int RL_TextLength(const char *text); // Get text length, checks for '\0' ending +RLAPI const char *RL_TextFormat(const char *text, ...); // Text formatting with variables (sprintf() style) +RLAPI const char *RL_TextSubtext(const char *text, int position, int length); // Get a piece of a text string +RLAPI char *RL_TextReplace(char *text, const char *replace, const char *by); // Replace text string (WARNING: memory must be freed!) +RLAPI char *RL_TextInsert(const char *text, const char *insert, int position); // Insert text in a position (WARNING: memory must be freed!) +RLAPI const char *RL_TextJoin(const char **textList, int count, const char *delimiter); // Join text strings with delimiter +RLAPI const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings +RLAPI void RL_TextAppend(char *text, const char *append, int *position); // Append text at specific position and move cursor! +RLAPI int RL_TextFindIndex(const char *text, const char *find); // Find first text occurrence within a string +RLAPI const char *RL_TextToUpper(const char *text); // Get upper case version of provided string +RLAPI const char *RL_TextToLower(const char *text); // Get lower case version of provided string +RLAPI const char *RL_TextToPascal(const char *text); // Get Pascal case notation version of provided string +RLAPI int RL_TextToInteger(const char *text); // Get integer value from text (negative values not supported) - // Model drawing functions - RLAPI void draw_model( Model model, Vector3 position, f32 scale, Color tint ); // Draw a model (with texture if set) - RLAPI void draw_model_ex( Model model, Vector3 position, Vector3 rotationAxis, f32 rotationAngle, Vector3 scale, Color tint ); // Draw a model with - // extended parameters - RLAPI void draw_model_wires( Model model, Vector3 position, f32 scale, Color tint ); // Draw a model wires (with texture if set) - RLAPI void draw_model_wires_ex( - Model model, - Vector3 position, - Vector3 rotationAxis, - f32 rotationAngle, - Vector3 scale, - Color tint - ); // Draw a model wires (with texture if set) with extended parameters - RLAPI void draw_bounding_box( BoundingBox box, Color color ); // Draw bounding box (wires) - RLAPI void draw_billboard( Camera camera, Texture2D texture, Vector3 position, f32 size, Color tint ); // Draw a billboard texture - RLAPI void - draw_billboard_rec( Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint ); // Draw a billboard texture - // defined by source - RLAPI void draw_billboard_pro( - Camera camera, - Texture2D texture, - Rectangle source, - Vector3 position, - Vector3 up, - Vector2 size, - Vector2 origin, - f32 rotation, - Color tint - ); // Draw a billboard texture defined by source and rotation +//------------------------------------------------------------------------------------ +// Basic 3d Shapes Drawing Functions (Module: models) +//------------------------------------------------------------------------------------ - // Mesh management functions - RLAPI void upload_mesh( Mesh* mesh, bool dynamic ); // Upload mesh vertex data in GPU and provide VAO/VBO ids - RLAPI void update_mesh_buffer( Mesh mesh, s32 index, void const* data, s32 dataSize, s32 offset ); // Update mesh vertex data in GPU for a specific - // buffer index - RLAPI void unload_mesh( Mesh mesh ); // Unload mesh data from CPU and GPU - RLAPI void draw_mesh( Mesh mesh, Material material, Matrix transform ); // Draw a 3d mesh with material and transform - RLAPI void draw_mesh_instanced( Mesh mesh, Material material, Matrix const* transforms, s32 instances ); // Draw multiple mesh instances with - // material and different transforms - RLAPI bool export_mesh( Mesh mesh, char const* fileName ); // Export mesh data to file, returns true on success - RLAPI BoundingBox get_mesh_bounding_box( Mesh mesh ); // Compute mesh bounding box limits - RLAPI void gen_mesh_tangents( Mesh* mesh ); // Compute mesh tangents +// Basic geometric 3D shapes drawing functions +RLAPI void RL_DrawLine3D(RL_Vector3 startPos, RL_Vector3 endPos, RL_Color color); // Draw a line in 3D world space +RLAPI void RL_DrawPoint3D(RL_Vector3 position, RL_Color color); // Draw a point in 3D space, actually a small line +RLAPI void RL_DrawCircle3D(RL_Vector3 center, float radius, RL_Vector3 rotationAxis, float rotationAngle, RL_Color color); // Draw a circle in 3D world space +RLAPI void RL_DrawTriangle3D(RL_Vector3 v1, RL_Vector3 v2, RL_Vector3 v3, RL_Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +RLAPI void RL_DrawTriangleStrip3D(RL_Vector3 *points, int pointCount, RL_Color color); // Draw a triangle strip defined by points +RLAPI void RL_DrawCube(RL_Vector3 position, float width, float height, float length, RL_Color color); // Draw cube +RLAPI void RL_DrawCubeV(RL_Vector3 position, RL_Vector3 size, RL_Color color); // Draw cube (Vector version) +RLAPI void RL_DrawCubeWires(RL_Vector3 position, float width, float height, float length, RL_Color color); // Draw cube wires +RLAPI void RL_DrawCubeWiresV(RL_Vector3 position, RL_Vector3 size, RL_Color color); // Draw cube wires (Vector version) +RLAPI void RL_DrawSphere(RL_Vector3 centerPos, float radius, RL_Color color); // Draw sphere +RLAPI void RL_DrawSphereEx(RL_Vector3 centerPos, float radius, int rings, int slices, RL_Color color); // Draw sphere with extended parameters +RLAPI void RL_DrawSphereWires(RL_Vector3 centerPos, float radius, int rings, int slices, RL_Color color); // Draw sphere wires +RLAPI void RL_DrawCylinder(RL_Vector3 position, float radiusTop, float radiusBottom, float height, int slices, RL_Color color); // Draw a cylinder/cone +RLAPI void RL_DrawCylinderEx(RL_Vector3 startPos, RL_Vector3 endPos, float startRadius, float endRadius, int sides, RL_Color color); // Draw a cylinder with base at startPos and top at endPos +RLAPI void RL_DrawCylinderWires(RL_Vector3 position, float radiusTop, float radiusBottom, float height, int slices, RL_Color color); // Draw a cylinder/cone wires +RLAPI void RL_DrawCylinderWiresEx(RL_Vector3 startPos, RL_Vector3 endPos, float startRadius, float endRadius, int sides, RL_Color color); // Draw a cylinder wires with base at startPos and top at endPos +RLAPI void RL_DrawCapsule(RL_Vector3 startPos, RL_Vector3 endPos, float radius, int slices, int rings, RL_Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos +RLAPI void RL_DrawCapsuleWires(RL_Vector3 startPos, RL_Vector3 endPos, float radius, int slices, int rings, RL_Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos +RLAPI void RL_DrawPlane(RL_Vector3 centerPos, RL_Vector2 size, RL_Color color); // Draw a plane XZ +RLAPI void RL_DrawRay(RL_Ray ray, RL_Color color); // Draw a ray line +RLAPI void RL_DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0)) - // Mesh generation functions - RLAPI Mesh gen_mesh_poly( s32 sides, f32 radius ); // Generate polygonal mesh - RLAPI Mesh gen_mesh_plane( f32 width, f32 length, s32 resX, s32 resZ ); // Generate plane mesh (with subdivisions) - RLAPI Mesh gen_mesh_cube( f32 width, f32 height, f32 length ); // Generate cuboid mesh - RLAPI Mesh gen_mesh_sphere( f32 radius, s32 rings, s32 slices ); // Generate sphere mesh (standard sphere) - RLAPI Mesh gen_mesh_hemi_sphere( f32 radius, s32 rings, s32 slices ); // Generate half-sphere mesh (no bottom cap) - RLAPI Mesh gen_mesh_cylinder( f32 radius, f32 height, s32 slices ); // Generate cylinder mesh - RLAPI Mesh gen_mesh_cone( f32 radius, f32 height, s32 slices ); // Generate cone/pyramid mesh - RLAPI Mesh gen_mesh_torus( f32 radius, f32 size, s32 radSeg, s32 sides ); // Generate torus mesh - RLAPI Mesh gen_mesh_knot( f32 radius, f32 size, s32 radSeg, s32 sides ); // Generate trefoil knot mesh - RLAPI Mesh gen_mesh_heightmap( Image heightmap, Vector3 size ); // Generate heightmap mesh from image data - RLAPI Mesh gen_mesh_cubicmap( Image cubicmap, Vector3 cubeSize ); // Generate cubes-based map mesh from image data +//------------------------------------------------------------------------------------ +// RL_Model 3d Loading and Drawing Functions (Module: models) +//------------------------------------------------------------------------------------ - // Material loading/unloading functions - RLAPI Material* load_materials( char const* fileName, s32* materialCount ); // Load materials from model file - RLAPI Material load_material_default( void ); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps) - RLAPI bool is_material_ready( Material material ); // Check if a material is ready - RLAPI void unload_material( Material material ); // Unload material from GPU memory (VRAM) - RLAPI void set_material_texture( - Material* material, - s32 mapType, - Texture2D texture - ); // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...) - RLAPI void set_model_mesh_material( Model* model, s32 meshId, s32 materialId ); // Set material for a mesh +// RL_Model management functions +RLAPI RL_Model RL_LoadModel(const char *fileName); // Load model from files (meshes and materials) +RLAPI RL_Model RL_LoadModelFromMesh(RL_Mesh mesh); // Load model from generated mesh (default material) +RLAPI bool RL_IsModelReady(RL_Model model); // Check if a model is ready +RLAPI void RL_UnloadModel(RL_Model model); // Unload model (including meshes) from memory (RAM and/or VRAM) +RLAPI RL_BoundingBox RL_GetModelBoundingBox(RL_Model model); // Compute model bounding box limits (considers all meshes) - // Model animations loading/unloading functions - RLAPI ModelAnimation* load_model_animations( char const* fileName, s32* animCount ); // Load model animations from file - RLAPI void update_model_animation( Model model, ModelAnimation anim, s32 frame ); // Update model animation pose - RLAPI void unload_model_animation( ModelAnimation anim ); // Unload animation data - RLAPI void unload_model_animations( ModelAnimation* animations, s32 animCount ); // Unload animation array data - RLAPI bool is_model_animation_valid( Model model, ModelAnimation anim ); // Check model animation skeleton match +// RL_Model drawing functions +RLAPI void RL_DrawModel(RL_Model model, RL_Vector3 position, float scale, RL_Color tint); // Draw a model (with texture if set) +RLAPI void RL_DrawModelEx(RL_Model model, RL_Vector3 position, RL_Vector3 rotationAxis, float rotationAngle, RL_Vector3 scale, RL_Color tint); // Draw a model with extended parameters +RLAPI void RL_DrawModelWires(RL_Model model, RL_Vector3 position, float scale, RL_Color tint); // Draw a model wires (with texture if set) +RLAPI void RL_DrawModelWiresEx(RL_Model model, RL_Vector3 position, RL_Vector3 rotationAxis, float rotationAngle, RL_Vector3 scale, RL_Color tint); // Draw a model wires (with texture if set) with extended parameters +RLAPI void RL_DrawBoundingBox(RL_BoundingBox box, RL_Color color); // Draw bounding box (wires) +RLAPI void RL_DrawBillboard(RL_Camera camera, RL_Texture2D texture, RL_Vector3 position, float size, RL_Color tint); // Draw a billboard texture +RLAPI void RL_DrawBillboardRec(RL_Camera camera, RL_Texture2D texture, RL_Rectangle source, RL_Vector3 position, RL_Vector2 size, RL_Color tint); // Draw a billboard texture defined by source +RLAPI void RL_DrawBillboardPro(RL_Camera camera, RL_Texture2D texture, RL_Rectangle source, RL_Vector3 position, RL_Vector3 up, RL_Vector2 size, RL_Vector2 origin, float rotation, RL_Color tint); // Draw a billboard texture defined by source and rotation - // Collision detection functions - RLAPI bool check_collision_spheres( Vector3 center1, f32 radius1, Vector3 center2, f32 radius2 ); // Check collision between two spheres - RLAPI bool check_collision_boxes( BoundingBox box1, BoundingBox box2 ); // Check collision between two bounding boxes - RLAPI bool check_collision_box_sphere( BoundingBox box, Vector3 center, f32 radius ); // Check collision between box and sphere - RLAPI RayCollision get_ray_collision_sphere( Ray ray, Vector3 center, f32 radius ); // Get collision info between ray and sphere - RLAPI RayCollision get_ray_collision_box( Ray ray, BoundingBox box ); // Get collision info between ray and box - RLAPI RayCollision get_ray_collision_mesh( Ray ray, Mesh mesh, Matrix transform ); // Get collision info between ray and mesh - RLAPI RayCollision get_ray_collision_triangle( Ray ray, Vector3 p1, Vector3 p2, Vector3 p3 ); // Get collision info between ray and triangle - RLAPI RayCollision get_ray_collision_quad( Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4 ); // Get collision info between ray and quad +// RL_Mesh management functions +RLAPI void RL_UploadMesh(RL_Mesh *mesh, bool dynamic); // Upload mesh vertex data in GPU and provide VAO/VBO ids +RLAPI void RL_UpdateMeshBuffer(RL_Mesh mesh, int index, const void *data, int dataSize, int offset); // Update mesh vertex data in GPU for a specific buffer index +RLAPI void RL_UnloadMesh(RL_Mesh mesh); // Unload mesh data from CPU and GPU +RLAPI void RL_DrawMesh(RL_Mesh mesh, RL_Material material, RL_Matrix transform); // Draw a 3d mesh with material and transform +RLAPI void RL_DrawMeshInstanced(RL_Mesh mesh, RL_Material material, const RL_Matrix *transforms, int instances); // Draw multiple mesh instances with material and different transforms +RLAPI bool RL_ExportMesh(RL_Mesh mesh, const char *fileName); // Export mesh data to file, returns true on success +RLAPI RL_BoundingBox RL_GetMeshBoundingBox(RL_Mesh mesh); // Compute mesh bounding box limits +RLAPI void RL_GenMeshTangents(RL_Mesh *mesh); // Compute mesh tangents - //------------------------------------------------------------------------------------ - // Audio Loading and Playing Functions (Module: audio) - //------------------------------------------------------------------------------------ - typedef void ( *AudioCallback )( void* bufferData, unsigned int frames ); +// RL_Mesh generation functions +RLAPI RL_Mesh RL_GenMeshPoly(int sides, float radius); // Generate polygonal mesh +RLAPI RL_Mesh RL_GenMeshPlane(float width, float length, int resX, int resZ); // Generate plane mesh (with subdivisions) +RLAPI RL_Mesh RL_GenMeshCube(float width, float height, float length); // Generate cuboid mesh +RLAPI RL_Mesh RL_GenMeshSphere(float radius, int rings, int slices); // Generate sphere mesh (standard sphere) +RLAPI RL_Mesh RL_GenMeshHemiSphere(float radius, int rings, int slices); // Generate half-sphere mesh (no bottom cap) +RLAPI RL_Mesh RL_GenMeshCylinder(float radius, float height, int slices); // Generate cylinder mesh +RLAPI RL_Mesh RL_GenMeshCone(float radius, float height, int slices); // Generate cone/pyramid mesh +RLAPI RL_Mesh RL_GenMeshTorus(float radius, float size, int radSeg, int sides); // Generate torus mesh +RLAPI RL_Mesh RL_GenMeshKnot(float radius, float size, int radSeg, int sides); // Generate trefoil knot mesh +RLAPI RL_Mesh RL_GenMeshHeightmap(RL_Image heightmap, RL_Vector3 size); // Generate heightmap mesh from image data +RLAPI RL_Mesh RL_GenMeshCubicmap(RL_Image cubicmap, RL_Vector3 cubeSize); // Generate cubes-based map mesh from image data - // Audio device management functions - RLAPI void init_audio_device( void ); // Initialize audio device and context - RLAPI void close_audio_device( void ); // Close the audio device and context - RLAPI bool is_audio_device_ready( void ); // Check if audio device has been initialized successfully - RLAPI void set_master_volume( f32 volume ); // Set master volume (listener) - RLAPI float get_master_volume( void ); // Get master volume (listener) +// RL_Material loading/unloading functions +RLAPI RL_Material *RL_LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file +RLAPI RL_Material RL_LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps) +RLAPI bool RL_IsMaterialReady(RL_Material material); // Check if a material is ready +RLAPI void RL_UnloadMaterial(RL_Material material); // Unload material from GPU memory (VRAM) +RLAPI void RL_SetMaterialTexture(RL_Material *material, int mapType, RL_Texture2D texture); // Set texture for a material map type (RL_MATERIAL_MAP_DIFFUSE, RL_MATERIAL_MAP_SPECULAR...) +RLAPI void RL_SetModelMeshMaterial(RL_Model *model, int meshId, int materialId); // Set material for a mesh - // Wave/Sound loading/unloading functions - RLAPI Wave load_wave( char const* fileName ); // Load wave data from file - RLAPI Wave load_wave_from_memory( - char const* fileType, - unsigned char const* fileData, - s32 dataSize - ); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav' - RLAPI bool is_wave_ready( Wave wave ); // Checks if wave data is ready - RLAPI Sound load_sound( char const* fileName ); // Load sound from file - RLAPI Sound load_sound_from_wave( Wave wave ); // Load sound from wave data - RLAPI Sound load_sound_alias( Sound source ); // Create a new sound that shares the same sample data as the source sound, does not own the sound data - RLAPI bool is_sound_ready( Sound sound ); // Checks if a sound is ready - RLAPI void update_sound( Sound sound, void const* data, s32 sampleCount ); // Update sound buffer with new data - RLAPI void unload_wave( Wave wave ); // Unload wave data - RLAPI void unload_sound( Sound sound ); // Unload sound - RLAPI void unload_sound_alias( Sound alias ); // Unload a sound alias (does not deallocate sample data) - RLAPI bool export_wave( Wave wave, char const* fileName ); // Export wave data to file, returns true on success - RLAPI bool export_wave_as_code( Wave wave, char const* fileName ); // Export wave sample data to code (.h), returns true on success +// RL_Model animations loading/unloading functions +RLAPI RL_ModelAnimation *RL_LoadModelAnimations(const char *fileName, int *animCount); // Load model animations from file +RLAPI void RL_UpdateModelAnimation(RL_Model model, RL_ModelAnimation anim, int frame); // Update model animation pose +RLAPI void RL_UnloadModelAnimation(RL_ModelAnimation anim); // Unload animation data +RLAPI void RL_UnloadModelAnimations(RL_ModelAnimation *animations, int animCount); // Unload animation array data +RLAPI bool RL_IsModelAnimationValid(RL_Model model, RL_ModelAnimation anim); // Check model animation skeleton match - // Wave/Sound management functions - RLAPI void play_sound( Sound sound ); // Play a sound - RLAPI void stop_sound( Sound sound ); // Stop playing a sound - RLAPI void pause_sound( Sound sound ); // Pause a sound - RLAPI void resume_sound( Sound sound ); // Resume a paused sound - RLAPI bool is_sound_playing( Sound sound ); // Check if a sound is currently playing - RLAPI void set_sound_volume( Sound sound, f32 volume ); // Set volume for a sound (1.0 is max level) - RLAPI void set_sound_pitch( Sound sound, f32 pitch ); // Set pitch for a sound (1.0 is base level) - RLAPI void set_sound_pan( Sound sound, f32 pan ); // Set pan for a sound (0.5 is center) - RLAPI Wave wave_copy( Wave wave ); // Copy a wave to a new wave - RLAPI void wave_crop( Wave* wave, s32 initSample, s32 finalSample ); // Crop a wave to defined samples range - RLAPI void wave_format( Wave* wave, s32 sampleRate, s32 sampleSize, s32 channels ); // Convert wave data to desired format - RLAPI float* load_wave_samples( Wave wave ); // Load samples data from wave as a 32bit float data array - RLAPI void unload_wave_samples( f32* samples ); // Unload samples data loaded with LoadWaveSamples() +// Collision detection functions +RLAPI bool RL_CheckCollisionSpheres(RL_Vector3 center1, float radius1, RL_Vector3 center2, float radius2); // Check collision between two spheres +RLAPI bool RL_CheckCollisionBoxes(RL_BoundingBox box1, RL_BoundingBox box2); // Check collision between two bounding boxes +RLAPI bool RL_CheckCollisionBoxSphere(RL_BoundingBox box, RL_Vector3 center, float radius); // Check collision between box and sphere +RLAPI RL_RayCollision RL_GetRayCollisionSphere(RL_Ray ray, RL_Vector3 center, float radius); // Get collision info between ray and sphere +RLAPI RL_RayCollision RL_GetRayCollisionBox(RL_Ray ray, RL_BoundingBox box); // Get collision info between ray and box +RLAPI RL_RayCollision RL_GetRayCollisionMesh(RL_Ray ray, RL_Mesh mesh, RL_Matrix transform); // Get collision info between ray and mesh +RLAPI RL_RayCollision RL_GetRayCollisionTriangle(RL_Ray ray, RL_Vector3 p1, RL_Vector3 p2, RL_Vector3 p3); // Get collision info between ray and triangle +RLAPI RL_RayCollision RL_GetRayCollisionQuad(RL_Ray ray, RL_Vector3 p1, RL_Vector3 p2, RL_Vector3 p3, RL_Vector3 p4); // Get collision info between ray and quad - // Music management functions - RLAPI Music load_music_stream( char const* fileName ); // Load music stream from file - RLAPI Music load_music_stream_from_memory( char const* fileType, unsigned char const* data, s32 dataSize ); // Load music stream from data - RLAPI bool is_music_ready( Music music ); // Checks if a music stream is ready - RLAPI void unload_music_stream( Music music ); // Unload music stream - RLAPI void play_music_stream( Music music ); // Start music playing - RLAPI bool is_music_stream_playing( Music music ); // Check if music is playing - RLAPI void update_music_stream( Music music ); // Updates buffers for music streaming - RLAPI void stop_music_stream( Music music ); // Stop music playing - RLAPI void pause_music_stream( Music music ); // Pause music playing - RLAPI void resume_music_stream( Music music ); // Resume playing paused music - RLAPI void seek_music_stream( Music music, f32 position ); // Seek music to a position (in seconds) - RLAPI void set_music_volume( Music music, f32 volume ); // Set volume for music (1.0 is max level) - RLAPI void set_music_pitch( Music music, f32 pitch ); // Set pitch for a music (1.0 is base level) - RLAPI void set_music_pan( Music music, f32 pan ); // Set pan for a music (0.5 is center) - RLAPI float get_music_time_length( Music music ); // Get music time length (in seconds) - RLAPI float get_music_time_played( Music music ); // Get current music time played (in seconds) +//------------------------------------------------------------------------------------ +// Audio Loading and Playing Functions (Module: audio) +//------------------------------------------------------------------------------------ +typedef void (*AudioCallback)(void *bufferData, unsigned int frames); - // AudioStream management functions - RLAPI AudioStream load_audio_stream( u32 sampleRate, u32 sampleSize, u32 channels ); // Load audio stream (to stream raw audio pcm data) - RLAPI bool is_audio_stream_ready( AudioStream stream ); // Checks if an audio stream is ready - RLAPI void unload_audio_stream( AudioStream stream ); // Unload audio stream and free memory - RLAPI void update_audio_stream( AudioStream stream, void const* data, s32 frameCount ); // Update audio stream buffers with data - RLAPI bool is_audio_stream_processed( AudioStream stream ); // Check if any audio stream buffers requires refill - RLAPI void play_audio_stream( AudioStream stream ); // Play audio stream - RLAPI void pause_audio_stream( AudioStream stream ); // Pause audio stream - RLAPI void resume_audio_stream( AudioStream stream ); // Resume audio stream - RLAPI bool is_audio_stream_playing( AudioStream stream ); // Check if audio stream is playing - RLAPI void stop_audio_stream( AudioStream stream ); // Stop audio stream - RLAPI void set_audio_stream_volume( AudioStream stream, f32 volume ); // Set volume for audio stream (1.0 is max level) - RLAPI void set_audio_stream_pitch( AudioStream stream, f32 pitch ); // Set pitch for audio stream (1.0 is base level) - RLAPI void set_audio_stream_pan( AudioStream stream, f32 pan ); // Set pan for audio stream (0.5 is centered) - RLAPI void set_audio_stream_buffer_size_default( s32 size ); // Default size for new audio streams - RLAPI void set_audio_stream_callback( AudioStream stream, AudioCallback callback ); // Audio thread callback to request new data +// Audio device management functions +RLAPI void RL_InitAudioDevice(void); // Initialize audio device and context +RLAPI void RL_CloseAudioDevice(void); // Close the audio device and context +RLAPI bool RL_IsAudioDeviceReady(void); // Check if audio device has been initialized successfully +RLAPI void RL_SetMasterVolume(float volume); // Set master volume (listener) +RLAPI float RL_GetMasterVolume(void); // Get master volume (listener) - RLAPI void attach_audio_stream_processor( - AudioStream stream, - AudioCallback processor - ); // Attach audio stream processor to stream, receives the samples as s - RLAPI void detach_audio_stream_processor( AudioStream stream, AudioCallback processor ); // Detach audio stream processor from stream +// RL_Wave/RL_Sound loading/unloading functions +RLAPI RL_Wave RL_LoadWave(const char *fileName); // Load wave data from file +RLAPI RL_Wave RL_LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav' +RLAPI bool RL_IsWaveReady(RL_Wave wave); // Checks if wave data is ready +RLAPI RL_Sound RL_LoadSound(const char *fileName); // Load sound from file +RLAPI RL_Sound RL_LoadSoundFromWave(RL_Wave wave); // Load sound from wave data +RLAPI RL_Sound RL_LoadSoundAlias(RL_Sound source); // Create a new sound that shares the same sample data as the source sound, does not own the sound data +RLAPI bool RL_IsSoundReady(RL_Sound sound); // Checks if a sound is ready +RLAPI void RL_UpdateSound(RL_Sound sound, const void *data, int sampleCount); // Update sound buffer with new data +RLAPI void RL_UnloadWave(RL_Wave wave); // Unload wave data +RLAPI void RL_UnloadSound(RL_Sound sound); // Unload sound +RLAPI void RL_UnloadSoundAlias(RL_Sound alias); // Unload a sound alias (does not deallocate sample data) +RLAPI bool RL_ExportWave(RL_Wave wave, const char *fileName); // Export wave data to file, returns true on success +RLAPI bool RL_ExportWaveAsCode(RL_Wave wave, const char *fileName); // Export wave sample data to code (.h), returns true on success - RLAPI void attach_audio_mixed_processor( AudioCallback processor - ); // Attach audio stream processor to the entire audio pipeline, receives the samples as s - RLAPI void detach_audio_mixed_processor( AudioCallback processor ); // Detach audio stream processor from the entire audio pipeline +// RL_Wave/RL_Sound management functions +RLAPI void RL_PlaySound(RL_Sound sound); // Play a sound +RLAPI void RL_StopSound(RL_Sound sound); // Stop playing a sound +RLAPI void RL_PauseSound(RL_Sound sound); // Pause a sound +RLAPI void RL_ResumeSound(RL_Sound sound); // Resume a paused sound +RLAPI bool RL_IsSoundPlaying(RL_Sound sound); // Check if a sound is currently playing +RLAPI void RL_SetSoundVolume(RL_Sound sound, float volume); // Set volume for a sound (1.0 is max level) +RLAPI void RL_SetSoundPitch(RL_Sound sound, float pitch); // Set pitch for a sound (1.0 is base level) +RLAPI void RL_SetSoundPan(RL_Sound sound, float pan); // Set pan for a sound (0.5 is center) +RLAPI RL_Wave RL_WaveCopy(RL_Wave wave); // Copy a wave to a new wave +RLAPI void RL_WaveCrop(RL_Wave *wave, int initSample, int finalSample); // Crop a wave to defined samples range +RLAPI void RL_WaveFormat(RL_Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format +RLAPI float *RL_LoadWaveSamples(RL_Wave wave); // Load samples data from wave as a 32bit float data array +RLAPI void RL_UnloadWaveSamples(float *samples); // Unload samples data loaded with RL_LoadWaveSamples() -#if defined( __cplusplus ) - } +// RL_Music management functions +RLAPI RL_Music RL_LoadMusicStream(const char *fileName); // Load music stream from file +RLAPI RL_Music RL_LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data +RLAPI bool RL_IsMusicReady(RL_Music music); // Checks if a music stream is ready +RLAPI void RL_UnloadMusicStream(RL_Music music); // Unload music stream +RLAPI void RL_PlayMusicStream(RL_Music music); // Start music playing +RLAPI bool RL_IsMusicStreamPlaying(RL_Music music); // Check if music is playing +RLAPI void RL_UpdateMusicStream(RL_Music music); // Updates buffers for music streaming +RLAPI void RL_StopMusicStream(RL_Music music); // Stop music playing +RLAPI void RL_PauseMusicStream(RL_Music music); // Pause music playing +RLAPI void RL_ResumeMusicStream(RL_Music music); // Resume playing paused music +RLAPI void RL_SeekMusicStream(RL_Music music, float position); // Seek music to a position (in seconds) +RLAPI void RL_SetMusicVolume(RL_Music music, float volume); // Set volume for music (1.0 is max level) +RLAPI void RL_SetMusicPitch(RL_Music music, float pitch); // Set pitch for a music (1.0 is base level) +RLAPI void RL_SetMusicPan(RL_Music music, float pan); // Set pan for a music (0.5 is center) +RLAPI float RL_GetMusicTimeLength(RL_Music music); // Get music time length (in seconds) +RLAPI float RL_GetMusicTimePlayed(RL_Music music); // Get current music time played (in seconds) + +// RL_AudioStream management functions +RLAPI RL_AudioStream RL_LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data) +RLAPI bool RL_IsAudioStreamReady(RL_AudioStream stream); // Checks if an audio stream is ready +RLAPI void RL_UnloadAudioStream(RL_AudioStream stream); // Unload audio stream and free memory +RLAPI void RL_UpdateAudioStream(RL_AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data +RLAPI bool RL_IsAudioStreamProcessed(RL_AudioStream stream); // Check if any audio stream buffers requires refill +RLAPI void RL_PlayAudioStream(RL_AudioStream stream); // Play audio stream +RLAPI void RL_PauseAudioStream(RL_AudioStream stream); // Pause audio stream +RLAPI void RL_ResumeAudioStream(RL_AudioStream stream); // Resume audio stream +RLAPI bool RL_IsAudioStreamPlaying(RL_AudioStream stream); // Check if audio stream is playing +RLAPI void RL_StopAudioStream(RL_AudioStream stream); // Stop audio stream +RLAPI void RL_SetAudioStreamVolume(RL_AudioStream stream, float volume); // Set volume for audio stream (1.0 is max level) +RLAPI void RL_SetAudioStreamPitch(RL_AudioStream stream, float pitch); // Set pitch for audio stream (1.0 is base level) +RLAPI void RL_SetAudioStreamPan(RL_AudioStream stream, float pan); // Set pan for audio stream (0.5 is centered) +RLAPI void RL_SetAudioStreamBufferSizeDefault(int size); // Default size for new audio streams +RLAPI void RL_SetAudioStreamCallback(RL_AudioStream stream, AudioCallback callback); // Audio thread callback to request new data + +RLAPI void RL_AttachAudioStreamProcessor(RL_AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream, receives the samples as s +RLAPI void RL_DetachAudioStreamProcessor(RL_AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream + +RLAPI void RL_AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline, receives the samples as s +RLAPI void RL_DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline + +#if defined(__cplusplus) } #endif -#endif -// RAYLIB_H +#endif // RAYLIB_H diff --git a/project/auxillary/vis_ast/dependencies/raylib/include/raymath.h b/project/auxillary/vis_ast/dependencies/raylib/include/raymath.h index 0a2073d..5178062 100644 --- a/project/auxillary/vis_ast/dependencies/raylib/include/raymath.h +++ b/project/auxillary/vis_ast/dependencies/raylib/include/raymath.h @@ -1,1118 +1,1114 @@ /********************************************************************************************** - * - * raymath v1.5 - Math functions to work with Vector2, Vector3, Matrix and Quaternions - * - * CONVENTIONS: - * - Matrix structure is defined as row-major (memory layout) but parameters naming AND all - * math operations performed by the library consider the structure as it was column-major - * It is like transposed versions of the matrices are used for all the maths - * It benefits some functions making them cache-friendly and also avoids matrix - * transpositions sometimes required by OpenGL - * Example: In memory order, row0 is [m0 m4 m8 m12] but in semantic math row0 is [m0 m1 m2 m3] - * - Functions are always self-contained, no function use another raymath function inside, - * required code is directly re-implemented inside - * - Functions input parameters are always received by value (2 unavoidable exceptions) - * - Functions use always a "result" variable for return - * - Functions are always defined inline - * - Angles are always in radians (DEG2RAD/RAD2DEG macros provided for convenience) - * - No compound literals used to make sure libray is compatible with C++ - * - * CONFIGURATION: - * #define RAYMATH_IMPLEMENTATION - * Generates the implementation of the library into the included file. - * If not defined, the library is in header only mode and can be included in other headers - * or source files without problems. But only ONE file should hold the implementation. - * - * #define RAYMATH_STATIC_INLINE - * Define static inline functions code, so #include header suffices for use. - * This may use up lots of memory. - * - * - * LICENSE: zlib/libpng - * - * Copyright (c) 2015-2023 Ramon Santamaria (@raysan5) - * - * This software is provided "as-is", without any express or implied warranty. In no event - * will the authors be held liable for any damages arising from the use of this software. - * - * Permission is granted to anyone to use this software for any purpose, including commercial - * applications, and to alter it and redistribute it freely, subject to the following restrictions: - * - * 1. The origin of this software must not be misrepresented; you must not claim that you - * wrote the original software. If you use this software in a product, an acknowledgment - * in the product documentation would be appreciated but is not required. - * - * 2. Altered source versions must be plainly marked as such, and must not be misrepresented - * as being the original software. - * - * 3. This notice may not be removed or altered from any source distribution. - * - **********************************************************************************************/ +* +* raymath v1.5 - Math functions to work with RL_Vector2, RL_Vector3, RL_Matrix and Quaternions +* +* CONVENTIONS: +* - RL_Matrix structure is defined as row-major (memory layout) but parameters naming AND all +* math operations performed by the library consider the structure as it was column-major +* It is like transposed versions of the matrices are used for all the maths +* It benefits some functions making them cache-friendly and also avoids matrix +* transpositions sometimes required by OpenGL +* Example: In memory order, row0 is [m0 m4 m8 m12] but in semantic math row0 is [m0 m1 m2 m3] +* - Functions are always self-contained, no function use another raymath function inside, +* required code is directly re-implemented inside +* - Functions input parameters are always received by value (2 unavoidable exceptions) +* - Functions use always a "result" variable for return +* - Functions are always defined inline +* - Angles are always in radians (RL_DEG2RAD/RL_RAD2DEG macros provided for convenience) +* - No compound literals used to make sure libray is compatible with C++ +* +* CONFIGURATION: +* #define RAYMATH_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RAYMATH_STATIC_INLINE +* Define static inline functions code, so #include header suffices for use. +* This may use up lots of memory. +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2015-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ #ifndef RAYMATH_H -#define RL_RAYMATH_H +#define RAYMATH_H -#if defined( RAYMATH_IMPLEMENTATION ) && defined( RAYMATH_STATIC_INLINE ) -#error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_STATIC_INLINE is contradictory" +#if defined(RAYMATH_IMPLEMENTATION) && defined(RAYMATH_STATIC_INLINE) + #error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_STATIC_INLINE is contradictory" #endif // Function specifiers definition -#if defined( RAYMATH_IMPLEMENTATION ) -#if defined( _WIN32 ) && defined( BUILD_LIBTYPE_SHARED ) -#define RL_RMAPI __declspec( dllexport ) extern inline // We are building raylib as a Win32 shared library (.dll). -#elif defined( _WIN32 ) && defined( USE_LIBTYPE_SHARED ) -#define RL_RMAPI __declspec( dllimport ) // We are using raylib as a Win32 shared library (.dll) +#if defined(RAYMATH_IMPLEMENTATION) + #if defined(_WIN32) && defined(RL_BUILD_LIBTYPE_SHARED) + #define RMAPI __declspec(dllexport) extern inline // We are building raylib as a Win32 shared library (.dll). + #elif defined(_WIN32) && defined(RL_USE_LIBTYPE_SHARED) + #define RMAPI __declspec(dllimport) // We are using raylib as a Win32 shared library (.dll) + #else + #define RMAPI extern inline // Provide external definition + #endif +#elif defined(RAYMATH_STATIC_INLINE) + #define RMAPI static inline // Functions may be inlined, no external out-of-line definition #else -#define RL_RMAPI extern inline // Provide external definition -#endif -#elif defined( RAYMATH_STATIC_INLINE ) -#define RL_RMAPI static inline // Functions may be inlined, no external out-of-line definition -#else -#if defined( __TINYC__ ) -#define RL_RMAPI static inline // plain inline not supported by tinycc (See issue #435) -#else -#define RL_RMAPI inline // Functions may be inlined or external definition used -#endif + #if defined(__TINYC__) + #define RMAPI static inline // plain inline not supported by tinycc (See issue #435) + #else + #define RMAPI inline // Functions may be inlined or external definition used + #endif #endif //---------------------------------------------------------------------------------- // Defines and Macros //---------------------------------------------------------------------------------- -#ifndef PI -#define RL_PI 3.14159265358979323846f +#ifndef RL_PI + #define RL_PI 3.14159265358979323846f #endif #ifndef EPSILON -#define RL_EPSILON 0.000001f + #define EPSILON 0.000001f #endif -#ifndef DEG2RAD -#define RL_DEG2RAD ( PI / 180.0f ) +#ifndef RL_DEG2RAD + #define RL_DEG2RAD (RL_PI/180.0f) #endif -#ifndef RAD2DEG -#define RL_RAD2DEG ( 180.0f / PI ) +#ifndef RL_RAD2DEG + #define RL_RAD2DEG (180.0f/RL_PI) #endif -// Get float vector for Matrix -#ifndef MatrixToFloat -#define RL_MatrixToFloat( mat ) ( MatrixToFloatV( mat ).v ) +// Get float vector for RL_Matrix +#ifndef RL_MatrixToFloat + #define RL_MatrixToFloat(mat) (RL_MatrixToFloatV(mat).v) #endif -// Get float vector for Vector3 -#ifndef Vector3ToFloat -#define RL_Vector3ToFloat( vec ) ( Vector3ToFloatV( vec ).v ) +// Get float vector for RL_Vector3 +#ifndef RL_Vector3ToFloat + #define RL_Vector3ToFloat(vec) (RL_Vector3ToFloatV(vec).v) #endif //---------------------------------------------------------------------------------- // Types and Structures Definition //---------------------------------------------------------------------------------- -#if ! defined( RL_VECTOR2_TYPE ) -// Vector2 type -typedef struct Vector2 -{ - f32 x; - f32 y; - -} Vector2; +#if !defined(RL_VECTOR2_TYPE) +// RL_Vector2 type +typedef struct RL_Vector2 { + float x; + float y; +} RL_Vector2; +#define RL_VECTOR2_TYPE #endif -#if ! defined( RL_VECTOR3_TYPE ) -// Vector3 type -typedef struct Vector3 -{ - f32 x; - f32 y; - f32 z; - -} Vector3; +#if !defined(RL_VECTOR3_TYPE) +// RL_Vector3 type +typedef struct RL_Vector3 { + float x; + float y; + float z; +} RL_Vector3; +#define RL_VECTOR3_TYPE #endif -#if ! defined( RL_VECTOR4_TYPE ) -// Vector4 type -typedef struct Vector4 -{ - f32 x; - f32 y; - f32 z; - f32 w; - -} Vector4; +#if !defined(RL_VECTOR4_TYPE) +// RL_Vector4 type +typedef struct RL_Vector4 { + float x; + float y; + float z; + float w; +} RL_Vector4; +#define RL_VECTOR4_TYPE #endif -#if ! defined( RL_QUATERNION_TYPE ) -// Quaternion type -typedef Vector4 Quaternion; +#if !defined(RL_QUATERNION_TYPE) +// RL_Quaternion type +typedef RL_Vector4 RL_Quaternion; +#define RL_QUATERNION_TYPE #endif -#if ! defined( RL_MATRIX_TYPE ) -// Matrix type (OpenGL style 4x4 - right handed, column major) -typedef struct Matrix -{ - f32 m0, m4, m8, m12; // Matrix first row (4 components) - f32 m1, m5, m9, m13; // Matrix second row (4 components) - f32 m2, m6, m10, m14; // Matrix third row (4 components) - f32 m3, m7, m11, m15; // Matrix fourth row (4 components) - -} Matrix; +#if !defined(RL_MATRIX_TYPE) +// RL_Matrix type (OpenGL style 4x4 - right handed, column major) +typedef struct RL_Matrix { + float m0, m4, m8, m12; // RL_Matrix first row (4 components) + float m1, m5, m9, m13; // RL_Matrix second row (4 components) + float m2, m6, m10, m14; // RL_Matrix third row (4 components) + float m3, m7, m11, m15; // RL_Matrix fourth row (4 components) +} RL_Matrix; +#define RL_MATRIX_TYPE #endif // NOTE: Helper types to be used instead of array return types for *ToFloat functions -typedef struct float3 -{ - f32 v; +typedef struct RL_float3 { + float v[3]; +} RL_float3; -} float3; +typedef struct RL_float16 { + float v[16]; +} RL_float16; -typedef struct float16 -{ - f32 v; - -} float16; - -#include - -// Required for: sinf(), cosf(), tan(), atan2f(), sqrtf(), floor(), fminf(), fmaxf(), fabs() +#include // Required for: sinf(), cosf(), tan(), atan2f(), sqrtf(), floor(), fminf(), fmaxf(), fabs() //---------------------------------------------------------------------------------- // Module Functions Definition - Utils math //---------------------------------------------------------------------------------- -// Clamp float value -RMAPI float clamp( f32 value, f32 min, f32 max ) +// RL_Clamp float value +RMAPI float RL_Clamp(float value, float min, float max) { - float result = ( value < min ) ? min : value; + float result = (value < min)? min : value; - if ( result > max ) - result = max; + if (result > max) result = max; - return result; + return result; } // Calculate linear interpolation between two floats -RMAPI float lerp( f32 start, f32 end, f32 amount ) +RMAPI float RL_Lerp(float start, float end, float amount) { - float result = start + amount * ( end - start ); + float result = start + amount*(end - start); - return result; + return result; } -// Normalize input value within input range -RMAPI float normalize( f32 value, f32 start, f32 end ) +// RL_Normalize input value within input range +RMAPI float RL_Normalize(float value, float start, float end) { - float result = ( value - start ) / ( end - start ); + float result = (value - start)/(end - start); - return result; + return result; } -// Remap input value within input range to output range -RMAPI float remap( f32 value, f32 inputStart, f32 inputEnd, f32 outputStart, f32 outputEnd ) +// RL_Remap input value within input range to output range +RMAPI float RL_Remap(float value, float inputStart, float inputEnd, float outputStart, float outputEnd) { - float result = ( value - inputStart ) / ( inputEnd - inputStart ) * ( outputEnd - outputStart ) + outputStart; + float result = (value - inputStart)/(inputEnd - inputStart)*(outputEnd - outputStart) + outputStart; - return result; + return result; } -// Wrap input value from min to max -RMAPI float wrap( f32 value, f32 min, f32 max ) +// RL_Wrap input value from min to max +RMAPI float RL_Wrap(float value, float min, float max) { - float result = value - ( max - min ) * floorf( ( value - min ) / ( max - min ) ); + float result = value - (max - min)*floorf((value - min)/(max - min)); - return result; + return result; } // Check whether two given floats are almost equal -RMAPI int float_equals( f32 x, f32 y ) +RMAPI int RL_FloatEquals(float x, float y) { -#if ! defined( EPSILON ) -#define EPSILON 0.000001f +#if !defined(EPSILON) + #define EPSILON 0.000001f #endif - int result = ( fabsf( x - y ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( x ), fabsf( y ) ) ) ); + int result = (fabsf(x - y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(x), fabsf(y)))); - return result; + return result; } //---------------------------------------------------------------------------------- -// Module Functions Definition - Vector2 math +// Module Functions Definition - RL_Vector2 math //---------------------------------------------------------------------------------- // Vector with components value 0.0f -RMAPI Vector2 vector2_zero( void ) +RMAPI RL_Vector2 RL_Vector2Zero(void) { - Vector2 result = { 0.0f, 0.0f }; + RL_Vector2 result = { 0.0f, 0.0f }; - return result; + return result; } // Vector with components value 1.0f -RMAPI Vector2 vector2_one( void ) +RMAPI RL_Vector2 RL_Vector2One(void) { - Vector2 result = { 1.0f, 1.0f }; + RL_Vector2 result = { 1.0f, 1.0f }; - return result; + return result; } // Add two vectors (v1 + v2) -RMAPI Vector2 vector2_add( Vector2 v1, Vector2 v2 ) +RMAPI RL_Vector2 RL_Vector2Add(RL_Vector2 v1, RL_Vector2 v2) { - Vector2 result = { v1.x + v2.x, v1.y + v2.y }; + RL_Vector2 result = { v1.x + v2.x, v1.y + v2.y }; - return result; + return result; } // Add vector and float value -RMAPI Vector2 vector2_add_value( Vector2 v, f32 add ) +RMAPI RL_Vector2 RL_Vector2AddValue(RL_Vector2 v, float add) { - Vector2 result = { v.x + add, v.y + add }; + RL_Vector2 result = { v.x + add, v.y + add }; - return result; + return result; } // Subtract two vectors (v1 - v2) -RMAPI Vector2 vector2_subtract( Vector2 v1, Vector2 v2 ) +RMAPI RL_Vector2 RL_Vector2Subtract(RL_Vector2 v1, RL_Vector2 v2) { - Vector2 result = { v1.x - v2.x, v1.y - v2.y }; + RL_Vector2 result = { v1.x - v2.x, v1.y - v2.y }; - return result; + return result; } // Subtract vector by float value -RMAPI Vector2 vector2_subtract_value( Vector2 v, f32 sub ) +RMAPI RL_Vector2 RL_Vector2SubtractValue(RL_Vector2 v, float sub) { - Vector2 result = { v.x - sub, v.y - sub }; + RL_Vector2 result = { v.x - sub, v.y - sub }; - return result; + return result; } // Calculate vector length -RMAPI float vector2_length( Vector2 v ) +RMAPI float RL_Vector2Length(RL_Vector2 v) { - float result = sqrtf( ( v.x * v.x ) + ( v.y * v.y ) ); + float result = sqrtf((v.x*v.x) + (v.y*v.y)); - return result; + return result; } // Calculate vector square length -RMAPI float vector2_length_sqr( Vector2 v ) +RMAPI float RL_Vector2LengthSqr(RL_Vector2 v) { - float result = ( v.x * v.x ) + ( v.y * v.y ); + float result = (v.x*v.x) + (v.y*v.y); - return result; + return result; } // Calculate two vectors dot product -RMAPI float vector_2dot_product( Vector2 v1, Vector2 v2 ) +RMAPI float RL_Vector2DotProduct(RL_Vector2 v1, RL_Vector2 v2) { - float result = ( v1.x * v2.x + v1.y * v2.y ); + float result = (v1.x*v2.x + v1.y*v2.y); - return result; + return result; } // Calculate distance between two vectors -RMAPI float vector_2distance( Vector2 v1, Vector2 v2 ) +RMAPI float RL_Vector2Distance(RL_Vector2 v1, RL_Vector2 v2) { - float result = sqrtf( ( v1.x - v2.x ) * ( v1.x - v2.x ) + ( v1.y - v2.y ) * ( v1.y - v2.y ) ); + float result = sqrtf((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y)); - return result; + return result; } // Calculate square distance between two vectors -RMAPI float vector_2distance_sqr( Vector2 v1, Vector2 v2 ) +RMAPI float RL_Vector2DistanceSqr(RL_Vector2 v1, RL_Vector2 v2) { - float result = ( ( v1.x - v2.x ) * ( v1.x - v2.x ) + ( v1.y - v2.y ) * ( v1.y - v2.y ) ); + float result = ((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y)); - return result; + return result; } // Calculate angle between two vectors // NOTE: Angle is calculated from origin point (0, 0) -RMAPI float vector2_angle( Vector2 v1, Vector2 v2 ) +RMAPI float RL_Vector2Angle(RL_Vector2 v1, RL_Vector2 v2) { - float result = 0.0f; + float result = 0.0f; - float dot = v1.x * v2.x + v1.y * v2.y; - float det = v1.x * v2.y - v1.y * v2.x; + float dot = v1.x*v2.x + v1.y*v2.y; + float det = v1.x*v2.y - v1.y*v2.x; - result = atan2f( det, dot ); + result = atan2f(det, dot); - return result; + return result; } // Calculate angle defined by a two vectors line // NOTE: Parameters need to be normalized // Current implementation should be aligned with glm::angle -RMAPI float vector2_line_angle( Vector2 start, Vector2 end ) +RMAPI float RL_Vector2LineAngle(RL_Vector2 start, RL_Vector2 end) { - float result = 0.0f; + float result = 0.0f; - // TODO(10/9/2023): Currently angles move clockwise, determine if this is wanted behavior - result = -atan2f( end.y - start.y, end.x - start.x ); + // TODO(10/9/2023): Currently angles move clockwise, determine if this is wanted behavior + result = -atan2f(end.y - start.y, end.x - start.x); - return result; + return result; } // Scale vector (multiply by value) -RMAPI Vector2 vector2_scale( Vector2 v, f32 scale ) +RMAPI RL_Vector2 RL_Vector2Scale(RL_Vector2 v, float scale) { - Vector2 result = { v.x * scale, v.y * scale }; + RL_Vector2 result = { v.x*scale, v.y*scale }; - return result; + return result; } // Multiply vector by vector -RMAPI Vector2 vector2_multiply( Vector2 v1, Vector2 v2 ) +RMAPI RL_Vector2 RL_Vector2Multiply(RL_Vector2 v1, RL_Vector2 v2) { - Vector2 result = { v1.x * v2.x, v1.y * v2.y }; + RL_Vector2 result = { v1.x*v2.x, v1.y*v2.y }; - return result; + return result; } // Negate vector -RMAPI Vector2 vector2_negate( Vector2 v ) +RMAPI RL_Vector2 RL_Vector2Negate(RL_Vector2 v) { - Vector2 result = { -v.x, -v.y }; + RL_Vector2 result = { -v.x, -v.y }; - return result; + return result; } // Divide vector by vector -RMAPI Vector2 vector_2divide( Vector2 v1, Vector2 v2 ) +RMAPI RL_Vector2 RL_Vector2Divide(RL_Vector2 v1, RL_Vector2 v2) { - Vector2 result = { v1.x / v2.x, v1.y / v2.y }; + RL_Vector2 result = { v1.x/v2.x, v1.y/v2.y }; - return result; + return result; } -// Normalize provided vector -RMAPI Vector2 vector2_normalize( Vector2 v ) +// RL_Normalize provided vector +RMAPI RL_Vector2 RL_Vector2Normalize(RL_Vector2 v) { - Vector2 result = { 0 }; - float length = sqrtf( ( v.x * v.x ) + ( v.y * v.y ) ); + RL_Vector2 result = { 0 }; + float length = sqrtf((v.x*v.x) + (v.y*v.y)); - if ( length > 0 ) - { - float ilength = 1.0f / length; - result.x = v.x * ilength; - result.y = v.y * ilength; - } + if (length > 0) + { + float ilength = 1.0f/length; + result.x = v.x*ilength; + result.y = v.y*ilength; + } - return result; + return result; } -// Transforms a Vector2 by a given Matrix -RMAPI Vector2 vector2_transform( Vector2 v, Matrix mat ) +// Transforms a RL_Vector2 by a given RL_Matrix +RMAPI RL_Vector2 RL_Vector2Transform(RL_Vector2 v, RL_Matrix mat) { - Vector2 result = { 0 }; + RL_Vector2 result = { 0 }; - float x = v.x; - float y = v.y; - float z = 0; + float x = v.x; + float y = v.y; + float z = 0; - result.x = mat.m0 * x + mat.m4 * y + mat.m8 * z + mat.m12; - result.y = mat.m1 * x + mat.m5 * y + mat.m9 * z + mat.m13; + result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12; + result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13; - return result; + return result; } // Calculate linear interpolation between two vectors -RMAPI Vector2 vector2_lerp( Vector2 v1, Vector2 v2, f32 amount ) +RMAPI RL_Vector2 RL_Vector2Lerp(RL_Vector2 v1, RL_Vector2 v2, float amount) { - Vector2 result = { 0 }; + RL_Vector2 result = { 0 }; - result.x = v1.x + amount * ( v2.x - v1.x ); - result.y = v1.y + amount * ( v2.y - v1.y ); + result.x = v1.x + amount*(v2.x - v1.x); + result.y = v1.y + amount*(v2.y - v1.y); - return result; + return result; } // Calculate reflected vector to normal -RMAPI Vector2 vector2_reflect( Vector2 v, Vector2 normal ) +RMAPI RL_Vector2 RL_Vector2Reflect(RL_Vector2 v, RL_Vector2 normal) { - Vector2 result = { 0 }; + RL_Vector2 result = { 0 }; - float dotProduct = ( v.x * normal.x + v.y * normal.y ); // Dot product + float dotProduct = (v.x*normal.x + v.y*normal.y); // Dot product - result.x = v.x - ( 2.0f * normal.x ) * dotProduct; - result.y = v.y - ( 2.0f * normal.y ) * dotProduct; + result.x = v.x - (2.0f*normal.x)*dotProduct; + result.y = v.y - (2.0f*normal.y)*dotProduct; - return result; + return result; } // Rotate vector by angle -RMAPI Vector2 vector2_rotate( Vector2 v, f32 angle ) +RMAPI RL_Vector2 RL_Vector2Rotate(RL_Vector2 v, float angle) { - Vector2 result = { 0 }; + RL_Vector2 result = { 0 }; - float cosres = cosf( angle ); - float sinres = sinf( angle ); + float cosres = cosf(angle); + float sinres = sinf(angle); - result.x = v.x * cosres - v.y * sinres; - result.y = v.x * sinres + v.y * cosres; + result.x = v.x*cosres - v.y*sinres; + result.y = v.x*sinres + v.y*cosres; - return result; + return result; } // Move Vector towards target -RMAPI Vector2 vector2_move_towards( Vector2 v, Vector2 target, f32 maxDistance ) +RMAPI RL_Vector2 RL_Vector2MoveTowards(RL_Vector2 v, RL_Vector2 target, float maxDistance) { - Vector2 result = { 0 }; + RL_Vector2 result = { 0 }; - float dx = target.x - v.x; - float dy = target.y - v.y; - float value = ( dx * dx ) + ( dy * dy ); + float dx = target.x - v.x; + float dy = target.y - v.y; + float value = (dx*dx) + (dy*dy); - if ( ( value == 0 ) || ( ( maxDistance >= 0 ) && ( value <= maxDistance * maxDistance ) ) ) - return target; + if ((value == 0) || ((maxDistance >= 0) && (value <= maxDistance*maxDistance))) return target; - float dist = sqrtf( value ); + float dist = sqrtf(value); - result.x = v.x + dx / dist * maxDistance; - result.y = v.y + dy / dist * maxDistance; + result.x = v.x + dx/dist*maxDistance; + result.y = v.y + dy/dist*maxDistance; - return result; + return result; } // Invert the given vector -RMAPI Vector2 vector2_invert( Vector2 v ) +RMAPI RL_Vector2 RL_Vector2Invert(RL_Vector2 v) { - Vector2 result = { 1.0f / v.x, 1.0f / v.y }; + RL_Vector2 result = { 1.0f/v.x, 1.0f/v.y }; - return result; + return result; } -// Clamp the components of the vector between +// RL_Clamp the components of the vector between // min and max values specified by the given vectors -RMAPI Vector2 vector2_clamp( Vector2 v, Vector2 min, Vector2 max ) +RMAPI RL_Vector2 RL_Vector2Clamp(RL_Vector2 v, RL_Vector2 min, RL_Vector2 max) { - Vector2 result = { 0 }; + RL_Vector2 result = { 0 }; - result.x = fminf( max.x, fmaxf( min.x, v.x ) ); - result.y = fminf( max.y, fmaxf( min.y, v.y ) ); + result.x = fminf(max.x, fmaxf(min.x, v.x)); + result.y = fminf(max.y, fmaxf(min.y, v.y)); - return result; + return result; } -// Clamp the magnitude of the vector between two min and max values -RMAPI Vector2 vector2_clamp_value( Vector2 v, f32 min, f32 max ) +// RL_Clamp the magnitude of the vector between two min and max values +RMAPI RL_Vector2 RL_Vector2ClampValue(RL_Vector2 v, float min, float max) { - Vector2 result = v; + RL_Vector2 result = v; - float length = ( v.x * v.x ) + ( v.y * v.y ); - if ( length > 0.0f ) - { - length = sqrtf( length ); + float length = (v.x*v.x) + (v.y*v.y); + if (length > 0.0f) + { + length = sqrtf(length); - if ( length < min ) - { - float scale = min / length; - result.x = v.x * scale; - result.y = v.y * scale; - } - else if ( length > max ) - { - float scale = max / length; - result.x = v.x * scale; - result.y = v.y * scale; - } - } + if (length < min) + { + float scale = min/length; + result.x = v.x*scale; + result.y = v.y*scale; + } + else if (length > max) + { + float scale = max/length; + result.x = v.x*scale; + result.y = v.y*scale; + } + } - return result; + return result; } // Check whether two given vectors are almost equal -RMAPI int vector2_equals( Vector2 p, Vector2 q ) +RMAPI int RL_Vector2Equals(RL_Vector2 p, RL_Vector2 q) { -#if ! defined( EPSILON ) -#define EPSILON 0.000001f +#if !defined(EPSILON) + #define EPSILON 0.000001f #endif - int result = ( ( fabsf( p.x - q.x ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.x ), fabsf( q.x ) ) ) ) ) - && ( ( fabsf( p.y - q.y ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.y ), fabsf( q.y ) ) ) ) ); + int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))); - return result; + return result; } //---------------------------------------------------------------------------------- -// Module Functions Definition - Vector3 math +// Module Functions Definition - RL_Vector3 math //---------------------------------------------------------------------------------- // Vector with components value 0.0f -RMAPI Vector3 vector3_zero( void ) +RMAPI RL_Vector3 RL_Vector3Zero(void) { - Vector3 result = { 0.0f, 0.0f, 0.0f }; + RL_Vector3 result = { 0.0f, 0.0f, 0.0f }; - return result; + return result; } // Vector with components value 1.0f -RMAPI Vector3 vector3_one( void ) +RMAPI RL_Vector3 RL_Vector3One(void) { - Vector3 result = { 1.0f, 1.0f, 1.0f }; + RL_Vector3 result = { 1.0f, 1.0f, 1.0f }; - return result; + return result; } // Add two vectors -RMAPI Vector3 vector3_add( Vector3 v1, Vector3 v2 ) +RMAPI RL_Vector3 RL_Vector3Add(RL_Vector3 v1, RL_Vector3 v2) { - Vector3 result = { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z }; + RL_Vector3 result = { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z }; - return result; + return result; } // Add vector and float value -RMAPI Vector3 vector3_add_value( Vector3 v, f32 add ) +RMAPI RL_Vector3 RL_Vector3AddValue(RL_Vector3 v, float add) { - Vector3 result = { v.x + add, v.y + add, v.z + add }; + RL_Vector3 result = { v.x + add, v.y + add, v.z + add }; - return result; + return result; } // Subtract two vectors -RMAPI Vector3 vector3_subtract( Vector3 v1, Vector3 v2 ) +RMAPI RL_Vector3 RL_Vector3Subtract(RL_Vector3 v1, RL_Vector3 v2) { - Vector3 result = { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z }; + RL_Vector3 result = { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z }; - return result; + return result; } // Subtract vector by float value -RMAPI Vector3 vector3_subtract_value( Vector3 v, f32 sub ) +RMAPI RL_Vector3 RL_Vector3SubtractValue(RL_Vector3 v, float sub) { - Vector3 result = { v.x - sub, v.y - sub, v.z - sub }; + RL_Vector3 result = { v.x - sub, v.y - sub, v.z - sub }; - return result; + return result; } // Multiply vector by scalar -RMAPI Vector3 vector3_scale( Vector3 v, f32 scalar ) +RMAPI RL_Vector3 RL_Vector3Scale(RL_Vector3 v, float scalar) { - Vector3 result = { v.x * scalar, v.y * scalar, v.z * scalar }; + RL_Vector3 result = { v.x*scalar, v.y*scalar, v.z*scalar }; - return result; + return result; } // Multiply vector by vector -RMAPI Vector3 vector3_multiply( Vector3 v1, Vector3 v2 ) +RMAPI RL_Vector3 RL_Vector3Multiply(RL_Vector3 v1, RL_Vector3 v2) { - Vector3 result = { v1.x * v2.x, v1.y * v2.y, v1.z * v2.z }; + RL_Vector3 result = { v1.x*v2.x, v1.y*v2.y, v1.z*v2.z }; - return result; + return result; } // Calculate two vectors cross product -RMAPI Vector3 vector3_cross_product( Vector3 v1, Vector3 v2 ) +RMAPI RL_Vector3 RL_Vector3CrossProduct(RL_Vector3 v1, RL_Vector3 v2) { - Vector3 result = { v1.y * v2.z - v1.z * v2.y, v1.z * v2.x - v1.x * v2.z, v1.x * v2.y - v1.y * v2.x }; + RL_Vector3 result = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x }; - return result; + return result; } // Calculate one vector perpendicular vector -RMAPI Vector3 vector3_perpendicular( Vector3 v ) +RMAPI RL_Vector3 RL_Vector3Perpendicular(RL_Vector3 v) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; - float min = ( float )fabs( v.x ); - Vector3 cardinalAxis = { 1.0f, 0.0f, 0.0f }; + float min = (float) fabs(v.x); + RL_Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f}; - if ( fabsf( v.y ) < min ) - { - min = ( float )fabs( v.y ); - Vector3 tmp = { 0.0f, 1.0f, 0.0f }; - cardinalAxis = tmp; - } + if (fabsf(v.y) < min) + { + min = (float) fabs(v.y); + RL_Vector3 tmp = {0.0f, 1.0f, 0.0f}; + cardinalAxis = tmp; + } - if ( fabsf( v.z ) < min ) - { - Vector3 tmp = { 0.0f, 0.0f, 1.0f }; - cardinalAxis = tmp; - } + if (fabsf(v.z) < min) + { + RL_Vector3 tmp = {0.0f, 0.0f, 1.0f}; + cardinalAxis = tmp; + } - // Cross product between vectors - result.x = v.y * cardinalAxis.z - v.z * cardinalAxis.y; - result.y = v.z * cardinalAxis.x - v.x * cardinalAxis.z; - result.z = v.x * cardinalAxis.y - v.y * cardinalAxis.x; + // Cross product between vectors + result.x = v.y*cardinalAxis.z - v.z*cardinalAxis.y; + result.y = v.z*cardinalAxis.x - v.x*cardinalAxis.z; + result.z = v.x*cardinalAxis.y - v.y*cardinalAxis.x; - return result; + return result; } // Calculate vector length -RMAPI float vector3_length( Vector3 const v ) +RMAPI float RL_Vector3Length(const RL_Vector3 v) { - float result = sqrtf( v.x * v.x + v.y * v.y + v.z * v.z ); + float result = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); - return result; + return result; } // Calculate vector square length -RMAPI float vector3_length_sqr( Vector3 const v ) +RMAPI float RL_Vector3LengthSqr(const RL_Vector3 v) { - float result = v.x * v.x + v.y * v.y + v.z * v.z; + float result = v.x*v.x + v.y*v.y + v.z*v.z; - return result; + return result; } // Calculate two vectors dot product -RMAPI float vector_3dot_product( Vector3 v1, Vector3 v2 ) +RMAPI float RL_Vector3DotProduct(RL_Vector3 v1, RL_Vector3 v2) { - float result = ( v1.x * v2.x + v1.y * v2.y + v1.z * v2.z ); + float result = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); - return result; + return result; } // Calculate distance between two vectors -RMAPI float vector_3distance( Vector3 v1, Vector3 v2 ) +RMAPI float RL_Vector3Distance(RL_Vector3 v1, RL_Vector3 v2) { - float result = 0.0f; + float result = 0.0f; - float dx = v2.x - v1.x; - float dy = v2.y - v1.y; - float dz = v2.z - v1.z; - result = sqrtf( dx * dx + dy * dy + dz * dz ); + float dx = v2.x - v1.x; + float dy = v2.y - v1.y; + float dz = v2.z - v1.z; + result = sqrtf(dx*dx + dy*dy + dz*dz); - return result; + return result; } // Calculate square distance between two vectors -RMAPI float vector_3distance_sqr( Vector3 v1, Vector3 v2 ) +RMAPI float RL_Vector3DistanceSqr(RL_Vector3 v1, RL_Vector3 v2) { - float result = 0.0f; + float result = 0.0f; - float dx = v2.x - v1.x; - float dy = v2.y - v1.y; - float dz = v2.z - v1.z; - result = dx * dx + dy * dy + dz * dz; + float dx = v2.x - v1.x; + float dy = v2.y - v1.y; + float dz = v2.z - v1.z; + result = dx*dx + dy*dy + dz*dz; - return result; + return result; } // Calculate angle between two vectors -RMAPI float vector3_angle( Vector3 v1, Vector3 v2 ) +RMAPI float RL_Vector3Angle(RL_Vector3 v1, RL_Vector3 v2) { - float result = 0.0f; + float result = 0.0f; - Vector3 cross = { v1.y * v2.z - v1.z * v2.y, v1.z * v2.x - v1.x * v2.z, v1.x * v2.y - v1.y * v2.x }; - float len = sqrtf( cross.x * cross.x + cross.y * cross.y + cross.z * cross.z ); - float dot = ( v1.x * v2.x + v1.y * v2.y + v1.z * v2.z ); - result = atan2f( len, dot ); + RL_Vector3 cross = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x }; + float len = sqrtf(cross.x*cross.x + cross.y*cross.y + cross.z*cross.z); + float dot = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + result = atan2f(len, dot); - return result; + return result; } // Negate provided vector (invert direction) -RMAPI Vector3 vector3_negate( Vector3 v ) +RMAPI RL_Vector3 RL_Vector3Negate(RL_Vector3 v) { - Vector3 result = { -v.x, -v.y, -v.z }; + RL_Vector3 result = { -v.x, -v.y, -v.z }; - return result; + return result; } // Divide vector by vector -RMAPI Vector3 vector_3divide( Vector3 v1, Vector3 v2 ) +RMAPI RL_Vector3 RL_Vector3Divide(RL_Vector3 v1, RL_Vector3 v2) { - Vector3 result = { v1.x / v2.x, v1.y / v2.y, v1.z / v2.z }; + RL_Vector3 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z }; - return result; + return result; } -// Normalize provided vector -RMAPI Vector3 vector3_normalize( Vector3 v ) +// RL_Normalize provided vector +RMAPI RL_Vector3 RL_Vector3Normalize(RL_Vector3 v) { - Vector3 result = v; + RL_Vector3 result = v; - float length = sqrtf( v.x * v.x + v.y * v.y + v.z * v.z ); - if ( length != 0.0f ) - { - float ilength = 1.0f / length; + float length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length != 0.0f) + { + float ilength = 1.0f/length; - result.x *= ilength; - result.y *= ilength; - result.z *= ilength; - } + result.x *= ilength; + result.y *= ilength; + result.z *= ilength; + } - return result; + return result; } -// Calculate the projection of the vector v1 on to v2 -RMAPI Vector3 vector3_project( Vector3 v1, Vector3 v2 ) +//Calculate the projection of the vector v1 on to v2 +RMAPI RL_Vector3 RL_Vector3Project(RL_Vector3 v1, RL_Vector3 v2) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; + + float v1dv2 = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + float v2dv2 = (v2.x*v2.x + v2.y*v2.y + v2.z*v2.z); - float v1dv2 = ( v1.x * v2.x + v1.y * v2.y + v1.z * v2.z ); - float v2dv2 = ( v2.x * v2.x + v2.y * v2.y + v2.z * v2.z ); + float mag = v1dv2/v2dv2; - float mag = v1dv2 / v2dv2; + result.x = v2.x*mag; + result.y = v2.y*mag; + result.z = v2.z*mag; - result.x = v2.x * mag; - result.y = v2.y * mag; - result.z = v2.z * mag; - - return result; + return result; } -// Calculate the rejection of the vector v1 on to v2 -RMAPI Vector3 vector3_reject( Vector3 v1, Vector3 v2 ) +//Calculate the rejection of the vector v1 on to v2 +RMAPI RL_Vector3 RL_Vector3Reject(RL_Vector3 v1, RL_Vector3 v2) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; + + float v1dv2 = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); + float v2dv2 = (v2.x*v2.x + v2.y*v2.y + v2.z*v2.z); - float v1dv2 = ( v1.x * v2.x + v1.y * v2.y + v1.z * v2.z ); - float v2dv2 = ( v2.x * v2.x + v2.y * v2.y + v2.z * v2.z ); + float mag = v1dv2/v2dv2; - float mag = v1dv2 / v2dv2; + result.x = v1.x - (v2.x*mag); + result.y = v1.y - (v2.y*mag); + result.z = v1.z - (v2.z*mag); - result.x = v1.x - ( v2.x * mag ); - result.y = v1.y - ( v2.y * mag ); - result.z = v1.z - ( v2.z * mag ); - - return result; + return result; } // Orthonormalize provided vectors // Makes vectors normalized and orthogonal to each other // Gram-Schmidt function implementation -RMAPI void vector3_ortho_normalize( Vector3* v1, Vector3* v2 ) +RMAPI void RL_Vector3OrthoNormalize(RL_Vector3 *v1, RL_Vector3 *v2) { - float length = 0.0f; - float ilength = 0.0f; + float length = 0.0f; + float ilength = 0.0f; - // Vector3Normalize(*v1); - Vector3 v = *v1; - length = sqrtf( v.x * v.x + v.y * v.y + v.z * v.z ); - if ( length == 0.0f ) - length = 1.0f; - ilength = 1.0f / length; - v1->x *= ilength; - v1->y *= ilength; - v1->z *= ilength; + // RL_Vector3Normalize(*v1); + RL_Vector3 v = *v1; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + v1->x *= ilength; + v1->y *= ilength; + v1->z *= ilength; - // Vector3CrossProduct(*v1, *v2) - Vector3 vn1 = { v1->y * v2->z - v1->z * v2->y, v1->z * v2->x - v1->x * v2->z, v1->x * v2->y - v1->y * v2->x }; + // RL_Vector3CrossProduct(*v1, *v2) + RL_Vector3 vn1 = { v1->y*v2->z - v1->z*v2->y, v1->z*v2->x - v1->x*v2->z, v1->x*v2->y - v1->y*v2->x }; - // Vector3Normalize(vn1); - v = vn1; - length = sqrtf( v.x * v.x + v.y * v.y + v.z * v.z ); - if ( length == 0.0f ) - length = 1.0f; - ilength = 1.0f / length; - vn1.x *= ilength; - vn1.y *= ilength; - vn1.z *= ilength; + // RL_Vector3Normalize(vn1); + v = vn1; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + vn1.x *= ilength; + vn1.y *= ilength; + vn1.z *= ilength; - // Vector3CrossProduct(vn1, *v1) - Vector3 vn2 = { vn1.y * v1->z - vn1.z * v1->y, vn1.z * v1->x - vn1.x * v1->z, vn1.x * v1->y - vn1.y * v1->x }; + // RL_Vector3CrossProduct(vn1, *v1) + RL_Vector3 vn2 = { vn1.y*v1->z - vn1.z*v1->y, vn1.z*v1->x - vn1.x*v1->z, vn1.x*v1->y - vn1.y*v1->x }; - *v2 = vn2; + *v2 = vn2; } -// Transforms a Vector3 by a given Matrix -RMAPI Vector3 vector3_transform( Vector3 v, Matrix mat ) +// Transforms a RL_Vector3 by a given RL_Matrix +RMAPI RL_Vector3 RL_Vector3Transform(RL_Vector3 v, RL_Matrix mat) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; - float x = v.x; - float y = v.y; - float z = v.z; + float x = v.x; + float y = v.y; + float z = v.z; - result.x = mat.m0 * x + mat.m4 * y + mat.m8 * z + mat.m12; - result.y = mat.m1 * x + mat.m5 * y + mat.m9 * z + mat.m13; - result.z = mat.m2 * x + mat.m6 * y + mat.m10 * z + mat.m14; + result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12; + result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13; + result.z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14; - return result; + return result; } -// Transform a vector by quaternion rotation -RMAPI Vector3 vector3_rotate_by_quaternion( Vector3 v, Quaternion q ) +// RL_Transform a vector by quaternion rotation +RMAPI RL_Vector3 RL_Vector3RotateByQuaternion(RL_Vector3 v, RL_Quaternion q) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; - result.x = v.x * ( q.x * q.x + q.w * q.w - q.y * q.y - q.z * q.z ) + v.y * ( 2 * q.x * q.y - 2 * q.w * q.z ) + v.z * ( 2 * q.x * q.z + 2 * q.w * q.y ); - result.y = v.x * ( 2 * q.w * q.z + 2 * q.x * q.y ) + v.y * ( q.w * q.w - q.x * q.x + q.y * q.y - q.z * q.z ) + v.z * ( -2 * q.w * q.x + 2 * q.y * q.z ); - result.z = v.x * ( -2 * q.w * q.y + 2 * q.x * q.z ) + v.y * ( 2 * q.w * q.x + 2 * q.y * q.z ) + v.z * ( q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z ); + result.x = v.x*(q.x*q.x + q.w*q.w - q.y*q.y - q.z*q.z) + v.y*(2*q.x*q.y - 2*q.w*q.z) + v.z*(2*q.x*q.z + 2*q.w*q.y); + result.y = v.x*(2*q.w*q.z + 2*q.x*q.y) + v.y*(q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z) + v.z*(-2*q.w*q.x + 2*q.y*q.z); + result.z = v.x*(-2*q.w*q.y + 2*q.x*q.z) + v.y*(2*q.w*q.x + 2*q.y*q.z)+ v.z*(q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z); - return result; + return result; } // Rotates a vector around an axis -RMAPI Vector3 vector3_rotate_by_axis_angle( Vector3 v, Vector3 axis, f32 angle ) +RMAPI RL_Vector3 RL_Vector3RotateByAxisAngle(RL_Vector3 v, RL_Vector3 axis, float angle) { - Vector3 result = v; + // Using Euler-Rodrigues Formula + // Ref.: https://en.wikipedia.org/w/index.php?title=Euler%E2%80%93Rodrigues_formula - // Vector3Normalize(axis); - float length = sqrtf( axis.x * axis.x + axis.y * axis.y + axis.z * axis.z ); - if ( length == 0.0f ) - length = 1.0f; - float ilength = 1.0f / length; - axis.x *= ilength; - axis.y *= ilength; - axis.z *= ilength; + RL_Vector3 result = v; - angle /= 2.0f; - float a = sinf( angle ); - float b = axis.x * a; - float c = axis.y * a; - float d = axis.z * a; - a = cosf( angle ); - Vector3 w = { b, c, d }; + // RL_Vector3Normalize(axis); + float length = sqrtf(axis.x*axis.x + axis.y*axis.y + axis.z*axis.z); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f / length; + axis.x *= ilength; + axis.y *= ilength; + axis.z *= ilength; - // Vector3CrossProduct(w, v) - Vector3 wv = { w.y * v.z - w.z * v.y, w.z * v.x - w.x * v.z, w.x * v.y - w.y * v.x }; + angle /= 2.0f; + float a = sinf(angle); + float b = axis.x*a; + float c = axis.y*a; + float d = axis.z*a; + a = cosf(angle); + RL_Vector3 w = { b, c, d }; - // Vector3CrossProduct(w, wv) - Vector3 wwv = { w.y * wv.z - w.z * wv.y, w.z * wv.x - w.x * wv.z, w.x * wv.y - w.y * wv.x }; + // RL_Vector3CrossProduct(w, v) + RL_Vector3 wv = { w.y*v.z - w.z*v.y, w.z*v.x - w.x*v.z, w.x*v.y - w.y*v.x }; - // Vector3Scale(wv, 2*a) - a *= 2; - wv.x *= a; - wv.y *= a; - wv.z *= a; + // RL_Vector3CrossProduct(w, wv) + RL_Vector3 wwv = { w.y*wv.z - w.z*wv.y, w.z*wv.x - w.x*wv.z, w.x*wv.y - w.y*wv.x }; - // Vector3Scale(wwv, 2) - wwv.x *= 2; - wwv.y *= 2; - wwv.z *= 2; + // RL_Vector3Scale(wv, 2*a) + a *= 2; + wv.x *= a; + wv.y *= a; + wv.z *= a; - result.x += wv.x; - result.y += wv.y; - result.z += wv.z; + // RL_Vector3Scale(wwv, 2) + wwv.x *= 2; + wwv.y *= 2; + wwv.z *= 2; - result.x += wwv.x; - result.y += wwv.y; - result.z += wwv.z; + result.x += wv.x; + result.y += wv.y; + result.z += wv.z; - return result; + result.x += wwv.x; + result.y += wwv.y; + result.z += wwv.z; + + return result; } // Calculate linear interpolation between two vectors -RMAPI Vector3 vector3_lerp( Vector3 v1, Vector3 v2, f32 amount ) +RMAPI RL_Vector3 RL_Vector3Lerp(RL_Vector3 v1, RL_Vector3 v2, float amount) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; - result.x = v1.x + amount * ( v2.x - v1.x ); - result.y = v1.y + amount * ( v2.y - v1.y ); - result.z = v1.z + amount * ( v2.z - v1.z ); + result.x = v1.x + amount*(v2.x - v1.x); + result.y = v1.y + amount*(v2.y - v1.y); + result.z = v1.z + amount*(v2.z - v1.z); - return result; + return result; } // Calculate reflected vector to normal -RMAPI Vector3 vector3_reflect( Vector3 v, Vector3 normal ) +RMAPI RL_Vector3 RL_Vector3Reflect(RL_Vector3 v, RL_Vector3 normal) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; - // I is the original vector - // N is the normal of the incident plane - // R = I - (2*N*(DotProduct[I, N])) + // I is the original vector + // N is the normal of the incident plane + // R = I - (2*N*(DotProduct[I, N])) - float dotProduct = ( v.x * normal.x + v.y * normal.y + v.z * normal.z ); + float dotProduct = (v.x*normal.x + v.y*normal.y + v.z*normal.z); - result.x = v.x - ( 2.0f * normal.x ) * dotProduct; - result.y = v.y - ( 2.0f * normal.y ) * dotProduct; - result.z = v.z - ( 2.0f * normal.z ) * dotProduct; + result.x = v.x - (2.0f*normal.x)*dotProduct; + result.y = v.y - (2.0f*normal.y)*dotProduct; + result.z = v.z - (2.0f*normal.z)*dotProduct; - return result; + return result; } // Get min value for each pair of components -RMAPI Vector3 vector3_min( Vector3 v1, Vector3 v2 ) +RMAPI RL_Vector3 RL_Vector3Min(RL_Vector3 v1, RL_Vector3 v2) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; - result.x = fminf( v1.x, v2.x ); - result.y = fminf( v1.y, v2.y ); - result.z = fminf( v1.z, v2.z ); + result.x = fminf(v1.x, v2.x); + result.y = fminf(v1.y, v2.y); + result.z = fminf(v1.z, v2.z); - return result; + return result; } // Get max value for each pair of components -RMAPI Vector3 vector3_max( Vector3 v1, Vector3 v2 ) +RMAPI RL_Vector3 RL_Vector3Max(RL_Vector3 v1, RL_Vector3 v2) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; - result.x = fmaxf( v1.x, v2.x ); - result.y = fmaxf( v1.y, v2.y ); - result.z = fmaxf( v1.z, v2.z ); + result.x = fmaxf(v1.x, v2.x); + result.y = fmaxf(v1.y, v2.y); + result.z = fmaxf(v1.z, v2.z); - return result; + return result; } // Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c) // NOTE: Assumes P is on the plane of the triangle -RMAPI Vector3 vector3_barycenter( Vector3 p, Vector3 a, Vector3 b, Vector3 c ) +RMAPI RL_Vector3 RL_Vector3Barycenter(RL_Vector3 p, RL_Vector3 a, RL_Vector3 b, RL_Vector3 c) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; - Vector3 v0 = { b.x - a.x, b.y - a.y, b.z - a.z }; // Vector3Subtract(b, a) - Vector3 v1 = { c.x - a.x, c.y - a.y, c.z - a.z }; // Vector3Subtract(c, a) - Vector3 v2 = { p.x - a.x, p.y - a.y, p.z - a.z }; // Vector3Subtract(p, a) - float d00 = ( v0.x * v0.x + v0.y * v0.y + v0.z * v0.z ); // Vector3DotProduct(v0, v0) - float d01 = ( v0.x * v1.x + v0.y * v1.y + v0.z * v1.z ); // Vector3DotProduct(v0, v1) - float d11 = ( v1.x * v1.x + v1.y * v1.y + v1.z * v1.z ); // Vector3DotProduct(v1, v1) - float d20 = ( v2.x * v0.x + v2.y * v0.y + v2.z * v0.z ); // Vector3DotProduct(v2, v0) - float d21 = ( v2.x * v1.x + v2.y * v1.y + v2.z * v1.z ); // Vector3DotProduct(v2, v1) + RL_Vector3 v0 = { b.x - a.x, b.y - a.y, b.z - a.z }; // RL_Vector3Subtract(b, a) + RL_Vector3 v1 = { c.x - a.x, c.y - a.y, c.z - a.z }; // RL_Vector3Subtract(c, a) + RL_Vector3 v2 = { p.x - a.x, p.y - a.y, p.z - a.z }; // RL_Vector3Subtract(p, a) + float d00 = (v0.x*v0.x + v0.y*v0.y + v0.z*v0.z); // RL_Vector3DotProduct(v0, v0) + float d01 = (v0.x*v1.x + v0.y*v1.y + v0.z*v1.z); // RL_Vector3DotProduct(v0, v1) + float d11 = (v1.x*v1.x + v1.y*v1.y + v1.z*v1.z); // RL_Vector3DotProduct(v1, v1) + float d20 = (v2.x*v0.x + v2.y*v0.y + v2.z*v0.z); // RL_Vector3DotProduct(v2, v0) + float d21 = (v2.x*v1.x + v2.y*v1.y + v2.z*v1.z); // RL_Vector3DotProduct(v2, v1) - float denom = d00 * d11 - d01 * d01; + float denom = d00*d11 - d01*d01; - result.y = ( d11 * d20 - d01 * d21 ) / denom; - result.z = ( d00 * d21 - d01 * d20 ) / denom; - result.x = 1.0f - ( result.z + result.y ); + result.y = (d11*d20 - d01*d21)/denom; + result.z = (d00*d21 - d01*d20)/denom; + result.x = 1.0f - (result.z + result.y); - return result; + return result; } -// Projects a Vector3 from screen space into object space +// Projects a RL_Vector3 from screen space into object space // NOTE: We are avoiding calling other raymath functions despite available -RMAPI Vector3 vector3_unproject( Vector3 source, Matrix projection, Matrix view ) +RMAPI RL_Vector3 RL_Vector3Unproject(RL_Vector3 source, RL_Matrix projection, RL_Matrix view) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; - // Calculate unprojected matrix (multiply view matrix by projection matrix) and invert it - Matrix matViewProj = { // MatrixMultiply(view, projection); - view.m0 * projection.m0 + view.m1 * projection.m4 + view.m2 * projection.m8 + view.m3 * projection.m12, - view.m0 * projection.m1 + view.m1 * projection.m5 + view.m2 * projection.m9 + view.m3 * projection.m13, - view.m0 * projection.m2 + view.m1 * projection.m6 + view.m2 * projection.m10 + view.m3 * projection.m14, - view.m0 * projection.m3 + view.m1 * projection.m7 + view.m2 * projection.m11 + view.m3 * projection.m15, - view.m4 * projection.m0 + view.m5 * projection.m4 + view.m6 * projection.m8 + view.m7 * projection.m12, - view.m4 * projection.m1 + view.m5 * projection.m5 + view.m6 * projection.m9 + view.m7 * projection.m13, - view.m4 * projection.m2 + view.m5 * projection.m6 + view.m6 * projection.m10 + view.m7 * projection.m14, - view.m4 * projection.m3 + view.m5 * projection.m7 + view.m6 * projection.m11 + view.m7 * projection.m15, - view.m8 * projection.m0 + view.m9 * projection.m4 + view.m10 * projection.m8 + view.m11 * projection.m12, - view.m8 * projection.m1 + view.m9 * projection.m5 + view.m10 * projection.m9 + view.m11 * projection.m13, - view.m8 * projection.m2 + view.m9 * projection.m6 + view.m10 * projection.m10 + view.m11 * projection.m14, - view.m8 * projection.m3 + view.m9 * projection.m7 + view.m10 * projection.m11 + view.m11 * projection.m15, - view.m12 * projection.m0 + view.m13 * projection.m4 + view.m14 * projection.m8 + view.m15 * projection.m12, - view.m12 * projection.m1 + view.m13 * projection.m5 + view.m14 * projection.m9 + view.m15 * projection.m13, - view.m12 * projection.m2 + view.m13 * projection.m6 + view.m14 * projection.m10 + view.m15 * projection.m14, - view.m12 * projection.m3 + view.m13 * projection.m7 + view.m14 * projection.m11 + view.m15 * projection.m15 - }; + // Calculate unprojected matrix (multiply view matrix by projection matrix) and invert it + RL_Matrix matViewProj = { // RL_MatrixMultiply(view, projection); + view.m0*projection.m0 + view.m1*projection.m4 + view.m2*projection.m8 + view.m3*projection.m12, + view.m0*projection.m1 + view.m1*projection.m5 + view.m2*projection.m9 + view.m3*projection.m13, + view.m0*projection.m2 + view.m1*projection.m6 + view.m2*projection.m10 + view.m3*projection.m14, + view.m0*projection.m3 + view.m1*projection.m7 + view.m2*projection.m11 + view.m3*projection.m15, + view.m4*projection.m0 + view.m5*projection.m4 + view.m6*projection.m8 + view.m7*projection.m12, + view.m4*projection.m1 + view.m5*projection.m5 + view.m6*projection.m9 + view.m7*projection.m13, + view.m4*projection.m2 + view.m5*projection.m6 + view.m6*projection.m10 + view.m7*projection.m14, + view.m4*projection.m3 + view.m5*projection.m7 + view.m6*projection.m11 + view.m7*projection.m15, + view.m8*projection.m0 + view.m9*projection.m4 + view.m10*projection.m8 + view.m11*projection.m12, + view.m8*projection.m1 + view.m9*projection.m5 + view.m10*projection.m9 + view.m11*projection.m13, + view.m8*projection.m2 + view.m9*projection.m6 + view.m10*projection.m10 + view.m11*projection.m14, + view.m8*projection.m3 + view.m9*projection.m7 + view.m10*projection.m11 + view.m11*projection.m15, + view.m12*projection.m0 + view.m13*projection.m4 + view.m14*projection.m8 + view.m15*projection.m12, + view.m12*projection.m1 + view.m13*projection.m5 + view.m14*projection.m9 + view.m15*projection.m13, + view.m12*projection.m2 + view.m13*projection.m6 + view.m14*projection.m10 + view.m15*projection.m14, + view.m12*projection.m3 + view.m13*projection.m7 + view.m14*projection.m11 + view.m15*projection.m15 }; - // Calculate inverted matrix -> MatrixInvert(matViewProj); - // Cache the matrix values (speed optimization) - float a00 = matViewProj.m0, a01 = matViewProj.m1, a02 = matViewProj.m2, a03 = matViewProj.m3; - float a10 = matViewProj.m4, a11 = matViewProj.m5, a12 = matViewProj.m6, a13 = matViewProj.m7; - float a20 = matViewProj.m8, a21 = matViewProj.m9, a22 = matViewProj.m10, a23 = matViewProj.m11; - float a30 = matViewProj.m12, a31 = matViewProj.m13, a32 = matViewProj.m14, a33 = matViewProj.m15; + // Calculate inverted matrix -> RL_MatrixInvert(matViewProj); + // Cache the matrix values (speed optimization) + float a00 = matViewProj.m0, a01 = matViewProj.m1, a02 = matViewProj.m2, a03 = matViewProj.m3; + float a10 = matViewProj.m4, a11 = matViewProj.m5, a12 = matViewProj.m6, a13 = matViewProj.m7; + float a20 = matViewProj.m8, a21 = matViewProj.m9, a22 = matViewProj.m10, a23 = matViewProj.m11; + float a30 = matViewProj.m12, a31 = matViewProj.m13, a32 = matViewProj.m14, a33 = matViewProj.m15; - float b00 = a00 * a11 - a01 * a10; - float b01 = a00 * a12 - a02 * a10; - float b02 = a00 * a13 - a03 * a10; - float b03 = a01 * a12 - a02 * a11; - float b04 = a01 * a13 - a03 * a11; - float b05 = a02 * a13 - a03 * a12; - float b06 = a20 * a31 - a21 * a30; - float b07 = a20 * a32 - a22 * a30; - float b08 = a20 * a33 - a23 * a30; - float b09 = a21 * a32 - a22 * a31; - float b10 = a21 * a33 - a23 * a31; - float b11 = a22 * a33 - a23 * a32; + float b00 = a00*a11 - a01*a10; + float b01 = a00*a12 - a02*a10; + float b02 = a00*a13 - a03*a10; + float b03 = a01*a12 - a02*a11; + float b04 = a01*a13 - a03*a11; + float b05 = a02*a13 - a03*a12; + float b06 = a20*a31 - a21*a30; + float b07 = a20*a32 - a22*a30; + float b08 = a20*a33 - a23*a30; + float b09 = a21*a32 - a22*a31; + float b10 = a21*a33 - a23*a31; + float b11 = a22*a33 - a23*a32; - // Calculate the invert determinant (inlined to avoid double-caching) - float invDet = 1.0f / ( b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06 ); + // Calculate the invert determinant (inlined to avoid double-caching) + float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); - Matrix matViewProjInv = { ( a11 * b11 - a12 * b10 + a13 * b09 ) * invDet, ( -a01 * b11 + a02 * b10 - a03 * b09 ) * invDet, - ( a31 * b05 - a32 * b04 + a33 * b03 ) * invDet, ( -a21 * b05 + a22 * b04 - a23 * b03 ) * invDet, - ( -a10 * b11 + a12 * b08 - a13 * b07 ) * invDet, ( a00 * b11 - a02 * b08 + a03 * b07 ) * invDet, - ( -a30 * b05 + a32 * b02 - a33 * b01 ) * invDet, ( a20 * b05 - a22 * b02 + a23 * b01 ) * invDet, - ( a10 * b10 - a11 * b08 + a13 * b06 ) * invDet, ( -a00 * b10 + a01 * b08 - a03 * b06 ) * invDet, - ( a30 * b04 - a31 * b02 + a33 * b00 ) * invDet, ( -a20 * b04 + a21 * b02 - a23 * b00 ) * invDet, - ( -a10 * b09 + a11 * b07 - a12 * b06 ) * invDet, ( a00 * b09 - a01 * b07 + a02 * b06 ) * invDet, - ( -a30 * b03 + a31 * b01 - a32 * b00 ) * invDet, ( a20 * b03 - a21 * b01 + a22 * b00 ) * invDet }; + RL_Matrix matViewProjInv = { + (a11*b11 - a12*b10 + a13*b09)*invDet, + (-a01*b11 + a02*b10 - a03*b09)*invDet, + (a31*b05 - a32*b04 + a33*b03)*invDet, + (-a21*b05 + a22*b04 - a23*b03)*invDet, + (-a10*b11 + a12*b08 - a13*b07)*invDet, + (a00*b11 - a02*b08 + a03*b07)*invDet, + (-a30*b05 + a32*b02 - a33*b01)*invDet, + (a20*b05 - a22*b02 + a23*b01)*invDet, + (a10*b10 - a11*b08 + a13*b06)*invDet, + (-a00*b10 + a01*b08 - a03*b06)*invDet, + (a30*b04 - a31*b02 + a33*b00)*invDet, + (-a20*b04 + a21*b02 - a23*b00)*invDet, + (-a10*b09 + a11*b07 - a12*b06)*invDet, + (a00*b09 - a01*b07 + a02*b06)*invDet, + (-a30*b03 + a31*b01 - a32*b00)*invDet, + (a20*b03 - a21*b01 + a22*b00)*invDet }; - // Create quaternion from source point - Quaternion quat = { source.x, source.y, source.z, 1.0f }; + // Create quaternion from source point + RL_Quaternion quat = { source.x, source.y, source.z, 1.0f }; - // Multiply quat point by unprojecte matrix - Quaternion qtransformed = { // QuaternionTransform(quat, matViewProjInv) - matViewProjInv.m0 * quat.x + matViewProjInv.m4 * quat.y + matViewProjInv.m8 * quat.z + matViewProjInv.m12 * quat.w, - matViewProjInv.m1 * quat.x + matViewProjInv.m5 * quat.y + matViewProjInv.m9 * quat.z + matViewProjInv.m13 * quat.w, - matViewProjInv.m2 * quat.x + matViewProjInv.m6 * quat.y + matViewProjInv.m10 * quat.z + matViewProjInv.m14 * quat.w, - matViewProjInv.m3 * quat.x + matViewProjInv.m7 * quat.y + matViewProjInv.m11 * quat.z + matViewProjInv.m15 * quat.w - }; + // Multiply quat point by unprojecte matrix + RL_Quaternion qtransformed = { // RL_QuaternionTransform(quat, matViewProjInv) + matViewProjInv.m0*quat.x + matViewProjInv.m4*quat.y + matViewProjInv.m8*quat.z + matViewProjInv.m12*quat.w, + matViewProjInv.m1*quat.x + matViewProjInv.m5*quat.y + matViewProjInv.m9*quat.z + matViewProjInv.m13*quat.w, + matViewProjInv.m2*quat.x + matViewProjInv.m6*quat.y + matViewProjInv.m10*quat.z + matViewProjInv.m14*quat.w, + matViewProjInv.m3*quat.x + matViewProjInv.m7*quat.y + matViewProjInv.m11*quat.z + matViewProjInv.m15*quat.w }; - // Normalized world points in vectors - result.x = qtransformed.x / qtransformed.w; - result.y = qtransformed.y / qtransformed.w; - result.z = qtransformed.z / qtransformed.w; + // Normalized world points in vectors + result.x = qtransformed.x/qtransformed.w; + result.y = qtransformed.y/qtransformed.w; + result.z = qtransformed.z/qtransformed.w; - return result; + return result; } -// Get Vector3 as float array -RMAPI float3 vector3_to_float_v( Vector3 v ) +// Get RL_Vector3 as float array +RMAPI RL_float3 RL_Vector3ToFloatV(RL_Vector3 v) { - float3 buffer = { 0 }; + RL_float3 buffer = { 0 }; - buffer.v[ 0 ] = v.x; - buffer.v[ 1 ] = v.y; - buffer.v[ 2 ] = v.z; + buffer.v[0] = v.x; + buffer.v[1] = v.y; + buffer.v[2] = v.z; - return buffer; + return buffer; } // Invert the given vector -RMAPI Vector3 vector3_invert( Vector3 v ) +RMAPI RL_Vector3 RL_Vector3Invert(RL_Vector3 v) { - Vector3 result = { 1.0f / v.x, 1.0f / v.y, 1.0f / v.z }; + RL_Vector3 result = { 1.0f/v.x, 1.0f/v.y, 1.0f/v.z }; - return result; + return result; } -// Clamp the components of the vector between +// RL_Clamp the components of the vector between // min and max values specified by the given vectors -RMAPI Vector3 vector3_clamp( Vector3 v, Vector3 min, Vector3 max ) +RMAPI RL_Vector3 RL_Vector3Clamp(RL_Vector3 v, RL_Vector3 min, RL_Vector3 max) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; - result.x = fminf( max.x, fmaxf( min.x, v.x ) ); - result.y = fminf( max.y, fmaxf( min.y, v.y ) ); - result.z = fminf( max.z, fmaxf( min.z, v.z ) ); + result.x = fminf(max.x, fmaxf(min.x, v.x)); + result.y = fminf(max.y, fmaxf(min.y, v.y)); + result.z = fminf(max.z, fmaxf(min.z, v.z)); - return result; + return result; } -// Clamp the magnitude of the vector between two values -RMAPI Vector3 vector3_clamp_value( Vector3 v, f32 min, f32 max ) +// RL_Clamp the magnitude of the vector between two values +RMAPI RL_Vector3 RL_Vector3ClampValue(RL_Vector3 v, float min, float max) { - Vector3 result = v; + RL_Vector3 result = v; - float length = ( v.x * v.x ) + ( v.y * v.y ) + ( v.z * v.z ); - if ( length > 0.0f ) - { - length = sqrtf( length ); + float length = (v.x*v.x) + (v.y*v.y) + (v.z*v.z); + if (length > 0.0f) + { + length = sqrtf(length); - if ( length < min ) - { - float scale = min / length; - result.x = v.x * scale; - result.y = v.y * scale; - result.z = v.z * scale; - } - else if ( length > max ) - { - float scale = max / length; - result.x = v.x * scale; - result.y = v.y * scale; - result.z = v.z * scale; - } - } + if (length < min) + { + float scale = min/length; + result.x = v.x*scale; + result.y = v.y*scale; + result.z = v.z*scale; + } + else if (length > max) + { + float scale = max/length; + result.x = v.x*scale; + result.y = v.y*scale; + result.z = v.z*scale; + } + } - return result; + return result; } // Check whether two given vectors are almost equal -RMAPI int vector3_equals( Vector3 p, Vector3 q ) +RMAPI int RL_Vector3Equals(RL_Vector3 p, RL_Vector3 q) { -#if ! defined( EPSILON ) -#define EPSILON 0.000001f +#if !defined(EPSILON) + #define EPSILON 0.000001f #endif - int result = ( ( fabsf( p.x - q.x ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.x ), fabsf( q.x ) ) ) ) ) - && ( ( fabsf( p.y - q.y ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.y ), fabsf( q.y ) ) ) ) ) - && ( ( fabsf( p.z - q.z ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.z ), fabsf( q.z ) ) ) ) ); + int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && + ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))); - return result; + return result; } // Compute the direction of a refracted ray @@ -1120,1062 +1116,1075 @@ RMAPI int vector3_equals( Vector3 p, Vector3 q ) // n: normalized normal vector of the interface of two optical media // r: ratio of the refractive index of the medium from where the ray comes // to the refractive index of the medium on the other side of the surface -RMAPI Vector3 vector3_refract( Vector3 v, Vector3 n, f32 r ) +RMAPI RL_Vector3 RL_Vector3Refract(RL_Vector3 v, RL_Vector3 n, float r) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; - float dot = v.x * n.x + v.y * n.y + v.z * n.z; - float d = 1.0f - r * r * ( 1.0f - dot * dot ); + float dot = v.x*n.x + v.y*n.y + v.z*n.z; + float d = 1.0f - r*r*(1.0f - dot*dot); - if ( d >= 0.0f ) - { - d = sqrtf( d ); - v.x = r * v.x - ( r * dot + d ) * n.x; - v.y = r * v.y - ( r * dot + d ) * n.y; - v.z = r * v.z - ( r * dot + d ) * n.z; + if (d >= 0.0f) + { + d = sqrtf(d); + v.x = r*v.x - (r*dot + d)*n.x; + v.y = r*v.y - (r*dot + d)*n.y; + v.z = r*v.z - (r*dot + d)*n.z; - result = v; - } + result = v; + } - return result; + return result; } //---------------------------------------------------------------------------------- -// Module Functions Definition - Matrix math +// Module Functions Definition - RL_Matrix math //---------------------------------------------------------------------------------- // Compute matrix determinant -RMAPI float matrix_determinant( Matrix mat ) +RMAPI float RL_MatrixDeterminant(RL_Matrix mat) { - float result = 0.0f; + float result = 0.0f; - // Cache the matrix values (speed optimization) - float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; - float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; - float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; - float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; + // Cache the matrix values (speed optimization) + float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; + float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; + float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; + float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; - result = a30 * a21 * a12 * a03 - a20 * a31 * a12 * a03 - a30 * a11 * a22 * a03 + a10 * a31 * a22 * a03 + a20 * a11 * a32 * a03 - a10 * a21 * a32 * a03 - - a30 * a21 * a02 * a13 + a20 * a31 * a02 * a13 + a30 * a01 * a22 * a13 - a00 * a31 * a22 * a13 - a20 * a01 * a32 * a13 + a00 * a21 * a32 * a13 - + a30 * a11 * a02 * a23 - a10 * a31 * a02 * a23 - a30 * a01 * a12 * a23 + a00 * a31 * a12 * a23 + a10 * a01 * a32 * a23 - a00 * a11 * a32 * a23 - - a20 * a11 * a02 * a33 + a10 * a21 * a02 * a33 + a20 * a01 * a12 * a33 - a00 * a21 * a12 * a33 - a10 * a01 * a22 * a33 + a00 * a11 * a22 * a33; + result = a30*a21*a12*a03 - a20*a31*a12*a03 - a30*a11*a22*a03 + a10*a31*a22*a03 + + a20*a11*a32*a03 - a10*a21*a32*a03 - a30*a21*a02*a13 + a20*a31*a02*a13 + + a30*a01*a22*a13 - a00*a31*a22*a13 - a20*a01*a32*a13 + a00*a21*a32*a13 + + a30*a11*a02*a23 - a10*a31*a02*a23 - a30*a01*a12*a23 + a00*a31*a12*a23 + + a10*a01*a32*a23 - a00*a11*a32*a23 - a20*a11*a02*a33 + a10*a21*a02*a33 + + a20*a01*a12*a33 - a00*a21*a12*a33 - a10*a01*a22*a33 + a00*a11*a22*a33; - return result; + return result; } // Get the trace of the matrix (sum of the values along the diagonal) -RMAPI float matrix_trace( Matrix mat ) +RMAPI float RL_MatrixTrace(RL_Matrix mat) { - float result = ( mat.m0 + mat.m5 + mat.m10 + mat.m15 ); + float result = (mat.m0 + mat.m5 + mat.m10 + mat.m15); - return result; + return result; } // Transposes provided matrix -RMAPI Matrix matrix_transpose( Matrix mat ) +RMAPI RL_Matrix RL_MatrixTranspose(RL_Matrix mat) { - Matrix result = { 0 }; + RL_Matrix result = { 0 }; - result.m0 = mat.m0; - result.m1 = mat.m4; - result.m2 = mat.m8; - result.m3 = mat.m12; - result.m4 = mat.m1; - result.m5 = mat.m5; - result.m6 = mat.m9; - result.m7 = mat.m13; - result.m8 = mat.m2; - result.m9 = mat.m6; - result.m10 = mat.m10; - result.m11 = mat.m14; - result.m12 = mat.m3; - result.m13 = mat.m7; - result.m14 = mat.m11; - result.m15 = mat.m15; + result.m0 = mat.m0; + result.m1 = mat.m4; + result.m2 = mat.m8; + result.m3 = mat.m12; + result.m4 = mat.m1; + result.m5 = mat.m5; + result.m6 = mat.m9; + result.m7 = mat.m13; + result.m8 = mat.m2; + result.m9 = mat.m6; + result.m10 = mat.m10; + result.m11 = mat.m14; + result.m12 = mat.m3; + result.m13 = mat.m7; + result.m14 = mat.m11; + result.m15 = mat.m15; - return result; + return result; } // Invert provided matrix -RMAPI Matrix matrix_invert( Matrix mat ) +RMAPI RL_Matrix RL_MatrixInvert(RL_Matrix mat) { - Matrix result = { 0 }; + RL_Matrix result = { 0 }; - // Cache the matrix values (speed optimization) - float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; - float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; - float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; - float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; + // Cache the matrix values (speed optimization) + float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; + float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; + float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; + float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; - float b00 = a00 * a11 - a01 * a10; - float b01 = a00 * a12 - a02 * a10; - float b02 = a00 * a13 - a03 * a10; - float b03 = a01 * a12 - a02 * a11; - float b04 = a01 * a13 - a03 * a11; - float b05 = a02 * a13 - a03 * a12; - float b06 = a20 * a31 - a21 * a30; - float b07 = a20 * a32 - a22 * a30; - float b08 = a20 * a33 - a23 * a30; - float b09 = a21 * a32 - a22 * a31; - float b10 = a21 * a33 - a23 * a31; - float b11 = a22 * a33 - a23 * a32; + float b00 = a00*a11 - a01*a10; + float b01 = a00*a12 - a02*a10; + float b02 = a00*a13 - a03*a10; + float b03 = a01*a12 - a02*a11; + float b04 = a01*a13 - a03*a11; + float b05 = a02*a13 - a03*a12; + float b06 = a20*a31 - a21*a30; + float b07 = a20*a32 - a22*a30; + float b08 = a20*a33 - a23*a30; + float b09 = a21*a32 - a22*a31; + float b10 = a21*a33 - a23*a31; + float b11 = a22*a33 - a23*a32; - // Calculate the invert determinant (inlined to avoid double-caching) - float invDet = 1.0f / ( b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06 ); + // Calculate the invert determinant (inlined to avoid double-caching) + float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); - result.m0 = ( a11 * b11 - a12 * b10 + a13 * b09 ) * invDet; - result.m1 = ( -a01 * b11 + a02 * b10 - a03 * b09 ) * invDet; - result.m2 = ( a31 * b05 - a32 * b04 + a33 * b03 ) * invDet; - result.m3 = ( -a21 * b05 + a22 * b04 - a23 * b03 ) * invDet; - result.m4 = ( -a10 * b11 + a12 * b08 - a13 * b07 ) * invDet; - result.m5 = ( a00 * b11 - a02 * b08 + a03 * b07 ) * invDet; - result.m6 = ( -a30 * b05 + a32 * b02 - a33 * b01 ) * invDet; - result.m7 = ( a20 * b05 - a22 * b02 + a23 * b01 ) * invDet; - result.m8 = ( a10 * b10 - a11 * b08 + a13 * b06 ) * invDet; - result.m9 = ( -a00 * b10 + a01 * b08 - a03 * b06 ) * invDet; - result.m10 = ( a30 * b04 - a31 * b02 + a33 * b00 ) * invDet; - result.m11 = ( -a20 * b04 + a21 * b02 - a23 * b00 ) * invDet; - result.m12 = ( -a10 * b09 + a11 * b07 - a12 * b06 ) * invDet; - result.m13 = ( a00 * b09 - a01 * b07 + a02 * b06 ) * invDet; - result.m14 = ( -a30 * b03 + a31 * b01 - a32 * b00 ) * invDet; - result.m15 = ( a20 * b03 - a21 * b01 + a22 * b00 ) * invDet; + result.m0 = (a11*b11 - a12*b10 + a13*b09)*invDet; + result.m1 = (-a01*b11 + a02*b10 - a03*b09)*invDet; + result.m2 = (a31*b05 - a32*b04 + a33*b03)*invDet; + result.m3 = (-a21*b05 + a22*b04 - a23*b03)*invDet; + result.m4 = (-a10*b11 + a12*b08 - a13*b07)*invDet; + result.m5 = (a00*b11 - a02*b08 + a03*b07)*invDet; + result.m6 = (-a30*b05 + a32*b02 - a33*b01)*invDet; + result.m7 = (a20*b05 - a22*b02 + a23*b01)*invDet; + result.m8 = (a10*b10 - a11*b08 + a13*b06)*invDet; + result.m9 = (-a00*b10 + a01*b08 - a03*b06)*invDet; + result.m10 = (a30*b04 - a31*b02 + a33*b00)*invDet; + result.m11 = (-a20*b04 + a21*b02 - a23*b00)*invDet; + result.m12 = (-a10*b09 + a11*b07 - a12*b06)*invDet; + result.m13 = (a00*b09 - a01*b07 + a02*b06)*invDet; + result.m14 = (-a30*b03 + a31*b01 - a32*b00)*invDet; + result.m15 = (a20*b03 - a21*b01 + a22*b00)*invDet; - return result; + return result; } // Get identity matrix -RMAPI Matrix matrix_identity( void ) +RMAPI RL_Matrix RL_MatrixIdentity(void) { - Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; + RL_Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; - return result; + return result; } // Add two matrices -RMAPI Matrix matrix_add( Matrix left, Matrix right ) +RMAPI RL_Matrix RL_MatrixAdd(RL_Matrix left, RL_Matrix right) { - Matrix result = { 0 }; + RL_Matrix result = { 0 }; - result.m0 = left.m0 + right.m0; - result.m1 = left.m1 + right.m1; - result.m2 = left.m2 + right.m2; - result.m3 = left.m3 + right.m3; - result.m4 = left.m4 + right.m4; - result.m5 = left.m5 + right.m5; - result.m6 = left.m6 + right.m6; - result.m7 = left.m7 + right.m7; - result.m8 = left.m8 + right.m8; - result.m9 = left.m9 + right.m9; - result.m10 = left.m10 + right.m10; - result.m11 = left.m11 + right.m11; - result.m12 = left.m12 + right.m12; - result.m13 = left.m13 + right.m13; - result.m14 = left.m14 + right.m14; - result.m15 = left.m15 + right.m15; + result.m0 = left.m0 + right.m0; + result.m1 = left.m1 + right.m1; + result.m2 = left.m2 + right.m2; + result.m3 = left.m3 + right.m3; + result.m4 = left.m4 + right.m4; + result.m5 = left.m5 + right.m5; + result.m6 = left.m6 + right.m6; + result.m7 = left.m7 + right.m7; + result.m8 = left.m8 + right.m8; + result.m9 = left.m9 + right.m9; + result.m10 = left.m10 + right.m10; + result.m11 = left.m11 + right.m11; + result.m12 = left.m12 + right.m12; + result.m13 = left.m13 + right.m13; + result.m14 = left.m14 + right.m14; + result.m15 = left.m15 + right.m15; - return result; + return result; } // Subtract two matrices (left - right) -RMAPI Matrix matrix_subtract( Matrix left, Matrix right ) +RMAPI RL_Matrix RL_MatrixSubtract(RL_Matrix left, RL_Matrix right) { - Matrix result = { 0 }; + RL_Matrix result = { 0 }; - result.m0 = left.m0 - right.m0; - result.m1 = left.m1 - right.m1; - result.m2 = left.m2 - right.m2; - result.m3 = left.m3 - right.m3; - result.m4 = left.m4 - right.m4; - result.m5 = left.m5 - right.m5; - result.m6 = left.m6 - right.m6; - result.m7 = left.m7 - right.m7; - result.m8 = left.m8 - right.m8; - result.m9 = left.m9 - right.m9; - result.m10 = left.m10 - right.m10; - result.m11 = left.m11 - right.m11; - result.m12 = left.m12 - right.m12; - result.m13 = left.m13 - right.m13; - result.m14 = left.m14 - right.m14; - result.m15 = left.m15 - right.m15; + result.m0 = left.m0 - right.m0; + result.m1 = left.m1 - right.m1; + result.m2 = left.m2 - right.m2; + result.m3 = left.m3 - right.m3; + result.m4 = left.m4 - right.m4; + result.m5 = left.m5 - right.m5; + result.m6 = left.m6 - right.m6; + result.m7 = left.m7 - right.m7; + result.m8 = left.m8 - right.m8; + result.m9 = left.m9 - right.m9; + result.m10 = left.m10 - right.m10; + result.m11 = left.m11 - right.m11; + result.m12 = left.m12 - right.m12; + result.m13 = left.m13 - right.m13; + result.m14 = left.m14 - right.m14; + result.m15 = left.m15 - right.m15; - return result; + return result; } // Get two matrix multiplication // NOTE: When multiplying matrices... the order matters! -RMAPI Matrix matrix_multiply( Matrix left, Matrix right ) +RMAPI RL_Matrix RL_MatrixMultiply(RL_Matrix left, RL_Matrix right) { - Matrix result = { 0 }; + RL_Matrix result = { 0 }; - result.m0 = left.m0 * right.m0 + left.m1 * right.m4 + left.m2 * right.m8 + left.m3 * right.m12; - result.m1 = left.m0 * right.m1 + left.m1 * right.m5 + left.m2 * right.m9 + left.m3 * right.m13; - result.m2 = left.m0 * right.m2 + left.m1 * right.m6 + left.m2 * right.m10 + left.m3 * right.m14; - result.m3 = left.m0 * right.m3 + left.m1 * right.m7 + left.m2 * right.m11 + left.m3 * right.m15; - result.m4 = left.m4 * right.m0 + left.m5 * right.m4 + left.m6 * right.m8 + left.m7 * right.m12; - result.m5 = left.m4 * right.m1 + left.m5 * right.m5 + left.m6 * right.m9 + left.m7 * right.m13; - result.m6 = left.m4 * right.m2 + left.m5 * right.m6 + left.m6 * right.m10 + left.m7 * right.m14; - result.m7 = left.m4 * right.m3 + left.m5 * right.m7 + left.m6 * right.m11 + left.m7 * right.m15; - result.m8 = left.m8 * right.m0 + left.m9 * right.m4 + left.m10 * right.m8 + left.m11 * right.m12; - result.m9 = left.m8 * right.m1 + left.m9 * right.m5 + left.m10 * right.m9 + left.m11 * right.m13; - result.m10 = left.m8 * right.m2 + left.m9 * right.m6 + left.m10 * right.m10 + left.m11 * right.m14; - result.m11 = left.m8 * right.m3 + left.m9 * right.m7 + left.m10 * right.m11 + left.m11 * right.m15; - result.m12 = left.m12 * right.m0 + left.m13 * right.m4 + left.m14 * right.m8 + left.m15 * right.m12; - result.m13 = left.m12 * right.m1 + left.m13 * right.m5 + left.m14 * right.m9 + left.m15 * right.m13; - result.m14 = left.m12 * right.m2 + left.m13 * right.m6 + left.m14 * right.m10 + left.m15 * right.m14; - result.m15 = left.m12 * right.m3 + left.m13 * right.m7 + left.m14 * right.m11 + left.m15 * right.m15; + result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12; + result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13; + result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14; + result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15; + result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12; + result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13; + result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14; + result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15; + result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12; + result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13; + result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14; + result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15; + result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12; + result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13; + result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14; + result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15; - return result; + return result; } // Get translation matrix -RMAPI Matrix matrix_translate( f32 x, f32 y, f32 z ) +RMAPI RL_Matrix RL_MatrixTranslate(float x, float y, float z) { - Matrix result = { 1.0f, 0.0f, 0.0f, x, 0.0f, 1.0f, 0.0f, y, 0.0f, 0.0f, 1.0f, z, 0.0f, 0.0f, 0.0f, 1.0f }; + RL_Matrix result = { 1.0f, 0.0f, 0.0f, x, + 0.0f, 1.0f, 0.0f, y, + 0.0f, 0.0f, 1.0f, z, + 0.0f, 0.0f, 0.0f, 1.0f }; - return result; + return result; } // Create rotation matrix from axis and angle // NOTE: Angle should be provided in radians -RMAPI Matrix matrix_rotate( Vector3 axis, f32 angle ) +RMAPI RL_Matrix RL_MatrixRotate(RL_Vector3 axis, float angle) { - Matrix result = { 0 }; + RL_Matrix result = { 0 }; - float x = axis.x, y = axis.y, z = axis.z; + float x = axis.x, y = axis.y, z = axis.z; - float lengthSquared = x * x + y * y + z * z; + float lengthSquared = x*x + y*y + z*z; - if ( ( lengthSquared != 1.0f ) && ( lengthSquared != 0.0f ) ) - { - float ilength = 1.0f / sqrtf( lengthSquared ); - x *= ilength; - y *= ilength; - z *= ilength; - } + if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f)) + { + float ilength = 1.0f/sqrtf(lengthSquared); + x *= ilength; + y *= ilength; + z *= ilength; + } - float sinres = sinf( angle ); - float cosres = cosf( angle ); - float t = 1.0f - cosres; + float sinres = sinf(angle); + float cosres = cosf(angle); + float t = 1.0f - cosres; - result.m0 = x * x * t + cosres; - result.m1 = y * x * t + z * sinres; - result.m2 = z * x * t - y * sinres; - result.m3 = 0.0f; + result.m0 = x*x*t + cosres; + result.m1 = y*x*t + z*sinres; + result.m2 = z*x*t - y*sinres; + result.m3 = 0.0f; - result.m4 = x * y * t - z * sinres; - result.m5 = y * y * t + cosres; - result.m6 = z * y * t + x * sinres; - result.m7 = 0.0f; + result.m4 = x*y*t - z*sinres; + result.m5 = y*y*t + cosres; + result.m6 = z*y*t + x*sinres; + result.m7 = 0.0f; - result.m8 = x * z * t + y * sinres; - result.m9 = y * z * t - x * sinres; - result.m10 = z * z * t + cosres; - result.m11 = 0.0f; + result.m8 = x*z*t + y*sinres; + result.m9 = y*z*t - x*sinres; + result.m10 = z*z*t + cosres; + result.m11 = 0.0f; - result.m12 = 0.0f; - result.m13 = 0.0f; - result.m14 = 0.0f; - result.m15 = 1.0f; + result.m12 = 0.0f; + result.m13 = 0.0f; + result.m14 = 0.0f; + result.m15 = 1.0f; - return result; + return result; } // Get x-rotation matrix // NOTE: Angle must be provided in radians -RMAPI Matrix matrix_rotate_x( f32 angle ) +RMAPI RL_Matrix RL_MatrixRotateX(float angle) { - Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + RL_Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // RL_MatrixIdentity() - float cosres = cosf( angle ); - float sinres = sinf( angle ); + float cosres = cosf(angle); + float sinres = sinf(angle); - result.m5 = cosres; - result.m6 = sinres; - result.m9 = -sinres; - result.m10 = cosres; + result.m5 = cosres; + result.m6 = sinres; + result.m9 = -sinres; + result.m10 = cosres; - return result; + return result; } // Get y-rotation matrix // NOTE: Angle must be provided in radians -RMAPI Matrix matrix_rotate_y( f32 angle ) +RMAPI RL_Matrix RL_MatrixRotateY(float angle) { - Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + RL_Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // RL_MatrixIdentity() - float cosres = cosf( angle ); - float sinres = sinf( angle ); + float cosres = cosf(angle); + float sinres = sinf(angle); - result.m0 = cosres; - result.m2 = -sinres; - result.m8 = sinres; - result.m10 = cosres; + result.m0 = cosres; + result.m2 = -sinres; + result.m8 = sinres; + result.m10 = cosres; - return result; + return result; } // Get z-rotation matrix // NOTE: Angle must be provided in radians -RMAPI Matrix matrix_rotate_z( f32 angle ) +RMAPI RL_Matrix RL_MatrixRotateZ(float angle) { - Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + RL_Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // RL_MatrixIdentity() - float cosres = cosf( angle ); - float sinres = sinf( angle ); + float cosres = cosf(angle); + float sinres = sinf(angle); - result.m0 = cosres; - result.m1 = sinres; - result.m4 = -sinres; - result.m5 = cosres; + result.m0 = cosres; + result.m1 = sinres; + result.m4 = -sinres; + result.m5 = cosres; - return result; + return result; } + // Get xyz-rotation matrix // NOTE: Angle must be provided in radians -RMAPI Matrix matrix_rotate_xyz( Vector3 angle ) +RMAPI RL_Matrix RL_MatrixRotateXYZ(RL_Vector3 angle) { - Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + RL_Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // RL_MatrixIdentity() - float cosz = cosf( -angle.z ); - float sinz = sinf( -angle.z ); - float cosy = cosf( -angle.y ); - float siny = sinf( -angle.y ); - float cosx = cosf( -angle.x ); - float sinx = sinf( -angle.x ); + float cosz = cosf(-angle.z); + float sinz = sinf(-angle.z); + float cosy = cosf(-angle.y); + float siny = sinf(-angle.y); + float cosx = cosf(-angle.x); + float sinx = sinf(-angle.x); - result.m0 = cosz * cosy; - result.m1 = ( cosz * siny * sinx ) - ( sinz * cosx ); - result.m2 = ( cosz * siny * cosx ) + ( sinz * sinx ); + result.m0 = cosz*cosy; + result.m1 = (cosz*siny*sinx) - (sinz*cosx); + result.m2 = (cosz*siny*cosx) + (sinz*sinx); - result.m4 = sinz * cosy; - result.m5 = ( sinz * siny * sinx ) + ( cosz * cosx ); - result.m6 = ( sinz * siny * cosx ) - ( cosz * sinx ); + result.m4 = sinz*cosy; + result.m5 = (sinz*siny*sinx) + (cosz*cosx); + result.m6 = (sinz*siny*cosx) - (cosz*sinx); - result.m8 = -siny; - result.m9 = cosy * sinx; - result.m10 = cosy * cosx; + result.m8 = -siny; + result.m9 = cosy*sinx; + result.m10= cosy*cosx; - return result; + return result; } // Get zyx-rotation matrix // NOTE: Angle must be provided in radians -RMAPI Matrix matrix_rotate_zyx( Vector3 angle ) +RMAPI RL_Matrix RL_MatrixRotateZYX(RL_Vector3 angle) { - Matrix result = { 0 }; + RL_Matrix result = { 0 }; - float cz = cosf( angle.z ); - float sz = sinf( angle.z ); - float cy = cosf( angle.y ); - float sy = sinf( angle.y ); - float cx = cosf( angle.x ); - float sx = sinf( angle.x ); + float cz = cosf(angle.z); + float sz = sinf(angle.z); + float cy = cosf(angle.y); + float sy = sinf(angle.y); + float cx = cosf(angle.x); + float sx = sinf(angle.x); - result.m0 = cz * cy; - result.m4 = cz * sy * sx - cx * sz; - result.m8 = sz * sx + cz * cx * sy; - result.m12 = 0; + result.m0 = cz*cy; + result.m4 = cz*sy*sx - cx*sz; + result.m8 = sz*sx + cz*cx*sy; + result.m12 = 0; - result.m1 = cy * sz; - result.m5 = cz * cx + sz * sy * sx; - result.m9 = cx * sz * sy - cz * sx; - result.m13 = 0; + result.m1 = cy*sz; + result.m5 = cz*cx + sz*sy*sx; + result.m9 = cx*sz*sy - cz*sx; + result.m13 = 0; - result.m2 = -sy; - result.m6 = cy * sx; - result.m10 = cy * cx; - result.m14 = 0; + result.m2 = -sy; + result.m6 = cy*sx; + result.m10 = cy*cx; + result.m14 = 0; - result.m3 = 0; - result.m7 = 0; - result.m11 = 0; - result.m15 = 1; + result.m3 = 0; + result.m7 = 0; + result.m11 = 0; + result.m15 = 1; - return result; + return result; } // Get scaling matrix -RMAPI Matrix matrix_scale( f32 x, f32 y, f32 z ) +RMAPI RL_Matrix RL_MatrixScale(float x, float y, float z) { - Matrix result = { x, 0.0f, 0.0f, 0.0f, 0.0f, y, 0.0f, 0.0f, 0.0f, 0.0f, z, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; + RL_Matrix result = { x, 0.0f, 0.0f, 0.0f, + 0.0f, y, 0.0f, 0.0f, + 0.0f, 0.0f, z, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; - return result; + return result; } // Get perspective projection matrix -RMAPI Matrix matrix_frustum( double left, double right, double bottom, double top, double near, double far ) +RMAPI RL_Matrix RL_MatrixFrustum(double left, double right, double bottom, double top, double near, double far) { - Matrix result = { 0 }; + RL_Matrix result = { 0 }; - float rl = ( float )( right - left ); - float tb = ( float )( top - bottom ); - float fn = ( float )( far - near ); + float RLGL_ = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(far - near); - result.m0 = ( ( float )near * 2.0f ) / rl; - result.m1 = 0.0f; - result.m2 = 0.0f; - result.m3 = 0.0f; + result.m0 = ((float)near*2.0f)/RLGL_; + result.m1 = 0.0f; + result.m2 = 0.0f; + result.m3 = 0.0f; - result.m4 = 0.0f; - result.m5 = ( ( float )near * 2.0f ) / tb; - result.m6 = 0.0f; - result.m7 = 0.0f; + result.m4 = 0.0f; + result.m5 = ((float)near*2.0f)/tb; + result.m6 = 0.0f; + result.m7 = 0.0f; - result.m8 = ( ( float )right + ( float )left ) / rl; - result.m9 = ( ( float )top + ( float )bottom ) / tb; - result.m10 = -( ( float )far + ( float )near ) / fn; - result.m11 = -1.0f; + result.m8 = ((float)right + (float)left)/RLGL_; + result.m9 = ((float)top + (float)bottom)/tb; + result.m10 = -((float)far + (float)near)/fn; + result.m11 = -1.0f; - result.m12 = 0.0f; - result.m13 = 0.0f; - result.m14 = -( ( float )far * ( float )near * 2.0f ) / fn; - result.m15 = 0.0f; + result.m12 = 0.0f; + result.m13 = 0.0f; + result.m14 = -((float)far*(float)near*2.0f)/fn; + result.m15 = 0.0f; - return result; + return result; } // Get perspective projection matrix // NOTE: Fovy angle must be provided in radians -RMAPI Matrix matrix_perspective( double fovY, double aspect, double nearPlane, double farPlane ) +RMAPI RL_Matrix RL_MatrixPerspective(double fovY, double aspect, double nearPlane, double farPlane) { - Matrix result = { 0 }; + RL_Matrix result = { 0 }; - double top = nearPlane * tan( fovY * 0.5 ); - double bottom = -top; - double right = top * aspect; - double left = -right; + double top = nearPlane*tan(fovY*0.5); + double bottom = -top; + double right = top*aspect; + double left = -right; - // MatrixFrustum(-right, right, -top, top, near, far); - float rl = ( float )( right - left ); - float tb = ( float )( top - bottom ); - float fn = ( float )( farPlane - nearPlane ); + // RL_MatrixFrustum(-right, right, -top, top, near, far); + float RLGL_ = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(farPlane - nearPlane); - result.m0 = ( ( float )nearPlane * 2.0f ) / rl; - result.m5 = ( ( float )nearPlane * 2.0f ) / tb; - result.m8 = ( ( float )right + ( float )left ) / rl; - result.m9 = ( ( float )top + ( float )bottom ) / tb; - result.m10 = -( ( float )farPlane + ( float )nearPlane ) / fn; - result.m11 = -1.0f; - result.m14 = -( ( float )farPlane * ( float )nearPlane * 2.0f ) / fn; + result.m0 = ((float)nearPlane*2.0f)/RLGL_; + result.m5 = ((float)nearPlane*2.0f)/tb; + result.m8 = ((float)right + (float)left)/RLGL_; + result.m9 = ((float)top + (float)bottom)/tb; + result.m10 = -((float)farPlane + (float)nearPlane)/fn; + result.m11 = -1.0f; + result.m14 = -((float)farPlane*(float)nearPlane*2.0f)/fn; - return result; + return result; } // Get orthographic projection matrix -RMAPI Matrix matrix_ortho( double left, double right, double bottom, double top, double nearPlane, double farPlane ) +RMAPI RL_Matrix RL_MatrixOrtho(double left, double right, double bottom, double top, double nearPlane, double farPlane) { - Matrix result = { 0 }; + RL_Matrix result = { 0 }; - float rl = ( float )( right - left ); - float tb = ( float )( top - bottom ); - float fn = ( float )( farPlane - nearPlane ); + float RLGL_ = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(farPlane - nearPlane); - result.m0 = 2.0f / rl; - result.m1 = 0.0f; - result.m2 = 0.0f; - result.m3 = 0.0f; - result.m4 = 0.0f; - result.m5 = 2.0f / tb; - result.m6 = 0.0f; - result.m7 = 0.0f; - result.m8 = 0.0f; - result.m9 = 0.0f; - result.m10 = -2.0f / fn; - result.m11 = 0.0f; - result.m12 = -( ( float )left + ( float )right ) / rl; - result.m13 = -( ( float )top + ( float )bottom ) / tb; - result.m14 = -( ( float )farPlane + ( float )nearPlane ) / fn; - result.m15 = 1.0f; + result.m0 = 2.0f/RLGL_; + result.m1 = 0.0f; + result.m2 = 0.0f; + result.m3 = 0.0f; + result.m4 = 0.0f; + result.m5 = 2.0f/tb; + result.m6 = 0.0f; + result.m7 = 0.0f; + result.m8 = 0.0f; + result.m9 = 0.0f; + result.m10 = -2.0f/fn; + result.m11 = 0.0f; + result.m12 = -((float)left + (float)right)/RLGL_; + result.m13 = -((float)top + (float)bottom)/tb; + result.m14 = -((float)farPlane + (float)nearPlane)/fn; + result.m15 = 1.0f; - return result; + return result; } // Get camera look-at matrix (view matrix) -RMAPI Matrix matrix_look_at( Vector3 eye, Vector3 target, Vector3 up ) +RMAPI RL_Matrix RL_MatrixLookAt(RL_Vector3 eye, RL_Vector3 target, RL_Vector3 up) { - Matrix result = { 0 }; + RL_Matrix result = { 0 }; - float length = 0.0f; - float ilength = 0.0f; + float length = 0.0f; + float ilength = 0.0f; - // Vector3Subtract(eye, target) - Vector3 vz = { eye.x - target.x, eye.y - target.y, eye.z - target.z }; + // RL_Vector3Subtract(eye, target) + RL_Vector3 vz = { eye.x - target.x, eye.y - target.y, eye.z - target.z }; - // Vector3Normalize(vz) - Vector3 v = vz; - length = sqrtf( v.x * v.x + v.y * v.y + v.z * v.z ); - if ( length == 0.0f ) - length = 1.0f; - ilength = 1.0f / length; - vz.x *= ilength; - vz.y *= ilength; - vz.z *= ilength; + // RL_Vector3Normalize(vz) + RL_Vector3 v = vz; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + vz.x *= ilength; + vz.y *= ilength; + vz.z *= ilength; - // Vector3CrossProduct(up, vz) - Vector3 vx = { up.y * vz.z - up.z * vz.y, up.z * vz.x - up.x * vz.z, up.x * vz.y - up.y * vz.x }; + // RL_Vector3CrossProduct(up, vz) + RL_Vector3 vx = { up.y*vz.z - up.z*vz.y, up.z*vz.x - up.x*vz.z, up.x*vz.y - up.y*vz.x }; - // Vector3Normalize(x) - v = vx; - length = sqrtf( v.x * v.x + v.y * v.y + v.z * v.z ); - if ( length == 0.0f ) - length = 1.0f; - ilength = 1.0f / length; - vx.x *= ilength; - vx.y *= ilength; - vx.z *= ilength; + // RL_Vector3Normalize(x) + v = vx; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + vx.x *= ilength; + vx.y *= ilength; + vx.z *= ilength; - // Vector3CrossProduct(vz, vx) - Vector3 vy = { vz.y * vx.z - vz.z * vx.y, vz.z * vx.x - vz.x * vx.z, vz.x * vx.y - vz.y * vx.x }; + // RL_Vector3CrossProduct(vz, vx) + RL_Vector3 vy = { vz.y*vx.z - vz.z*vx.y, vz.z*vx.x - vz.x*vx.z, vz.x*vx.y - vz.y*vx.x }; - result.m0 = vx.x; - result.m1 = vy.x; - result.m2 = vz.x; - result.m3 = 0.0f; - result.m4 = vx.y; - result.m5 = vy.y; - result.m6 = vz.y; - result.m7 = 0.0f; - result.m8 = vx.z; - result.m9 = vy.z; - result.m10 = vz.z; - result.m11 = 0.0f; - result.m12 = -( vx.x * eye.x + vx.y * eye.y + vx.z * eye.z ); // Vector3DotProduct(vx, eye) - result.m13 = -( vy.x * eye.x + vy.y * eye.y + vy.z * eye.z ); // Vector3DotProduct(vy, eye) - result.m14 = -( vz.x * eye.x + vz.y * eye.y + vz.z * eye.z ); // Vector3DotProduct(vz, eye) - result.m15 = 1.0f; + result.m0 = vx.x; + result.m1 = vy.x; + result.m2 = vz.x; + result.m3 = 0.0f; + result.m4 = vx.y; + result.m5 = vy.y; + result.m6 = vz.y; + result.m7 = 0.0f; + result.m8 = vx.z; + result.m9 = vy.z; + result.m10 = vz.z; + result.m11 = 0.0f; + result.m12 = -(vx.x*eye.x + vx.y*eye.y + vx.z*eye.z); // RL_Vector3DotProduct(vx, eye) + result.m13 = -(vy.x*eye.x + vy.y*eye.y + vy.z*eye.z); // RL_Vector3DotProduct(vy, eye) + result.m14 = -(vz.x*eye.x + vz.y*eye.y + vz.z*eye.z); // RL_Vector3DotProduct(vz, eye) + result.m15 = 1.0f; - return result; + return result; } // Get float array of matrix data -RMAPI float16 matrix_to_float_v( Matrix mat ) +RMAPI RL_float16 RL_MatrixToFloatV(RL_Matrix mat) { - float16 result = { 0 }; + RL_float16 result = { 0 }; - result.v[ 0 ] = mat.m0; - result.v[ 1 ] = mat.m1; - result.v[ 2 ] = mat.m2; - result.v[ 3 ] = mat.m3; - result.v[ 4 ] = mat.m4; - result.v[ 5 ] = mat.m5; - result.v[ 6 ] = mat.m6; - result.v[ 7 ] = mat.m7; - result.v[ 8 ] = mat.m8; - result.v[ 9 ] = mat.m9; - result.v[ 10 ] = mat.m10; - result.v[ 11 ] = mat.m11; - result.v[ 12 ] = mat.m12; - result.v[ 13 ] = mat.m13; - result.v[ 14 ] = mat.m14; - result.v[ 15 ] = mat.m15; + result.v[0] = mat.m0; + result.v[1] = mat.m1; + result.v[2] = mat.m2; + result.v[3] = mat.m3; + result.v[4] = mat.m4; + result.v[5] = mat.m5; + result.v[6] = mat.m6; + result.v[7] = mat.m7; + result.v[8] = mat.m8; + result.v[9] = mat.m9; + result.v[10] = mat.m10; + result.v[11] = mat.m11; + result.v[12] = mat.m12; + result.v[13] = mat.m13; + result.v[14] = mat.m14; + result.v[15] = mat.m15; - return result; + return result; } //---------------------------------------------------------------------------------- -// Module Functions Definition - Quaternion math +// Module Functions Definition - RL_Quaternion math //---------------------------------------------------------------------------------- // Add two quaternions -RMAPI Quaternion quaternion_add( Quaternion q1, Quaternion q2 ) +RMAPI RL_Quaternion RL_QuaternionAdd(RL_Quaternion q1, RL_Quaternion q2) { - Quaternion result = { q1.x + q2.x, q1.y + q2.y, q1.z + q2.z, q1.w + q2.w }; + RL_Quaternion result = {q1.x + q2.x, q1.y + q2.y, q1.z + q2.z, q1.w + q2.w}; - return result; + return result; } // Add quaternion and float value -RMAPI Quaternion quaternion_add_value( Quaternion q, f32 add ) +RMAPI RL_Quaternion RL_QuaternionAddValue(RL_Quaternion q, float add) { - Quaternion result = { q.x + add, q.y + add, q.z + add, q.w + add }; + RL_Quaternion result = {q.x + add, q.y + add, q.z + add, q.w + add}; - return result; + return result; } // Subtract two quaternions -RMAPI Quaternion quaternion_subtract( Quaternion q1, Quaternion q2 ) +RMAPI RL_Quaternion RL_QuaternionSubtract(RL_Quaternion q1, RL_Quaternion q2) { - Quaternion result = { q1.x - q2.x, q1.y - q2.y, q1.z - q2.z, q1.w - q2.w }; + RL_Quaternion result = {q1.x - q2.x, q1.y - q2.y, q1.z - q2.z, q1.w - q2.w}; - return result; + return result; } // Subtract quaternion and float value -RMAPI Quaternion quaternion_subtract_value( Quaternion q, f32 sub ) +RMAPI RL_Quaternion RL_QuaternionSubtractValue(RL_Quaternion q, float sub) { - Quaternion result = { q.x - sub, q.y - sub, q.z - sub, q.w - sub }; + RL_Quaternion result = {q.x - sub, q.y - sub, q.z - sub, q.w - sub}; - return result; + return result; } // Get identity quaternion -RMAPI Quaternion quaternion_identity( void ) +RMAPI RL_Quaternion RL_QuaternionIdentity(void) { - Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; + RL_Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; - return result; + return result; } // Computes the length of a quaternion -RMAPI float quaternion_length( Quaternion q ) +RMAPI float RL_QuaternionLength(RL_Quaternion q) { - float result = sqrtf( q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w ); + float result = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); - return result; + return result; } -// Normalize provided quaternion -RMAPI Quaternion quaternion_normalize( Quaternion q ) +// RL_Normalize provided quaternion +RMAPI RL_Quaternion RL_QuaternionNormalize(RL_Quaternion q) { - Quaternion result = { 0 }; + RL_Quaternion result = { 0 }; - float length = sqrtf( q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w ); - if ( length == 0.0f ) - length = 1.0f; - float ilength = 1.0f / length; + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; - result.x = q.x * ilength; - result.y = q.y * ilength; - result.z = q.z * ilength; - result.w = q.w * ilength; + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; - return result; + return result; } // Invert provided quaternion -RMAPI Quaternion quaternion_invert( Quaternion q ) +RMAPI RL_Quaternion RL_QuaternionInvert(RL_Quaternion q) { - Quaternion result = q; + RL_Quaternion result = q; - float lengthSq = q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w; + float lengthSq = q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w; - if ( lengthSq != 0.0f ) - { - float invLength = 1.0f / lengthSq; + if (lengthSq != 0.0f) + { + float invLength = 1.0f/lengthSq; - result.x *= -invLength; - result.y *= -invLength; - result.z *= -invLength; - result.w *= invLength; - } + result.x *= -invLength; + result.y *= -invLength; + result.z *= -invLength; + result.w *= invLength; + } - return result; + return result; } // Calculate two quaternion multiplication -RMAPI Quaternion quaternion_multiply( Quaternion q1, Quaternion q2 ) +RMAPI RL_Quaternion RL_QuaternionMultiply(RL_Quaternion q1, RL_Quaternion q2) { - Quaternion result = { 0 }; + RL_Quaternion result = { 0 }; - float qax = q1.x, qay = q1.y, qaz = q1.z, qaw = q1.w; - float qbx = q2.x, qby = q2.y, qbz = q2.z, qbw = q2.w; + float qax = q1.x, qay = q1.y, qaz = q1.z, qaw = q1.w; + float qbx = q2.x, qby = q2.y, qbz = q2.z, qbw = q2.w; - result.x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby; - result.y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz; - result.z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx; - result.w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz; + result.x = qax*qbw + qaw*qbx + qay*qbz - qaz*qby; + result.y = qay*qbw + qaw*qby + qaz*qbx - qax*qbz; + result.z = qaz*qbw + qaw*qbz + qax*qby - qay*qbx; + result.w = qaw*qbw - qax*qbx - qay*qby - qaz*qbz; - return result; + return result; } // Scale quaternion by float value -RMAPI Quaternion quaternion_scale( Quaternion q, f32 mul ) +RMAPI RL_Quaternion RL_QuaternionScale(RL_Quaternion q, float mul) { - Quaternion result = { 0 }; + RL_Quaternion result = { 0 }; - result.x = q.x * mul; - result.y = q.y * mul; - result.z = q.z * mul; - result.w = q.w * mul; + result.x = q.x*mul; + result.y = q.y*mul; + result.z = q.z*mul; + result.w = q.w*mul; - return result; + return result; } // Divide two quaternions -RMAPI Quaternion quaternion_divide( Quaternion q1, Quaternion q2 ) +RMAPI RL_Quaternion RL_QuaternionDivide(RL_Quaternion q1, RL_Quaternion q2) { - Quaternion result = { q1.x / q2.x, q1.y / q2.y, q1.z / q2.z, q1.w / q2.w }; + RL_Quaternion result = { q1.x/q2.x, q1.y/q2.y, q1.z/q2.z, q1.w/q2.w }; - return result; + return result; } // Calculate linear interpolation between two quaternions -RMAPI Quaternion quaternion_lerp( Quaternion q1, Quaternion q2, f32 amount ) +RMAPI RL_Quaternion RL_QuaternionLerp(RL_Quaternion q1, RL_Quaternion q2, float amount) { - Quaternion result = { 0 }; + RL_Quaternion result = { 0 }; - result.x = q1.x + amount * ( q2.x - q1.x ); - result.y = q1.y + amount * ( q2.y - q1.y ); - result.z = q1.z + amount * ( q2.z - q1.z ); - result.w = q1.w + amount * ( q2.w - q1.w ); + result.x = q1.x + amount*(q2.x - q1.x); + result.y = q1.y + amount*(q2.y - q1.y); + result.z = q1.z + amount*(q2.z - q1.z); + result.w = q1.w + amount*(q2.w - q1.w); - return result; + return result; } // Calculate slerp-optimized interpolation between two quaternions -RMAPI Quaternion quaternion_nlerp( Quaternion q1, Quaternion q2, f32 amount ) +RMAPI RL_Quaternion RL_QuaternionNlerp(RL_Quaternion q1, RL_Quaternion q2, float amount) { - Quaternion result = { 0 }; + RL_Quaternion result = { 0 }; - // QuaternionLerp(q1, q2, amount) - result.x = q1.x + amount * ( q2.x - q1.x ); - result.y = q1.y + amount * ( q2.y - q1.y ); - result.z = q1.z + amount * ( q2.z - q1.z ); - result.w = q1.w + amount * ( q2.w - q1.w ); + // RL_QuaternionLerp(q1, q2, amount) + result.x = q1.x + amount*(q2.x - q1.x); + result.y = q1.y + amount*(q2.y - q1.y); + result.z = q1.z + amount*(q2.z - q1.z); + result.w = q1.w + amount*(q2.w - q1.w); - // QuaternionNormalize(q); - Quaternion q = result; - float length = sqrtf( q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w ); - if ( length == 0.0f ) - length = 1.0f; - float ilength = 1.0f / length; + // RL_QuaternionNormalize(q); + RL_Quaternion q = result; + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; - result.x = q.x * ilength; - result.y = q.y * ilength; - result.z = q.z * ilength; - result.w = q.w * ilength; + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; - return result; + return result; } // Calculates spherical linear interpolation between two quaternions -RMAPI Quaternion quaternion_slerp( Quaternion q1, Quaternion q2, f32 amount ) +RMAPI RL_Quaternion RL_QuaternionSlerp(RL_Quaternion q1, RL_Quaternion q2, float amount) { - Quaternion result = { 0 }; + RL_Quaternion result = { 0 }; -#if ! defined( EPSILON ) -#define EPSILON 0.000001f +#if !defined(EPSILON) + #define EPSILON 0.000001f #endif - float cosHalfTheta = q1.x * q2.x + q1.y * q2.y + q1.z * q2.z + q1.w * q2.w; + float cosHalfTheta = q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w; - if ( cosHalfTheta < 0 ) - { - q2.x = -q2.x; - q2.y = -q2.y; - q2.z = -q2.z; - q2.w = -q2.w; - cosHalfTheta = -cosHalfTheta; - } + if (cosHalfTheta < 0) + { + q2.x = -q2.x; q2.y = -q2.y; q2.z = -q2.z; q2.w = -q2.w; + cosHalfTheta = -cosHalfTheta; + } - if ( fabsf( cosHalfTheta ) >= 1.0f ) - result = q1; - else if ( cosHalfTheta > 0.95f ) - result = QuaternionNlerp( q1, q2, amount ); - else - { - float halfTheta = acosf( cosHalfTheta ); - float sinHalfTheta = sqrtf( 1.0f - cosHalfTheta * cosHalfTheta ); + if (fabsf(cosHalfTheta) >= 1.0f) result = q1; + else if (cosHalfTheta > 0.95f) result = RL_QuaternionNlerp(q1, q2, amount); + else + { + float halfTheta = acosf(cosHalfTheta); + float sinHalfTheta = sqrtf(1.0f - cosHalfTheta*cosHalfTheta); - if ( fabsf( sinHalfTheta ) < EPSILON ) - { - result.x = ( q1.x * 0.5f + q2.x * 0.5f ); - result.y = ( q1.y * 0.5f + q2.y * 0.5f ); - result.z = ( q1.z * 0.5f + q2.z * 0.5f ); - result.w = ( q1.w * 0.5f + q2.w * 0.5f ); - } - else - { - float ratioA = sinf( ( 1 - amount ) * halfTheta ) / sinHalfTheta; - float ratioB = sinf( amount * halfTheta ) / sinHalfTheta; + if (fabsf(sinHalfTheta) < EPSILON) + { + result.x = (q1.x*0.5f + q2.x*0.5f); + result.y = (q1.y*0.5f + q2.y*0.5f); + result.z = (q1.z*0.5f + q2.z*0.5f); + result.w = (q1.w*0.5f + q2.w*0.5f); + } + else + { + float ratioA = sinf((1 - amount)*halfTheta)/sinHalfTheta; + float ratioB = sinf(amount*halfTheta)/sinHalfTheta; - result.x = ( q1.x * ratioA + q2.x * ratioB ); - result.y = ( q1.y * ratioA + q2.y * ratioB ); - result.z = ( q1.z * ratioA + q2.z * ratioB ); - result.w = ( q1.w * ratioA + q2.w * ratioB ); - } - } + result.x = (q1.x*ratioA + q2.x*ratioB); + result.y = (q1.y*ratioA + q2.y*ratioB); + result.z = (q1.z*ratioA + q2.z*ratioB); + result.w = (q1.w*ratioA + q2.w*ratioB); + } + } - return result; + return result; } // Calculate quaternion based on the rotation from one vector to another -RMAPI Quaternion quaternion_from_vector3_to_vector3( Vector3 from, Vector3 to ) +RMAPI RL_Quaternion RL_QuaternionFromVector3ToVector3(RL_Vector3 from, RL_Vector3 to) { - Quaternion result = { 0 }; + RL_Quaternion result = { 0 }; - float cos2Theta = ( from.x * to.x + from.y * to.y + from.z * to.z ); // Vector3DotProduct(from, to) - Vector3 cross = { from.y * to.z - from.z * to.y, from.z * to.x - from.x * to.z, from.x * to.y - from.y * to.x }; // Vector3CrossProduct(from, to) + float cos2Theta = (from.x*to.x + from.y*to.y + from.z*to.z); // RL_Vector3DotProduct(from, to) + RL_Vector3 cross = { from.y*to.z - from.z*to.y, from.z*to.x - from.x*to.z, from.x*to.y - from.y*to.x }; // RL_Vector3CrossProduct(from, to) - result.x = cross.x; - result.y = cross.y; - result.z = cross.z; - result.w = 1.0f + cos2Theta; + result.x = cross.x; + result.y = cross.y; + result.z = cross.z; + result.w = 1.0f + cos2Theta; - // QuaternionNormalize(q); - // NOTE: Normalize to essentially nlerp the original and identity to 0.5 - Quaternion q = result; - float length = sqrtf( q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w ); - if ( length == 0.0f ) - length = 1.0f; - float ilength = 1.0f / length; + // RL_QuaternionNormalize(q); + // NOTE: RL_Normalize to essentially nlerp the original and identity to 0.5 + RL_Quaternion q = result; + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; - result.x = q.x * ilength; - result.y = q.y * ilength; - result.z = q.z * ilength; - result.w = q.w * ilength; + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; - return result; + return result; } // Get a quaternion for a given rotation matrix -RMAPI Quaternion quaternion_from_matrix( Matrix mat ) +RMAPI RL_Quaternion RL_QuaternionFromMatrix(RL_Matrix mat) { - Quaternion result = { 0 }; + RL_Quaternion result = { 0 }; - float fourWSquaredMinus1 = mat.m0 + mat.m5 + mat.m10; - float fourXSquaredMinus1 = mat.m0 - mat.m5 - mat.m10; - float fourYSquaredMinus1 = mat.m5 - mat.m0 - mat.m10; - float fourZSquaredMinus1 = mat.m10 - mat.m0 - mat.m5; + float fourWSquaredMinus1 = mat.m0 + mat.m5 + mat.m10; + float fourXSquaredMinus1 = mat.m0 - mat.m5 - mat.m10; + float fourYSquaredMinus1 = mat.m5 - mat.m0 - mat.m10; + float fourZSquaredMinus1 = mat.m10 - mat.m0 - mat.m5; - int biggestIndex = 0; - float fourBiggestSquaredMinus1 = fourWSquaredMinus1; - if ( fourXSquaredMinus1 > fourBiggestSquaredMinus1 ) - { - fourBiggestSquaredMinus1 = fourXSquaredMinus1; - biggestIndex = 1; - } + int biggestIndex = 0; + float fourBiggestSquaredMinus1 = fourWSquaredMinus1; + if (fourXSquaredMinus1 > fourBiggestSquaredMinus1) + { + fourBiggestSquaredMinus1 = fourXSquaredMinus1; + biggestIndex = 1; + } - if ( fourYSquaredMinus1 > fourBiggestSquaredMinus1 ) - { - fourBiggestSquaredMinus1 = fourYSquaredMinus1; - biggestIndex = 2; - } + if (fourYSquaredMinus1 > fourBiggestSquaredMinus1) + { + fourBiggestSquaredMinus1 = fourYSquaredMinus1; + biggestIndex = 2; + } - if ( fourZSquaredMinus1 > fourBiggestSquaredMinus1 ) - { - fourBiggestSquaredMinus1 = fourZSquaredMinus1; - biggestIndex = 3; - } + if (fourZSquaredMinus1 > fourBiggestSquaredMinus1) + { + fourBiggestSquaredMinus1 = fourZSquaredMinus1; + biggestIndex = 3; + } - float biggestVal = sqrtf( fourBiggestSquaredMinus1 + 1.0f ) * 0.5f; - float mult = 0.25f / biggestVal; + float biggestVal = sqrtf(fourBiggestSquaredMinus1 + 1.0f)*0.5f; + float mult = 0.25f / biggestVal; - switch ( biggestIndex ) - { - case 0 : - result.w = biggestVal; - result.x = ( mat.m6 - mat.m9 ) * mult; - result.y = ( mat.m8 - mat.m2 ) * mult; - result.z = ( mat.m1 - mat.m4 ) * mult; - break; - case 1 : - result.x = biggestVal; - result.w = ( mat.m6 - mat.m9 ) * mult; - result.y = ( mat.m1 + mat.m4 ) * mult; - result.z = ( mat.m8 + mat.m2 ) * mult; - break; - case 2 : - result.y = biggestVal; - result.w = ( mat.m8 - mat.m2 ) * mult; - result.x = ( mat.m1 + mat.m4 ) * mult; - result.z = ( mat.m6 + mat.m9 ) * mult; - break; - case 3 : - result.z = biggestVal; - result.w = ( mat.m1 - mat.m4 ) * mult; - result.x = ( mat.m8 + mat.m2 ) * mult; - result.y = ( mat.m6 + mat.m9 ) * mult; - break; - } + switch (biggestIndex) + { + case 0: + result.w = biggestVal; + result.x = (mat.m6 - mat.m9)*mult; + result.y = (mat.m8 - mat.m2)*mult; + result.z = (mat.m1 - mat.m4)*mult; + break; + case 1: + result.x = biggestVal; + result.w = (mat.m6 - mat.m9)*mult; + result.y = (mat.m1 + mat.m4)*mult; + result.z = (mat.m8 + mat.m2)*mult; + break; + case 2: + result.y = biggestVal; + result.w = (mat.m8 - mat.m2)*mult; + result.x = (mat.m1 + mat.m4)*mult; + result.z = (mat.m6 + mat.m9)*mult; + break; + case 3: + result.z = biggestVal; + result.w = (mat.m1 - mat.m4)*mult; + result.x = (mat.m8 + mat.m2)*mult; + result.y = (mat.m6 + mat.m9)*mult; + break; + } - return result; + return result; } // Get a matrix for a given quaternion -RMAPI Matrix quaternion_to_matrix( Quaternion q ) +RMAPI RL_Matrix RL_QuaternionToMatrix(RL_Quaternion q) { - Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() + RL_Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f }; // RL_MatrixIdentity() - float a2 = q.x * q.x; - float b2 = q.y * q.y; - float c2 = q.z * q.z; - float ac = q.x * q.z; - float ab = q.x * q.y; - float bc = q.y * q.z; - float ad = q.w * q.x; - float bd = q.w * q.y; - float cd = q.w * q.z; + float a2 = q.x*q.x; + float b2 = q.y*q.y; + float c2 = q.z*q.z; + float ac = q.x*q.z; + float ab = q.x*q.y; + float bc = q.y*q.z; + float ad = q.w*q.x; + float bd = q.w*q.y; + float cd = q.w*q.z; - result.m0 = 1 - 2 * ( b2 + c2 ); - result.m1 = 2 * ( ab + cd ); - result.m2 = 2 * ( ac - bd ); + result.m0 = 1 - 2*(b2 + c2); + result.m1 = 2*(ab + cd); + result.m2 = 2*(ac - bd); - result.m4 = 2 * ( ab - cd ); - result.m5 = 1 - 2 * ( a2 + c2 ); - result.m6 = 2 * ( bc + ad ); + result.m4 = 2*(ab - cd); + result.m5 = 1 - 2*(a2 + c2); + result.m6 = 2*(bc + ad); - result.m8 = 2 * ( ac + bd ); - result.m9 = 2 * ( bc - ad ); - result.m10 = 1 - 2 * ( a2 + b2 ); + result.m8 = 2*(ac + bd); + result.m9 = 2*(bc - ad); + result.m10 = 1 - 2*(a2 + b2); - return result; + return result; } // Get rotation quaternion for an angle and axis // NOTE: Angle must be provided in radians -RMAPI Quaternion quaternion_from_axis_angle( Vector3 axis, f32 angle ) +RMAPI RL_Quaternion RL_QuaternionFromAxisAngle(RL_Vector3 axis, float angle) { - Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; + RL_Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; - float axisLength = sqrtf( axis.x * axis.x + axis.y * axis.y + axis.z * axis.z ); + float axisLength = sqrtf(axis.x*axis.x + axis.y*axis.y + axis.z*axis.z); - if ( axisLength != 0.0f ) - { - angle *= 0.5f; + if (axisLength != 0.0f) + { + angle *= 0.5f; - float length = 0.0f; - float ilength = 0.0f; + float length = 0.0f; + float ilength = 0.0f; - // Vector3Normalize(axis) - Vector3 v = axis; - length = sqrtf( v.x * v.x + v.y * v.y + v.z * v.z ); - if ( length == 0.0f ) - length = 1.0f; - ilength = 1.0f / length; - axis.x *= ilength; - axis.y *= ilength; - axis.z *= ilength; + // RL_Vector3Normalize(axis) + RL_Vector3 v = axis; + length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + axis.x *= ilength; + axis.y *= ilength; + axis.z *= ilength; - float sinres = sinf( angle ); - float cosres = cosf( angle ); + float sinres = sinf(angle); + float cosres = cosf(angle); - result.x = axis.x * sinres; - result.y = axis.y * sinres; - result.z = axis.z * sinres; - result.w = cosres; + result.x = axis.x*sinres; + result.y = axis.y*sinres; + result.z = axis.z*sinres; + result.w = cosres; - // QuaternionNormalize(q); - Quaternion q = result; - length = sqrtf( q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w ); - if ( length == 0.0f ) - length = 1.0f; - ilength = 1.0f / length; - result.x = q.x * ilength; - result.y = q.y * ilength; - result.z = q.z * ilength; - result.w = q.w * ilength; - } + // RL_QuaternionNormalize(q); + RL_Quaternion q = result; + length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + ilength = 1.0f/length; + result.x = q.x*ilength; + result.y = q.y*ilength; + result.z = q.z*ilength; + result.w = q.w*ilength; + } - return result; + return result; } // Get the rotation angle and axis for a given quaternion -RMAPI void quaternion_to_axis_angle( Quaternion q, Vector3* outAxis, f32* outAngle ) +RMAPI void RL_QuaternionToAxisAngle(RL_Quaternion q, RL_Vector3 *outAxis, float *outAngle) { - if ( fabsf( q.w ) > 1.0f ) - { - // QuaternionNormalize(q); - float length = sqrtf( q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w ); - if ( length == 0.0f ) - length = 1.0f; - float ilength = 1.0f / length; + if (fabsf(q.w) > 1.0f) + { + // RL_QuaternionNormalize(q); + float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); + if (length == 0.0f) length = 1.0f; + float ilength = 1.0f/length; - q.x = q.x * ilength; - q.y = q.y * ilength; - q.z = q.z * ilength; - q.w = q.w * ilength; - } + q.x = q.x*ilength; + q.y = q.y*ilength; + q.z = q.z*ilength; + q.w = q.w*ilength; + } - Vector3 resAxis = { 0.0f, 0.0f, 0.0f }; - float resAngle = 2.0f * acosf( q.w ); - float den = sqrtf( 1.0f - q.w * q.w ); + RL_Vector3 resAxis = { 0.0f, 0.0f, 0.0f }; + float resAngle = 2.0f*acosf(q.w); + float den = sqrtf(1.0f - q.w*q.w); - if ( den > EPSILON ) - { - resAxis.x = q.x / den; - resAxis.y = q.y / den; - resAxis.z = q.z / den; - } - else - { - // This occurs when the angle is zero. - // Not a problem: just set an arbitrary normalized axis. - resAxis.x = 1.0f; - } + if (den > EPSILON) + { + resAxis.x = q.x/den; + resAxis.y = q.y/den; + resAxis.z = q.z/den; + } + else + { + // This occurs when the angle is zero. + // Not a problem: just set an arbitrary normalized axis. + resAxis.x = 1.0f; + } - *outAxis = resAxis; - *outAngle = resAngle; + *outAxis = resAxis; + *outAngle = resAngle; } // Get the quaternion equivalent to Euler angles // NOTE: Rotation order is ZYX -RMAPI Quaternion quaternion_from_euler( f32 pitch, f32 yaw, f32 roll ) +RMAPI RL_Quaternion RL_QuaternionFromEuler(float pitch, float yaw, float roll) { - Quaternion result = { 0 }; + RL_Quaternion result = { 0 }; - float x0 = cosf( pitch * 0.5f ); - float x1 = sinf( pitch * 0.5f ); - float y0 = cosf( yaw * 0.5f ); - float y1 = sinf( yaw * 0.5f ); - float z0 = cosf( roll * 0.5f ); - float z1 = sinf( roll * 0.5f ); + float x0 = cosf(pitch*0.5f); + float x1 = sinf(pitch*0.5f); + float y0 = cosf(yaw*0.5f); + float y1 = sinf(yaw*0.5f); + float z0 = cosf(roll*0.5f); + float z1 = sinf(roll*0.5f); - result.x = x1 * y0 * z0 - x0 * y1 * z1; - result.y = x0 * y1 * z0 + x1 * y0 * z1; - result.z = x0 * y0 * z1 - x1 * y1 * z0; - result.w = x0 * y0 * z0 + x1 * y1 * z1; + result.x = x1*y0*z0 - x0*y1*z1; + result.y = x0*y1*z0 + x1*y0*z1; + result.z = x0*y0*z1 - x1*y1*z0; + result.w = x0*y0*z0 + x1*y1*z1; - return result; + return result; } // Get the Euler angles equivalent to quaternion (roll, pitch, yaw) -// NOTE: Angles are returned in a Vector3 struct in radians -RMAPI Vector3 quaternion_to_euler( Quaternion q ) +// NOTE: Angles are returned in a RL_Vector3 struct in radians +RMAPI RL_Vector3 RL_QuaternionToEuler(RL_Quaternion q) { - Vector3 result = { 0 }; + RL_Vector3 result = { 0 }; - // Roll (x-axis rotation) - float x0 = 2.0f * ( q.w * q.x + q.y * q.z ); - float x1 = 1.0f - 2.0f * ( q.x * q.x + q.y * q.y ); - result.x = atan2f( x0, x1 ); + // Roll (x-axis rotation) + float x0 = 2.0f*(q.w*q.x + q.y*q.z); + float x1 = 1.0f - 2.0f*(q.x*q.x + q.y*q.y); + result.x = atan2f(x0, x1); - // Pitch (y-axis rotation) - float y0 = 2.0f * ( q.w * q.y - q.z * q.x ); - y0 = y0 > 1.0f ? 1.0f : y0; - y0 = y0 < -1.0f ? -1.0f : y0; - result.y = asinf( y0 ); + // Pitch (y-axis rotation) + float y0 = 2.0f*(q.w*q.y - q.z*q.x); + y0 = y0 > 1.0f ? 1.0f : y0; + y0 = y0 < -1.0f ? -1.0f : y0; + result.y = asinf(y0); - // Yaw (z-axis rotation) - float z0 = 2.0f * ( q.w * q.z + q.x * q.y ); - float z1 = 1.0f - 2.0f * ( q.y * q.y + q.z * q.z ); - result.z = atan2f( z0, z1 ); + // Yaw (z-axis rotation) + float z0 = 2.0f*(q.w*q.z + q.x*q.y); + float z1 = 1.0f - 2.0f*(q.y*q.y + q.z*q.z); + result.z = atan2f(z0, z1); - return result; + return result; } -// Transform a quaternion given a transformation matrix -RMAPI Quaternion quaternion_transform( Quaternion q, Matrix mat ) +// RL_Transform a quaternion given a transformation matrix +RMAPI RL_Quaternion RL_QuaternionTransform(RL_Quaternion q, RL_Matrix mat) { - Quaternion result = { 0 }; + RL_Quaternion result = { 0 }; - result.x = mat.m0 * q.x + mat.m4 * q.y + mat.m8 * q.z + mat.m12 * q.w; - result.y = mat.m1 * q.x + mat.m5 * q.y + mat.m9 * q.z + mat.m13 * q.w; - result.z = mat.m2 * q.x + mat.m6 * q.y + mat.m10 * q.z + mat.m14 * q.w; - result.w = mat.m3 * q.x + mat.m7 * q.y + mat.m11 * q.z + mat.m15 * q.w; + result.x = mat.m0*q.x + mat.m4*q.y + mat.m8*q.z + mat.m12*q.w; + result.y = mat.m1*q.x + mat.m5*q.y + mat.m9*q.z + mat.m13*q.w; + result.z = mat.m2*q.x + mat.m6*q.y + mat.m10*q.z + mat.m14*q.w; + result.w = mat.m3*q.x + mat.m7*q.y + mat.m11*q.z + mat.m15*q.w; - return result; + return result; } // Check whether two given quaternions are almost equal -RMAPI int quaternion_equals( Quaternion p, Quaternion q ) +RMAPI int RL_QuaternionEquals(RL_Quaternion p, RL_Quaternion q) { -#if ! defined( EPSILON ) -#define EPSILON 0.000001f +#if !defined(EPSILON) + #define EPSILON 0.000001f #endif - int result = ( ( ( fabsf( p.x - q.x ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.x ), fabsf( q.x ) ) ) ) ) - && ( ( fabsf( p.y - q.y ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.y ), fabsf( q.y ) ) ) ) ) - && ( ( fabsf( p.z - q.z ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.z ), fabsf( q.z ) ) ) ) ) - && ( ( fabsf( p.w - q.w ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.w ), fabsf( q.w ) ) ) ) ) ) - || ( ( ( fabsf( p.x + q.x ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.x ), fabsf( q.x ) ) ) ) ) - && ( ( fabsf( p.y + q.y ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.y ), fabsf( q.y ) ) ) ) ) - && ( ( fabsf( p.z + q.z ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.z ), fabsf( q.z ) ) ) ) ) - && ( ( fabsf( p.w + q.w ) ) <= ( EPSILON * fmaxf( 1.0f, fmaxf( fabsf( p.w ), fabsf( q.w ) ) ) ) ) ); + int result = (((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && + ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))) && + ((fabsf(p.w - q.w)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.w), fabsf(q.w)))))) || + (((fabsf(p.x + q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && + ((fabsf(p.y + q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && + ((fabsf(p.z + q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))) && + ((fabsf(p.w + q.w)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.w), fabsf(q.w)))))); - return result; + return result; } -#endif -// RAYMATH_H +#endif // RAYMATH_H diff --git a/project/auxillary/vis_ast/dependencies/raylib/include/rcamera.h b/project/auxillary/vis_ast/dependencies/raylib/include/rcamera.h index 5b8f0f0..d33aaa8 100644 --- a/project/auxillary/vis_ast/dependencies/raylib/include/rcamera.h +++ b/project/auxillary/vis_ast/dependencies/raylib/include/rcamera.h @@ -1,46 +1,46 @@ /******************************************************************************************* - * - * rcamera - Basic camera system with support for multiple camera modes - * - * CONFIGURATION: - * #define RCAMERA_IMPLEMENTATION - * Generates the implementation of the library into the included file. - * If not defined, the library is in header only mode and can be included in other headers - * or source files without problems. But only ONE file should hold the implementation. - * - * #define RCAMERA_STANDALONE - * If defined, the library can be used as standalone as a camera system but some - * functions must be redefined to manage inputs accordingly. - * - * CONTRIBUTORS: - * Ramon Santamaria: Supervision, review, update and maintenance - * Christoph Wagner: Complete redesign, using raymath (2022) - * Marc Palau: Initial implementation (2014) - * - * - * LICENSE: zlib/libpng - * - * Copyright (c) 2022-2023 Christoph Wagner (@Crydsch) & Ramon Santamaria (@raysan5) - * - * This software is provided "as-is", without any express or implied warranty. In no event - * will the authors be held liable for any damages arising from the use of this software. - * - * Permission is granted to anyone to use this software for any purpose, including commercial - * applications, and to alter it and redistribute it freely, subject to the following restrictions: - * - * 1. The origin of this software must not be misrepresented; you must not claim that you - * wrote the original software. If you use this software in a product, an acknowledgment - * in the product documentation would be appreciated but is not required. - * - * 2. Altered source versions must be plainly marked as such, and must not be misrepresented - * as being the original software. - * - * 3. This notice may not be removed or altered from any source distribution. - * - **********************************************************************************************/ +* +* rcamera - Basic camera system with support for multiple camera modes +* +* CONFIGURATION: +* #define RCAMERA_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RCAMERA_STANDALONE +* If defined, the library can be used as standalone as a camera system but some +* functions must be redefined to manage inputs accordingly. +* +* CONTRIBUTORS: +* Ramon Santamaria: Supervision, review, update and maintenance +* Christoph Wagner: Complete redesign, using raymath (2022) +* Marc Palau: Initial implementation (2014) +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2022-2023 Christoph Wagner (@Crydsch) & Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ #ifndef RCAMERA_H -#define RL_RCAMERA_H +#define RCAMERA_H //---------------------------------------------------------------------------------- // Defines and Macros @@ -49,89 +49,80 @@ // Function specifiers in case library is build/used as a shared library (Windows) // NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll -#if defined( _WIN32 ) -#if defined( BUILD_LIBTYPE_SHARED ) -#if defined( __TINYC__ ) -#define RL___declspec( x ) __attribute__( ( x ) ) +#if defined(_WIN32) +#if defined(RL_BUILD_LIBTYPE_SHARED) +#if defined(__TINYC__) +#define __declspec(x) __attribute__((x)) #endif -#elif defined( USE_LIBTYPE_SHARED ) +#define RLAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) +#elif defined(RL_USE_LIBTYPE_SHARED) +#define RLAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) #endif #endif #ifndef RLAPI + #define RLAPI // Functions defined as 'extern' by default (implicit specifiers) #endif -#if defined( RCAMERA_STANDALONE ) -#define RL_CAMERA_CULL_DISTANCE_NEAR 0.01 -#define RL_CAMERA_CULL_DISTANCE_FAR 1000.0 +#if defined(RCAMERA_STANDALONE) + #define RL_CAMERA_CULL_DISTANCE_NEAR 0.01 + #define RL_CAMERA_CULL_DISTANCE_FAR 1000.0 #else -#define RL_CAMERA_CULL_DISTANCE_NEAR RL_CULL_DISTANCE_NEAR -#define RL_CAMERA_CULL_DISTANCE_FAR RL_CULL_DISTANCE_FAR + #define RL_CAMERA_CULL_DISTANCE_NEAR RL_CULL_DISTANCE_NEAR + #define RL_CAMERA_CULL_DISTANCE_FAR RL_CULL_DISTANCE_FAR #endif //---------------------------------------------------------------------------------- // Types and Structures Definition // NOTE: Below types are required for standalone usage //---------------------------------------------------------------------------------- -#if defined( RCAMERA_STANDALONE ) -// Vector2, 2 components -typedef struct Vector2 -{ - f32 x; // Vector x component - f32 y; // Vector y component +#if defined(RCAMERA_STANDALONE) + // RL_Vector2, 2 components + typedef struct RL_Vector2 { + float x; // Vector x component + float y; // Vector y component + } RL_Vector2; -} Vector2; + // RL_Vector3, 3 components + typedef struct RL_Vector3 { + float x; // Vector x component + float y; // Vector y component + float z; // Vector z component + } RL_Vector3; -// Vector3, 3 components -typedef struct Vector3 -{ - f32 x; // Vector x component - f32 y; // Vector y component - f32 z; // Vector z component + // RL_Matrix, 4x4 components, column major, OpenGL style, right-handed + typedef struct RL_Matrix { + float m0, m4, m8, m12; // RL_Matrix first row (4 components) + float m1, m5, m9, m13; // RL_Matrix second row (4 components) + float m2, m6, m10, m14; // RL_Matrix third row (4 components) + float m3, m7, m11, m15; // RL_Matrix fourth row (4 components) + } RL_Matrix; -} Vector3; + // RL_Camera type, defines a camera position/orientation in 3d space + typedef struct RL_Camera3D { + RL_Vector3 position; // RL_Camera position + RL_Vector3 target; // RL_Camera target it looks-at + RL_Vector3 up; // RL_Camera up vector (rotation over its axis) + float fovy; // RL_Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic + int projection; // RL_Camera projection type: RL_CAMERA_PERSPECTIVE or RL_CAMERA_ORTHOGRAPHIC + } RL_Camera3D; -// Matrix, 4x4 components, column major, OpenGL style, right-handed -typedef struct Matrix -{ - f32 m0, m4, m8, m12; // Matrix first row (4 components) - f32 m1, m5, m9, m13; // Matrix second row (4 components) - f32 m2, m6, m10, m14; // Matrix third row (4 components) - f32 m3, m7, m11, m15; // Matrix fourth row (4 components) + typedef RL_Camera3D RL_Camera; // RL_Camera type fallback, defaults to RL_Camera3D -} Matrix; + // RL_Camera projection + typedef enum { + RL_CAMERA_PERSPECTIVE = 0, // Perspective projection + RL_CAMERA_ORTHOGRAPHIC // Orthographic projection + } RL_CameraProjection; -// Camera type, defines a camera position/orientation in 3d space -typedef struct Camera3D -{ - Vector3 position; // Camera position - Vector3 target; // Camera target it looks-at - Vector3 up; // Camera up vector (rotation over its axis) - f32 fovy; // Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic - s32 projection; // Camera projection type: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC - -} Camera3D; - -typedef Camera3D Camera; // Camera type fallback, defaults to Camera3D - -// Camera projection -typedef enum -{ - Camera_Perspective = 0, // Perspective projection - Camera_Orthographic // orthographic projection - -} CameraProjection; - -// Camera system modes -typedef enum -{ - Camera_Custom = 0, // Camera custom, controlled by user (UpdateCamera() does nothing) - Camera_Free, // Camera free mode - Camera_Orbital, // Camera orbital, around target, zoom supported - Camera_First_Person, // Camera first person - Camera_Third_Person // camera third person - -} CameraMode; + // RL_Camera system modes + typedef enum { + RL_CAMERA_CUSTOM = 0, // RL_Camera custom, controlled by user (RL_UpdateCamera() does nothing) + RL_CAMERA_FREE, // RL_Camera free mode + RL_CAMERA_ORBITAL, // RL_Camera orbital, around target, zoom supported + RL_CAMERA_FIRST_PERSON, // RL_Camera first person + RL_CAMERA_THIRD_PERSON // RL_Camera third person + } RL_CameraMode; #endif //---------------------------------------------------------------------------------- @@ -143,92 +134,85 @@ typedef enum // Module Functions Declaration //---------------------------------------------------------------------------------- -#if defined( __cplusplus ) -namespace raylib -{ - extern "C" - { -// Prevents name mangling of functions +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions #endif - RLAPI Vector3 get_camera_forward( Camera* camera ); - RLAPI Vector3 get_camera_up( Camera* camera ); - RLAPI Vector3 get_camera_right( Camera* camera ); +RLAPI RL_Vector3 GetCameraForward(RL_Camera *camera); +RLAPI RL_Vector3 GetCameraUp(RL_Camera *camera); +RLAPI RL_Vector3 GetCameraRight(RL_Camera *camera); - // Camera movement - RLAPI void camera_move_forward( Camera* camera, f32 distance, bool moveInWorldPlane ); - RLAPI void camera_move_up( Camera* camera, f32 distance ); - RLAPI void camera_move_right( Camera* camera, f32 distance, bool moveInWorldPlane ); - RLAPI void camera_move_to_target( Camera* camera, f32 delta ); +// RL_Camera movement +RLAPI void CameraMoveForward(RL_Camera *camera, float distance, bool moveInWorldPlane); +RLAPI void CameraMoveUp(RL_Camera *camera, float distance); +RLAPI void CameraMoveRight(RL_Camera *camera, float distance, bool moveInWorldPlane); +RLAPI void CameraMoveToTarget(RL_Camera *camera, float delta); - // Camera rotation - RLAPI void camera_yaw( Camera* camera, f32 angle, bool rotateAroundTarget ); - RLAPI void camera_pitch( Camera* camera, f32 angle, bool lockView, bool rotateAroundTarget, bool rotateUp ); - RLAPI void camera_roll( Camera* camera, f32 angle ); +// RL_Camera rotation +RLAPI void CameraYaw(RL_Camera *camera, float angle, bool rotateAroundTarget); +RLAPI void CameraPitch(RL_Camera *camera, float angle, bool lockView, bool rotateAroundTarget, bool rotateUp); +RLAPI void CameraRoll(RL_Camera *camera, float angle); - RLAPI Matrix get_camera_view_matrix( Camera* camera ); - RLAPI Matrix get_camera_projection_matrix( Camera* camera, f32 aspect ); +RLAPI RL_Matrix GetCameraViewMatrix(RL_Camera *camera); +RLAPI RL_Matrix GetCameraProjectionMatrix(RL_Camera* camera, float aspect); -#if defined( __cplusplus ) - } +#if defined(__cplusplus) } #endif -#endif -// RCAMERA_H +#endif // RCAMERA_H /*********************************************************************************** - * - * CAMERA IMPLEMENTATION - * - ************************************************************************************/ +* +* CAMERA IMPLEMENTATION +* +************************************************************************************/ -#if defined( RCAMERA_IMPLEMENTATION ) +#if defined(RCAMERA_IMPLEMENTATION) -#include "raymath.h" -// Required for vector maths: -// Vector3Add() -// Vector3Subtract() -// Vector3Scale() -// Vector3Normalize() -// Vector3Distance() -// Vector3CrossProduct() -// Vector3RotateByAxisAngle() -// Vector3Angle() -// Vector3Negate() -// MatrixLookAt() -// MatrixPerspective() -// MatrixOrtho() -// MatrixIdentity() +#include "raymath.h" // Required for vector maths: + // RL_Vector3Add() + // RL_Vector3Subtract() + // RL_Vector3Scale() + // RL_Vector3Normalize() + // RL_Vector3Distance() + // RL_Vector3CrossProduct() + // RL_Vector3RotateByAxisAngle() + // RL_Vector3Angle() + // RL_Vector3Negate() + // RL_MatrixLookAt() + // RL_MatrixPerspective() + // RL_MatrixOrtho() + // RL_MatrixIdentity() // raylib required functionality: -// GetMouseDelta() -// GetMouseWheelMove() -// IsKeyDown() -// IsKeyPressed() -// GetFrameTime() + // RL_GetMouseDelta() + // RL_GetMouseWheelMove() + // RL_IsKeyDown() + // RL_IsKeyPressed() + // RL_GetFrameTime() //---------------------------------------------------------------------------------- // Defines and Macros //---------------------------------------------------------------------------------- -#define RL_CAMERA_MOVE_SPEED 0.09f -#define RL_CAMERA_ROTATION_SPEED 0.03f -#define RL_CAMERA_PAN_SPEED 0.2f +#define RL_CAMERA_MOVE_SPEED 0.09f +#define RL_CAMERA_ROTATION_SPEED 0.03f +#define RL_CAMERA_PAN_SPEED 0.2f -// Camera mouse movement sensitivity -#define RL_CAMERA_MOUSE_MOVE_SENSITIVITY 0.003f // TODO: it should be independant of framerate -#define RL_CAMERA_MOUSE_SCROLL_SENSITIVITY 1.5f +// RL_Camera mouse movement sensitivity +#define RL_CAMERA_MOUSE_MOVE_SENSITIVITY 0.003f // TODO: it should be independant of framerate +#define RL_CAMERA_MOUSE_SCROLL_SENSITIVITY 1.5f -#define RL_CAMERA_ORBITAL_SPEED 0.5f // Radians per second +#define RL_CAMERA_ORBITAL_SPEED 0.5f // Radians per second -#define RL_CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER 8.0f -#define RL_CAMERA_FIRST_PERSON_STEP_DIVIDER 30.0f -#define RL_CAMERA_FIRST_PERSON_WAVING_DIVIDER 200.0f +#define RL_CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER 8.0f +#define RL_CAMERA_FIRST_PERSON_STEP_DIVIDER 30.0f +#define RL_CAMERA_FIRST_PERSON_WAVING_DIVIDER 200.0f // PLAYER (used by camera) -#define RL_PLAYER_MOVEMENT_SENSITIVITY 20.0f +#define RL_PLAYER_MOVEMENT_SENSITIVITY 20.0f //---------------------------------------------------------------------------------- // Types and Structures Definition @@ -249,347 +233,326 @@ namespace raylib // Module Functions Definition //---------------------------------------------------------------------------------- // Returns the cameras forward vector (normalized) -Vector3 get_camera_forward( Camera* camera ) +RL_Vector3 GetCameraForward(RL_Camera *camera) { - return Vector3Normalize( Vector3Subtract( camera->target, camera->position ) ); + return RL_Vector3Normalize(RL_Vector3Subtract(camera->target, camera->position)); } // Returns the cameras up vector (normalized) // Note: The up vector might not be perpendicular to the forward vector -Vector3 get_camera_up( Camera* camera ) +RL_Vector3 GetCameraUp(RL_Camera *camera) { - return Vector3Normalize( camera->up ); + return RL_Vector3Normalize(camera->up); } // Returns the cameras right vector (normalized) -Vector3 get_camera_right( Camera* camera ) +RL_Vector3 GetCameraRight(RL_Camera *camera) { - Vector3 forward = GetCameraForward( camera ); - Vector3 up = GetCameraUp( camera ); + RL_Vector3 forward = GetCameraForward(camera); + RL_Vector3 up = GetCameraUp(camera); - return Vector3CrossProduct( forward, up ); + return RL_Vector3CrossProduct(forward, up); } // Moves the camera in its forward direction -void camera_move_forward( Camera* camera, f32 distance, bool moveInWorldPlane ) +void CameraMoveForward(RL_Camera *camera, float distance, bool moveInWorldPlane) { - Vector3 forward = GetCameraForward( camera ); + RL_Vector3 forward = GetCameraForward(camera); - if ( moveInWorldPlane ) - { - // Project vector onto world plane - forward.y = 0; - forward = Vector3Normalize( forward ); - } + if (moveInWorldPlane) + { + // Project vector onto world plane + forward.y = 0; + forward = RL_Vector3Normalize(forward); + } - // Scale by distance - forward = Vector3Scale( forward, distance ); + // Scale by distance + forward = RL_Vector3Scale(forward, distance); - // Move position and target - camera->position = Vector3Add( camera->position, forward ); - camera->target = Vector3Add( camera->target, forward ); + // Move position and target + camera->position = RL_Vector3Add(camera->position, forward); + camera->target = RL_Vector3Add(camera->target, forward); } // Moves the camera in its up direction -void camera_move_up( Camera* camera, f32 distance ) +void CameraMoveUp(RL_Camera *camera, float distance) { - Vector3 up = GetCameraUp( camera ); + RL_Vector3 up = GetCameraUp(camera); - // Scale by distance - up = Vector3Scale( up, distance ); + // Scale by distance + up = RL_Vector3Scale(up, distance); - // Move position and target - camera->position = Vector3Add( camera->position, up ); - camera->target = Vector3Add( camera->target, up ); + // Move position and target + camera->position = RL_Vector3Add(camera->position, up); + camera->target = RL_Vector3Add(camera->target, up); } // Moves the camera target in its current right direction -void camera_move_right( Camera* camera, f32 distance, bool moveInWorldPlane ) +void CameraMoveRight(RL_Camera *camera, float distance, bool moveInWorldPlane) { - Vector3 right = GetCameraRight( camera ); + RL_Vector3 right = GetCameraRight(camera); - if ( moveInWorldPlane ) - { - // Project vector onto world plane - right.y = 0; - right = Vector3Normalize( right ); - } + if (moveInWorldPlane) + { + // Project vector onto world plane + right.y = 0; + right = RL_Vector3Normalize(right); + } - // Scale by distance - right = Vector3Scale( right, distance ); + // Scale by distance + right = RL_Vector3Scale(right, distance); - // Move position and target - camera->position = Vector3Add( camera->position, right ); - camera->target = Vector3Add( camera->target, right ); + // Move position and target + camera->position = RL_Vector3Add(camera->position, right); + camera->target = RL_Vector3Add(camera->target, right); } // Moves the camera position closer/farther to/from the camera target -void camera_move_to_target( Camera* camera, f32 delta ) +void CameraMoveToTarget(RL_Camera *camera, float delta) { - float distance = Vector3Distance( camera->position, camera->target ); + float distance = RL_Vector3Distance(camera->position, camera->target); - // Apply delta - distance += delta; + // Apply delta + distance += delta; - // Distance must be greater than 0 - if ( distance <= 0 ) - distance = 0.001f; + // Distance must be greater than 0 + if (distance <= 0) distance = 0.001f; - // Set new distance by moving the position along the forward vector - Vector3 forward = GetCameraForward( camera ); - camera->position = Vector3Add( camera->target, Vector3Scale( forward, -distance ) ); + // Set new distance by moving the position along the forward vector + RL_Vector3 forward = GetCameraForward(camera); + camera->position = RL_Vector3Add(camera->target, RL_Vector3Scale(forward, -distance)); } // Rotates the camera around its up vector // Yaw is "looking left and right" // If rotateAroundTarget is false, the camera rotates around its position // Note: angle must be provided in radians -void camera_yaw( Camera* camera, f32 angle, bool rotateAroundTarget ) +void CameraYaw(RL_Camera *camera, float angle, bool rotateAroundTarget) { - Vector3 up = GetCameraUp( camera ); + // Rotation axis + RL_Vector3 up = GetCameraUp(camera); - // View vector - Vector3 targetPosition = Vector3Subtract( camera->target, camera->position ); + // View vector + RL_Vector3 targetPosition = RL_Vector3Subtract(camera->target, camera->position); - // Rotate view vector around up axis - targetPosition = Vector3RotateByAxisAngle( targetPosition, up, angle ); + // Rotate view vector around up axis + targetPosition = RL_Vector3RotateByAxisAngle(targetPosition, up, angle); - if ( rotateAroundTarget ) - { - // Move position relative to target - camera->position = Vector3Subtract( camera->target, targetPosition ); - } - else // rotate around camera.position - { - // Move target relative to position - camera->target = Vector3Add( camera->position, targetPosition ); - } + if (rotateAroundTarget) + { + // Move position relative to target + camera->position = RL_Vector3Subtract(camera->target, targetPosition); + } + else // rotate around camera.position + { + // Move target relative to position + camera->target = RL_Vector3Add(camera->position, targetPosition); + } } // Rotates the camera around its right vector, pitch is "looking up and down" // - lockView prevents camera overrotation (aka "somersaults") // - rotateAroundTarget defines if rotation is around target or around its position -// - rotateUp rotates the up direction as well (typically only usefull in CAMERA_FREE) +// - rotateUp rotates the up direction as well (typically only usefull in RL_CAMERA_FREE) // NOTE: angle must be provided in radians -void camera_pitch( Camera* camera, f32 angle, bool lockView, bool rotateAroundTarget, bool rotateUp ) +void CameraPitch(RL_Camera *camera, float angle, bool lockView, bool rotateAroundTarget, bool rotateUp) { - Vector3 up = GetCameraUp( camera ); + // Up direction + RL_Vector3 up = GetCameraUp(camera); - // View vector - Vector3 targetPosition = Vector3Subtract( camera->target, camera->position ); + // View vector + RL_Vector3 targetPosition = RL_Vector3Subtract(camera->target, camera->position); - if ( lockView ) - { - // In these camera modes we clamp the Pitch angle - // to allow only viewing straight up or down. + if (lockView) + { + // In these camera modes we clamp the Pitch angle + // to allow only viewing straight up or down. - // Clamp view up - float maxAngleUp = Vector3Angle( up, targetPosition ); - maxAngleUp -= 0.001f; // avoid numerical errors - if ( angle > maxAngleUp ) - angle = maxAngleUp; + // RL_Clamp view up + float maxAngleUp = RL_Vector3Angle(up, targetPosition); + maxAngleUp -= 0.001f; // avoid numerical errors + if (angle > maxAngleUp) angle = maxAngleUp; - // Clamp view down - float maxAngleDown = Vector3Angle( Vector3Negate( up ), targetPosition ); - maxAngleDown *= -1.0f; // downwards angle is negative - maxAngleDown += 0.001f; // avoid numerical errors - if ( angle < maxAngleDown ) - angle = maxAngleDown; - } + // RL_Clamp view down + float maxAngleDown = RL_Vector3Angle(RL_Vector3Negate(up), targetPosition); + maxAngleDown *= -1.0f; // downwards angle is negative + maxAngleDown += 0.001f; // avoid numerical errors + if (angle < maxAngleDown) angle = maxAngleDown; + } - // Rotation axis - Vector3 right = GetCameraRight( camera ); + // Rotation axis + RL_Vector3 right = GetCameraRight(camera); - // Rotate view vector around right axis - targetPosition = Vector3RotateByAxisAngle( targetPosition, right, angle ); + // Rotate view vector around right axis + targetPosition = RL_Vector3RotateByAxisAngle(targetPosition, right, angle); - if ( rotateAroundTarget ) - { - // Move position relative to target - camera->position = Vector3Subtract( camera->target, targetPosition ); - } - else // rotate around camera.position - { - // Move target relative to position - camera->target = Vector3Add( camera->position, targetPosition ); - } + if (rotateAroundTarget) + { + // Move position relative to target + camera->position = RL_Vector3Subtract(camera->target, targetPosition); + } + else // rotate around camera.position + { + // Move target relative to position + camera->target = RL_Vector3Add(camera->position, targetPosition); + } - if ( rotateUp ) - { - // Rotate up direction around right axis - camera->up = Vector3RotateByAxisAngle( camera->up, right, angle ); - } + if (rotateUp) + { + // Rotate up direction around right axis + camera->up = RL_Vector3RotateByAxisAngle(camera->up, right, angle); + } } // Rotates the camera around its forward vector // Roll is "turning your head sideways to the left or right" // Note: angle must be provided in radians -void camera_roll( Camera* camera, f32 angle ) +void CameraRoll(RL_Camera *camera, float angle) { - Vector3 forward = GetCameraForward( camera ); + // Rotation axis + RL_Vector3 forward = GetCameraForward(camera); - // Rotate up direction around forward axis - camera->up = Vector3RotateByAxisAngle( camera->up, forward, angle ); + // Rotate up direction around forward axis + camera->up = RL_Vector3RotateByAxisAngle(camera->up, forward, angle); } // Returns the camera view matrix -Matrix get_camera_view_matrix( Camera* camera ) +RL_Matrix GetCameraViewMatrix(RL_Camera *camera) { - return MatrixLookAt( camera->position, camera->target, camera->up ); + return RL_MatrixLookAt(camera->position, camera->target, camera->up); } // Returns the camera projection matrix -Matrix get_camera_projection_matrix( Camera* camera, f32 aspect ) +RL_Matrix GetCameraProjectionMatrix(RL_Camera *camera, float aspect) { - if ( camera->projection == CAMERA_PERSPECTIVE ) - { - return MatrixPerspective( camera->fovy * DEG2RAD, aspect, CAMERA_CULL_DISTANCE_NEAR, CAMERA_CULL_DISTANCE_FAR ); - } - else if ( camera->projection == CAMERA_ORTHOGRAPHIC ) - { - double top = camera->fovy / 2.0; - double right = top * aspect; + if (camera->projection == RL_CAMERA_PERSPECTIVE) + { + return RL_MatrixPerspective(camera->fovy*RL_DEG2RAD, aspect, RL_CAMERA_CULL_DISTANCE_NEAR, RL_CAMERA_CULL_DISTANCE_FAR); + } + else if (camera->projection == RL_CAMERA_ORTHOGRAPHIC) + { + double top = camera->fovy/2.0; + double right = top*aspect; - return MatrixOrtho( -right, right, -top, top, CAMERA_CULL_DISTANCE_NEAR, CAMERA_CULL_DISTANCE_FAR ); - } + return RL_MatrixOrtho(-right, right, -top, top, RL_CAMERA_CULL_DISTANCE_NEAR, RL_CAMERA_CULL_DISTANCE_FAR); + } - return MatrixIdentity(); + return RL_MatrixIdentity(); } -#if ! defined( RCAMERA_STANDALONE ) +#if !defined(RCAMERA_STANDALONE) // Update camera position for selected mode -// Camera mode: CAMERA_FREE, CAMERA_FIRST_PERSON, CAMERA_THIRD_PERSON, CAMERA_ORBITAL or CUSTOM -void update_camera( Camera* camera, s32 mode ) +// RL_Camera mode: RL_CAMERA_FREE, RL_CAMERA_FIRST_PERSON, RL_CAMERA_THIRD_PERSON, RL_CAMERA_ORBITAL or CUSTOM +void RL_UpdateCamera(RL_Camera *camera, int mode) { - Vector2 mousePositionDelta = GetMouseDelta(); + RL_Vector2 mousePositionDelta = RL_GetMouseDelta(); - bool moveInWorldPlane = ( ( mode == CAMERA_FIRST_PERSON ) || ( mode == CAMERA_THIRD_PERSON ) ); - bool rotateAroundTarget = ( ( mode == CAMERA_THIRD_PERSON ) || ( mode == CAMERA_ORBITAL ) ); - bool lockView = ( ( mode == CAMERA_FIRST_PERSON ) || ( mode == CAMERA_THIRD_PERSON ) || ( mode == CAMERA_ORBITAL ) ); - bool rotateUp = false; + bool moveInWorldPlane = ((mode == RL_CAMERA_FIRST_PERSON) || (mode == RL_CAMERA_THIRD_PERSON)); + bool rotateAroundTarget = ((mode == RL_CAMERA_THIRD_PERSON) || (mode == RL_CAMERA_ORBITAL)); + bool lockView = ((mode == RL_CAMERA_FIRST_PERSON) || (mode == RL_CAMERA_THIRD_PERSON) || (mode == RL_CAMERA_ORBITAL)); + bool rotateUp = false; - if ( mode == CAMERA_ORBITAL ) - { - // Orbital can just orbit - Matrix rotation = MatrixRotate( GetCameraUp( camera ), CAMERA_ORBITAL_SPEED * GetFrameTime() ); - Vector3 view = Vector3Subtract( camera->position, camera->target ); - view = Vector3Transform( view, rotation ); - camera->position = Vector3Add( camera->target, view ); - } - else - { - // Camera rotation - if ( IsKeyDown( KEY_DOWN ) ) - CameraPitch( camera, -CAMERA_ROTATION_SPEED, lockView, rotateAroundTarget, rotateUp ); - if ( IsKeyDown( KEY_UP ) ) - CameraPitch( camera, CAMERA_ROTATION_SPEED, lockView, rotateAroundTarget, rotateUp ); - if ( IsKeyDown( KEY_RIGHT ) ) - CameraYaw( camera, -CAMERA_ROTATION_SPEED, rotateAroundTarget ); - if ( IsKeyDown( KEY_LEFT ) ) - CameraYaw( camera, CAMERA_ROTATION_SPEED, rotateAroundTarget ); - if ( IsKeyDown( KEY_Q ) ) - CameraRoll( camera, -CAMERA_ROTATION_SPEED ); - if ( IsKeyDown( KEY_E ) ) - CameraRoll( camera, CAMERA_ROTATION_SPEED ); + if (mode == RL_CAMERA_ORBITAL) + { + // Orbital can just orbit + RL_Matrix rotation = RL_MatrixRotate(GetCameraUp(camera), RL_CAMERA_ORBITAL_SPEED*RL_GetFrameTime()); + RL_Vector3 view = RL_Vector3Subtract(camera->position, camera->target); + view = RL_Vector3Transform(view, rotation); + camera->position = RL_Vector3Add(camera->target, view); + } + else + { + // RL_Camera rotation + if (RL_IsKeyDown(RL_KEY_DOWN)) CameraPitch(camera, -RL_CAMERA_ROTATION_SPEED, lockView, rotateAroundTarget, rotateUp); + if (RL_IsKeyDown(RL_KEY_UP)) CameraPitch(camera, RL_CAMERA_ROTATION_SPEED, lockView, rotateAroundTarget, rotateUp); + if (RL_IsKeyDown(RL_KEY_RIGHT)) CameraYaw(camera, -RL_CAMERA_ROTATION_SPEED, rotateAroundTarget); + if (RL_IsKeyDown(RL_KEY_LEFT)) CameraYaw(camera, RL_CAMERA_ROTATION_SPEED, rotateAroundTarget); + if (RL_IsKeyDown(RL_KEY_Q)) CameraRoll(camera, -RL_CAMERA_ROTATION_SPEED); + if (RL_IsKeyDown(RL_KEY_E)) CameraRoll(camera, RL_CAMERA_ROTATION_SPEED); - // Camera movement - if ( ! IsGamepadAvailable( 0 ) ) - { - // Camera pan (for CAMERA_FREE) - if ( ( mode == CAMERA_FREE ) && ( IsMouseButtonDown( MOUSE_BUTTON_MIDDLE ) ) ) - { - const Vector2 mouseDelta = GetMouseDelta(); - if ( mouseDelta.x > 0.0f ) - CameraMoveRight( camera, CAMERA_PAN_SPEED, moveInWorldPlane ); - if ( mouseDelta.x < 0.0f ) - CameraMoveRight( camera, -CAMERA_PAN_SPEED, moveInWorldPlane ); - if ( mouseDelta.y > 0.0f ) - CameraMoveUp( camera, -CAMERA_PAN_SPEED ); - if ( mouseDelta.y < 0.0f ) - CameraMoveUp( camera, CAMERA_PAN_SPEED ); - } - else - { - // Mouse support - CameraYaw( camera, -mousePositionDelta.x * CAMERA_MOUSE_MOVE_SENSITIVITY, rotateAroundTarget ); - CameraPitch( camera, -mousePositionDelta.y * CAMERA_MOUSE_MOVE_SENSITIVITY, lockView, rotateAroundTarget, rotateUp ); - } + // RL_Camera movement + if (!RL_IsGamepadAvailable(0)) + { + // RL_Camera pan (for RL_CAMERA_FREE) + if ((mode == RL_CAMERA_FREE) && (RL_IsMouseButtonDown(RL_MOUSE_BUTTON_MIDDLE))) + { + const RL_Vector2 mouseDelta = RL_GetMouseDelta(); + if (mouseDelta.x > 0.0f) CameraMoveRight(camera, RL_CAMERA_PAN_SPEED, moveInWorldPlane); + if (mouseDelta.x < 0.0f) CameraMoveRight(camera, -RL_CAMERA_PAN_SPEED, moveInWorldPlane); + if (mouseDelta.y > 0.0f) CameraMoveUp(camera, -RL_CAMERA_PAN_SPEED); + if (mouseDelta.y < 0.0f) CameraMoveUp(camera, RL_CAMERA_PAN_SPEED); + } + else + { + // Mouse support + CameraYaw(camera, -mousePositionDelta.x*RL_CAMERA_MOUSE_MOVE_SENSITIVITY, rotateAroundTarget); + CameraPitch(camera, -mousePositionDelta.y*RL_CAMERA_MOUSE_MOVE_SENSITIVITY, lockView, rotateAroundTarget, rotateUp); + } - // Keyboard support - if ( IsKeyDown( KEY_W ) ) - CameraMoveForward( camera, CAMERA_MOVE_SPEED, moveInWorldPlane ); - if ( IsKeyDown( KEY_A ) ) - CameraMoveRight( camera, -CAMERA_MOVE_SPEED, moveInWorldPlane ); - if ( IsKeyDown( KEY_S ) ) - CameraMoveForward( camera, -CAMERA_MOVE_SPEED, moveInWorldPlane ); - if ( IsKeyDown( KEY_D ) ) - CameraMoveRight( camera, CAMERA_MOVE_SPEED, moveInWorldPlane ); - } - else - { - // Gamepad controller support - CameraYaw( camera, -( GetGamepadAxisMovement( 0, GAMEPAD_AXIS_RIGHT_X ) * 2 ) * CAMERA_MOUSE_MOVE_SENSITIVITY, rotateAroundTarget ); - CameraPitch( - camera, - -( GetGamepadAxisMovement( 0, GAMEPAD_AXIS_RIGHT_Y ) * 2 ) * CAMERA_MOUSE_MOVE_SENSITIVITY, - lockView, - rotateAroundTarget, - rotateUp - ); + // Keyboard support + if (RL_IsKeyDown(RL_KEY_W)) CameraMoveForward(camera, RL_CAMERA_MOVE_SPEED, moveInWorldPlane); + if (RL_IsKeyDown(RL_KEY_A)) CameraMoveRight(camera, -RL_CAMERA_MOVE_SPEED, moveInWorldPlane); + if (RL_IsKeyDown(RL_KEY_S)) CameraMoveForward(camera, -RL_CAMERA_MOVE_SPEED, moveInWorldPlane); + if (RL_IsKeyDown(RL_KEY_D)) CameraMoveRight(camera, RL_CAMERA_MOVE_SPEED, moveInWorldPlane); + } + else + { + // Gamepad controller support + CameraYaw(camera, -(RL_GetGamepadAxisMovement(0, RL_GAMEPAD_AXIS_RIGHT_X) * 2)*RL_CAMERA_MOUSE_MOVE_SENSITIVITY, rotateAroundTarget); + CameraPitch(camera, -(RL_GetGamepadAxisMovement(0, RL_GAMEPAD_AXIS_RIGHT_Y) * 2)*RL_CAMERA_MOUSE_MOVE_SENSITIVITY, lockView, rotateAroundTarget, rotateUp); - if ( GetGamepadAxisMovement( 0, GAMEPAD_AXIS_LEFT_Y ) <= -0.25f ) - CameraMoveForward( camera, CAMERA_MOVE_SPEED, moveInWorldPlane ); - if ( GetGamepadAxisMovement( 0, GAMEPAD_AXIS_LEFT_X ) <= -0.25f ) - CameraMoveRight( camera, -CAMERA_MOVE_SPEED, moveInWorldPlane ); - if ( GetGamepadAxisMovement( 0, GAMEPAD_AXIS_LEFT_Y ) >= 0.25f ) - CameraMoveForward( camera, -CAMERA_MOVE_SPEED, moveInWorldPlane ); - if ( GetGamepadAxisMovement( 0, GAMEPAD_AXIS_LEFT_X ) >= 0.25f ) - CameraMoveRight( camera, CAMERA_MOVE_SPEED, moveInWorldPlane ); - } + if (RL_GetGamepadAxisMovement(0, RL_GAMEPAD_AXIS_LEFT_Y) <= -0.25f) CameraMoveForward(camera, RL_CAMERA_MOVE_SPEED, moveInWorldPlane); + if (RL_GetGamepadAxisMovement(0, RL_GAMEPAD_AXIS_LEFT_X) <= -0.25f) CameraMoveRight(camera, -RL_CAMERA_MOVE_SPEED, moveInWorldPlane); + if (RL_GetGamepadAxisMovement(0, RL_GAMEPAD_AXIS_LEFT_Y) >= 0.25f) CameraMoveForward(camera, -RL_CAMERA_MOVE_SPEED, moveInWorldPlane); + if (RL_GetGamepadAxisMovement(0, RL_GAMEPAD_AXIS_LEFT_X) >= 0.25f) CameraMoveRight(camera, RL_CAMERA_MOVE_SPEED, moveInWorldPlane); + } - if ( mode == CAMERA_FREE ) - { - if ( IsKeyDown( KEY_SPACE ) ) - CameraMoveUp( camera, CAMERA_MOVE_SPEED ); - if ( IsKeyDown( KEY_LEFT_CONTROL ) ) - CameraMoveUp( camera, -CAMERA_MOVE_SPEED ); - } - } + if (mode == RL_CAMERA_FREE) + { + if (RL_IsKeyDown(RL_KEY_SPACE)) CameraMoveUp(camera, RL_CAMERA_MOVE_SPEED); + if (RL_IsKeyDown(RL_KEY_LEFT_CONTROL)) CameraMoveUp(camera, -RL_CAMERA_MOVE_SPEED); + } + } - if ( ( mode == CAMERA_THIRD_PERSON ) || ( mode == CAMERA_ORBITAL ) || ( mode == CAMERA_FREE ) ) - { - // Zoom target distance - CameraMoveToTarget( camera, -GetMouseWheelMove() ); - if ( IsKeyPressed( KEY_KP_SUBTRACT ) ) - CameraMoveToTarget( camera, 2.0f ); - if ( IsKeyPressed( KEY_KP_ADD ) ) - CameraMoveToTarget( camera, -2.0f ); - } + if ((mode == RL_CAMERA_THIRD_PERSON) || (mode == RL_CAMERA_ORBITAL) || (mode == RL_CAMERA_FREE)) + { + // Zoom target distance + CameraMoveToTarget(camera, -RL_GetMouseWheelMove()); + if (RL_IsKeyPressed(RL_KEY_KP_SUBTRACT)) CameraMoveToTarget(camera, 2.0f); + if (RL_IsKeyPressed(RL_KEY_KP_ADD)) CameraMoveToTarget(camera, -2.0f); + } } -#endif -// !RCAMERA_STANDALONE +#endif // !RCAMERA_STANDALONE // Update camera movement, movement/rotation values should be provided by user -void update_camera_pro( Camera* camera, Vector3 movement, Vector3 rotation, f32 zoom ) +void RL_UpdateCameraPro(RL_Camera *camera, RL_Vector3 movement, RL_Vector3 rotation, float zoom) { - bool lockView = true; - bool rotateAroundTarget = false; - bool rotateUp = false; - bool moveInWorldPlane = true; + // Required values + // movement.x - Move forward/backward + // movement.y - Move right/left + // movement.z - Move up/down + // rotation.x - yaw + // rotation.y - pitch + // rotation.z - roll + // zoom - Move towards target - // Camera rotation - CameraPitch( camera, -rotation.y * DEG2RAD, lockView, rotateAroundTarget, rotateUp ); - CameraYaw( camera, -rotation.x * DEG2RAD, rotateAroundTarget ); - CameraRoll( camera, rotation.z * DEG2RAD ); + bool lockView = true; + bool rotateAroundTarget = false; + bool rotateUp = false; + bool moveInWorldPlane = true; - // Camera movement - CameraMoveForward( camera, movement.x, moveInWorldPlane ); - CameraMoveRight( camera, movement.y, moveInWorldPlane ); - CameraMoveUp( camera, movement.z ); + // RL_Camera rotation + CameraPitch(camera, -rotation.y*RL_DEG2RAD, lockView, rotateAroundTarget, rotateUp); + CameraYaw(camera, -rotation.x*RL_DEG2RAD, rotateAroundTarget); + CameraRoll(camera, rotation.z*RL_DEG2RAD); - // Zoom target distance - CameraMoveToTarget( camera, zoom ); + // RL_Camera movement + CameraMoveForward(camera, movement.x, moveInWorldPlane); + CameraMoveRight(camera, movement.y, moveInWorldPlane); + CameraMoveUp(camera, movement.z); + + // Zoom target distance + CameraMoveToTarget(camera, zoom); } -#endif -// RCAMERA_IMPLEMENTATION +#endif // RCAMERA_IMPLEMENTATION diff --git a/project/auxillary/vis_ast/dependencies/raylib/include/rcore.h b/project/auxillary/vis_ast/dependencies/raylib/include/rcore.h deleted file mode 100644 index 83d852f..0000000 --- a/project/auxillary/vis_ast/dependencies/raylib/include/rcore.h +++ /dev/null @@ -1,233 +0,0 @@ -/********************************************************************************************** - * - * rcore - Common types and globals (all platforms) - * - * LIMITATIONS: - * - Limitation 01 - * - Limitation 02 - * - * POSSIBLE IMPROVEMENTS: - * - Improvement 01 - * - Improvement 02 - * - * - * LICENSE: zlib/libpng - * - * Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) and contributors - * - * This software is provided "as-is", without any express or implied warranty. In no event - * will the authors be held liable for any damages arising from the use of this software. - * - * Permission is granted to anyone to use this software for any purpose, including commercial - * applications, and to alter it and redistribute it freely, subject to the following restrictions: - * - * 1. The origin of this software must not be misrepresented; you must not claim that you - * wrote the original software. If you use this software in a product, an acknowledgment - * in the product documentation would be appreciated but is not required. - * - * 2. Altered source versions must be plainly marked as such, and must not be misrepresented - * as being the original software. - * - * 3. This notice may not be removed or altered from any source distribution. - * - **********************************************************************************************/ - -#ifndef RCORE_H -#define RCORE_H - -#include "raylib.h" - -#include "utils.h" // Required for: TRACELOG() macros - -#include "rlgl.h" // Required for: graphics layer functionality - -#define RAYMATH_IMPLEMENTATION -#include "raymath.h" // Required for: Vector2/Vector3/Matrix functionality - -#include // Required for: srand(), rand(), atexit() -#include // Required for: sprintf() [Used in OpenURL()] -#include // Required for: strrchr(), strcmp(), strlen(), memset() -#include // Required for: time() [Used in InitTimer()] -#include // Required for: tan() [Used in BeginMode3D()], atan2f() [Used in LoadVrStereoConfig()] - -//---------------------------------------------------------------------------------- -// Defines and Macros -//---------------------------------------------------------------------------------- -#ifndef MAX_FILEPATH_CAPACITY -#define MAX_FILEPATH_CAPACITY 8192 // Maximum capacity for filepath -#endif -#ifndef MAX_FILEPATH_LENGTH -#define MAX_FILEPATH_LENGTH 4096 // Maximum length for filepaths (Linux PATH_MAX default value) -#endif - -#ifndef MAX_KEYBOARD_KEYS -#define MAX_KEYBOARD_KEYS 512 // Maximum number of keyboard keys supported -#endif -#ifndef MAX_MOUSE_BUTTONS -#define MAX_MOUSE_BUTTONS 8 // Maximum number of mouse buttons supported -#endif -#ifndef MAX_GAMEPADS -#define MAX_GAMEPADS 4 // Maximum number of gamepads supported -#endif -#ifndef MAX_GAMEPAD_AXIS -#define MAX_GAMEPAD_AXIS 8 // Maximum number of axis supported (per gamepad) -#endif -#ifndef MAX_GAMEPAD_BUTTONS -#define MAX_GAMEPAD_BUTTONS 32 // Maximum number of buttons supported (per gamepad) -#endif -#ifndef MAX_TOUCH_POINTS -#define MAX_TOUCH_POINTS 8 // Maximum number of touch points supported -#endif -#ifndef MAX_KEY_PRESSED_QUEUE -#define MAX_KEY_PRESSED_QUEUE 16 // Maximum number of keys in the key input queue -#endif -#ifndef MAX_CHAR_PRESSED_QUEUE -#define MAX_CHAR_PRESSED_QUEUE 16 // Maximum number of characters in the char input queue -#endif - -#ifndef MAX_DECOMPRESSION_SIZE -#define MAX_DECOMPRESSION_SIZE 64 // Maximum size allocated for decompression in MB -#endif - -// Flags operation macros -#define FLAG_SET( n, f ) ( ( n ) |= ( f ) ) -#define FLAG_CLEAR( n, f ) ( ( n ) &= ~( f ) ) -#define FLAG_TOGGLE( n, f ) ( ( n ) ^= ( f ) ) -#define FLAG_CHECK( n, f ) ( ( n ) & ( f ) ) - -#if ( defined( __linux__ ) || defined( PLATFORM_WEB ) ) && ( _POSIX_C_SOURCE < 199309L ) -#undef _POSIX_C_SOURCE -#define _POSIX_C_SOURCE 199309L // Required for: CLOCK_MONOTONIC if compiled with c99 without gnu ext. -#endif - -//---------------------------------------------------------------------------------- -// Types and Structures Definition -//---------------------------------------------------------------------------------- -typedef struct -{ - int x; - int y; -} Point; - -typedef struct -{ - unsigned int width; - unsigned int height; -} Size; - -// Core global state context data -typedef struct CoreData -{ - struct - { - const char* title; // Window text title const pointer - unsigned int flags; // Configuration flags (bit based), keeps window state - bool ready; // Check if window has been initialized successfully - bool fullscreen; // Check if fullscreen mode is enabled - bool shouldClose; // Check if window set for closing - bool resizedLastFrame; // Check if window has been resized last frame - bool eventWaiting; // Wait for events before ending frame - - Point position; // Window position (required on fullscreen toggle) - Point previousPosition; // Window previous position (required on borderless windowed toggle) - Size display; // Display width and height (monitor, device-screen, LCD, ...) - Size screen; // Screen width and height (used render area) - Size previousScreen; // Screen previous width and height (required on borderless windowed toggle) - Size currentFbo; // Current render width and height (depends on active fbo) - Size render; // Framebuffer width and height (render area, including black bars if required) - Point renderOffset; // Offset from render area (must be divided by 2) - Size screenMin; // Screen minimum width and height (for resizable window) - Size screenMax; // Screen maximum width and height (for resizable window) - Matrix screenScale; // Matrix to scale screen (framebuffer rendering) - - char** dropFilepaths; // Store dropped files paths pointers (provided by GLFW) - unsigned int dropFileCount; // Count dropped files strings - - } Window; - - struct - { - const char* basePath; // Base path for data storage - - } Storage; - - struct - { - struct - { - int exitKey; // Default exit key - char currentKeyState[ MAX_KEYBOARD_KEYS ]; // Registers current frame key state - char previousKeyState[ MAX_KEYBOARD_KEYS ]; // Registers previous frame key state - - // NOTE: Since key press logic involves comparing prev vs cur key state, we need to handle key repeats specially - char keyRepeatInFrame[ MAX_KEYBOARD_KEYS ]; // Registers key repeats for current frame. - - int keyPressedQueue[ MAX_KEY_PRESSED_QUEUE ]; // Input keys queue - int keyPressedQueueCount; // Input keys queue count - - int charPressedQueue[ MAX_CHAR_PRESSED_QUEUE ]; // Input characters queue (unicode) - int charPressedQueueCount; // Input characters queue count - - } Keyboard; - - struct - { - Vector2 offset; // Mouse offset - Vector2 scale; // Mouse scaling - Vector2 currentPosition; // Mouse position on screen - Vector2 previousPosition; // Previous mouse position - - int cursor; // Tracks current mouse cursor - bool cursorHidden; // Track if cursor is hidden - bool cursorOnScreen; // Tracks if cursor is inside client area - - char currentButtonState[ MAX_MOUSE_BUTTONS ]; // Registers current mouse button state - char previousButtonState[ MAX_MOUSE_BUTTONS ]; // Registers previous mouse button state - Vector2 currentWheelMove; // Registers current mouse wheel variation - Vector2 previousWheelMove; // Registers previous mouse wheel variation - - } Mouse; - - struct - { - int pointCount; // Number of touch points active - int pointId[ MAX_TOUCH_POINTS ]; // Point identifiers - Vector2 position[ MAX_TOUCH_POINTS ]; // Touch position on screen - char currentTouchState[ MAX_TOUCH_POINTS ]; // Registers current touch state - char previousTouchState[ MAX_TOUCH_POINTS ]; // Registers previous touch state - - } Touch; - - struct - { - int lastButtonPressed; // Register last gamepad button pressed - int axisCount[ MAX_GAMEPADS ]; // Register number of available gamepad axis - bool ready[ MAX_GAMEPADS ]; // Flag to know if gamepad is ready - char name[ MAX_GAMEPADS ][ 64 ]; // Gamepad name holder - char currentButtonState[ MAX_GAMEPADS ][ MAX_GAMEPAD_BUTTONS ]; // Current gamepad buttons state - char previousButtonState[ MAX_GAMEPADS ][ MAX_GAMEPAD_BUTTONS ]; // Previous gamepad buttons state - float axisState[ MAX_GAMEPADS ][ MAX_GAMEPAD_AXIS ]; // Gamepad axis state - - } Gamepad; - } Input; - - struct - { - double current; // Current time measure - double previous; // Previous time measure - double update; // Time measure for frame update - double draw; // Time measure for frame draw - double frame; // Time measure for one frame - double target; // Desired time for one frame, if 0 not applied - unsigned long long int base; // Base time measure for hi-res timer (PLATFORM_ANDROID, PLATFORM_DRM) - unsigned int frameCounter; // Frame counter - - } Time; -} CoreData; - -//---------------------------------------------------------------------------------- -// Global Variables Definition -//---------------------------------------------------------------------------------- -extern CoreData CORE; - -#endif diff --git a/project/auxillary/vis_ast/dependencies/raylib/include/rgestures.h b/project/auxillary/vis_ast/dependencies/raylib/include/rgestures.h index 3284448..650cfbb 100644 --- a/project/auxillary/vis_ast/dependencies/raylib/include/rgestures.h +++ b/project/auxillary/vis_ast/dependencies/raylib/include/rgestures.h @@ -1,57 +1,57 @@ /********************************************************************************************** - * - * rgestures - Gestures system, gestures processing based on input events (touch/mouse) - * - * CONFIGURATION: - * #define RGESTURES_IMPLEMENTATION - * Generates the implementation of the library into the included file. - * If not defined, the library is in header only mode and can be included in other headers - * or source files without problems. But only ONE file should hold the implementation. - * - * #define RGESTURES_STANDALONE - * If defined, the library can be used as standalone to process gesture events with - * no external dependencies. - * - * CONTRIBUTORS: - * Marc Palau: Initial implementation (2014) - * Albert Martos: Complete redesign and testing (2015) - * Ian Eito: Complete redesign and testing (2015) - * Ramon Santamaria: Supervision, review, update and maintenance - * - * - * LICENSE: zlib/libpng - * - * Copyright (c) 2014-2023 Ramon Santamaria (@raysan5) - * - * This software is provided "as-is", without any express or implied warranty. In no event - * will the authors be held liable for any damages arising from the use of this software. - * - * Permission is granted to anyone to use this software for any purpose, including commercial - * applications, and to alter it and redistribute it freely, subject to the following restrictions: - * - * 1. The origin of this software must not be misrepresented; you must not claim that you - * wrote the original software. If you use this software in a product, an acknowledgment - * in the product documentation would be appreciated but is not required. - * - * 2. Altered source versions must be plainly marked as such, and must not be misrepresented - * as being the original software. - * - * 3. This notice may not be removed or altered from any source distribution. - * - **********************************************************************************************/ +* +* rgestures - Gestures system, gestures processing based on input events (touch/mouse) +* +* CONFIGURATION: +* #define RGESTURES_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RGESTURES_STANDALONE +* If defined, the library can be used as standalone to process gesture events with +* no external dependencies. +* +* CONTRIBUTORS: +* Marc Palau: Initial implementation (2014) +* Albert Martos: Complete redesign and testing (2015) +* Ian Eito: Complete redesign and testing (2015) +* Ramon Santamaria: Supervision, review, update and maintenance +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2014-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ #ifndef RGESTURES_H #define RGESTURES_H -#ifndef PI -#define PI 3.14159265358979323846 +#ifndef RL_PI + #define RL_PI 3.14159265358979323846 #endif //---------------------------------------------------------------------------------- // Defines and Macros //---------------------------------------------------------------------------------- -#ifndef MAX_TOUCH_POINTS -#define MAX_TOUCH_POINTS 8 // Maximum number of touch points supported +#ifndef RL_MAX_TOUCH_POINTS + #define RL_MAX_TOUCH_POINTS 8 // Maximum number of touch points supported #endif //---------------------------------------------------------------------------------- @@ -59,60 +59,52 @@ // NOTE: Below types are required for standalone usage //---------------------------------------------------------------------------------- // Boolean type -#if ( defined( __STDC__ ) && __STDC_VERSION__ >= 199901L ) || ( defined( _MSC_VER ) && _MSC_VER >= 1800 ) -#include -#elif ! defined( __cplusplus ) && ! defined( bool ) && ! defined( RL_BOOL_TYPE ) -typedef enum bool -{ - false = 0, - true = ! false -} bool; +#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800) + #include +#elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE) + typedef enum bool { false = 0, true = !false } bool; #endif -#if ! defined( RL_VECTOR2_TYPE ) -// Vector2 type -typedef struct Vector2 -{ - float x; - float y; -} Vector2; +#if !defined(RL_VECTOR2_TYPE) +// RL_Vector2 type +typedef struct RL_Vector2 { + float x; + float y; +} RL_Vector2; #endif -#if defined( RGESTURES_STANDALONE ) +#if defined(RGESTURES_STANDALONE) // Gestures type // NOTE: It could be used as flags to enable only some gestures -typedef enum -{ - GESTURE_NONE = 0, - GESTURE_TAP = 1, - GESTURE_DOUBLETAP = 2, - GESTURE_HOLD = 4, - GESTURE_DRAG = 8, - GESTURE_SWIPE_RIGHT = 16, - GESTURE_SWIPE_LEFT = 32, - GESTURE_SWIPE_UP = 64, - GESTURE_SWIPE_DOWN = 128, - GESTURE_PINCH_IN = 256, - GESTURE_PINCH_OUT = 512 -} Gesture; +typedef enum { + RL_GESTURE_NONE = 0, + RL_GESTURE_TAP = 1, + RL_GESTURE_DOUBLETAP = 2, + RL_GESTURE_HOLD = 4, + RL_GESTURE_DRAG = 8, + RL_GESTURE_SWIPE_RIGHT = 16, + RL_GESTURE_SWIPE_LEFT = 32, + RL_GESTURE_SWIPE_UP = 64, + RL_GESTURE_SWIPE_DOWN = 128, + RL_GESTURE_PINCH_IN = 256, + RL_GESTURE_PINCH_OUT = 512 +} RL_Gesture; #endif -typedef enum -{ - TOUCH_ACTION_UP = 0, - TOUCH_ACTION_DOWN, - TOUCH_ACTION_MOVE, - TOUCH_ACTION_CANCEL -} TouchAction; +typedef enum { + TOUCH_ACTION_UP = 0, + TOUCH_ACTION_DOWN, + TOUCH_ACTION_MOVE, + TOUCH_ACTION_CANCEL +} RL_TouchAction; -// Gesture event -typedef struct -{ - int touchAction; - int pointCount; - int pointId[ MAX_TOUCH_POINTS ]; - Vector2 position[ MAX_TOUCH_POINTS ]; -} GestureEvent; +// RL_Gesture event +typedef struct { + int touchAction; + int pointCount; + int pointId[RL_MAX_TOUCH_POINTS]; + RL_Vector2 position[RL_MAX_TOUCH_POINTS]; +} RL_GestureEvent; //---------------------------------------------------------------------------------- // Global Variables Definition @@ -123,472 +115,441 @@ typedef struct // Module Functions Declaration //---------------------------------------------------------------------------------- -#if defined( __cplusplus ) -extern "C" -{ // Prevents name mangling of functions +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions #endif - void ProcessGestureEvent( GestureEvent event ); // Process gesture event and translate it into gestures - void UpdateGestures( void ); // Update gestures detected (must be called every frame) +void RL_ProcessGestureEvent(RL_GestureEvent event); // Process gesture event and translate it into gestures +void RL_UpdateGestures(void); // Update gestures detected (must be called every frame) -#if defined( RGESTURES_STANDALONE ) - void SetGesturesEnabled( unsigned int flags ); // Enable a set of gestures using flags - bool IsGestureDetected( int gesture ); // Check if a gesture have been detected - int GetGestureDetected( void ); // Get latest detected gesture +#if defined(RGESTURES_STANDALONE) +void RL_SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags +bool RL_IsGestureDetected(int gesture); // Check if a gesture have been detected +int RL_GetGestureDetected(void); // Get latest detected gesture - float GetGestureHoldDuration( void ); // Get gesture hold time in seconds - Vector2 GetGestureDragVector( void ); // Get gesture drag vector - float GetGestureDragAngle( void ); // Get gesture drag angle - Vector2 GetGesturePinchVector( void ); // Get gesture pinch delta - float GetGesturePinchAngle( void ); // Get gesture pinch angle +float RL_GetGestureHoldDuration(void); // Get gesture hold time in seconds +RL_Vector2 RL_GetGestureDragVector(void); // Get gesture drag vector +float RL_GetGestureDragAngle(void); // Get gesture drag angle +RL_Vector2 RL_GetGesturePinchVector(void); // Get gesture pinch delta +float RL_GetGesturePinchAngle(void); // Get gesture pinch angle #endif -#if defined( __cplusplus ) +#if defined(__cplusplus) } #endif -#endif // RGESTURES_H +#endif // RGESTURES_H /*********************************************************************************** - * - * RGESTURES IMPLEMENTATION - * - ************************************************************************************/ +* +* RGESTURES IMPLEMENTATION +* +************************************************************************************/ -#if defined( RGESTURES_IMPLEMENTATION ) +#if defined(RGESTURES_IMPLEMENTATION) -#if defined( RGESTURES_STANDALONE ) -#if defined( _WIN32 ) -#if defined( __cplusplus ) -extern "C" -{ // Prevents name mangling of functions -#endif - // Functions required to query time on Windows - int __stdcall QueryPerformanceCounter( unsigned long long int* lpPerformanceCount ); - int __stdcall QueryPerformanceFrequency( unsigned long long int* lpFrequency ); -#if defined( __cplusplus ) -} -#endif -#elif defined( __linux__ ) -#if _POSIX_C_SOURCE < 199309L -#undef _POSIX_C_SOURCE -#define _POSIX_C_SOURCE 199309L // Required for CLOCK_MONOTONIC if compiled with c99 without gnu ext. -#endif -#include // Required for: timespec -#include // Required for: clock_gettime() +#if defined(RGESTURES_STANDALONE) +#if defined(_WIN32) + #if defined(__cplusplus) + extern "C" { // Prevents name mangling of functions + #endif + // Functions required to query time on Windows + int __stdcall RL_QueryPerformanceCounter(unsigned long long int *lpPerformanceCount); + int __stdcall RL_QueryPerformanceFrequency(unsigned long long int *lpFrequency); + #if defined(__cplusplus) + } + #endif +#elif defined(__linux__) + #if _POSIX_C_SOURCE < 199309L + #undef _POSIX_C_SOURCE + #define _POSIX_C_SOURCE 199309L // Required for CLOCK_MONOTONIC if compiled with c99 without gnu ext. + #endif + #include // Required for: timespec + #include // Required for: clock_gettime() -#include // Required for: sqrtf(), atan2f() + #include // Required for: sqrtf(), atan2f() #endif -#if defined( __APPLE__ ) // macOS also defines __MACH__ -#include // Required for: clock_get_time() -#include // Required for: mach_timespec_t +#if defined(__APPLE__) // macOS also defines __MACH__ + #include // Required for: clock_get_time() + #include // Required for: mach_timespec_t #endif #endif //---------------------------------------------------------------------------------- // Defines and Macros //---------------------------------------------------------------------------------- -#define FORCE_TO_SWIPE 0.2f // Swipe force, measured in normalized screen units/time -#define MINIMUM_DRAG 0.015f // Drag minimum force, measured in normalized screen units (0.0f to 1.0f) -#define DRAG_TIMEOUT 0.3f // Drag minimum time for web, measured in seconds -#define MINIMUM_PINCH 0.005f // Pinch minimum force, measured in normalized screen units (0.0f to 1.0f) -#define TAP_TIMEOUT 0.3f // Tap minimum time, measured in seconds -#define PINCH_TIMEOUT 0.3f // Pinch minimum time, measured in seconds -#define DOUBLETAP_RANGE 0.03f // DoubleTap range, measured in normalized screen units (0.0f to 1.0f) +#define RL_FORCE_TO_SWIPE 0.2f // Swipe force, measured in normalized screen units/time +#define RL_MINIMUM_DRAG 0.015f // Drag minimum force, measured in normalized screen units (0.0f to 1.0f) +#define RL_DRAG_TIMEOUT 0.3f // Drag minimum time for web, measured in seconds +#define RL_MINIMUM_PINCH 0.005f // Pinch minimum force, measured in normalized screen units (0.0f to 1.0f) +#define RL_TAP_TIMEOUT 0.3f // Tap minimum time, measured in seconds +#define RL_PINCH_TIMEOUT 0.3f // Pinch minimum time, measured in seconds +#define RL_DOUBLETAP_RANGE 0.03f // DoubleTap range, measured in normalized screen units (0.0f to 1.0f) //---------------------------------------------------------------------------------- // Types and Structures Definition //---------------------------------------------------------------------------------- // Gestures module state context [136 bytes] -typedef struct -{ - unsigned int current; // Current detected gesture - unsigned int enabledFlags; // Enabled gestures flags - - struct - { - int firstId; // Touch id for first touch point - int pointCount; // Touch points counter - double eventTime; // Time stamp when an event happened - Vector2 upPosition; // Touch up position - Vector2 downPositionA; // First touch down position - Vector2 downPositionB; // Second touch down position - Vector2 downDragPosition; // Touch drag position - Vector2 moveDownPositionA; // First touch down position on move - Vector2 moveDownPositionB; // Second touch down position on move - Vector2 previousPositionA; // Previous position A to compare for pinch gestures - Vector2 previousPositionB; // Previous position B to compare for pinch gestures - int tapCounter; // TAP counter (one tap implies TOUCH_ACTION_DOWN and TOUCH_ACTION_UP actions) - } Touch; - - struct - { - bool resetRequired; // HOLD reset to get first touch point again - double timeDuration; // HOLD duration in seconds - } Hold; - - struct - { - Vector2 vector; // DRAG vector (between initial and current position) - float angle; // DRAG angle (relative to x-axis) - float distance; // DRAG distance (from initial touch point to final) (normalized [0..1]) - float intensity; // DRAG intensity, how far why did the DRAG (pixels per frame) - } Drag; - - struct - { - double startTime; // SWIPE start time to calculate drag intensity - } Swipe; - - struct - { - Vector2 vector; // PINCH vector (between first and second touch points) - float angle; // PINCH angle (relative to x-axis) - float distance; // PINCH displacement distance (normalized [0..1]) - } Pinch; -} GesturesData; +typedef struct { + unsigned int current; // Current detected gesture + unsigned int enabledFlags; // Enabled gestures flags + struct { + int firstId; // Touch id for first touch point + int pointCount; // Touch points counter + double eventTime; // Time stamp when an event happened + RL_Vector2 upPosition; // Touch up position + RL_Vector2 downPositionA; // First touch down position + RL_Vector2 downPositionB; // Second touch down position + RL_Vector2 downDragPosition; // Touch drag position + RL_Vector2 moveDownPositionA; // First touch down position on move + RL_Vector2 moveDownPositionB; // Second touch down position on move + RL_Vector2 previousPositionA; // Previous position A to compare for pinch gestures + RL_Vector2 previousPositionB; // Previous position B to compare for pinch gestures + int tapCounter; // TAP counter (one tap implies TOUCH_ACTION_DOWN and TOUCH_ACTION_UP actions) + } Touch; + struct { + bool resetRequired; // HOLD reset to get first touch point again + double timeDuration; // HOLD duration in seconds + } Hold; + struct { + RL_Vector2 vector; // DRAG vector (between initial and current position) + float angle; // DRAG angle (relative to x-axis) + float distance; // DRAG distance (from initial touch point to final) (normalized [0..1]) + float intensity; // DRAG intensity, how far why did the DRAG (pixels per frame) + } Drag; + struct { + double startTime; // SWIPE start time to calculate drag intensity + } Swipe; + struct { + RL_Vector2 vector; // PINCH vector (between first and second touch points) + float angle; // PINCH angle (relative to x-axis) + float distance; // PINCH displacement distance (normalized [0..1]) + } Pinch; +} RL_GesturesData; //---------------------------------------------------------------------------------- // Global Variables Definition //---------------------------------------------------------------------------------- -static GesturesData GESTURES = { - .Touch.firstId = -1, - .current = GESTURE_NONE, // No current gesture detected - .enabledFlags = 0b0000001111111111 // All gestures supported by default +static RL_GesturesData RL_GESTURES = { + .Touch.firstId = -1, + .current = RL_GESTURE_NONE, // No current gesture detected + .enabledFlags = 0b0000001111111111 // All gestures supported by default }; //---------------------------------------------------------------------------------- // Module specific Functions Declaration //---------------------------------------------------------------------------------- -static float rgVector2Angle( Vector2 initialPosition, Vector2 finalPosition ); -static float rgVector2Distance( Vector2 v1, Vector2 v2 ); -static double rgGetCurrentTime( void ); +static float rgVector2Angle(RL_Vector2 initialPosition, RL_Vector2 finalPosition); +static float rgVector2Distance(RL_Vector2 v1, RL_Vector2 v2); +static double rgGetCurrentTime(void); //---------------------------------------------------------------------------------- // Module Functions Definition //---------------------------------------------------------------------------------- // Enable only desired gestures to be detected -void SetGesturesEnabled( unsigned int flags ) +void RL_SetGesturesEnabled(unsigned int flags) { - GESTURES.enabledFlags = flags; + RL_GESTURES.enabledFlags = flags; } // Check if a gesture have been detected -bool IsGestureDetected( unsigned int gesture ) +bool RL_IsGestureDetected(unsigned int gesture) { - if ( ( GESTURES.enabledFlags & GESTURES.current ) == gesture ) - return true; - else - return false; + if ((RL_GESTURES.enabledFlags & RL_GESTURES.current) == gesture) return true; + else return false; } // Process gesture event and translate it into gestures -void ProcessGestureEvent( GestureEvent event ) +void RL_ProcessGestureEvent(RL_GestureEvent event) { - // Reset required variables - GESTURES.Touch.pointCount = event.pointCount; // Required on UpdateGestures() + // Reset required variables + RL_GESTURES.Touch.pointCount = event.pointCount; // Required on RL_UpdateGestures() - if ( GESTURES.Touch.pointCount == 1 ) // One touch point - { - if ( event.touchAction == TOUCH_ACTION_DOWN ) - { - GESTURES.Touch.tapCounter++; // Tap counter + if (RL_GESTURES.Touch.pointCount == 1) // One touch point + { + if (event.touchAction == TOUCH_ACTION_DOWN) + { + RL_GESTURES.Touch.tapCounter++; // Tap counter - // Detect GESTURE_DOUBLE_TAP - if ( ( GESTURES.current == GESTURE_NONE ) && ( GESTURES.Touch.tapCounter >= 2 ) - && ( ( rgGetCurrentTime() - GESTURES.Touch.eventTime ) < TAP_TIMEOUT ) - && ( rgVector2Distance( GESTURES.Touch.downPositionA, event.position[ 0 ] ) < DOUBLETAP_RANGE ) ) - { - GESTURES.current = GESTURE_DOUBLETAP; - GESTURES.Touch.tapCounter = 0; - } - else // Detect GESTURE_TAP - { - GESTURES.Touch.tapCounter = 1; - GESTURES.current = GESTURE_TAP; - } + // Detect GESTURE_DOUBLE_TAP + if ((RL_GESTURES.current == RL_GESTURE_NONE) && (RL_GESTURES.Touch.tapCounter >= 2) && ((rgGetCurrentTime() - RL_GESTURES.Touch.eventTime) < RL_TAP_TIMEOUT) && (rgVector2Distance(RL_GESTURES.Touch.downPositionA, event.position[0]) < RL_DOUBLETAP_RANGE)) + { + RL_GESTURES.current = RL_GESTURE_DOUBLETAP; + RL_GESTURES.Touch.tapCounter = 0; + } + else // Detect RL_GESTURE_TAP + { + RL_GESTURES.Touch.tapCounter = 1; + RL_GESTURES.current = RL_GESTURE_TAP; + } - GESTURES.Touch.downPositionA = event.position[ 0 ]; - GESTURES.Touch.downDragPosition = event.position[ 0 ]; + RL_GESTURES.Touch.downPositionA = event.position[0]; + RL_GESTURES.Touch.downDragPosition = event.position[0]; - GESTURES.Touch.upPosition = GESTURES.Touch.downPositionA; - GESTURES.Touch.eventTime = rgGetCurrentTime(); + RL_GESTURES.Touch.upPosition = RL_GESTURES.Touch.downPositionA; + RL_GESTURES.Touch.eventTime = rgGetCurrentTime(); - GESTURES.Swipe.startTime = rgGetCurrentTime(); + RL_GESTURES.Swipe.startTime = rgGetCurrentTime(); - GESTURES.Drag.vector = ( Vector2 ) { 0.0f, 0.0f }; - } - else if ( event.touchAction == TOUCH_ACTION_UP ) - { - // A swipe can happen while the current gesture is drag, but (specially for web) also hold, so set upPosition for both cases - if ( GESTURES.current == GESTURE_DRAG || GESTURES.current == GESTURE_HOLD ) - GESTURES.Touch.upPosition = event.position[ 0 ]; + RL_GESTURES.Drag.vector = (RL_Vector2){ 0.0f, 0.0f }; + } + else if (event.touchAction == TOUCH_ACTION_UP) + { + // A swipe can happen while the current gesture is drag, but (specially for web) also hold, so set upPosition for both cases + if (RL_GESTURES.current == RL_GESTURE_DRAG || RL_GESTURES.current == RL_GESTURE_HOLD) RL_GESTURES.Touch.upPosition = event.position[0]; - // NOTE: GESTURES.Drag.intensity dependent on the resolution of the screen - GESTURES.Drag.distance = rgVector2Distance( GESTURES.Touch.downPositionA, GESTURES.Touch.upPosition ); - GESTURES.Drag.intensity = GESTURES.Drag.distance / ( float )( ( rgGetCurrentTime() - GESTURES.Swipe.startTime ) ); + // NOTE: RL_GESTURES.Drag.intensity dependent on the resolution of the screen + RL_GESTURES.Drag.distance = rgVector2Distance(RL_GESTURES.Touch.downPositionA, RL_GESTURES.Touch.upPosition); + RL_GESTURES.Drag.intensity = RL_GESTURES.Drag.distance/(float)((rgGetCurrentTime() - RL_GESTURES.Swipe.startTime)); - // Detect GESTURE_SWIPE - if ( ( GESTURES.Drag.intensity > FORCE_TO_SWIPE ) && ( GESTURES.current != GESTURE_DRAG ) ) - { - // NOTE: Angle should be inverted in Y - GESTURES.Drag.angle = 360.0f - rgVector2Angle( GESTURES.Touch.downPositionA, GESTURES.Touch.upPosition ); + // Detect GESTURE_SWIPE + if ((RL_GESTURES.Drag.intensity > RL_FORCE_TO_SWIPE) && (RL_GESTURES.current != RL_GESTURE_DRAG)) + { + // NOTE: Angle should be inverted in Y + RL_GESTURES.Drag.angle = 360.0f - rgVector2Angle(RL_GESTURES.Touch.downPositionA, RL_GESTURES.Touch.upPosition); - if ( ( GESTURES.Drag.angle < 30 ) || ( GESTURES.Drag.angle > 330 ) ) - GESTURES.current = GESTURE_SWIPE_RIGHT; // Right - else if ( ( GESTURES.Drag.angle >= 30 ) && ( GESTURES.Drag.angle <= 150 ) ) - GESTURES.current = GESTURE_SWIPE_UP; // Up - else if ( ( GESTURES.Drag.angle > 150 ) && ( GESTURES.Drag.angle < 210 ) ) - GESTURES.current = GESTURE_SWIPE_LEFT; // Left - else if ( ( GESTURES.Drag.angle >= 210 ) && ( GESTURES.Drag.angle <= 330 ) ) - GESTURES.current = GESTURE_SWIPE_DOWN; // Down - else - GESTURES.current = GESTURE_NONE; - } - else - { - GESTURES.Drag.distance = 0.0f; - GESTURES.Drag.intensity = 0.0f; - GESTURES.Drag.angle = 0.0f; + if ((RL_GESTURES.Drag.angle < 30) || (RL_GESTURES.Drag.angle > 330)) RL_GESTURES.current = RL_GESTURE_SWIPE_RIGHT; // Right + else if ((RL_GESTURES.Drag.angle >= 30) && (RL_GESTURES.Drag.angle <= 150)) RL_GESTURES.current = RL_GESTURE_SWIPE_UP; // Up + else if ((RL_GESTURES.Drag.angle > 150) && (RL_GESTURES.Drag.angle < 210)) RL_GESTURES.current = RL_GESTURE_SWIPE_LEFT; // Left + else if ((RL_GESTURES.Drag.angle >= 210) && (RL_GESTURES.Drag.angle <= 330)) RL_GESTURES.current = RL_GESTURE_SWIPE_DOWN; // Down + else RL_GESTURES.current = RL_GESTURE_NONE; + } + else + { + RL_GESTURES.Drag.distance = 0.0f; + RL_GESTURES.Drag.intensity = 0.0f; + RL_GESTURES.Drag.angle = 0.0f; - GESTURES.current = GESTURE_NONE; - } + RL_GESTURES.current = RL_GESTURE_NONE; + } - GESTURES.Touch.downDragPosition = ( Vector2 ) { 0.0f, 0.0f }; - GESTURES.Touch.pointCount = 0; - } - else if ( event.touchAction == TOUCH_ACTION_MOVE ) - { - GESTURES.Touch.moveDownPositionA = event.position[ 0 ]; + RL_GESTURES.Touch.downDragPosition = (RL_Vector2){ 0.0f, 0.0f }; + RL_GESTURES.Touch.pointCount = 0; + } + else if (event.touchAction == TOUCH_ACTION_MOVE) + { + RL_GESTURES.Touch.moveDownPositionA = event.position[0]; - if ( GESTURES.current == GESTURE_HOLD ) - { - if ( GESTURES.Hold.resetRequired ) - GESTURES.Touch.downPositionA = event.position[ 0 ]; + if (RL_GESTURES.current == RL_GESTURE_HOLD) + { + if (RL_GESTURES.Hold.resetRequired) RL_GESTURES.Touch.downPositionA = event.position[0]; - GESTURES.Hold.resetRequired = false; + RL_GESTURES.Hold.resetRequired = false; - // Detect GESTURE_DRAG - if ( ( rgGetCurrentTime() - GESTURES.Touch.eventTime ) > DRAG_TIMEOUT ) - { - GESTURES.Touch.eventTime = rgGetCurrentTime(); - GESTURES.current = GESTURE_DRAG; - } - } + // Detect RL_GESTURE_DRAG + if ((rgGetCurrentTime() - RL_GESTURES.Touch.eventTime) > RL_DRAG_TIMEOUT) + { + RL_GESTURES.Touch.eventTime = rgGetCurrentTime(); + RL_GESTURES.current = RL_GESTURE_DRAG; + } + } - GESTURES.Drag.vector.x = GESTURES.Touch.moveDownPositionA.x - GESTURES.Touch.downDragPosition.x; - GESTURES.Drag.vector.y = GESTURES.Touch.moveDownPositionA.y - GESTURES.Touch.downDragPosition.y; - } - } - else if ( GESTURES.Touch.pointCount == 2 ) // Two touch points - { - if ( event.touchAction == TOUCH_ACTION_DOWN ) - { - GESTURES.Touch.downPositionA = event.position[ 0 ]; - GESTURES.Touch.downPositionB = event.position[ 1 ]; + RL_GESTURES.Drag.vector.x = RL_GESTURES.Touch.moveDownPositionA.x - RL_GESTURES.Touch.downDragPosition.x; + RL_GESTURES.Drag.vector.y = RL_GESTURES.Touch.moveDownPositionA.y - RL_GESTURES.Touch.downDragPosition.y; + } + } + else if (RL_GESTURES.Touch.pointCount == 2) // Two touch points + { + if (event.touchAction == TOUCH_ACTION_DOWN) + { + RL_GESTURES.Touch.downPositionA = event.position[0]; + RL_GESTURES.Touch.downPositionB = event.position[1]; - GESTURES.Touch.previousPositionA = GESTURES.Touch.downPositionA; - GESTURES.Touch.previousPositionB = GESTURES.Touch.downPositionB; + RL_GESTURES.Touch.previousPositionA = RL_GESTURES.Touch.downPositionA; + RL_GESTURES.Touch.previousPositionB = RL_GESTURES.Touch.downPositionB; - // GESTURES.Pinch.distance = rgVector2Distance(GESTURES.Touch.downPositionA, GESTURES.Touch.downPositionB); + //RL_GESTURES.Pinch.distance = rgVector2Distance(RL_GESTURES.Touch.downPositionA, RL_GESTURES.Touch.downPositionB); - GESTURES.Pinch.vector.x = GESTURES.Touch.downPositionB.x - GESTURES.Touch.downPositionA.x; - GESTURES.Pinch.vector.y = GESTURES.Touch.downPositionB.y - GESTURES.Touch.downPositionA.y; + RL_GESTURES.Pinch.vector.x = RL_GESTURES.Touch.downPositionB.x - RL_GESTURES.Touch.downPositionA.x; + RL_GESTURES.Pinch.vector.y = RL_GESTURES.Touch.downPositionB.y - RL_GESTURES.Touch.downPositionA.y; - GESTURES.current = GESTURE_HOLD; - GESTURES.Hold.timeDuration = rgGetCurrentTime(); - } - else if ( event.touchAction == TOUCH_ACTION_MOVE ) - { - GESTURES.Pinch.distance = rgVector2Distance( GESTURES.Touch.moveDownPositionA, GESTURES.Touch.moveDownPositionB ); + RL_GESTURES.current = RL_GESTURE_HOLD; + RL_GESTURES.Hold.timeDuration = rgGetCurrentTime(); + } + else if (event.touchAction == TOUCH_ACTION_MOVE) + { + RL_GESTURES.Pinch.distance = rgVector2Distance(RL_GESTURES.Touch.moveDownPositionA, RL_GESTURES.Touch.moveDownPositionB); - GESTURES.Touch.moveDownPositionA = event.position[ 0 ]; - GESTURES.Touch.moveDownPositionB = event.position[ 1 ]; + RL_GESTURES.Touch.moveDownPositionA = event.position[0]; + RL_GESTURES.Touch.moveDownPositionB = event.position[1]; - GESTURES.Pinch.vector.x = GESTURES.Touch.moveDownPositionB.x - GESTURES.Touch.moveDownPositionA.x; - GESTURES.Pinch.vector.y = GESTURES.Touch.moveDownPositionB.y - GESTURES.Touch.moveDownPositionA.y; + RL_GESTURES.Pinch.vector.x = RL_GESTURES.Touch.moveDownPositionB.x - RL_GESTURES.Touch.moveDownPositionA.x; + RL_GESTURES.Pinch.vector.y = RL_GESTURES.Touch.moveDownPositionB.y - RL_GESTURES.Touch.moveDownPositionA.y; - if ( ( rgVector2Distance( GESTURES.Touch.previousPositionA, GESTURES.Touch.moveDownPositionA ) >= MINIMUM_PINCH ) - || ( rgVector2Distance( GESTURES.Touch.previousPositionB, GESTURES.Touch.moveDownPositionB ) >= MINIMUM_PINCH ) ) - { - if ( rgVector2Distance( GESTURES.Touch.previousPositionA, GESTURES.Touch.previousPositionB ) - > rgVector2Distance( GESTURES.Touch.moveDownPositionA, GESTURES.Touch.moveDownPositionB ) ) - GESTURES.current = GESTURE_PINCH_IN; - else - GESTURES.current = GESTURE_PINCH_OUT; - } - else - { - GESTURES.current = GESTURE_HOLD; - GESTURES.Hold.timeDuration = rgGetCurrentTime(); - } + if ((rgVector2Distance(RL_GESTURES.Touch.previousPositionA, RL_GESTURES.Touch.moveDownPositionA) >= RL_MINIMUM_PINCH) || (rgVector2Distance(RL_GESTURES.Touch.previousPositionB, RL_GESTURES.Touch.moveDownPositionB) >= RL_MINIMUM_PINCH)) + { + if ( rgVector2Distance(RL_GESTURES.Touch.previousPositionA, RL_GESTURES.Touch.previousPositionB) > rgVector2Distance(RL_GESTURES.Touch.moveDownPositionA, RL_GESTURES.Touch.moveDownPositionB) ) RL_GESTURES.current = RL_GESTURE_PINCH_IN; + else RL_GESTURES.current = RL_GESTURE_PINCH_OUT; + } + else + { + RL_GESTURES.current = RL_GESTURE_HOLD; + RL_GESTURES.Hold.timeDuration = rgGetCurrentTime(); + } - // NOTE: Angle should be inverted in Y - GESTURES.Pinch.angle = 360.0f - rgVector2Angle( GESTURES.Touch.moveDownPositionA, GESTURES.Touch.moveDownPositionB ); - } - else if ( event.touchAction == TOUCH_ACTION_UP ) - { - GESTURES.Pinch.distance = 0.0f; - GESTURES.Pinch.angle = 0.0f; - GESTURES.Pinch.vector = ( Vector2 ) { 0.0f, 0.0f }; - GESTURES.Touch.pointCount = 0; + // NOTE: Angle should be inverted in Y + RL_GESTURES.Pinch.angle = 360.0f - rgVector2Angle(RL_GESTURES.Touch.moveDownPositionA, RL_GESTURES.Touch.moveDownPositionB); + } + else if (event.touchAction == TOUCH_ACTION_UP) + { + RL_GESTURES.Pinch.distance = 0.0f; + RL_GESTURES.Pinch.angle = 0.0f; + RL_GESTURES.Pinch.vector = (RL_Vector2){ 0.0f, 0.0f }; + RL_GESTURES.Touch.pointCount = 0; - GESTURES.current = GESTURE_NONE; - } - } - else if ( GESTURES.Touch.pointCount > 2 ) // More than two touch points - { - // TODO: Process gesture events for more than two points - } + RL_GESTURES.current = RL_GESTURE_NONE; + } + } + else if (RL_GESTURES.Touch.pointCount > 2) // More than two touch points + { + // TODO: Process gesture events for more than two points + } } // Update gestures detected (must be called every frame) -void UpdateGestures( void ) +void RL_UpdateGestures(void) { - // NOTE: Gestures are processed through system callbacks on touch events + // NOTE: Gestures are processed through system callbacks on touch events - // Detect GESTURE_HOLD - if ( ( ( GESTURES.current == GESTURE_TAP ) || ( GESTURES.current == GESTURE_DOUBLETAP ) ) && ( GESTURES.Touch.pointCount < 2 ) ) - { - GESTURES.current = GESTURE_HOLD; - GESTURES.Hold.timeDuration = rgGetCurrentTime(); - } + // Detect RL_GESTURE_HOLD + if (((RL_GESTURES.current == RL_GESTURE_TAP) || (RL_GESTURES.current == RL_GESTURE_DOUBLETAP)) && (RL_GESTURES.Touch.pointCount < 2)) + { + RL_GESTURES.current = RL_GESTURE_HOLD; + RL_GESTURES.Hold.timeDuration = rgGetCurrentTime(); + } - // Detect GESTURE_NONE - if ( ( GESTURES.current == GESTURE_SWIPE_RIGHT ) || ( GESTURES.current == GESTURE_SWIPE_UP ) || ( GESTURES.current == GESTURE_SWIPE_LEFT ) - || ( GESTURES.current == GESTURE_SWIPE_DOWN ) ) - { - GESTURES.current = GESTURE_NONE; - } + // Detect RL_GESTURE_NONE + if ((RL_GESTURES.current == RL_GESTURE_SWIPE_RIGHT) || (RL_GESTURES.current == RL_GESTURE_SWIPE_UP) || (RL_GESTURES.current == RL_GESTURE_SWIPE_LEFT) || (RL_GESTURES.current == RL_GESTURE_SWIPE_DOWN)) + { + RL_GESTURES.current = RL_GESTURE_NONE; + } } // Get latest detected gesture -int GetGestureDetected( void ) +int RL_GetGestureDetected(void) { - // Get current gesture only if enabled - return ( GESTURES.enabledFlags & GESTURES.current ); + // Get current gesture only if enabled + return (RL_GESTURES.enabledFlags & RL_GESTURES.current); } // Hold time measured in ms -float GetGestureHoldDuration( void ) +float RL_GetGestureHoldDuration(void) { - // NOTE: time is calculated on current gesture HOLD + // NOTE: time is calculated on current gesture HOLD - double time = 0.0; + double time = 0.0; - if ( GESTURES.current == GESTURE_HOLD ) - time = rgGetCurrentTime() - GESTURES.Hold.timeDuration; + if (RL_GESTURES.current == RL_GESTURE_HOLD) time = rgGetCurrentTime() - RL_GESTURES.Hold.timeDuration; - return ( float )time; + return (float)time; } // Get drag vector (between initial touch point to current) -Vector2 GetGestureDragVector( void ) +RL_Vector2 RL_GetGestureDragVector(void) { - // NOTE: drag vector is calculated on one touch points TOUCH_ACTION_MOVE + // NOTE: drag vector is calculated on one touch points TOUCH_ACTION_MOVE - return GESTURES.Drag.vector; + return RL_GESTURES.Drag.vector; } // Get drag angle // NOTE: Angle in degrees, horizontal-right is 0, counterclockwise -float GetGestureDragAngle( void ) +float RL_GetGestureDragAngle(void) { - // NOTE: drag angle is calculated on one touch points TOUCH_ACTION_UP + // NOTE: drag angle is calculated on one touch points TOUCH_ACTION_UP - return GESTURES.Drag.angle; + return RL_GESTURES.Drag.angle; } // Get distance between two pinch points -Vector2 GetGesturePinchVector( void ) +RL_Vector2 RL_GetGesturePinchVector(void) { - // NOTE: Pinch distance is calculated on two touch points TOUCH_ACTION_MOVE + // NOTE: Pinch distance is calculated on two touch points TOUCH_ACTION_MOVE - return GESTURES.Pinch.vector; + return RL_GESTURES.Pinch.vector; } // Get angle between two pinch points // NOTE: Angle in degrees, horizontal-right is 0, counterclockwise -float GetGesturePinchAngle( void ) +float RL_GetGesturePinchAngle(void) { - // NOTE: pinch angle is calculated on two touch points TOUCH_ACTION_MOVE + // NOTE: pinch angle is calculated on two touch points TOUCH_ACTION_MOVE - return GESTURES.Pinch.angle; + return RL_GESTURES.Pinch.angle; } //---------------------------------------------------------------------------------- // Module specific Functions Definition //---------------------------------------------------------------------------------- // Get angle from two-points vector with X-axis -static float rgVector2Angle( Vector2 v1, Vector2 v2 ) +static float rgVector2Angle(RL_Vector2 v1, RL_Vector2 v2) { - float angle = atan2f( v2.y - v1.y, v2.x - v1.x ) * ( 180.0f / PI ); + float angle = atan2f(v2.y - v1.y, v2.x - v1.x)*(180.0f/RL_PI); - if ( angle < 0 ) - angle += 360.0f; + if (angle < 0) angle += 360.0f; - return angle; + return angle; } -// Calculate distance between two Vector2 -static float rgVector2Distance( Vector2 v1, Vector2 v2 ) +// Calculate distance between two RL_Vector2 +static float rgVector2Distance(RL_Vector2 v1, RL_Vector2 v2) { - float result; + float result; - float dx = v2.x - v1.x; - float dy = v2.y - v1.y; + float dx = v2.x - v1.x; + float dy = v2.y - v1.y; - result = ( float )sqrt( dx * dx + dy * dy ); + result = (float)sqrt(dx*dx + dy*dy); - return result; + return result; } // Time measure returned are seconds -static double rgGetCurrentTime( void ) +static double rgGetCurrentTime(void) { - double time = 0; + double time = 0; -#if ! defined( RGESTURES_STANDALONE ) - time = GetTime(); +#if !defined(RGESTURES_STANDALONE) + time = RL_GetTime(); #else -#if defined( _WIN32 ) - unsigned long long int clockFrequency, currentTime; +#if defined(_WIN32) + unsigned long long int clockFrequency, currentTime; - QueryPerformanceFrequency( &clockFrequency ); // BE CAREFUL: Costly operation! - QueryPerformanceCounter( ¤tTime ); + RL_QueryPerformanceFrequency(&clockFrequency); // BE CAREFUL: Costly operation! + RL_QueryPerformanceCounter(¤tTime); - time = ( double )currentTime / clockFrequency; // Time in seconds + time = (double)currentTime/clockFrequency; // Time in seconds #endif -#if defined( __linux__ ) - // NOTE: Only for Linux-based systems - struct timespec now; - clock_gettime( CLOCK_MONOTONIC, &now ); - unsigned long long int nowTime = ( unsigned long long int )now.tv_sec * 1000000000LLU + ( unsigned long long int )now.tv_nsec; // Time in nanoseconds +#if defined(__linux__) + // NOTE: Only for Linux-based systems + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + unsigned long long int nowTime = (unsigned long long int)now.tv_sec*1000000000LLU + (unsigned long long int)now.tv_nsec; // Time in nanoseconds - time = ( ( double )nowTime * 1e-9 ); // Time in seconds + time = ((double)nowTime*1e-9); // Time in seconds #endif -#if defined( __APPLE__ ) - // #define CLOCK_REALTIME CALENDAR_CLOCK // returns UTC time since 1970-01-01 - // #define CLOCK_MONOTONIC SYSTEM_CLOCK // returns the time since boot time +#if defined(__APPLE__) + //#define CLOCK_REALTIME CALENDAR_CLOCK // returns UTC time since 1970-01-01 + //#define CLOCK_MONOTONIC SYSTEM_CLOCK // returns the time since boot time - clock_serv_t cclock; - mach_timespec_t now; - host_get_clock_service( mach_host_self(), SYSTEM_CLOCK, &cclock ); + clock_serv_t cclock; + mach_timespec_t now; + host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock); - // NOTE: OS X does not have clock_gettime(), using clock_get_time() - clock_get_time( cclock, &now ); - mach_port_deallocate( mach_task_self(), cclock ); - unsigned long long int nowTime = ( unsigned long long int )now.tv_sec * 1000000000LLU + ( unsigned long long int )now.tv_nsec; // Time in nanoseconds + // NOTE: OS X does not have clock_gettime(), using clock_get_time() + clock_get_time(cclock, &now); + mach_port_deallocate(mach_task_self(), cclock); + unsigned long long int nowTime = (unsigned long long int)now.tv_sec*1000000000LLU + (unsigned long long int)now.tv_nsec; // Time in nanoseconds - time = ( ( double )nowTime * 1e-9 ); // Time in seconds + time = ((double)nowTime*1e-9); // Time in seconds #endif #endif - return time; + return time; } -#endif // RGESTURES_IMPLEMENTATION +#endif // RGESTURES_IMPLEMENTATION diff --git a/project/auxillary/vis_ast/dependencies/raylib/include/rlgl.h b/project/auxillary/vis_ast/dependencies/raylib/include/rlgl.h index dde4422..b68a608 100644 --- a/project/auxillary/vis_ast/dependencies/raylib/include/rlgl.h +++ b/project/auxillary/vis_ast/dependencies/raylib/include/rlgl.h @@ -1,184 +1,191 @@ /********************************************************************************************** - * - * rlgl v4.5 - A multi-OpenGL abstraction layer with an immediate-mode style API - * - * DESCRIPTION: - * An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0) - * that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...) - * - * ADDITIONAL NOTES: - * When choosing an OpenGL backend different than OpenGL 1.1, some internal buffer are - * initialized on rlglInit() to accumulate vertex data. - * - * When an internal state change is required all the stored vertex data is renderer in batch, - * additionally, rlDrawRenderBatchActive() could be called to force flushing of the batch. - * - * Some resources are also loaded for convenience, here the complete list: - * - Default batch (RLGL.defaultBatch): RenderBatch system to accumulate vertex data - * - Default texture (RLGL.defaultTextureId): 1x1 white pixel R8G8B8A8 - * - Default shader (RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs) - * - * Internal buffer (and resources) must be manually unloaded calling rlglClose(). - * - * CONFIGURATION: - * #define GRAPHICS_API_OPENGL_11 - * #define GRAPHICS_API_OPENGL_21 - * #define GRAPHICS_API_OPENGL_33 - * #define GRAPHICS_API_OPENGL_43 - * #define GRAPHICS_API_OPENGL_ES2 - * #define GRAPHICS_API_OPENGL_ES3 - * Use selected OpenGL graphics backend, should be supported by platform - * Those preprocessor defines are only used on rlgl module, if OpenGL version is - * required by any other module, use rlGetVersion() to check it - * - * #define RLGL_IMPLEMENTATION - * Generates the implementation of the library into the included file. - * If not defined, the library is in header only mode and can be included in other headers - * or source files without problems. But only ONE file should hold the implementation. - * - * #define RLGL_RENDER_TEXTURES_HINT - * Enable framebuffer objects (fbo) support (enabled by default) - * Some GPUs could not support them despite the OpenGL version - * - * #define RLGL_SHOW_GL_DETAILS_INFO - * Show OpenGL extensions and capabilities detailed logs on init - * - * #define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT - * Enable debug context (only available on OpenGL 4.3) - * - * rlgl capabilities could be customized just defining some internal - * values before library inclusion (default values listed): - * - * #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192 // Default internal render batch elements limits - * #define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering) - * #define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture) - * #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture()) - * - * #define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of internal Matrix stack - * #define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported - * #define RL_CULL_DISTANCE_NEAR 0.01 // Default projection matrix near cull distance - * #define RL_CULL_DISTANCE_FAR 1000.0 // Default projection matrix far cull distance - * - * When loading a shader, the following vertex attribute and uniform - * location names are tried to be set automatically: - * - * #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: 0 - * #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: 1 - * #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: 2 - * #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: 3 - * #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: 4 - * #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix - * #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix - * #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix - * #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix - * #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView)) - * #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color) - * #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0) - * #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1) - * #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2) - * - * DEPENDENCIES: - * - OpenGL libraries (depending on platform and OpenGL version selected) - * - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core, 4.3 Core) - * - * - * LICENSE: zlib/libpng - * - * Copyright (c) 2014-2023 Ramon Santamaria (@raysan5) - * - * This software is provided "as-is", without any express or implied warranty. In no event - * will the authors be held liable for any damages arising from the use of this software. - * - * Permission is granted to anyone to use this software for any purpose, including commercial - * applications, and to alter it and redistribute it freely, subject to the following restrictions: - * - * 1. The origin of this software must not be misrepresented; you must not claim that you - * wrote the original software. If you use this software in a product, an acknowledgment - * in the product documentation would be appreciated but is not required. - * - * 2. Altered source versions must be plainly marked as such, and must not be misrepresented - * as being the original software. - * - * 3. This notice may not be removed or altered from any source distribution. - * - **********************************************************************************************/ +* +* RLGL_gl v4.5 - A multi-OpenGL abstraction layer with an immediate-mode style API +* +* DESCRIPTION: +* An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0) +* that provides a pseudo-OpenGL 1.1 immediate-mode style API (RLGL_Vertex, RLGL_Translate, RLGL_Rotate...) +* +* ADDITIONAL NOTES: +* When choosing an OpenGL backend different than OpenGL 1.1, some internal buffer are +* initialized on RLGL_Init() to accumulate vertex data. +* +* When an internal state change is required all the stored vertex data is renderer in batch, +* additionally, RLGL_DrawRenderBatchActive() could be called to force flushing of the batch. +* +* Some resources are also loaded for convenience, here the complete list: +* - Default batch (RLGL_GLOBAL_DATA.defaultBatch): RenderBatch system to accumulate vertex data +* - Default texture (RLGL_GLOBAL_DATA.defaultTextureId): 1x1 white pixel R8G8B8A8 +* - Default shader (RLGL_GLOBAL_DATA.State.defaultShaderId, RLGL_GLOBAL_DATA.State.defaultShaderLocs) +* +* Internal buffer (and resources) must be manually unloaded calling RLGL_Close(). +* +* CONFIGURATION: +* #define GRAPHICS_API_OPENGL_11 +* #define GRAPHICS_API_OPENGL_21 +* #define GRAPHICS_API_OPENGL_33 +* #define GRAPHICS_API_OPENGL_43 +* #define GRAPHICS_API_OPENGL_ES2 +* #define GRAPHICS_API_OPENGL_ES3 +* Use selected OpenGL graphics backend, should be supported by platform +* Those preprocessor defines are only used on RLGL_gl module, if OpenGL version is +* required by any other module, use RLGL_GetVersion() to check it +* +* #define RLGL_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define RLGL_RENDER_TEXTURES_HINT +* Enable framebuffer objects (fbo) support (enabled by default) +* Some GPUs could not support them despite the OpenGL version +* +* #define RLGL_SHOW_GL_DETAILS_INFO +* Show OpenGL extensions and capabilities detailed logs on init +* +* #define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT +* Enable debug context (only available on OpenGL 4.3) +* +* RLGL_gl capabilities could be customized just defining some internal +* values before library inclusion (default values listed): +* +* #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192 // Default internal render batch elements limits +* #define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering) +* #define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture) +* #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture()) +* +* #define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of internal RL_Matrix stack +* #define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported +* #define RL_CULL_DISTANCE_NEAR 0.01 // Default projection matrix near cull distance +* #define RL_CULL_DISTANCE_FAR 1000.0 // Default projection matrix far cull distance +* +* When loading a shader, the following vertex attributes and uniform +* location names are tried to be set automatically: +* +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: 0 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: 1 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: 2 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: 3 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: 4 +* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Bound by default to shader location: 5 +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView)) +* #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color) +* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0) +* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1) +* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2) +* +* DEPENDENCIES: +* - OpenGL libraries (depending on platform and OpenGL version selected) +* - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core, 4.3 Core) +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2014-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ #ifndef RLGL_H #define RLGL_H -#define RLGL_VERSION "4.5" +#define RLGL_VERSION "4.5" +#ifndef RAYLIB_H // Function specifiers in case library is build/used as a shared library (Windows) // NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll -#if defined( _WIN32 ) -#if defined( BUILD_LIBTYPE_SHARED ) -#define RLAPI __declspec( dllexport ) // We are building the library as a Win32 shared library (.dll) -#elif defined( USE_LIBTYPE_SHARED ) -#define RLAPI __declspec( dllimport ) // We are using the library as a Win32 shared library (.dll) -#endif +#if defined(_WIN32) + #if defined(BUILD_LIBTYPE_SHARED) + #define RLAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) + #elif defined(USE_LIBTYPE_SHARED) + #define RLAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) + #endif #endif // Function specifiers definition #ifndef RLAPI -#define RLAPI // Functions defined as 'extern' by default (implicit specifiers) + #define RLAPI // Functions defined as 'extern' by default (implicit specifiers) +#endif #endif -// Support TRACELOG macros -#ifndef TRACELOG -#define TRACELOG( level, ... ) ( void )0 -#define TRACELOGD( ... ) ( void )0 +// Support RL_TRACELOG macros +#ifndef RL_TRACELOG + #define RL_TRACELOG(level, ...) (void)0 + #define TRACELOGD(...) (void)0 #endif // Allow custom memory allocators #ifndef RL_MALLOC -#define RL_MALLOC( sz ) malloc( sz ) + #define RL_MALLOC(sz) malloc(sz) #endif #ifndef RL_CALLOC -#define RL_CALLOC( n, sz ) calloc( n, sz ) + #define RL_CALLOC(n,sz) calloc(n,sz) #endif #ifndef RL_REALLOC -#define RL_REALLOC( n, sz ) realloc( n, sz ) + #define RL_REALLOC(n,sz) realloc(n,sz) #endif #ifndef RL_FREE -#define RL_FREE( p ) free( p ) + #define RL_FREE(p) free(p) #endif // Security check in case no GRAPHICS_API_OPENGL_* defined -#if ! defined( GRAPHICS_API_OPENGL_11 ) && ! defined( GRAPHICS_API_OPENGL_21 ) && ! defined( GRAPHICS_API_OPENGL_33 ) && ! defined( GRAPHICS_API_OPENGL_43 ) \ - && ! defined( GRAPHICS_API_OPENGL_ES2 ) && ! defined( GRAPHICS_API_OPENGL_ES3 ) -#define GRAPHICS_API_OPENGL_33 +#if !defined(GRAPHICS_API_OPENGL_11) && \ + !defined(GRAPHICS_API_OPENGL_21) && \ + !defined(GRAPHICS_API_OPENGL_33) && \ + !defined(GRAPHICS_API_OPENGL_43) && \ + !defined(GRAPHICS_API_OPENGL_ES2) && \ + !defined(GRAPHICS_API_OPENGL_ES3) + #define GRAPHICS_API_OPENGL_33 #endif // Security check in case multiple GRAPHICS_API_OPENGL_* defined -#if defined( GRAPHICS_API_OPENGL_11 ) -#if defined( GRAPHICS_API_OPENGL_21 ) -#undef GRAPHICS_API_OPENGL_21 -#endif -#if defined( GRAPHICS_API_OPENGL_33 ) -#undef GRAPHICS_API_OPENGL_33 -#endif -#if defined( GRAPHICS_API_OPENGL_43 ) -#undef GRAPHICS_API_OPENGL_43 -#endif -#if defined( GRAPHICS_API_OPENGL_ES2 ) -#undef GRAPHICS_API_OPENGL_ES2 -#endif +#if defined(GRAPHICS_API_OPENGL_11) + #if defined(GRAPHICS_API_OPENGL_21) + #undef GRAPHICS_API_OPENGL_21 + #endif + #if defined(GRAPHICS_API_OPENGL_33) + #undef GRAPHICS_API_OPENGL_33 + #endif + #if defined(GRAPHICS_API_OPENGL_43) + #undef GRAPHICS_API_OPENGL_43 + #endif + #if defined(GRAPHICS_API_OPENGL_ES2) + #undef GRAPHICS_API_OPENGL_ES2 + #endif #endif // OpenGL 2.1 uses most of OpenGL 3.3 Core functionality // WARNING: Specific parts are checked with #if defines -#if defined( GRAPHICS_API_OPENGL_21 ) -#define GRAPHICS_API_OPENGL_33 +#if defined(GRAPHICS_API_OPENGL_21) + #define GRAPHICS_API_OPENGL_33 #endif // OpenGL 4.3 uses OpenGL 3.3 Core functionality -#if defined( GRAPHICS_API_OPENGL_43 ) -#define GRAPHICS_API_OPENGL_33 +#if defined(GRAPHICS_API_OPENGL_43) + #define GRAPHICS_API_OPENGL_33 #endif // OpenGL ES 3.0 uses OpenGL ES 2.0 functionality (and more) -#if defined( GRAPHICS_API_OPENGL_ES3 ) -#define GRAPHICS_API_OPENGL_ES2 +#if defined(GRAPHICS_API_OPENGL_ES3) + #define GRAPHICS_API_OPENGL_ES2 #endif // Support framebuffer objects by default @@ -191,1424 +198,1309 @@ // Default internal render batch elements limits #ifndef RL_DEFAULT_BATCH_BUFFER_ELEMENTS -#if defined( GRAPHICS_API_OPENGL_11 ) || defined( GRAPHICS_API_OPENGL_33 ) -// This is the maximum amount of elements (quads) per batch -// NOTE: Be careful with text, every letter maps to a quad -#define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192 -#endif -#if defined( GRAPHICS_API_OPENGL_ES2 ) -// We reduce memory sizes for embedded systems (RPI and HTML5) -// NOTE: On HTML5 (emscripten) this is allocated on heap, -// by default it's only 16MB!...just take care... -#define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 2048 -#endif + #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // This is the maximum amount of elements (quads) per batch + // NOTE: Be careful with text, every letter maps to a quad + #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192 + #endif + #if defined(GRAPHICS_API_OPENGL_ES2) + // We reduce memory sizes for embedded systems (RPI and HTML5) + // NOTE: On HTML5 (emscripten) this is allocated on heap, + // by default it's only 16MB!...just take care... + #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 2048 + #endif #endif #ifndef RL_DEFAULT_BATCH_BUFFERS -#define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering) + #define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering) #endif #ifndef RL_DEFAULT_BATCH_DRAWCALLS -#define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture) + #define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture) #endif #ifndef RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS -#define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture()) + #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture()) #endif -// Internal Matrix stack +// Internal RL_Matrix stack #ifndef RL_MAX_MATRIX_STACK_SIZE -#define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of Matrix stack + #define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of RL_Matrix stack #endif // Shader limits #ifndef RL_MAX_SHADER_LOCATIONS -#define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported + #define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported #endif // Projection matrix culling #ifndef RL_CULL_DISTANCE_NEAR -#define RL_CULL_DISTANCE_NEAR 0.01 // Default near cull distance + #define RL_CULL_DISTANCE_NEAR 0.01 // Default near cull distance #endif #ifndef RL_CULL_DISTANCE_FAR -#define RL_CULL_DISTANCE_FAR 1000.0 // Default far cull distance + #define RL_CULL_DISTANCE_FAR 1000.0 // Default far cull distance #endif // Texture parameters (equivalent to OpenGL defines) -#define RL_TEXTURE_WRAP_S 0x2802 // GL_TEXTURE_WRAP_S -#define RL_TEXTURE_WRAP_T 0x2803 // GL_TEXTURE_WRAP_T -#define RL_TEXTURE_MAG_FILTER 0x2800 // GL_TEXTURE_MAG_FILTER -#define RL_TEXTURE_MIN_FILTER 0x2801 // GL_TEXTURE_MIN_FILTER +#define RL_TEXTURE_WRAP_S 0x2802 // GL_TEXTURE_WRAP_S +#define RL_TEXTURE_WRAP_T 0x2803 // GL_TEXTURE_WRAP_T +#define RL_TEXTURE_MAG_FILTER 0x2800 // GL_TEXTURE_MAG_FILTER +#define RL_TEXTURE_MIN_FILTER 0x2801 // GL_TEXTURE_MIN_FILTER -#define RL_TEXTURE_FILTER_NEAREST 0x2600 // GL_NEAREST -#define RL_TEXTURE_FILTER_LINEAR 0x2601 // GL_LINEAR -#define RL_TEXTURE_FILTER_MIP_NEAREST 0x2700 // GL_NEAREST_MIPMAP_NEAREST -#define RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR 0x2702 // GL_NEAREST_MIPMAP_LINEAR -#define RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST 0x2701 // GL_LINEAR_MIPMAP_NEAREST -#define RL_TEXTURE_FILTER_MIP_LINEAR 0x2703 // GL_LINEAR_MIPMAP_LINEAR -#define RL_TEXTURE_FILTER_ANISOTROPIC 0x3000 // Anisotropic filter (custom identifier) -#define RL_TEXTURE_MIPMAP_BIAS_RATIO 0x4000 // Texture mipmap bias, percentage ratio (custom identifier) +#define RL_TEXTURE_FILTER_NEAREST 0x2600 // GL_NEAREST +#define RL_TEXTURE_FILTER_LINEAR 0x2601 // GL_LINEAR +#define RL_TEXTURE_FILTER_MIP_NEAREST 0x2700 // GL_NEAREST_MIPMAP_NEAREST +#define RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR 0x2702 // GL_NEAREST_MIPMAP_LINEAR +#define RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST 0x2701 // GL_LINEAR_MIPMAP_NEAREST +#define RL_TEXTURE_FILTER_MIP_LINEAR 0x2703 // GL_LINEAR_MIPMAP_LINEAR +#define RL_TEXTURE_FILTER_ANISOTROPIC 0x3000 // Anisotropic filter (custom identifier) +#define RL_TEXTURE_MIPMAP_BIAS_RATIO 0x4000 // Texture mipmap bias, percentage ratio (custom identifier) -#define RL_TEXTURE_WRAP_REPEAT 0x2901 // GL_REPEAT -#define RL_TEXTURE_WRAP_CLAMP 0x812F // GL_CLAMP_TO_EDGE -#define RL_TEXTURE_WRAP_MIRROR_REPEAT 0x8370 // GL_MIRRORED_REPEAT -#define RL_TEXTURE_WRAP_MIRROR_CLAMP 0x8742 // GL_MIRROR_CLAMP_EXT +#define RL_TEXTURE_WRAP_REPEAT 0x2901 // GL_REPEAT +#define RL_TEXTURE_WRAP_CLAMP 0x812F // GL_CLAMP_TO_EDGE +#define RL_TEXTURE_WRAP_MIRROR_REPEAT 0x8370 // GL_MIRRORED_REPEAT +#define RL_TEXTURE_WRAP_MIRROR_CLAMP 0x8742 // GL_MIRROR_CLAMP_EXT -// Matrix modes (equivalent to OpenGL) -#define RL_MODELVIEW 0x1700 // GL_MODELVIEW -#define RL_PROJECTION 0x1701 // GL_PROJECTION -#define RL_TEXTURE 0x1702 // GL_TEXTURE +// RL_Matrix modes (equivalent to OpenGL) +#define RL_MODELVIEW 0x1700 // GL_MODELVIEW +#define RL_PROJECTION 0x1701 // GL_PROJECTION +#define RL_TEXTURE 0x1702 // GL_TEXTURE // Primitive assembly draw modes -#define RL_LINES 0x0001 // GL_LINES -#define RL_TRIANGLES 0x0004 // GL_TRIANGLES -#define RL_QUADS 0x0007 // GL_QUADS +#define RL_LINES 0x0001 // GL_LINES +#define RL_TRIANGLES 0x0004 // GL_TRIANGLES +#define RL_QUADS 0x0007 // GL_QUADS // GL equivalent data types -#define RL_UNSIGNED_BYTE 0x1401 // GL_UNSIGNED_BYTE -#define RL_FLOAT 0x1406 // GL_FLOAT +#define RL_UNSIGNED_BYTE 0x1401 // GL_UNSIGNED_BYTE +#define RL_FLOAT 0x1406 // GL_FLOAT // GL buffer usage hint -#define RL_STREAM_DRAW 0x88E0 // GL_STREAM_DRAW -#define RL_STREAM_READ 0x88E1 // GL_STREAM_READ -#define RL_STREAM_COPY 0x88E2 // GL_STREAM_COPY -#define RL_STATIC_DRAW 0x88E4 // GL_STATIC_DRAW -#define RL_STATIC_READ 0x88E5 // GL_STATIC_READ -#define RL_STATIC_COPY 0x88E6 // GL_STATIC_COPY -#define RL_DYNAMIC_DRAW 0x88E8 // GL_DYNAMIC_DRAW -#define RL_DYNAMIC_READ 0x88E9 // GL_DYNAMIC_READ -#define RL_DYNAMIC_COPY 0x88EA // GL_DYNAMIC_COPY +#define RL_STREAM_DRAW 0x88E0 // GL_STREAM_DRAW +#define RL_STREAM_READ 0x88E1 // GL_STREAM_READ +#define RL_STREAM_COPY 0x88E2 // GL_STREAM_COPY +#define RL_STATIC_DRAW 0x88E4 // GL_STATIC_DRAW +#define RL_STATIC_READ 0x88E5 // GL_STATIC_READ +#define RL_STATIC_COPY 0x88E6 // GL_STATIC_COPY +#define RL_DYNAMIC_DRAW 0x88E8 // GL_DYNAMIC_DRAW +#define RL_DYNAMIC_READ 0x88E9 // GL_DYNAMIC_READ +#define RL_DYNAMIC_COPY 0x88EA // GL_DYNAMIC_COPY // GL Shader type -#define RL_FRAGMENT_SHADER 0x8B30 // GL_FRAGMENT_SHADER -#define RL_VERTEX_SHADER 0x8B31 // GL_VERTEX_SHADER -#define RL_COMPUTE_SHADER 0x91B9 // GL_COMPUTE_SHADER +#define RL_FRAGMENT_SHADER 0x8B30 // GL_FRAGMENT_SHADER +#define RL_VERTEX_SHADER 0x8B31 // GL_VERTEX_SHADER +#define RL_COMPUTE_SHADER 0x91B9 // GL_COMPUTE_SHADER // GL blending factors -#define RL_ZERO 0 // GL_ZERO -#define RL_ONE 1 // GL_ONE -#define RL_SRC_COLOR 0x0300 // GL_SRC_COLOR -#define RL_ONE_MINUS_SRC_COLOR 0x0301 // GL_ONE_MINUS_SRC_COLOR -#define RL_SRC_ALPHA 0x0302 // GL_SRC_ALPHA -#define RL_ONE_MINUS_SRC_ALPHA 0x0303 // GL_ONE_MINUS_SRC_ALPHA -#define RL_DST_ALPHA 0x0304 // GL_DST_ALPHA -#define RL_ONE_MINUS_DST_ALPHA 0x0305 // GL_ONE_MINUS_DST_ALPHA -#define RL_DST_COLOR 0x0306 // GL_DST_COLOR -#define RL_ONE_MINUS_DST_COLOR 0x0307 // GL_ONE_MINUS_DST_COLOR -#define RL_SRC_ALPHA_SATURATE 0x0308 // GL_SRC_ALPHA_SATURATE -#define RL_CONSTANT_COLOR 0x8001 // GL_CONSTANT_COLOR -#define RL_ONE_MINUS_CONSTANT_COLOR 0x8002 // GL_ONE_MINUS_CONSTANT_COLOR -#define RL_CONSTANT_ALPHA 0x8003 // GL_CONSTANT_ALPHA -#define RL_ONE_MINUS_CONSTANT_ALPHA 0x8004 // GL_ONE_MINUS_CONSTANT_ALPHA +#define RL_ZERO 0 // GL_ZERO +#define RL_ONE 1 // GL_ONE +#define RL_SRC_COLOR 0x0300 // GL_SRC_COLOR +#define RL_ONE_MINUS_SRC_COLOR 0x0301 // GL_ONE_MINUS_SRC_COLOR +#define RL_SRC_ALPHA 0x0302 // GL_SRC_ALPHA +#define RL_ONE_MINUS_SRC_ALPHA 0x0303 // GL_ONE_MINUS_SRC_ALPHA +#define RL_DST_ALPHA 0x0304 // GL_DST_ALPHA +#define RL_ONE_MINUS_DST_ALPHA 0x0305 // GL_ONE_MINUS_DST_ALPHA +#define RL_DST_COLOR 0x0306 // GL_DST_COLOR +#define RL_ONE_MINUS_DST_COLOR 0x0307 // GL_ONE_MINUS_DST_COLOR +#define RL_SRC_ALPHA_SATURATE 0x0308 // GL_SRC_ALPHA_SATURATE +#define RL_CONSTANT_COLOR 0x8001 // GL_CONSTANT_COLOR +#define RL_ONE_MINUS_CONSTANT_COLOR 0x8002 // GL_ONE_MINUS_CONSTANT_COLOR +#define RL_CONSTANT_ALPHA 0x8003 // GL_CONSTANT_ALPHA +#define RL_ONE_MINUS_CONSTANT_ALPHA 0x8004 // GL_ONE_MINUS_CONSTANT_ALPHA // GL blending functions/equations -#define RL_FUNC_ADD 0x8006 // GL_FUNC_ADD -#define RL_MIN 0x8007 // GL_MIN -#define RL_MAX 0x8008 // GL_MAX -#define RL_FUNC_SUBTRACT 0x800A // GL_FUNC_SUBTRACT -#define RL_FUNC_REVERSE_SUBTRACT 0x800B // GL_FUNC_REVERSE_SUBTRACT -#define RL_BLEND_EQUATION 0x8009 // GL_BLEND_EQUATION -#define RL_BLEND_EQUATION_RGB 0x8009 // GL_BLEND_EQUATION_RGB // (Same as BLEND_EQUATION) -#define RL_BLEND_EQUATION_ALPHA 0x883D // GL_BLEND_EQUATION_ALPHA -#define RL_BLEND_DST_RGB 0x80C8 // GL_BLEND_DST_RGB -#define RL_BLEND_SRC_RGB 0x80C9 // GL_BLEND_SRC_RGB -#define RL_BLEND_DST_ALPHA 0x80CA // GL_BLEND_DST_ALPHA -#define RL_BLEND_SRC_ALPHA 0x80CB // GL_BLEND_SRC_ALPHA -#define RL_BLEND_COLOR 0x8005 // GL_BLEND_COLOR +#define RL_FUNC_ADD 0x8006 // GL_FUNC_ADD +#define RL_MIN 0x8007 // GL_MIN +#define RL_MAX 0x8008 // GL_MAX +#define RL_FUNC_SUBTRACT 0x800A // GL_FUNC_SUBTRACT +#define RL_FUNC_REVERSE_SUBTRACT 0x800B // GL_FUNC_REVERSE_SUBTRACT +#define RL_BLEND_EQUATION 0x8009 // GL_BLEND_EQUATION +#define RL_BLEND_EQUATION_RGB 0x8009 // GL_BLEND_EQUATION_RGB // (Same as BLEND_EQUATION) +#define RL_BLEND_EQUATION_ALPHA 0x883D // GL_BLEND_EQUATION_ALPHA +#define RL_BLEND_DST_RGB 0x80C8 // GL_BLEND_DST_RGB +#define RL_BLEND_SRC_RGB 0x80C9 // GL_BLEND_SRC_RGB +#define RL_BLEND_DST_ALPHA 0x80CA // GL_BLEND_DST_ALPHA +#define RL_BLEND_SRC_ALPHA 0x80CB // GL_BLEND_SRC_ALPHA +#define RL_BLEND_COLOR 0x8005 // GL_BLEND_COLOR //---------------------------------------------------------------------------------- // Types and Structures Definition //---------------------------------------------------------------------------------- -#if ( defined( __STDC__ ) && __STDC_VERSION__ >= 199901L ) || ( defined( _MSC_VER ) && _MSC_VER >= 1800 ) -#include -#elif ! defined( __cplusplus ) && ! defined( bool ) && ! defined( RL_BOOL_TYPE ) -// Boolean type -typedef enum bool -{ - false = 0, - true = ! false -} bool; +#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800) + #include +#elif !defined(__cplusplus) && !defined(bool) && !defined(RL_BOOL_TYPE) + // Boolean type +typedef enum bool { false = 0, true = !false } bool; #endif -#if ! defined( RL_MATRIX_TYPE ) -// Matrix, 4x4 components, column major, OpenGL style, right handed -typedef struct Matrix -{ - float m0, m4, m8, m12; // Matrix first row (4 components) - float m1, m5, m9, m13; // Matrix second row (4 components) - float m2, m6, m10, m14; // Matrix third row (4 components) - float m3, m7, m11, m15; // Matrix fourth row (4 components) -} Matrix; - +#if !defined(RL_MATRIX_TYPE) +// RL_Matrix, 4x4 components, column major, OpenGL style, right handed +typedef struct RL_Matrix { + float m0, m4, m8, m12; // RL_Matrix first row (4 components) + float m1, m5, m9, m13; // RL_Matrix second row (4 components) + float m2, m6, m10, m14; // RL_Matrix third row (4 components) + float m3, m7, m11, m15; // RL_Matrix fourth row (4 components) +} RL_Matrix; #define RL_MATRIX_TYPE #endif // Dynamic vertex buffers (position + texcoords + colors + indices arrays) -typedef struct rlVertexBuffer -{ - int elementCount; // Number of elements in the buffer (QUADS) +typedef struct RLGL_VertexBuffer { + int elementCount; // Number of elements in the buffer (QUADS) - float* vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0) - float* texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) - unsigned char* colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) -#if defined( GRAPHICS_API_OPENGL_11 ) || defined( GRAPHICS_API_OPENGL_33 ) - unsigned int* indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad) + float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0) + float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) + unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + unsigned int *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad) #endif -#if defined( GRAPHICS_API_OPENGL_ES2 ) - unsigned short* indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad) +#if defined(GRAPHICS_API_OPENGL_ES2) + unsigned short *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad) #endif - unsigned int vaoId; // OpenGL Vertex Array Object id - unsigned int vboId[ 4 ]; // OpenGL Vertex Buffer Objects id (4 types of vertex data) -} rlVertexBuffer; + unsigned int vaoId; // OpenGL Vertex Array Object id + unsigned int vboId[4]; // OpenGL Vertex Buffer Objects id (4 types of vertex data) +} RLGL_VertexBuffer; // Draw call type // NOTE: Only texture changes register a new draw, other state-change-related elements are not // used at this moment (vaoId, shaderId, matrices), raylib just forces a batch draw call if any // of those state-change happens (this is done in core module) -typedef struct rlDrawCall -{ - int mode; // Drawing mode: LINES, TRIANGLES, QUADS - int vertexCount; // Number of vertex of the draw - int vertexAlignment; // Number of vertex required for index alignment (LINES, TRIANGLES) - // unsigned int vaoId; // Vertex array id to be used on the draw -> Using RLGL.currentBatch->vertexBuffer.vaoId - // unsigned int shaderId; // Shader id to be used on the draw -> Using RLGL.currentShaderId - unsigned int textureId; // Texture id to be used on the draw -> Use to create new draw call if changes +typedef struct RLGL_DrawCall { + int mode; // Drawing mode: LINES, TRIANGLES, QUADS + int vertexCount; // Number of vertex of the draw + int vertexAlignment; // Number of vertex required for index alignment (LINES, TRIANGLES) + //unsigned int vaoId; // Vertex array id to be used on the draw -> Using RLGL_GLOBAL_DATA.currentBatch->vertexBuffer.vaoId + //unsigned int shaderId; // Shader id to be used on the draw -> Using RLGL_GLOBAL_DATA.currentShaderId + unsigned int textureId; // Texture id to be used on the draw -> Use to create new draw call if changes - // Matrix projection; // Projection matrix for this draw -> Using RLGL.projection by default - // Matrix modelview; // Modelview matrix for this draw -> Using RLGL.modelview by default -} rlDrawCall; + //RL_Matrix projection; // Projection matrix for this draw -> Using RLGL_GLOBAL_DATA.projection by default + //RL_Matrix modelview; // Modelview matrix for this draw -> Using RLGL_GLOBAL_DATA.modelview by default +} RLGL_DrawCall; -// rlRenderBatch type -typedef struct rlRenderBatch -{ - int bufferCount; // Number of vertex buffers (multi-buffering support) - int currentBuffer; // Current buffer tracking in case of multi-buffering - rlVertexBuffer* vertexBuffer; // Dynamic buffer(s) for vertex data +// RLGL_RenderBatch type +typedef struct RLGL_RenderBatch { + int bufferCount; // Number of vertex buffers (multi-buffering support) + int currentBuffer; // Current buffer tracking in case of multi-buffering + RLGL_VertexBuffer *vertexBuffer; // Dynamic buffer(s) for vertex data - rlDrawCall* draws; // Draw calls array, depends on textureId - int drawCounter; // Draw calls counter - float currentDepth; // Current depth value for next draw -} rlRenderBatch; + RLGL_DrawCall *draws; // Draw calls array, depends on textureId + int drawCounter; // Draw calls counter + float currentDepth; // Current depth value for next draw +} RLGL_RenderBatch; // OpenGL version -typedef enum -{ - RL_OPENGL_11 = 1, // OpenGL 1.1 - RL_OPENGL_21, // OpenGL 2.1 (GLSL 120) - RL_OPENGL_33, // OpenGL 3.3 (GLSL 330) - RL_OPENGL_43, // OpenGL 4.3 (using GLSL 330) - RL_OPENGL_ES_20, // OpenGL ES 2.0 (GLSL 100) - RL_OPENGL_ES_30 // OpenGL ES 3.0 (GLSL 300 es) -} rlGlVersion; +typedef enum { + RLGL_OPENGL_11 = 1, // OpenGL 1.1 + RLGL_OPENGL_21, // OpenGL 2.1 (GLSL 120) + RLGL_OPENGL_33, // OpenGL 3.3 (GLSL 330) + RLGL_OPENGL_43, // OpenGL 4.3 (using GLSL 330) + RLGL_OPENGL_ES_20, // OpenGL ES 2.0 (GLSL 100) + RLGL_OPENGL_ES_30 // OpenGL ES 3.0 (GLSL 300 es) +} RLGL_GlVersion; +#ifndef RAYLIB_H // Trace log level // NOTE: Organized by priority level -typedef enum -{ - RL_LOG_ALL = 0, // Display all logs - RL_LOG_TRACE, // Trace logging, intended for internal use only - RL_LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds - RL_LOG_INFO, // Info logging, used for program execution info - RL_LOG_WARNING, // Warning logging, used on recoverable failures - RL_LOG_ERROR, // Error logging, used on unrecoverable failures - RL_LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE) - RL_LOG_NONE // Disable logging -} rlTraceLogLevel; +typedef enum { + RL_LOG_ALL = 0, // Display all logs + RL_LOG_TRACE, // Trace logging, intended for internal use only + RL_LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds + RL_LOG_INFO, // Info logging, used for program execution info + RL_LOG_WARNING, // Warning logging, used on recoverable failures + RL_LOG_ERROR, // Error logging, used on unrecoverable failures + RL_LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE) + RL_LOG_NONE // Disable logging +} RLGL_TraceLogLevel; // Texture pixel formats // NOTE: Support depends on OpenGL version -typedef enum -{ - RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha) - RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels) - RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp - RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp - RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha) - RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha) - RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp - RL_PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float) - RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float) - RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float) - RL_PIXELFORMAT_UNCOMPRESSED_R16, // 16 bpp (1 channel - half float) - RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16, // 16*3 bpp (3 channels - half float) - RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16, // 16*4 bpp (4 channels - half float) - RL_PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha) - RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha) - RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp - RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp - RL_PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp - RL_PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp - RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp - RL_PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp - RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp - RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp - RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp -} rlPixelFormat; +typedef enum { + RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha) + RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels) + RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha) + RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha) + RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp + RL_PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float) + RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float) + RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float) + RL_PIXELFORMAT_UNCOMPRESSED_R16, // 16 bpp (1 channel - half float) + RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16, // 16*3 bpp (3 channels - half float) + RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16, // 16*4 bpp (4 channels - half float) + RL_PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha) + RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha) + RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp + RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp + RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp +} RLGL_PixelFormat; // Texture parameters: filter mode // NOTE 1: Filtering considers mipmaps if available in the texture // NOTE 2: Filter is accordingly set for minification and magnification -typedef enum -{ - RL_TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation - RL_TEXTURE_FILTER_BILINEAR, // Linear filtering - RL_TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps) - RL_TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x - RL_TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x - RL_TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x -} rlTextureFilter; +typedef enum { + RL_TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation + RL_TEXTURE_FILTER_BILINEAR, // Linear filtering + RL_TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps) + RL_TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x + RL_TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x + RL_TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x +} RLGL_TextureFilter; -// Color blending modes (pre-defined) -typedef enum -{ - RL_BLEND_ALPHA = 0, // Blend textures considering alpha (default) - RL_BLEND_ADDITIVE, // Blend textures adding colors - RL_BLEND_MULTIPLIED, // Blend textures multiplying colors - RL_BLEND_ADD_COLORS, // Blend textures adding colors (alternative) - RL_BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative) - RL_BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha - RL_BLEND_CUSTOM, // Blend textures using custom src/dst factors (use rlSetBlendFactors()) - RL_BLEND_CUSTOM_SEPARATE // Blend textures using custom src/dst factors (use rlSetBlendFactorsSeparate()) -} rlBlendMode; // Shader location point type -typedef enum -{ - RL_SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position - RL_SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01 - RL_SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02 - RL_SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal - RL_SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent - RL_SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color - RL_SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection - RL_SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform) - RL_SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection - RL_SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform) - RL_SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal - RL_SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view - RL_SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color - RL_SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color - RL_SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color - RL_SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE) - RL_SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR) - RL_SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal - RL_SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness - RL_SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion - RL_SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission - RL_SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height - RL_SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap - RL_SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance - RL_SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter - RL_SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf -} rlShaderLocationIndex; +typedef enum { + RL_SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position + RL_SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01 + RL_SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02 + RL_SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal + RL_SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent + RL_SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color + RL_SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection + RL_SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform) + RL_SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection + RL_SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform) + RL_SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal + RL_SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view + RL_SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color + RL_SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color + RL_SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color + RL_SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE) + RL_SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR) + RL_SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal + RL_SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness + RL_SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion + RL_SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission + RL_SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height + RL_SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap + RL_SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance + RL_SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter + RL_SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf +} RLGL_ShaderLocationIndex; -#define RL_SHADER_LOC_MAP_DIFFUSE RL_SHADER_LOC_MAP_ALBEDO -#define RL_SHADER_LOC_MAP_SPECULAR RL_SHADER_LOC_MAP_METALNESS +#define RL_SHADER_LOC_MAP_DIFFUSE RL_SHADER_LOC_MAP_ALBEDO +#define RL_SHADER_LOC_MAP_SPECULAR RL_SHADER_LOC_MAP_METALNESS // Shader uniform data type -typedef enum -{ - RL_SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float - RL_SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float) - RL_SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float) - RL_SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float) - RL_SHADER_UNIFORM_INT, // Shader uniform type: int - RL_SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int) - RL_SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int) - RL_SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int) - RL_SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d -} rlShaderUniformDataType; +typedef enum { + RL_SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float + RL_SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float) + RL_SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float) + RL_SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float) + RL_SHADER_UNIFORM_INT, // Shader uniform type: int + RL_SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int) + RL_SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int) + RL_SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int) + RL_SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d +} RLGL_ShaderUniformDataType; // Shader attribute data types -typedef enum -{ - RL_SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float - RL_SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float) - RL_SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float) - RL_SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float) -} rlShaderAttributeDataType; +typedef enum { + RL_SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float + RL_SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float) + RL_SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float) + RL_SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float) +} RLGL_ShaderAttributeDataType; + +// Color blending modes (pre-defined) +typedef enum { + RL_BLEND_ALPHA = 0, // Blend textures considering alpha (default) + RL_BLEND_ADDITIVE, // Blend textures adding colors + RL_BLEND_MULTIPLIED, // Blend textures multiplying colors + RL_BLEND_ADD_COLORS, // Blend textures adding colors (alternative) + RL_BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative) + RL_BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha + RL_BLEND_CUSTOM, // Blend textures using custom src/dst factors (use RLGL_SetBlendFactors()) + RL_BLEND_CUSTOM_SEPARATE // Blend textures using custom src/dst factors (use RLGL_SetBlendFactorsSeparate()) +} RLGL_BlendMode; +#endif //ifndef RAYLIB_H // Framebuffer attachment type // NOTE: By default up to 8 color channels defined, but it can be more -typedef enum -{ - RL_ATTACHMENT_COLOR_CHANNEL0 = 0, // Framebuffer attachment type: color 0 - RL_ATTACHMENT_COLOR_CHANNEL1, // Framebuffer attachment type: color 1 - RL_ATTACHMENT_COLOR_CHANNEL2, // Framebuffer attachment type: color 2 - RL_ATTACHMENT_COLOR_CHANNEL3, // Framebuffer attachment type: color 3 - RL_ATTACHMENT_COLOR_CHANNEL4, // Framebuffer attachment type: color 4 - RL_ATTACHMENT_COLOR_CHANNEL5, // Framebuffer attachment type: color 5 - RL_ATTACHMENT_COLOR_CHANNEL6, // Framebuffer attachment type: color 6 - RL_ATTACHMENT_COLOR_CHANNEL7, // Framebuffer attachment type: color 7 - RL_ATTACHMENT_DEPTH = 100, // Framebuffer attachment type: depth - RL_ATTACHMENT_STENCIL = 200, // Framebuffer attachment type: stencil -} rlFramebufferAttachType; +typedef enum { + RL_ATTACHMENT_COLOR_CHANNEL0 = 0, // Framebuffer attachment type: color 0 + RL_ATTACHMENT_COLOR_CHANNEL1 = 1, // Framebuffer attachment type: color 1 + RL_ATTACHMENT_COLOR_CHANNEL2 = 2, // Framebuffer attachment type: color 2 + RL_ATTACHMENT_COLOR_CHANNEL3 = 3, // Framebuffer attachment type: color 3 + RL_ATTACHMENT_COLOR_CHANNEL4 = 4, // Framebuffer attachment type: color 4 + RL_ATTACHMENT_COLOR_CHANNEL5 = 5, // Framebuffer attachment type: color 5 + RL_ATTACHMENT_COLOR_CHANNEL6 = 6, // Framebuffer attachment type: color 6 + RL_ATTACHMENT_COLOR_CHANNEL7 = 7, // Framebuffer attachment type: color 7 + RL_ATTACHMENT_DEPTH = 100, // Framebuffer attachment type: depth + RL_ATTACHMENT_STENCIL = 200, // Framebuffer attachment type: stencil +} RLGL_FramebufferAttachType; // Framebuffer texture attachment type -typedef enum -{ - RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0, // Framebuffer texture attachment type: cubemap, +X side - RL_ATTACHMENT_CUBEMAP_NEGATIVE_X, // Framebuffer texture attachment type: cubemap, -X side - RL_ATTACHMENT_CUBEMAP_POSITIVE_Y, // Framebuffer texture attachment type: cubemap, +Y side - RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y, // Framebuffer texture attachment type: cubemap, -Y side - RL_ATTACHMENT_CUBEMAP_POSITIVE_Z, // Framebuffer texture attachment type: cubemap, +Z side - RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z, // Framebuffer texture attachment type: cubemap, -Z side - RL_ATTACHMENT_TEXTURE2D = 100, // Framebuffer texture attachment type: texture2d - RL_ATTACHMENT_RENDERBUFFER = 200, // Framebuffer texture attachment type: renderbuffer -} rlFramebufferAttachTextureType; +typedef enum { + RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0, // Framebuffer texture attachment type: cubemap, +X side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_X = 1, // Framebuffer texture attachment type: cubemap, -X side + RL_ATTACHMENT_CUBEMAP_POSITIVE_Y = 2, // Framebuffer texture attachment type: cubemap, +Y side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y = 3, // Framebuffer texture attachment type: cubemap, -Y side + RL_ATTACHMENT_CUBEMAP_POSITIVE_Z = 4, // Framebuffer texture attachment type: cubemap, +Z side + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z = 5, // Framebuffer texture attachment type: cubemap, -Z side + RL_ATTACHMENT_TEXTURE2D = 100, // Framebuffer texture attachment type: texture2d + RL_ATTACHMENT_RENDERBUFFER = 200, // Framebuffer texture attachment type: renderbuffer +} RLGL_FramebufferAttachTextureType; // Face culling mode -typedef enum -{ - RL_CULL_FACE_FRONT = 0, - RL_CULL_FACE_BACK -} rlCullMode; +typedef enum { + RL_CULL_FACE_FRONT = 0, + RL_CULL_FACE_BACK +} RLGL_CullMode; //------------------------------------------------------------------------------------ -// Functions Declaration - Matrix operations +// Functions Declaration - RL_Matrix operations //------------------------------------------------------------------------------------ -#if defined( __cplusplus ) -extern "C" -{ // Prevents name mangling of functions +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions #endif - RLAPI void rlMatrixMode( int mode ); // Choose the current matrix to be transformed - RLAPI void rlPushMatrix( void ); // Push the current matrix to stack - RLAPI void rlPopMatrix( void ); // Pop latest inserted matrix from stack - RLAPI void rlLoadIdentity( void ); // Reset current matrix to identity matrix - RLAPI void rlTranslatef( float x, float y, float z ); // Multiply the current matrix by a translation matrix - RLAPI void rlRotatef( float angle, float x, float y, float z ); // Multiply the current matrix by a rotation matrix - RLAPI void rlScalef( float x, float y, float z ); // Multiply the current matrix by a scaling matrix - RLAPI void rlMultMatrixf( const float* matf ); // Multiply the current matrix by another matrix - RLAPI void rlFrustum( double left, double right, double bottom, double top, double znear, double zfar ); - RLAPI void rlOrtho( double left, double right, double bottom, double top, double znear, double zfar ); - RLAPI void rlViewport( int x, int y, int width, int height ); // Set the viewport area +RLAPI void RLGL_MatrixMode(int mode); // Choose the current matrix to be transformed +RLAPI void RLGL_PushMatrix(void); // Push the current matrix to stack +RLAPI void RLGL_PopMatrix(void); // Pop latest inserted matrix from stack +RLAPI void RLGL_LoadIdentity(void); // Reset current matrix to identity matrix +RLAPI void RLGL_Translatef(float x, float y, float z); // Multiply the current matrix by a translation matrix +RLAPI void RLGL_Rotatef(float angle, float x, float y, float z); // Multiply the current matrix by a rotation matrix +RLAPI void RLGL_Scalef(float x, float y, float z); // Multiply the current matrix by a scaling matrix +RLAPI void RLGL_MultMatrixf(const float *matf); // Multiply the current matrix by another matrix +RLAPI void RLGL_Frustum(double left, double right, double bottom, double top, double znear, double zfar); +RLAPI void RLGL_Ortho(double left, double right, double bottom, double top, double znear, double zfar); +RLAPI void RLGL_Viewport(int x, int y, int width, int height); // Set the viewport area - //------------------------------------------------------------------------------------ - // Functions Declaration - Vertex level operations - //------------------------------------------------------------------------------------ - RLAPI void rlBegin( int mode ); // Initialize drawing mode (how to organize vertex) - RLAPI void rlEnd( void ); // Finish vertex providing - RLAPI void rlVertex2i( int x, int y ); // Define one vertex (position) - 2 int - RLAPI void rlVertex2f( float x, float y ); // Define one vertex (position) - 2 float - RLAPI void rlVertex3f( float x, float y, float z ); // Define one vertex (position) - 3 float - RLAPI void rlTexCoord2f( float x, float y ); // Define one vertex (texture coordinate) - 2 float - RLAPI void rlNormal3f( float x, float y, float z ); // Define one vertex (normal) - 3 float - RLAPI void rlColor4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a ); // Define one vertex (color) - 4 byte - RLAPI void rlColor3f( float x, float y, float z ); // Define one vertex (color) - 3 float - RLAPI void rlColor4f( float x, float y, float z, float w ); // Define one vertex (color) - 4 float +//------------------------------------------------------------------------------------ +// Functions Declaration - Vertex level operations +//------------------------------------------------------------------------------------ +RLAPI void RLGL_Begin(int mode); // Initialize drawing mode (how to organize vertex) +RLAPI void RLGL_End(void); // Finish vertex providing +RLAPI void RLGL_Vertex2i(int x, int y); // Define one vertex (position) - 2 int +RLAPI void RLGL_Vertex2f(float x, float y); // Define one vertex (position) - 2 float +RLAPI void RLGL_Vertex3f(float x, float y, float z); // Define one vertex (position) - 3 float +RLAPI void RLGL_TexCoord2f(float x, float y); // Define one vertex (texture coordinate) - 2 float +RLAPI void RLGL_Normal3f(float x, float y, float z); // Define one vertex (normal) - 3 float +RLAPI void RLGL_Color4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Define one vertex (color) - 4 byte +RLAPI void RLGL_Color3f(float x, float y, float z); // Define one vertex (color) - 3 float +RLAPI void RLGL_Color4f(float x, float y, float z, float w); // Define one vertex (color) - 4 float - //------------------------------------------------------------------------------------ - // Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2) - // NOTE: This functions are used to completely abstract raylib code from OpenGL layer, - // some of them are direct wrappers over OpenGL calls, some others are custom - //------------------------------------------------------------------------------------ +//------------------------------------------------------------------------------------ +// Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2) +// NOTE: This functions are used to completely abstract raylib code from OpenGL layer, +// some of them are direct wrappers over OpenGL calls, some others are custom +//------------------------------------------------------------------------------------ - // Vertex buffers state - RLAPI bool rlEnableVertexArray( unsigned int vaoId ); // Enable vertex array (VAO, if supported) - RLAPI void rlDisableVertexArray( void ); // Disable vertex array (VAO, if supported) - RLAPI void rlEnableVertexBuffer( unsigned int id ); // Enable vertex buffer (VBO) - RLAPI void rlDisableVertexBuffer( void ); // Disable vertex buffer (VBO) - RLAPI void rlEnableVertexBufferElement( unsigned int id ); // Enable vertex buffer element (VBO element) - RLAPI void rlDisableVertexBufferElement( void ); // Disable vertex buffer element (VBO element) - RLAPI void rlEnableVertexAttribute( unsigned int index ); // Enable vertex attribute index - RLAPI void rlDisableVertexAttribute( unsigned int index ); // Disable vertex attribute index -#if defined( GRAPHICS_API_OPENGL_11 ) - RLAPI void rlEnableStatePointer( int vertexAttribType, void* buffer ); // Enable attribute state pointer - RLAPI void rlDisableStatePointer( int vertexAttribType ); // Disable attribute state pointer +// Vertex buffers state +RLAPI bool RLGL_EnableVertexArray(unsigned int vaoId); // Enable vertex array (VAO, if supported) +RLAPI void RLGL_DisableVertexArray(void); // Disable vertex array (VAO, if supported) +RLAPI void RLGL_EnableVertexBuffer(unsigned int id); // Enable vertex buffer (VBO) +RLAPI void RLGL_DisableVertexBuffer(void); // Disable vertex buffer (VBO) +RLAPI void RLGL_EnableVertexBufferElement(unsigned int id);// Enable vertex buffer element (VBO element) +RLAPI void RLGL_DisableVertexBufferElement(void); // Disable vertex buffer element (VBO element) +RLAPI void RLGL_EnableVertexAttribute(unsigned int index); // Enable vertex attribute index +RLAPI void RLGL_DisableVertexAttribute(unsigned int index);// Disable vertex attribute index +#if defined(GRAPHICS_API_OPENGL_11) +RLAPI void RLGL_EnableStatePointer(int vertexAttribType, void *buffer); // Enable attribute state pointer +RLAPI void RLGL_DisableStatePointer(int vertexAttribType); // Disable attribute state pointer #endif - // Textures state - RLAPI void rlActiveTextureSlot( int slot ); // Select and active a texture slot - RLAPI void rlEnableTexture( unsigned int id ); // Enable texture - RLAPI void rlDisableTexture( void ); // Disable texture - RLAPI void rlEnableTextureCubemap( unsigned int id ); // Enable texture cubemap - RLAPI void rlDisableTextureCubemap( void ); // Disable texture cubemap - RLAPI void rlTextureParameters( unsigned int id, int param, int value ); // Set texture parameters (filter, wrap) - RLAPI void rlCubemapParameters( unsigned int id, int param, int value ); // Set cubemap parameters (filter, wrap) +// Textures state +RLAPI void RLGL_ActiveTextureSlot(int slot); // Select and active a texture slot +RLAPI void RLGL_EnableTexture(unsigned int id); // Enable texture +RLAPI void RLGL_DisableTexture(void); // Disable texture +RLAPI void RLGL_EnableTextureCubemap(unsigned int id); // Enable texture cubemap +RLAPI void RLGL_DisableTextureCubemap(void); // Disable texture cubemap +RLAPI void RLGL_TextureParameters(unsigned int id, int param, int value); // Set texture parameters (filter, wrap) +RLAPI void RLGL_CubemapParameters(unsigned int id, int param, int value); // Set cubemap parameters (filter, wrap) - // Shader state - RLAPI void rlEnableShader( unsigned int id ); // Enable shader program - RLAPI void rlDisableShader( void ); // Disable shader program +// Shader state +RLAPI void RLGL_EnableShader(unsigned int id); // Enable shader program +RLAPI void RLGL_DisableShader(void); // Disable shader program - // Framebuffer state - RLAPI void rlEnableFramebuffer( unsigned int id ); // Enable render texture (fbo) - RLAPI void rlDisableFramebuffer( void ); // Disable render texture (fbo), return to default framebuffer - RLAPI void rlActiveDrawBuffers( int count ); // Activate multiple draw color buffers +// Framebuffer state +RLAPI void RLGL_EnableFramebuffer(unsigned int id); // Enable render texture (fbo) +RLAPI void RLGL_DisableFramebuffer(void); // Disable render texture (fbo), return to default framebuffer +RLAPI void RLGL_ActiveDrawBuffers(int count); // Activate multiple draw color buffers +RLAPI void RLGL_BlitFramebuffer(int srcX, int srcY, int srcWidth, int srcHeight, int dstX, int dstY, int dstWidth, int dstHeight, int bufferMask); // Blit active framebuffer to main framebuffer - // General render state - RLAPI void rlEnableColorBlend( void ); // Enable color blending - RLAPI void rlDisableColorBlend( void ); // Disable color blending - RLAPI void rlEnableDepthTest( void ); // Enable depth test - RLAPI void rlDisableDepthTest( void ); // Disable depth test - RLAPI void rlEnableDepthMask( void ); // Enable depth write - RLAPI void rlDisableDepthMask( void ); // Disable depth write - RLAPI void rlEnableBackfaceCulling( void ); // Enable backface culling - RLAPI void rlDisableBackfaceCulling( void ); // Disable backface culling - RLAPI void rlSetCullFace( int mode ); // Set face culling mode - RLAPI void rlEnableScissorTest( void ); // Enable scissor test - RLAPI void rlDisableScissorTest( void ); // Disable scissor test - RLAPI void rlScissor( int x, int y, int width, int height ); // Scissor test - RLAPI void rlEnableWireMode( void ); // Enable wire mode - RLAPI void rlDisableWireMode( void ); // Disable wire mode - RLAPI void rlSetLineWidth( float width ); // Set the line drawing width - RLAPI float rlGetLineWidth( void ); // Get the line drawing width - RLAPI void rlEnableSmoothLines( void ); // Enable line aliasing - RLAPI void rlDisableSmoothLines( void ); // Disable line aliasing - RLAPI void rlEnableStereoRender( void ); // Enable stereo rendering - RLAPI void rlDisableStereoRender( void ); // Disable stereo rendering - RLAPI bool rlIsStereoRenderEnabled( void ); // Check if stereo render is enabled +// General render state +RLAPI void RLGL_EnableColorBlend(void); // Enable color blending +RLAPI void RLGL_DisableColorBlend(void); // Disable color blending +RLAPI void RLGL_EnableDepthTest(void); // Enable depth test +RLAPI void RLGL_DisableDepthTest(void); // Disable depth test +RLAPI void RLGL_EnableDepthMask(void); // Enable depth write +RLAPI void RLGL_DisableDepthMask(void); // Disable depth write +RLAPI void RLGL_EnableBackfaceCulling(void); // Enable backface culling +RLAPI void RLGL_DisableBackfaceCulling(void); // Disable backface culling +RLAPI void RLGL_SetCullFace(int mode); // Set face culling mode +RLAPI void RLGL_EnableScissorTest(void); // Enable scissor test +RLAPI void RLGL_DisableScissorTest(void); // Disable scissor test +RLAPI void RLGL_Scissor(int x, int y, int width, int height); // Scissor test +RLAPI void RLGL_EnableWireMode(void); // Enable wire mode +RLAPI void RLGL_EnablePointMode(void); // Enable point mode +RLAPI void RLGL_DisableWireMode(void); // Disable wire mode ( and point ) maybe rename +RLAPI void RLGL_SetLineWidth(float width); // Set the line drawing width +RLAPI float RLGL_GetLineWidth(void); // Get the line drawing width +RLAPI void RLGL_EnableSmoothLines(void); // Enable line aliasing +RLAPI void RLGL_DisableSmoothLines(void); // Disable line aliasing +RLAPI void RLGL_EnableStereoRender(void); // Enable stereo rendering +RLAPI void RLGL_DisableStereoRender(void); // Disable stereo rendering +RLAPI bool RLGL_IsStereoRenderEnabled(void); // Check if stereo render is enabled - RLAPI void rlClearColor( unsigned char r, unsigned char g, unsigned char b, unsigned char a ); // Clear color buffer with color - RLAPI void rlClearScreenBuffers( void ); // Clear used screen buffers (color and depth) - RLAPI void rlCheckErrors( void ); // Check and log OpenGL error codes - RLAPI void rlSetBlendMode( int mode ); // Set blending mode - RLAPI void rlSetBlendFactors( int glSrcFactor, int glDstFactor, int glEquation ); // Set blending mode factor and equation (using OpenGL factors) - RLAPI void rlSetBlendFactorsSeparate( - int glSrcRGB, - int glDstRGB, - int glSrcAlpha, - int glDstAlpha, - int glEqRGB, - int glEqAlpha - ); // Set blending mode factors and equations separately (using OpenGL factors) +RLAPI void RLGL_ClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Clear color buffer with color +RLAPI void RLGL_ClearScreenBuffers(void); // Clear used screen buffers (color and depth) +RLAPI void RLGL_CheckErrors(void); // Check and log OpenGL error codes +RLAPI void RLGL_SetBlendMode(int mode); // Set blending mode +RLAPI void RLGL_SetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation); // Set blending mode factor and equation (using OpenGL factors) +RLAPI void RLGL_SetBlendFactorsSeparate(int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB, int glEqAlpha); // Set blending mode factors and equations separately (using OpenGL factors) - //------------------------------------------------------------------------------------ - // Functions Declaration - rlgl functionality - //------------------------------------------------------------------------------------ - // rlgl initialization functions - RLAPI void rlglInit( int width, int height ); // Initialize rlgl (buffers, shaders, textures, states) - RLAPI void rlglClose( void ); // De-initialize rlgl (buffers, shaders, textures) - RLAPI void rlLoadExtensions( void* loader ); // Load OpenGL extensions (loader function required) - RLAPI int rlGetVersion( void ); // Get current OpenGL version - RLAPI void rlSetFramebufferWidth( int width ); // Set current framebuffer width - RLAPI int rlGetFramebufferWidth( void ); // Get default framebuffer width - RLAPI void rlSetFramebufferHeight( int height ); // Set current framebuffer height - RLAPI int rlGetFramebufferHeight( void ); // Get default framebuffer height +//------------------------------------------------------------------------------------ +// Functions Declaration - RLGL_gl functionality +//------------------------------------------------------------------------------------ +// RLGL_gl initialization functions +RLAPI void RLGL_Init(int width, int height); // Initialize RLGL_gl (buffers, shaders, textures, states) +RLAPI void RLGL_Close(void); // De-initialize RLGL_gl (buffers, shaders, textures) +RLAPI void RLGL_LoadExtensions(void *loader); // Load OpenGL extensions (loader function required) +RLAPI int RLGL_GetVersion(void); // Get current OpenGL version +RLAPI void RLGL_SetFramebufferWidth(int width); // Set current framebuffer width +RLAPI int RLGL_GetFramebufferWidth(void); // Get default framebuffer width +RLAPI void RLGL_SetFramebufferHeight(int height); // Set current framebuffer height +RLAPI int RLGL_GetFramebufferHeight(void); // Get default framebuffer height - RLAPI unsigned int rlGetTextureIdDefault( void ); // Get default texture id - RLAPI unsigned int rlGetShaderIdDefault( void ); // Get default shader id - RLAPI int* rlGetShaderLocsDefault( void ); // Get default shader locations +RLAPI unsigned int RLGL_GetTextureIdDefault(void); // Get default texture id +RLAPI unsigned int RLGL_GetShaderIdDefault(void); // Get default shader id +RLAPI int *RLGL_GetShaderLocsDefault(void); // Get default shader locations - // Render batch management - // NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode - // but this render batch API is exposed in case of custom batches are required - RLAPI rlRenderBatch rlLoadRenderBatch( int numBuffers, int bufferElements ); // Load a render batch system - RLAPI void rlUnloadRenderBatch( rlRenderBatch batch ); // Unload render batch system - RLAPI void rlDrawRenderBatch( rlRenderBatch* batch ); // Draw render batch data (Update->Draw->Reset) - RLAPI void rlSetRenderBatchActive( rlRenderBatch* batch ); // Set the active render batch for rlgl (NULL for default internal) - RLAPI void rlDrawRenderBatchActive( void ); // Update and draw internal render batch - RLAPI bool rlCheckRenderBatchLimit( int vCount ); // Check internal buffer overflow for a given number of vertex +// Render batch management +// NOTE: RLGL_gl provides a default render batch to behave like OpenGL 1.1 immediate mode +// but this render batch API is exposed in case of custom batches are required +RLAPI RLGL_RenderBatch RLGL_LoadRenderBatch(int numBuffers, int bufferElements); // Load a render batch system +RLAPI void RLGL_UnloadRenderBatch(RLGL_RenderBatch batch); // Unload render batch system +RLAPI void RLGL_DrawRenderBatch(RLGL_RenderBatch *batch); // Draw render batch data (Update->Draw->Reset) +RLAPI void RLGL_SetRenderBatchActive(RLGL_RenderBatch *batch); // Set the active render batch for RLGL_gl (NULL for default internal) +RLAPI void RLGL_DrawRenderBatchActive(void); // Update and draw internal render batch +RLAPI bool RLGL_CheckRenderBatchLimit(int vCount); // Check internal buffer overflow for a given number of vertex - RLAPI void rlSetTexture( unsigned int id ); // Set current texture for render batch and check buffers limits +RLAPI void RLGL_SetTexture(unsigned int id); // Set current texture for render batch and check buffers limits - //------------------------------------------------------------------------------------------------------------------------ +//------------------------------------------------------------------------------------------------------------------------ - // Vertex buffers management - RLAPI unsigned int rlLoadVertexArray( void ); // Load vertex array (vao) if supported - RLAPI unsigned int rlLoadVertexBuffer( const void* buffer, int size, bool dynamic ); // Load a vertex buffer attribute - RLAPI unsigned int rlLoadVertexBufferElement( const void* buffer, int size, bool dynamic ); // Load a new attributes element buffer - RLAPI void rlUpdateVertexBuffer( unsigned int bufferId, const void* data, int dataSize, int offset ); // Update GPU buffer with new data - RLAPI void rlUpdateVertexBufferElements( unsigned int id, const void* data, int dataSize, int offset ); // Update vertex buffer elements with new data - RLAPI void rlUnloadVertexArray( unsigned int vaoId ); - RLAPI void rlUnloadVertexBuffer( unsigned int vboId ); - RLAPI void rlSetVertexAttribute( unsigned int index, int compSize, int type, bool normalized, int stride, const void* pointer ); - RLAPI void rlSetVertexAttributeDivisor( unsigned int index, int divisor ); - RLAPI void rlSetVertexAttributeDefault( int locIndex, const void* value, int attribType, int count ); // Set vertex attribute default value - RLAPI void rlDrawVertexArray( int offset, int count ); - RLAPI void rlDrawVertexArrayElements( int offset, int count, const void* buffer ); - RLAPI void rlDrawVertexArrayInstanced( int offset, int count, int instances ); - RLAPI void rlDrawVertexArrayElementsInstanced( int offset, int count, const void* buffer, int instances ); +// Vertex buffers management +RLAPI unsigned int RLGL_LoadVertexArray(void); // Load vertex array (vao) if supported +RLAPI unsigned int RLGL_LoadVertexBuffer(const void *buffer, int size, bool dynamic); // Load a vertex buffer attribute +RLAPI unsigned int RLGL_LoadVertexBufferElement(const void *buffer, int size, bool dynamic); // Load a new attributes element buffer +RLAPI void RLGL_UpdateVertexBuffer(unsigned int bufferId, const void *data, int dataSize, int offset); // Update GPU buffer with new data +RLAPI void RLGL_UpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset); // Update vertex buffer elements with new data +RLAPI void RLGL_UnloadVertexArray(unsigned int vaoId); +RLAPI void RLGL_UnloadVertexBuffer(unsigned int vboId); +RLAPI void RLGL_SetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, const void *pointer); +RLAPI void RLGL_SetVertexAttributeDivisor(unsigned int index, int divisor); +RLAPI void RLGL_SetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count); // Set vertex attribute default value +RLAPI void RLGL_DrawVertexArray(int offset, int count); +RLAPI void RLGL_DrawVertexArrayElements(int offset, int count, const void *buffer); +RLAPI void RLGL_DrawVertexArrayInstanced(int offset, int count, int instances); +RLAPI void RLGL_DrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances); - // Textures management - RLAPI unsigned int rlLoadTexture( const void* data, int width, int height, int format, int mipmapCount ); // Load texture in GPU - RLAPI unsigned int rlLoadTextureDepth( int width, int height, bool useRenderBuffer ); // Load depth texture/renderbuffer (to be attached to fbo) - RLAPI unsigned int rlLoadTextureCubemap( const void* data, int size, int format ); // Load texture cubemap - RLAPI void rlUpdateTexture( unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void* data ); // Update GPU texture with - // new data - RLAPI void - rlGetGlTextureFormats( int format, unsigned int* glInternalFormat, unsigned int* glFormat, unsigned int* glType ); // Get OpenGL internal formats - RLAPI const char* rlGetPixelFormatName( unsigned int format ); // Get name string for pixel format - RLAPI void rlUnloadTexture( unsigned int id ); // Unload texture from GPU memory - RLAPI void rlGenTextureMipmaps( unsigned int id, int width, int height, int format, int* mipmaps ); // Generate mipmap data for selected texture - RLAPI void* rlReadTexturePixels( unsigned int id, int width, int height, int format ); // Read texture pixel data - RLAPI unsigned char* rlReadScreenPixels( int width, int height ); // Read screen pixel data (color buffer) +// Textures management +RLAPI unsigned int RLGL_LoadTexture(const void *data, int width, int height, int format, int mipmapCount); // Load texture in GPU +RLAPI unsigned int RLGL_LoadTextureDepth(int width, int height, bool useRenderBuffer); // Load depth texture/renderbuffer (to be attached to fbo) +RLAPI unsigned int RLGL_LoadTextureCubemap(const void *data, int size, int format); // Load texture cubemap +RLAPI void RLGL_UpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data); // Update GPU texture with new data +RLAPI void RLGL_GetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType); // Get OpenGL internal formats +RLAPI const char *RLGL_GetPixelFormatName(unsigned int format); // Get name string for pixel format +RLAPI void RLGL_UnloadTexture(unsigned int id); // Unload texture from GPU memory +RLAPI void RLGL_GenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps); // Generate mipmap data for selected texture +RLAPI void *RLGL_ReadTexturePixels(unsigned int id, int width, int height, int format); // Read texture pixel data +RLAPI unsigned char *RLGL_ReadScreenPixels(int width, int height); // Read screen pixel data (color buffer) - // Framebuffer management (fbo) - RLAPI unsigned int rlLoadFramebuffer( int width, int height ); // Load an empty framebuffer - RLAPI void rlFramebufferAttach( unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel ); // Attach texture/renderbuffer to a - // framebuffer - RLAPI bool rlFramebufferComplete( unsigned int id ); // Verify framebuffer is complete - RLAPI void rlUnloadFramebuffer( unsigned int id ); // Delete framebuffer from GPU +// Framebuffer management (fbo) +RLAPI unsigned int RLGL_LoadFramebuffer(int width, int height); // Load an empty framebuffer +RLAPI void RLGL_FramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel); // Attach texture/renderbuffer to a framebuffer +RLAPI bool RLGL_FramebufferComplete(unsigned int id); // Verify framebuffer is complete +RLAPI void RLGL_UnloadFramebuffer(unsigned int id); // Delete framebuffer from GPU - // Shaders management - RLAPI unsigned int rlLoadShaderCode( const char* vsCode, const char* fsCode ); // Load shader from code strings - RLAPI unsigned int rlCompileShader( - const char* shaderCode, - int type - ); // Compile custom shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER) - RLAPI unsigned int rlLoadShaderProgram( unsigned int vShaderId, unsigned int fShaderId ); // Load custom shader program - RLAPI void rlUnloadShaderProgram( unsigned int id ); // Unload shader program - RLAPI int rlGetLocationUniform( unsigned int shaderId, const char* uniformName ); // Get shader location uniform - RLAPI int rlGetLocationAttrib( unsigned int shaderId, const char* attribName ); // Get shader location attribute - RLAPI void rlSetUniform( int locIndex, const void* value, int uniformType, int count ); // Set shader value uniform - RLAPI void rlSetUniformMatrix( int locIndex, Matrix mat ); // Set shader value matrix - RLAPI void rlSetUniformSampler( int locIndex, unsigned int textureId ); // Set shader value sampler - RLAPI void rlSetShader( unsigned int id, int* locs ); // Set shader currently active (id and locations) +// Shaders management +RLAPI unsigned int RLGL_LoadShaderCode(const char *vsCode, const char *fsCode); // Load shader from code strings +RLAPI unsigned int RLGL_CompileShader(const char *shaderCode, int type); // Compile custom shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER) +RLAPI unsigned int RLGL_LoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId); // Load custom shader program +RLAPI void RLGL_UnloadShaderProgram(unsigned int id); // Unload shader program +RLAPI int RLGL_GetLocationUniform(unsigned int shaderId, const char *uniformName); // Get shader location uniform +RLAPI int RLGL_GetLocationAttrib(unsigned int shaderId, const char *attribName); // Get shader location attribute +RLAPI void RLGL_SetUniform(int locIndex, const void *value, int uniformType, int count); // Set shader value uniform +RLAPI void RLGL_SetUniformMatrix(int locIndex, RL_Matrix mat); // Set shader value matrix +RLAPI void RLGL_SetUniformSampler(int locIndex, unsigned int textureId); // Set shader value sampler +RLAPI void RLGL_SetShader(unsigned int id, int *locs); // Set shader currently active (id and locations) - // Compute shader management - RLAPI unsigned int rlLoadComputeShaderProgram( unsigned int shaderId ); // Load compute shader program - RLAPI void rlComputeShaderDispatch( - unsigned int groupX, - unsigned int groupY, - unsigned int groupZ - ); // Dispatch compute shader (equivalent to *draw* for graphics pipeline) +// Compute shader management +RLAPI unsigned int RLGL_LoadComputeShaderProgram(unsigned int shaderId); // Load compute shader program +RLAPI void RLGL_ComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ); // Dispatch compute shader (equivalent to *draw* for graphics pipeline) - // Shader buffer storage object management (ssbo) - RLAPI unsigned int rlLoadShaderBuffer( unsigned int size, const void* data, int usageHint ); // Load shader storage buffer object (SSBO) - RLAPI void rlUnloadShaderBuffer( unsigned int ssboId ); // Unload shader storage buffer object (SSBO) - RLAPI void rlUpdateShaderBuffer( unsigned int id, const void* data, unsigned int dataSize, unsigned int offset ); // Update SSBO buffer data - RLAPI void rlBindShaderBuffer( unsigned int id, unsigned int index ); // Bind SSBO buffer - RLAPI void rlReadShaderBuffer( unsigned int id, void* dest, unsigned int count, unsigned int offset ); // Read SSBO buffer data (GPU->CPU) - RLAPI void rlCopyShaderBuffer( - unsigned int destId, - unsigned int srcId, - unsigned int destOffset, - unsigned int srcOffset, - unsigned int count - ); // Copy SSBO data between buffers - RLAPI unsigned int rlGetShaderBufferSize( unsigned int id ); // Get SSBO buffer size +// Shader buffer storage object management (ssbo) +RLAPI unsigned int RLGL_LoadShaderBuffer(unsigned int size, const void *data, int usageHint); // Load shader storage buffer object (SSBO) +RLAPI void RLGL_UnloadShaderBuffer(unsigned int ssboId); // Unload shader storage buffer object (SSBO) +RLAPI void RLGL_UpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset); // Update SSBO buffer data +RLAPI void RLGL_BindShaderBuffer(unsigned int id, unsigned int index); // Bind SSBO buffer +RLAPI void RLGL_ReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset); // Read SSBO buffer data (GPU->CPU) +RLAPI void RLGL_CopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count); // Copy SSBO data between buffers +RLAPI unsigned int RLGL_GetShaderBufferSize(unsigned int id); // Get SSBO buffer size - // Buffer management - RLAPI void rlBindImageTexture( unsigned int id, unsigned int index, int format, bool readonly ); // Bind image texture +// Buffer management +RLAPI void RLGL_BindImageTexture(unsigned int id, unsigned int index, int format, bool readonly); // Bind image texture - // Matrix state management - RLAPI Matrix rlGetMatrixModelview( void ); // Get internal modelview matrix - RLAPI Matrix rlGetMatrixProjection( void ); // Get internal projection matrix - RLAPI Matrix rlGetMatrixTransform( void ); // Get internal accumulated transform matrix - RLAPI Matrix rlGetMatrixProjectionStereo( int eye ); // Get internal projection matrix for stereo render (selected eye) - RLAPI Matrix rlGetMatrixViewOffsetStereo( int eye ); // Get internal view offset matrix for stereo render (selected eye) - RLAPI void rlSetMatrixProjection( Matrix proj ); // Set a custom projection matrix (replaces internal projection matrix) - RLAPI void rlSetMatrixModelview( Matrix view ); // Set a custom modelview matrix (replaces internal modelview matrix) - RLAPI void rlSetMatrixProjectionStereo( Matrix right, Matrix left ); // Set eyes projection matrices for stereo rendering - RLAPI void rlSetMatrixViewOffsetStereo( Matrix right, Matrix left ); // Set eyes view offsets matrices for stereo rendering +// RL_Matrix state management +RLAPI RL_Matrix RLGL_GetMatrixModelview(void); // Get internal modelview matrix +RLAPI RL_Matrix RLGL_GetMatrixProjection(void); // Get internal projection matrix +RLAPI RL_Matrix RLGL_GetMatrixTransform(void); // Get internal accumulated transform matrix +RLAPI RL_Matrix RLGL_GetMatrixProjectionStereo(int eye); // Get internal projection matrix for stereo render (selected eye) +RLAPI RL_Matrix RLGL_GetMatrixViewOffsetStereo(int eye); // Get internal view offset matrix for stereo render (selected eye) +RLAPI void RLGL_SetMatrixProjection(RL_Matrix proj); // Set a custom projection matrix (replaces internal projection matrix) +RLAPI void RLGL_SetMatrixModelview(RL_Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix) +RLAPI void RLGL_SetMatrixProjectionStereo(RL_Matrix right, RL_Matrix left); // Set eyes projection matrices for stereo rendering +RLAPI void RLGL_SetMatrixViewOffsetStereo(RL_Matrix right, RL_Matrix left); // Set eyes view offsets matrices for stereo rendering - // Quick and dirty cube/quad buffers load->draw->unload - RLAPI void rlLoadDrawCube( void ); // Load and draw a cube - RLAPI void rlLoadDrawQuad( void ); // Load and draw a quad +// Quick and dirty cube/quad buffers load->draw->unload +RLAPI void RLGL_LoadDrawCube(void); // Load and draw a cube +RLAPI void RLGL_LoadDrawQuad(void); // Load and draw a quad -#if defined( __cplusplus ) +#if defined(__cplusplus) } #endif -#endif // RLGL_H +#endif // RLGL_H /*********************************************************************************** - * - * RLGL IMPLEMENTATION - * - ************************************************************************************/ +* +* RLGL_GLOBAL_DATA IMPLEMENTATION +* +************************************************************************************/ -#if defined( RLGL_IMPLEMENTATION ) +#if defined(RLGL_IMPLEMENTATION) -#if defined( GRAPHICS_API_OPENGL_11 ) -#if defined( __APPLE__ ) -#include // OpenGL 1.1 library for OSX -#include // OpenGL extensions library -#else -// APIENTRY for OpenGL function pointer declarations is required -#if ! defined( APIENTRY ) -#if defined( _WIN32 ) -#define APIENTRY __stdcall -#else -#define APIENTRY -#endif -#endif -// WINGDIAPI definition. Some Windows OpenGL headers need it -#if ! defined( WINGDIAPI ) && defined( _WIN32 ) -#define WINGDIAPI __declspec( dllimport ) +#if defined(GRAPHICS_API_OPENGL_11) + #if defined(__APPLE__) + #include // OpenGL 1.1 library for OSX + #include // OpenGL extensions library + #else + // APIENTRY for OpenGL function pointer declarations is required + #if !defined(APIENTRY) + #if defined(_WIN32) + #define APIENTRY __stdcall + #else + #define APIENTRY + #endif + #endif + // WINGDIAPI definition. Some Windows OpenGL headers need it + #if !defined(WINGDIAPI) && defined(_WIN32) + #define WINGDIAPI __declspec(dllimport) + #endif + + #include // OpenGL 1.1 library + #endif #endif -#include // OpenGL 1.1 library -#endif +#if defined(GRAPHICS_API_OPENGL_33) + #define GLAD_MALLOC RL_MALLOC + #define GLAD_FREE RL_FREE + + #define GLAD_GL_IMPLEMENTATION + #include "external/glad.h" // GLAD extensions loading library, includes OpenGL headers #endif -#if defined( GRAPHICS_API_OPENGL_33 ) -#define GLAD_MALLOC RL_MALLOC -#define GLAD_FREE RL_FREE +#if defined(GRAPHICS_API_OPENGL_ES3) + #include // OpenGL ES 3.0 library + #define GL_GLEXT_PROTOTYPES + #include // OpenGL ES 2.0 extensions library +#elif defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: OpenGL ES 2.0 can be enabled on PLATFORM_DESKTOP, + // in that case, functions are loaded from a custom glad for OpenGL ES 2.0 + #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL) + #define GLAD_GLES2_IMPLEMENTATION + #include "external/glad_gles2.h" + #else + #define GL_GLEXT_PROTOTYPES + //#include // EGL library -> not required, platform layer + #include // OpenGL ES 2.0 library + #include // OpenGL ES 2.0 extensions library + #endif -#define GLAD_GL_IMPLEMENTATION -#include "external/glad.h" // GLAD extensions loading library, includes OpenGL headers + // It seems OpenGL ES 2.0 instancing entry points are not defined on Raspberry Pi + // provided headers (despite being defined in official Khronos GLES2 headers) + #if defined(PLATFORM_DRM) + typedef void (GL_APIENTRYP PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount); + typedef void (GL_APIENTRYP PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount); + typedef void (GL_APIENTRYP PFNGLVERTEXATTRIBDIVISOREXTPROC) (GLuint index, GLuint divisor); + #endif #endif -#if defined( GRAPHICS_API_OPENGL_ES2 ) -// NOTE: OpenGL ES 2.0 can be enabled on PLATFORM_DESKTOP, -// in that case, functions are loaded from a custom glad for OpenGL ES 2.0 -#if defined( PLATFORM_DESKTOP ) -#define GLAD_GLES2_IMPLEMENTATION -#include "external/glad_gles2.h" -#else -#define GL_GLEXT_PROTOTYPES -// #include // EGL library -> not required, platform layer -#include // OpenGL ES 2.0 library -#include // OpenGL ES 2.0 extensions library -#endif - -// It seems OpenGL ES 2.0 instancing entry points are not defined on Raspberry Pi -// provided headers (despite being defined in official Khronos GLES2 headers) -#if defined( PLATFORM_DRM ) -typedef void( GL_APIENTRYP PFNGLDRAWARRAYSINSTANCEDEXTPROC )( GLenum mode, GLint start, GLsizei count, GLsizei primcount ); -typedef void( GL_APIENTRYP PFNGLDRAWELEMENTSINSTANCEDEXTPROC )( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount ); -typedef void( GL_APIENTRYP PFNGLVERTEXATTRIBDIVISOREXTPROC )( GLuint index, GLuint divisor ); -#endif -#endif - -#include // Required for: malloc(), free() -#include // Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading] -#include // Required for: sqrtf(), sinf(), cosf(), floor(), log() +#include // Required for: malloc(), free() +#include // Required for: strcmp(), strlen() [Used in RLGL_Init(), on extensions loading] +#include // Required for: sqrtf(), sinf(), cosf(), floor(), log() //---------------------------------------------------------------------------------- // Defines and Macros //---------------------------------------------------------------------------------- #ifndef PI -#define PI 3.14159265358979323846f + #define PI 3.14159265358979323846f #endif #ifndef DEG2RAD -#define DEG2RAD ( PI / 180.0f ) + #define DEG2RAD (PI/180.0f) #endif #ifndef RAD2DEG -#define RAD2DEG ( 180.0f / PI ) + #define RAD2DEG (180.0f/PI) #endif #ifndef GL_SHADING_LANGUAGE_VERSION -#define GL_SHADING_LANGUAGE_VERSION 0x8B8C + #define GL_SHADING_LANGUAGE_VERSION 0x8B8C #endif #ifndef GL_COMPRESSED_RGB_S3TC_DXT1_EXT -#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 + #define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 #endif #ifndef GL_COMPRESSED_RGBA_S3TC_DXT1_EXT -#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 + #define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 #endif #ifndef GL_COMPRESSED_RGBA_S3TC_DXT3_EXT -#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 + #define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 #endif #ifndef GL_COMPRESSED_RGBA_S3TC_DXT5_EXT -#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 + #define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 #endif #ifndef GL_ETC1_RGB8_OES -#define GL_ETC1_RGB8_OES 0x8D64 + #define GL_ETC1_RGB8_OES 0x8D64 #endif #ifndef GL_COMPRESSED_RGB8_ETC2 -#define GL_COMPRESSED_RGB8_ETC2 0x9274 + #define GL_COMPRESSED_RGB8_ETC2 0x9274 #endif #ifndef GL_COMPRESSED_RGBA8_ETC2_EAC -#define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278 + #define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278 #endif #ifndef GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG -#define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00 + #define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00 #endif #ifndef GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG -#define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02 + #define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02 #endif #ifndef GL_COMPRESSED_RGBA_ASTC_4x4_KHR -#define GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93b0 + #define GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93b0 #endif #ifndef GL_COMPRESSED_RGBA_ASTC_8x8_KHR -#define GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93b7 + #define GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93b7 #endif #ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT -#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF + #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF #endif #ifndef GL_TEXTURE_MAX_ANISOTROPY_EXT -#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE + #define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE #endif -#if defined( GRAPHICS_API_OPENGL_11 ) -#define GL_UNSIGNED_SHORT_5_6_5 0x8363 -#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 -#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#if defined(GRAPHICS_API_OPENGL_11) + #define GL_UNSIGNED_SHORT_5_6_5 0x8363 + #define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 + #define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 #endif -#if defined( GRAPHICS_API_OPENGL_21 ) -#define GL_LUMINANCE 0x1909 -#define GL_LUMINANCE_ALPHA 0x190A +#if defined(GRAPHICS_API_OPENGL_21) + #define GL_LUMINANCE 0x1909 + #define GL_LUMINANCE_ALPHA 0x190A #endif -#if defined( GRAPHICS_API_OPENGL_ES2 ) -#define glClearDepth glClearDepthf -#define GL_READ_FRAMEBUFFER GL_FRAMEBUFFER -#define GL_DRAW_FRAMEBUFFER GL_FRAMEBUFFER +#if defined(GRAPHICS_API_OPENGL_ES2) + #define glClearDepth glClearDepthf + #if !defined(GRAPHICS_API_OPENGL_ES3) + #define GL_READ_FRAMEBUFFER GL_FRAMEBUFFER + #define GL_DRAW_FRAMEBUFFER GL_FRAMEBUFFER + #endif #endif // Default shader vertex attribute names to set location points #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION -#define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: 0 + #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Bound by default to shader location: 0 #endif #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD -#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: 1 + #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Bound by default to shader location: 1 #endif #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL -#define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: 2 + #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Bound by default to shader location: 2 #endif #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR -#define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: 3 + #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Bound by default to shader location: 3 #endif #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT -#define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: 4 + #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Bound by default to shader location: 4 #endif #ifndef RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 -#define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Bound by default to shader location: 5 + #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Bound by default to shader location: 5 #endif #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MVP -#define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix + #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix #endif #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW -#define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix + #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix #endif #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION -#define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix + #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix #endif #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL -#define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix + #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix #endif #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL -#define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView)) + #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView)) #endif #ifndef RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR -#define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color) + #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color) #endif #ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 -#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0) + #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0) #endif #ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 -#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1) + #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1) #endif #ifndef RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 -#define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2) + #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2) #endif //---------------------------------------------------------------------------------- // Types and Structures Definition //---------------------------------------------------------------------------------- -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) -typedef struct rlglData -{ - rlRenderBatch* currentBatch; // Current render batch - rlRenderBatch defaultBatch; // Default internal render batch +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +typedef struct RLGL_glData { + RLGL_RenderBatch *currentBatch; // Current render batch + RLGL_RenderBatch defaultBatch; // Default internal render batch - struct - { - int vertexCounter; // Current active render batch vertex counter (generic, used for all batches) - float texcoordx, texcoordy; // Current active texture coordinate (added on glVertex*()) - float normalx, normaly, normalz; // Current active normal (added on glVertex*()) - unsigned char colorr, colorg, colorb, colora; // Current active color (added on glVertex*()) + struct { + int vertexCounter; // Current active render batch vertex counter (generic, used for all batches) + float texcoordx, texcoordy; // Current active texture coordinate (added on glVertex*()) + float normalx, normaly, normalz; // Current active normal (added on glVertex*()) + unsigned char colorr, colorg, colorb, colora; // Current active color (added on glVertex*()) - int currentMatrixMode; // Current matrix mode - Matrix* currentMatrix; // Current matrix pointer - Matrix modelview; // Default modelview matrix - Matrix projection; // Default projection matrix - Matrix transform; // Transform matrix to be used with rlTranslate, rlRotate, rlScale - bool transformRequired; // Require transform matrix application to current draw-call vertex (if required) - Matrix stack[ RL_MAX_MATRIX_STACK_SIZE ]; // Matrix stack for push/pop - int stackCounter; // Matrix stack counter + int currentMatrixMode; // Current matrix mode + RL_Matrix *currentMatrix; // Current matrix pointer + RL_Matrix modelview; // Default modelview matrix + RL_Matrix projection; // Default projection matrix + RL_Matrix transform; // Transform matrix to be used with RLGL_Translate, RLGL_Rotate, RLGL_Scale + bool transformRequired; // Require transform matrix application to current draw-call vertex (if required) + RL_Matrix stack[RL_MAX_MATRIX_STACK_SIZE];// RL_Matrix stack for push/pop + int stackCounter; // RL_Matrix stack counter - unsigned int defaultTextureId; // Default texture used on shapes/poly drawing (required by shader) - unsigned int activeTextureId[ RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS ]; // Active texture ids to be enabled on batch drawing (0 active by default) - unsigned int defaultVShaderId; // Default vertex shader id (used by default shader program) - unsigned int defaultFShaderId; // Default fragment shader id (used by default shader program) - unsigned int defaultShaderId; // Default shader program id, supports vertex color and diffuse texture - int* defaultShaderLocs; // Default shader locations pointer to be used on rendering - unsigned int currentShaderId; // Current shader id to be used on rendering (by default, defaultShaderId) - int* currentShaderLocs; // Current shader locations pointer to be used on rendering (by default, defaultShaderLocs) + unsigned int defaultTextureId; // Default texture used on shapes/poly drawing (required by shader) + unsigned int activeTextureId[RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS]; // Active texture ids to be enabled on batch drawing (0 active by default) + unsigned int defaultVShaderId; // Default vertex shader id (used by default shader program) + unsigned int defaultFShaderId; // Default fragment shader id (used by default shader program) + unsigned int defaultShaderId; // Default shader program id, supports vertex color and diffuse texture + int *defaultShaderLocs; // Default shader locations pointer to be used on rendering + unsigned int currentShaderId; // Current shader id to be used on rendering (by default, defaultShaderId) + int *currentShaderLocs; // Current shader locations pointer to be used on rendering (by default, defaultShaderLocs) - bool stereoRender; // Stereo rendering flag - Matrix projectionStereo[ 2 ]; // VR stereo rendering eyes projection matrices - Matrix viewOffsetStereo[ 2 ]; // VR stereo rendering eyes view offset matrices + bool stereoRender; // Stereo rendering flag + RL_Matrix projectionStereo[2]; // VR stereo rendering eyes projection matrices + RL_Matrix viewOffsetStereo[2]; // VR stereo rendering eyes view offset matrices - // Blending variables - int currentBlendMode; // Blending mode active - int glBlendSrcFactor; // Blending source factor - int glBlendDstFactor; // Blending destination factor - int glBlendEquation; // Blending equation - int glBlendSrcFactorRGB; // Blending source RGB factor - int glBlendDestFactorRGB; // Blending destination RGB factor - int glBlendSrcFactorAlpha; // Blending source alpha factor - int glBlendDestFactorAlpha; // Blending destination alpha factor - int glBlendEquationRGB; // Blending equation for RGB - int glBlendEquationAlpha; // Blending equation for alpha - bool glCustomBlendModeModified; // Custom blending factor and equation modification status + // Blending variables + int currentBlendMode; // Blending mode active + int glBlendSrcFactor; // Blending source factor + int glBlendDstFactor; // Blending destination factor + int glBlendEquation; // Blending equation + int glBlendSrcFactorRGB; // Blending source RGB factor + int glBlendDestFactorRGB; // Blending destination RGB factor + int glBlendSrcFactorAlpha; // Blending source alpha factor + int glBlendDestFactorAlpha; // Blending destination alpha factor + int glBlendEquationRGB; // Blending equation for RGB + int glBlendEquationAlpha; // Blending equation for alpha + bool glCustomBlendModeModified; // Custom blending factor and equation modification status - int framebufferWidth; // Current framebuffer width - int framebufferHeight; // Current framebuffer height + int framebufferWidth; // Current framebuffer width + int framebufferHeight; // Current framebuffer height - } State; // Renderer state + } State; // Renderer state + struct { + bool vao; // VAO support (OpenGL ES2 could not support VAO extension) (GL_ARB_vertex_array_object) + bool instancing; // Instancing supported (GL_ANGLE_instanced_arrays, GL_EXT_draw_instanced + GL_EXT_instanced_arrays) + bool texNPOT; // NPOT textures full support (GL_ARB_texture_non_power_of_two, GL_OES_texture_npot) + bool texDepth; // Depth textures supported (GL_ARB_depth_texture, GL_OES_depth_texture) + bool texDepthWebGL; // Depth textures supported WebGL specific (GL_WEBGL_depth_texture) + bool texFloat32; // float textures support (32 bit per channel) (GL_OES_texture_float) + bool texFloat16; // half float textures support (16 bit per channel) (GL_OES_texture_half_float) + bool texCompDXT; // DDS texture compression support (GL_EXT_texture_compression_s3tc, GL_WEBGL_compressed_texture_s3tc, GL_WEBKIT_WEBGL_compressed_texture_s3tc) + bool texCompETC1; // ETC1 texture compression support (GL_OES_compressed_ETC1_RGB8_texture, GL_WEBGL_compressed_texture_etc1) + bool texCompETC2; // ETC2/EAC texture compression support (GL_ARB_ES3_compatibility) + bool texCompPVRT; // PVR texture compression support (GL_IMG_texture_compression_pvrtc) + bool texCompASTC; // ASTC texture compression support (GL_KHR_texture_compression_astc_hdr, GL_KHR_texture_compression_astc_ldr) + bool texMirrorClamp; // Clamp mirror wrap mode supported (GL_EXT_texture_mirror_clamp) + bool texAnisoFilter; // Anisotropic texture filtering support (GL_EXT_texture_filter_anisotropic) + bool computeShader; // Compute shaders support (GL_ARB_compute_shader) + bool ssbo; // Shader storage buffer object support (GL_ARB_shader_storage_buffer_object) - struct - { - bool vao; // VAO support (OpenGL ES2 could not support VAO extension) (GL_ARB_vertex_array_object) - bool instancing; // Instancing supported (GL_ANGLE_instanced_arrays, GL_EXT_draw_instanced + GL_EXT_instanced_arrays) - bool texNPOT; // NPOT textures full support (GL_ARB_texture_non_power_of_two, GL_OES_texture_npot) - bool texDepth; // Depth textures supported (GL_ARB_depth_texture, GL_OES_depth_texture) - bool texDepthWebGL; // Depth textures supported WebGL specific (GL_WEBGL_depth_texture) - bool texFloat32; // float textures support (32 bit per channel) (GL_OES_texture_float) - bool texFloat16; // half float textures support (16 bit per channel) (GL_OES_texture_half_float) - bool texCompDXT; // DDS texture compression support (GL_EXT_texture_compression_s3tc, GL_WEBGL_compressed_texture_s3tc, - // GL_WEBKIT_WEBGL_compressed_texture_s3tc) - bool texCompETC1; // ETC1 texture compression support (GL_OES_compressed_ETC1_RGB8_texture, GL_WEBGL_compressed_texture_etc1) - bool texCompETC2; // ETC2/EAC texture compression support (GL_ARB_ES3_compatibility) - bool texCompPVRT; // PVR texture compression support (GL_IMG_texture_compression_pvrtc) - bool texCompASTC; // ASTC texture compression support (GL_KHR_texture_compression_astc_hdr, GL_KHR_texture_compression_astc_ldr) - bool texMirrorClamp; // Clamp mirror wrap mode supported (GL_EXT_texture_mirror_clamp) - bool texAnisoFilter; // Anisotropic texture filtering support (GL_EXT_texture_filter_anisotropic) - bool computeShader; // Compute shaders support (GL_ARB_compute_shader) - bool ssbo; // Shader storage buffer object support (GL_ARB_shader_storage_buffer_object) + float maxAnisotropyLevel; // Maximum anisotropy level supported (minimum is 2.0f) + int maxDepthBits; // Maximum bits for depth component - float maxAnisotropyLevel; // Maximum anisotropy level supported (minimum is 2.0f) - int maxDepthBits; // Maximum bits for depth component + } ExtSupported; // Extensions supported flags +} RLGL_glData; - } ExtSupported; // Extensions supported flags -} rlglData; +typedef void *(*RLGL_glLoadProc)(const char *name); // OpenGL extension functions loader signature (same as GLADloadproc) -typedef void* ( *rlglLoadProc )( const char* name ); // OpenGL extension functions loader signature (same as GLADloadproc) - -#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 //---------------------------------------------------------------------------------- // Global Variables Definition //---------------------------------------------------------------------------------- -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) -static rlglData RLGL = { 0 }; -#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +static RLGL_glData RLGL_GLOBAL_DATA = { 0 }; +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 -#if defined( GRAPHICS_API_OPENGL_ES2 ) +#if defined(GRAPHICS_API_OPENGL_ES2) && !defined(GRAPHICS_API_OPENGL_ES3) // NOTE: VAO functionality is exposed through extensions (OES) -static PFNGLGENVERTEXARRAYSOESPROC glGenVertexArrays = NULL; -static PFNGLBINDVERTEXARRAYOESPROC glBindVertexArray = NULL; +static PFNGLGENVERTEXARRAYSOESPROC glGenVertexArrays = NULL; +static PFNGLBINDVERTEXARRAYOESPROC glBindVertexArray = NULL; static PFNGLDELETEVERTEXARRAYSOESPROC glDeleteVertexArrays = NULL; // NOTE: Instancing functionality could also be available through extension -static PFNGLDRAWARRAYSINSTANCEDEXTPROC glDrawArraysInstanced = NULL; +static PFNGLDRAWARRAYSINSTANCEDEXTPROC glDrawArraysInstanced = NULL; static PFNGLDRAWELEMENTSINSTANCEDEXTPROC glDrawElementsInstanced = NULL; -static PFNGLVERTEXATTRIBDIVISOREXTPROC glVertexAttribDivisor = NULL; +static PFNGLVERTEXATTRIBDIVISOREXTPROC glVertexAttribDivisor = NULL; #endif //---------------------------------------------------------------------------------- // Module specific Functions Declaration //---------------------------------------------------------------------------------- -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) -static void rlLoadShaderDefault( void ); // Load default shader -static void rlUnloadShaderDefault( void ); // Unload default shader -#if defined( RLGL_SHOW_GL_DETAILS_INFO ) -static char* rlGetCompressedFormatName( int format ); // Get compressed format official GL identifier name -#endif // RLGL_SHOW_GL_DETAILS_INFO -#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) +static void RLGL_LoadShaderDefault(void); // Load default shader +static void RLGL_UnloadShaderDefault(void); // Unload default shader +#if defined(RLGL_SHOW_GL_DETAILS_INFO) +static const char *RLGL_GetCompressedFormatName(int format); // Get compressed format official GL identifier name +#endif // RLGL_SHOW_GL_DETAILS_INFO +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 -static int rlGetPixelDataSize( int width, int height, int format ); // Get pixel data size in bytes (image or texture) +static int RLGL_GetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes (image or texture) // Auxiliar matrix math functions -static Matrix rlMatrixIdentity( void ); // Get identity matrix -static Matrix rlMatrixMultiply( Matrix left, Matrix right ); // Multiply two matrices +static RL_Matrix RLGL_MatrixIdentity(void); // Get identity matrix +static RL_Matrix RLGL_MatrixMultiply(RL_Matrix left, RL_Matrix right); // Multiply two matrices //---------------------------------------------------------------------------------- -// Module Functions Definition - Matrix operations +// Module Functions Definition - RL_Matrix operations //---------------------------------------------------------------------------------- -#if defined( GRAPHICS_API_OPENGL_11 ) +#if defined(GRAPHICS_API_OPENGL_11) // Fallback to OpenGL 1.1 function calls //--------------------------------------- -void rlMatrixMode( int mode ) +void RLGL_MatrixMode(int mode) { - switch ( mode ) - { - case RL_PROJECTION : - glMatrixMode( GL_PROJECTION ); - break; - case RL_MODELVIEW : - glMatrixMode( GL_MODELVIEW ); - break; - case RL_TEXTURE : - glMatrixMode( GL_TEXTURE ); - break; - default : - break; - } + switch (mode) + { + case RL_PROJECTION: glMatrixMode(GL_PROJECTION); break; + case RL_MODELVIEW: glMatrixMode(GL_MODELVIEW); break; + case RL_TEXTURE: glMatrixMode(GL_TEXTURE); break; + default: break; + } } -void rlFrustum( double left, double right, double bottom, double top, double znear, double zfar ) +void RLGL_Frustum(double left, double right, double bottom, double top, double znear, double zfar) { - glFrustum( left, right, bottom, top, znear, zfar ); + glFrustum(left, right, bottom, top, znear, zfar); } -void rlOrtho( double left, double right, double bottom, double top, double znear, double zfar ) +void RLGL_Ortho(double left, double right, double bottom, double top, double znear, double zfar) { - glOrtho( left, right, bottom, top, znear, zfar ); + glOrtho(left, right, bottom, top, znear, zfar); } -void rlPushMatrix( void ) -{ - glPushMatrix(); -} - -void rlPopMatrix( void ) -{ - glPopMatrix(); -} - -void rlLoadIdentity( void ) -{ - glLoadIdentity(); -} - -void rlTranslatef( float x, float y, float z ) -{ - glTranslatef( x, y, z ); -} - -void rlRotatef( float angle, float x, float y, float z ) -{ - glRotatef( angle, x, y, z ); -} - -void rlScalef( float x, float y, float z ) -{ - glScalef( x, y, z ); -} - -void rlMultMatrixf( const float* matf ) -{ - glMultMatrixf( matf ); -} +void RLGL_PushMatrix(void) { glPushMatrix(); } +void RLGL_PopMatrix(void) { glPopMatrix(); } +void RLGL_LoadIdentity(void) { glLoadIdentity(); } +void RLGL_Translatef(float x, float y, float z) { glTranslatef(x, y, z); } +void RLGL_Rotatef(float angle, float x, float y, float z) { glRotatef(angle, x, y, z); } +void RLGL_Scalef(float x, float y, float z) { glScalef(x, y, z); } +void RLGL_MultMatrixf(const float *matf) { glMultMatrixf(matf); } #endif -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) // Choose the current matrix to be transformed -void rlMatrixMode( int mode ) +void RLGL_MatrixMode(int mode) { - if ( mode == RL_PROJECTION ) - RLGL.State.currentMatrix = &RLGL.State.projection; - else if ( mode == RL_MODELVIEW ) - RLGL.State.currentMatrix = &RLGL.State.modelview; - // else if (mode == RL_TEXTURE) // Not supported + if (mode == RL_PROJECTION) RLGL_GLOBAL_DATA.State.currentMatrix = &RLGL_GLOBAL_DATA.State.projection; + else if (mode == RL_MODELVIEW) RLGL_GLOBAL_DATA.State.currentMatrix = &RLGL_GLOBAL_DATA.State.modelview; + //else if (mode == RL_TEXTURE) // Not supported - RLGL.State.currentMatrixMode = mode; + RLGL_GLOBAL_DATA.State.currentMatrixMode = mode; } -// Push the current matrix into RLGL.State.stack -void rlPushMatrix( void ) +// Push the current matrix into RLGL_GLOBAL_DATA.State.stack +void RLGL_PushMatrix(void) { - if ( RLGL.State.stackCounter >= RL_MAX_MATRIX_STACK_SIZE ) - TRACELOG( RL_LOG_ERROR, "RLGL: Matrix stack overflow (RL_MAX_MATRIX_STACK_SIZE)" ); + if (RLGL_GLOBAL_DATA.State.stackCounter >= RL_MAX_MATRIX_STACK_SIZE) RL_TRACELOG(RL_LOG_ERROR, "RLGL_GLOBAL_DATA: RL_Matrix stack overflow (RL_MAX_MATRIX_STACK_SIZE)"); - if ( RLGL.State.currentMatrixMode == RL_MODELVIEW ) - { - RLGL.State.transformRequired = true; - RLGL.State.currentMatrix = &RLGL.State.transform; - } + if (RLGL_GLOBAL_DATA.State.currentMatrixMode == RL_MODELVIEW) + { + RLGL_GLOBAL_DATA.State.transformRequired = true; + RLGL_GLOBAL_DATA.State.currentMatrix = &RLGL_GLOBAL_DATA.State.transform; + } - RLGL.State.stack[ RLGL.State.stackCounter ] = *RLGL.State.currentMatrix; - RLGL.State.stackCounter++; + RLGL_GLOBAL_DATA.State.stack[RLGL_GLOBAL_DATA.State.stackCounter] = *RLGL_GLOBAL_DATA.State.currentMatrix; + RLGL_GLOBAL_DATA.State.stackCounter++; } -// Pop lattest inserted matrix from RLGL.State.stack -void rlPopMatrix( void ) +// Pop lattest inserted matrix from RLGL_GLOBAL_DATA.State.stack +void RLGL_PopMatrix(void) { - if ( RLGL.State.stackCounter > 0 ) - { - Matrix mat = RLGL.State.stack[ RLGL.State.stackCounter - 1 ]; - *RLGL.State.currentMatrix = mat; - RLGL.State.stackCounter--; - } + if (RLGL_GLOBAL_DATA.State.stackCounter > 0) + { + RL_Matrix mat = RLGL_GLOBAL_DATA.State.stack[RLGL_GLOBAL_DATA.State.stackCounter - 1]; + *RLGL_GLOBAL_DATA.State.currentMatrix = mat; + RLGL_GLOBAL_DATA.State.stackCounter--; + } - if ( ( RLGL.State.stackCounter == 0 ) && ( RLGL.State.currentMatrixMode == RL_MODELVIEW ) ) - { - RLGL.State.currentMatrix = &RLGL.State.modelview; - RLGL.State.transformRequired = false; - } + if ((RLGL_GLOBAL_DATA.State.stackCounter == 0) && (RLGL_GLOBAL_DATA.State.currentMatrixMode == RL_MODELVIEW)) + { + RLGL_GLOBAL_DATA.State.currentMatrix = &RLGL_GLOBAL_DATA.State.modelview; + RLGL_GLOBAL_DATA.State.transformRequired = false; + } } // Reset current matrix to identity matrix -void rlLoadIdentity( void ) +void RLGL_LoadIdentity(void) { - *RLGL.State.currentMatrix = rlMatrixIdentity(); + *RLGL_GLOBAL_DATA.State.currentMatrix = RLGL_MatrixIdentity(); } // Multiply the current matrix by a translation matrix -void rlTranslatef( float x, float y, float z ) +void RLGL_Translatef(float x, float y, float z) { - Matrix matTranslation = { 1.0f, 0.0f, 0.0f, x, 0.0f, 1.0f, 0.0f, y, 0.0f, 0.0f, 1.0f, z, 0.0f, 0.0f, 0.0f, 1.0f }; + RL_Matrix matTranslation = { + 1.0f, 0.0f, 0.0f, x, + 0.0f, 1.0f, 0.0f, y, + 0.0f, 0.0f, 1.0f, z, + 0.0f, 0.0f, 0.0f, 1.0f + }; - // NOTE: We transpose matrix with multiplication order - *RLGL.State.currentMatrix = rlMatrixMultiply( matTranslation, *RLGL.State.currentMatrix ); + // NOTE: We transpose matrix with multiplication order + *RLGL_GLOBAL_DATA.State.currentMatrix = RLGL_MatrixMultiply(matTranslation, *RLGL_GLOBAL_DATA.State.currentMatrix); } // Multiply the current matrix by a rotation matrix // NOTE: The provided angle must be in degrees -void rlRotatef( float angle, float x, float y, float z ) +void RLGL_Rotatef(float angle, float x, float y, float z) { - Matrix matRotation = rlMatrixIdentity(); + RL_Matrix matRotation = RLGL_MatrixIdentity(); - // Axis vector (x, y, z) normalization - float lengthSquared = x * x + y * y + z * z; - if ( ( lengthSquared != 1.0f ) && ( lengthSquared != 0.0f ) ) - { - float inverseLength = 1.0f / sqrtf( lengthSquared ); - x *= inverseLength; - y *= inverseLength; - z *= inverseLength; - } + // Axis vector (x, y, z) normalization + float lengthSquared = x*x + y*y + z*z; + if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f)) + { + float inverseLength = 1.0f/sqrtf(lengthSquared); + x *= inverseLength; + y *= inverseLength; + z *= inverseLength; + } - // Rotation matrix generation - float sinres = sinf( DEG2RAD * angle ); - float cosres = cosf( DEG2RAD * angle ); - float t = 1.0f - cosres; + // Rotation matrix generation + float sinres = sinf(DEG2RAD*angle); + float cosres = cosf(DEG2RAD*angle); + float t = 1.0f - cosres; - matRotation.m0 = x * x * t + cosres; - matRotation.m1 = y * x * t + z * sinres; - matRotation.m2 = z * x * t - y * sinres; - matRotation.m3 = 0.0f; + matRotation.m0 = x*x*t + cosres; + matRotation.m1 = y*x*t + z*sinres; + matRotation.m2 = z*x*t - y*sinres; + matRotation.m3 = 0.0f; - matRotation.m4 = x * y * t - z * sinres; - matRotation.m5 = y * y * t + cosres; - matRotation.m6 = z * y * t + x * sinres; - matRotation.m7 = 0.0f; + matRotation.m4 = x*y*t - z*sinres; + matRotation.m5 = y*y*t + cosres; + matRotation.m6 = z*y*t + x*sinres; + matRotation.m7 = 0.0f; - matRotation.m8 = x * z * t + y * sinres; - matRotation.m9 = y * z * t - x * sinres; - matRotation.m10 = z * z * t + cosres; - matRotation.m11 = 0.0f; + matRotation.m8 = x*z*t + y*sinres; + matRotation.m9 = y*z*t - x*sinres; + matRotation.m10 = z*z*t + cosres; + matRotation.m11 = 0.0f; - matRotation.m12 = 0.0f; - matRotation.m13 = 0.0f; - matRotation.m14 = 0.0f; - matRotation.m15 = 1.0f; + matRotation.m12 = 0.0f; + matRotation.m13 = 0.0f; + matRotation.m14 = 0.0f; + matRotation.m15 = 1.0f; - // NOTE: We transpose matrix with multiplication order - *RLGL.State.currentMatrix = rlMatrixMultiply( matRotation, *RLGL.State.currentMatrix ); + // NOTE: We transpose matrix with multiplication order + *RLGL_GLOBAL_DATA.State.currentMatrix = RLGL_MatrixMultiply(matRotation, *RLGL_GLOBAL_DATA.State.currentMatrix); } // Multiply the current matrix by a scaling matrix -void rlScalef( float x, float y, float z ) +void RLGL_Scalef(float x, float y, float z) { - Matrix matScale = { x, 0.0f, 0.0f, 0.0f, 0.0f, y, 0.0f, 0.0f, 0.0f, 0.0f, z, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; + RL_Matrix matScale = { + x, 0.0f, 0.0f, 0.0f, + 0.0f, y, 0.0f, 0.0f, + 0.0f, 0.0f, z, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }; - // NOTE: We transpose matrix with multiplication order - *RLGL.State.currentMatrix = rlMatrixMultiply( matScale, *RLGL.State.currentMatrix ); + // NOTE: We transpose matrix with multiplication order + *RLGL_GLOBAL_DATA.State.currentMatrix = RLGL_MatrixMultiply(matScale, *RLGL_GLOBAL_DATA.State.currentMatrix); } // Multiply the current matrix by another matrix -void rlMultMatrixf( const float* matf ) +void RLGL_MultMatrixf(const float *matf) { - // Matrix creation from array - Matrix mat = { matf[ 0 ], matf[ 4 ], matf[ 8 ], matf[ 12 ], matf[ 1 ], matf[ 5 ], matf[ 9 ], matf[ 13 ], - matf[ 2 ], matf[ 6 ], matf[ 10 ], matf[ 14 ], matf[ 3 ], matf[ 7 ], matf[ 11 ], matf[ 15 ] }; + // RL_Matrix creation from array + RL_Matrix mat = { matf[0], matf[4], matf[8], matf[12], + matf[1], matf[5], matf[9], matf[13], + matf[2], matf[6], matf[10], matf[14], + matf[3], matf[7], matf[11], matf[15] }; - *RLGL.State.currentMatrix = rlMatrixMultiply( *RLGL.State.currentMatrix, mat ); + *RLGL_GLOBAL_DATA.State.currentMatrix = RLGL_MatrixMultiply(*RLGL_GLOBAL_DATA.State.currentMatrix, mat); } // Multiply the current matrix by a perspective matrix generated by parameters -void rlFrustum( double left, double right, double bottom, double top, double znear, double zfar ) +void RLGL_Frustum(double left, double right, double bottom, double top, double znear, double zfar) { - Matrix matFrustum = { 0 }; + RL_Matrix matFrustum = { 0 }; - float rl = ( float )( right - left ); - float tb = ( float )( top - bottom ); - float fn = ( float )( zfar - znear ); + float RLGL_ = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(zfar - znear); - matFrustum.m0 = ( ( float )znear * 2.0f ) / rl; - matFrustum.m1 = 0.0f; - matFrustum.m2 = 0.0f; - matFrustum.m3 = 0.0f; + matFrustum.m0 = ((float) znear*2.0f)/RLGL_; + matFrustum.m1 = 0.0f; + matFrustum.m2 = 0.0f; + matFrustum.m3 = 0.0f; - matFrustum.m4 = 0.0f; - matFrustum.m5 = ( ( float )znear * 2.0f ) / tb; - matFrustum.m6 = 0.0f; - matFrustum.m7 = 0.0f; + matFrustum.m4 = 0.0f; + matFrustum.m5 = ((float) znear*2.0f)/tb; + matFrustum.m6 = 0.0f; + matFrustum.m7 = 0.0f; - matFrustum.m8 = ( ( float )right + ( float )left ) / rl; - matFrustum.m9 = ( ( float )top + ( float )bottom ) / tb; - matFrustum.m10 = -( ( float )zfar + ( float )znear ) / fn; - matFrustum.m11 = -1.0f; + matFrustum.m8 = ((float)right + (float)left)/RLGL_; + matFrustum.m9 = ((float)top + (float)bottom)/tb; + matFrustum.m10 = -((float)zfar + (float)znear)/fn; + matFrustum.m11 = -1.0f; - matFrustum.m12 = 0.0f; - matFrustum.m13 = 0.0f; - matFrustum.m14 = -( ( float )zfar * ( float )znear * 2.0f ) / fn; - matFrustum.m15 = 0.0f; + matFrustum.m12 = 0.0f; + matFrustum.m13 = 0.0f; + matFrustum.m14 = -((float)zfar*(float)znear*2.0f)/fn; + matFrustum.m15 = 0.0f; - *RLGL.State.currentMatrix = rlMatrixMultiply( *RLGL.State.currentMatrix, matFrustum ); + *RLGL_GLOBAL_DATA.State.currentMatrix = RLGL_MatrixMultiply(*RLGL_GLOBAL_DATA.State.currentMatrix, matFrustum); } // Multiply the current matrix by an orthographic matrix generated by parameters -void rlOrtho( double left, double right, double bottom, double top, double znear, double zfar ) +void RLGL_Ortho(double left, double right, double bottom, double top, double znear, double zfar) { - // NOTE: If left-right and top-botton values are equal it could create a division by zero, - // response to it is platform/compiler dependant - Matrix matOrtho = { 0 }; + // NOTE: If left-right and top-botton values are equal it could create a division by zero, + // response to it is platform/compiler dependant + RL_Matrix matOrtho = { 0 }; - float rl = ( float )( right - left ); - float tb = ( float )( top - bottom ); - float fn = ( float )( zfar - znear ); + float RLGL_ = (float)(right - left); + float tb = (float)(top - bottom); + float fn = (float)(zfar - znear); - matOrtho.m0 = 2.0f / rl; - matOrtho.m1 = 0.0f; - matOrtho.m2 = 0.0f; - matOrtho.m3 = 0.0f; - matOrtho.m4 = 0.0f; - matOrtho.m5 = 2.0f / tb; - matOrtho.m6 = 0.0f; - matOrtho.m7 = 0.0f; - matOrtho.m8 = 0.0f; - matOrtho.m9 = 0.0f; - matOrtho.m10 = -2.0f / fn; - matOrtho.m11 = 0.0f; - matOrtho.m12 = -( ( float )left + ( float )right ) / rl; - matOrtho.m13 = -( ( float )top + ( float )bottom ) / tb; - matOrtho.m14 = -( ( float )zfar + ( float )znear ) / fn; - matOrtho.m15 = 1.0f; + matOrtho.m0 = 2.0f/RLGL_; + matOrtho.m1 = 0.0f; + matOrtho.m2 = 0.0f; + matOrtho.m3 = 0.0f; + matOrtho.m4 = 0.0f; + matOrtho.m5 = 2.0f/tb; + matOrtho.m6 = 0.0f; + matOrtho.m7 = 0.0f; + matOrtho.m8 = 0.0f; + matOrtho.m9 = 0.0f; + matOrtho.m10 = -2.0f/fn; + matOrtho.m11 = 0.0f; + matOrtho.m12 = -((float)left + (float)right)/RLGL_; + matOrtho.m13 = -((float)top + (float)bottom)/tb; + matOrtho.m14 = -((float)zfar + (float)znear)/fn; + matOrtho.m15 = 1.0f; - *RLGL.State.currentMatrix = rlMatrixMultiply( *RLGL.State.currentMatrix, matOrtho ); + *RLGL_GLOBAL_DATA.State.currentMatrix = RLGL_MatrixMultiply(*RLGL_GLOBAL_DATA.State.currentMatrix, matOrtho); } #endif // Set the viewport area (transformation from normalized device coordinates to window coordinates) // NOTE: We store current viewport dimensions -void rlViewport( int x, int y, int width, int height ) +void RLGL_Viewport(int x, int y, int width, int height) { - glViewport( x, y, width, height ); + glViewport(x, y, width, height); } //---------------------------------------------------------------------------------- // Module Functions Definition - Vertex level operations //---------------------------------------------------------------------------------- -#if defined( GRAPHICS_API_OPENGL_11 ) +#if defined(GRAPHICS_API_OPENGL_11) // Fallback to OpenGL 1.1 function calls //--------------------------------------- -void rlBegin( int mode ) +void RLGL_Begin(int mode) { - switch ( mode ) - { - case RL_LINES : - glBegin( GL_LINES ); - break; - case RL_TRIANGLES : - glBegin( GL_TRIANGLES ); - break; - case RL_QUADS : - glBegin( GL_QUADS ); - break; - default : - break; - } + switch (mode) + { + case RL_LINES: glBegin(GL_LINES); break; + case RL_TRIANGLES: glBegin(GL_TRIANGLES); break; + case RL_QUADS: glBegin(GL_QUADS); break; + default: break; + } } -void rlEnd() -{ - glEnd(); -} - -void rlVertex2i( int x, int y ) -{ - glVertex2i( x, y ); -} - -void rlVertex2f( float x, float y ) -{ - glVertex2f( x, y ); -} - -void rlVertex3f( float x, float y, float z ) -{ - glVertex3f( x, y, z ); -} - -void rlTexCoord2f( float x, float y ) -{ - glTexCoord2f( x, y ); -} - -void rlNormal3f( float x, float y, float z ) -{ - glNormal3f( x, y, z ); -} - -void rlColor4ub( unsigned char r, unsigned char g, unsigned char b, unsigned char a ) -{ - glColor4ub( r, g, b, a ); -} - -void rlColor3f( float x, float y, float z ) -{ - glColor3f( x, y, z ); -} - -void rlColor4f( float x, float y, float z, float w ) -{ - glColor4f( x, y, z, w ); -} +void RLGL_End() { glEnd(); } +void RLGL_Vertex2i(int x, int y) { glVertex2i(x, y); } +void RLGL_Vertex2f(float x, float y) { glVertex2f(x, y); } +void RLGL_Vertex3f(float x, float y, float z) { glVertex3f(x, y, z); } +void RLGL_TexCoord2f(float x, float y) { glTexCoord2f(x, y); } +void RLGL_Normal3f(float x, float y, float z) { glNormal3f(x, y, z); } +void RLGL_Color4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a) { glColor4ub(r, g, b, a); } +void RLGL_Color3f(float x, float y, float z) { glColor3f(x, y, z); } +void RLGL_Color4f(float x, float y, float z, float w) { glColor4f(x, y, z, w); } #endif -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) // Initialize drawing mode (how to organize vertex) -void rlBegin( int mode ) +void RLGL_Begin(int mode) { - // Draw mode can be RL_LINES, RL_TRIANGLES and RL_QUADS - // NOTE: In all three cases, vertex are accumulated over default internal vertex buffer - if ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].mode != mode ) - { - if ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount > 0 ) - { - // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4, - // that way, following QUADS drawing will keep aligned with index processing - // It implies adding some extra alignment vertex at the end of the draw, - // those vertex are not processed but they are considered as an additional offset - // for the next set of vertex to be drawn - if ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].mode == RL_LINES ) - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexAlignment = - ( ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount < 4 ) - ? RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount - : RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount % 4 ); - else if ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].mode == RL_TRIANGLES ) - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexAlignment = - ( ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount < 4 ) - ? 1 - : ( 4 - ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount % 4 ) ) ); - else - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexAlignment = 0; + // Draw mode can be RL_LINES, RL_TRIANGLES and RL_QUADS + // NOTE: In all three cases, vertex are accumulated over default internal vertex buffer + if (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].mode != mode) + { + if (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount > 0) + { + // Make sure current RLGL_GLOBAL_DATA.currentBatch->draws[i].vertexCount is aligned a multiple of 4, + // that way, following QUADS drawing will keep aligned with index processing + // It implies adding some extra alignment vertex at the end of the draw, + // those vertex are not processed but they are considered as an additional offset + // for the next set of vertex to be drawn + if (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].mode == RL_LINES) RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount < 4)? RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount : RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount%4); + else if (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount < 4)? 1 : (4 - (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount%4))); + else RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexAlignment = 0; - if ( ! rlCheckRenderBatchLimit( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexAlignment ) ) - { - RLGL.State.vertexCounter += RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexAlignment; - RLGL.currentBatch->drawCounter++; - } - } + if (!RLGL_CheckRenderBatchLimit(RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexAlignment)) + { + RLGL_GLOBAL_DATA.State.vertexCounter += RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexAlignment; + RLGL_GLOBAL_DATA.currentBatch->drawCounter++; + } + } - if ( RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS ) - rlDrawRenderBatch( RLGL.currentBatch ); + if (RLGL_GLOBAL_DATA.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) RLGL_DrawRenderBatch(RLGL_GLOBAL_DATA.currentBatch); - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].mode = mode; - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount = 0; - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].textureId = RLGL.State.defaultTextureId; - } + RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].mode = mode; + RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount = 0; + RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].textureId = RLGL_GLOBAL_DATA.State.defaultTextureId; + } } // Finish vertex providing -void rlEnd( void ) +void RLGL_End(void) { - // NOTE: Depth increment is dependant on rlOrtho(): z-near and z-far values, - // as well as depth buffer bit-depth (16bit or 24bit or 32bit) - // Correct increment formula would be: depthInc = (zfar - znear)/pow(2, bits) - RLGL.currentBatch->currentDepth += ( 1.0f / 20000.0f ); + // NOTE: Depth increment is dependant on RLGL_Ortho(): z-near and z-far values, + // as well as depth buffer bit-depth (16bit or 24bit or 32bit) + // Correct increment formula would be: depthInc = (zfar - znear)/pow(2, bits) + RLGL_GLOBAL_DATA.currentBatch->currentDepth += (1.0f/20000.0f); } // Define one vertex (position) // NOTE: Vertex position data is the basic information required for drawing -void rlVertex3f( float x, float y, float z ) +void RLGL_Vertex3f(float x, float y, float z) { - float tx = x; - float ty = y; - float tz = z; + float tx = x; + float ty = y; + float tz = z; - // Transform provided vector if required - if ( RLGL.State.transformRequired ) - { - tx = RLGL.State.transform.m0 * x + RLGL.State.transform.m4 * y + RLGL.State.transform.m8 * z + RLGL.State.transform.m12; - ty = RLGL.State.transform.m1 * x + RLGL.State.transform.m5 * y + RLGL.State.transform.m9 * z + RLGL.State.transform.m13; - tz = RLGL.State.transform.m2 * x + RLGL.State.transform.m6 * y + RLGL.State.transform.m10 * z + RLGL.State.transform.m14; - } + // Transform provided vector if required + if (RLGL_GLOBAL_DATA.State.transformRequired) + { + tx = RLGL_GLOBAL_DATA.State.transform.m0*x + RLGL_GLOBAL_DATA.State.transform.m4*y + RLGL_GLOBAL_DATA.State.transform.m8*z + RLGL_GLOBAL_DATA.State.transform.m12; + ty = RLGL_GLOBAL_DATA.State.transform.m1*x + RLGL_GLOBAL_DATA.State.transform.m5*y + RLGL_GLOBAL_DATA.State.transform.m9*z + RLGL_GLOBAL_DATA.State.transform.m13; + tz = RLGL_GLOBAL_DATA.State.transform.m2*x + RLGL_GLOBAL_DATA.State.transform.m6*y + RLGL_GLOBAL_DATA.State.transform.m10*z + RLGL_GLOBAL_DATA.State.transform.m14; + } - // WARNING: We can't break primitives when launching a new batch. - // RL_LINES comes in pairs, RL_TRIANGLES come in groups of 3 vertices and RL_QUADS come in groups of 4 vertices. - // We must check current draw.mode when a new vertex is required and finish the batch only if the draw.mode draw.vertexCount is %2, %3 or %4 - if ( RLGL.State.vertexCounter > ( RLGL.currentBatch->vertexBuffer[ RLGL.currentBatch->currentBuffer ].elementCount * 4 - 4 ) ) - { - if ( ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].mode == RL_LINES ) - && ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount % 2 == 0 ) ) - { - // Reached the maximum number of vertices for RL_LINES drawing - // Launch a draw call but keep current state for next vertices comming - // NOTE: We add +1 vertex to the check for security - rlCheckRenderBatchLimit( 2 + 1 ); - } - else if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) && - (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%3 == 0)) - { - rlCheckRenderBatchLimit( 3 + 1 ); - } - else if ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_QUADS) && - (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4 == 0)) - { - rlCheckRenderBatchLimit( 4 + 1 ); - } - } + // WARNING: We can't break primitives when launching a new batch. + // RL_LINES comes in pairs, RL_TRIANGLES come in groups of 3 vertices and RL_QUADS come in groups of 4 vertices. + // We must check current draw.mode when a new vertex is required and finish the batch only if the draw.mode draw.vertexCount is %2, %3 or %4 + if (RLGL_GLOBAL_DATA.State.vertexCounter > (RLGL_GLOBAL_DATA.currentBatch->vertexBuffer[RLGL_GLOBAL_DATA.currentBatch->currentBuffer].elementCount*4 - 4)) + { + if ((RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].mode == RL_LINES) && + (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount%2 == 0)) + { + // Reached the maximum number of vertices for RL_LINES drawing + // Launch a draw call but keep current state for next vertices comming + // NOTE: We add +1 vertex to the check for security + RLGL_CheckRenderBatchLimit(2 + 1); + } + else if ((RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) && + (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount%3 == 0)) + { + RLGL_CheckRenderBatchLimit(3 + 1); + } + else if ((RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].mode == RL_QUADS) && + (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount%4 == 0)) + { + RLGL_CheckRenderBatchLimit(4 + 1); + } + } - // Add vertices - RLGL.currentBatch->vertexBuffer[ RLGL.currentBatch->currentBuffer ].vertices[ 3 * RLGL.State.vertexCounter ] = tx; - RLGL.currentBatch->vertexBuffer[ RLGL.currentBatch->currentBuffer ].vertices[ 3 * RLGL.State.vertexCounter + 1 ] = ty; - RLGL.currentBatch->vertexBuffer[ RLGL.currentBatch->currentBuffer ].vertices[ 3 * RLGL.State.vertexCounter + 2 ] = tz; + // Add vertices + RLGL_GLOBAL_DATA.currentBatch->vertexBuffer[RLGL_GLOBAL_DATA.currentBatch->currentBuffer].vertices[3*RLGL_GLOBAL_DATA.State.vertexCounter] = tx; + RLGL_GLOBAL_DATA.currentBatch->vertexBuffer[RLGL_GLOBAL_DATA.currentBatch->currentBuffer].vertices[3*RLGL_GLOBAL_DATA.State.vertexCounter + 1] = ty; + RLGL_GLOBAL_DATA.currentBatch->vertexBuffer[RLGL_GLOBAL_DATA.currentBatch->currentBuffer].vertices[3*RLGL_GLOBAL_DATA.State.vertexCounter + 2] = tz; - // Add current texcoord - RLGL.currentBatch->vertexBuffer[ RLGL.currentBatch->currentBuffer ].texcoords[ 2 * RLGL.State.vertexCounter ] = RLGL.State.texcoordx; - RLGL.currentBatch->vertexBuffer[ RLGL.currentBatch->currentBuffer ].texcoords[ 2 * RLGL.State.vertexCounter + 1 ] = RLGL.State.texcoordy; + // Add current texcoord + RLGL_GLOBAL_DATA.currentBatch->vertexBuffer[RLGL_GLOBAL_DATA.currentBatch->currentBuffer].texcoords[2*RLGL_GLOBAL_DATA.State.vertexCounter] = RLGL_GLOBAL_DATA.State.texcoordx; + RLGL_GLOBAL_DATA.currentBatch->vertexBuffer[RLGL_GLOBAL_DATA.currentBatch->currentBuffer].texcoords[2*RLGL_GLOBAL_DATA.State.vertexCounter + 1] = RLGL_GLOBAL_DATA.State.texcoordy; - // WARNING: By default rlVertexBuffer struct does not store normals + // WARNING: By default RLGL_VertexBuffer struct does not store normals - // Add current color - RLGL.currentBatch->vertexBuffer[ RLGL.currentBatch->currentBuffer ].colors[ 4 * RLGL.State.vertexCounter ] = RLGL.State.colorr; - RLGL.currentBatch->vertexBuffer[ RLGL.currentBatch->currentBuffer ].colors[ 4 * RLGL.State.vertexCounter + 1 ] = RLGL.State.colorg; - RLGL.currentBatch->vertexBuffer[ RLGL.currentBatch->currentBuffer ].colors[ 4 * RLGL.State.vertexCounter + 2 ] = RLGL.State.colorb; - RLGL.currentBatch->vertexBuffer[ RLGL.currentBatch->currentBuffer ].colors[ 4 * RLGL.State.vertexCounter + 3 ] = RLGL.State.colora; + // Add current color + RLGL_GLOBAL_DATA.currentBatch->vertexBuffer[RLGL_GLOBAL_DATA.currentBatch->currentBuffer].colors[4*RLGL_GLOBAL_DATA.State.vertexCounter] = RLGL_GLOBAL_DATA.State.colorr; + RLGL_GLOBAL_DATA.currentBatch->vertexBuffer[RLGL_GLOBAL_DATA.currentBatch->currentBuffer].colors[4*RLGL_GLOBAL_DATA.State.vertexCounter + 1] = RLGL_GLOBAL_DATA.State.colorg; + RLGL_GLOBAL_DATA.currentBatch->vertexBuffer[RLGL_GLOBAL_DATA.currentBatch->currentBuffer].colors[4*RLGL_GLOBAL_DATA.State.vertexCounter + 2] = RLGL_GLOBAL_DATA.State.colorb; + RLGL_GLOBAL_DATA.currentBatch->vertexBuffer[RLGL_GLOBAL_DATA.currentBatch->currentBuffer].colors[4*RLGL_GLOBAL_DATA.State.vertexCounter + 3] = RLGL_GLOBAL_DATA.State.colora; - RLGL.State.vertexCounter++; - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount++; + RLGL_GLOBAL_DATA.State.vertexCounter++; + RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount++; } // Define one vertex (position) -void rlVertex2f( float x, float y ) +void RLGL_Vertex2f(float x, float y) { - rlVertex3f( x, y, RLGL.currentBatch->currentDepth ); + RLGL_Vertex3f(x, y, RLGL_GLOBAL_DATA.currentBatch->currentDepth); } // Define one vertex (position) -void rlVertex2i( int x, int y ) +void RLGL_Vertex2i(int x, int y) { - rlVertex3f( ( float )x, ( float )y, RLGL.currentBatch->currentDepth ); + RLGL_Vertex3f((float)x, (float)y, RLGL_GLOBAL_DATA.currentBatch->currentDepth); } // Define one vertex (texture coordinate) // NOTE: Texture coordinates are limited to QUADS only -void rlTexCoord2f( float x, float y ) +void RLGL_TexCoord2f(float x, float y) { - RLGL.State.texcoordx = x; - RLGL.State.texcoordy = y; + RLGL_GLOBAL_DATA.State.texcoordx = x; + RLGL_GLOBAL_DATA.State.texcoordy = y; } // Define one vertex (normal) // NOTE: Normals limited to TRIANGLES only? -void rlNormal3f( float x, float y, float z ) +void RLGL_Normal3f(float x, float y, float z) { - RLGL.State.normalx = x; - RLGL.State.normaly = y; - RLGL.State.normalz = z; + RLGL_GLOBAL_DATA.State.normalx = x; + RLGL_GLOBAL_DATA.State.normaly = y; + RLGL_GLOBAL_DATA.State.normalz = z; } // Define one vertex (color) -void rlColor4ub( unsigned char x, unsigned char y, unsigned char z, unsigned char w ) +void RLGL_Color4ub(unsigned char x, unsigned char y, unsigned char z, unsigned char w) { - RLGL.State.colorr = x; - RLGL.State.colorg = y; - RLGL.State.colorb = z; - RLGL.State.colora = w; + RLGL_GLOBAL_DATA.State.colorr = x; + RLGL_GLOBAL_DATA.State.colorg = y; + RLGL_GLOBAL_DATA.State.colorb = z; + RLGL_GLOBAL_DATA.State.colora = w; } // Define one vertex (color) -void rlColor4f( float r, float g, float b, float a ) +void RLGL_Color4f(float r, float g, float b, float a) { - rlColor4ub( ( unsigned char )( r * 255 ), ( unsigned char )( g * 255 ), ( unsigned char )( b * 255 ), ( unsigned char )( a * 255 ) ); + RLGL_Color4ub((unsigned char)(r*255), (unsigned char)(g*255), (unsigned char)(b*255), (unsigned char)(a*255)); } // Define one vertex (color) -void rlColor3f( float x, float y, float z ) +void RLGL_Color3f(float x, float y, float z) { - rlColor4ub( ( unsigned char )( x * 255 ), ( unsigned char )( y * 255 ), ( unsigned char )( z * 255 ), 255 ); + RLGL_Color4ub((unsigned char)(x*255), (unsigned char)(y*255), (unsigned char)(z*255), 255); } #endif @@ -1618,298 +1510,275 @@ void rlColor3f( float x, float y, float z ) //-------------------------------------------------------------------------------------- // Set current texture to use -void rlSetTexture( unsigned int id ) +void RLGL_SetTexture(unsigned int id) { - if ( id == 0 ) - { -#if defined( GRAPHICS_API_OPENGL_11 ) - rlDisableTexture(); + if (id == 0) + { +#if defined(GRAPHICS_API_OPENGL_11) + RLGL_DisableTexture(); #else - // NOTE: If quads batch limit is reached, we force a draw call and next batch starts - if ( RLGL.State.vertexCounter >= RLGL.currentBatch->vertexBuffer[ RLGL.currentBatch->currentBuffer ].elementCount * 4 ) - { - rlDrawRenderBatch( RLGL.currentBatch ); - } + // NOTE: If quads batch limit is reached, we force a draw call and next batch starts + if (RLGL_GLOBAL_DATA.State.vertexCounter >= + RLGL_GLOBAL_DATA.currentBatch->vertexBuffer[RLGL_GLOBAL_DATA.currentBatch->currentBuffer].elementCount*4) + { + RLGL_DrawRenderBatch(RLGL_GLOBAL_DATA.currentBatch); + } #endif - } - else - { -#if defined( GRAPHICS_API_OPENGL_11 ) - rlEnableTexture( id ); + } + else + { +#if defined(GRAPHICS_API_OPENGL_11) + RLGL_EnableTexture(id); #else - if ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].textureId != id ) - { - if ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount > 0 ) - { - // Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4, - // that way, following QUADS drawing will keep aligned with index processing - // It implies adding some extra alignment vertex at the end of the draw, - // those vertex are not processed but they are considered as an additional offset - // for the next set of vertex to be drawn - if ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].mode == RL_LINES ) - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexAlignment = - ( ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount < 4 ) - ? RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount - : RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount % 4 ); - else if ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].mode == RL_TRIANGLES ) - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexAlignment = - ( ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount < 4 ) - ? 1 - : ( 4 - ( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount % 4 ) ) ); - else - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexAlignment = 0; + if (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].textureId != id) + { + if (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount > 0) + { + // Make sure current RLGL_GLOBAL_DATA.currentBatch->draws[i].vertexCount is aligned a multiple of 4, + // that way, following QUADS drawing will keep aligned with index processing + // It implies adding some extra alignment vertex at the end of the draw, + // those vertex are not processed but they are considered as an additional offset + // for the next set of vertex to be drawn + if (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].mode == RL_LINES) RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount < 4)? RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount : RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount%4); + else if (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount < 4)? 1 : (4 - (RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount%4))); + else RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexAlignment = 0; - if ( ! rlCheckRenderBatchLimit( RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexAlignment ) ) - { - RLGL.State.vertexCounter += RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexAlignment; + if (!RLGL_CheckRenderBatchLimit(RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexAlignment)) + { + RLGL_GLOBAL_DATA.State.vertexCounter += RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexAlignment; - RLGL.currentBatch->drawCounter++; - } - } + RLGL_GLOBAL_DATA.currentBatch->drawCounter++; + } + } - if ( RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS ) - rlDrawRenderBatch( RLGL.currentBatch ); + if (RLGL_GLOBAL_DATA.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) RLGL_DrawRenderBatch(RLGL_GLOBAL_DATA.currentBatch); - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].textureId = id; - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].vertexCount = 0; - } + RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].textureId = id; + RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].vertexCount = 0; + } #endif - } + } } // Select and active a texture slot -void rlActiveTextureSlot( int slot ) +void RLGL_ActiveTextureSlot(int slot) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glActiveTexture( GL_TEXTURE0 + slot ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glActiveTexture(GL_TEXTURE0 + slot); #endif } // Enable texture -void rlEnableTexture( unsigned int id ) +void RLGL_EnableTexture(unsigned int id) { -#if defined( GRAPHICS_API_OPENGL_11 ) - glEnable( GL_TEXTURE_2D ); +#if defined(GRAPHICS_API_OPENGL_11) + glEnable(GL_TEXTURE_2D); #endif - glBindTexture( GL_TEXTURE_2D, id ); + glBindTexture(GL_TEXTURE_2D, id); } // Disable texture -void rlDisableTexture( void ) +void RLGL_DisableTexture(void) { -#if defined( GRAPHICS_API_OPENGL_11 ) - glDisable( GL_TEXTURE_2D ); +#if defined(GRAPHICS_API_OPENGL_11) + glDisable(GL_TEXTURE_2D); #endif - glBindTexture( GL_TEXTURE_2D, 0 ); + glBindTexture(GL_TEXTURE_2D, 0); } // Enable texture cubemap -void rlEnableTextureCubemap( unsigned int id ) +void RLGL_EnableTextureCubemap(unsigned int id) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glBindTexture( GL_TEXTURE_CUBE_MAP, id ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindTexture(GL_TEXTURE_CUBE_MAP, id); #endif } // Disable texture cubemap -void rlDisableTextureCubemap( void ) +void RLGL_DisableTextureCubemap(void) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glBindTexture( GL_TEXTURE_CUBE_MAP, 0 ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindTexture(GL_TEXTURE_CUBE_MAP, 0); #endif } // Set texture parameters (wrap mode/filter mode) -void rlTextureParameters( unsigned int id, int param, int value ) +void RLGL_TextureParameters(unsigned int id, int param, int value) { - glBindTexture( GL_TEXTURE_2D, id ); + glBindTexture(GL_TEXTURE_2D, id); -#if ! defined( GRAPHICS_API_OPENGL_11 ) - // Reset anisotropy filter, in case it was set - glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f ); +#if !defined(GRAPHICS_API_OPENGL_11) + // Reset anisotropy filter, in case it was set + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f); #endif - switch ( param ) - { - case RL_TEXTURE_WRAP_S : - case RL_TEXTURE_WRAP_T : - { - if ( value == RL_TEXTURE_WRAP_MIRROR_CLAMP ) - { -#if ! defined( GRAPHICS_API_OPENGL_11 ) - if ( RLGL.ExtSupported.texMirrorClamp ) - glTexParameteri( GL_TEXTURE_2D, param, value ); - else - TRACELOG( RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)" ); + switch (param) + { + case RL_TEXTURE_WRAP_S: + case RL_TEXTURE_WRAP_T: + { + if (value == RL_TEXTURE_WRAP_MIRROR_CLAMP) + { +#if !defined(GRAPHICS_API_OPENGL_11) + if (RLGL_GLOBAL_DATA.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_2D, param, value); + else RL_TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)"); #endif - } - else - glTexParameteri( GL_TEXTURE_2D, param, value ); - } - break; - case RL_TEXTURE_MAG_FILTER : - case RL_TEXTURE_MIN_FILTER : - glTexParameteri( GL_TEXTURE_2D, param, value ); - break; - case RL_TEXTURE_FILTER_ANISOTROPIC : - { -#if ! defined( GRAPHICS_API_OPENGL_11 ) - if ( value <= RLGL.ExtSupported.maxAnisotropyLevel ) - glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, ( float )value ); - else if ( RLGL.ExtSupported.maxAnisotropyLevel > 0.0f ) - { - TRACELOG( RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, ( int )RLGL.ExtSupported.maxAnisotropyLevel ); - glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, ( float )value ); - } - else - TRACELOG( RL_LOG_WARNING, "GL: Anisotropic filtering not supported" ); -#endif - } - break; -#if defined( GRAPHICS_API_OPENGL_33 ) - case RL_TEXTURE_MIPMAP_BIAS_RATIO : - glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, value / 100.0f ); -#endif - default : - break; - } + } + else glTexParameteri(GL_TEXTURE_2D, param, value); - glBindTexture( GL_TEXTURE_2D, 0 ); + } break; + case RL_TEXTURE_MAG_FILTER: + case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_2D, param, value); break; + case RL_TEXTURE_FILTER_ANISOTROPIC: + { +#if !defined(GRAPHICS_API_OPENGL_11) + if (value <= RLGL_GLOBAL_DATA.ExtSupported.maxAnisotropyLevel) glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + else if (RLGL_GLOBAL_DATA.ExtSupported.maxAnisotropyLevel > 0.0f) + { + RL_TRACELOG(RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, (int)RLGL_GLOBAL_DATA.ExtSupported.maxAnisotropyLevel); + glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + } + else RL_TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported"); +#endif + } break; +#if defined(GRAPHICS_API_OPENGL_33) + case RL_TEXTURE_MIPMAP_BIAS_RATIO: glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, value/100.0f); +#endif + default: break; + } + + glBindTexture(GL_TEXTURE_2D, 0); } // Set cubemap parameters (wrap mode/filter mode) -void rlCubemapParameters( unsigned int id, int param, int value ) +void RLGL_CubemapParameters(unsigned int id, int param, int value) { -#if ! defined( GRAPHICS_API_OPENGL_11 ) - glBindTexture( GL_TEXTURE_CUBE_MAP, id ); +#if !defined(GRAPHICS_API_OPENGL_11) + glBindTexture(GL_TEXTURE_CUBE_MAP, id); - // Reset anisotropy filter, in case it was set - glTexParameterf( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f ); + // Reset anisotropy filter, in case it was set + glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f); - switch ( param ) - { - case RL_TEXTURE_WRAP_S : - case RL_TEXTURE_WRAP_T : - { - if ( value == RL_TEXTURE_WRAP_MIRROR_CLAMP ) - { - if ( RLGL.ExtSupported.texMirrorClamp ) - glTexParameteri( GL_TEXTURE_CUBE_MAP, param, value ); - else - TRACELOG( RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)" ); - } - else - glTexParameteri( GL_TEXTURE_CUBE_MAP, param, value ); - } - break; - case RL_TEXTURE_MAG_FILTER : - case RL_TEXTURE_MIN_FILTER : - glTexParameteri( GL_TEXTURE_CUBE_MAP, param, value ); - break; - case RL_TEXTURE_FILTER_ANISOTROPIC : - { - if ( value <= RLGL.ExtSupported.maxAnisotropyLevel ) - glTexParameterf( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, ( float )value ); - else if ( RLGL.ExtSupported.maxAnisotropyLevel > 0.0f ) - { - TRACELOG( RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, ( int )RLGL.ExtSupported.maxAnisotropyLevel ); - glTexParameterf( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, ( float )value ); - } - else - TRACELOG( RL_LOG_WARNING, "GL: Anisotropic filtering not supported" ); - } - break; -#if defined( GRAPHICS_API_OPENGL_33 ) - case RL_TEXTURE_MIPMAP_BIAS_RATIO : - glTexParameterf( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_LOD_BIAS, value / 100.0f ); + switch (param) + { + case RL_TEXTURE_WRAP_S: + case RL_TEXTURE_WRAP_T: + { + if (value == RL_TEXTURE_WRAP_MIRROR_CLAMP) + { + if (RLGL_GLOBAL_DATA.ExtSupported.texMirrorClamp) glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); + else RL_TRACELOG(RL_LOG_WARNING, "GL: Clamp mirror wrap mode not supported (GL_MIRROR_CLAMP_EXT)"); + } + else glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); + + } break; + case RL_TEXTURE_MAG_FILTER: + case RL_TEXTURE_MIN_FILTER: glTexParameteri(GL_TEXTURE_CUBE_MAP, param, value); break; + case RL_TEXTURE_FILTER_ANISOTROPIC: + { + if (value <= RLGL_GLOBAL_DATA.ExtSupported.maxAnisotropyLevel) glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + else if (RLGL_GLOBAL_DATA.ExtSupported.maxAnisotropyLevel > 0.0f) + { + RL_TRACELOG(RL_LOG_WARNING, "GL: Maximum anisotropic filter level supported is %iX", id, (int)RLGL_GLOBAL_DATA.ExtSupported.maxAnisotropyLevel); + glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAX_ANISOTROPY_EXT, (float)value); + } + else RL_TRACELOG(RL_LOG_WARNING, "GL: Anisotropic filtering not supported"); + } break; +#if defined(GRAPHICS_API_OPENGL_33) + case RL_TEXTURE_MIPMAP_BIAS_RATIO: glTexParameterf(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_LOD_BIAS, value/100.0f); #endif - default : - break; - } + default: break; + } - glBindTexture( GL_TEXTURE_CUBE_MAP, 0 ); + glBindTexture(GL_TEXTURE_CUBE_MAP, 0); #endif } // Enable shader program -void rlEnableShader( unsigned int id ) +void RLGL_EnableShader(unsigned int id) { -#if ( defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) ) - glUseProgram( id ); +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + glUseProgram(id); #endif } // Disable shader program -void rlDisableShader( void ) +void RLGL_DisableShader(void) { -#if ( defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) ) - glUseProgram( 0 ); +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + glUseProgram(0); #endif } // Enable rendering to texture (fbo) -void rlEnableFramebuffer( unsigned int id ) +void RLGL_EnableFramebuffer(unsigned int id) { -#if ( defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) ) && defined( RLGL_RENDER_TEXTURES_HINT ) - glBindFramebuffer( GL_FRAMEBUFFER, id ); +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, id); #endif } // Disable rendering to texture -void rlDisableFramebuffer( void ) +void RLGL_DisableFramebuffer(void) { -#if ( defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) ) && defined( RLGL_RENDER_TEXTURES_HINT ) - glBindFramebuffer( GL_FRAMEBUFFER, 0 ); +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, 0); +#endif +} + +// Blit active framebuffer to main framebuffer +void RLGL_BlitFramebuffer(int srcX, int srcY, int srcWidth, int srcHeight, int dstX, int dstY, int dstWidth, int dstHeight, int bufferMask) +{ +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBlitFramebuffer(srcX, srcY, srcWidth, srcHeight, dstX, dstY, dstWidth, dstHeight, bufferMask, GL_NEAREST); #endif } // Activate multiple draw color buffers // NOTE: One color buffer is always active by default -void rlActiveDrawBuffers( int count ) +void RLGL_ActiveDrawBuffers(int count) { -#if ( ( defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES3 ) ) && defined( RLGL_RENDER_TEXTURES_HINT ) ) - // NOTE: Maximum number of draw buffers supported is implementation dependant, - // it can be queried with glGet*() but it must be at least 8 - // GLint maxDrawBuffers = 0; - // glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); +#if ((defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES3)) && defined(RLGL_RENDER_TEXTURES_HINT)) + // NOTE: Maximum number of draw buffers supported is implementation dependant, + // it can be queried with glGet*() but it must be at least 8 + //GLint maxDrawBuffers = 0; + //glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers); - if ( count > 0 ) - { - if ( count > 8 ) - TRACELOG( LOG_WARNING, "GL: Max color buffers limited to 8" ); - else - { - unsigned int buffers[ 8 ] = { -#if defined( GRAPHICS_API_OPENGL_ES3 ) - GL_COLOR_ATTACHMENT0_EXT, - GL_COLOR_ATTACHMENT1_EXT, - GL_COLOR_ATTACHMENT2_EXT, - GL_COLOR_ATTACHMENT3_EXT, - GL_COLOR_ATTACHMENT4_EXT, - GL_COLOR_ATTACHMENT5_EXT, - GL_COLOR_ATTACHMENT6_EXT, - GL_COLOR_ATTACHMENT7_EXT, + if (count > 0) + { + if (count > 8) RL_TRACELOG(RL_LOG_WARNING, "GL: Max color buffers limited to 8"); + else + { + unsigned int buffers[8] = { +#if defined(GRAPHICS_API_OPENGL_ES3) + GL_COLOR_ATTACHMENT0_EXT, + GL_COLOR_ATTACHMENT1_EXT, + GL_COLOR_ATTACHMENT2_EXT, + GL_COLOR_ATTACHMENT3_EXT, + GL_COLOR_ATTACHMENT4_EXT, + GL_COLOR_ATTACHMENT5_EXT, + GL_COLOR_ATTACHMENT6_EXT, + GL_COLOR_ATTACHMENT7_EXT, #else - GL_COLOR_ATTACHMENT0, - GL_COLOR_ATTACHMENT1, - GL_COLOR_ATTACHMENT2, - GL_COLOR_ATTACHMENT3, - GL_COLOR_ATTACHMENT4, - GL_COLOR_ATTACHMENT5, - GL_COLOR_ATTACHMENT6, - GL_COLOR_ATTACHMENT7, + GL_COLOR_ATTACHMENT0, + GL_COLOR_ATTACHMENT1, + GL_COLOR_ATTACHMENT2, + GL_COLOR_ATTACHMENT3, + GL_COLOR_ATTACHMENT4, + GL_COLOR_ATTACHMENT5, + GL_COLOR_ATTACHMENT6, + GL_COLOR_ATTACHMENT7, #endif - }; + }; -#if defined( GRAPHICS_API_OPENGL_ES3 ) - glDrawBuffersEXT( count, buffers ); +#if defined(GRAPHICS_API_OPENGL_ES3) + glDrawBuffersEXT(count, buffers); #else - glDrawBuffers( count, buffers ); + glDrawBuffers(count, buffers); #endif - } - } - else - TRACELOG( LOG_WARNING, "GL: One color buffer active by default" ); + } + } + else RL_TRACELOG(RL_LOG_WARNING, "GL: One color buffer active by default"); #endif } @@ -1918,2507 +1787,2042 @@ void rlActiveDrawBuffers( int count ) //---------------------------------------------------------------------------------- // Enable color blending -void rlEnableColorBlend( void ) -{ - glEnable( GL_BLEND ); -} +void RLGL_EnableColorBlend(void) { glEnable(GL_BLEND); } // Disable color blending -void rlDisableColorBlend( void ) -{ - glDisable( GL_BLEND ); -} +void RLGL_DisableColorBlend(void) { glDisable(GL_BLEND); } // Enable depth test -void rlEnableDepthTest( void ) -{ - glEnable( GL_DEPTH_TEST ); -} +void RLGL_EnableDepthTest(void) { glEnable(GL_DEPTH_TEST); } // Disable depth test -void rlDisableDepthTest( void ) -{ - glDisable( GL_DEPTH_TEST ); -} +void RLGL_DisableDepthTest(void) { glDisable(GL_DEPTH_TEST); } // Enable depth write -void rlEnableDepthMask( void ) -{ - glDepthMask( GL_TRUE ); -} +void RLGL_EnableDepthMask(void) { glDepthMask(GL_TRUE); } // Disable depth write -void rlDisableDepthMask( void ) -{ - glDepthMask( GL_FALSE ); -} +void RLGL_DisableDepthMask(void) { glDepthMask(GL_FALSE); } // Enable backface culling -void rlEnableBackfaceCulling( void ) -{ - glEnable( GL_CULL_FACE ); -} +void RLGL_EnableBackfaceCulling(void) { glEnable(GL_CULL_FACE); } // Disable backface culling -void rlDisableBackfaceCulling( void ) -{ - glDisable( GL_CULL_FACE ); -} +void RLGL_DisableBackfaceCulling(void) { glDisable(GL_CULL_FACE); } // Set face culling mode -void rlSetCullFace( int mode ) +void RLGL_SetCullFace(int mode) { - switch ( mode ) - { - case RL_CULL_FACE_BACK : - glCullFace( GL_BACK ); - break; - case RL_CULL_FACE_FRONT : - glCullFace( GL_FRONT ); - break; - default : - break; - } + switch (mode) + { + case RL_CULL_FACE_BACK: glCullFace(GL_BACK); break; + case RL_CULL_FACE_FRONT: glCullFace(GL_FRONT); break; + default: break; + } } // Enable scissor test -void rlEnableScissorTest( void ) -{ - glEnable( GL_SCISSOR_TEST ); -} +void RLGL_EnableScissorTest(void) { glEnable(GL_SCISSOR_TEST); } // Disable scissor test -void rlDisableScissorTest( void ) -{ - glDisable( GL_SCISSOR_TEST ); -} +void RLGL_DisableScissorTest(void) { glDisable(GL_SCISSOR_TEST); } // Scissor test -void rlScissor( int x, int y, int width, int height ) -{ - glScissor( x, y, width, height ); -} +void RLGL_Scissor(int x, int y, int width, int height) { glScissor(x, y, width, height); } // Enable wire mode -void rlEnableWireMode( void ) +void RLGL_EnableWireMode(void) { -#if defined( GRAPHICS_API_OPENGL_11 ) || defined( GRAPHICS_API_OPENGL_33 ) - // NOTE: glPolygonMode() not available on OpenGL ES - glPolygonMode( GL_FRONT_AND_BACK, GL_LINE ); +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // NOTE: glPolygonMode() not available on OpenGL ES + glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); #endif } -// Disable wire mode -void rlDisableWireMode( void ) +void RLGL_EnablePointMode(void) { -#if defined( GRAPHICS_API_OPENGL_11 ) || defined( GRAPHICS_API_OPENGL_33 ) - // NOTE: glPolygonMode() not available on OpenGL ES - glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // NOTE: glPolygonMode() not available on OpenGL ES + glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); + glEnable(GL_PROGRAM_POINT_SIZE); +#endif +} +// Disable wire mode +void RLGL_DisableWireMode(void) +{ +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + // NOTE: glPolygonMode() not available on OpenGL ES + glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); #endif } // Set the line drawing width -void rlSetLineWidth( float width ) -{ - glLineWidth( width ); -} +void RLGL_SetLineWidth(float width) { glLineWidth(width); } // Get the line drawing width -float rlGetLineWidth( void ) +float RLGL_GetLineWidth(void) { - float width = 0; - glGetFloatv( GL_LINE_WIDTH, &width ); - return width; + float width = 0; + glGetFloatv(GL_LINE_WIDTH, &width); + return width; } // Enable line aliasing -void rlEnableSmoothLines( void ) +void RLGL_EnableSmoothLines(void) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_11 ) - glEnable( GL_LINE_SMOOTH ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11) + glEnable(GL_LINE_SMOOTH); #endif } // Disable line aliasing -void rlDisableSmoothLines( void ) +void RLGL_DisableSmoothLines(void) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_11 ) - glDisable( GL_LINE_SMOOTH ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_11) + glDisable(GL_LINE_SMOOTH); #endif } // Enable stereo rendering -void rlEnableStereoRender( void ) +void RLGL_EnableStereoRender(void) { -#if ( defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) ) - RLGL.State.stereoRender = true; +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + RLGL_GLOBAL_DATA.State.stereoRender = true; #endif } // Disable stereo rendering -void rlDisableStereoRender( void ) +void RLGL_DisableStereoRender(void) { -#if ( defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) ) - RLGL.State.stereoRender = false; +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + RLGL_GLOBAL_DATA.State.stereoRender = false; #endif } // Check if stereo render is enabled -bool rlIsStereoRenderEnabled( void ) +bool RLGL_IsStereoRenderEnabled(void) { -#if ( defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) ) - return RLGL.State.stereoRender; +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) + return RLGL_GLOBAL_DATA.State.stereoRender; #else - return false; + return false; #endif } // Clear color buffer with color -void rlClearColor( unsigned char r, unsigned char g, unsigned char b, unsigned char a ) +void RLGL_ClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a) { - // Color values clamp to 0.0f(0) and 1.0f(255) - float cr = ( float )r / 255; - float cg = ( float )g / 255; - float cb = ( float )b / 255; - float ca = ( float )a / 255; + // Color values clamp to 0.0f(0) and 1.0f(255) + float cr = (float)r/255; + float cg = (float)g/255; + float cb = (float)b/255; + float ca = (float)a/255; - glClearColor( cr, cg, cb, ca ); + glClearColor(cr, cg, cb, ca); } // Clear used screen buffers (color and depth) -void rlClearScreenBuffers( void ) +void RLGL_ClearScreenBuffers(void) { - glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); // Clear used buffers: Color and Depth (Depth is used for 3D) - // glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); // Stencil buffer not used... + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear used buffers: Color and Depth (Depth is used for 3D) + //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); // Stencil buffer not used... } // Check and log OpenGL error codes -void rlCheckErrors() +void RLGL_CheckErrors() { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - int check = 1; - while ( check ) - { - const GLenum err = glGetError(); - switch ( err ) - { - case GL_NO_ERROR : - check = 0; - break; - case 0x0500 : - TRACELOG( RL_LOG_WARNING, "GL: Error detected: GL_INVALID_ENUM" ); - break; - case 0x0501 : - TRACELOG( RL_LOG_WARNING, "GL: Error detected: GL_INVALID_VALUE" ); - break; - case 0x0502 : - TRACELOG( RL_LOG_WARNING, "GL: Error detected: GL_INVALID_OPERATION" ); - break; - case 0x0503 : - TRACELOG( RL_LOG_WARNING, "GL: Error detected: GL_STACK_OVERFLOW" ); - break; - case 0x0504 : - TRACELOG( RL_LOG_WARNING, "GL: Error detected: GL_STACK_UNDERFLOW" ); - break; - case 0x0505 : - TRACELOG( RL_LOG_WARNING, "GL: Error detected: GL_OUT_OF_MEMORY" ); - break; - case 0x0506 : - TRACELOG( RL_LOG_WARNING, "GL: Error detected: GL_INVALID_FRAMEBUFFER_OPERATION" ); - break; - default : - TRACELOG( RL_LOG_WARNING, "GL: Error detected: Unknown error code: %x", err ); - break; - } - } +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + int check = 1; + while (check) + { + const GLenum err = glGetError(); + switch (err) + { + case GL_NO_ERROR: check = 0; break; + case 0x0500: RL_TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_ENUM"); break; + case 0x0501: RL_TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_VALUE"); break; + case 0x0502: RL_TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_OPERATION"); break; + case 0x0503: RL_TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_OVERFLOW"); break; + case 0x0504: RL_TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_STACK_UNDERFLOW"); break; + case 0x0505: RL_TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_OUT_OF_MEMORY"); break; + case 0x0506: RL_TRACELOG(RL_LOG_WARNING, "GL: Error detected: GL_INVALID_FRAMEBUFFER_OPERATION"); break; + default: RL_TRACELOG(RL_LOG_WARNING, "GL: Error detected: Unknown error code: %x", err); break; + } + } #endif } // Set blend mode -void rlSetBlendMode( int mode ) +void RLGL_SetBlendMode(int mode) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - if ( ( RLGL.State.currentBlendMode != mode ) - || ( ( mode == RL_BLEND_CUSTOM || mode == RL_BLEND_CUSTOM_SEPARATE ) && RLGL.State.glCustomBlendModeModified ) ) - { - rlDrawRenderBatch( RLGL.currentBatch ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL_GLOBAL_DATA.State.currentBlendMode != mode) || ((mode == RL_BLEND_CUSTOM || mode == RL_BLEND_CUSTOM_SEPARATE) && RLGL_GLOBAL_DATA.State.glCustomBlendModeModified)) + { + RLGL_DrawRenderBatch(RLGL_GLOBAL_DATA.currentBatch); - switch ( mode ) - { - case RL_BLEND_ALPHA : - glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); - glBlendEquation( GL_FUNC_ADD ); - break; - case RL_BLEND_ADDITIVE : - glBlendFunc( GL_SRC_ALPHA, GL_ONE ); - glBlendEquation( GL_FUNC_ADD ); - break; - case RL_BLEND_MULTIPLIED : - glBlendFunc( GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA ); - glBlendEquation( GL_FUNC_ADD ); - break; - case RL_BLEND_ADD_COLORS : - glBlendFunc( GL_ONE, GL_ONE ); - glBlendEquation( GL_FUNC_ADD ); - break; - case RL_BLEND_SUBTRACT_COLORS : - glBlendFunc( GL_ONE, GL_ONE ); - glBlendEquation( GL_FUNC_SUBTRACT ); - break; - case RL_BLEND_ALPHA_PREMULTIPLY : - glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ); - glBlendEquation( GL_FUNC_ADD ); - break; - case RL_BLEND_CUSTOM : - { - // NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactors() - glBlendFunc( RLGL.State.glBlendSrcFactor, RLGL.State.glBlendDstFactor ); - glBlendEquation( RLGL.State.glBlendEquation ); - } - break; - case RL_BLEND_CUSTOM_SEPARATE : - { - // NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactorsSeparate() - glBlendFuncSeparate( - RLGL.State.glBlendSrcFactorRGB, - RLGL.State.glBlendDestFactorRGB, - RLGL.State.glBlendSrcFactorAlpha, - RLGL.State.glBlendDestFactorAlpha - ); - glBlendEquationSeparate( RLGL.State.glBlendEquationRGB, RLGL.State.glBlendEquationAlpha ); - } - break; - default : - break; - } + switch (mode) + { + case RL_BLEND_ALPHA: glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_ADDITIVE: glBlendFunc(GL_SRC_ALPHA, GL_ONE); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_MULTIPLIED: glBlendFunc(GL_DST_COLOR, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_ADD_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_SUBTRACT_COLORS: glBlendFunc(GL_ONE, GL_ONE); glBlendEquation(GL_FUNC_SUBTRACT); break; + case RL_BLEND_ALPHA_PREMULTIPLY: glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glBlendEquation(GL_FUNC_ADD); break; + case RL_BLEND_CUSTOM: + { + // NOTE: Using GL blend src/dst factors and GL equation configured with RLGL_SetBlendFactors() + glBlendFunc(RLGL_GLOBAL_DATA.State.glBlendSrcFactor, RLGL_GLOBAL_DATA.State.glBlendDstFactor); glBlendEquation(RLGL_GLOBAL_DATA.State.glBlendEquation); - RLGL.State.currentBlendMode = mode; - RLGL.State.glCustomBlendModeModified = false; - } + } break; + case RL_BLEND_CUSTOM_SEPARATE: + { + // NOTE: Using GL blend src/dst factors and GL equation configured with RLGL_SetBlendFactorsSeparate() + glBlendFuncSeparate(RLGL_GLOBAL_DATA.State.glBlendSrcFactorRGB, RLGL_GLOBAL_DATA.State.glBlendDestFactorRGB, RLGL_GLOBAL_DATA.State.glBlendSrcFactorAlpha, RLGL_GLOBAL_DATA.State.glBlendDestFactorAlpha); + glBlendEquationSeparate(RLGL_GLOBAL_DATA.State.glBlendEquationRGB, RLGL_GLOBAL_DATA.State.glBlendEquationAlpha); + + } break; + default: break; + } + + RLGL_GLOBAL_DATA.State.currentBlendMode = mode; + RLGL_GLOBAL_DATA.State.glCustomBlendModeModified = false; + } #endif } // Set blending mode factor and equation -void rlSetBlendFactors( int glSrcFactor, int glDstFactor, int glEquation ) +void RLGL_SetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - if ( ( RLGL.State.glBlendSrcFactor != glSrcFactor ) || ( RLGL.State.glBlendDstFactor != glDstFactor ) || ( RLGL.State.glBlendEquation != glEquation ) ) - { - RLGL.State.glBlendSrcFactor = glSrcFactor; - RLGL.State.glBlendDstFactor = glDstFactor; - RLGL.State.glBlendEquation = glEquation; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL_GLOBAL_DATA.State.glBlendSrcFactor != glSrcFactor) || + (RLGL_GLOBAL_DATA.State.glBlendDstFactor != glDstFactor) || + (RLGL_GLOBAL_DATA.State.glBlendEquation != glEquation)) + { + RLGL_GLOBAL_DATA.State.glBlendSrcFactor = glSrcFactor; + RLGL_GLOBAL_DATA.State.glBlendDstFactor = glDstFactor; + RLGL_GLOBAL_DATA.State.glBlendEquation = glEquation; - RLGL.State.glCustomBlendModeModified = true; - } + RLGL_GLOBAL_DATA.State.glCustomBlendModeModified = true; + } #endif } // Set blending mode factor and equation separately for RGB and alpha -void rlSetBlendFactorsSeparate( int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB, int glEqAlpha ) +void RLGL_SetBlendFactorsSeparate(int glSrcRGB, int glDstRGB, int glSrcAlpha, int glDstAlpha, int glEqRGB, int glEqAlpha) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - if ( ( RLGL.State.glBlendSrcFactorRGB != glSrcRGB ) || ( RLGL.State.glBlendDestFactorRGB != glDstRGB ) || ( RLGL.State.glBlendSrcFactorAlpha != glSrcAlpha ) - || ( RLGL.State.glBlendDestFactorAlpha != glDstAlpha ) || ( RLGL.State.glBlendEquationRGB != glEqRGB ) - || ( RLGL.State.glBlendEquationAlpha != glEqAlpha ) ) - { - RLGL.State.glBlendSrcFactorRGB = glSrcRGB; - RLGL.State.glBlendDestFactorRGB = glDstRGB; - RLGL.State.glBlendSrcFactorAlpha = glSrcAlpha; - RLGL.State.glBlendDestFactorAlpha = glDstAlpha; - RLGL.State.glBlendEquationRGB = glEqRGB; - RLGL.State.glBlendEquationAlpha = glEqAlpha; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL_GLOBAL_DATA.State.glBlendSrcFactorRGB != glSrcRGB) || + (RLGL_GLOBAL_DATA.State.glBlendDestFactorRGB != glDstRGB) || + (RLGL_GLOBAL_DATA.State.glBlendSrcFactorAlpha != glSrcAlpha) || + (RLGL_GLOBAL_DATA.State.glBlendDestFactorAlpha != glDstAlpha) || + (RLGL_GLOBAL_DATA.State.glBlendEquationRGB != glEqRGB) || + (RLGL_GLOBAL_DATA.State.glBlendEquationAlpha != glEqAlpha)) + { + RLGL_GLOBAL_DATA.State.glBlendSrcFactorRGB = glSrcRGB; + RLGL_GLOBAL_DATA.State.glBlendDestFactorRGB = glDstRGB; + RLGL_GLOBAL_DATA.State.glBlendSrcFactorAlpha = glSrcAlpha; + RLGL_GLOBAL_DATA.State.glBlendDestFactorAlpha = glDstAlpha; + RLGL_GLOBAL_DATA.State.glBlendEquationRGB = glEqRGB; + RLGL_GLOBAL_DATA.State.glBlendEquationAlpha = glEqAlpha; - RLGL.State.glCustomBlendModeModified = true; - } + RLGL_GLOBAL_DATA.State.glCustomBlendModeModified = true; + } #endif } //---------------------------------------------------------------------------------- // Module Functions Definition - OpenGL Debug //---------------------------------------------------------------------------------- -#if defined( RLGL_ENABLE_OPENGL_DEBUG_CONTEXT ) && defined( GRAPHICS_API_OPENGL_43 ) -static void GLAPIENTRY - rlDebugMessageCallback( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* userParam ) +#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43) +static void GLAPIENTRY RLGL_DebugMessageCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *message, const void *userParam) { - // Ignore non-significant error/warning codes (NVidia drivers) - // NOTE: Here there are the details with a sample output: - // - #131169 - Framebuffer detailed info: The driver allocated storage for renderbuffer 2. (severity: low) - // - #131185 - Buffer detailed info: Buffer object 1 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_ENUM_88e4) - // will use VIDEO memory as the source for buffer object operations. (severity: low) - // - #131218 - Program/shader state performance warning: Vertex shader in program 7 is being recompiled based on GL state. (severity: medium) - // - #131204 - Texture state usage warning: The texture object (0) bound to texture image unit 0 does not have - // a defined base level and cannot be used for texture mapping. (severity: low) - if ( ( id == 131169 ) || ( id == 131185 ) || ( id == 131218 ) || ( id == 131204 ) ) - return; + // Ignore non-significant error/warning codes (NVidia drivers) + // NOTE: Here there are the details with a sample output: + // - #131169 - Framebuffer detailed info: The driver allocated storage for renderbuffer 2. (severity: low) + // - #131185 - Buffer detailed info: Buffer object 1 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_ENUM_88e4) + // will use VIDEO memory as the source for buffer object operations. (severity: low) + // - #131218 - Program/shader state performance warning: Vertex shader in program 7 is being recompiled based on GL state. (severity: medium) + // - #131204 - Texture state usage warning: The texture object (0) bound to texture image unit 0 does not have + // a defined base level and cannot be used for texture mapping. (severity: low) + if ((id == 131169) || (id == 131185) || (id == 131218) || (id == 131204)) return; - const char* msgSource = NULL; - switch ( source ) - { - case GL_DEBUG_SOURCE_API : - msgSource = "API"; - break; - case GL_DEBUG_SOURCE_WINDOW_SYSTEM : - msgSource = "WINDOW_SYSTEM"; - break; - case GL_DEBUG_SOURCE_SHADER_COMPILER : - msgSource = "SHADER_COMPILER"; - break; - case GL_DEBUG_SOURCE_THIRD_PARTY : - msgSource = "THIRD_PARTY"; - break; - case GL_DEBUG_SOURCE_APPLICATION : - msgSource = "APPLICATION"; - break; - case GL_DEBUG_SOURCE_OTHER : - msgSource = "OTHER"; - break; - default : - break; - } + const char *msgSource = NULL; + switch (source) + { + case GL_DEBUG_SOURCE_API: msgSource = "API"; break; + case GL_DEBUG_SOURCE_WINDOW_SYSTEM: msgSource = "WINDOW_SYSTEM"; break; + case GL_DEBUG_SOURCE_SHADER_COMPILER: msgSource = "SHADER_COMPILER"; break; + case GL_DEBUG_SOURCE_THIRD_PARTY: msgSource = "THIRD_PARTY"; break; + case GL_DEBUG_SOURCE_APPLICATION: msgSource = "APPLICATION"; break; + case GL_DEBUG_SOURCE_OTHER: msgSource = "OTHER"; break; + default: break; + } - const char* msgType = NULL; - switch ( type ) - { - case GL_DEBUG_TYPE_ERROR : - msgType = "ERROR"; - break; - case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR : - msgType = "DEPRECATED_BEHAVIOR"; - break; - case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR : - msgType = "UNDEFINED_BEHAVIOR"; - break; - case GL_DEBUG_TYPE_PORTABILITY : - msgType = "PORTABILITY"; - break; - case GL_DEBUG_TYPE_PERFORMANCE : - msgType = "PERFORMANCE"; - break; - case GL_DEBUG_TYPE_MARKER : - msgType = "MARKER"; - break; - case GL_DEBUG_TYPE_PUSH_GROUP : - msgType = "PUSH_GROUP"; - break; - case GL_DEBUG_TYPE_POP_GROUP : - msgType = "POP_GROUP"; - break; - case GL_DEBUG_TYPE_OTHER : - msgType = "OTHER"; - break; - default : - break; - } + const char *msgType = NULL; + switch (type) + { + case GL_DEBUG_TYPE_ERROR: msgType = "ERROR"; break; + case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: msgType = "DEPRECATED_BEHAVIOR"; break; + case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: msgType = "UNDEFINED_BEHAVIOR"; break; + case GL_DEBUG_TYPE_PORTABILITY: msgType = "PORTABILITY"; break; + case GL_DEBUG_TYPE_PERFORMANCE: msgType = "PERFORMANCE"; break; + case GL_DEBUG_TYPE_MARKER: msgType = "MARKER"; break; + case GL_DEBUG_TYPE_PUSH_GROUP: msgType = "PUSH_GROUP"; break; + case GL_DEBUG_TYPE_POP_GROUP: msgType = "POP_GROUP"; break; + case GL_DEBUG_TYPE_OTHER: msgType = "OTHER"; break; + default: break; + } - const char* msgSeverity = "DEFAULT"; - switch ( severity ) - { - case GL_DEBUG_SEVERITY_LOW : - msgSeverity = "LOW"; - break; - case GL_DEBUG_SEVERITY_MEDIUM : - msgSeverity = "MEDIUM"; - break; - case GL_DEBUG_SEVERITY_HIGH : - msgSeverity = "HIGH"; - break; - case GL_DEBUG_SEVERITY_NOTIFICATION : - msgSeverity = "NOTIFICATION"; - break; - default : - break; - } + const char *msgSeverity = "DEFAULT"; + switch (severity) + { + case GL_DEBUG_SEVERITY_LOW: msgSeverity = "LOW"; break; + case GL_DEBUG_SEVERITY_MEDIUM: msgSeverity = "MEDIUM"; break; + case GL_DEBUG_SEVERITY_HIGH: msgSeverity = "HIGH"; break; + case GL_DEBUG_SEVERITY_NOTIFICATION: msgSeverity = "NOTIFICATION"; break; + default: break; + } - TRACELOG( LOG_WARNING, "GL: OpenGL debug message: %s", message ); - TRACELOG( LOG_WARNING, " > Type: %s", msgType ); - TRACELOG( LOG_WARNING, " > Source = %s", msgSource ); - TRACELOG( LOG_WARNING, " > Severity = %s", msgSeverity ); + RL_TRACELOG(RL_LOG_WARNING, "GL: OpenGL debug message: %s", message); + RL_TRACELOG(RL_LOG_WARNING, " > Type: %s", msgType); + RL_TRACELOG(RL_LOG_WARNING, " > Source = %s", msgSource); + RL_TRACELOG(RL_LOG_WARNING, " > Severity = %s", msgSeverity); } #endif //---------------------------------------------------------------------------------- -// Module Functions Definition - rlgl functionality +// Module Functions Definition - RLGL_gl functionality //---------------------------------------------------------------------------------- -// Initialize rlgl: OpenGL extensions, default buffers/shaders/textures, OpenGL states -void rlglInit( int width, int height ) +// Initialize RLGL_gl: OpenGL extensions, default buffers/shaders/textures, OpenGL states +void RLGL_Init(int width, int height) { - // Enable OpenGL debug context if required -#if defined( RLGL_ENABLE_OPENGL_DEBUG_CONTEXT ) && defined( GRAPHICS_API_OPENGL_43 ) - if ( ( glDebugMessageCallback != NULL ) && ( glDebugMessageControl != NULL ) ) - { - glDebugMessageCallback( rlDebugMessageCallback, 0 ); - // glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, GL_DEBUG_SEVERITY_HIGH, 0, 0, GL_TRUE); + // Enable OpenGL debug context if required +#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT) && defined(GRAPHICS_API_OPENGL_43) + if ((glDebugMessageCallback != NULL) && (glDebugMessageControl != NULL)) + { + glDebugMessageCallback(RLGL_DebugMessageCallback, 0); + // glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, GL_DEBUG_SEVERITY_HIGH, 0, 0, GL_TRUE); - // Debug context options: - // - GL_DEBUG_OUTPUT - Faster version but not useful for breakpoints - // - GL_DEBUG_OUTPUT_SYNCHRONUS - Callback is in sync with errors, so a breakpoint can be placed on the callback in order to get a stacktrace for the - // GL error - glEnable( GL_DEBUG_OUTPUT ); - glEnable( GL_DEBUG_OUTPUT_SYNCHRONOUS ); - } + // Debug context options: + // - GL_DEBUG_OUTPUT - Faster version but not useful for breakpoints + // - GL_DEBUG_OUTPUT_SYNCHRONUS - Callback is in sync with errors, so a breakpoint can be placed on the callback in order to get a stacktrace for the GL error + glEnable(GL_DEBUG_OUTPUT); + glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); + } #endif -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - // Init default white texture - unsigned char pixels[ 4 ] = { 255, 255, 255, 255 }; // 1 pixel RGBA (4 bytes) - RLGL.State.defaultTextureId = rlLoadTexture( pixels, 1, 1, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1 ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Init default white texture + unsigned char pixels[4] = { 255, 255, 255, 255 }; // 1 pixel RGBA (4 bytes) + RLGL_GLOBAL_DATA.State.defaultTextureId = RLGL_LoadTexture(pixels, 1, 1, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, 1); - if ( RLGL.State.defaultTextureId != 0 ) - TRACELOG( RL_LOG_INFO, "TEXTURE: [ID %i] Default texture loaded successfully", RLGL.State.defaultTextureId ); - else - TRACELOG( RL_LOG_WARNING, "TEXTURE: Failed to load default texture" ); + if (RLGL_GLOBAL_DATA.State.defaultTextureId != 0) RL_TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture loaded successfully", RLGL_GLOBAL_DATA.State.defaultTextureId); + else RL_TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load default texture"); - // Init default Shader (customized for GL 3.3 and ES2) - // Loaded: RLGL.State.defaultShaderId + RLGL.State.defaultShaderLocs - rlLoadShaderDefault(); - RLGL.State.currentShaderId = RLGL.State.defaultShaderId; - RLGL.State.currentShaderLocs = RLGL.State.defaultShaderLocs; + // Init default Shader (customized for GL 3.3 and ES2) + // Loaded: RLGL_GLOBAL_DATA.State.defaultShaderId + RLGL_GLOBAL_DATA.State.defaultShaderLocs + RLGL_LoadShaderDefault(); + RLGL_GLOBAL_DATA.State.currentShaderId = RLGL_GLOBAL_DATA.State.defaultShaderId; + RLGL_GLOBAL_DATA.State.currentShaderLocs = RLGL_GLOBAL_DATA.State.defaultShaderLocs; - // Init default vertex arrays buffers - RLGL.defaultBatch = rlLoadRenderBatch( RL_DEFAULT_BATCH_BUFFERS, RL_DEFAULT_BATCH_BUFFER_ELEMENTS ); - RLGL.currentBatch = &RLGL.defaultBatch; + // Init default vertex arrays buffers + RLGL_GLOBAL_DATA.defaultBatch = RLGL_LoadRenderBatch(RL_DEFAULT_BATCH_BUFFERS, RL_DEFAULT_BATCH_BUFFER_ELEMENTS); + RLGL_GLOBAL_DATA.currentBatch = &RLGL_GLOBAL_DATA.defaultBatch; - // Init stack matrices (emulating OpenGL 1.1) - for ( int i = 0; i < RL_MAX_MATRIX_STACK_SIZE; i++ ) - RLGL.State.stack[ i ] = rlMatrixIdentity(); + // Init stack matrices (emulating OpenGL 1.1) + for (int i = 0; i < RL_MAX_MATRIX_STACK_SIZE; i++) RLGL_GLOBAL_DATA.State.stack[i] = RLGL_MatrixIdentity(); - // Init internal matrices - RLGL.State.transform = rlMatrixIdentity(); - RLGL.State.projection = rlMatrixIdentity(); - RLGL.State.modelview = rlMatrixIdentity(); - RLGL.State.currentMatrix = &RLGL.State.modelview; -#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 + // Init internal matrices + RLGL_GLOBAL_DATA.State.transform = RLGL_MatrixIdentity(); + RLGL_GLOBAL_DATA.State.projection = RLGL_MatrixIdentity(); + RLGL_GLOBAL_DATA.State.modelview = RLGL_MatrixIdentity(); + RLGL_GLOBAL_DATA.State.currentMatrix = &RLGL_GLOBAL_DATA.State.modelview; +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 - // Initialize OpenGL default states - //---------------------------------------------------------- - // Init state: Depth test - glDepthFunc( GL_LEQUAL ); // Type of depth testing to apply - glDisable( GL_DEPTH_TEST ); // Disable depth testing for 2D (only used for 3D) + // Initialize OpenGL default states + //---------------------------------------------------------- + // Init state: Depth test + glDepthFunc(GL_LEQUAL); // Type of depth testing to apply + glDisable(GL_DEPTH_TEST); // Disable depth testing for 2D (only used for 3D) - // Init state: Blending mode - glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); // Color blending function (how colors are mixed) - glEnable( GL_BLEND ); // Enable color blending (required to work with transparencies) + // Init state: Blending mode + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Color blending function (how colors are mixed) + glEnable(GL_BLEND); // Enable color blending (required to work with transparencies) - // Init state: Culling - // NOTE: All shapes/models triangles are drawn CCW - glCullFace( GL_BACK ); // Cull the back face (default) - glFrontFace( GL_CCW ); // Front face are defined counter clockwise (default) - glEnable( GL_CULL_FACE ); // Enable backface culling + // Init state: Culling + // NOTE: All shapes/models triangles are drawn CCW + glCullFace(GL_BACK); // Cull the back face (default) + glFrontFace(GL_CCW); // Front face are defined counter clockwise (default) + glEnable(GL_CULL_FACE); // Enable backface culling - // Init state: Cubemap seamless -#if defined( GRAPHICS_API_OPENGL_33 ) - glEnable( GL_TEXTURE_CUBE_MAP_SEAMLESS ); // Seamless cubemaps (not supported on OpenGL ES 2.0) + // Init state: Cubemap seamless +#if defined(GRAPHICS_API_OPENGL_33) + glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS); // Seamless cubemaps (not supported on OpenGL ES 2.0) #endif -#if defined( GRAPHICS_API_OPENGL_11 ) - // Init state: Color hints (deprecated in OpenGL 3.0+) - glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST ); // Improve quality of color and texture coordinate interpolation - glShadeModel( GL_SMOOTH ); // Smooth shading between vertex (vertex colors interpolation) +#if defined(GRAPHICS_API_OPENGL_11) + // Init state: Color hints (deprecated in OpenGL 3.0+) + glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Improve quality of color and texture coordinate interpolation + glShadeModel(GL_SMOOTH); // Smooth shading between vertex (vertex colors interpolation) #endif -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - // Store screen size into global variables - RLGL.State.framebufferWidth = width; - RLGL.State.framebufferHeight = height; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Store screen size into global variables + RLGL_GLOBAL_DATA.State.framebufferWidth = width; + RLGL_GLOBAL_DATA.State.framebufferHeight = height; - TRACELOG( RL_LOG_INFO, "RLGL: Default OpenGL state initialized successfully" ); - //---------------------------------------------------------- + RL_TRACELOG(RL_LOG_INFO, "RLGL_GLOBAL_DATA: Default OpenGL state initialized successfully"); + //---------------------------------------------------------- #endif - // Init state: Color/Depth buffers clear - glClearColor( 0.0f, 0.0f, 0.0f, 1.0f ); // Set clear color (black) - glClearDepth( 1.0f ); // Set clear depth value (default) - glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); // Clear color and depth buffers (depth buffer required for 3D) + // Init state: Color/Depth buffers clear + glClearColor(0.0f, 0.0f, 0.0f, 1.0f); // Set clear color (black) + glClearDepth(1.0f); // Set clear depth value (default) + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear color and depth buffers (depth buffer required for 3D) } // Vertex Buffer Object deinitialization (memory free) -void rlglClose( void ) +void RLGL_Close(void) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - rlUnloadRenderBatch( RLGL.defaultBatch ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL_UnloadRenderBatch(RLGL_GLOBAL_DATA.defaultBatch); - rlUnloadShaderDefault(); // Unload default shader + RLGL_UnloadShaderDefault(); // Unload default shader - glDeleteTextures( 1, &RLGL.State.defaultTextureId ); // Unload default texture - TRACELOG( RL_LOG_INFO, "TEXTURE: [ID %i] Default texture unloaded successfully", RLGL.State.defaultTextureId ); + glDeleteTextures(1, &RLGL_GLOBAL_DATA.State.defaultTextureId); // Unload default texture + RL_TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Default texture unloaded successfully", RLGL_GLOBAL_DATA.State.defaultTextureId); #endif } // Load OpenGL extensions // NOTE: External loader function must be provided -void rlLoadExtensions( void* loader ) +void RLGL_LoadExtensions(void *loader) { -#if defined( GRAPHICS_API_OPENGL_33 ) // Also defined for GRAPHICS_API_OPENGL_21 - // NOTE: glad is generated and contains only required OpenGL 3.3 Core extensions (and lower versions) - if ( gladLoadGL( ( GLADloadfunc )loader ) == 0 ) - TRACELOG( RL_LOG_WARNING, "GLAD: Cannot load OpenGL extensions" ); - else - TRACELOG( RL_LOG_INFO, "GLAD: OpenGL extensions loaded successfully" ); +#if defined(GRAPHICS_API_OPENGL_33) // Also defined for GRAPHICS_API_OPENGL_21 + // NOTE: glad is generated and contains only required OpenGL 3.3 Core extensions (and lower versions) + if (gladLoadGL((GLADloadfunc)loader) == 0) RL_TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL extensions"); + else RL_TRACELOG(RL_LOG_INFO, "GLAD: OpenGL extensions loaded successfully"); - // Get number of supported extensions - GLint numExt = 0; - glGetIntegerv( GL_NUM_EXTENSIONS, &numExt ); - TRACELOG( RL_LOG_INFO, "GL: Supported extensions count: %i", numExt ); + // Get number of supported extensions + GLint numExt = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &numExt); + RL_TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt); -#if defined( RLGL_SHOW_GL_DETAILS_INFO ) - // Get supported extensions list - // WARNING: glGetStringi() not available on OpenGL 2.1 - TRACELOG( RL_LOG_INFO, "GL: OpenGL extensions:" ); - for ( int i = 0; i < numExt; i++ ) - TRACELOG( RL_LOG_INFO, " %s", glGetStringi( GL_EXTENSIONS, i ) ); +#if defined(RLGL_SHOW_GL_DETAILS_INFO) + // Get supported extensions list + // WARNING: glGetStringi() not available on OpenGL 2.1 + RL_TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:"); + for (int i = 0; i < numExt; i++) RL_TRACELOG(RL_LOG_INFO, " %s", glGetStringi(GL_EXTENSIONS, i)); #endif -#if defined( GRAPHICS_API_OPENGL_21 ) - // Register supported extensions flags - // Optional OpenGL 2.1 extensions - RLGL.ExtSupported.vao = GLAD_GL_ARB_vertex_array_object; - RLGL.ExtSupported.instancing = ( GLAD_GL_EXT_draw_instanced && GLAD_GL_ARB_instanced_arrays ); - RLGL.ExtSupported.texNPOT = GLAD_GL_ARB_texture_non_power_of_two; - RLGL.ExtSupported.texFloat32 = GLAD_GL_ARB_texture_float; - RLGL.ExtSupported.texFloat16 = GLAD_GL_ARB_texture_float; - RLGL.ExtSupported.texDepth = GLAD_GL_ARB_depth_texture; - RLGL.ExtSupported.maxDepthBits = 32; - RLGL.ExtSupported.texAnisoFilter = GLAD_GL_EXT_texture_filter_anisotropic; - RLGL.ExtSupported.texMirrorClamp = GLAD_GL_EXT_texture_mirror_clamp; +#if defined(GRAPHICS_API_OPENGL_21) + // Register supported extensions flags + // Optional OpenGL 2.1 extensions + RLGL_GLOBAL_DATA.ExtSupported.vao = GLAD_GL_ARB_vertex_array_object; + RLGL_GLOBAL_DATA.ExtSupported.instancing = (GLAD_GL_EXT_draw_instanced && GLAD_GL_ARB_instanced_arrays); + RLGL_GLOBAL_DATA.ExtSupported.texNPOT = GLAD_GL_ARB_texture_non_power_of_two; + RLGL_GLOBAL_DATA.ExtSupported.texFloat32 = GLAD_GL_ARB_texture_float; + RLGL_GLOBAL_DATA.ExtSupported.texFloat16 = GLAD_GL_ARB_texture_float; + RLGL_GLOBAL_DATA.ExtSupported.texDepth = GLAD_GL_ARB_depth_texture; + RLGL_GLOBAL_DATA.ExtSupported.maxDepthBits = 32; + RLGL_GLOBAL_DATA.ExtSupported.texAnisoFilter = GLAD_GL_EXT_texture_filter_anisotropic; + RLGL_GLOBAL_DATA.ExtSupported.texMirrorClamp = GLAD_GL_EXT_texture_mirror_clamp; #else - // Register supported extensions flags - // OpenGL 3.3 extensions supported by default (core) - RLGL.ExtSupported.vao = true; - RLGL.ExtSupported.instancing = true; - RLGL.ExtSupported.texNPOT = true; - RLGL.ExtSupported.texFloat32 = true; - RLGL.ExtSupported.texFloat16 = true; - RLGL.ExtSupported.texDepth = true; - RLGL.ExtSupported.maxDepthBits = 32; - RLGL.ExtSupported.texAnisoFilter = true; - RLGL.ExtSupported.texMirrorClamp = true; + // Register supported extensions flags + // OpenGL 3.3 extensions supported by default (core) + RLGL_GLOBAL_DATA.ExtSupported.vao = true; + RLGL_GLOBAL_DATA.ExtSupported.instancing = true; + RLGL_GLOBAL_DATA.ExtSupported.texNPOT = true; + RLGL_GLOBAL_DATA.ExtSupported.texFloat32 = true; + RLGL_GLOBAL_DATA.ExtSupported.texFloat16 = true; + RLGL_GLOBAL_DATA.ExtSupported.texDepth = true; + RLGL_GLOBAL_DATA.ExtSupported.maxDepthBits = 32; + RLGL_GLOBAL_DATA.ExtSupported.texAnisoFilter = true; + RLGL_GLOBAL_DATA.ExtSupported.texMirrorClamp = true; #endif - // Optional OpenGL 3.3 extensions - RLGL.ExtSupported.texCompASTC = GLAD_GL_KHR_texture_compression_astc_hdr && GLAD_GL_KHR_texture_compression_astc_ldr; - RLGL.ExtSupported.texCompDXT = GLAD_GL_EXT_texture_compression_s3tc; // Texture compression: DXT - RLGL.ExtSupported.texCompETC2 = GLAD_GL_ARB_ES3_compatibility; // Texture compression: ETC2/EAC -#if defined( GRAPHICS_API_OPENGL_43 ) - RLGL.ExtSupported.computeShader = GLAD_GL_ARB_compute_shader; - RLGL.ExtSupported.ssbo = GLAD_GL_ARB_shader_storage_buffer_object; + // Optional OpenGL 3.3 extensions + RLGL_GLOBAL_DATA.ExtSupported.texCompASTC = GLAD_GL_KHR_texture_compression_astc_hdr && GLAD_GL_KHR_texture_compression_astc_ldr; + RLGL_GLOBAL_DATA.ExtSupported.texCompDXT = GLAD_GL_EXT_texture_compression_s3tc; // Texture compression: DXT + RLGL_GLOBAL_DATA.ExtSupported.texCompETC2 = GLAD_GL_ARB_ES3_compatibility; // Texture compression: ETC2/EAC + #if defined(GRAPHICS_API_OPENGL_43) + RLGL_GLOBAL_DATA.ExtSupported.computeShader = GLAD_GL_ARB_compute_shader; + RLGL_GLOBAL_DATA.ExtSupported.ssbo = GLAD_GL_ARB_shader_storage_buffer_object; + #endif + +#endif // GRAPHICS_API_OPENGL_33 + +#if defined(GRAPHICS_API_OPENGL_ES3) + // Register supported extensions flags + // OpenGL ES 3.0 extensions supported by default (or it should be) + RLGL_GLOBAL_DATA.ExtSupported.vao = true; + RLGL_GLOBAL_DATA.ExtSupported.instancing = true; + RLGL_GLOBAL_DATA.ExtSupported.texNPOT = true; + RLGL_GLOBAL_DATA.ExtSupported.texFloat32 = true; + RLGL_GLOBAL_DATA.ExtSupported.texFloat16 = true; + RLGL_GLOBAL_DATA.ExtSupported.texDepth = true; + RLGL_GLOBAL_DATA.ExtSupported.texDepthWebGL = true; + RLGL_GLOBAL_DATA.ExtSupported.maxDepthBits = 24; + RLGL_GLOBAL_DATA.ExtSupported.texAnisoFilter = true; + RLGL_GLOBAL_DATA.ExtSupported.texMirrorClamp = true; + // TODO: Check for additional OpenGL ES 3.0 supported extensions: + //RLGL_GLOBAL_DATA.ExtSupported.texCompDXT = true; + //RLGL_GLOBAL_DATA.ExtSupported.texCompETC1 = true; + //RLGL_GLOBAL_DATA.ExtSupported.texCompETC2 = true; + //RLGL_GLOBAL_DATA.ExtSupported.texCompPVRT = true; + //RLGL_GLOBAL_DATA.ExtSupported.texCompASTC = true; + //RLGL_GLOBAL_DATA.ExtSupported.maxAnisotropyLevel = true; + //RLGL_GLOBAL_DATA.ExtSupported.computeShader = true; + //RLGL_GLOBAL_DATA.ExtSupported.ssbo = true; + +#elif defined(GRAPHICS_API_OPENGL_ES2) + + #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL) + // TODO: Support GLAD loader for OpenGL ES 3.0 + if (gladLoadGLES2((GLADloadfunc)loader) == 0) RL_TRACELOG(RL_LOG_WARNING, "GLAD: Cannot load OpenGL ES2.0 functions"); + else RL_TRACELOG(RL_LOG_INFO, "GLAD: OpenGL ES 2.0 loaded successfully"); + #endif + + // Get supported extensions list + GLint numExt = 0; + const char **extList = RL_MALLOC(512*sizeof(const char *)); // Allocate 512 strings pointers (2 KB) + const char *extensions = (const char *)glGetString(GL_EXTENSIONS); // One big const string + + // NOTE: We have to duplicate string because glGetString() returns a const string + int size = strlen(extensions) + 1; // Get extensions string size in bytes + char *extensionsDup = (char *)RL_CALLOC(size, sizeof(char)); + strcpy(extensionsDup, extensions); + extList[numExt] = extensionsDup; + + for (int i = 0; i < size; i++) + { + if (extensionsDup[i] == ' ') + { + extensionsDup[i] = '\0'; + numExt++; + extList[numExt] = &extensionsDup[i + 1]; + } + } + + RL_TRACELOG(RL_LOG_INFO, "GL: Supported extensions count: %i", numExt); + +#if defined(RLGL_SHOW_GL_DETAILS_INFO) + RL_TRACELOG(RL_LOG_INFO, "GL: OpenGL extensions:"); + for (int i = 0; i < numExt; i++) RL_TRACELOG(RL_LOG_INFO, " %s", extList[i]); #endif -#endif // GRAPHICS_API_OPENGL_33 + // Check required extensions + for (int i = 0; i < numExt; i++) + { + // Check VAO support + // NOTE: Only check on OpenGL ES, OpenGL 3.3 has VAO support as core feature + if (strcmp(extList[i], (const char *)"GL_OES_vertex_array_object") == 0) + { + // The extension is supported by our hardware and driver, try to get related functions pointers + // NOTE: emscripten does not support VAOs natively, it uses emulation and it reduces overall performance... + glGenVertexArrays = (PFNGLGENVERTEXARRAYSOESPROC)((RLGL_glLoadProc)loader)("glGenVertexArraysOES"); + glBindVertexArray = (PFNGLBINDVERTEXARRAYOESPROC)((RLGL_glLoadProc)loader)("glBindVertexArrayOES"); + glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSOESPROC)((RLGL_glLoadProc)loader)("glDeleteVertexArraysOES"); + //glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)loader("glIsVertexArrayOES"); // NOTE: Fails in WebGL, omitted -#if defined( GRAPHICS_API_OPENGL_ES3 ) - // Register supported extensions flags - // OpenGL ES 3.0 extensions supported by default - RLGL.ExtSupported.vao = true; - RLGL.ExtSupported.instancing = true; - RLGL.ExtSupported.texNPOT = true; - RLGL.ExtSupported.texFloat32 = true; - RLGL.ExtSupported.texFloat16 = true; - RLGL.ExtSupported.texDepth = true; - RLGL.ExtSupported.texDepthWebGL = true; - RLGL.ExtSupported.maxDepthBits = 24; - RLGL.ExtSupported.texAnisoFilter = true; - RLGL.ExtSupported.texMirrorClamp = true; - // TODO: Make sure that the ones above are actually present by default - // TODO: Check for these... - // RLGL.ExtSupported.texCompDXT - // RLGL.ExtSupported.texCompETC1 - // RLGL.ExtSupported.texCompETC2 - // RLGL.ExtSupported.texCompPVRT - // RLGL.ExtSupported.texCompASTC - // RLGL.ExtSupported.computeShader - // RLGL.ExtSupported.ssbo - // RLGL.ExtSupported.maxAnisotropyLevel -#elif defined( GRAPHICS_API_OPENGL_ES2 ) + if ((glGenVertexArrays != NULL) && (glBindVertexArray != NULL) && (glDeleteVertexArrays != NULL)) RLGL_GLOBAL_DATA.ExtSupported.vao = true; + } -#if defined( PLATFORM_DESKTOP ) - // TODO: Support OpenGL ES 3.0 - if ( gladLoadGLES2( ( GLADloadfunc )loader ) == 0 ) - TRACELOG( RL_LOG_WARNING, "GLAD: Cannot load OpenGL ES2.0 functions" ); - else - TRACELOG( RL_LOG_INFO, "GLAD: OpenGL ES 2.0 loaded successfully" ); -#endif + // Check instanced rendering support + if (strcmp(extList[i], (const char *)"GL_ANGLE_instanced_arrays") == 0) // Web ANGLE + { + glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((RLGL_glLoadProc)loader)("glDrawArraysInstancedANGLE"); + glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((RLGL_glLoadProc)loader)("glDrawElementsInstancedANGLE"); + glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((RLGL_glLoadProc)loader)("glVertexAttribDivisorANGLE"); - // Get supported extensions list - GLint numExt = 0; - const char** extList = RL_MALLOC( 512 * sizeof( const char* ) ); // Allocate 512 strings pointers (2 KB) - const char* extensions = ( const char* )glGetString( GL_EXTENSIONS ); // One big const string + if ((glDrawArraysInstanced != NULL) && (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL)) RLGL_GLOBAL_DATA.ExtSupported.instancing = true; + } + else + { + if ((strcmp(extList[i], (const char *)"GL_EXT_draw_instanced") == 0) && // Standard EXT + (strcmp(extList[i], (const char *)"GL_EXT_instanced_arrays") == 0)) + { + glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)((RLGL_glLoadProc)loader)("glDrawArraysInstancedEXT"); + glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)((RLGL_glLoadProc)loader)("glDrawElementsInstancedEXT"); + glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISOREXTPROC)((RLGL_glLoadProc)loader)("glVertexAttribDivisorEXT"); - // NOTE: We have to duplicate string because glGetString() returns a const string - int size = strlen( extensions ) + 1; // Get extensions string size in bytes - char* extensionsDup = ( char* )RL_CALLOC( size, sizeof( char ) ); - strcpy( extensionsDup, extensions ); - extList[ numExt ] = extensionsDup; + if ((glDrawArraysInstanced != NULL) && (glDrawElementsInstanced != NULL) && (glVertexAttribDivisor != NULL)) RLGL_GLOBAL_DATA.ExtSupported.instancing = true; + } + } - for ( int i = 0; i < size; i++ ) - { - if ( extensionsDup[ i ] == ' ' ) - { - extensionsDup[ i ] = '\0'; - numExt++; - extList[ numExt ] = &extensionsDup[ i + 1 ]; - } - } + // Check NPOT textures support + // NOTE: Only check on OpenGL ES, OpenGL 3.3 has NPOT textures full support as core feature + if (strcmp(extList[i], (const char *)"GL_OES_texture_npot") == 0) RLGL_GLOBAL_DATA.ExtSupported.texNPOT = true; - TRACELOG( RL_LOG_INFO, "GL: Supported extensions count: %i", numExt ); + // Check texture float support + if (strcmp(extList[i], (const char *)"GL_OES_texture_float") == 0) RLGL_GLOBAL_DATA.ExtSupported.texFloat32 = true; + if (strcmp(extList[i], (const char *)"GL_OES_texture_half_float") == 0) RLGL_GLOBAL_DATA.ExtSupported.texFloat16 = true; -#if defined( RLGL_SHOW_GL_DETAILS_INFO ) - TRACELOG( RL_LOG_INFO, "GL: OpenGL extensions:" ); - for ( int i = 0; i < numExt; i++ ) - TRACELOG( RL_LOG_INFO, " %s", extList[ i ] ); -#endif + // Check depth texture support + if (strcmp(extList[i], (const char *)"GL_OES_depth_texture") == 0) RLGL_GLOBAL_DATA.ExtSupported.texDepth = true; + if (strcmp(extList[i], (const char *)"GL_WEBGL_depth_texture") == 0) RLGL_GLOBAL_DATA.ExtSupported.texDepthWebGL = true; // WebGL requires unsized internal format + if (RLGL_GLOBAL_DATA.ExtSupported.texDepthWebGL) RLGL_GLOBAL_DATA.ExtSupported.texDepth = true; - // Check required extensions - for ( int i = 0; i < numExt; i++ ) - { - // Check VAO support - // NOTE: Only check on OpenGL ES, OpenGL 3.3 has VAO support as core feature - if ( strcmp( extList[ i ], ( const char* )"GL_OES_vertex_array_object" ) == 0 ) - { - // The extension is supported by our hardware and driver, try to get related functions pointers - // NOTE: emscripten does not support VAOs natively, it uses emulation and it reduces overall performance... - glGenVertexArrays = ( PFNGLGENVERTEXARRAYSOESPROC )( ( rlglLoadProc )loader )( "glGenVertexArraysOES" ); - glBindVertexArray = ( PFNGLBINDVERTEXARRAYOESPROC )( ( rlglLoadProc )loader )( "glBindVertexArrayOES" ); - glDeleteVertexArrays = ( PFNGLDELETEVERTEXARRAYSOESPROC )( ( rlglLoadProc )loader )( "glDeleteVertexArraysOES" ); - // glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)loader("glIsVertexArrayOES"); // NOTE: Fails in WebGL, omitted + if (strcmp(extList[i], (const char *)"GL_OES_depth24") == 0) RLGL_GLOBAL_DATA.ExtSupported.maxDepthBits = 24; // Not available on WebGL + if (strcmp(extList[i], (const char *)"GL_OES_depth32") == 0) RLGL_GLOBAL_DATA.ExtSupported.maxDepthBits = 32; // Not available on WebGL - if ( ( glGenVertexArrays != NULL ) && ( glBindVertexArray != NULL ) && ( glDeleteVertexArrays != NULL ) ) - RLGL.ExtSupported.vao = true; - } + // Check texture compression support: DXT + if ((strcmp(extList[i], (const char *)"GL_EXT_texture_compression_s3tc") == 0) || + (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_s3tc") == 0) || + (strcmp(extList[i], (const char *)"GL_WEBKIT_WEBGL_compressed_texture_s3tc") == 0)) RLGL_GLOBAL_DATA.ExtSupported.texCompDXT = true; - // Check instanced rendering support - if ( strcmp( extList[ i ], ( const char* )"GL_ANGLE_instanced_arrays" ) == 0 ) // Web ANGLE - { - glDrawArraysInstanced = ( PFNGLDRAWARRAYSINSTANCEDEXTPROC )( ( rlglLoadProc )loader )( "glDrawArraysInstancedANGLE" ); - glDrawElementsInstanced = ( PFNGLDRAWELEMENTSINSTANCEDEXTPROC )( ( rlglLoadProc )loader )( "glDrawElementsInstancedANGLE" ); - glVertexAttribDivisor = ( PFNGLVERTEXATTRIBDIVISOREXTPROC )( ( rlglLoadProc )loader )( "glVertexAttribDivisorANGLE" ); + // Check texture compression support: ETC1 + if ((strcmp(extList[i], (const char *)"GL_OES_compressed_ETC1_RGB8_texture") == 0) || + (strcmp(extList[i], (const char *)"GL_WEBGL_compressed_texture_etc1") == 0)) RLGL_GLOBAL_DATA.ExtSupported.texCompETC1 = true; - if ( ( glDrawArraysInstanced != NULL ) && ( glDrawElementsInstanced != NULL ) && ( glVertexAttribDivisor != NULL ) ) - RLGL.ExtSupported.instancing = true; - } - else - { - if ( ( strcmp( extList[ i ], ( const char* )"GL_EXT_draw_instanced" ) == 0 ) && // Standard EXT - ( strcmp( extList[ i ], ( const char* )"GL_EXT_instanced_arrays" ) == 0 ) ) - { - glDrawArraysInstanced = ( PFNGLDRAWARRAYSINSTANCEDEXTPROC )( ( rlglLoadProc )loader )( "glDrawArraysInstancedEXT" ); - glDrawElementsInstanced = ( PFNGLDRAWELEMENTSINSTANCEDEXTPROC )( ( rlglLoadProc )loader )( "glDrawElementsInstancedEXT" ); - glVertexAttribDivisor = ( PFNGLVERTEXATTRIBDIVISOREXTPROC )( ( rlglLoadProc )loader )( "glVertexAttribDivisorEXT" ); + // Check texture compression support: ETC2/EAC + if (strcmp(extList[i], (const char *)"GL_ARB_ES3_compatibility") == 0) RLGL_GLOBAL_DATA.ExtSupported.texCompETC2 = true; - if ( ( glDrawArraysInstanced != NULL ) && ( glDrawElementsInstanced != NULL ) && ( glVertexAttribDivisor != NULL ) ) - RLGL.ExtSupported.instancing = true; - } - } + // Check texture compression support: PVR + if (strcmp(extList[i], (const char *)"GL_IMG_texture_compression_pvrtc") == 0) RLGL_GLOBAL_DATA.ExtSupported.texCompPVRT = true; - // Check NPOT textures support - // NOTE: Only check on OpenGL ES, OpenGL 3.3 has NPOT textures full support as core feature - if ( strcmp( extList[ i ], ( const char* )"GL_OES_texture_npot" ) == 0 ) - RLGL.ExtSupported.texNPOT = true; + // Check texture compression support: ASTC + if (strcmp(extList[i], (const char *)"GL_KHR_texture_compression_astc_hdr") == 0) RLGL_GLOBAL_DATA.ExtSupported.texCompASTC = true; - // Check texture float support - if ( strcmp( extList[ i ], ( const char* )"GL_OES_texture_float" ) == 0 ) - RLGL.ExtSupported.texFloat32 = true; - if ( strcmp( extList[ i ], ( const char* )"GL_OES_texture_half_float" ) == 0 ) - RLGL.ExtSupported.texFloat16 = true; + // Check anisotropic texture filter support + if (strcmp(extList[i], (const char *)"GL_EXT_texture_filter_anisotropic") == 0) RLGL_GLOBAL_DATA.ExtSupported.texAnisoFilter = true; - // Check depth texture support - if ( strcmp( extList[ i ], ( const char* )"GL_OES_depth_texture" ) == 0 ) - RLGL.ExtSupported.texDepth = true; - if ( strcmp( extList[ i ], ( const char* )"GL_WEBGL_depth_texture" ) == 0 ) - RLGL.ExtSupported.texDepthWebGL = true; // WebGL requires unsized internal format - if ( RLGL.ExtSupported.texDepthWebGL ) - RLGL.ExtSupported.texDepth = true; + // Check clamp mirror wrap mode support + if (strcmp(extList[i], (const char *)"GL_EXT_texture_mirror_clamp") == 0) RLGL_GLOBAL_DATA.ExtSupported.texMirrorClamp = true; + } - if ( strcmp( extList[ i ], ( const char* )"GL_OES_depth24" ) == 0 ) - RLGL.ExtSupported.maxDepthBits = 24; // Not available on WebGL - if ( strcmp( extList[ i ], ( const char* )"GL_OES_depth32" ) == 0 ) - RLGL.ExtSupported.maxDepthBits = 32; // Not available on WebGL + // Free extensions pointers + RL_FREE(extList); + RL_FREE(extensionsDup); // Duplicated string must be deallocated +#endif // GRAPHICS_API_OPENGL_ES2 - // Check texture compression support: DXT - if ( ( strcmp( extList[ i ], ( const char* )"GL_EXT_texture_compression_s3tc" ) == 0 ) - || ( strcmp( extList[ i ], ( const char* )"GL_WEBGL_compressed_texture_s3tc" ) == 0 ) - || ( strcmp( extList[ i ], ( const char* )"GL_WEBKIT_WEBGL_compressed_texture_s3tc" ) == 0 ) ) - RLGL.ExtSupported.texCompDXT = true; + // Check OpenGL information and capabilities + //------------------------------------------------------------------------------ + // Show current OpenGL and GLSL version + RL_TRACELOG(RL_LOG_INFO, "GL: OpenGL device information:"); + RL_TRACELOG(RL_LOG_INFO, " > Vendor: %s", glGetString(GL_VENDOR)); + RL_TRACELOG(RL_LOG_INFO, " > Renderer: %s", glGetString(GL_RENDERER)); + RL_TRACELOG(RL_LOG_INFO, " > Version: %s", glGetString(GL_VERSION)); + RL_TRACELOG(RL_LOG_INFO, " > GLSL: %s", glGetString(GL_SHADING_LANGUAGE_VERSION)); - // Check texture compression support: ETC1 - if ( ( strcmp( extList[ i ], ( const char* )"GL_OES_compressed_ETC1_RGB8_texture" ) == 0 ) - || ( strcmp( extList[ i ], ( const char* )"GL_WEBGL_compressed_texture_etc1" ) == 0 ) ) - RLGL.ExtSupported.texCompETC1 = true; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: Anisotropy levels capability is an extension + #ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT + #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF + #endif + glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &RLGL_GLOBAL_DATA.ExtSupported.maxAnisotropyLevel); - // Check texture compression support: ETC2/EAC - if ( strcmp( extList[ i ], ( const char* )"GL_ARB_ES3_compatibility" ) == 0 ) - RLGL.ExtSupported.texCompETC2 = true; +#if defined(RLGL_SHOW_GL_DETAILS_INFO) + // Show some OpenGL GPU capabilities + RL_TRACELOG(RL_LOG_INFO, "GL: OpenGL capabilities:"); + GLint capability = 0; + glGetIntegerv(GL_MAX_TEXTURE_SIZE, &capability); + RL_TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_SIZE: %i", capability); + glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &capability); + RL_TRACELOG(RL_LOG_INFO, " GL_MAX_CUBE_MAP_TEXTURE_SIZE: %i", capability); + glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &capability); + RL_TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_IMAGE_UNITS: %i", capability); + glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &capability); + RL_TRACELOG(RL_LOG_INFO, " GL_MAX_VERTEX_ATTRIBS: %i", capability); + #if !defined(GRAPHICS_API_OPENGL_ES2) + glGetIntegerv(GL_MAX_UNIFORM_BLOCK_SIZE, &capability); + RL_TRACELOG(RL_LOG_INFO, " GL_MAX_UNIFORM_BLOCK_SIZE: %i", capability); + glGetIntegerv(GL_MAX_DRAW_BUFFERS, &capability); + RL_TRACELOG(RL_LOG_INFO, " GL_MAX_DRAW_BUFFERS: %i", capability); + if (RLGL_GLOBAL_DATA.ExtSupported.texAnisoFilter) RL_TRACELOG(RL_LOG_INFO, " GL_MAX_TEXTURE_MAX_ANISOTROPY: %.0f", RLGL_GLOBAL_DATA.ExtSupported.maxAnisotropyLevel); + #endif + glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &capability); + RL_TRACELOG(RL_LOG_INFO, " GL_NUM_COMPRESSED_TEXTURE_FORMATS: %i", capability); + GLint *compFormats = (GLint *)RL_CALLOC(capability, sizeof(GLint)); + glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS, compFormats); + for (int i = 0; i < capability; i++) RL_TRACELOG(RL_LOG_INFO, " %s", RLGL_GetCompressedFormatName(compFormats[i])); + RL_FREE(compFormats); - // Check texture compression support: PVR - if ( strcmp( extList[ i ], ( const char* )"GL_IMG_texture_compression_pvrtc" ) == 0 ) - RLGL.ExtSupported.texCompPVRT = true; +#if defined(GRAPHICS_API_OPENGL_43) + glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &capability); + RL_TRACELOG(RL_LOG_INFO, " GL_MAX_VERTEX_ATTRIB_BINDINGS: %i", capability); + glGetIntegerv(GL_MAX_UNIFORM_LOCATIONS, &capability); + RL_TRACELOG(RL_LOG_INFO, " GL_MAX_UNIFORM_LOCATIONS: %i", capability); +#endif // GRAPHICS_API_OPENGL_43 +#else // RLGL_SHOW_GL_DETAILS_INFO - // Check texture compression support: ASTC - if ( strcmp( extList[ i ], ( const char* )"GL_KHR_texture_compression_astc_hdr" ) == 0 ) - RLGL.ExtSupported.texCompASTC = true; + // Show some basic info about GL supported features + if (RLGL_GLOBAL_DATA.ExtSupported.vao) RL_TRACELOG(RL_LOG_INFO, "GL: VAO extension detected, VAO functions loaded successfully"); + else RL_TRACELOG(RL_LOG_WARNING, "GL: VAO extension not found, VAO not supported"); + if (RLGL_GLOBAL_DATA.ExtSupported.texNPOT) RL_TRACELOG(RL_LOG_INFO, "GL: NPOT textures extension detected, full NPOT textures supported"); + else RL_TRACELOG(RL_LOG_WARNING, "GL: NPOT textures extension not found, limited NPOT support (no-mipmaps, no-repeat)"); + if (RLGL_GLOBAL_DATA.ExtSupported.texCompDXT) RL_TRACELOG(RL_LOG_INFO, "GL: DXT compressed textures supported"); + if (RLGL_GLOBAL_DATA.ExtSupported.texCompETC1) RL_TRACELOG(RL_LOG_INFO, "GL: ETC1 compressed textures supported"); + if (RLGL_GLOBAL_DATA.ExtSupported.texCompETC2) RL_TRACELOG(RL_LOG_INFO, "GL: ETC2/EAC compressed textures supported"); + if (RLGL_GLOBAL_DATA.ExtSupported.texCompPVRT) RL_TRACELOG(RL_LOG_INFO, "GL: PVRT compressed textures supported"); + if (RLGL_GLOBAL_DATA.ExtSupported.texCompASTC) RL_TRACELOG(RL_LOG_INFO, "GL: ASTC compressed textures supported"); + if (RLGL_GLOBAL_DATA.ExtSupported.computeShader) RL_TRACELOG(RL_LOG_INFO, "GL: Compute shaders supported"); + if (RLGL_GLOBAL_DATA.ExtSupported.ssbo) RL_TRACELOG(RL_LOG_INFO, "GL: Shader storage buffer objects supported"); +#endif // RLGL_SHOW_GL_DETAILS_INFO - // Check anisotropic texture filter support - if ( strcmp( extList[ i ], ( const char* )"GL_EXT_texture_filter_anisotropic" ) == 0 ) - RLGL.ExtSupported.texAnisoFilter = true; - - // Check clamp mirror wrap mode support - if ( strcmp( extList[ i ], ( const char* )"GL_EXT_texture_mirror_clamp" ) == 0 ) - RLGL.ExtSupported.texMirrorClamp = true; - } - - // Free extensions pointers - RL_FREE( extList ); - RL_FREE( extensionsDup ); // Duplicated string must be deallocated -#endif // GRAPHICS_API_OPENGL_ES2 - - // Check OpenGL information and capabilities - //------------------------------------------------------------------------------ - // Show current OpenGL and GLSL version - TRACELOG( RL_LOG_INFO, "GL: OpenGL device information:" ); - TRACELOG( RL_LOG_INFO, " > Vendor: %s", glGetString( GL_VENDOR ) ); - TRACELOG( RL_LOG_INFO, " > Renderer: %s", glGetString( GL_RENDERER ) ); - TRACELOG( RL_LOG_INFO, " > Version: %s", glGetString( GL_VERSION ) ); - TRACELOG( RL_LOG_INFO, " > GLSL: %s", glGetString( GL_SHADING_LANGUAGE_VERSION ) ); - -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) -// NOTE: Anisotropy levels capability is an extension -#ifndef GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT -#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF -#endif - glGetFloatv( GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &RLGL.ExtSupported.maxAnisotropyLevel ); - -#if defined( RLGL_SHOW_GL_DETAILS_INFO ) - // Show some OpenGL GPU capabilities - TRACELOG( RL_LOG_INFO, "GL: OpenGL capabilities:" ); - GLint capability = 0; - glGetIntegerv( GL_MAX_TEXTURE_SIZE, &capability ); - TRACELOG( RL_LOG_INFO, " GL_MAX_TEXTURE_SIZE: %i", capability ); - glGetIntegerv( GL_MAX_CUBE_MAP_TEXTURE_SIZE, &capability ); - TRACELOG( RL_LOG_INFO, " GL_MAX_CUBE_MAP_TEXTURE_SIZE: %i", capability ); - glGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS, &capability ); - TRACELOG( RL_LOG_INFO, " GL_MAX_TEXTURE_IMAGE_UNITS: %i", capability ); - glGetIntegerv( GL_MAX_VERTEX_ATTRIBS, &capability ); - TRACELOG( RL_LOG_INFO, " GL_MAX_VERTEX_ATTRIBS: %i", capability ); -#if ! defined( GRAPHICS_API_OPENGL_ES2 ) - glGetIntegerv( GL_MAX_UNIFORM_BLOCK_SIZE, &capability ); - TRACELOG( RL_LOG_INFO, " GL_MAX_UNIFORM_BLOCK_SIZE: %i", capability ); - glGetIntegerv( GL_MAX_DRAW_BUFFERS, &capability ); - TRACELOG( RL_LOG_INFO, " GL_MAX_DRAW_BUFFERS: %i", capability ); - if ( RLGL.ExtSupported.texAnisoFilter ) - TRACELOG( RL_LOG_INFO, " GL_MAX_TEXTURE_MAX_ANISOTROPY: %.0f", RLGL.ExtSupported.maxAnisotropyLevel ); -#endif - glGetIntegerv( GL_NUM_COMPRESSED_TEXTURE_FORMATS, &capability ); - TRACELOG( RL_LOG_INFO, " GL_NUM_COMPRESSED_TEXTURE_FORMATS: %i", capability ); - GLint* compFormats = ( GLint* )RL_CALLOC( capability, sizeof( GLint ) ); - glGetIntegerv( GL_COMPRESSED_TEXTURE_FORMATS, compFormats ); - for ( int i = 0; i < capability; i++ ) - TRACELOG( RL_LOG_INFO, " %s", rlGetCompressedFormatName( compFormats[ i ] ) ); - RL_FREE( compFormats ); - -#if defined( GRAPHICS_API_OPENGL_43 ) - glGetIntegerv( GL_MAX_VERTEX_ATTRIB_BINDINGS, &capability ); - TRACELOG( RL_LOG_INFO, " GL_MAX_VERTEX_ATTRIB_BINDINGS: %i", capability ); - glGetIntegerv( GL_MAX_UNIFORM_LOCATIONS, &capability ); - TRACELOG( RL_LOG_INFO, " GL_MAX_UNIFORM_LOCATIONS: %i", capability ); -#endif // GRAPHICS_API_OPENGL_43 -#else // RLGL_SHOW_GL_DETAILS_INFO - - // Show some basic info about GL supported features - if ( RLGL.ExtSupported.vao ) - TRACELOG( RL_LOG_INFO, "GL: VAO extension detected, VAO functions loaded successfully" ); - else - TRACELOG( RL_LOG_WARNING, "GL: VAO extension not found, VAO not supported" ); - if ( RLGL.ExtSupported.texNPOT ) - TRACELOG( RL_LOG_INFO, "GL: NPOT textures extension detected, full NPOT textures supported" ); - else - TRACELOG( RL_LOG_WARNING, "GL: NPOT textures extension not found, limited NPOT support (no-mipmaps, no-repeat)" ); - if ( RLGL.ExtSupported.texCompDXT ) - TRACELOG( RL_LOG_INFO, "GL: DXT compressed textures supported" ); - if ( RLGL.ExtSupported.texCompETC1 ) - TRACELOG( RL_LOG_INFO, "GL: ETC1 compressed textures supported" ); - if ( RLGL.ExtSupported.texCompETC2 ) - TRACELOG( RL_LOG_INFO, "GL: ETC2/EAC compressed textures supported" ); - if ( RLGL.ExtSupported.texCompPVRT ) - TRACELOG( RL_LOG_INFO, "GL: PVRT compressed textures supported" ); - if ( RLGL.ExtSupported.texCompASTC ) - TRACELOG( RL_LOG_INFO, "GL: ASTC compressed textures supported" ); - if ( RLGL.ExtSupported.computeShader ) - TRACELOG( RL_LOG_INFO, "GL: Compute shaders supported" ); - if ( RLGL.ExtSupported.ssbo ) - TRACELOG( RL_LOG_INFO, "GL: Shader storage buffer objects supported" ); -#endif // RLGL_SHOW_GL_DETAILS_INFO - -#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 } // Get current OpenGL version -int rlGetVersion( void ) +int RLGL_GetVersion(void) { - int glVersion = 0; -#if defined( GRAPHICS_API_OPENGL_11 ) - glVersion = RL_OPENGL_11; + int glVersion = 0; +#if defined(GRAPHICS_API_OPENGL_11) + glVersion = RLGL_OPENGL_11; #endif -#if defined( GRAPHICS_API_OPENGL_21 ) - glVersion = RL_OPENGL_21; -#elif defined( GRAPHICS_API_OPENGL_43 ) - glVersion = RL_OPENGL_43; -#elif defined( GRAPHICS_API_OPENGL_33 ) - glVersion = RL_OPENGL_33; +#if defined(GRAPHICS_API_OPENGL_21) + glVersion = RLGL_OPENGL_21; +#elif defined(GRAPHICS_API_OPENGL_43) + glVersion = RLGL_OPENGL_43; +#elif defined(GRAPHICS_API_OPENGL_33) + glVersion = RLGL_OPENGL_33; #endif -#if defined( GRAPHICS_API_OPENGL_ES3 ) - glVersion = RL_OPENGL_ES_30; -#elif defined( GRAPHICS_API_OPENGL_ES2 ) - glVersion = RL_OPENGL_ES_20; +#if defined(GRAPHICS_API_OPENGL_ES3) + glVersion = RLGL_OPENGL_ES_30; +#elif defined(GRAPHICS_API_OPENGL_ES2) + glVersion = RLGL_OPENGL_ES_20; #endif - return glVersion; + return glVersion; } // Set current framebuffer width -void rlSetFramebufferWidth( int width ) +void RLGL_SetFramebufferWidth(int width) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - RLGL.State.framebufferWidth = width; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL_GLOBAL_DATA.State.framebufferWidth = width; #endif } // Set current framebuffer height -void rlSetFramebufferHeight( int height ) +void RLGL_SetFramebufferHeight(int height) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - RLGL.State.framebufferHeight = height; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL_GLOBAL_DATA.State.framebufferHeight = height; #endif } // Get default framebuffer width -int rlGetFramebufferWidth( void ) +int RLGL_GetFramebufferWidth(void) { - int width = 0; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - width = RLGL.State.framebufferWidth; + int width = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + width = RLGL_GLOBAL_DATA.State.framebufferWidth; #endif - return width; + return width; } // Get default framebuffer height -int rlGetFramebufferHeight( void ) +int RLGL_GetFramebufferHeight(void) { - int height = 0; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - height = RLGL.State.framebufferHeight; + int height = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + height = RLGL_GLOBAL_DATA.State.framebufferHeight; #endif - return height; + return height; } // Get default internal texture (white texture) // NOTE: Default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8 -unsigned int rlGetTextureIdDefault( void ) +unsigned int RLGL_GetTextureIdDefault(void) { - unsigned int id = 0; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - id = RLGL.State.defaultTextureId; + unsigned int id = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + id = RLGL_GLOBAL_DATA.State.defaultTextureId; #endif - return id; + return id; } // Get default shader id -unsigned int rlGetShaderIdDefault( void ) +unsigned int RLGL_GetShaderIdDefault(void) { - unsigned int id = 0; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - id = RLGL.State.defaultShaderId; + unsigned int id = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + id = RLGL_GLOBAL_DATA.State.defaultShaderId; #endif - return id; + return id; } // Get default shader locs -int* rlGetShaderLocsDefault( void ) +int *RLGL_GetShaderLocsDefault(void) { - int* locs = NULL; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - locs = RLGL.State.defaultShaderLocs; + int *locs = NULL; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + locs = RLGL_GLOBAL_DATA.State.defaultShaderLocs; #endif - return locs; + return locs; } // Render batch management //------------------------------------------------------------------------------------------------ // Load render batch -rlRenderBatch rlLoadRenderBatch( int numBuffers, int bufferElements ) +RLGL_RenderBatch RLGL_LoadRenderBatch(int numBuffers, int bufferElements) { - rlRenderBatch batch = { 0 }; + RLGL_RenderBatch batch = { 0 }; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - // Initialize CPU (RAM) vertex buffers (position, texcoord, color data and indexes) - //-------------------------------------------------------------------------------------------- - batch.vertexBuffer = ( rlVertexBuffer* )RL_MALLOC( numBuffers * sizeof( rlVertexBuffer ) ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Initialize CPU (RAM) vertex buffers (position, texcoord, color data and indexes) + //-------------------------------------------------------------------------------------------- + batch.vertexBuffer = (RLGL_VertexBuffer *)RL_MALLOC(numBuffers*sizeof(RLGL_VertexBuffer)); - for ( int i = 0; i < numBuffers; i++ ) - { - batch.vertexBuffer[ i ].elementCount = bufferElements; + for (int i = 0; i < numBuffers; i++) + { + batch.vertexBuffer[i].elementCount = bufferElements; - batch.vertexBuffer[ i ].vertices = ( float* )RL_MALLOC( bufferElements * 3 * 4 * sizeof( float ) ); // 3 float by vertex, 4 vertex by quad - batch.vertexBuffer[ i ].texcoords = ( float* )RL_MALLOC( bufferElements * 2 * 4 * sizeof( float ) ); // 2 float by texcoord, 4 texcoord by quad - batch.vertexBuffer[ i ].colors = - ( unsigned char* )RL_MALLOC( bufferElements * 4 * 4 * sizeof( unsigned char ) ); // 4 float by color, 4 colors by quad -#if defined( GRAPHICS_API_OPENGL_33 ) - batch.vertexBuffer[ i ].indices = ( unsigned int* )RL_MALLOC( bufferElements * 6 * sizeof( unsigned int ) ); // 6 int by quad (indices) + batch.vertexBuffer[i].vertices = (float *)RL_MALLOC(bufferElements*3*4*sizeof(float)); // 3 float by vertex, 4 vertex by quad + batch.vertexBuffer[i].texcoords = (float *)RL_MALLOC(bufferElements*2*4*sizeof(float)); // 2 float by texcoord, 4 texcoord by quad + batch.vertexBuffer[i].colors = (unsigned char *)RL_MALLOC(bufferElements*4*4*sizeof(unsigned char)); // 4 float by color, 4 colors by quad +#if defined(GRAPHICS_API_OPENGL_33) + batch.vertexBuffer[i].indices = (unsigned int *)RL_MALLOC(bufferElements*6*sizeof(unsigned int)); // 6 int by quad (indices) #endif -#if defined( GRAPHICS_API_OPENGL_ES2 ) - batch.vertexBuffer[ i ].indices = ( unsigned short* )RL_MALLOC( bufferElements * 6 * sizeof( unsigned short ) ); // 6 int by quad (indices) +#if defined(GRAPHICS_API_OPENGL_ES2) + batch.vertexBuffer[i].indices = (unsigned short *)RL_MALLOC(bufferElements*6*sizeof(unsigned short)); // 6 int by quad (indices) #endif - for ( int j = 0; j < ( 3 * 4 * bufferElements ); j++ ) - batch.vertexBuffer[ i ].vertices[ j ] = 0.0f; - for ( int j = 0; j < ( 2 * 4 * bufferElements ); j++ ) - batch.vertexBuffer[ i ].texcoords[ j ] = 0.0f; - for ( int j = 0; j < ( 4 * 4 * bufferElements ); j++ ) - batch.vertexBuffer[ i ].colors[ j ] = 0; + for (int j = 0; j < (3*4*bufferElements); j++) batch.vertexBuffer[i].vertices[j] = 0.0f; + for (int j = 0; j < (2*4*bufferElements); j++) batch.vertexBuffer[i].texcoords[j] = 0.0f; + for (int j = 0; j < (4*4*bufferElements); j++) batch.vertexBuffer[i].colors[j] = 0; - int k = 0; + int k = 0; - // Indices can be initialized right now - for ( int j = 0; j < ( 6 * bufferElements ); j += 6 ) - { - batch.vertexBuffer[ i ].indices[ j ] = 4 * k; - batch.vertexBuffer[ i ].indices[ j + 1 ] = 4 * k + 1; - batch.vertexBuffer[ i ].indices[ j + 2 ] = 4 * k + 2; - batch.vertexBuffer[ i ].indices[ j + 3 ] = 4 * k; - batch.vertexBuffer[ i ].indices[ j + 4 ] = 4 * k + 2; - batch.vertexBuffer[ i ].indices[ j + 5 ] = 4 * k + 3; + // Indices can be initialized right now + for (int j = 0; j < (6*bufferElements); j += 6) + { + batch.vertexBuffer[i].indices[j] = 4*k; + batch.vertexBuffer[i].indices[j + 1] = 4*k + 1; + batch.vertexBuffer[i].indices[j + 2] = 4*k + 2; + batch.vertexBuffer[i].indices[j + 3] = 4*k; + batch.vertexBuffer[i].indices[j + 4] = 4*k + 2; + batch.vertexBuffer[i].indices[j + 5] = 4*k + 3; - k++; - } + k++; + } - RLGL.State.vertexCounter = 0; - } + RLGL_GLOBAL_DATA.State.vertexCounter = 0; + } - TRACELOG( RL_LOG_INFO, "RLGL: Render batch vertex buffers loaded successfully in RAM (CPU)" ); - //-------------------------------------------------------------------------------------------- + RL_TRACELOG(RL_LOG_INFO, "RLGL_GLOBAL_DATA: Render batch vertex buffers loaded successfully in RAM (CPU)"); + //-------------------------------------------------------------------------------------------- - // Upload to GPU (VRAM) vertex data and initialize VAOs/VBOs - //-------------------------------------------------------------------------------------------- - for ( int i = 0; i < numBuffers; i++ ) - { - if ( RLGL.ExtSupported.vao ) - { - // Initialize Quads VAO - glGenVertexArrays( 1, &batch.vertexBuffer[ i ].vaoId ); - glBindVertexArray( batch.vertexBuffer[ i ].vaoId ); - } + // Upload to GPU (VRAM) vertex data and initialize VAOs/VBOs + //-------------------------------------------------------------------------------------------- + for (int i = 0; i < numBuffers; i++) + { + if (RLGL_GLOBAL_DATA.ExtSupported.vao) + { + // Initialize Quads VAO + glGenVertexArrays(1, &batch.vertexBuffer[i].vaoId); + glBindVertexArray(batch.vertexBuffer[i].vaoId); + } - // Quads - Vertex buffers binding and attributes enable - // Vertex position buffer (shader-location = 0) - glGenBuffers( 1, &batch.vertexBuffer[ i ].vboId[ 0 ] ); - glBindBuffer( GL_ARRAY_BUFFER, batch.vertexBuffer[ i ].vboId[ 0 ] ); - glBufferData( GL_ARRAY_BUFFER, bufferElements * 3 * 4 * sizeof( float ), batch.vertexBuffer[ i ].vertices, GL_DYNAMIC_DRAW ); - glEnableVertexAttribArray( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_VERTEX_POSITION ] ); - glVertexAttribPointer( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_VERTEX_POSITION ], 3, GL_FLOAT, 0, 0, 0 ); + // Quads - Vertex buffers binding and attributes enable + // Vertex position buffer (shader-location = 0) + glGenBuffers(1, &batch.vertexBuffer[i].vboId[0]); + glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[0]); + glBufferData(GL_ARRAY_BUFFER, bufferElements*3*4*sizeof(float), batch.vertexBuffer[i].vertices, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]); + glVertexAttribPointer(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0); - // Vertex texcoord buffer (shader-location = 1) - glGenBuffers( 1, &batch.vertexBuffer[ i ].vboId[ 1 ] ); - glBindBuffer( GL_ARRAY_BUFFER, batch.vertexBuffer[ i ].vboId[ 1 ] ); - glBufferData( GL_ARRAY_BUFFER, bufferElements * 2 * 4 * sizeof( float ), batch.vertexBuffer[ i ].texcoords, GL_DYNAMIC_DRAW ); - glEnableVertexAttribArray( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_VERTEX_TEXCOORD01 ] ); - glVertexAttribPointer( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_VERTEX_TEXCOORD01 ], 2, GL_FLOAT, 0, 0, 0 ); + // Vertex texcoord buffer (shader-location = 1) + glGenBuffers(1, &batch.vertexBuffer[i].vboId[1]); + glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[1]); + glBufferData(GL_ARRAY_BUFFER, bufferElements*2*4*sizeof(float), batch.vertexBuffer[i].texcoords, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]); + glVertexAttribPointer(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0); - // Vertex color buffer (shader-location = 3) - glGenBuffers( 1, &batch.vertexBuffer[ i ].vboId[ 2 ] ); - glBindBuffer( GL_ARRAY_BUFFER, batch.vertexBuffer[ i ].vboId[ 2 ] ); - glBufferData( GL_ARRAY_BUFFER, bufferElements * 4 * 4 * sizeof( unsigned char ), batch.vertexBuffer[ i ].colors, GL_DYNAMIC_DRAW ); - glEnableVertexAttribArray( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_VERTEX_COLOR ] ); - glVertexAttribPointer( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_VERTEX_COLOR ], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0 ); + // Vertex color buffer (shader-location = 3) + glGenBuffers(1, &batch.vertexBuffer[i].vboId[2]); + glBindBuffer(GL_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[2]); + glBufferData(GL_ARRAY_BUFFER, bufferElements*4*4*sizeof(unsigned char), batch.vertexBuffer[i].colors, GL_DYNAMIC_DRAW); + glEnableVertexAttribArray(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]); + glVertexAttribPointer(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0); - // Fill index buffer - glGenBuffers( 1, &batch.vertexBuffer[ i ].vboId[ 3 ] ); - glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, batch.vertexBuffer[ i ].vboId[ 3 ] ); -#if defined( GRAPHICS_API_OPENGL_33 ) - glBufferData( GL_ELEMENT_ARRAY_BUFFER, bufferElements * 6 * sizeof( int ), batch.vertexBuffer[ i ].indices, GL_STATIC_DRAW ); + // Fill index buffer + glGenBuffers(1, &batch.vertexBuffer[i].vboId[3]); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch.vertexBuffer[i].vboId[3]); +#if defined(GRAPHICS_API_OPENGL_33) + glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements*6*sizeof(int), batch.vertexBuffer[i].indices, GL_STATIC_DRAW); #endif -#if defined( GRAPHICS_API_OPENGL_ES2 ) - glBufferData( GL_ELEMENT_ARRAY_BUFFER, bufferElements * 6 * sizeof( short ), batch.vertexBuffer[ i ].indices, GL_STATIC_DRAW ); +#if defined(GRAPHICS_API_OPENGL_ES2) + glBufferData(GL_ELEMENT_ARRAY_BUFFER, bufferElements*6*sizeof(short), batch.vertexBuffer[i].indices, GL_STATIC_DRAW); #endif - } + } - TRACELOG( RL_LOG_INFO, "RLGL: Render batch vertex buffers loaded successfully in VRAM (GPU)" ); + RL_TRACELOG(RL_LOG_INFO, "RLGL_GLOBAL_DATA: Render batch vertex buffers loaded successfully in VRAM (GPU)"); - // Unbind the current VAO - if ( RLGL.ExtSupported.vao ) - glBindVertexArray( 0 ); - //-------------------------------------------------------------------------------------------- + // Unbind the current VAO + if (RLGL_GLOBAL_DATA.ExtSupported.vao) glBindVertexArray(0); + //-------------------------------------------------------------------------------------------- - // Init draw calls tracking system - //-------------------------------------------------------------------------------------------- - batch.draws = ( rlDrawCall* )RL_MALLOC( RL_DEFAULT_BATCH_DRAWCALLS * sizeof( rlDrawCall ) ); + // Init draw calls tracking system + //-------------------------------------------------------------------------------------------- + batch.draws = (RLGL_DrawCall *)RL_MALLOC(RL_DEFAULT_BATCH_DRAWCALLS*sizeof(RLGL_DrawCall)); - for ( int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++ ) - { - batch.draws[ i ].mode = RL_QUADS; - batch.draws[ i ].vertexCount = 0; - batch.draws[ i ].vertexAlignment = 0; - // batch.draws[i].vaoId = 0; - // batch.draws[i].shaderId = 0; - batch.draws[ i ].textureId = RLGL.State.defaultTextureId; - // batch.draws[i].RLGL.State.projection = rlMatrixIdentity(); - // batch.draws[i].RLGL.State.modelview = rlMatrixIdentity(); - } + for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++) + { + batch.draws[i].mode = RL_QUADS; + batch.draws[i].vertexCount = 0; + batch.draws[i].vertexAlignment = 0; + //batch.draws[i].vaoId = 0; + //batch.draws[i].shaderId = 0; + batch.draws[i].textureId = RLGL_GLOBAL_DATA.State.defaultTextureId; + //batch.draws[i].RLGL_GLOBAL_DATA.State.projection = RLGL_MatrixIdentity(); + //batch.draws[i].RLGL_GLOBAL_DATA.State.modelview = RLGL_MatrixIdentity(); + } - batch.bufferCount = numBuffers; // Record buffer count - batch.drawCounter = 1; // Reset draws counter - batch.currentDepth = -1.0f; // Reset depth value - //-------------------------------------------------------------------------------------------- + batch.bufferCount = numBuffers; // Record buffer count + batch.drawCounter = 1; // Reset draws counter + batch.currentDepth = -1.0f; // Reset depth value + //-------------------------------------------------------------------------------------------- #endif - return batch; + return batch; } // Unload default internal buffers vertex data from CPU and GPU -void rlUnloadRenderBatch( rlRenderBatch batch ) +void RLGL_UnloadRenderBatch(RLGL_RenderBatch batch) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - // Unbind everything - glBindBuffer( GL_ARRAY_BUFFER, 0 ); - glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Unbind everything + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); - // Unload all vertex buffers data - for ( int i = 0; i < batch.bufferCount; i++ ) - { - // Unbind VAO attribs data - if ( RLGL.ExtSupported.vao ) - { - glBindVertexArray( batch.vertexBuffer[ i ].vaoId ); - glDisableVertexAttribArray( 0 ); - glDisableVertexAttribArray( 1 ); - glDisableVertexAttribArray( 2 ); - glDisableVertexAttribArray( 3 ); - glBindVertexArray( 0 ); - } + // Unload all vertex buffers data + for (int i = 0; i < batch.bufferCount; i++) + { + // Unbind VAO attribs data + if (RLGL_GLOBAL_DATA.ExtSupported.vao) + { + glBindVertexArray(batch.vertexBuffer[i].vaoId); + glDisableVertexAttribArray(0); + glDisableVertexAttribArray(1); + glDisableVertexAttribArray(2); + glDisableVertexAttribArray(3); + glBindVertexArray(0); + } - // Delete VBOs from GPU (VRAM) - glDeleteBuffers( 1, &batch.vertexBuffer[ i ].vboId[ 0 ] ); - glDeleteBuffers( 1, &batch.vertexBuffer[ i ].vboId[ 1 ] ); - glDeleteBuffers( 1, &batch.vertexBuffer[ i ].vboId[ 2 ] ); - glDeleteBuffers( 1, &batch.vertexBuffer[ i ].vboId[ 3 ] ); + // Delete VBOs from GPU (VRAM) + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[0]); + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[1]); + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[2]); + glDeleteBuffers(1, &batch.vertexBuffer[i].vboId[3]); - // Delete VAOs from GPU (VRAM) - if ( RLGL.ExtSupported.vao ) - glDeleteVertexArrays( 1, &batch.vertexBuffer[ i ].vaoId ); + // Delete VAOs from GPU (VRAM) + if (RLGL_GLOBAL_DATA.ExtSupported.vao) glDeleteVertexArrays(1, &batch.vertexBuffer[i].vaoId); - // Free vertex arrays memory from CPU (RAM) - RL_FREE( batch.vertexBuffer[ i ].vertices ); - RL_FREE( batch.vertexBuffer[ i ].texcoords ); - RL_FREE( batch.vertexBuffer[ i ].colors ); - RL_FREE( batch.vertexBuffer[ i ].indices ); - } + // Free vertex arrays memory from CPU (RAM) + RL_FREE(batch.vertexBuffer[i].vertices); + RL_FREE(batch.vertexBuffer[i].texcoords); + RL_FREE(batch.vertexBuffer[i].colors); + RL_FREE(batch.vertexBuffer[i].indices); + } - // Unload arrays - RL_FREE( batch.vertexBuffer ); - RL_FREE( batch.draws ); + // Unload arrays + RL_FREE(batch.vertexBuffer); + RL_FREE(batch.draws); #endif } // Draw render batch // NOTE: We require a pointer to reset batch and increase current buffer (multi-buffer) -void rlDrawRenderBatch( rlRenderBatch* batch ) +void RLGL_DrawRenderBatch(RLGL_RenderBatch *batch) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - // Update batch vertex buffers - //------------------------------------------------------------------------------------------------------------ - // NOTE: If there is not vertex data, buffers doesn't need to be updated (vertexCount > 0) - // TODO: If no data changed on the CPU arrays --> No need to re-update GPU arrays (use a change detector flag?) - if ( RLGL.State.vertexCounter > 0 ) - { - // Activate elements VAO - if ( RLGL.ExtSupported.vao ) - glBindVertexArray( batch->vertexBuffer[ batch->currentBuffer ].vaoId ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Update batch vertex buffers + //------------------------------------------------------------------------------------------------------------ + // NOTE: If there is not vertex data, buffers doesn't need to be updated (vertexCount > 0) + // TODO: If no data changed on the CPU arrays --> No need to re-update GPU arrays (use a change detector flag?) + if (RLGL_GLOBAL_DATA.State.vertexCounter > 0) + { + // Activate elements VAO + if (RLGL_GLOBAL_DATA.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId); - // Vertex positions buffer - glBindBuffer( GL_ARRAY_BUFFER, batch->vertexBuffer[ batch->currentBuffer ].vboId[ 0 ] ); - glBufferSubData( GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter * 3 * sizeof( float ), batch->vertexBuffer[ batch->currentBuffer ].vertices ); - // glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*batch->vertexBuffer[batch->currentBuffer].elementCount, - // batch->vertexBuffer[batch->currentBuffer].vertices, GL_DYNAMIC_DRAW); // Update all buffer + // Vertex positions buffer + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]); + glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL_GLOBAL_DATA.State.vertexCounter*3*sizeof(float), batch->vertexBuffer[batch->currentBuffer].vertices); + //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].vertices, GL_DYNAMIC_DRAW); // Update all buffer - // Texture coordinates buffer - glBindBuffer( GL_ARRAY_BUFFER, batch->vertexBuffer[ batch->currentBuffer ].vboId[ 1 ] ); - glBufferSubData( GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter * 2 * sizeof( float ), batch->vertexBuffer[ batch->currentBuffer ].texcoords ); - // glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*4*batch->vertexBuffer[batch->currentBuffer].elementCount, - // batch->vertexBuffer[batch->currentBuffer].texcoords, GL_DYNAMIC_DRAW); // Update all buffer + // Texture coordinates buffer + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]); + glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL_GLOBAL_DATA.State.vertexCounter*2*sizeof(float), batch->vertexBuffer[batch->currentBuffer].texcoords); + //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].texcoords, GL_DYNAMIC_DRAW); // Update all buffer - // Colors buffer - glBindBuffer( GL_ARRAY_BUFFER, batch->vertexBuffer[ batch->currentBuffer ].vboId[ 2 ] ); - glBufferSubData( GL_ARRAY_BUFFER, 0, RLGL.State.vertexCounter * 4 * sizeof( unsigned char ), batch->vertexBuffer[ batch->currentBuffer ].colors ); - // glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*batch->vertexBuffer[batch->currentBuffer].elementCount, - // batch->vertexBuffer[batch->currentBuffer].colors, GL_DYNAMIC_DRAW); // Update all buffer + // Colors buffer + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]); + glBufferSubData(GL_ARRAY_BUFFER, 0, RLGL_GLOBAL_DATA.State.vertexCounter*4*sizeof(unsigned char), batch->vertexBuffer[batch->currentBuffer].colors); + //glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].colors, GL_DYNAMIC_DRAW); // Update all buffer - // NOTE: glMapBuffer() causes sync issue. - // If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job. - // To avoid waiting (idle), you can call first glBufferData() with NULL pointer before glMapBuffer(). - // If you do that, the previous data in PBO will be discarded and glMapBuffer() returns a new - // allocated pointer immediately even if GPU is still working with the previous data. + // NOTE: glMapBuffer() causes sync issue. + // If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job. + // To avoid waiting (idle), you can call first glBufferData() with NULL pointer before glMapBuffer(). + // If you do that, the previous data in PBO will be discarded and glMapBuffer() returns a new + // allocated pointer immediately even if GPU is still working with the previous data. - // Another option: map the buffer object into client's memory - // Probably this code could be moved somewhere else... - // batch->vertexBuffer[batch->currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE); - // if (batch->vertexBuffer[batch->currentBuffer].vertices) - // { - // Update vertex data - // } - // glUnmapBuffer(GL_ARRAY_BUFFER); + // Another option: map the buffer object into client's memory + // Probably this code could be moved somewhere else... + // batch->vertexBuffer[batch->currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE); + // if (batch->vertexBuffer[batch->currentBuffer].vertices) + // { + // Update vertex data + // } + // glUnmapBuffer(GL_ARRAY_BUFFER); - // Unbind the current VAO - if ( RLGL.ExtSupported.vao ) - glBindVertexArray( 0 ); - } - //------------------------------------------------------------------------------------------------------------ + // Unbind the current VAO + if (RLGL_GLOBAL_DATA.ExtSupported.vao) glBindVertexArray(0); + } + //------------------------------------------------------------------------------------------------------------ - // Draw batch vertex buffers (considering VR stereo if required) - //------------------------------------------------------------------------------------------------------------ - Matrix matProjection = RLGL.State.projection; - Matrix matModelView = RLGL.State.modelview; + // Draw batch vertex buffers (considering VR stereo if required) + //------------------------------------------------------------------------------------------------------------ + RL_Matrix matProjection = RLGL_GLOBAL_DATA.State.projection; + RL_Matrix matModelView = RLGL_GLOBAL_DATA.State.modelview; - int eyeCount = 1; - if ( RLGL.State.stereoRender ) - eyeCount = 2; + int eyeCount = 1; + if (RLGL_GLOBAL_DATA.State.stereoRender) eyeCount = 2; - for ( int eye = 0; eye < eyeCount; eye++ ) - { - if ( eyeCount == 2 ) - { - // Setup current eye viewport (half screen width) - rlViewport( eye * RLGL.State.framebufferWidth / 2, 0, RLGL.State.framebufferWidth / 2, RLGL.State.framebufferHeight ); + for (int eye = 0; eye < eyeCount; eye++) + { + if (eyeCount == 2) + { + // Setup current eye viewport (half screen width) + RLGL_Viewport(eye*RLGL_GLOBAL_DATA.State.framebufferWidth/2, 0, RLGL_GLOBAL_DATA.State.framebufferWidth/2, RLGL_GLOBAL_DATA.State.framebufferHeight); - // Set current eye view offset to modelview matrix - rlSetMatrixModelview( rlMatrixMultiply( matModelView, RLGL.State.viewOffsetStereo[ eye ] ) ); - // Set current eye projection matrix - rlSetMatrixProjection( RLGL.State.projectionStereo[ eye ] ); - } + // Set current eye view offset to modelview matrix + RLGL_SetMatrixModelview(RLGL_MatrixMultiply(matModelView, RLGL_GLOBAL_DATA.State.viewOffsetStereo[eye])); + // Set current eye projection matrix + RLGL_SetMatrixProjection(RLGL_GLOBAL_DATA.State.projectionStereo[eye]); + } - // Draw buffers - if ( RLGL.State.vertexCounter > 0 ) - { - // Set current shader and upload current MVP matrix - glUseProgram( RLGL.State.currentShaderId ); + // Draw buffers + if (RLGL_GLOBAL_DATA.State.vertexCounter > 0) + { + // Set current shader and upload current MVP matrix + glUseProgram(RLGL_GLOBAL_DATA.State.currentShaderId); - // Create modelview-projection matrix and upload to shader - Matrix matMVP = rlMatrixMultiply( RLGL.State.modelview, RLGL.State.projection ); - float matMVPfloat[ 16 ] = { matMVP.m0, matMVP.m1, matMVP.m2, matMVP.m3, matMVP.m4, matMVP.m5, matMVP.m6, matMVP.m7, - matMVP.m8, matMVP.m9, matMVP.m10, matMVP.m11, matMVP.m12, matMVP.m13, matMVP.m14, matMVP.m15 }; - glUniformMatrix4fv( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_MATRIX_MVP ], 1, false, matMVPfloat ); + // Create modelview-projection matrix and upload to shader + RL_Matrix matMVP = RLGL_MatrixMultiply(RLGL_GLOBAL_DATA.State.modelview, RLGL_GLOBAL_DATA.State.projection); + float matMVPfloat[16] = { + matMVP.m0, matMVP.m1, matMVP.m2, matMVP.m3, + matMVP.m4, matMVP.m5, matMVP.m6, matMVP.m7, + matMVP.m8, matMVP.m9, matMVP.m10, matMVP.m11, + matMVP.m12, matMVP.m13, matMVP.m14, matMVP.m15 + }; + glUniformMatrix4fv(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_MATRIX_MVP], 1, false, matMVPfloat); - if ( RLGL.ExtSupported.vao ) - glBindVertexArray( batch->vertexBuffer[ batch->currentBuffer ].vaoId ); - else - { - // Bind vertex attrib: position (shader-location = 0) - glBindBuffer( GL_ARRAY_BUFFER, batch->vertexBuffer[ batch->currentBuffer ].vboId[ 0 ] ); - glVertexAttribPointer( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_VERTEX_POSITION ], 3, GL_FLOAT, 0, 0, 0 ); - glEnableVertexAttribArray( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_VERTEX_POSITION ] ); + if (RLGL_GLOBAL_DATA.ExtSupported.vao) glBindVertexArray(batch->vertexBuffer[batch->currentBuffer].vaoId); + else + { + // Bind vertex attrib: position (shader-location = 0) + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[0]); + glVertexAttribPointer(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION], 3, GL_FLOAT, 0, 0, 0); + glEnableVertexAttribArray(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_POSITION]); - // Bind vertex attrib: texcoord (shader-location = 1) - glBindBuffer( GL_ARRAY_BUFFER, batch->vertexBuffer[ batch->currentBuffer ].vboId[ 1 ] ); - glVertexAttribPointer( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_VERTEX_TEXCOORD01 ], 2, GL_FLOAT, 0, 0, 0 ); - glEnableVertexAttribArray( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_VERTEX_TEXCOORD01 ] ); + // Bind vertex attrib: texcoord (shader-location = 1) + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[1]); + glVertexAttribPointer(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01], 2, GL_FLOAT, 0, 0, 0); + glEnableVertexAttribArray(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01]); - // Bind vertex attrib: color (shader-location = 3) - glBindBuffer( GL_ARRAY_BUFFER, batch->vertexBuffer[ batch->currentBuffer ].vboId[ 2 ] ); - glVertexAttribPointer( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_VERTEX_COLOR ], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0 ); - glEnableVertexAttribArray( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_VERTEX_COLOR ] ); + // Bind vertex attrib: color (shader-location = 3) + glBindBuffer(GL_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[2]); + glVertexAttribPointer(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR], 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, 0); + glEnableVertexAttribArray(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_VERTEX_COLOR]); - glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, batch->vertexBuffer[ batch->currentBuffer ].vboId[ 3 ] ); - } + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, batch->vertexBuffer[batch->currentBuffer].vboId[3]); + } - // Setup some default shader values - glUniform4f( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_COLOR_DIFFUSE ], 1.0f, 1.0f, 1.0f, 1.0f ); - glUniform1i( RLGL.State.currentShaderLocs[ RL_SHADER_LOC_MAP_DIFFUSE ], 0 ); // Active default sampler2D: texture0 + // Setup some default shader values + glUniform4f(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE], 1.0f, 1.0f, 1.0f, 1.0f); + glUniform1i(RLGL_GLOBAL_DATA.State.currentShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE], 0); // Active default sampler2D: texture0 - // Activate additional sampler textures - // Those additional textures will be common for all draw calls of the batch - for ( int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++ ) - { - if ( RLGL.State.activeTextureId[ i ] > 0 ) - { - glActiveTexture( GL_TEXTURE0 + 1 + i ); - glBindTexture( GL_TEXTURE_2D, RLGL.State.activeTextureId[ i ] ); - } - } + // Activate additional sampler textures + // Those additional textures will be common for all draw calls of the batch + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) + { + if (RLGL_GLOBAL_DATA.State.activeTextureId[i] > 0) + { + glActiveTexture(GL_TEXTURE0 + 1 + i); + glBindTexture(GL_TEXTURE_2D, RLGL_GLOBAL_DATA.State.activeTextureId[i]); + } + } - // Activate default sampler2D texture0 (one texture is always active for default batch shader) - // NOTE: Batch system accumulates calls by texture0 changes, additional textures are enabled for all the draw calls - glActiveTexture( GL_TEXTURE0 ); + // Activate default sampler2D texture0 (one texture is always active for default batch shader) + // NOTE: Batch system accumulates calls by texture0 changes, additional textures are enabled for all the draw calls + glActiveTexture(GL_TEXTURE0); - for ( int i = 0, vertexOffset = 0; i < batch->drawCounter; i++ ) - { - // Bind current draw call texture, activated as GL_TEXTURE0 and Bound to sampler2D texture0 by default - glBindTexture( GL_TEXTURE_2D, batch->draws[ i ].textureId ); + for (int i = 0, vertexOffset = 0; i < batch->drawCounter; i++) + { + // Bind current draw call texture, activated as GL_TEXTURE0 and Bound to sampler2D texture0 by default + glBindTexture(GL_TEXTURE_2D, batch->draws[i].textureId); - if ( ( batch->draws[ i ].mode == RL_LINES ) || ( batch->draws[ i ].mode == RL_TRIANGLES ) ) - glDrawArrays( batch->draws[ i ].mode, vertexOffset, batch->draws[ i ].vertexCount ); - else - { -#if defined( GRAPHICS_API_OPENGL_33 ) - // We need to define the number of indices to be processed: elementCount*6 - // NOTE: The final parameter tells the GPU the offset in bytes from the - // start of the index buffer to the location of the first index to process - glDrawElements( - GL_TRIANGLES, - batch->draws[ i ].vertexCount / 4 * 6, - GL_UNSIGNED_INT, - ( GLvoid* )( vertexOffset / 4 * 6 * sizeof( GLuint ) ) - ); + if ((batch->draws[i].mode == RL_LINES) || (batch->draws[i].mode == RL_TRIANGLES)) glDrawArrays(batch->draws[i].mode, vertexOffset, batch->draws[i].vertexCount); + else + { +#if defined(GRAPHICS_API_OPENGL_33) + // We need to define the number of indices to be processed: elementCount*6 + // NOTE: The final parameter tells the GPU the offset in bytes from the + // start of the index buffer to the location of the first index to process + glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_INT, (GLvoid *)(vertexOffset/4*6*sizeof(GLuint))); #endif -#if defined( GRAPHICS_API_OPENGL_ES2 ) - glDrawElements( - GL_TRIANGLES, - batch->draws[ i ].vertexCount / 4 * 6, - GL_UNSIGNED_SHORT, - ( GLvoid* )( vertexOffset / 4 * 6 * sizeof( GLushort ) ) - ); +#if defined(GRAPHICS_API_OPENGL_ES2) + glDrawElements(GL_TRIANGLES, batch->draws[i].vertexCount/4*6, GL_UNSIGNED_SHORT, (GLvoid *)(vertexOffset/4*6*sizeof(GLushort))); #endif - } + } - vertexOffset += ( batch->draws[ i ].vertexCount + batch->draws[ i ].vertexAlignment ); - } + vertexOffset += (batch->draws[i].vertexCount + batch->draws[i].vertexAlignment); + } - if ( ! RLGL.ExtSupported.vao ) - { - glBindBuffer( GL_ARRAY_BUFFER, 0 ); - glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 ); - } + if (!RLGL_GLOBAL_DATA.ExtSupported.vao) + { + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + } - glBindTexture( GL_TEXTURE_2D, 0 ); // Unbind textures - } + glBindTexture(GL_TEXTURE_2D, 0); // Unbind textures + } - if ( RLGL.ExtSupported.vao ) - glBindVertexArray( 0 ); // Unbind VAO + if (RLGL_GLOBAL_DATA.ExtSupported.vao) glBindVertexArray(0); // Unbind VAO - glUseProgram( 0 ); // Unbind shader program - } + glUseProgram(0); // Unbind shader program + } - // Restore viewport to default measures - if ( eyeCount == 2 ) - rlViewport( 0, 0, RLGL.State.framebufferWidth, RLGL.State.framebufferHeight ); - //------------------------------------------------------------------------------------------------------------ + // Restore viewport to default measures + if (eyeCount == 2) RLGL_Viewport(0, 0, RLGL_GLOBAL_DATA.State.framebufferWidth, RLGL_GLOBAL_DATA.State.framebufferHeight); + //------------------------------------------------------------------------------------------------------------ - // Reset batch buffers - //------------------------------------------------------------------------------------------------------------ - // Reset vertex counter for next frame - RLGL.State.vertexCounter = 0; + // Reset batch buffers + //------------------------------------------------------------------------------------------------------------ + // Reset vertex counter for next frame + RLGL_GLOBAL_DATA.State.vertexCounter = 0; - // Reset depth for next draw - batch->currentDepth = -1.0f; + // Reset depth for next draw + batch->currentDepth = -1.0f; - // Restore projection/modelview matrices - RLGL.State.projection = matProjection; - RLGL.State.modelview = matModelView; + // Restore projection/modelview matrices + RLGL_GLOBAL_DATA.State.projection = matProjection; + RLGL_GLOBAL_DATA.State.modelview = matModelView; - // Reset RLGL.currentBatch->draws array - for ( int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++ ) - { - batch->draws[ i ].mode = RL_QUADS; - batch->draws[ i ].vertexCount = 0; - batch->draws[ i ].textureId = RLGL.State.defaultTextureId; - } + // Reset RLGL_GLOBAL_DATA.currentBatch->draws array + for (int i = 0; i < RL_DEFAULT_BATCH_DRAWCALLS; i++) + { + batch->draws[i].mode = RL_QUADS; + batch->draws[i].vertexCount = 0; + batch->draws[i].textureId = RLGL_GLOBAL_DATA.State.defaultTextureId; + } - // Reset active texture units for next batch - for ( int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++ ) - RLGL.State.activeTextureId[ i ] = 0; + // Reset active texture units for next batch + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) RLGL_GLOBAL_DATA.State.activeTextureId[i] = 0; - // Reset draws counter to one draw for the batch - batch->drawCounter = 1; - //------------------------------------------------------------------------------------------------------------ + // Reset draws counter to one draw for the batch + batch->drawCounter = 1; + //------------------------------------------------------------------------------------------------------------ - // Change to next buffer in the list (in case of multi-buffering) - batch->currentBuffer++; - if ( batch->currentBuffer >= batch->bufferCount ) - batch->currentBuffer = 0; + // Change to next buffer in the list (in case of multi-buffering) + batch->currentBuffer++; + if (batch->currentBuffer >= batch->bufferCount) batch->currentBuffer = 0; #endif } -// Set the active render batch for rlgl -void rlSetRenderBatchActive( rlRenderBatch* batch ) +// Set the active render batch for RLGL_gl +void RLGL_SetRenderBatchActive(RLGL_RenderBatch *batch) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - rlDrawRenderBatch( RLGL.currentBatch ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL_DrawRenderBatch(RLGL_GLOBAL_DATA.currentBatch); - if ( batch != NULL ) - RLGL.currentBatch = batch; - else - RLGL.currentBatch = &RLGL.defaultBatch; + if (batch != NULL) RLGL_GLOBAL_DATA.currentBatch = batch; + else RLGL_GLOBAL_DATA.currentBatch = &RLGL_GLOBAL_DATA.defaultBatch; #endif } // Update and draw internal render batch -void rlDrawRenderBatchActive( void ) +void RLGL_DrawRenderBatchActive(void) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - rlDrawRenderBatch( RLGL.currentBatch ); // NOTE: Stereo rendering is checked inside +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL_DrawRenderBatch(RLGL_GLOBAL_DATA.currentBatch); // NOTE: Stereo rendering is checked inside #endif } // Check internal buffer overflow for a given number of vertex -// and force a rlRenderBatch draw call if required -bool rlCheckRenderBatchLimit( int vCount ) +// and force a RLGL_RenderBatch draw call if required +bool RLGL_CheckRenderBatchLimit(int vCount) { - bool overflow = false; + bool overflow = false; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - if ( ( RLGL.State.vertexCounter + vCount ) >= ( RLGL.currentBatch->vertexBuffer[ RLGL.currentBatch->currentBuffer ].elementCount * 4 ) ) - { - overflow = true; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((RLGL_GLOBAL_DATA.State.vertexCounter + vCount) >= + (RLGL_GLOBAL_DATA.currentBatch->vertexBuffer[RLGL_GLOBAL_DATA.currentBatch->currentBuffer].elementCount*4)) + { + overflow = true; - // Store current primitive drawing mode and texture id - int currentMode = RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].mode; - int currentTexture = RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].textureId; + // Store current primitive drawing mode and texture id + int currentMode = RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].mode; + int currentTexture = RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].textureId; - rlDrawRenderBatch( RLGL.currentBatch ); // NOTE: Stereo rendering is checked inside + RLGL_DrawRenderBatch(RLGL_GLOBAL_DATA.currentBatch); // NOTE: Stereo rendering is checked inside - // Restore state of last batch so we can continue adding vertices - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].mode = currentMode; - RLGL.currentBatch->draws[ RLGL.currentBatch->drawCounter - 1 ].textureId = currentTexture; - } + // Restore state of last batch so we can continue adding vertices + RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].mode = currentMode; + RLGL_GLOBAL_DATA.currentBatch->draws[RLGL_GLOBAL_DATA.currentBatch->drawCounter - 1].textureId = currentTexture; + } #endif - return overflow; + return overflow; } // Textures data management //----------------------------------------------------------------------------------------- // Convert image data to OpenGL texture (returns OpenGL valid Id) -unsigned int rlLoadTexture( const void* data, int width, int height, int format, int mipmapCount ) +unsigned int RLGL_LoadTexture(const void *data, int width, int height, int format, int mipmapCount) { - unsigned int id = 0; + unsigned int id = 0; - glBindTexture( GL_TEXTURE_2D, 0 ); // Free any old binding + glBindTexture(GL_TEXTURE_2D, 0); // Free any old binding - // Check texture format support by OpenGL 1.1 (compressed textures not supported) -#if defined( GRAPHICS_API_OPENGL_11 ) - if ( format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB ) - { - TRACELOG( RL_LOG_WARNING, "GL: OpenGL 1.1 does not support GPU compressed texture formats" ); - return id; - } + // Check texture format support by OpenGL 1.1 (compressed textures not supported) +#if defined(GRAPHICS_API_OPENGL_11) + if (format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) + { + RL_TRACELOG(RL_LOG_WARNING, "GL: OpenGL 1.1 does not support GPU compressed texture formats"); + return id; + } #else - if ( ( ! RLGL.ExtSupported.texCompDXT ) - && ( ( format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGB ) || ( format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA ) - || ( format == RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA ) || ( format == RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA ) ) ) - { - TRACELOG( RL_LOG_WARNING, "GL: DXT compressed texture format not supported" ); - return id; - } -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - if ( ( ! RLGL.ExtSupported.texCompETC1 ) && ( format == RL_PIXELFORMAT_COMPRESSED_ETC1_RGB ) ) - { - TRACELOG( RL_LOG_WARNING, "GL: ETC1 compressed texture format not supported" ); - return id; - } + if ((!RLGL_GLOBAL_DATA.ExtSupported.texCompDXT) && ((format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA) || + (format == RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) || (format == RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA))) + { + RL_TRACELOG(RL_LOG_WARNING, "GL: DXT compressed texture format not supported"); + return id; + } +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if ((!RLGL_GLOBAL_DATA.ExtSupported.texCompETC1) && (format == RL_PIXELFORMAT_COMPRESSED_ETC1_RGB)) + { + RL_TRACELOG(RL_LOG_WARNING, "GL: ETC1 compressed texture format not supported"); + return id; + } - if ( ( ! RLGL.ExtSupported.texCompETC2 ) && ( ( format == RL_PIXELFORMAT_COMPRESSED_ETC2_RGB ) || ( format == RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA ) ) ) - { - TRACELOG( RL_LOG_WARNING, "GL: ETC2 compressed texture format not supported" ); - return id; - } + if ((!RLGL_GLOBAL_DATA.ExtSupported.texCompETC2) && ((format == RL_PIXELFORMAT_COMPRESSED_ETC2_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA))) + { + RL_TRACELOG(RL_LOG_WARNING, "GL: ETC2 compressed texture format not supported"); + return id; + } - if ( ( ! RLGL.ExtSupported.texCompPVRT ) && ( ( format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGB ) || ( format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA ) ) ) - { - TRACELOG( RL_LOG_WARNING, "GL: PVRT compressed texture format not supported" ); - return id; - } + if ((!RLGL_GLOBAL_DATA.ExtSupported.texCompPVRT) && ((format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGB) || (format == RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA))) + { + RL_TRACELOG(RL_LOG_WARNING, "GL: PVRT compressed texture format not supported"); + return id; + } - if ( ( ! RLGL.ExtSupported.texCompASTC ) - && ( ( format == RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA ) || ( format == RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA ) ) ) - { - TRACELOG( RL_LOG_WARNING, "GL: ASTC compressed texture format not supported" ); - return id; - } + if ((!RLGL_GLOBAL_DATA.ExtSupported.texCompASTC) && ((format == RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA) || (format == RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA))) + { + RL_TRACELOG(RL_LOG_WARNING, "GL: ASTC compressed texture format not supported"); + return id; + } #endif -#endif // GRAPHICS_API_OPENGL_11 +#endif // GRAPHICS_API_OPENGL_11 - glPixelStorei( GL_UNPACK_ALIGNMENT, 1 ); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - glGenTextures( 1, &id ); // Generate texture id + glGenTextures(1, &id); // Generate texture id - glBindTexture( GL_TEXTURE_2D, id ); + glBindTexture(GL_TEXTURE_2D, id); - int mipWidth = width; - int mipHeight = height; - int mipOffset = 0; // Mipmap data offset, only used for tracelog + int mipWidth = width; + int mipHeight = height; + int mipOffset = 0; // Mipmap data offset, only used for tracelog - // NOTE: Added pointer math separately from function to avoid UBSAN complaining - unsigned char* dataPtr = NULL; - if ( data != NULL ) - dataPtr = ( unsigned char* )data; + // NOTE: Added pointer math separately from function to avoid UBSAN complaining + unsigned char *dataPtr = NULL; + if (data != NULL) dataPtr = (unsigned char *)data; - // Load the different mipmap levels - for ( int i = 0; i < mipmapCount; i++ ) - { - unsigned int mipSize = rlGetPixelDataSize( mipWidth, mipHeight, format ); + // Load the different mipmap levels + for (int i = 0; i < mipmapCount; i++) + { + unsigned int mipSize = RLGL_GetPixelDataSize(mipWidth, mipHeight, format); - unsigned int glInternalFormat, glFormat, glType; - rlGetGlTextureFormats( format, &glInternalFormat, &glFormat, &glType ); + unsigned int glInternalFormat, glFormat, glType; + RLGL_GetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); - TRACELOGD( "TEXTURE: Load mipmap level %i (%i x %i), size: %i, offset: %i", i, mipWidth, mipHeight, mipSize, mipOffset ); + TRACELOGD("TEXTURE: Load mipmap level %i (%i x %i), size: %i, offset: %i", i, mipWidth, mipHeight, mipSize, mipOffset); - if ( glInternalFormat != 0 ) - { - if ( format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB ) - glTexImage2D( GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, glFormat, glType, dataPtr ); -#if ! defined( GRAPHICS_API_OPENGL_11 ) - else - glCompressedTexImage2D( GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, mipSize, dataPtr ); + if (glInternalFormat != 0) + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, glFormat, glType, dataPtr); +#if !defined(GRAPHICS_API_OPENGL_11) + else glCompressedTexImage2D(GL_TEXTURE_2D, i, glInternalFormat, mipWidth, mipHeight, 0, mipSize, dataPtr); #endif -#if defined( GRAPHICS_API_OPENGL_33 ) - if ( format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE ) - { - GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; - glTexParameteriv( GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask ); - } - else if ( format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA ) - { -#if defined( GRAPHICS_API_OPENGL_21 ) - GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA }; -#elif defined( GRAPHICS_API_OPENGL_33 ) - GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN }; +#if defined(GRAPHICS_API_OPENGL_33) + if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) + { + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } + else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) + { +#if defined(GRAPHICS_API_OPENGL_21) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA }; +#elif defined(GRAPHICS_API_OPENGL_33) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN }; #endif - glTexParameteriv( GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask ); - } + glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } #endif - } + } - mipWidth /= 2; - mipHeight /= 2; - mipOffset += mipSize; // Increment offset position to next mipmap - if ( data != NULL ) - dataPtr += mipSize; // Increment data pointer to next mipmap + mipWidth /= 2; + mipHeight /= 2; + mipOffset += mipSize; // Increment offset position to next mipmap + if (data != NULL) dataPtr += mipSize; // Increment data pointer to next mipmap - // Security check for NPOT textures - if ( mipWidth < 1 ) - mipWidth = 1; - if ( mipHeight < 1 ) - mipHeight = 1; - } + // Security check for NPOT textures + if (mipWidth < 1) mipWidth = 1; + if (mipHeight < 1) mipHeight = 1; + } - // Texture parameters configuration - // NOTE: glTexParameteri does NOT affect texture uploading, just the way it's used -#if defined( GRAPHICS_API_OPENGL_ES2 ) - // NOTE: OpenGL ES 2.0 with no GL_OES_texture_npot support (i.e. WebGL) has limited NPOT support, so CLAMP_TO_EDGE must be used - if ( RLGL.ExtSupported.texNPOT ) - { - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); // Set texture to repeat on x-axis - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); // Set texture to repeat on y-axis - } - else - { - // NOTE: If using negative texture coordinates (LoadOBJ()), it does not work! - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); // Set texture to clamp on x-axis - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); // Set texture to clamp on y-axis - } + // Texture parameters configuration + // NOTE: glTexParameteri does NOT affect texture uploading, just the way it's used +#if defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: OpenGL ES 2.0 with no GL_OES_texture_npot support (i.e. WebGL) has limited NPOT support, so CLAMP_TO_EDGE must be used + if (RLGL_GLOBAL_DATA.ExtSupported.texNPOT) + { + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture to repeat on x-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture to repeat on y-axis + } + else + { + // NOTE: If using negative texture coordinates (LoadOBJ()), it does not work! + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // Set texture to clamp on x-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // Set texture to clamp on y-axis + } #else - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT ); // Set texture to repeat on x-axis - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT ); // Set texture to repeat on y-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Set texture to repeat on x-axis + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Set texture to repeat on y-axis #endif - // Magnification and minification filters - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); // Alternative: GL_LINEAR - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); // Alternative: GL_LINEAR + // Magnification and minification filters + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Alternative: GL_LINEAR + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // Alternative: GL_LINEAR -#if defined( GRAPHICS_API_OPENGL_33 ) - if ( mipmapCount > 1 ) - { - // Activate Trilinear filtering if mipmaps are available - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR ); - } +#if defined(GRAPHICS_API_OPENGL_33) + if (mipmapCount > 1) + { + // Activate Trilinear filtering if mipmaps are available + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + } #endif - // At this point we have the texture loaded in GPU and texture parameters configured + // At this point we have the texture loaded in GPU and texture parameters configured - // NOTE: If mipmaps were not in data, they are not generated automatically + // NOTE: If mipmaps were not in data, they are not generated automatically - // Unbind current texture - glBindTexture( GL_TEXTURE_2D, 0 ); + // Unbind current texture + glBindTexture(GL_TEXTURE_2D, 0); - if ( id > 0 ) - TRACELOG( - RL_LOG_INFO, - "TEXTURE: [ID %i] Texture loaded successfully (%ix%i | %s | %i mipmaps)", - id, - width, - height, - rlGetPixelFormatName( format ), - mipmapCount - ); - else - TRACELOG( RL_LOG_WARNING, "TEXTURE: Failed to load texture" ); + if (id > 0) RL_TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Texture loaded successfully (%ix%i | %s | %i mipmaps)", id, width, height, RLGL_GetPixelFormatName(format), mipmapCount); + else RL_TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load texture"); - return id; + return id; } // Load depth texture/renderbuffer (to be attached to fbo) // WARNING: OpenGL ES 2.0 requires GL_OES_depth_texture and WebGL requires WEBGL_depth_texture extensions -unsigned int rlLoadTextureDepth( int width, int height, bool useRenderBuffer ) +unsigned int RLGL_LoadTextureDepth(int width, int height, bool useRenderBuffer) { - unsigned int id = 0; + unsigned int id = 0; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - // In case depth textures not supported, we force renderbuffer usage - if ( ! RLGL.ExtSupported.texDepth ) - useRenderBuffer = true; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // In case depth textures not supported, we force renderbuffer usage + if (!RLGL_GLOBAL_DATA.ExtSupported.texDepth) useRenderBuffer = true; - // NOTE: We let the implementation to choose the best bit-depth - // Possible formats: GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32 and GL_DEPTH_COMPONENT32F - unsigned int glInternalFormat = GL_DEPTH_COMPONENT; + // NOTE: We let the implementation to choose the best bit-depth + // Possible formats: GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32 and GL_DEPTH_COMPONENT32F + unsigned int glInternalFormat = GL_DEPTH_COMPONENT; -#if ( defined( GRAPHICS_API_OPENGL_ES2 ) || defined( GRAPHICS_API_OPENGL_ES3 ) ) - // WARNING: WebGL platform requires unsized internal format definition (GL_DEPTH_COMPONENT) - // while other platforms using OpenGL ES 2.0 require/support sized internal formats depending on the GPU capabilities - if ( ! RLGL.ExtSupported.texDepthWebGL || useRenderBuffer ) - { - if ( RLGL.ExtSupported.maxDepthBits == 32 ) - glInternalFormat = GL_DEPTH_COMPONENT32_OES; - else if ( RLGL.ExtSupported.maxDepthBits == 24 ) - glInternalFormat = GL_DEPTH_COMPONENT24_OES; - else - glInternalFormat = GL_DEPTH_COMPONENT16; - } +#if (defined(GRAPHICS_API_OPENGL_ES2) || defined(GRAPHICS_API_OPENGL_ES3)) + // WARNING: WebGL platform requires unsized internal format definition (GL_DEPTH_COMPONENT) + // while other platforms using OpenGL ES 2.0 require/support sized internal formats depending on the GPU capabilities + if (!RLGL_GLOBAL_DATA.ExtSupported.texDepthWebGL || useRenderBuffer) + { + if (RLGL_GLOBAL_DATA.ExtSupported.maxDepthBits == 32) glInternalFormat = GL_DEPTH_COMPONENT32_OES; + else if (RLGL_GLOBAL_DATA.ExtSupported.maxDepthBits == 24) glInternalFormat = GL_DEPTH_COMPONENT24_OES; + else glInternalFormat = GL_DEPTH_COMPONENT16; + } #endif - if ( ! useRenderBuffer && RLGL.ExtSupported.texDepth ) - { - glGenTextures( 1, &id ); - glBindTexture( GL_TEXTURE_2D, id ); - glTexImage2D( GL_TEXTURE_2D, 0, glInternalFormat, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL ); + if (!useRenderBuffer && RLGL_GLOBAL_DATA.ExtSupported.texDepth) + { + glGenTextures(1, &id); + glBindTexture(GL_TEXTURE_2D, id); + glTexImage2D(GL_TEXTURE_2D, 0, glInternalFormat, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST ); - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST ); - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); - glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); - glBindTexture( GL_TEXTURE_2D, 0 ); + glBindTexture(GL_TEXTURE_2D, 0); - TRACELOG( RL_LOG_INFO, "TEXTURE: Depth texture loaded successfully" ); - } - else - { - // Create the renderbuffer that will serve as the depth attachment for the framebuffer - // NOTE: A renderbuffer is simpler than a texture and could offer better performance on embedded devices - glGenRenderbuffers( 1, &id ); - glBindRenderbuffer( GL_RENDERBUFFER, id ); - glRenderbufferStorage( GL_RENDERBUFFER, glInternalFormat, width, height ); + RL_TRACELOG(RL_LOG_INFO, "TEXTURE: Depth texture loaded successfully"); + } + else + { + // Create the renderbuffer that will serve as the depth attachment for the framebuffer + // NOTE: A renderbuffer is simpler than a texture and could offer better performance on embedded devices + glGenRenderbuffers(1, &id); + glBindRenderbuffer(GL_RENDERBUFFER, id); + glRenderbufferStorage(GL_RENDERBUFFER, glInternalFormat, width, height); - glBindRenderbuffer( GL_RENDERBUFFER, 0 ); + glBindRenderbuffer(GL_RENDERBUFFER, 0); - TRACELOG( - RL_LOG_INFO, - "TEXTURE: [ID %i] Depth renderbuffer loaded successfully (%i bits)", - id, - ( RLGL.ExtSupported.maxDepthBits >= 24 ) ? RLGL.ExtSupported.maxDepthBits : 16 - ); - } + RL_TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Depth renderbuffer loaded successfully (%i bits)", id, (RLGL_GLOBAL_DATA.ExtSupported.maxDepthBits >= 24)? RLGL_GLOBAL_DATA.ExtSupported.maxDepthBits : 16); + } #endif - return id; + return id; } // Load texture cubemap // NOTE: Cubemap data is expected to be 6 images in a single data array (one after the other), // expected the following convention: +X, -X, +Y, -Y, +Z, -Z -unsigned int rlLoadTextureCubemap( const void* data, int size, int format ) +unsigned int RLGL_LoadTextureCubemap(const void *data, int size, int format) { - unsigned int id = 0; + unsigned int id = 0; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - unsigned int dataSize = rlGetPixelDataSize( size, size, format ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int dataSize = RLGL_GetPixelDataSize(size, size, format); - glGenTextures( 1, &id ); - glBindTexture( GL_TEXTURE_CUBE_MAP, id ); + glGenTextures(1, &id); + glBindTexture(GL_TEXTURE_CUBE_MAP, id); - unsigned int glInternalFormat, glFormat, glType; - rlGetGlTextureFormats( format, &glInternalFormat, &glFormat, &glType ); + unsigned int glInternalFormat, glFormat, glType; + RLGL_GetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); - if ( glInternalFormat != 0 ) - { - // Load cubemap faces - for ( unsigned int i = 0; i < 6; i++ ) - { - if ( data == NULL ) - { - if ( format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB ) - { - if ( ( format == RL_PIXELFORMAT_UNCOMPRESSED_R32 ) || ( format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 ) - || ( format == RL_PIXELFORMAT_UNCOMPRESSED_R16 ) || ( format == RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 ) ) - TRACELOG( RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported" ); - else - glTexImage2D( GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, NULL ); - } - else - TRACELOG( RL_LOG_WARNING, "TEXTURES: Empty cubemap creation does not support compressed format" ); - } - else - { - if ( format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB ) - glTexImage2D( - GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, - 0, - glInternalFormat, - size, - size, - 0, - glFormat, - glType, - ( unsigned char* )data + i * dataSize - ); - else - glCompressedTexImage2D( - GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, - 0, - glInternalFormat, - size, - size, - 0, - dataSize, - ( unsigned char* )data + i * dataSize - ); - } + if (glInternalFormat != 0) + { + // Load cubemap faces + for (unsigned int i = 0; i < 6; i++) + { + if (data == NULL) + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) + { + if ((format == RL_PIXELFORMAT_UNCOMPRESSED_R32) || (format == RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32) + || (format == RL_PIXELFORMAT_UNCOMPRESSED_R16) || (format == RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16)) + RL_TRACELOG(RL_LOG_WARNING, "TEXTURES: Cubemap requested format not supported"); + else glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, NULL); + } + else RL_TRACELOG(RL_LOG_WARNING, "TEXTURES: Empty cubemap creation does not support compressed format"); + } + else + { + if (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, glFormat, glType, (unsigned char *)data + i*dataSize); + else glCompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glInternalFormat, size, size, 0, dataSize, (unsigned char *)data + i*dataSize); + } -#if defined( GRAPHICS_API_OPENGL_33 ) - if ( format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE ) - { - GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; - glTexParameteriv( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask ); - } - else if ( format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA ) - { -#if defined( GRAPHICS_API_OPENGL_21 ) - GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA }; -#elif defined( GRAPHICS_API_OPENGL_33 ) - GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN }; +#if defined(GRAPHICS_API_OPENGL_33) + if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) + { + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ONE }; + glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } + else if (format == RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) + { +#if defined(GRAPHICS_API_OPENGL_21) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_ALPHA }; +#elif defined(GRAPHICS_API_OPENGL_33) + GLint swizzleMask[] = { GL_RED, GL_RED, GL_RED, GL_GREEN }; #endif - glTexParameteriv( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask ); - } + glTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_SWIZZLE_RGBA, swizzleMask); + } #endif - } - } + } + } - // Set cubemap texture sampling parameters - glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); - glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); - glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); - glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE ); -#if defined( GRAPHICS_API_OPENGL_33 ) - glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE ); // Flag not supported on OpenGL ES 2.0 + // Set cubemap texture sampling parameters + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); +#if defined(GRAPHICS_API_OPENGL_33) + glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); // Flag not supported on OpenGL ES 2.0 #endif - glBindTexture( GL_TEXTURE_CUBE_MAP, 0 ); + glBindTexture(GL_TEXTURE_CUBE_MAP, 0); #endif - if ( id > 0 ) - TRACELOG( RL_LOG_INFO, "TEXTURE: [ID %i] Cubemap texture loaded successfully (%ix%i)", id, size, size ); - else - TRACELOG( RL_LOG_WARNING, "TEXTURE: Failed to load cubemap texture" ); + if (id > 0) RL_TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Cubemap texture loaded successfully (%ix%i)", id, size, size); + else RL_TRACELOG(RL_LOG_WARNING, "TEXTURE: Failed to load cubemap texture"); - return id; + return id; } // Update already loaded texture in GPU with new data // NOTE: We don't know safely if internal texture format is the expected one... -void rlUpdateTexture( unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void* data ) +void RLGL_UpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data) { - glBindTexture( GL_TEXTURE_2D, id ); + glBindTexture(GL_TEXTURE_2D, id); - unsigned int glInternalFormat, glFormat, glType; - rlGetGlTextureFormats( format, &glInternalFormat, &glFormat, &glType ); + unsigned int glInternalFormat, glFormat, glType; + RLGL_GetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); - if ( ( glInternalFormat != 0 ) && ( format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB ) ) - { - glTexSubImage2D( GL_TEXTURE_2D, 0, offsetX, offsetY, width, height, glFormat, glType, data ); - } - else - TRACELOG( RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to update for current texture format (%i)", id, format ); + if ((glInternalFormat != 0) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)) + { + glTexSubImage2D(GL_TEXTURE_2D, 0, offsetX, offsetY, width, height, glFormat, glType, data); + } + else RL_TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to update for current texture format (%i)", id, format); } // Get OpenGL internal formats and data type from raylib PixelFormat -void rlGetGlTextureFormats( int format, unsigned int* glInternalFormat, unsigned int* glFormat, unsigned int* glType ) +void RLGL_GetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType) { - *glInternalFormat = 0; - *glFormat = 0; - *glType = 0; + *glInternalFormat = 0; + *glFormat = 0; + *glType = 0; - switch ( format ) - { -#if defined( GRAPHICS_API_OPENGL_11 ) || defined( GRAPHICS_API_OPENGL_21 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - // NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA - case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE : - *glInternalFormat = GL_LUMINANCE; - *glFormat = GL_LUMINANCE; - *glType = GL_UNSIGNED_BYTE; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA : - *glInternalFormat = GL_LUMINANCE_ALPHA; - *glFormat = GL_LUMINANCE_ALPHA; - *glType = GL_UNSIGNED_BYTE; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5 : - *glInternalFormat = GL_RGB; - *glFormat = GL_RGB; - *glType = GL_UNSIGNED_SHORT_5_6_5; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8 : - *glInternalFormat = GL_RGB; - *glFormat = GL_RGB; - *glType = GL_UNSIGNED_BYTE; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 : - *glInternalFormat = GL_RGBA; - *glFormat = GL_RGBA; - *glType = GL_UNSIGNED_SHORT_5_5_5_1; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 : - *glInternalFormat = GL_RGBA; - *glFormat = GL_RGBA; - *glType = GL_UNSIGNED_SHORT_4_4_4_4; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 : - *glInternalFormat = GL_RGBA; - *glFormat = GL_RGBA; - *glType = GL_UNSIGNED_BYTE; - break; -#if ! defined( GRAPHICS_API_OPENGL_11 ) -#if defined( GRAPHICS_API_OPENGL_ES3 ) - case RL_PIXELFORMAT_UNCOMPRESSED_R32 : - if ( RLGL.ExtSupported.texFloat32 ) - *glInternalFormat = GL_R32F_EXT; - *glFormat = GL_RED_EXT; - *glType = GL_FLOAT; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32 : - if ( RLGL.ExtSupported.texFloat32 ) - *glInternalFormat = GL_RGB32F_EXT; - *glFormat = GL_RGB; - *glType = GL_FLOAT; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 : - if ( RLGL.ExtSupported.texFloat32 ) - *glInternalFormat = GL_RGBA32F_EXT; - *glFormat = GL_RGBA; - *glType = GL_FLOAT; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R16 : - if ( RLGL.ExtSupported.texFloat16 ) - *glInternalFormat = GL_R16F_EXT; - *glFormat = GL_RED_EXT; - *glType = GL_HALF_FLOAT; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16 : - if ( RLGL.ExtSupported.texFloat16 ) - *glInternalFormat = GL_RGB16F_EXT; - *glFormat = GL_RGB; - *glType = GL_HALF_FLOAT; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 : - if ( RLGL.ExtSupported.texFloat16 ) - *glInternalFormat = GL_RGBA16F_EXT; - *glFormat = GL_RGBA; - *glType = GL_HALF_FLOAT; - break; -#else - case RL_PIXELFORMAT_UNCOMPRESSED_R32 : - if ( RLGL.ExtSupported.texFloat32 ) - *glInternalFormat = GL_LUMINANCE; - *glFormat = GL_LUMINANCE; - *glType = GL_FLOAT; - break; // NOTE: Requires extension OES_texture_float - case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32 : - if ( RLGL.ExtSupported.texFloat32 ) - *glInternalFormat = GL_RGB; - *glFormat = GL_RGB; - *glType = GL_FLOAT; - break; // NOTE: Requires extension OES_texture_float - case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 : - if ( RLGL.ExtSupported.texFloat32 ) - *glInternalFormat = GL_RGBA; - *glFormat = GL_RGBA; - *glType = GL_FLOAT; - break; // NOTE: Requires extension OES_texture_float -#if defined( GRAPHICS_API_OPENGL_21 ) - case RL_PIXELFORMAT_UNCOMPRESSED_R16 : - if ( RLGL.ExtSupported.texFloat16 ) - *glInternalFormat = GL_LUMINANCE; - *glFormat = GL_LUMINANCE; - *glType = GL_HALF_FLOAT_ARB; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16 : - if ( RLGL.ExtSupported.texFloat16 ) - *glInternalFormat = GL_RGB; - *glFormat = GL_RGB; - *glType = GL_HALF_FLOAT_ARB; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 : - if ( RLGL.ExtSupported.texFloat16 ) - *glInternalFormat = GL_RGBA; - *glFormat = GL_RGBA; - *glType = GL_HALF_FLOAT_ARB; - break; -#else // defined(GRAPHICS_API_OPENGL_ES2) - case RL_PIXELFORMAT_UNCOMPRESSED_R16 : - if ( RLGL.ExtSupported.texFloat16 ) - *glInternalFormat = GL_LUMINANCE; - *glFormat = GL_LUMINANCE; - *glType = GL_HALF_FLOAT_OES; - break; // NOTE: Requires extension OES_texture_half_float - case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16 : - if ( RLGL.ExtSupported.texFloat16 ) - *glInternalFormat = GL_RGB; - *glFormat = GL_RGB; - *glType = GL_HALF_FLOAT_OES; - break; // NOTE: Requires extension OES_texture_half_float - case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 : - if ( RLGL.ExtSupported.texFloat16 ) - *glInternalFormat = GL_RGBA; - *glFormat = GL_RGBA; - *glType = GL_HALF_FLOAT_OES; - break; // NOTE: Requires extension OES_texture_half_float -#endif -#endif -#endif -#elif defined( GRAPHICS_API_OPENGL_33 ) - case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE : - *glInternalFormat = GL_R8; - *glFormat = GL_RED; - *glType = GL_UNSIGNED_BYTE; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA : - *glInternalFormat = GL_RG8; - *glFormat = GL_RG; - *glType = GL_UNSIGNED_BYTE; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5 : - *glInternalFormat = GL_RGB565; - *glFormat = GL_RGB; - *glType = GL_UNSIGNED_SHORT_5_6_5; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8 : - *glInternalFormat = GL_RGB8; - *glFormat = GL_RGB; - *glType = GL_UNSIGNED_BYTE; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 : - *glInternalFormat = GL_RGB5_A1; - *glFormat = GL_RGBA; - *glType = GL_UNSIGNED_SHORT_5_5_5_1; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 : - *glInternalFormat = GL_RGBA4; - *glFormat = GL_RGBA; - *glType = GL_UNSIGNED_SHORT_4_4_4_4; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 : - *glInternalFormat = GL_RGBA8; - *glFormat = GL_RGBA; - *glType = GL_UNSIGNED_BYTE; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R32 : - if ( RLGL.ExtSupported.texFloat32 ) - *glInternalFormat = GL_R32F; - *glFormat = GL_RED; - *glType = GL_FLOAT; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32 : - if ( RLGL.ExtSupported.texFloat32 ) - *glInternalFormat = GL_RGB32F; - *glFormat = GL_RGB; - *glType = GL_FLOAT; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 : - if ( RLGL.ExtSupported.texFloat32 ) - *glInternalFormat = GL_RGBA32F; - *glFormat = GL_RGBA; - *glType = GL_FLOAT; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R16 : - if ( RLGL.ExtSupported.texFloat16 ) - *glInternalFormat = GL_R16F; - *glFormat = GL_RED; - *glType = GL_HALF_FLOAT; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16 : - if ( RLGL.ExtSupported.texFloat16 ) - *glInternalFormat = GL_RGB16F; - *glFormat = GL_RGB; - *glType = GL_HALF_FLOAT; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 : - if ( RLGL.ExtSupported.texFloat16 ) - *glInternalFormat = GL_RGBA16F; - *glFormat = GL_RGBA; - *glType = GL_HALF_FLOAT; - break; -#endif -#if ! defined( GRAPHICS_API_OPENGL_11 ) - case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB : - if ( RLGL.ExtSupported.texCompDXT ) - *glInternalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; - break; - case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA : - if ( RLGL.ExtSupported.texCompDXT ) - *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; - break; - case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA : - if ( RLGL.ExtSupported.texCompDXT ) - *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; - break; - case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA : - if ( RLGL.ExtSupported.texCompDXT ) - *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; - break; - case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB : - if ( RLGL.ExtSupported.texCompETC1 ) - *glInternalFormat = GL_ETC1_RGB8_OES; - break; // NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3 - case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB : - if ( RLGL.ExtSupported.texCompETC2 ) - *glInternalFormat = GL_COMPRESSED_RGB8_ETC2; - break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3 - case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA : - if ( RLGL.ExtSupported.texCompETC2 ) - *glInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC; - break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3 - case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB : - if ( RLGL.ExtSupported.texCompPVRT ) - *glInternalFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; - break; // NOTE: Requires PowerVR GPU - case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA : - if ( RLGL.ExtSupported.texCompPVRT ) - *glInternalFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; - break; // NOTE: Requires PowerVR GPU - case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA : - if ( RLGL.ExtSupported.texCompASTC ) - *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR; - break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3 - case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA : - if ( RLGL.ExtSupported.texCompASTC ) - *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR; - break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3 -#endif - default : - TRACELOG( RL_LOG_WARNING, "TEXTURE: Current format not supported (%i)", format ); - break; - } + switch (format) + { + #if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_21) || defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_LUMINANCE_ALPHA; *glFormat = GL_LUMINANCE_ALPHA; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break; + #if !defined(GRAPHICS_API_OPENGL_11) + #if defined(GRAPHICS_API_OPENGL_ES3) + case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat32) *glInternalFormat = GL_R32F_EXT; *glFormat = GL_RED_EXT; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat32) *glInternalFormat = GL_RGB32F_EXT; *glFormat = GL_RGB; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA32F_EXT; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat16) *glInternalFormat = GL_R16F_EXT; *glFormat = GL_RED_EXT; *glType = GL_HALF_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat16) *glInternalFormat = GL_RGB16F_EXT; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA16F_EXT; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT; break; + #else + case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat32) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat32) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; // NOTE: Requires extension OES_texture_float + #if defined(GRAPHICS_API_OPENGL_21) + case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat16) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_HALF_FLOAT_ARB; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat16) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT_ARB; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT_ARB; break; + #else // defined(GRAPHICS_API_OPENGL_ES2) + case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat16) *glInternalFormat = GL_LUMINANCE; *glFormat = GL_LUMINANCE; *glType = GL_HALF_FLOAT_OES; break; // NOTE: Requires extension OES_texture_half_float + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat16) *glInternalFormat = GL_RGB; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT_OES; break; // NOTE: Requires extension OES_texture_half_float + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT_OES; break; // NOTE: Requires extension OES_texture_half_float + #endif + #endif + #endif + #elif defined(GRAPHICS_API_OPENGL_33) + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: *glInternalFormat = GL_R8; *glFormat = GL_RED; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: *glInternalFormat = GL_RG8; *glFormat = GL_RG; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: *glInternalFormat = GL_RGB565; *glFormat = GL_RGB; *glType = GL_UNSIGNED_SHORT_5_6_5; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: *glInternalFormat = GL_RGB8; *glFormat = GL_RGB; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: *glInternalFormat = GL_RGB5_A1; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_5_5_5_1; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: *glInternalFormat = GL_RGBA4; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_SHORT_4_4_4_4; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: *glInternalFormat = GL_RGBA8; *glFormat = GL_RGBA; *glType = GL_UNSIGNED_BYTE; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat32) *glInternalFormat = GL_R32F; *glFormat = GL_RED; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat32) *glInternalFormat = GL_RGB32F; *glFormat = GL_RGB; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat32) *glInternalFormat = GL_RGBA32F; *glFormat = GL_RGBA; *glType = GL_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat16) *glInternalFormat = GL_R16F; *glFormat = GL_RED; *glType = GL_HALF_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat16) *glInternalFormat = GL_RGB16F; *glFormat = GL_RGB; *glType = GL_HALF_FLOAT; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: if (RLGL_GLOBAL_DATA.ExtSupported.texFloat16) *glInternalFormat = GL_RGBA16F; *glFormat = GL_RGBA; *glType = GL_HALF_FLOAT; break; + #endif + #if !defined(GRAPHICS_API_OPENGL_11) + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: if (RLGL_GLOBAL_DATA.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: if (RLGL_GLOBAL_DATA.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: if (RLGL_GLOBAL_DATA.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: if (RLGL_GLOBAL_DATA.ExtSupported.texCompDXT) *glInternalFormat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break; + case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: if (RLGL_GLOBAL_DATA.ExtSupported.texCompETC1) *glInternalFormat = GL_ETC1_RGB8_OES; break; // NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: if (RLGL_GLOBAL_DATA.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGB8_ETC2; break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: if (RLGL_GLOBAL_DATA.ExtSupported.texCompETC2) *glInternalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC; break; // NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: if (RLGL_GLOBAL_DATA.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: if (RLGL_GLOBAL_DATA.ExtSupported.texCompPVRT) *glInternalFormat = GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG; break; // NOTE: Requires PowerVR GPU + case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: if (RLGL_GLOBAL_DATA.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR; break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3 + case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: if (RLGL_GLOBAL_DATA.ExtSupported.texCompASTC) *glInternalFormat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR; break; // NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3 + #endif + default: RL_TRACELOG(RL_LOG_WARNING, "TEXTURE: Current format not supported (%i)", format); break; + } } // Unload texture from GPU memory -void rlUnloadTexture( unsigned int id ) +void RLGL_UnloadTexture(unsigned int id) { - glDeleteTextures( 1, &id ); + glDeleteTextures(1, &id); } // Generate mipmap data for selected texture // NOTE: Only supports GPU mipmap generation -void rlGenTextureMipmaps( unsigned int id, int width, int height, int format, int* mipmaps ) +void RLGL_GenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glBindTexture( GL_TEXTURE_2D, id ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindTexture(GL_TEXTURE_2D, id); - // Check if texture is power-of-two (POT) - bool texIsPOT = false; + // Check if texture is power-of-two (POT) + bool texIsPOT = false; - if ( ( ( width > 0 ) && ( ( width & ( width - 1 ) ) == 0 ) ) && ( ( height > 0 ) && ( ( height & ( height - 1 ) ) == 0 ) ) ) - texIsPOT = true; + if (((width > 0) && ((width & (width - 1)) == 0)) && + ((height > 0) && ((height & (height - 1)) == 0))) texIsPOT = true; - if ( ( texIsPOT ) || ( RLGL.ExtSupported.texNPOT ) ) - { - // glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE); // Hint for mipmaps generation algorithm: GL_FASTEST, GL_NICEST, GL_DONT_CARE - glGenerateMipmap( GL_TEXTURE_2D ); // Generate mipmaps automatically + if ((texIsPOT) || (RLGL_GLOBAL_DATA.ExtSupported.texNPOT)) + { + //glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE); // Hint for mipmaps generation algorithm: GL_FASTEST, GL_NICEST, GL_DONT_CARE + glGenerateMipmap(GL_TEXTURE_2D); // Generate mipmaps automatically -#define MIN( a, b ) ( ( ( a ) < ( b ) ) ? ( a ) : ( b ) ) -#define MAX( a, b ) ( ( ( a ) > ( b ) ) ? ( a ) : ( b ) ) + #define MIN(a,b) (((a)<(b))? (a):(b)) + #define MAX(a,b) (((a)>(b))? (a):(b)) - *mipmaps = 1 + ( int )floor( log( MAX( width, height ) ) / log( 2 ) ); - TRACELOG( RL_LOG_INFO, "TEXTURE: [ID %i] Mipmaps generated automatically, total: %i", id, *mipmaps ); - } - else - TRACELOG( RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to generate mipmaps", id ); + *mipmaps = 1 + (int)floor(log(MAX(width, height))/log(2)); + RL_TRACELOG(RL_LOG_INFO, "TEXTURE: [ID %i] Mipmaps generated automatically, total: %i", id, *mipmaps); + } + else RL_TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Failed to generate mipmaps", id); - glBindTexture( GL_TEXTURE_2D, 0 ); + glBindTexture(GL_TEXTURE_2D, 0); #else - TRACELOG( RL_LOG_WARNING, "TEXTURE: [ID %i] GPU mipmap generation not supported", id ); + RL_TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] GPU mipmap generation not supported", id); #endif } + // Read texture pixel data -void* rlReadTexturePixels( unsigned int id, int width, int height, int format ) +void *RLGL_ReadTexturePixels(unsigned int id, int width, int height, int format) { - void* pixels = NULL; + void *pixels = NULL; -#if defined( GRAPHICS_API_OPENGL_11 ) || defined( GRAPHICS_API_OPENGL_33 ) - glBindTexture( GL_TEXTURE_2D, id ); +#if defined(GRAPHICS_API_OPENGL_11) || defined(GRAPHICS_API_OPENGL_33) + glBindTexture(GL_TEXTURE_2D, id); - // NOTE: Using texture id, we can retrieve some texture info (but not on OpenGL ES 2.0) - // Possible texture info: GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE - // int width, height, format; - // glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width); - // glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height); - // glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format); + // NOTE: Using texture id, we can retrieve some texture info (but not on OpenGL ES 2.0) + // Possible texture info: GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE + //int width, height, format; + //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width); + //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height); + //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format); - // NOTE: Each row written to or read from by OpenGL pixel operations like glGetTexImage are aligned to a 4 byte boundary by default, which may add some - // padding. Use glPixelStorei to modify padding with the GL_[UN]PACK_ALIGNMENT setting. GL_PACK_ALIGNMENT affects operations that read from OpenGL memory - // (glReadPixels, glGetTexImage, etc.) GL_UNPACK_ALIGNMENT affects operations that write to OpenGL memory (glTexImage, etc.) - glPixelStorei( GL_PACK_ALIGNMENT, 1 ); + // NOTE: Each row written to or read from by OpenGL pixel operations like glGetTexImage are aligned to a 4 byte boundary by default, which may add some padding. + // Use glPixelStorei to modify padding with the GL_[UN]PACK_ALIGNMENT setting. + // GL_PACK_ALIGNMENT affects operations that read from OpenGL memory (glReadPixels, glGetTexImage, etc.) + // GL_UNPACK_ALIGNMENT affects operations that write to OpenGL memory (glTexImage, etc.) + glPixelStorei(GL_PACK_ALIGNMENT, 1); - unsigned int glInternalFormat, glFormat, glType; - rlGetGlTextureFormats( format, &glInternalFormat, &glFormat, &glType ); - unsigned int size = rlGetPixelDataSize( width, height, format ); + unsigned int glInternalFormat, glFormat, glType; + RLGL_GetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + unsigned int size = RLGL_GetPixelDataSize(width, height, format); - if ( ( glInternalFormat != 0 ) && ( format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB ) ) - { - pixels = RL_MALLOC( size ); - glGetTexImage( GL_TEXTURE_2D, 0, glFormat, glType, pixels ); - } - else - TRACELOG( RL_LOG_WARNING, "TEXTURE: [ID %i] Data retrieval not suported for pixel format (%i)", id, format ); + if ((glInternalFormat != 0) && (format < RL_PIXELFORMAT_COMPRESSED_DXT1_RGB)) + { + pixels = RL_MALLOC(size); + glGetTexImage(GL_TEXTURE_2D, 0, glFormat, glType, pixels); + } + else RL_TRACELOG(RL_LOG_WARNING, "TEXTURE: [ID %i] Data retrieval not suported for pixel format (%i)", id, format); - glBindTexture( GL_TEXTURE_2D, 0 ); + glBindTexture(GL_TEXTURE_2D, 0); #endif -#if defined( GRAPHICS_API_OPENGL_ES2 ) - // glGetTexImage() is not available on OpenGL ES 2.0 - // Texture width and height are required on OpenGL ES 2.0. There is no way to get it from texture id. - // Two possible Options: - // 1 - Bind texture to color fbo attachment and glReadPixels() - // 2 - Create an fbo, activate it, render quad with texture, glReadPixels() - // We are using Option 1, just need to care for texture format on retrieval - // NOTE: This behaviour could be conditioned by graphic driver... - unsigned int fboId = rlLoadFramebuffer( width, height ); +#if defined(GRAPHICS_API_OPENGL_ES2) + // glGetTexImage() is not available on OpenGL ES 2.0 + // Texture width and height are required on OpenGL ES 2.0. There is no way to get it from texture id. + // Two possible Options: + // 1 - Bind texture to color fbo attachment and glReadPixels() + // 2 - Create an fbo, activate it, render quad with texture, glReadPixels() + // We are using Option 1, just need to care for texture format on retrieval + // NOTE: This behaviour could be conditioned by graphic driver... + unsigned int fboId = RLGL_LoadFramebuffer(width, height); - glBindFramebuffer( GL_FRAMEBUFFER, fboId ); - glBindTexture( GL_TEXTURE_2D, 0 ); + glBindFramebuffer(GL_FRAMEBUFFER, fboId); + glBindTexture(GL_TEXTURE_2D, 0); - // Attach our texture to FBO - glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id, 0 ); + // Attach our texture to FBO + glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, id, 0); - // We read data as RGBA because FBO texture is configured as RGBA, despite binding another texture format - pixels = ( unsigned char* )RL_MALLOC( rlGetPixelDataSize( width, height, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 ) ); - glReadPixels( 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels ); + // We read data as RGBA because FBO texture is configured as RGBA, despite binding another texture format + pixels = (unsigned char *)RL_MALLOC(RLGL_GetPixelDataSize(width, height, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)); + glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels); - glBindFramebuffer( GL_FRAMEBUFFER, 0 ); + glBindFramebuffer(GL_FRAMEBUFFER, 0); - // Clean up temporal fbo - rlUnloadFramebuffer( fboId ); + // Clean up temporal fbo + RLGL_UnloadFramebuffer(fboId); #endif - return pixels; + return pixels; } // Read screen pixel data (color buffer) -unsigned char* rlReadScreenPixels( int width, int height ) +unsigned char *RLGL_ReadScreenPixels(int width, int height) { - unsigned char* screenData = ( unsigned char* )RL_CALLOC( width * height * 4, sizeof( unsigned char ) ); + unsigned char *screenData = (unsigned char *)RL_CALLOC(width*height*4, sizeof(unsigned char)); - // NOTE 1: glReadPixels returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer - // NOTE 2: We are getting alpha channel! Be careful, it can be transparent if not cleared properly! - glReadPixels( 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, screenData ); + // NOTE 1: glReadPixels returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer + // NOTE 2: We are getting alpha channel! Be careful, it can be transparent if not cleared properly! + glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, screenData); - // Flip image vertically! - unsigned char* imgData = ( unsigned char* )RL_MALLOC( width * height * 4 * sizeof( unsigned char ) ); + // Flip image vertically! + unsigned char *imgData = (unsigned char *)RL_MALLOC(width*height*4*sizeof(unsigned char)); - for ( int y = height - 1; y >= 0; y-- ) - { - for ( int x = 0; x < ( width * 4 ); x++ ) - { - imgData[ ( ( height - 1 ) - y ) * width * 4 + x ] = screenData[ ( y * width * 4 ) + x ]; // Flip line + for (int y = height - 1; y >= 0; y--) + { + for (int x = 0; x < (width*4); x++) + { + imgData[((height - 1) - y)*width*4 + x] = screenData[(y*width*4) + x]; // Flip line - // Set alpha component value to 255 (no trasparent image retrieval) - // NOTE: Alpha value has already been applied to RGB in framebuffer, we don't need it! - if ( ( ( x + 1 ) % 4 ) == 0 ) - imgData[ ( ( height - 1 ) - y ) * width * 4 + x ] = 255; - } - } + // Set alpha component value to 255 (no trasparent image retrieval) + // NOTE: Alpha value has already been applied to RGB in framebuffer, we don't need it! + if (((x + 1)%4) == 0) imgData[((height - 1) - y)*width*4 + x] = 255; + } + } - RL_FREE( screenData ); + RL_FREE(screenData); - return imgData; // NOTE: image data should be freed + return imgData; // NOTE: image data should be freed } // Framebuffer management (fbo) //----------------------------------------------------------------------------------------- // Load a framebuffer to be used for rendering // NOTE: No textures attached -unsigned int rlLoadFramebuffer( int width, int height ) +unsigned int RLGL_LoadFramebuffer(int width, int height) { - unsigned int fboId = 0; + unsigned int fboId = 0; -#if ( defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) ) && defined( RLGL_RENDER_TEXTURES_HINT ) - glGenFramebuffers( 1, &fboId ); // Create the framebuffer object - glBindFramebuffer( GL_FRAMEBUFFER, 0 ); // Unbind any framebuffer +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glGenFramebuffers(1, &fboId); // Create the framebuffer object + glBindFramebuffer(GL_FRAMEBUFFER, 0); // Unbind any framebuffer #endif - return fboId; + return fboId; } // Attach color buffer texture to an fbo (unloads previous attachment) // NOTE: Attach type: 0-Color, 1-Depth renderbuffer, 2-Depth texture -void rlFramebufferAttach( unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel ) +void RLGL_FramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel) { -#if ( defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) ) && defined( RLGL_RENDER_TEXTURES_HINT ) - glBindFramebuffer( GL_FRAMEBUFFER, fboId ); +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, fboId); - switch ( attachType ) - { - case RL_ATTACHMENT_COLOR_CHANNEL0 : - case RL_ATTACHMENT_COLOR_CHANNEL1 : - case RL_ATTACHMENT_COLOR_CHANNEL2 : - case RL_ATTACHMENT_COLOR_CHANNEL3 : - case RL_ATTACHMENT_COLOR_CHANNEL4 : - case RL_ATTACHMENT_COLOR_CHANNEL5 : - case RL_ATTACHMENT_COLOR_CHANNEL6 : - case RL_ATTACHMENT_COLOR_CHANNEL7 : - { - if ( texType == RL_ATTACHMENT_TEXTURE2D ) - glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_2D, texId, mipLevel ); - else if ( texType == RL_ATTACHMENT_RENDERBUFFER ) - glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_RENDERBUFFER, texId ); - else if ( texType >= RL_ATTACHMENT_CUBEMAP_POSITIVE_X ) - glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_CUBE_MAP_POSITIVE_X + texType, texId, mipLevel ); - } - break; - case RL_ATTACHMENT_DEPTH : - { - if ( texType == RL_ATTACHMENT_TEXTURE2D ) - glFramebufferTexture2D( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel ); - else if ( texType == RL_ATTACHMENT_RENDERBUFFER ) - glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, texId ); - } - break; - case RL_ATTACHMENT_STENCIL : - { - if ( texType == RL_ATTACHMENT_TEXTURE2D ) - glFramebufferTexture2D( GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel ); - else if ( texType == RL_ATTACHMENT_RENDERBUFFER ) - glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, texId ); - } - break; - default : - break; - } + switch (attachType) + { + case RL_ATTACHMENT_COLOR_CHANNEL0: + case RL_ATTACHMENT_COLOR_CHANNEL1: + case RL_ATTACHMENT_COLOR_CHANNEL2: + case RL_ATTACHMENT_COLOR_CHANNEL3: + case RL_ATTACHMENT_COLOR_CHANNEL4: + case RL_ATTACHMENT_COLOR_CHANNEL5: + case RL_ATTACHMENT_COLOR_CHANNEL6: + case RL_ATTACHMENT_COLOR_CHANNEL7: + { + if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_2D, texId, mipLevel); + else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_RENDERBUFFER, texId); + else if (texType >= RL_ATTACHMENT_CUBEMAP_POSITIVE_X) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachType, GL_TEXTURE_CUBE_MAP_POSITIVE_X + texType, texId, mipLevel); - glBindFramebuffer( GL_FRAMEBUFFER, 0 ); + } break; + case RL_ATTACHMENT_DEPTH: + { + if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel); + else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, texId); + + } break; + case RL_ATTACHMENT_STENCIL: + { + if (texType == RL_ATTACHMENT_TEXTURE2D) glFramebufferTexture2D(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, texId, mipLevel); + else if (texType == RL_ATTACHMENT_RENDERBUFFER) glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, texId); + + } break; + default: break; + } + + glBindFramebuffer(GL_FRAMEBUFFER, 0); #endif } // Verify render texture is complete -bool rlFramebufferComplete( unsigned int id ) +bool RLGL_FramebufferComplete(unsigned int id) { - bool result = false; + bool result = false; -#if ( defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) ) && defined( RLGL_RENDER_TEXTURES_HINT ) - glBindFramebuffer( GL_FRAMEBUFFER, id ); +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + glBindFramebuffer(GL_FRAMEBUFFER, id); - GLenum status = glCheckFramebufferStatus( GL_FRAMEBUFFER ); + GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER); - if ( status != GL_FRAMEBUFFER_COMPLETE ) - { - switch ( status ) - { - case GL_FRAMEBUFFER_UNSUPPORTED : - TRACELOG( RL_LOG_WARNING, "FBO: [ID %i] Framebuffer is unsupported", id ); - break; - case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT : - TRACELOG( RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete attachment", id ); - break; -#if defined( GRAPHICS_API_OPENGL_ES2 ) - case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS : - TRACELOG( RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete dimensions", id ); - break; + if (status != GL_FRAMEBUFFER_COMPLETE) + { + switch (status) + { + case GL_FRAMEBUFFER_UNSUPPORTED: RL_TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer is unsupported", id); break; + case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT: RL_TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete attachment", id); break; +#if defined(GRAPHICS_API_OPENGL_ES2) + case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS: RL_TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has incomplete dimensions", id); break; #endif - case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT : - TRACELOG( RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has a missing attachment", id ); - break; - default : - break; - } - } + case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT: RL_TRACELOG(RL_LOG_WARNING, "FBO: [ID %i] Framebuffer has a missing attachment", id); break; + default: break; + } + } - glBindFramebuffer( GL_FRAMEBUFFER, 0 ); + glBindFramebuffer(GL_FRAMEBUFFER, 0); - result = ( status == GL_FRAMEBUFFER_COMPLETE ); + result = (status == GL_FRAMEBUFFER_COMPLETE); #endif - return result; + return result; } // Unload framebuffer from GPU memory // NOTE: All attached textures/cubemaps/renderbuffers are also deleted -void rlUnloadFramebuffer( unsigned int id ) +void RLGL_UnloadFramebuffer(unsigned int id) { -#if ( defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) ) && defined( RLGL_RENDER_TEXTURES_HINT ) - // Query depth attachment to automatically delete texture/renderbuffer - int depthType = 0, depthId = 0; - glBindFramebuffer( GL_FRAMEBUFFER, id ); // Bind framebuffer to query depth texture type - glGetFramebufferAttachmentParameteriv( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &depthType ); +#if (defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)) && defined(RLGL_RENDER_TEXTURES_HINT) + // Query depth attachment to automatically delete texture/renderbuffer + int depthType = 0, depthId = 0; + glBindFramebuffer(GL_FRAMEBUFFER, id); // Bind framebuffer to query depth texture type + glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &depthType); - // TODO: Review warning retrieving object name in WebGL - // WARNING: WebGL: INVALID_ENUM: getFramebufferAttachmentParameter: invalid parameter name - // https://registry.khronos.org/webgl/specs/latest/1.0/ - glGetFramebufferAttachmentParameteriv( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &depthId ); + // TODO: Review warning retrieving object name in WebGL + // WARNING: WebGL: INVALID_ENUM: getFramebufferAttachmentParameter: invalid parameter name + // https://registry.khronos.org/webgl/specs/latest/1.0/ + glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &depthId); - unsigned int depthIdU = ( unsigned int )depthId; - if ( depthType == GL_RENDERBUFFER ) - glDeleteRenderbuffers( 1, &depthIdU ); - else if ( depthType == GL_TEXTURE ) - glDeleteTextures( 1, &depthIdU ); + unsigned int depthIdU = (unsigned int)depthId; + if (depthType == GL_RENDERBUFFER) glDeleteRenderbuffers(1, &depthIdU); + else if (depthType == GL_TEXTURE) glDeleteTextures(1, &depthIdU); - // NOTE: If a texture object is deleted while its image is attached to the *currently bound* framebuffer, - // the texture image is automatically detached from the currently bound framebuffer. + // NOTE: If a texture object is deleted while its image is attached to the *currently bound* framebuffer, + // the texture image is automatically detached from the currently bound framebuffer. - glBindFramebuffer( GL_FRAMEBUFFER, 0 ); - glDeleteFramebuffers( 1, &id ); + glBindFramebuffer(GL_FRAMEBUFFER, 0); + glDeleteFramebuffers(1, &id); - TRACELOG( RL_LOG_INFO, "FBO: [ID %i] Unloaded framebuffer from VRAM (GPU)", id ); + RL_TRACELOG(RL_LOG_INFO, "FBO: [ID %i] Unloaded framebuffer from VRAM (GPU)", id); #endif } // Vertex data management //----------------------------------------------------------------------------------------- // Load a new attributes buffer -unsigned int rlLoadVertexBuffer( const void* buffer, int size, bool dynamic ) +unsigned int RLGL_LoadVertexBuffer(const void *buffer, int size, bool dynamic) { - unsigned int id = 0; + unsigned int id = 0; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glGenBuffers( 1, &id ); - glBindBuffer( GL_ARRAY_BUFFER, id ); - glBufferData( GL_ARRAY_BUFFER, size, buffer, dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glGenBuffers(1, &id); + glBindBuffer(GL_ARRAY_BUFFER, id); + glBufferData(GL_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); #endif - return id; + return id; } // Load a new attributes element buffer -unsigned int rlLoadVertexBufferElement( const void* buffer, int size, bool dynamic ) +unsigned int RLGL_LoadVertexBufferElement(const void *buffer, int size, bool dynamic) { - unsigned int id = 0; + unsigned int id = 0; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glGenBuffers( 1, &id ); - glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, id ); - glBufferData( GL_ELEMENT_ARRAY_BUFFER, size, buffer, dynamic ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glGenBuffers(1, &id); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, buffer, dynamic? GL_DYNAMIC_DRAW : GL_STATIC_DRAW); #endif - return id; + return id; } // Enable vertex buffer (VBO) -void rlEnableVertexBuffer( unsigned int id ) +void RLGL_EnableVertexBuffer(unsigned int id) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glBindBuffer( GL_ARRAY_BUFFER, id ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ARRAY_BUFFER, id); #endif } // Disable vertex buffer (VBO) -void rlDisableVertexBuffer( void ) +void RLGL_DisableVertexBuffer(void) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glBindBuffer( GL_ARRAY_BUFFER, 0 ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ARRAY_BUFFER, 0); #endif } // Enable vertex buffer element (VBO element) -void rlEnableVertexBufferElement( unsigned int id ) +void RLGL_EnableVertexBufferElement(unsigned int id) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, id ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); #endif } // Disable vertex buffer element (VBO element) -void rlDisableVertexBufferElement( void ) +void RLGL_DisableVertexBufferElement(void) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); #endif } // Update vertex buffer with new data // NOTE: dataSize and offset must be provided in bytes -void rlUpdateVertexBuffer( unsigned int id, const void* data, int dataSize, int offset ) +void RLGL_UpdateVertexBuffer(unsigned int id, const void *data, int dataSize, int offset) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glBindBuffer( GL_ARRAY_BUFFER, id ); - glBufferSubData( GL_ARRAY_BUFFER, offset, dataSize, data ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ARRAY_BUFFER, id); + glBufferSubData(GL_ARRAY_BUFFER, offset, dataSize, data); #endif } // Update vertex buffer elements with new data // NOTE: dataSize and offset must be provided in bytes -void rlUpdateVertexBufferElements( unsigned int id, const void* data, int dataSize, int offset ) +void RLGL_UpdateVertexBufferElements(unsigned int id, const void *data, int dataSize, int offset) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, id ); - glBufferSubData( GL_ELEMENT_ARRAY_BUFFER, offset, dataSize, data ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, id); + glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, dataSize, data); #endif } // Enable vertex array object (VAO) -bool rlEnableVertexArray( unsigned int vaoId ) +bool RLGL_EnableVertexArray(unsigned int vaoId) { - bool result = false; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - if ( RLGL.ExtSupported.vao ) - { - glBindVertexArray( vaoId ); - result = true; - } + bool result = false; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL_GLOBAL_DATA.ExtSupported.vao) + { + glBindVertexArray(vaoId); + result = true; + } #endif - return result; + return result; } // Disable vertex array object (VAO) -void rlDisableVertexArray( void ) +void RLGL_DisableVertexArray(void) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - if ( RLGL.ExtSupported.vao ) - glBindVertexArray( 0 ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL_GLOBAL_DATA.ExtSupported.vao) glBindVertexArray(0); #endif } // Enable vertex attribute index -void rlEnableVertexAttribute( unsigned int index ) +void RLGL_EnableVertexAttribute(unsigned int index) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glEnableVertexAttribArray( index ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glEnableVertexAttribArray(index); #endif } // Disable vertex attribute index -void rlDisableVertexAttribute( unsigned int index ) +void RLGL_DisableVertexAttribute(unsigned int index) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glDisableVertexAttribArray( index ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDisableVertexAttribArray(index); #endif } // Draw vertex array -void rlDrawVertexArray( int offset, int count ) +void RLGL_DrawVertexArray(int offset, int count) { - glDrawArrays( GL_TRIANGLES, offset, count ); + glDrawArrays(GL_TRIANGLES, offset, count); } // Draw vertex array elements -void rlDrawVertexArrayElements( int offset, int count, const void* buffer ) +void RLGL_DrawVertexArrayElements(int offset, int count, const void *buffer) { - // NOTE: Added pointer math separately from function to avoid UBSAN complaining - unsigned short* bufferPtr = ( unsigned short* )buffer; - if ( offset > 0 ) - bufferPtr += offset; + // NOTE: Added pointer math separately from function to avoid UBSAN complaining + unsigned short *bufferPtr = (unsigned short *)buffer; + if (offset > 0) bufferPtr += offset; - glDrawElements( GL_TRIANGLES, count, GL_UNSIGNED_SHORT, ( const unsigned short* )bufferPtr ); + glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)bufferPtr); } // Draw vertex array instanced -void rlDrawVertexArrayInstanced( int offset, int count, int instances ) +void RLGL_DrawVertexArrayInstanced(int offset, int count, int instances) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glDrawArraysInstanced( GL_TRIANGLES, 0, count, instances ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDrawArraysInstanced(GL_TRIANGLES, 0, count, instances); #endif } // Draw vertex array elements instanced -void rlDrawVertexArrayElementsInstanced( int offset, int count, const void* buffer, int instances ) +void RLGL_DrawVertexArrayElementsInstanced(int offset, int count, const void *buffer, int instances) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - // NOTE: Added pointer math separately from function to avoid UBSAN complaining - unsigned short* bufferPtr = ( unsigned short* )buffer; - if ( offset > 0 ) - bufferPtr += offset; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // NOTE: Added pointer math separately from function to avoid UBSAN complaining + unsigned short *bufferPtr = (unsigned short *)buffer; + if (offset > 0) bufferPtr += offset; - glDrawElementsInstanced( GL_TRIANGLES, count, GL_UNSIGNED_SHORT, ( const unsigned short* )bufferPtr, instances ); + glDrawElementsInstanced(GL_TRIANGLES, count, GL_UNSIGNED_SHORT, (const unsigned short *)bufferPtr, instances); #endif } -#if defined( GRAPHICS_API_OPENGL_11 ) +#if defined(GRAPHICS_API_OPENGL_11) // Enable vertex state pointer -void rlEnableStatePointer( int vertexAttribType, void* buffer ) +void RLGL_EnableStatePointer(int vertexAttribType, void *buffer) { - if ( buffer != NULL ) - glEnableClientState( vertexAttribType ); - switch ( vertexAttribType ) - { - case GL_VERTEX_ARRAY : - glVertexPointer( 3, GL_FLOAT, 0, buffer ); - break; - case GL_TEXTURE_COORD_ARRAY : - glTexCoordPointer( 2, GL_FLOAT, 0, buffer ); - break; - case GL_NORMAL_ARRAY : - if ( buffer != NULL ) - glNormalPointer( GL_FLOAT, 0, buffer ); - break; - case GL_COLOR_ARRAY : - if ( buffer != NULL ) - glColorPointer( 4, GL_UNSIGNED_BYTE, 0, buffer ); - break; - // case GL_INDEX_ARRAY: if (buffer != NULL) glIndexPointer(GL_SHORT, 0, buffer); break; // Indexed colors - default : - break; - } + if (buffer != NULL) glEnableClientState(vertexAttribType); + switch (vertexAttribType) + { + case GL_VERTEX_ARRAY: glVertexPointer(3, GL_FLOAT, 0, buffer); break; + case GL_TEXTURE_COORD_ARRAY: glTexCoordPointer(2, GL_FLOAT, 0, buffer); break; + case GL_NORMAL_ARRAY: if (buffer != NULL) glNormalPointer(GL_FLOAT, 0, buffer); break; + case GL_COLOR_ARRAY: if (buffer != NULL) glColorPointer(4, GL_UNSIGNED_BYTE, 0, buffer); break; + //case GL_INDEX_ARRAY: if (buffer != NULL) glIndexPointer(GL_SHORT, 0, buffer); break; // Indexed colors + default: break; + } } // Disable vertex state pointer -void rlDisableStatePointer( int vertexAttribType ) +void RLGL_DisableStatePointer(int vertexAttribType) { - glDisableClientState( vertexAttribType ); + glDisableClientState(vertexAttribType); } #endif // Load vertex array object (VAO) -unsigned int rlLoadVertexArray( void ) +unsigned int RLGL_LoadVertexArray(void) { - unsigned int vaoId = 0; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - if ( RLGL.ExtSupported.vao ) - { - glGenVertexArrays( 1, &vaoId ); - } + unsigned int vaoId = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL_GLOBAL_DATA.ExtSupported.vao) + { + glGenVertexArrays(1, &vaoId); + } #endif - return vaoId; + return vaoId; } // Set vertex attribute -void rlSetVertexAttribute( unsigned int index, int compSize, int type, bool normalized, int stride, const void* pointer ) +void RLGL_SetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, const void *pointer) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glVertexAttribPointer( index, compSize, type, normalized, stride, pointer ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glVertexAttribPointer(index, compSize, type, normalized, stride, pointer); #endif } // Set vertex attribute divisor -void rlSetVertexAttributeDivisor( unsigned int index, int divisor ) +void RLGL_SetVertexAttributeDivisor(unsigned int index, int divisor) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glVertexAttribDivisor( index, divisor ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glVertexAttribDivisor(index, divisor); #endif } // Unload vertex array object (VAO) -void rlUnloadVertexArray( unsigned int vaoId ) +void RLGL_UnloadVertexArray(unsigned int vaoId) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - if ( RLGL.ExtSupported.vao ) - { - glBindVertexArray( 0 ); - glDeleteVertexArrays( 1, &vaoId ); - TRACELOG( RL_LOG_INFO, "VAO: [ID %i] Unloaded vertex array data from VRAM (GPU)", vaoId ); - } +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL_GLOBAL_DATA.ExtSupported.vao) + { + glBindVertexArray(0); + glDeleteVertexArrays(1, &vaoId); + RL_TRACELOG(RL_LOG_INFO, "VAO: [ID %i] Unloaded vertex array data from VRAM (GPU)", vaoId); + } #endif } // Unload vertex buffer (VBO) -void rlUnloadVertexBuffer( unsigned int vboId ) +void RLGL_UnloadVertexBuffer(unsigned int vboId) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glDeleteBuffers( 1, &vboId ); - // TRACELOG(RL_LOG_INFO, "VBO: Unloaded vertex data from VRAM (GPU)"); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDeleteBuffers(1, &vboId); + //RL_TRACELOG(RL_LOG_INFO, "VBO: Unloaded vertex data from VRAM (GPU)"); #endif } @@ -4426,1254 +3830,1035 @@ void rlUnloadVertexBuffer( unsigned int vboId ) //----------------------------------------------------------------------------------------------- // Load shader from code strings // NOTE: If shader string is NULL, using default vertex/fragment shaders -unsigned int rlLoadShaderCode( const char* vsCode, const char* fsCode ) +unsigned int RLGL_LoadShaderCode(const char *vsCode, const char *fsCode) { - unsigned int id = 0; + unsigned int id = 0; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - unsigned int vertexShaderId = 0; - unsigned int fragmentShaderId = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int vertexShaderId = 0; + unsigned int fragmentShaderId = 0; - // Compile vertex shader (if provided) - if ( vsCode != NULL ) - vertexShaderId = rlCompileShader( vsCode, GL_VERTEX_SHADER ); - // In case no vertex shader was provided or compilation failed, we use default vertex shader - if ( vertexShaderId == 0 ) - vertexShaderId = RLGL.State.defaultVShaderId; + // Compile vertex shader (if provided) + if (vsCode != NULL) vertexShaderId = RLGL_CompileShader(vsCode, GL_VERTEX_SHADER); + // In case no vertex shader was provided or compilation failed, we use default vertex shader + if (vertexShaderId == 0) vertexShaderId = RLGL_GLOBAL_DATA.State.defaultVShaderId; - // Compile fragment shader (if provided) - if ( fsCode != NULL ) - fragmentShaderId = rlCompileShader( fsCode, GL_FRAGMENT_SHADER ); - // In case no fragment shader was provided or compilation failed, we use default fragment shader - if ( fragmentShaderId == 0 ) - fragmentShaderId = RLGL.State.defaultFShaderId; + // Compile fragment shader (if provided) + if (fsCode != NULL) fragmentShaderId = RLGL_CompileShader(fsCode, GL_FRAGMENT_SHADER); + // In case no fragment shader was provided or compilation failed, we use default fragment shader + if (fragmentShaderId == 0) fragmentShaderId = RLGL_GLOBAL_DATA.State.defaultFShaderId; - // In case vertex and fragment shader are the default ones, no need to recompile, we can just assign the default shader program id - if ( ( vertexShaderId == RLGL.State.defaultVShaderId ) && ( fragmentShaderId == RLGL.State.defaultFShaderId ) ) - id = RLGL.State.defaultShaderId; - else - { - // One of or both shader are new, we need to compile a new shader program - id = rlLoadShaderProgram( vertexShaderId, fragmentShaderId ); + // In case vertex and fragment shader are the default ones, no need to recompile, we can just assign the default shader program id + if ((vertexShaderId == RLGL_GLOBAL_DATA.State.defaultVShaderId) && (fragmentShaderId == RLGL_GLOBAL_DATA.State.defaultFShaderId)) id = RLGL_GLOBAL_DATA.State.defaultShaderId; + else + { + // One of or both shader are new, we need to compile a new shader program + id = RLGL_LoadShaderProgram(vertexShaderId, fragmentShaderId); - // We can detach and delete vertex/fragment shaders (if not default ones) - // NOTE: We detach shader before deletion to make sure memory is freed - if ( vertexShaderId != RLGL.State.defaultVShaderId ) - { - // WARNING: Shader program linkage could fail and returned id is 0 - if ( id > 0 ) - glDetachShader( id, vertexShaderId ); - glDeleteShader( vertexShaderId ); - } - if ( fragmentShaderId != RLGL.State.defaultFShaderId ) - { - // WARNING: Shader program linkage could fail and returned id is 0 - if ( id > 0 ) - glDetachShader( id, fragmentShaderId ); - glDeleteShader( fragmentShaderId ); - } + // We can detach and delete vertex/fragment shaders (if not default ones) + // NOTE: We detach shader before deletion to make sure memory is freed + if (vertexShaderId != RLGL_GLOBAL_DATA.State.defaultVShaderId) + { + // WARNING: Shader program linkage could fail and returned id is 0 + if (id > 0) glDetachShader(id, vertexShaderId); + glDeleteShader(vertexShaderId); + } + if (fragmentShaderId != RLGL_GLOBAL_DATA.State.defaultFShaderId) + { + // WARNING: Shader program linkage could fail and returned id is 0 + if (id > 0) glDetachShader(id, fragmentShaderId); + glDeleteShader(fragmentShaderId); + } - // In case shader program loading failed, we assign default shader - if ( id == 0 ) - { - // In case shader loading fails, we return the default shader - TRACELOG( RL_LOG_WARNING, "SHADER: Failed to load custom shader code, using default shader" ); - id = RLGL.State.defaultShaderId; - } - /* - else - { - // Get available shader uniforms - // NOTE: This information is useful for debug... - int uniformCount = -1; - glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &uniformCount); + // In case shader program loading failed, we assign default shader + if (id == 0) + { + // In case shader loading fails, we return the default shader + RL_TRACELOG(RL_LOG_WARNING, "SHADER: Failed to load custom shader code, using default shader"); + id = RLGL_GLOBAL_DATA.State.defaultShaderId; + } + /* + else + { + // Get available shader uniforms + // NOTE: This information is useful for debug... + int uniformCount = -1; + glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &uniformCount); - for (int i = 0; i < uniformCount; i++) - { - int namelen = -1; - int num = -1; - char name[256] = { 0 }; // Assume no variable names longer than 256 - GLenum type = GL_ZERO; + for (int i = 0; i < uniformCount; i++) + { + int namelen = -1; + int num = -1; + char name[256] = { 0 }; // Assume no variable names longer than 256 + GLenum type = GL_ZERO; - // Get the name of the uniforms - glGetActiveUniform(id, i, sizeof(name) - 1, &namelen, &num, &type, name); + // Get the name of the uniforms + glGetActiveUniform(id, i, sizeof(name) - 1, &namelen, &num, &type, name); - name[namelen] = 0; - TRACELOGD("SHADER: [ID %i] Active uniform (%s) set at location: %i", id, name, glGetUniformLocation(id, name)); - } - } - */ - } + name[namelen] = 0; + TRACELOGD("SHADER: [ID %i] Active uniform (%s) set at location: %i", id, name, glGetUniformLocation(id, name)); + } + } + */ + } #endif - return id; + return id; } // Compile custom shader and return shader id -unsigned int rlCompileShader( const char* shaderCode, int type ) +unsigned int RLGL_CompileShader(const char *shaderCode, int type) { - unsigned int shader = 0; + unsigned int shader = 0; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - shader = glCreateShader( type ); - glShaderSource( shader, 1, &shaderCode, NULL ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + shader = glCreateShader(type); + glShaderSource(shader, 1, &shaderCode, NULL); - GLint success = 0; - glCompileShader( shader ); - glGetShaderiv( shader, GL_COMPILE_STATUS, &success ); + GLint success = 0; + glCompileShader(shader); + glGetShaderiv(shader, GL_COMPILE_STATUS, &success); - if ( success == GL_FALSE ) - { - switch ( type ) - { - case GL_VERTEX_SHADER : - TRACELOG( RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile vertex shader code", shader ); - break; - case GL_FRAGMENT_SHADER : - TRACELOG( RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile fragment shader code", shader ); - break; - // case GL_GEOMETRY_SHADER: -#if defined( GRAPHICS_API_OPENGL_43 ) - case GL_COMPUTE_SHADER : - TRACELOG( RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile compute shader code", shader ); - break; -#endif - default : - break; - } + if (success == GL_FALSE) + { + switch (type) + { + case GL_VERTEX_SHADER: RL_TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile vertex shader code", shader); break; + case GL_FRAGMENT_SHADER: RL_TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile fragment shader code", shader); break; + //case GL_GEOMETRY_SHADER: + #if defined(GRAPHICS_API_OPENGL_43) + case GL_COMPUTE_SHADER: RL_TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to compile compute shader code", shader); break; + #endif + default: break; + } - int maxLength = 0; - glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &maxLength ); + int maxLength = 0; + glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength); - if ( maxLength > 0 ) - { - int length = 0; - char* log = ( char* )RL_CALLOC( maxLength, sizeof( char ) ); - glGetShaderInfoLog( shader, maxLength, &length, log ); - TRACELOG( RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shader, log ); - RL_FREE( log ); - } - } - else - { - switch ( type ) - { - case GL_VERTEX_SHADER : - TRACELOG( RL_LOG_INFO, "SHADER: [ID %i] Vertex shader compiled successfully", shader ); - break; - case GL_FRAGMENT_SHADER : - TRACELOG( RL_LOG_INFO, "SHADER: [ID %i] Fragment shader compiled successfully", shader ); - break; - // case GL_GEOMETRY_SHADER: -#if defined( GRAPHICS_API_OPENGL_43 ) - case GL_COMPUTE_SHADER : - TRACELOG( RL_LOG_INFO, "SHADER: [ID %i] Compute shader compiled successfully", shader ); - break; -#endif - default : - break; - } - } + if (maxLength > 0) + { + int length = 0; + char *log = (char *)RL_CALLOC(maxLength, sizeof(char)); + glGetShaderInfoLog(shader, maxLength, &length, log); + RL_TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Compile error: %s", shader, log); + RL_FREE(log); + } + } + else + { + switch (type) + { + case GL_VERTEX_SHADER: RL_TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Vertex shader compiled successfully", shader); break; + case GL_FRAGMENT_SHADER: RL_TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Fragment shader compiled successfully", shader); break; + //case GL_GEOMETRY_SHADER: + #if defined(GRAPHICS_API_OPENGL_43) + case GL_COMPUTE_SHADER: RL_TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader compiled successfully", shader); break; + #endif + default: break; + } + } #endif - return shader; + return shader; } // Load custom shader strings and return program id -unsigned int rlLoadShaderProgram( unsigned int vShaderId, unsigned int fShaderId ) +unsigned int RLGL_LoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId) { - unsigned int program = 0; + unsigned int program = 0; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - GLint success = 0; - program = glCreateProgram(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + GLint success = 0; + program = glCreateProgram(); - glAttachShader( program, vShaderId ); - glAttachShader( program, fShaderId ); + glAttachShader(program, vShaderId); + glAttachShader(program, fShaderId); - // NOTE: Default attribute shader locations must be Bound before linking - glBindAttribLocation( program, 0, RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION ); - glBindAttribLocation( program, 1, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD ); - glBindAttribLocation( program, 2, RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL ); - glBindAttribLocation( program, 3, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR ); - glBindAttribLocation( program, 4, RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT ); - glBindAttribLocation( program, 5, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 ); + // NOTE: Default attribute shader locations must be Bound before linking + glBindAttribLocation(program, 0, RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION); + glBindAttribLocation(program, 1, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD); + glBindAttribLocation(program, 2, RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL); + glBindAttribLocation(program, 3, RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR); + glBindAttribLocation(program, 4, RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT); + glBindAttribLocation(program, 5, RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2); - // NOTE: If some attrib name is no found on the shader, it locations becomes -1 + // NOTE: If some attrib name is no found on the shader, it locations becomes -1 - glLinkProgram( program ); + glLinkProgram(program); - // NOTE: All uniform variables are intitialised to 0 when a program links + // NOTE: All uniform variables are intitialised to 0 when a program links - glGetProgramiv( program, GL_LINK_STATUS, &success ); + glGetProgramiv(program, GL_LINK_STATUS, &success); - if ( success == GL_FALSE ) - { - TRACELOG( RL_LOG_WARNING, "SHADER: [ID %i] Failed to link shader program", program ); + if (success == GL_FALSE) + { + RL_TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link shader program", program); - int maxLength = 0; - glGetProgramiv( program, GL_INFO_LOG_LENGTH, &maxLength ); + int maxLength = 0; + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength); - if ( maxLength > 0 ) - { - int length = 0; - char* log = ( char* )RL_CALLOC( maxLength, sizeof( char ) ); - glGetProgramInfoLog( program, maxLength, &length, log ); - TRACELOG( RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log ); - RL_FREE( log ); - } + if (maxLength > 0) + { + int length = 0; + char *log = (char *)RL_CALLOC(maxLength, sizeof(char)); + glGetProgramInfoLog(program, maxLength, &length, log); + RL_TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log); + RL_FREE(log); + } - glDeleteProgram( program ); + glDeleteProgram(program); - program = 0; - } - else - { - // Get the size of compiled shader program (not available on OpenGL ES 2.0) - // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero. - // GLint binarySize = 0; - // glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize); + program = 0; + } + else + { + // Get the size of compiled shader program (not available on OpenGL ES 2.0) + // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero. + //GLint binarySize = 0; + //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize); - TRACELOG( RL_LOG_INFO, "SHADER: [ID %i] Program shader loaded successfully", program ); - } + RL_TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Program shader loaded successfully", program); + } #endif - return program; + return program; } // Unload shader program -void rlUnloadShaderProgram( unsigned int id ) +void RLGL_UnloadShaderProgram(unsigned int id) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - glDeleteProgram( id ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + glDeleteProgram(id); - TRACELOG( RL_LOG_INFO, "SHADER: [ID %i] Unloaded shader program data from VRAM (GPU)", id ); + RL_TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Unloaded shader program data from VRAM (GPU)", id); #endif } // Get shader location uniform -int rlGetLocationUniform( unsigned int shaderId, const char* uniformName ) +int RLGL_GetLocationUniform(unsigned int shaderId, const char *uniformName) { - int location = -1; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - location = glGetUniformLocation( shaderId, uniformName ); + int location = -1; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + location = glGetUniformLocation(shaderId, uniformName); - // if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader uniform: %s", shaderId, uniformName); - // else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader uniform (%s) set at location: %i", shaderId, uniformName, location); + //if (location == -1) RL_TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader uniform: %s", shaderId, uniformName); + //else RL_TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader uniform (%s) set at location: %i", shaderId, uniformName, location); #endif - return location; + return location; } // Get shader location attribute -int rlGetLocationAttrib( unsigned int shaderId, const char* attribName ) +int RLGL_GetLocationAttrib(unsigned int shaderId, const char *attribName) { - int location = -1; -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - location = glGetAttribLocation( shaderId, attribName ); + int location = -1; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + location = glGetAttribLocation(shaderId, attribName); - // if (location == -1) TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader attribute: %s", shaderId, attribName); - // else TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader attribute (%s) set at location: %i", shaderId, attribName, location); + //if (location == -1) RL_TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to find shader attribute: %s", shaderId, attribName); + //else RL_TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Shader attribute (%s) set at location: %i", shaderId, attribName, location); #endif - return location; + return location; } // Set shader value uniform -void rlSetUniform( int locIndex, const void* value, int uniformType, int count ) +void RLGL_SetUniform(int locIndex, const void *value, int uniformType, int count) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - switch ( uniformType ) - { - case RL_SHADER_UNIFORM_FLOAT : - glUniform1fv( locIndex, count, ( float* )value ); - break; - case RL_SHADER_UNIFORM_VEC2 : - glUniform2fv( locIndex, count, ( float* )value ); - break; - case RL_SHADER_UNIFORM_VEC3 : - glUniform3fv( locIndex, count, ( float* )value ); - break; - case RL_SHADER_UNIFORM_VEC4 : - glUniform4fv( locIndex, count, ( float* )value ); - break; - case RL_SHADER_UNIFORM_INT : - glUniform1iv( locIndex, count, ( int* )value ); - break; - case RL_SHADER_UNIFORM_IVEC2 : - glUniform2iv( locIndex, count, ( int* )value ); - break; - case RL_SHADER_UNIFORM_IVEC3 : - glUniform3iv( locIndex, count, ( int* )value ); - break; - case RL_SHADER_UNIFORM_IVEC4 : - glUniform4iv( locIndex, count, ( int* )value ); - break; - case RL_SHADER_UNIFORM_SAMPLER2D : - glUniform1iv( locIndex, count, ( int* )value ); - break; - default : - TRACELOG( RL_LOG_WARNING, "SHADER: Failed to set uniform value, data type not recognized" ); - } +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + switch (uniformType) + { + case RL_SHADER_UNIFORM_FLOAT: glUniform1fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_VEC2: glUniform2fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_VEC3: glUniform3fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_VEC4: glUniform4fv(locIndex, count, (float *)value); break; + case RL_SHADER_UNIFORM_INT: glUniform1iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_IVEC2: glUniform2iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_IVEC3: glUniform3iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_IVEC4: glUniform4iv(locIndex, count, (int *)value); break; + case RL_SHADER_UNIFORM_SAMPLER2D: glUniform1iv(locIndex, count, (int *)value); break; + default: RL_TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set uniform value, data type not recognized"); + } #endif } // Set shader value attribute -void rlSetVertexAttributeDefault( int locIndex, const void* value, int attribType, int count ) +void RLGL_SetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - switch ( attribType ) - { - case RL_SHADER_ATTRIB_FLOAT : - if ( count == 1 ) - glVertexAttrib1fv( locIndex, ( float* )value ); - break; - case RL_SHADER_ATTRIB_VEC2 : - if ( count == 2 ) - glVertexAttrib2fv( locIndex, ( float* )value ); - break; - case RL_SHADER_ATTRIB_VEC3 : - if ( count == 3 ) - glVertexAttrib3fv( locIndex, ( float* )value ); - break; - case RL_SHADER_ATTRIB_VEC4 : - if ( count == 4 ) - glVertexAttrib4fv( locIndex, ( float* )value ); - break; - default : - TRACELOG( RL_LOG_WARNING, "SHADER: Failed to set attrib default value, data type not recognized" ); - } +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + switch (attribType) + { + case RL_SHADER_ATTRIB_FLOAT: if (count == 1) glVertexAttrib1fv(locIndex, (float *)value); break; + case RL_SHADER_ATTRIB_VEC2: if (count == 2) glVertexAttrib2fv(locIndex, (float *)value); break; + case RL_SHADER_ATTRIB_VEC3: if (count == 3) glVertexAttrib3fv(locIndex, (float *)value); break; + case RL_SHADER_ATTRIB_VEC4: if (count == 4) glVertexAttrib4fv(locIndex, (float *)value); break; + default: RL_TRACELOG(RL_LOG_WARNING, "SHADER: Failed to set attrib default value, data type not recognized"); + } #endif } // Set shader value uniform matrix -void rlSetUniformMatrix( int locIndex, Matrix mat ) +void RLGL_SetUniformMatrix(int locIndex, RL_Matrix mat) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - float matfloat[ 16 ] = { mat.m0, mat.m1, mat.m2, mat.m3, mat.m4, mat.m5, mat.m6, mat.m7, - mat.m8, mat.m9, mat.m10, mat.m11, mat.m12, mat.m13, mat.m14, mat.m15 }; - glUniformMatrix4fv( locIndex, 1, false, matfloat ); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + float matfloat[16] = { + mat.m0, mat.m1, mat.m2, mat.m3, + mat.m4, mat.m5, mat.m6, mat.m7, + mat.m8, mat.m9, mat.m10, mat.m11, + mat.m12, mat.m13, mat.m14, mat.m15 + }; + glUniformMatrix4fv(locIndex, 1, false, matfloat); #endif } // Set shader value uniform sampler -void rlSetUniformSampler( int locIndex, unsigned int textureId ) +void RLGL_SetUniformSampler(int locIndex, unsigned int textureId) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - // Check if texture is already active - for ( int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++ ) - if ( RLGL.State.activeTextureId[ i ] == textureId ) - return; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // Check if texture is already active + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) if (RLGL_GLOBAL_DATA.State.activeTextureId[i] == textureId) return; - // Register a new active texture for the internal batch system - // NOTE: Default texture is always activated as GL_TEXTURE0 - for ( int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++ ) - { - if ( RLGL.State.activeTextureId[ i ] == 0 ) - { - glUniform1i( locIndex, 1 + i ); // Activate new texture unit - RLGL.State.activeTextureId[ i ] = textureId; // Save texture id for binding on drawing - break; - } - } + // Register a new active texture for the internal batch system + // NOTE: Default texture is always activated as GL_TEXTURE0 + for (int i = 0; i < RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS; i++) + { + if (RLGL_GLOBAL_DATA.State.activeTextureId[i] == 0) + { + glUniform1i(locIndex, 1 + i); // Activate new texture unit + RLGL_GLOBAL_DATA.State.activeTextureId[i] = textureId; // Save texture id for binding on drawing + break; + } + } #endif } // Set shader currently active (id and locations) -void rlSetShader( unsigned int id, int* locs ) +void RLGL_SetShader(unsigned int id, int *locs) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - if ( RLGL.State.currentShaderId != id ) - { - rlDrawRenderBatch( RLGL.currentBatch ); - RLGL.State.currentShaderId = id; - RLGL.State.currentShaderLocs = locs; - } +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + if (RLGL_GLOBAL_DATA.State.currentShaderId != id) + { + RLGL_DrawRenderBatch(RLGL_GLOBAL_DATA.currentBatch); + RLGL_GLOBAL_DATA.State.currentShaderId = id; + RLGL_GLOBAL_DATA.State.currentShaderLocs = locs; + } #endif } // Load compute shader program -unsigned int rlLoadComputeShaderProgram( unsigned int shaderId ) +unsigned int RLGL_LoadComputeShaderProgram(unsigned int shaderId) { - unsigned int program = 0; + unsigned int program = 0; -#if defined( GRAPHICS_API_OPENGL_43 ) - GLint success = 0; - program = glCreateProgram(); - glAttachShader( program, shaderId ); - glLinkProgram( program ); +#if defined(GRAPHICS_API_OPENGL_43) + GLint success = 0; + program = glCreateProgram(); + glAttachShader(program, shaderId); + glLinkProgram(program); - // NOTE: All uniform variables are intitialised to 0 when a program links + // NOTE: All uniform variables are intitialised to 0 when a program links - glGetProgramiv( program, GL_LINK_STATUS, &success ); + glGetProgramiv(program, GL_LINK_STATUS, &success); - if ( success == GL_FALSE ) - { - TRACELOG( RL_LOG_WARNING, "SHADER: [ID %i] Failed to link compute shader program", program ); + if (success == GL_FALSE) + { + RL_TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to link compute shader program", program); - int maxLength = 0; - glGetProgramiv( program, GL_INFO_LOG_LENGTH, &maxLength ); + int maxLength = 0; + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength); - if ( maxLength > 0 ) - { - int length = 0; - char* log = ( char* )RL_CALLOC( maxLength, sizeof( char ) ); - glGetProgramInfoLog( program, maxLength, &length, log ); - TRACELOG( RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log ); - RL_FREE( log ); - } + if (maxLength > 0) + { + int length = 0; + char *log = (char *)RL_CALLOC(maxLength, sizeof(char)); + glGetProgramInfoLog(program, maxLength, &length, log); + RL_TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Link error: %s", program, log); + RL_FREE(log); + } - glDeleteProgram( program ); + glDeleteProgram(program); - program = 0; - } - else - { - // Get the size of compiled shader program (not available on OpenGL ES 2.0) - // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero. - // GLint binarySize = 0; - // glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize); + program = 0; + } + else + { + // Get the size of compiled shader program (not available on OpenGL ES 2.0) + // NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero. + //GLint binarySize = 0; + //glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize); - TRACELOG( RL_LOG_INFO, "SHADER: [ID %i] Compute shader program loaded successfully", program ); - } + RL_TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Compute shader program loaded successfully", program); + } #endif - return program; + return program; } // Dispatch compute shader (equivalent to *draw* for graphics pilepine) -void rlComputeShaderDispatch( unsigned int groupX, unsigned int groupY, unsigned int groupZ ) +void RLGL_ComputeShaderDispatch(unsigned int groupX, unsigned int groupY, unsigned int groupZ) { -#if defined( GRAPHICS_API_OPENGL_43 ) - glDispatchCompute( groupX, groupY, groupZ ); +#if defined(GRAPHICS_API_OPENGL_43) + glDispatchCompute(groupX, groupY, groupZ); #endif } // Load shader storage buffer object (SSBO) -unsigned int rlLoadShaderBuffer( unsigned int size, const void* data, int usageHint ) +unsigned int RLGL_LoadShaderBuffer(unsigned int size, const void *data, int usageHint) { - unsigned int ssbo = 0; + unsigned int ssbo = 0; -#if defined( GRAPHICS_API_OPENGL_43 ) - glGenBuffers( 1, &ssbo ); - glBindBuffer( GL_SHADER_STORAGE_BUFFER, ssbo ); - glBufferData( GL_SHADER_STORAGE_BUFFER, size, data, usageHint ? usageHint : RL_STREAM_COPY ); - if ( data == NULL ) - glClearBufferData( GL_SHADER_STORAGE_BUFFER, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, NULL ); // Clear buffer data to 0 - glBindBuffer( GL_SHADER_STORAGE_BUFFER, 0 ); +#if defined(GRAPHICS_API_OPENGL_43) + glGenBuffers(1, &ssbo); + glBindBuffer(GL_SHADER_STORAGE_BUFFER, ssbo); + glBufferData(GL_SHADER_STORAGE_BUFFER, size, data, usageHint? usageHint : RL_STREAM_COPY); + if (data == NULL) glClearBufferData(GL_SHADER_STORAGE_BUFFER, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, NULL); // Clear buffer data to 0 + glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0); #endif - return ssbo; + return ssbo; } // Unload shader storage buffer object (SSBO) -void rlUnloadShaderBuffer( unsigned int ssboId ) +void RLGL_UnloadShaderBuffer(unsigned int ssboId) { -#if defined( GRAPHICS_API_OPENGL_43 ) - glDeleteBuffers( 1, &ssboId ); +#if defined(GRAPHICS_API_OPENGL_43) + glDeleteBuffers(1, &ssboId); #endif } // Update SSBO buffer data -void rlUpdateShaderBuffer( unsigned int id, const void* data, unsigned int dataSize, unsigned int offset ) +void RLGL_UpdateShaderBuffer(unsigned int id, const void *data, unsigned int dataSize, unsigned int offset) { -#if defined( GRAPHICS_API_OPENGL_43 ) - glBindBuffer( GL_SHADER_STORAGE_BUFFER, id ); - glBufferSubData( GL_SHADER_STORAGE_BUFFER, offset, dataSize, data ); +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_SHADER_STORAGE_BUFFER, id); + glBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, dataSize, data); #endif } // Get SSBO buffer size -unsigned int rlGetShaderBufferSize( unsigned int id ) +unsigned int RLGL_GetShaderBufferSize(unsigned int id) { - long long size = 0; + long long size = 0; -#if defined( GRAPHICS_API_OPENGL_43 ) - glBindBuffer( GL_SHADER_STORAGE_BUFFER, id ); - glGetInteger64v( GL_SHADER_STORAGE_BUFFER_SIZE, &size ); +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_SHADER_STORAGE_BUFFER, id); + glGetInteger64v(GL_SHADER_STORAGE_BUFFER_SIZE, &size); #endif - return ( size > 0 ) ? ( unsigned int )size : 0; + return (size > 0)? (unsigned int)size : 0; } // Read SSBO buffer data (GPU->CPU) -void rlReadShaderBuffer( unsigned int id, void* dest, unsigned int count, unsigned int offset ) +void RLGL_ReadShaderBuffer(unsigned int id, void *dest, unsigned int count, unsigned int offset) { -#if defined( GRAPHICS_API_OPENGL_43 ) - glBindBuffer( GL_SHADER_STORAGE_BUFFER, id ); - glGetBufferSubData( GL_SHADER_STORAGE_BUFFER, offset, count, dest ); +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_SHADER_STORAGE_BUFFER, id); + glGetBufferSubData(GL_SHADER_STORAGE_BUFFER, offset, count, dest); #endif } // Bind SSBO buffer -void rlBindShaderBuffer( unsigned int id, unsigned int index ) +void RLGL_BindShaderBuffer(unsigned int id, unsigned int index) { -#if defined( GRAPHICS_API_OPENGL_43 ) - glBindBufferBase( GL_SHADER_STORAGE_BUFFER, index, id ); +#if defined(GRAPHICS_API_OPENGL_43) + glBindBufferBase(GL_SHADER_STORAGE_BUFFER, index, id); #endif } // Copy SSBO buffer data -void rlCopyShaderBuffer( unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count ) +void RLGL_CopyShaderBuffer(unsigned int destId, unsigned int srcId, unsigned int destOffset, unsigned int srcOffset, unsigned int count) { -#if defined( GRAPHICS_API_OPENGL_43 ) - glBindBuffer( GL_COPY_READ_BUFFER, srcId ); - glBindBuffer( GL_COPY_WRITE_BUFFER, destId ); - glCopyBufferSubData( GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, srcOffset, destOffset, count ); +#if defined(GRAPHICS_API_OPENGL_43) + glBindBuffer(GL_COPY_READ_BUFFER, srcId); + glBindBuffer(GL_COPY_WRITE_BUFFER, destId); + glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, srcOffset, destOffset, count); #endif } // Bind image texture -void rlBindImageTexture( unsigned int id, unsigned int index, int format, bool readonly ) +void RLGL_BindImageTexture(unsigned int id, unsigned int index, int format, bool readonly) { -#if defined( GRAPHICS_API_OPENGL_43 ) - unsigned int glInternalFormat = 0, glFormat = 0, glType = 0; +#if defined(GRAPHICS_API_OPENGL_43) + unsigned int glInternalFormat = 0, glFormat = 0, glType = 0; - rlGetGlTextureFormats( format, &glInternalFormat, &glFormat, &glType ); - glBindImageTexture( index, id, 0, 0, 0, readonly ? GL_READ_ONLY : GL_READ_WRITE, glInternalFormat ); + RLGL_GetGlTextureFormats(format, &glInternalFormat, &glFormat, &glType); + glBindImageTexture(index, id, 0, 0, 0, readonly? GL_READ_ONLY : GL_READ_WRITE, glInternalFormat); #endif } -// Matrix state management +// RL_Matrix state management //----------------------------------------------------------------------------------------- // Get internal modelview matrix -Matrix rlGetMatrixModelview( void ) +RL_Matrix RLGL_GetMatrixModelview(void) { - Matrix matrix = rlMatrixIdentity(); -#if defined( GRAPHICS_API_OPENGL_11 ) - float mat[ 16 ]; - glGetFloatv( GL_MODELVIEW_MATRIX, mat ); - matrix.m0 = mat[ 0 ]; - matrix.m1 = mat[ 1 ]; - matrix.m2 = mat[ 2 ]; - matrix.m3 = mat[ 3 ]; - matrix.m4 = mat[ 4 ]; - matrix.m5 = mat[ 5 ]; - matrix.m6 = mat[ 6 ]; - matrix.m7 = mat[ 7 ]; - matrix.m8 = mat[ 8 ]; - matrix.m9 = mat[ 9 ]; - matrix.m10 = mat[ 10 ]; - matrix.m11 = mat[ 11 ]; - matrix.m12 = mat[ 12 ]; - matrix.m13 = mat[ 13 ]; - matrix.m14 = mat[ 14 ]; - matrix.m15 = mat[ 15 ]; + RL_Matrix matrix = RLGL_MatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_11) + float mat[16]; + glGetFloatv(GL_MODELVIEW_MATRIX, mat); + matrix.m0 = mat[0]; + matrix.m1 = mat[1]; + matrix.m2 = mat[2]; + matrix.m3 = mat[3]; + matrix.m4 = mat[4]; + matrix.m5 = mat[5]; + matrix.m6 = mat[6]; + matrix.m7 = mat[7]; + matrix.m8 = mat[8]; + matrix.m9 = mat[9]; + matrix.m10 = mat[10]; + matrix.m11 = mat[11]; + matrix.m12 = mat[12]; + matrix.m13 = mat[13]; + matrix.m14 = mat[14]; + matrix.m15 = mat[15]; #else - matrix = RLGL.State.modelview; + matrix = RLGL_GLOBAL_DATA.State.modelview; #endif - return matrix; + return matrix; } // Get internal projection matrix -Matrix rlGetMatrixProjection( void ) +RL_Matrix RLGL_GetMatrixProjection(void) { -#if defined( GRAPHICS_API_OPENGL_11 ) - float mat[ 16 ]; - glGetFloatv( GL_PROJECTION_MATRIX, mat ); - Matrix m; - m.m0 = mat[ 0 ]; - m.m1 = mat[ 1 ]; - m.m2 = mat[ 2 ]; - m.m3 = mat[ 3 ]; - m.m4 = mat[ 4 ]; - m.m5 = mat[ 5 ]; - m.m6 = mat[ 6 ]; - m.m7 = mat[ 7 ]; - m.m8 = mat[ 8 ]; - m.m9 = mat[ 9 ]; - m.m10 = mat[ 10 ]; - m.m11 = mat[ 11 ]; - m.m12 = mat[ 12 ]; - m.m13 = mat[ 13 ]; - m.m14 = mat[ 14 ]; - m.m15 = mat[ 15 ]; - return m; +#if defined(GRAPHICS_API_OPENGL_11) + float mat[16]; + glGetFloatv(GL_PROJECTION_MATRIX,mat); + RL_Matrix m; + m.m0 = mat[0]; + m.m1 = mat[1]; + m.m2 = mat[2]; + m.m3 = mat[3]; + m.m4 = mat[4]; + m.m5 = mat[5]; + m.m6 = mat[6]; + m.m7 = mat[7]; + m.m8 = mat[8]; + m.m9 = mat[9]; + m.m10 = mat[10]; + m.m11 = mat[11]; + m.m12 = mat[12]; + m.m13 = mat[13]; + m.m14 = mat[14]; + m.m15 = mat[15]; + return m; #else - return RLGL.State.projection; + return RLGL_GLOBAL_DATA.State.projection; #endif } // Get internal accumulated transform matrix -Matrix rlGetMatrixTransform( void ) +RL_Matrix RLGL_GetMatrixTransform(void) { - Matrix mat = rlMatrixIdentity(); -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - // TODO: Consider possible transform matrices in the RLGL.State.stack - // Is this the right order? or should we start with the first stored matrix instead of the last one? - // Matrix matStackTransform = rlMatrixIdentity(); - // for (int i = RLGL.State.stackCounter; i > 0; i--) matStackTransform = rlMatrixMultiply(RLGL.State.stack[i], matStackTransform); - mat = RLGL.State.transform; + RL_Matrix mat = RLGL_MatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + // TODO: Consider possible transform matrices in the RLGL_GLOBAL_DATA.State.stack + // Is this the right order? or should we start with the first stored matrix instead of the last one? + //RL_Matrix matStackTransform = RLGL_MatrixIdentity(); + //for (int i = RLGL_GLOBAL_DATA.State.stackCounter; i > 0; i--) matStackTransform = RLGL_MatrixMultiply(RLGL_GLOBAL_DATA.State.stack[i], matStackTransform); + mat = RLGL_GLOBAL_DATA.State.transform; #endif - return mat; + return mat; } // Get internal projection matrix for stereo render (selected eye) -RLAPI Matrix rlGetMatrixProjectionStereo( int eye ) +RLAPI RL_Matrix RLGL_GetMatrixProjectionStereo(int eye) { - Matrix mat = rlMatrixIdentity(); -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - mat = RLGL.State.projectionStereo[ eye ]; + RL_Matrix mat = RLGL_MatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + mat = RLGL_GLOBAL_DATA.State.projectionStereo[eye]; #endif - return mat; + return mat; } // Get internal view offset matrix for stereo render (selected eye) -RLAPI Matrix rlGetMatrixViewOffsetStereo( int eye ) +RLAPI RL_Matrix RLGL_GetMatrixViewOffsetStereo(int eye) { - Matrix mat = rlMatrixIdentity(); -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - mat = RLGL.State.viewOffsetStereo[ eye ]; + RL_Matrix mat = RLGL_MatrixIdentity(); +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + mat = RLGL_GLOBAL_DATA.State.viewOffsetStereo[eye]; #endif - return mat; + return mat; } // Set a custom modelview matrix (replaces internal modelview matrix) -void rlSetMatrixModelview( Matrix view ) +void RLGL_SetMatrixModelview(RL_Matrix view) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - RLGL.State.modelview = view; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL_GLOBAL_DATA.State.modelview = view; #endif } // Set a custom projection matrix (replaces internal projection matrix) -void rlSetMatrixProjection( Matrix projection ) +void RLGL_SetMatrixProjection(RL_Matrix projection) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - RLGL.State.projection = projection; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL_GLOBAL_DATA.State.projection = projection; #endif } // Set eyes projection matrices for stereo rendering -void rlSetMatrixProjectionStereo( Matrix right, Matrix left ) +void RLGL_SetMatrixProjectionStereo(RL_Matrix right, RL_Matrix left) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - RLGL.State.projectionStereo[ 0 ] = right; - RLGL.State.projectionStereo[ 1 ] = left; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL_GLOBAL_DATA.State.projectionStereo[0] = right; + RLGL_GLOBAL_DATA.State.projectionStereo[1] = left; #endif } // Set eyes view offsets matrices for stereo rendering -void rlSetMatrixViewOffsetStereo( Matrix right, Matrix left ) +void RLGL_SetMatrixViewOffsetStereo(RL_Matrix right, RL_Matrix left) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - RLGL.State.viewOffsetStereo[ 0 ] = right; - RLGL.State.viewOffsetStereo[ 1 ] = left; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + RLGL_GLOBAL_DATA.State.viewOffsetStereo[0] = right; + RLGL_GLOBAL_DATA.State.viewOffsetStereo[1] = left; #endif } // Load and draw a quad in NDC -void rlLoadDrawQuad( void ) +void RLGL_LoadDrawQuad(void) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - unsigned int quadVAO = 0; - unsigned int quadVBO = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int quadVAO = 0; + unsigned int quadVBO = 0; - float vertices[] = { - // Positions Texcoords - -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, - }; + float vertices[] = { + // Positions Texcoords + -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, + 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, + 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, + }; - // Gen VAO to contain VBO - glGenVertexArrays( 1, &quadVAO ); - glBindVertexArray( quadVAO ); + // Gen VAO to contain VBO + glGenVertexArrays(1, &quadVAO); + glBindVertexArray(quadVAO); - // Gen and fill vertex buffer (VBO) - glGenBuffers( 1, &quadVBO ); - glBindBuffer( GL_ARRAY_BUFFER, quadVBO ); - glBufferData( GL_ARRAY_BUFFER, sizeof( vertices ), &vertices, GL_STATIC_DRAW ); + // Gen and fill vertex buffer (VBO) + glGenBuffers(1, &quadVBO); + glBindBuffer(GL_ARRAY_BUFFER, quadVBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW); - // Bind vertex attributes (position, texcoords) - glEnableVertexAttribArray( 0 ); - glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof( float ), ( void* )0 ); // Positions - glEnableVertexAttribArray( 1 ); - glVertexAttribPointer( 1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof( float ), ( void* )( 3 * sizeof( float ) ) ); // Texcoords + // Bind vertex attributes (position, texcoords) + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void *)0); // Positions + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5*sizeof(float), (void *)(3*sizeof(float))); // Texcoords - // Draw quad - glBindVertexArray( quadVAO ); - glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 ); - glBindVertexArray( 0 ); + // Draw quad + glBindVertexArray(quadVAO); + glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); + glBindVertexArray(0); - // Delete buffers (VBO and VAO) - glDeleteBuffers( 1, &quadVBO ); - glDeleteVertexArrays( 1, &quadVAO ); + // Delete buffers (VBO and VAO) + glDeleteBuffers(1, &quadVBO); + glDeleteVertexArrays(1, &quadVAO); #endif } // Load and draw a cube in NDC -void rlLoadDrawCube( void ) +void RLGL_LoadDrawCube(void) { -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) - unsigned int cubeVAO = 0; - unsigned int cubeVBO = 0; +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) + unsigned int cubeVAO = 0; + unsigned int cubeVBO = 0; - float vertices[] = { - // Positions Normals Texcoords - -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, - -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, - -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, - 0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, - 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, -1.0f, - 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, - 0.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, - 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, - 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, - 0.0f, 0.0f, 0.0f, -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f, 1.0f, -1.0f, - 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, -1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, - 0.0f, -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, - 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, -1.0f, - 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f - }; + float vertices[] = { + // Positions Normals Texcoords + -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, + 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, + 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f, + 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f, + -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f, + -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, + -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, + -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + -1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, + -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + -1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + -1.0f, -1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, + 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, + 1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, + -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, + 1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f, + 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, + 1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f, + -1.0f, -1.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, + -1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, + -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, + 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, + 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, + -1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, + -1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f + }; - // Gen VAO to contain VBO - glGenVertexArrays( 1, &cubeVAO ); - glBindVertexArray( cubeVAO ); + // Gen VAO to contain VBO + glGenVertexArrays(1, &cubeVAO); + glBindVertexArray(cubeVAO); - // Gen and fill vertex buffer (VBO) - glGenBuffers( 1, &cubeVBO ); - glBindBuffer( GL_ARRAY_BUFFER, cubeVBO ); - glBufferData( GL_ARRAY_BUFFER, sizeof( vertices ), vertices, GL_STATIC_DRAW ); + // Gen and fill vertex buffer (VBO) + glGenBuffers(1, &cubeVBO); + glBindBuffer(GL_ARRAY_BUFFER, cubeVBO); + glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); - // Bind vertex attributes (position, normals, texcoords) - glBindVertexArray( cubeVAO ); - glEnableVertexAttribArray( 0 ); - glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof( float ), ( void* )0 ); // Positions - glEnableVertexAttribArray( 1 ); - glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof( float ), ( void* )( 3 * sizeof( float ) ) ); // Normals - glEnableVertexAttribArray( 2 ); - glVertexAttribPointer( 2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof( float ), ( void* )( 6 * sizeof( float ) ) ); // Texcoords - glBindBuffer( GL_ARRAY_BUFFER, 0 ); - glBindVertexArray( 0 ); + // Bind vertex attributes (position, normals, texcoords) + glBindVertexArray(cubeVAO); + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)0); // Positions + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)(3*sizeof(float))); // Normals + glEnableVertexAttribArray(2); + glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8*sizeof(float), (void *)(6*sizeof(float))); // Texcoords + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindVertexArray(0); - // Draw cube - glBindVertexArray( cubeVAO ); - glDrawArrays( GL_TRIANGLES, 0, 36 ); - glBindVertexArray( 0 ); + // Draw cube + glBindVertexArray(cubeVAO); + glDrawArrays(GL_TRIANGLES, 0, 36); + glBindVertexArray(0); - // Delete VBO and VAO - glDeleteBuffers( 1, &cubeVBO ); - glDeleteVertexArrays( 1, &cubeVAO ); + // Delete VBO and VAO + glDeleteBuffers(1, &cubeVBO); + glDeleteVertexArrays(1, &cubeVAO); #endif } // Get name string for pixel format -const char* rlGetPixelFormatName( unsigned int format ) +const char *RLGL_GetPixelFormatName(unsigned int format) { - switch ( format ) - { - case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE : - return "GRAYSCALE"; - break; // 8 bit per pixel (no alpha) - case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA : - return "GRAY_ALPHA"; - break; // 8*2 bpp (2 channels) - case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5 : - return "R5G6B5"; - break; // 16 bpp - case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8 : - return "R8G8B8"; - break; // 24 bpp - case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 : - return "R5G5B5A1"; - break; // 16 bpp (1 bit alpha) - case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 : - return "R4G4B4A4"; - break; // 16 bpp (4 bit alpha) - case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 : - return "R8G8B8A8"; - break; // 32 bpp - case RL_PIXELFORMAT_UNCOMPRESSED_R32 : - return "R32"; - break; // 32 bpp (1 channel - float) - case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32 : - return "R32G32B32"; - break; // 32*3 bpp (3 channels - float) - case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 : - return "R32G32B32A32"; - break; // 32*4 bpp (4 channels - float) - case RL_PIXELFORMAT_UNCOMPRESSED_R16 : - return "R16"; - break; // 16 bpp (1 channel - half float) - case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16 : - return "R16G16B16"; - break; // 16*3 bpp (3 channels - half float) - case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 : - return "R16G16B16A16"; - break; // 16*4 bpp (4 channels - half float) - case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB : - return "DXT1_RGB"; - break; // 4 bpp (no alpha) - case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA : - return "DXT1_RGBA"; - break; // 4 bpp (1 bit alpha) - case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA : - return "DXT3_RGBA"; - break; // 8 bpp - case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA : - return "DXT5_RGBA"; - break; // 8 bpp - case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB : - return "ETC1_RGB"; - break; // 4 bpp - case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB : - return "ETC2_RGB"; - break; // 4 bpp - case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA : - return "ETC2_RGBA"; - break; // 8 bpp - case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB : - return "PVRT_RGB"; - break; // 4 bpp - case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA : - return "PVRT_RGBA"; - break; // 4 bpp - case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA : - return "ASTC_4x4_RGBA"; - break; // 8 bpp - case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA : - return "ASTC_8x8_RGBA"; - break; // 2 bpp - default : - return "UNKNOWN"; - break; - } + switch (format) + { + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: return "GRAYSCALE"; break; // 8 bit per pixel (no alpha) + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: return "GRAY_ALPHA"; break; // 8*2 bpp (2 channels) + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: return "R5G6B5"; break; // 16 bpp + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: return "R8G8B8"; break; // 24 bpp + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: return "R5G5B5A1"; break; // 16 bpp (1 bit alpha) + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: return "R4G4B4A4"; break; // 16 bpp (4 bit alpha) + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: return "R8G8B8A8"; break; // 32 bpp + case RL_PIXELFORMAT_UNCOMPRESSED_R32: return "R32"; break; // 32 bpp (1 channel - float) + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: return "R32G32B32"; break; // 32*3 bpp (3 channels - float) + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: return "R32G32B32A32"; break; // 32*4 bpp (4 channels - float) + case RL_PIXELFORMAT_UNCOMPRESSED_R16: return "R16"; break; // 16 bpp (1 channel - half float) + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: return "R16G16B16"; break; // 16*3 bpp (3 channels - half float) + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: return "R16G16B16A16"; break; // 16*4 bpp (4 channels - half float) + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: return "DXT1_RGB"; break; // 4 bpp (no alpha) + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: return "DXT1_RGBA"; break; // 4 bpp (1 bit alpha) + case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: return "DXT3_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: return "DXT5_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: return "ETC1_RGB"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: return "ETC2_RGB"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: return "ETC2_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: return "PVRT_RGB"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: return "PVRT_RGBA"; break; // 4 bpp + case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: return "ASTC_4x4_RGBA"; break; // 8 bpp + case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: return "ASTC_8x8_RGBA"; break; // 2 bpp + default: return "UNKNOWN"; break; + } } //---------------------------------------------------------------------------------- // Module specific Functions Definition //---------------------------------------------------------------------------------- -#if defined( GRAPHICS_API_OPENGL_33 ) || defined( GRAPHICS_API_OPENGL_ES2 ) +#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2) // Load default shader (just vertex positioning and texture coloring) // NOTE: This shader program is used for internal buffers -// NOTE: Loaded: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs -static void rlLoadShaderDefault( void ) +// NOTE: Loaded: RLGL_GLOBAL_DATA.State.defaultShaderId, RLGL_GLOBAL_DATA.State.defaultShaderLocs +static void RLGL_LoadShaderDefault(void) { - RLGL.State.defaultShaderLocs = ( int* )RL_CALLOC( RL_MAX_SHADER_LOCATIONS, sizeof( int ) ); + RLGL_GLOBAL_DATA.State.defaultShaderLocs = (int *)RL_CALLOC(RL_MAX_SHADER_LOCATIONS, sizeof(int)); - // NOTE: All locations must be reseted to -1 (no location) - for ( int i = 0; i < RL_MAX_SHADER_LOCATIONS; i++ ) - RLGL.State.defaultShaderLocs[ i ] = -1; + // NOTE: All locations must be reseted to -1 (no location) + for (int i = 0; i < RL_MAX_SHADER_LOCATIONS; i++) RLGL_GLOBAL_DATA.State.defaultShaderLocs[i] = -1; - // Vertex shader directly defined, no external file required - const char* defaultVShaderCode = -#if defined( GRAPHICS_API_OPENGL_21 ) - "#version 120 \n" - "attribute vec3 vertexPosition; \n" - "attribute vec2 vertexTexCoord; \n" - "attribute vec4 vertexColor; \n" - "varying vec2 fragTexCoord; \n" - "varying vec4 fragColor; \n" -#elif defined( GRAPHICS_API_OPENGL_33 ) - "#version 330 \n" - "in vec3 vertexPosition; \n" - "in vec2 vertexTexCoord; \n" - "in vec4 vertexColor; \n" - "out vec2 fragTexCoord; \n" - "out vec4 fragColor; \n" + // Vertex shader directly defined, no external file required + const char *defaultVShaderCode = +#if defined(GRAPHICS_API_OPENGL_21) + "#version 120 \n" + "attribute vec3 vertexPosition; \n" + "attribute vec2 vertexTexCoord; \n" + "attribute vec4 vertexColor; \n" + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" +#elif defined(GRAPHICS_API_OPENGL_33) + "#version 330 \n" + "in vec3 vertexPosition; \n" + "in vec2 vertexTexCoord; \n" + "in vec4 vertexColor; \n" + "out vec2 fragTexCoord; \n" + "out vec4 fragColor; \n" #endif -#if defined( GRAPHICS_API_OPENGL_ES2 ) - "#version 100 \n" - "precision mediump float; \n" // Precision required for OpenGL ES2 (WebGL) (on some browsers) - "attribute vec3 vertexPosition; \n" - "attribute vec2 vertexTexCoord; \n" - "attribute vec4 vertexColor; \n" - "varying vec2 fragTexCoord; \n" - "varying vec4 fragColor; \n" +#if defined(GRAPHICS_API_OPENGL_ES2) + "#version 100 \n" + "precision mediump float; \n" // Precision required for OpenGL ES2 (WebGL) (on some browsers) + "attribute vec3 vertexPosition; \n" + "attribute vec2 vertexTexCoord; \n" + "attribute vec4 vertexColor; \n" + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" #endif - "uniform mat4 mvp; \n" - "void main() \n" - "{ \n" - " fragTexCoord = vertexTexCoord; \n" - " fragColor = vertexColor; \n" - " gl_Position = mvp*vec4(vertexPosition, 1.0); \n" - "} \n"; + "uniform mat4 mvp; \n" + "void main() \n" + "{ \n" + " fragTexCoord = vertexTexCoord; \n" + " fragColor = vertexColor; \n" + " gl_Position = mvp*vec4(vertexPosition, 1.0); \n" + "} \n"; - // Fragment shader directly defined, no external file required - const char* defaultFShaderCode = -#if defined( GRAPHICS_API_OPENGL_21 ) - "#version 120 \n" - "varying vec2 fragTexCoord; \n" - "varying vec4 fragColor; \n" - "uniform sampler2D texture0; \n" - "uniform vec4 colDiffuse; \n" - "void main() \n" - "{ \n" - " vec4 texelColor = texture2D(texture0, fragTexCoord); \n" - " gl_FragColor = texelColor*colDiffuse*fragColor; \n" - "} \n"; -#elif defined( GRAPHICS_API_OPENGL_33 ) - "#version 330 \n" - "in vec2 fragTexCoord; \n" - "in vec4 fragColor; \n" - "out vec4 finalColor; \n" - "uniform sampler2D texture0; \n" - "uniform vec4 colDiffuse; \n" - "void main() \n" - "{ \n" - " vec4 texelColor = texture(texture0, fragTexCoord); \n" - " finalColor = texelColor*colDiffuse*fragColor; \n" - "} \n"; + // Fragment shader directly defined, no external file required + const char *defaultFShaderCode = +#if defined(GRAPHICS_API_OPENGL_21) + "#version 120 \n" + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" + "uniform sampler2D texture0; \n" + "uniform vec4 colDiffuse; \n" + "void main() \n" + "{ \n" + " vec4 texelColor = texture2D(texture0, fragTexCoord); \n" + " gl_FragColor = texelColor*colDiffuse*fragColor; \n" + "} \n"; +#elif defined(GRAPHICS_API_OPENGL_33) + "#version 330 \n" + "in vec2 fragTexCoord; \n" + "in vec4 fragColor; \n" + "out vec4 finalColor; \n" + "uniform sampler2D texture0; \n" + "uniform vec4 colDiffuse; \n" + "void main() \n" + "{ \n" + " vec4 texelColor = texture(texture0, fragTexCoord); \n" + " finalColor = texelColor*colDiffuse*fragColor; \n" + "} \n"; #endif -#if defined( GRAPHICS_API_OPENGL_ES2 ) - "#version 100 \n" - "precision mediump float; \n" // Precision required for OpenGL ES2 (WebGL) - "varying vec2 fragTexCoord; \n" - "varying vec4 fragColor; \n" - "uniform sampler2D texture0; \n" - "uniform vec4 colDiffuse; \n" - "void main() \n" - "{ \n" - " vec4 texelColor = texture2D(texture0, fragTexCoord); \n" - " gl_FragColor = texelColor*colDiffuse*fragColor; \n" - "} \n"; +#if defined(GRAPHICS_API_OPENGL_ES2) + "#version 100 \n" + "precision mediump float; \n" // Precision required for OpenGL ES2 (WebGL) + "varying vec2 fragTexCoord; \n" + "varying vec4 fragColor; \n" + "uniform sampler2D texture0; \n" + "uniform vec4 colDiffuse; \n" + "void main() \n" + "{ \n" + " vec4 texelColor = texture2D(texture0, fragTexCoord); \n" + " gl_FragColor = texelColor*colDiffuse*fragColor; \n" + "} \n"; #endif - // NOTE: Compiled vertex/fragment shaders are not deleted, - // they are kept for re-use as default shaders in case some shader loading fails - RLGL.State.defaultVShaderId = rlCompileShader( defaultVShaderCode, GL_VERTEX_SHADER ); // Compile default vertex shader - RLGL.State.defaultFShaderId = rlCompileShader( defaultFShaderCode, GL_FRAGMENT_SHADER ); // Compile default fragment shader + // NOTE: Compiled vertex/fragment shaders are not deleted, + // they are kept for re-use as default shaders in case some shader loading fails + RLGL_GLOBAL_DATA.State.defaultVShaderId = RLGL_CompileShader(defaultVShaderCode, GL_VERTEX_SHADER); // Compile default vertex shader + RLGL_GLOBAL_DATA.State.defaultFShaderId = RLGL_CompileShader(defaultFShaderCode, GL_FRAGMENT_SHADER); // Compile default fragment shader - RLGL.State.defaultShaderId = rlLoadShaderProgram( RLGL.State.defaultVShaderId, RLGL.State.defaultFShaderId ); + RLGL_GLOBAL_DATA.State.defaultShaderId = RLGL_LoadShaderProgram(RLGL_GLOBAL_DATA.State.defaultVShaderId, RLGL_GLOBAL_DATA.State.defaultFShaderId); - if ( RLGL.State.defaultShaderId > 0 ) - { - TRACELOG( RL_LOG_INFO, "SHADER: [ID %i] Default shader loaded successfully", RLGL.State.defaultShaderId ); + if (RLGL_GLOBAL_DATA.State.defaultShaderId > 0) + { + RL_TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader loaded successfully", RLGL_GLOBAL_DATA.State.defaultShaderId); - // Set default shader locations: attributes locations - RLGL.State.defaultShaderLocs[ RL_SHADER_LOC_VERTEX_POSITION ] = glGetAttribLocation( RLGL.State.defaultShaderId, "vertexPosition" ); - RLGL.State.defaultShaderLocs[ RL_SHADER_LOC_VERTEX_TEXCOORD01 ] = glGetAttribLocation( RLGL.State.defaultShaderId, "vertexTexCoord" ); - RLGL.State.defaultShaderLocs[ RL_SHADER_LOC_VERTEX_COLOR ] = glGetAttribLocation( RLGL.State.defaultShaderId, "vertexColor" ); + // Set default shader locations: attributes locations + RLGL_GLOBAL_DATA.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_POSITION] = glGetAttribLocation(RLGL_GLOBAL_DATA.State.defaultShaderId, "vertexPosition"); + RLGL_GLOBAL_DATA.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_TEXCOORD01] = glGetAttribLocation(RLGL_GLOBAL_DATA.State.defaultShaderId, "vertexTexCoord"); + RLGL_GLOBAL_DATA.State.defaultShaderLocs[RL_SHADER_LOC_VERTEX_COLOR] = glGetAttribLocation(RLGL_GLOBAL_DATA.State.defaultShaderId, "vertexColor"); - // Set default shader locations: uniform locations - RLGL.State.defaultShaderLocs[ RL_SHADER_LOC_MATRIX_MVP ] = glGetUniformLocation( RLGL.State.defaultShaderId, "mvp" ); - RLGL.State.defaultShaderLocs[ RL_SHADER_LOC_COLOR_DIFFUSE ] = glGetUniformLocation( RLGL.State.defaultShaderId, "colDiffuse" ); - RLGL.State.defaultShaderLocs[ RL_SHADER_LOC_MAP_DIFFUSE ] = glGetUniformLocation( RLGL.State.defaultShaderId, "texture0" ); - } - else - TRACELOG( RL_LOG_WARNING, "SHADER: [ID %i] Failed to load default shader", RLGL.State.defaultShaderId ); + // Set default shader locations: uniform locations + RLGL_GLOBAL_DATA.State.defaultShaderLocs[RL_SHADER_LOC_MATRIX_MVP] = glGetUniformLocation(RLGL_GLOBAL_DATA.State.defaultShaderId, "mvp"); + RLGL_GLOBAL_DATA.State.defaultShaderLocs[RL_SHADER_LOC_COLOR_DIFFUSE] = glGetUniformLocation(RLGL_GLOBAL_DATA.State.defaultShaderId, "colDiffuse"); + RLGL_GLOBAL_DATA.State.defaultShaderLocs[RL_SHADER_LOC_MAP_DIFFUSE] = glGetUniformLocation(RLGL_GLOBAL_DATA.State.defaultShaderId, "texture0"); + } + else RL_TRACELOG(RL_LOG_WARNING, "SHADER: [ID %i] Failed to load default shader", RLGL_GLOBAL_DATA.State.defaultShaderId); } // Unload default shader -// NOTE: Unloads: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs -static void rlUnloadShaderDefault( void ) +// NOTE: Unloads: RLGL_GLOBAL_DATA.State.defaultShaderId, RLGL_GLOBAL_DATA.State.defaultShaderLocs +static void RLGL_UnloadShaderDefault(void) { - glUseProgram( 0 ); + glUseProgram(0); - glDetachShader( RLGL.State.defaultShaderId, RLGL.State.defaultVShaderId ); - glDetachShader( RLGL.State.defaultShaderId, RLGL.State.defaultFShaderId ); - glDeleteShader( RLGL.State.defaultVShaderId ); - glDeleteShader( RLGL.State.defaultFShaderId ); + glDetachShader(RLGL_GLOBAL_DATA.State.defaultShaderId, RLGL_GLOBAL_DATA.State.defaultVShaderId); + glDetachShader(RLGL_GLOBAL_DATA.State.defaultShaderId, RLGL_GLOBAL_DATA.State.defaultFShaderId); + glDeleteShader(RLGL_GLOBAL_DATA.State.defaultVShaderId); + glDeleteShader(RLGL_GLOBAL_DATA.State.defaultFShaderId); - glDeleteProgram( RLGL.State.defaultShaderId ); + glDeleteProgram(RLGL_GLOBAL_DATA.State.defaultShaderId); - RL_FREE( RLGL.State.defaultShaderLocs ); + RL_FREE(RLGL_GLOBAL_DATA.State.defaultShaderLocs); - TRACELOG( RL_LOG_INFO, "SHADER: [ID %i] Default shader unloaded successfully", RLGL.State.defaultShaderId ); + RL_TRACELOG(RL_LOG_INFO, "SHADER: [ID %i] Default shader unloaded successfully", RLGL_GLOBAL_DATA.State.defaultShaderId); } -#if defined( RLGL_SHOW_GL_DETAILS_INFO ) +#if defined(RLGL_SHOW_GL_DETAILS_INFO) // Get compressed format official GL identifier name -static char* rlGetCompressedFormatName( int format ) +static const char *RLGL_GetCompressedFormatName(int format) { - switch ( format ) - { - // GL_EXT_texture_compression_s3tc - case 0x83F0 : - return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; - break; - case 0x83F1 : - return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; - break; - case 0x83F2 : - return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT"; - break; - case 0x83F3 : - return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT"; - break; - // GL_3DFX_texture_compression_FXT1 - case 0x86B0 : - return "GL_COMPRESSED_RGB_FXT1_3DFX"; - break; - case 0x86B1 : - return "GL_COMPRESSED_RGBA_FXT1_3DFX"; - break; - // GL_IMG_texture_compression_pvrtc - case 0x8C00 : - return "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG"; - break; - case 0x8C01 : - return "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG"; - break; - case 0x8C02 : - return "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"; - break; - case 0x8C03 : - return "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"; - break; - // GL_OES_compressed_ETC1_RGB8_texture - case 0x8D64 : - return "GL_ETC1_RGB8_OES"; - break; - // GL_ARB_texture_compression_rgtc - case 0x8DBB : - return "GL_COMPRESSED_RED_RGTC1"; - break; - case 0x8DBC : - return "GL_COMPRESSED_SIGNED_RED_RGTC1"; - break; - case 0x8DBD : - return "GL_COMPRESSED_RG_RGTC2"; - break; - case 0x8DBE : - return "GL_COMPRESSED_SIGNED_RG_RGTC2"; - break; - // GL_ARB_texture_compression_bptc - case 0x8E8C : - return "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB"; - break; - case 0x8E8D : - return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB"; - break; - case 0x8E8E : - return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB"; - break; - case 0x8E8F : - return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB"; - break; - // GL_ARB_ES3_compatibility - case 0x9274 : - return "GL_COMPRESSED_RGB8_ETC2"; - break; - case 0x9275 : - return "GL_COMPRESSED_SRGB8_ETC2"; - break; - case 0x9276 : - return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; - break; - case 0x9277 : - return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; - break; - case 0x9278 : - return "GL_COMPRESSED_RGBA8_ETC2_EAC"; - break; - case 0x9279 : - return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; - break; - case 0x9270 : - return "GL_COMPRESSED_R11_EAC"; - break; - case 0x9271 : - return "GL_COMPRESSED_SIGNED_R11_EAC"; - break; - case 0x9272 : - return "GL_COMPRESSED_RG11_EAC"; - break; - case 0x9273 : - return "GL_COMPRESSED_SIGNED_RG11_EAC"; - break; - // GL_KHR_texture_compression_astc_hdr - case 0x93B0 : - return "GL_COMPRESSED_RGBA_ASTC_4x4_KHR"; - break; - case 0x93B1 : - return "GL_COMPRESSED_RGBA_ASTC_5x4_KHR"; - break; - case 0x93B2 : - return "GL_COMPRESSED_RGBA_ASTC_5x5_KHR"; - break; - case 0x93B3 : - return "GL_COMPRESSED_RGBA_ASTC_6x5_KHR"; - break; - case 0x93B4 : - return "GL_COMPRESSED_RGBA_ASTC_6x6_KHR"; - break; - case 0x93B5 : - return "GL_COMPRESSED_RGBA_ASTC_8x5_KHR"; - break; - case 0x93B6 : - return "GL_COMPRESSED_RGBA_ASTC_8x6_KHR"; - break; - case 0x93B7 : - return "GL_COMPRESSED_RGBA_ASTC_8x8_KHR"; - break; - case 0x93B8 : - return "GL_COMPRESSED_RGBA_ASTC_10x5_KHR"; - break; - case 0x93B9 : - return "GL_COMPRESSED_RGBA_ASTC_10x6_KHR"; - break; - case 0x93BA : - return "GL_COMPRESSED_RGBA_ASTC_10x8_KHR"; - break; - case 0x93BB : - return "GL_COMPRESSED_RGBA_ASTC_10x10_KHR"; - break; - case 0x93BC : - return "GL_COMPRESSED_RGBA_ASTC_12x10_KHR"; - break; - case 0x93BD : - return "GL_COMPRESSED_RGBA_ASTC_12x12_KHR"; - break; - case 0x93D0 : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; - break; - case 0x93D1 : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; - break; - case 0x93D2 : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; - break; - case 0x93D3 : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; - break; - case 0x93D4 : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; - break; - case 0x93D5 : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; - break; - case 0x93D6 : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; - break; - case 0x93D7 : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; - break; - case 0x93D8 : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; - break; - case 0x93D9 : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; - break; - case 0x93DA : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; - break; - case 0x93DB : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; - break; - case 0x93DC : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; - break; - case 0x93DD : - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; - break; - default : - return "GL_COMPRESSED_UNKNOWN"; - break; - } + switch (format) + { + // GL_EXT_texture_compression_s3tc + case 0x83F0: return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; break; + case 0x83F1: return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; break; + case 0x83F2: return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT"; break; + case 0x83F3: return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT"; break; + // GL_3DFX_texture_compression_FXT1 + case 0x86B0: return "GL_COMPRESSED_RGB_FXT1_3DFX"; break; + case 0x86B1: return "GL_COMPRESSED_RGBA_FXT1_3DFX"; break; + // GL_IMG_texture_compression_pvrtc + case 0x8C00: return "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG"; break; + case 0x8C01: return "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG"; break; + case 0x8C02: return "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"; break; + case 0x8C03: return "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"; break; + // GL_OES_compressed_ETC1_RGB8_texture + case 0x8D64: return "GL_ETC1_RGB8_OES"; break; + // GL_ARB_texture_compression_rgtc + case 0x8DBB: return "GL_COMPRESSED_RED_RGTC1"; break; + case 0x8DBC: return "GL_COMPRESSED_SIGNED_RED_RGTC1"; break; + case 0x8DBD: return "GL_COMPRESSED_RG_RGTC2"; break; + case 0x8DBE: return "GL_COMPRESSED_SIGNED_RG_RGTC2"; break; + // GL_ARB_texture_compression_bptc + case 0x8E8C: return "GL_COMPRESSED_RGBA_BPTC_UNORM_ARB"; break; + case 0x8E8D: return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB"; break; + case 0x8E8E: return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB"; break; + case 0x8E8F: return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB"; break; + // GL_ARB_ES3_compatibility + case 0x9274: return "GL_COMPRESSED_RGB8_ETC2"; break; + case 0x9275: return "GL_COMPRESSED_SRGB8_ETC2"; break; + case 0x9276: return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; break; + case 0x9277: return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; break; + case 0x9278: return "GL_COMPRESSED_RGBA8_ETC2_EAC"; break; + case 0x9279: return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; break; + case 0x9270: return "GL_COMPRESSED_R11_EAC"; break; + case 0x9271: return "GL_COMPRESSED_SIGNED_R11_EAC"; break; + case 0x9272: return "GL_COMPRESSED_RG11_EAC"; break; + case 0x9273: return "GL_COMPRESSED_SIGNED_RG11_EAC"; break; + // GL_KHR_texture_compression_astc_hdr + case 0x93B0: return "GL_COMPRESSED_RGBA_ASTC_4x4_KHR"; break; + case 0x93B1: return "GL_COMPRESSED_RGBA_ASTC_5x4_KHR"; break; + case 0x93B2: return "GL_COMPRESSED_RGBA_ASTC_5x5_KHR"; break; + case 0x93B3: return "GL_COMPRESSED_RGBA_ASTC_6x5_KHR"; break; + case 0x93B4: return "GL_COMPRESSED_RGBA_ASTC_6x6_KHR"; break; + case 0x93B5: return "GL_COMPRESSED_RGBA_ASTC_8x5_KHR"; break; + case 0x93B6: return "GL_COMPRESSED_RGBA_ASTC_8x6_KHR"; break; + case 0x93B7: return "GL_COMPRESSED_RGBA_ASTC_8x8_KHR"; break; + case 0x93B8: return "GL_COMPRESSED_RGBA_ASTC_10x5_KHR"; break; + case 0x93B9: return "GL_COMPRESSED_RGBA_ASTC_10x6_KHR"; break; + case 0x93BA: return "GL_COMPRESSED_RGBA_ASTC_10x8_KHR"; break; + case 0x93BB: return "GL_COMPRESSED_RGBA_ASTC_10x10_KHR"; break; + case 0x93BC: return "GL_COMPRESSED_RGBA_ASTC_12x10_KHR"; break; + case 0x93BD: return "GL_COMPRESSED_RGBA_ASTC_12x12_KHR"; break; + case 0x93D0: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; break; + case 0x93D1: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; break; + case 0x93D2: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; break; + case 0x93D3: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; break; + case 0x93D4: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; break; + case 0x93D5: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; break; + case 0x93D6: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; break; + case 0x93D7: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; break; + case 0x93D8: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; break; + case 0x93D9: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; break; + case 0x93DA: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; break; + case 0x93DB: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; break; + case 0x93DC: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; break; + case 0x93DD: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; break; + default: return "GL_COMPRESSED_UNKNOWN"; break; + } } -#endif // RLGL_SHOW_GL_DETAILS_INFO +#endif // RLGL_SHOW_GL_DETAILS_INFO -#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 +#endif // GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2 // Get pixel data size in bytes (image or texture) // NOTE: Size depends on pixel format -static int rlGetPixelDataSize( int width, int height, int format ) +static int RLGL_GetPixelDataSize(int width, int height, int format) { - int dataSize = 0; // Size in bytes - int bpp = 0; // Bits per pixel + int dataSize = 0; // Size in bytes + int bpp = 0; // Bits per pixel - switch ( format ) - { - case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE : - bpp = 8; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA : - case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5 : - case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 : - case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 : - bpp = 16; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 : - bpp = 32; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8 : - bpp = 24; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R32 : - bpp = 32; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32 : - bpp = 32 * 3; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 : - bpp = 32 * 4; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R16 : - bpp = 16; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16 : - bpp = 16 * 3; - break; - case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 : - bpp = 16 * 4; - break; - case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB : - case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA : - case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB : - case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB : - case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB : - case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA : - bpp = 4; - break; - case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA : - case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA : - case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA : - case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA : - bpp = 8; - break; - case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA : - bpp = 2; - break; - default : - break; - } + switch (format) + { + case RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE: bpp = 8; break; + case RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA: + case RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5: + case RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1: + case RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4: bpp = 16; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8: bpp = 32; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8: bpp = 24; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32: bpp = 32; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32: bpp = 32*3; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32: bpp = 32*4; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16: bpp = 16; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16: bpp = 16*3; break; + case RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16: bpp = 16*4; break; + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGB: + case RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA: + case RL_PIXELFORMAT_COMPRESSED_ETC1_RGB: + case RL_PIXELFORMAT_COMPRESSED_ETC2_RGB: + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGB: + case RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA: bpp = 4; break; + case RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA: + case RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA: + case RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA: + case RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA: bpp = 8; break; + case RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA: bpp = 2; break; + default: break; + } - dataSize = width * height * bpp / 8; // Total data size in bytes + dataSize = width*height*bpp/8; // Total data size in bytes - // Most compressed formats works on 4x4 blocks, - // if texture is smaller, minimum dataSize is 8 or 16 - if ( ( width < 4 ) && ( height < 4 ) ) - { - if ( ( format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB ) && ( format < RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA ) ) - dataSize = 8; - else if ( ( format >= RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA ) && ( format < RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA ) ) - dataSize = 16; - } + // Most compressed formats works on 4x4 blocks, + // if texture is smaller, minimum dataSize is 8 or 16 + if ((width < 4) && (height < 4)) + { + if ((format >= RL_PIXELFORMAT_COMPRESSED_DXT1_RGB) && (format < RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA)) dataSize = 8; + else if ((format >= RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA) && (format < RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA)) dataSize = 16; + } - return dataSize; + return dataSize; } // Auxiliar math functions // Get identity matrix -static Matrix rlMatrixIdentity( void ) +static RL_Matrix RLGL_MatrixIdentity(void) { - Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }; + RL_Matrix result = { + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 1.0f + }; - return result; + return result; } // Get two matrix multiplication // NOTE: When multiplying matrices... the order matters! -static Matrix rlMatrixMultiply( Matrix left, Matrix right ) +static RL_Matrix RLGL_MatrixMultiply(RL_Matrix left, RL_Matrix right) { - Matrix result = { 0 }; + RL_Matrix result = { 0 }; - result.m0 = left.m0 * right.m0 + left.m1 * right.m4 + left.m2 * right.m8 + left.m3 * right.m12; - result.m1 = left.m0 * right.m1 + left.m1 * right.m5 + left.m2 * right.m9 + left.m3 * right.m13; - result.m2 = left.m0 * right.m2 + left.m1 * right.m6 + left.m2 * right.m10 + left.m3 * right.m14; - result.m3 = left.m0 * right.m3 + left.m1 * right.m7 + left.m2 * right.m11 + left.m3 * right.m15; - result.m4 = left.m4 * right.m0 + left.m5 * right.m4 + left.m6 * right.m8 + left.m7 * right.m12; - result.m5 = left.m4 * right.m1 + left.m5 * right.m5 + left.m6 * right.m9 + left.m7 * right.m13; - result.m6 = left.m4 * right.m2 + left.m5 * right.m6 + left.m6 * right.m10 + left.m7 * right.m14; - result.m7 = left.m4 * right.m3 + left.m5 * right.m7 + left.m6 * right.m11 + left.m7 * right.m15; - result.m8 = left.m8 * right.m0 + left.m9 * right.m4 + left.m10 * right.m8 + left.m11 * right.m12; - result.m9 = left.m8 * right.m1 + left.m9 * right.m5 + left.m10 * right.m9 + left.m11 * right.m13; - result.m10 = left.m8 * right.m2 + left.m9 * right.m6 + left.m10 * right.m10 + left.m11 * right.m14; - result.m11 = left.m8 * right.m3 + left.m9 * right.m7 + left.m10 * right.m11 + left.m11 * right.m15; - result.m12 = left.m12 * right.m0 + left.m13 * right.m4 + left.m14 * right.m8 + left.m15 * right.m12; - result.m13 = left.m12 * right.m1 + left.m13 * right.m5 + left.m14 * right.m9 + left.m15 * right.m13; - result.m14 = left.m12 * right.m2 + left.m13 * right.m6 + left.m14 * right.m10 + left.m15 * right.m14; - result.m15 = left.m12 * right.m3 + left.m13 * right.m7 + left.m14 * right.m11 + left.m15 * right.m15; + result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12; + result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13; + result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14; + result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15; + result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12; + result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13; + result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14; + result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15; + result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12; + result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13; + result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14; + result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15; + result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12; + result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13; + result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14; + result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15; - return result; + return result; } -#endif // RLGL_IMPLEMENTATION +#endif // RLGL_IMPLEMENTATION diff --git a/project/auxillary/vis_ast/dependencies/raylib/include/utils.h b/project/auxillary/vis_ast/dependencies/raylib/include/utils.h index 7e959b2..397a4af 100644 --- a/project/auxillary/vis_ast/dependencies/raylib/include/utils.h +++ b/project/auxillary/vis_ast/dependencies/raylib/include/utils.h @@ -1,55 +1,55 @@ /********************************************************************************************** - * - * raylib.utils - Some common utility functions - * - * - * LICENSE: zlib/libpng - * - * Copyright (c) 2014-2023 Ramon Santamaria (@raysan5) - * - * This software is provided "as-is", without any express or implied warranty. In no event - * will the authors be held liable for any damages arising from the use of this software. - * - * Permission is granted to anyone to use this software for any purpose, including commercial - * applications, and to alter it and redistribute it freely, subject to the following restrictions: - * - * 1. The origin of this software must not be misrepresented; you must not claim that you - * wrote the original software. If you use this software in a product, an acknowledgment - * in the product documentation would be appreciated but is not required. - * - * 2. Altered source versions must be plainly marked as such, and must not be misrepresented - * as being the original software. - * - * 3. This notice may not be removed or altered from any source distribution. - * - **********************************************************************************************/ +* +* raylib.utils - Some common utility functions +* +* +* LICENSE: zlib/libpng +* +* Copyright (c) 2014-2023 Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ #ifndef UTILS_H #define UTILS_H -#if defined( PLATFORM_ANDROID ) -#include // Required for: FILE -#include // Required for: AAssetManager +#if defined(PLATFORM_ANDROID) + #include // Required for: FILE + #include // Required for: AAssetManager #endif -#if defined( SUPPORT_TRACELOG ) -#define TRACELOG( level, ... ) TraceLog( level, __VA_ARGS__ ) +#if defined(RL_SUPPORT_TRACELOG) + #define RL_TRACELOG(level, ...) RL_TraceLog(level, __VA_ARGS__) -#if defined( SUPPORT_TRACELOG_DEBUG ) -#define TRACELOGD( ... ) TraceLog( LOG_DEBUG, __VA_ARGS__ ) + #if defined(RL_SUPPORT_TRACELOG_DEBUG) + #define TRACELOGD(...) RL_TraceLog(RL_LOG_DEBUG, __VA_ARGS__) + #else + #define TRACELOGD(...) (void)0 + #endif #else -#define TRACELOGD( ... ) ( void )0 -#endif -#else -#define TRACELOG( level, ... ) ( void )0 -#define TRACELOGD( ... ) ( void )0 + #define RL_TRACELOG(level, ...) (void)0 + #define TRACELOGD(...) (void)0 #endif //---------------------------------------------------------------------------------- // Some basic Defines //---------------------------------------------------------------------------------- -#if defined( PLATFORM_ANDROID ) -#define fopen( name, mode ) android_fopen( name, mode ) +#if defined(PLATFORM_ANDROID) + #define fopen(name, mode) android_fopen(name, mode) #endif //---------------------------------------------------------------------------------- @@ -65,18 +65,17 @@ //---------------------------------------------------------------------------------- // Module Functions Declaration //---------------------------------------------------------------------------------- -#if defined( __cplusplus ) -extern "C" -{ // Prevents name mangling of functions +#if defined(__cplusplus) +extern "C" { // Prevents name mangling of functions #endif -#if defined( PLATFORM_ANDROID ) - void InitAssetManager( AAssetManager* manager, const char* dataPath ); // Initialize asset manager from android app - FILE* android_fopen( const char* fileName, const char* mode ); // Replacement for fopen() -> Read-only! +#if defined(PLATFORM_ANDROID) +void InitAssetManager(AAssetManager *manager, const char *dataPath); // Initialize asset manager from android app +FILE *android_fopen(const char *fileName, const char *mode); // Replacement for fopen() -> Read-only! #endif -#if defined( __cplusplus ) +#if defined(__cplusplus) } #endif -#endif // UTILS_H +#endif // UTILS_H diff --git a/project/auxillary/vis_ast/dependencies/raylib/raylib.refactor b/project/auxillary/vis_ast/dependencies/raylib/raylib.refactor deleted file mode 100644 index 21068a2..0000000 --- a/project/auxillary/vis_ast/dependencies/raylib/raylib.refactor +++ /dev/null @@ -1,9 +0,0 @@ - __VERSION 1 - - -word SUPPORT_MODULE_RSHAPES, RL_SUPPORT_MODULE_RSHAPES -word SUPPORT_MODULE_RTEXTURES, RL_SUPPORT_MODULE_RTEXTURES -word SUPPORT_MODULE_RTEXT, RL_SUPPORT_MODULE_RTEXT -word SUPPORT_MODULE_RMODELS, RL_SUPPORT_MODULE_RMODELS -word SUPPORT_MODULE_RAUDIO, RL_SUPPORT_MODULE_RAUDIO - diff --git a/project/auxillary/vis_ast/dependencies/raylib/raylib_c.refactor b/project/auxillary/vis_ast/dependencies/raylib/raylib_c.refactor new file mode 100644 index 0000000..1dbc3ac --- /dev/null +++ b/project/auxillary/vis_ast/dependencies/raylib/raylib_c.refactor @@ -0,0 +1,1340 @@ + __VERSION 1 + + +// Config.h +word CONFIG_H, RL_CONFIG_H + +word SUPPORT_MODULE_RSHAPES, RL_SUPPORT_MODULE_RSHAPES +word SUPPORT_MODULE_RTEXTURES, RL_SUPPORT_MODULE_RTEXTURES +word SUPPORT_MODULE_RTEXT, RL_SUPPORT_MODULE_RTEXT +word SUPPORT_MODULE_RMODELS, RL_SUPPORT_MODULE_RMODELS +word SUPPORT_MODULE_RAUDIO, RL_SUPPORT_MODULE_RAUDIO +word SUPPORT_CAMERA_SYSTEM, RL_SUPPORT_CAMERA_SYSTEM +word SUPPORT_GESTURES_SYSTEM, RL_SUPPORT_GESTURES_SYSTEM +word SUPPORT_MOUSE_GESTURES, RL_SUPPORT_MOUSE_GESTURES +word SUPPORT_SSH_KEYBOARD_RPI, RL_SUPPORT_SSH_KEYBOARD_RPI +word SUPPORT_WINMM_HIGHRES_TIMER, RL_SUPPORT_WINMM_HIGHRES_TIMER +word SUPPORT_PARTIALBUSY_WAIT_LOOP, RL_SUPPORT_PARTIALBUSY_WAIT_LOOP +word SUPPORT_SCREEN_CAPTURE, RL_SUPPORT_SCREEN_CAPTURE +word SUPPORT_GIF_RECORDING, RL_SUPPORT_GIF_RECORDING +word SUPPORT_COMPRESSION_API, RL_SUPPORT_COMPRESSION_API +word SUPPORT_AUTOMATION_EVENTS, RL_SUPPORT_AUTOMATION_EVENTS + +word MAX_FILEPATH_CAPACITY, RL_MAX_FILEPATH_CAPACITY +word MAX_FILEPATH_LENGTH, RL_MAX_FILEPATH_LENGTH +word MAX_KEYBOARD_KEYS, RL_MAX_KEYBOARD_KEYS +word MAX_MOUSE_BUTTONS, RL_MAX_MOUSE_BUTTONS +word MAX_GAMEPADS, RL_MAX_GAMEPADS +word MAX_GAMEPAD_AXIS, RL_MAX_GAMEPAD_AXIS +word MAX_GAMEPAD_BUTTONS, RL_MAX_GAMEPAD_BUTTONS +word MAX_TOUCH_POINTS, RL_MAX_TOUCH_POINTS +word MAX_KEY_PRESSED_QUEUE, RL_MAX_KEY_PRESSED_QUEUE +word MAX_CHAR_PRESSED_QUEUE, RL_MAX_CHAR_PRESSED_QUEUE +word MAX_DECOMPRESSION_SIZE, RL_MAX_DECOMPRESSION_SIZE +word MAX_AUTOMATION_EVENTS, RL_MAX_AUTOMATION_EVENTS + +word SUPPORT_QUADS_DRAW_MODE, RL_SUPPORT_QUADS_DRAW_MODE +word SUPPORT_FILEFORMAT_PNG, RL_SUPPORT_FILEFORMAT_PNG +word SUPPORT_FILEFORMAT_BMP, RL_SUPPORT_FILEFORMAT_BMP +word SUPPORT_FILEFORMAT_TGA, RL_SUPPORT_FILEFORMAT_TGA +word SUPPORT_FILEFORMAT_JPG, RL_SUPPORT_FILEFORMAT_JPG +word SUPPORT_FILEFORMAT_GIF, RL_SUPPORT_FILEFORMAT_GIF +word SUPPORT_FILEFORMAT_QOI, RL_SUPPORT_FILEFORMAT_QOI +word SUPPORT_FILEFORMAT_PSD, RL_SUPPORT_FILEFORMAT_PSD +word SUPPORT_FILEFORMAT_DDS, RL_SUPPORT_FILEFORMAT_DDS +word SUPPORT_FILEFORMAT_HDR, RL_SUPPORT_FILEFORMAT_HDR +word SUPPORT_FILEFORMAT_PIC, RL_SUPPORT_FILEFORMAT_PIC +word SUPPORT_FILEFORMAT_KTX, RL_SUPPORT_FILEFORMAT_KTX +word SUPPORT_FILEFORMAT_ASTC, RL_SUPPORT_FILEFORMAT_ASTC +word SUPPORT_FILEFORMAT_PKM, RL_SUPPORT_FILEFORMAT_PKM +word SUPPORT_FILEFORMAT_PVR, RL_SUPPORT_FILEFORMAT_PVR +word SUPPORT_FILEFORMAT_SVG, RL_SUPPORT_FILEFORMAT_SVG +word SUPPORT_IMAGE_EXPORT, RL_SUPPORT_IMAGE_EXPORT +word SUPPORT_IMAGE_GENERATION, RL_SUPPORT_IMAGE_GENERATION +word SUPPORT_IMAGE_MANIPULATION, RL_SUPPORT_IMAGE_MANIPULATION +word SUPPORT_DEFAULT_FONT, RL_SUPPORT_DEFAULT_FONT +word SUPPORT_FILEFORMAT_FNT, RL_SUPPORT_FILEFORMAT_FNT +word SUPPORT_FILEFORMAT_TTF, RL_SUPPORT_FILEFORMAT_TTF +word SUPPORT_TEXT_MANIPULATION, RL_SUPPORT_TEXT_MANIPULATION +word SUPPORT_FONT_ATLAS_WHITE_REC, RL_SUPPORT_FONT_ATLAS_WHITE_REC + +word MAX_TEXT_BUFFER_LENGTH, RL_MAX_TEXT_BUFFER_LENGTH +word MAX_TEXTSPLIT_COUNT, RL_MAX_TEXTSPLIT_COUNT + +word SUPPORT_FILEFORMAT_OBJ, RL_SUPPORT_FILEFORMAT_OBJ; +word SUPPORT_FILEFORMAT_MTL, RL_SUPPORT_FILEFORMAT_MTL; +word SUPPORT_FILEFORMAT_IQM, RL_SUPPORT_FILEFORMAT_IQM; +word SUPPORT_FILEFORMAT_GLTF, RL_SUPPORT_FILEFORMAT_GLTF; +word SUPPORT_FILEFORMAT_VOX, RL_SUPPORT_FILEFORMAT_VOX; +word SUPPORT_FILEFORMAT_M3D, RL_SUPPORT_FILEFORMAT_M3D; +word SUPPORT_MESH_GENERATION, RL_SUPPORT_MESH_GENERATION; + +word MAX_MATERIAL_MAPS, RL_MAX_MATERIAL_MAPS +word MAX_MESH_VERTEX_BUFFERS, RL_MAX_MESH_VERTEX_BUFFERS + +word SUPPORT_FILEFORMAT_WAV, RL_SUPPORT_FILEFORMAT_WAV +word SUPPORT_FILEFORMAT_OGG, RL_SUPPORT_FILEFORMAT_OGG +word SUPPORT_FILEFORMAT_MP3, RL_SUPPORT_FILEFORMAT_MP3 +word SUPPORT_FILEFORMAT_QOA, RL_SUPPORT_FILEFORMAT_QOA +word SUPPORT_FILEFORMAT_FLAC, RL_SUPPORT_FILEFORMAT_FLAC +word SUPPORT_FILEFORMAT_XM, RL_SUPPORT_FILEFORMAT_XM +word SUPPORT_FILEFORMAT_MOD, RL_SUPPORT_FILEFORMAT_MOD + +word AUDIO_DEVICE_FORMAT, RL_AUDIO_DEVICE_FORMAT +word AUDIO_DEVICE_CHANNELS, RL_AUDIO_DEVICE_CHANNELS +word AUDIO_DEVICE_SAMPLE_RATE, RL_AUDIO_DEVICE_SAMPLE_RATE + +word MAX_AUDIO_BUFFER_POOL_CHANNELS, RL_MAX_AUDIO_BUFFER_POOL_CHANNELS + +word SUPPORT_STANDARD_FILEIO, RL_SUPPORT_STANDARD_FILEIO +word SUPPORT_TRACELOG, RL_SUPPORT_TRACELOG +word SUPPORT_TRACELOG_DEBUG, RL_SUPPORT_TRACELOG_DEBUG + +word MAX_TRACELOG_MSG_LENGTH, RL_MAX_TRACELOG_MSG_LENGTH + +// raylib.h + +word BUILD_LIBTYPE_SHARED, RL_BUILD_LIBTYPE_SHARED +word USE_LIBTYPE_SHARED, RL_USE_LIBTYPE_SHARED +word PI, RL_PI +word DEG2RAD, RL_DEG2RAD +word RAD2DEG, RL_RAD2DEG + +word CLITERAL, RL_CLITERAL + +word LIGHTGRAY, RL_LIGHTGRAY +word GRAY, RL_GRAY +word DARKGRAY, RL_DARKGRAY +word YELLOW, RL_YELLOW +word GOLD, RL_GOLD +word ORANGE, RL_ORANGE +word PINK, RL_PINK +word RED, RL_RED +word MAROON, RL_MAROON +word GREEN, RL_GREEN +word LIME, RL_LIME +word DARKGREEN, RL_DARKGREEN +word SKYBLUE, RL_SKYBLUE +word BLUE, RL_BLUE +word DARKBLUE, RL_DARKBLUE +word PURPLE, RL_PURPLE +word VIOLET, RL_VIOLET +word DARKPURPLE, RL_DARKPURPLE +word BEIGE, RL_BEIGE +word BROWN, RL_BROWN +word DARKBROWN, RL_DARKBROWN + +word WHITE, RL_WHITE +word BLACK, RL_BLACK +word BLANK, RL_BLANK +word MAGENTA, RL_MAGENTA +word RAYWHITE, RL_RAYWHITE + +word Vector2, RL_Vector2 +word Vector3, RL_Vector3 +word Vector4, RL_Vector4 +word Quaternion, RL_Quaternion +word Matrix, RL_Matrix +word Color, RL_Color +word Rectangle, RL_Rectangle +word Image, RL_Image +word Texture, RL_Texture +word Texture2D, RL_Texture2D +word TextureCubemap, RL_TextureCubemap +word RenderTexture, RL_RenderTexture +word RenderTexture2D, RL_RenderTexture2D +word NPatchInfo, RL_NPatchInfo +word GlyphInfo, RL_GlyphInfo +word Font, RL_Font +word Camera3D, RL_Camera3D +word Camera, RL_Camera +word Camera2D, RL_Camera2D +word Mesh, RL_Mesh +word Shader, RL_Shader +word MaterialMap, RL_MaterialMap +word Material, RL_Material +word Transform, RL_Transform +word BoneInfo, RL_BoneInfo +word Model, RL_Model +word ModelAnimation, RL_ModelAnimation +word Ray, RL_Ray +word RayCollision, RL_RayCollision +word BoundingBox, RL_BoundingBox +word Wave, RL_Wave +word rAudioBuffer, RL_AudioBuffer +word rAudioProcessor, RL_AudioProcessor +word AudioStream, RL_AudioStream +word Sound, RL_Sound +word Music, RL_Music +word VrDeviceInfo, RL_VrDeviceInfo +word VrStereoConfig, RL_VrStereoConfig +word FilePathList, RL_FilePathList +word AutomationEvent, RL_AutomationEvent +word AutomationEventList, RL_AutomationEventList + +word ConfigFlags, RL_ConfigFlags + word FLAG_VSYNC_HINT, RL_FLAG_VSYNC_HINT + word FLAG_FULLSCREEN_MODE, RL_FLAG_FULLSCREEN_MODE + word FLAG_WINDOW_RESIZABLE, RL_FLAG_WINDOW_RESIZABLE + word FLAG_WINDOW_UNDECORATED, RL_FLAG_WINDOW_UNDECORATED + word FLAG_WINDOW_HIDDEN, RL_FLAG_WINDOW_HIDDEN + word FLAG_WINDOW_MINIMIZED, RL_FLAG_WINDOW_MINIMIZED + word FLAG_WINDOW_MAXIMIZED, RL_FLAG_WINDOW_MAXIMIZED + word FLAG_WINDOW_UNFOCUSED, RL_FLAG_WINDOW_UNFOCUSED + word FLAG_WINDOW_TOPMOST, RL_FLAG_WINDOW_TOPMOST + word FLAG_WINDOW_ALWAYS_RUN, RL_FLAG_WINDOW_ALWAYS_RUN + word FLAG_WINDOW_TRANSPARENT, RL_FLAG_WINDOW_TRANSPARENT + word FLAG_WINDOW_HIGHDPI, RL_FLAG_WINDOW_HIGHDPI + word FLAG_WINDOW_MOUSE_PASSTHROUGH, RL_FLAG_WINDOW_MOUSE_PASSTHROUGH + word FLAG_BORDERLESS_WINDOWED_MODE, RL_FLAG_BORDERLESS_WINDOWED_MODE + word FLAG_MSAA_4X_HINT, RL_FLAG_MSAA_4X_HINT + word FLAG_INTERLACED_HINT, RL_FLAG_INTERLACED_HINT +word TraceLogLevel, RL_TraceLogLevel + word LOG_ALL, RL_LOG_ALL + word LOG_TRACE, RL_LOG_TRACE + word LOG_DEBUG, RL_LOG_DEBUG + word LOG_INFO, RL_LOG_INFO + word LOG_WARNING, RL_LOG_WARNING + word LOG_ERROR, RL_LOG_ERROR + word LOG_FATAL, RL_LOG_FATAL + word LOG_NONE, RL_LOG_NONE +word KeyboardKey, RL_KeyboardKey + word KEY_NULL, RL_KEY_NULL + word KEY_APOSTROPHE, RL_KEY_APOSTROPHE + word KEY_COMMA, RL_KEY_COMMA + word KEY_MINUS, RL_KEY_MINUS + word KEY_PERIOD, RL_KEY_PERIOD + word KEY_SLASH, RL_KEY_SLASH + word KEY_ZERO, RL_KEY_ZERO + word KEY_ONE, RL_KEY_ONE + word KEY_TWO, RL_KEY_TWO + word KEY_THREE, RL_KEY_THREE + word KEY_FOUR, RL_KEY_FOUR + word KEY_FIVE, RL_KEY_FIVE + word KEY_SIX, RL_KEY_SIX + word KEY_SEVEN, RL_KEY_SEVEN + word KEY_EIGHT, RL_KEY_EIGHT + word KEY_NINE, RL_KEY_NINE + word KEY_SEMICOLON, RL_KEY_SEMICOLON + word KEY_EQUAL, RL_KEY_EQUAL + word KEY_A, RL_KEY_A + word KEY_B, RL_KEY_B + word KEY_C, RL_KEY_C + word KEY_D, RL_KEY_D + word KEY_E, RL_KEY_E + word KEY_F, RL_KEY_F + word KEY_G, RL_KEY_G + word KEY_H, RL_KEY_H + word KEY_I, RL_KEY_I + word KEY_J, RL_KEY_J + word KEY_K, RL_KEY_K + word KEY_L, RL_KEY_L + word KEY_M, RL_KEY_M + word KEY_N, RL_KEY_N + word KEY_O, RL_KEY_O + word KEY_P, RL_KEY_P + word KEY_Q, RL_KEY_Q + word KEY_R, RL_KEY_R + word KEY_S, RL_KEY_S + word KEY_T, RL_KEY_T + word KEY_U, RL_KEY_U + word KEY_V, RL_KEY_V + word KEY_W, RL_KEY_W + word KEY_X, RL_KEY_X + word KEY_Y, RL_KEY_Y + word KEY_Z, RL_KEY_Z + word KEY_LEFT_BRACKET, RL_KEY_LEFT_BRACKET + word KEY_GRAVE, RL_KEY_GRAVE + word KEY_SPACE, RL_KEY_SPACE + word KEY_ESCAPE, RL_KEY_ESCAPE + word KEY_ENTER, RL_KEY_ENTER + word KEY_TAB, RL_KEY_TAB + word KEY_BACKSPACE, RL_KEY_BACKSPACE + word KEY_INSERT, RL_KEY_INSERT + word KEY_DELETE, RL_KEY_DELETE + word KEY_RIGHT, RL_KEY_RIGHT + word KEY_LEFT, RL_KEY_LEFT + word KEY_DOWN, RL_KEY_DOWN + word KEY_UP, RL_KEY_UP + word KEY_PAGE_UP, RL_KEY_PAGE_UP + word KEY_PAGE_DOWN, RL_KEY_PAGE_DOWN + word KEY_HOME, RL_KEY_HOME + word KEY_END, RL_KEY_END + word KEY_CAPS_LOCK, RL_KEY_CAPS_LOCK + word KEY_SCROLL_LOCK, RL_KEY_SCROLL_LOCK + word KEY_NUM_LOCK, RL_KEY_NUM_LOCK + word KEY_PRINT_SCREEN, RL_KEY_PRINT_SCREEN + word KEY_PAUSE, RL_KEY_PAUSE + word KEY_F1, RL_KEY_F1 + word KEY_F2, RL_KEY_F2 + word KEY_F3, RL_KEY_F3 + word KEY_F4, RL_KEY_F4 + word KEY_F5, RL_KEY_F5 + word KEY_F6, RL_KEY_F6 + word KEY_F7, RL_KEY_F7 + word KEY_F8, RL_KEY_F8 + word KEY_F9, RL_KEY_F9 + word KEY_F10, RL_KEY_F10 + word KEY_F11, RL_KEY_F11 + word KEY_F12, RL_KEY_F12 + word KEY_LEFT_SHIFT, RL_KEY_LEFT_SHIFT + word KEY_LEFT_CONTROL, RL_KEY_LEFT_CONTROL + word KEY_LEFT_ALT, RL_KEY_LEFT_ALT + word KEY_LEFT_SUPER, RL_KEY_LEFT_SUPER + word KEY_RIGHT_SHIFT, RL_KEY_RIGHT_SHIFT + word KEY_RIGHT_CONTROL, RL_KEY_RIGHT_CONTROL + word KEY_RIGHT_ALT, RL_KEY_RIGHT_ALT + word KEY_RIGHT_SUPER, RL_KEY_RIGHT_SUPER + word KEY_KB_MENU, RL_KEY_KB_MENU + word KEY_KP_0, RL_KEY_KP_0 + word KEY_KP_1, RL_KEY_KP_1 + word KEY_KP_2, RL_KEY_KP_2 + word KEY_KP_3, RL_KEY_KP_3 + word KEY_KP_4, RL_KEY_KP_4 + word KEY_KP_5, RL_KEY_KP_5 + word KEY_KP_6, RL_KEY_KP_6 + word KEY_KP_7, RL_KEY_KP_7 + word KEY_KP_8, RL_KEY_KP_8 + word KEY_KP_9, RL_KEY_KP_9 + word KEY_KP_DECIMAL, RL_KEY_KP_DECIMAL + word KEY_KP_DIVIDE, RL_KEY_KP_DIVIDE + word KEY_KP_MULTIPLY, RL_KEY_KP_MULTIPLY + word KEY_KP_SUBTRACT, RL_KEY_KP_SUBTRACT + word KEY_KP_ADD, RL_KEY_KP_ADD + word KEY_KP_ENTER, RL_KEY_KP_ENTER + word KEY_KP_EQUAL, RL_KEY_KP_EQUAL + word KEY_BACK, RL_KEY_BACK + word KEY_MENU, RL_KEY_MENU + word KEY_VOLUME_UP, RL_KEY_VOLUME_UP + word KEY_VOLUME_DOWN, RL_KEY_VOLUME_DOWN +word MouseButton, RL_MouseButton + word MOUSE_BUTTON_LEFT, RL_MOUSE_BUTTON_LEFT + word MOUSE_BUTTON_RIGHT, RL_MOUSE_BUTTON_RIGHT + word MOUSE_BUTTON_MIDDLE, RL_MOUSE_BUTTON_MIDDLE + word MOUSE_BUTTON_SIDE, RL_MOUSE_BUTTON_SIDE + word MOUSE_BUTTON_EXTRA, RL_MOUSE_BUTTON_EXTRA + word MOUSE_BUTTON_FORWARD, RL_MOUSE_BUTTON_FORWARD + word MOUSE_BUTTON_BACK, RL_MOUSE_BUTTON_BACK + word MOUSE_LEFT_BUTTON, RL_MOUSE_LEFT_BUTTON + word MOUSE_RIGHT_BUTTON, RL_MOUSE_RIGHT_BUTTON + word MOUSE_MIDDLE_BUTTON, RL_MOUSE_MIDDLE_BUTTON +word MouseCursor, RL_MouseCursor + word MOUSE_CURSOR_DEFAULT, RL_MOUSE_CURSOR_DEFAULT + word MOUSE_CURSOR_ARROW, RL_MOUSE_CURSOR_ARROW + word MOUSE_CURSOR_IBEAM, RL_MOUSE_CURSOR_IBEAM + word MOUSE_CURSOR_CROSSHAIR, RL_MOUSE_CURSOR_CROSSHAIR + word MOUSE_CURSOR_POINTING_HAND, RL_MOUSE_CURSOR_POINTING_HAND + word MOUSE_CURSOR_RESIZE_EW, RL_MOUSE_CURSOR_RESIZE_EW + word MOUSE_CURSOR_RESIZE_NS, RL_MOUSE_CURSOR_RESIZE_NS + word MOUSE_CURSOR_RESIZE_NWSE, RL_MOUSE_CURSOR_RESIZE_NWSE + word MOUSE_CURSOR_RESIZE_NESW, RL_MOUSE_CURSOR_RESIZE_NESW + word MOUSE_CURSOR_RESIZE_ALL, RL_MOUSE_CURSOR_RESIZE_ALL + word MOUSE_CURSOR_NOT_ALLOWED, RL_MOUSE_CURSOR_NOT_ALLOWED +word GamepadButton, RL_GamepadButton + word GAMEPAD_BUTTON_UNKNOWN, RL_GAMEPAD_BUTTON_UNKNOWN + word GAMEPAD_BUTTON_LEFT_FACE_UP, RL_GAMEPAD_BUTTON_LEFT_FACE_UP + word GAMEPAD_BUTTON_LEFT_FACE_RIGHT, RL_GAMEPAD_BUTTON_LEFT_FACE_RIGHT + word GAMEPAD_BUTTON_LEFT_FACE_DOWN, RL_GAMEPAD_BUTTON_LEFT_FACE_DOWN + word GAMEPAD_BUTTON_LEFT_FACE_LEFT, RL_GAMEPAD_BUTTON_LEFT_FACE_LEFT + word GAMEPAD_BUTTON_RIGHT_FACE_UP, RL_GAMEPAD_BUTTON_RIGHT_FACE_UP + word GAMEPAD_BUTTON_RIGHT_FACE_RIGHT, RL_GAMEPAD_BUTTON_RIGHT_FACE_RIGHT + word GAMEPAD_BUTTON_RIGHT_FACE_DOWN, RL_GAMEPAD_BUTTON_RIGHT_FACE_DOWN + word GAMEPAD_BUTTON_RIGHT_FACE_LEFT, RL_GAMEPAD_BUTTON_RIGHT_FACE_LEFT + word GAMEPAD_BUTTON_LEFT_TRIGGER_1, RL_GAMEPAD_BUTTON_LEFT_TRIGGER_1 + word GAMEPAD_BUTTON_LEFT_TRIGGER_2, RL_GAMEPAD_BUTTON_LEFT_TRIGGER_2 + word GAMEPAD_BUTTON_RIGHT_TRIGGER_1, RL_GAMEPAD_BUTTON_RIGHT_TRIGGER_1 + word GAMEPAD_BUTTON_RIGHT_TRIGGER_2, RL_GAMEPAD_BUTTON_RIGHT_TRIGGER_2 + word GAMEPAD_BUTTON_MIDDLE_LEFT, RL_GAMEPAD_BUTTON_MIDDLE_LEFT + word GAMEPAD_BUTTON_MIDDLE, RL_GAMEPAD_BUTTON_MIDDLE + word GAMEPAD_BUTTON_MIDDLE_RIGHT, RL_GAMEPAD_BUTTON_MIDDLE_RIGHT + word GAMEPAD_BUTTON_LEFT_THUMB, RL_GAMEPAD_BUTTON_LEFT_THUMB + word GAMEPAD_BUTTON_RIGHT_THUMB, RL_GAMEPAD_BUTTON_RIGHT_THUMB +word GamepadAxis, RL_GamepadAxis + word GAMEPAD_AXIS_LEFT_X, RL_GAMEPAD_AXIS_LEFT_X + word GAMEPAD_AXIS_LEFT_Y, RL_GAMEPAD_AXIS_LEFT_Y + word GAMEPAD_AXIS_RIGHT_X, RL_GAMEPAD_AXIS_RIGHT_X + word GAMEPAD_AXIS_RIGHT_Y, RL_GAMEPAD_AXIS_RIGHT_Y + word GAMEPAD_AXIS_LEFT_TRIGGER, RL_GAMEPAD_AXIS_LEFT_TRIGGER + word GAMEPAD_AXIS_RIGHT_TRIGGER, RL_GAMEPAD_AXIS_RIGHT_TRIGGER +word MaterialMapIndex, RL_MaterialMapIndex + word MATERIAL_MAP_ALBEDO, RL_MATERIAL_MAP_ALBEDO + word MATERIAL_MAP_METALNESS, RL_MATERIAL_MAP_METALNESS + word MATERIAL_MAP_NORMAL, RL_MATERIAL_MAP_NORMAL + word MATERIAL_MAP_ROUGHNESS, RL_MATERIAL_MAP_ROUGHNESS + word MATERIAL_MAP_OCCLUSION, RL_MATERIAL_MAP_OCCLUSION + word MATERIAL_MAP_EMISSION, RL_MATERIAL_MAP_EMISSION + word MATERIAL_MAP_HEIGHT, RL_MATERIAL_MAP_HEIGHT + word MATERIAL_MAP_CUBEMAP, RL_MATERIAL_MAP_CUBEMAP + word MATERIAL_MAP_IRRADIANCE, RL_MATERIAL_MAP_IRRADIANCE + word MATERIAL_MAP_PREFILTER, RL_MATERIAL_MAP_PREFILTER + word MATERIAL_MAP_BRDF, RL_MATERIAL_MAP_BRDF + word MATERIAL_MAP_DIFFUSE, RL_MATERIAL_MAP_DIFFUSE + word MATERIAL_MAP_SPECULAR, RL_MATERIAL_MAP_SPECULAR +word ShaderLocationIndex, RL_ShaderLocationIndex + word SHADER_LOC_VERTEX_POSITION, RL_SHADER_LOC_VERTEX_POSITION + word SHADER_LOC_VERTEX_TEXCOORD01, RL_SHADER_LOC_VERTEX_TEXCOORD01 + word SHADER_LOC_VERTEX_TEXCOORD02, RL_SHADER_LOC_VERTEX_TEXCOORD02 + word SHADER_LOC_VERTEX_NORMAL, RL_SHADER_LOC_VERTEX_NORMAL + word SHADER_LOC_VERTEX_TANGENT, RL_SHADER_LOC_VERTEX_TANGENT + word SHADER_LOC_VERTEX_COLOR, RL_SHADER_LOC_VERTEX_COLOR + word SHADER_LOC_MATRIX_MVP, RL_SHADER_LOC_MATRIX_MVP + word SHADER_LOC_MATRIX_VIEW, RL_SHADER_LOC_MATRIX_VIEW + word SHADER_LOC_MATRIX_PROJECTION, RL_SHADER_LOC_MATRIX_PROJECTION + word SHADER_LOC_MATRIX_MODEL, RL_SHADER_LOC_MATRIX_MODEL + word SHADER_LOC_MATRIX_NORMAL, RL_SHADER_LOC_MATRIX_NORMAL + word SHADER_LOC_VECTOR_VIEW, RL_SHADER_LOC_VECTOR_VIEW + word SHADER_LOC_COLOR_DIFFUSE, RL_SHADER_LOC_COLOR_DIFFUSE + word SHADER_LOC_COLOR_SPECULAR, RL_SHADER_LOC_COLOR_SPECULAR + word SHADER_LOC_COLOR_AMBIENT, RL_SHADER_LOC_COLOR_AMBIENT + word SHADER_LOC_MAP_ALBEDO, RL_SHADER_LOC_MAP_ALBEDO + word SHADER_LOC_MAP_METALNESS, RL_SHADER_LOC_MAP_METALNESS + word SHADER_LOC_MAP_NORMAL, RL_SHADER_LOC_MAP_NORMAL + word SHADER_LOC_MAP_ROUGHNESS, RL_SHADER_LOC_MAP_ROUGHNESS + word SHADER_LOC_MAP_OCCLUSION, RL_SHADER_LOC_MAP_OCCLUSION + word SHADER_LOC_MAP_EMISSION, RL_SHADER_LOC_MAP_EMISSION + word SHADER_LOC_MAP_HEIGHT, RL_SHADER_LOC_MAP_HEIGHT + word SHADER_LOC_MAP_CUBEMAP, RL_SHADER_LOC_MAP_CUBEMAP + word SHADER_LOC_MAP_IRRADIANCE, RL_SHADER_LOC_MAP_IRRADIANCE + word SHADER_LOC_MAP_PREFILTER, RL_SHADER_LOC_MAP_PREFILTER + word SHADER_LOC_MAP_BRDF, RL_SHADER_LOC_MAP_BRDF + word SHADER_LOC_MAP_DIFFUSE, RL_SHADER_LOC_MAP_DIFFUSE + word SHADER_LOC_MAP_SPECULAR, RL_SHADER_LOC_MAP_SPECULAR +word ShaderUniformDataType, RL_ShaderUniformDataType + word SHADER_UNIFORM_FLOAT, RL_SHADER_UNIFORM_FLOAT + word SHADER_UNIFORM_VEC2, RL_SHADER_UNIFORM_VEC2 + word SHADER_UNIFORM_VEC3, RL_SHADER_UNIFORM_VEC3 + word SHADER_UNIFORM_VEC4, RL_SHADER_UNIFORM_VEC4 + word SHADER_UNIFORM_INT, RL_SHADER_UNIFORM_INT + word SHADER_UNIFORM_IVEC2, RL_SHADER_UNIFORM_IVEC2 + word SHADER_UNIFORM_IVEC3, RL_SHADER_UNIFORM_IVEC3 + word SHADER_UNIFORM_IVEC4, RL_SHADER_UNIFORM_IVEC4 + word SHADER_UNIFORM_SAMPLER2D, RL_SHADER_UNIFORM_SAMPLER2D +word ShaderAttributeDataType, RL_ShaderAttributeDataType + word SHADER_ATTRIB_FLOAT, RL_SHADER_ATTRIB_FLOAT + word SHADER_ATTRIB_VEC2, RL_SHADER_ATTRIB_VEC2 + word SHADER_ATTRIB_VEC3, RL_SHADER_ATTRIB_VEC3 + word SHADER_ATTRIB_VEC4, RL_SHADER_ATTRIB_VEC4 +word PixelFormat, RL_PixelFormat + word PIXELFORMAT_UNCOMPRESSED_GRAYSCALE, RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE + word PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA + word PIXELFORMAT_UNCOMPRESSED_R5G6B5, RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5 + word PIXELFORMAT_UNCOMPRESSED_R8G8B8, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8 + word PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 + word PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 + word PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 + word PIXELFORMAT_UNCOMPRESSED_R32, RL_PIXELFORMAT_UNCOMPRESSED_R32 + word PIXELFORMAT_UNCOMPRESSED_R32G32B32, RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32 + word PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 + word PIXELFORMAT_UNCOMPRESSED_R16, RL_PIXELFORMAT_UNCOMPRESSED_R16 + word PIXELFORMAT_UNCOMPRESSED_R16G16B16, RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16 + word PIXELFORMAT_UNCOMPRESSED_R16G16B16A16, RL_PIXELFORMAT_UNCOMPRESSED_R16G16B16A16 + word PIXELFORMAT_COMPRESSED_DXT1_RGB, RL_PIXELFORMAT_COMPRESSED_DXT1_RGB + word PIXELFORMAT_COMPRESSED_DXT1_RGBA, RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA + word PIXELFORMAT_COMPRESSED_DXT3_RGBA, RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA + word PIXELFORMAT_COMPRESSED_DXT5_RGBA, RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA + word PIXELFORMAT_COMPRESSED_ETC1_RGB, RL_PIXELFORMAT_COMPRESSED_ETC1_RGB + word PIXELFORMAT_COMPRESSED_ETC2_RGB, RL_PIXELFORMAT_COMPRESSED_ETC2_RGB + word PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA + word PIXELFORMAT_COMPRESSED_PVRT_RGB, RL_PIXELFORMAT_COMPRESSED_PVRT_RGB + word PIXELFORMAT_COMPRESSED_PVRT_RGBA, RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA + word PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA + word PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA, RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA +word TextureFilter, RL_TextureFilter + word TEXTURE_FILTER_POINT, RL_TEXTURE_FILTER_POINT + word TEXTURE_FILTER_BILINEAR, RL_TEXTURE_FILTER_BILINEAR + word TEXTURE_FILTER_TRILINEAR, RL_TEXTURE_FILTER_TRILINEAR + word TEXTURE_FILTER_ANISOTROPIC_4X, RL_TEXTURE_FILTER_ANISOTROPIC_4X + word TEXTURE_FILTER_ANISOTROPIC_8X, RL_TEXTURE_FILTER_ANISOTROPIC_8X + word TEXTURE_FILTER_ANISOTROPIC_16X, RL_TEXTURE_FILTER_ANISOTROPIC_16X +word TextureWrap, RL_TextureWrap + word TEXTURE_WRAP_REPEAT, RL_TEXTURE_WRAP_REPEAT + word TEXTURE_WRAP_CLAMP, RL_TEXTURE_WRAP_CLAMP + word TEXTURE_WRAP_MIRROR_REPEAT, RL_TEXTURE_WRAP_MIRROR_REPEAT + word TEXTURE_WRAP_MIRROR_CLAMP, RL_TEXTURE_WRAP_MIRROR_CLAMP +word CubemapLayout, RL_CubemapLayout + word CUBEMAP_LAYOUT_AUTO_DETECT, RL_CUBEMAP_LAYOUT_AUTO_DETECT + word CUBEMAP_LAYOUT_LINE_VERTICAL, RL_CUBEMAP_LAYOUT_LINE_VERTICAL + word CUBEMAP_LAYOUT_LINE_HORIZONTAL, RL_CUBEMAP_LAYOUT_LINE_HORIZONTAL + word CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR, RL_CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR + word CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE, RL_CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE + word CUBEMAP_LAYOUT_PANORAMA, RL_CUBEMAP_LAYOUT_PANORAMA +word FontType, RL_FontType + word FONT_DEFAULT, RL_FONT_DEFAULT + word FONT_BITMAP, RL_FONT_BITMAP + word FONT_SDF, RL_FONT_SDF +word BlendMode, RL_BlendMode + word BLEND_ALPHA, RL_BLEND_ALPHA + word BLEND_ADDITIVE, RL_BLEND_ADDITIVE + word BLEND_MULTIPLIED, RL_BLEND_MULTIPLIED + word BLEND_ADD_COLORS, RL_BLEND_ADD_COLORS + word BLEND_SUBTRACT_COLORS, RL_BLEND_SUBTRACT_COLORS + word BLEND_ALPHA_PREMULTIPLY, RL_BLEND_ALPHA_PREMULTIPLY + word BLEND_CUSTOM, RL_BLEND_CUSTOM + word BLEND_CUSTOM_SEPARATE, RL_BLEND_CUSTOM_SEPARATE +word Gesture, RL_Gesture + word GESTURE_NONE, RL_GESTURE_NONE + word GESTURE_TAP, RL_GESTURE_TAP + word GESTURE_DOUBLETAP, RL_GESTURE_DOUBLETAP + word GESTURE_HOLD, RL_GESTURE_HOLD + word GESTURE_DRAG, RL_GESTURE_DRAG + word GESTURE_SWIPE_RIGHT, RL_GESTURE_SWIPE_RIGHT + word GESTURE_SWIPE_LEFT, RL_GESTURE_SWIPE_LEFT + word GESTURE_SWIPE_UP, RL_GESTURE_SWIPE_UP + word GESTURE_SWIPE_DOWN, RL_GESTURE_SWIPE_DOWN + word GESTURE_PINCH_IN, RL_GESTURE_PINCH_IN + word GESTURE_PINCH_OUT, RL_GESTURE_PINCH_OUT +word CameraMode, RL_CameraMode +word CAMERA_CUSTOM, RL_CAMERA_CUSTOM +word CAMERA_FREE, RL_CAMERA_FREE +word CAMERA_ORBITAL, RL_CAMERA_ORBITAL +word CAMERA_FIRST_PERSON, RL_CAMERA_FIRST_PERSON +word CAMERA_THIRD_PERSON, RL_CAMERA_THIRD_PERSON +word CameraProjection, RL_CameraProjection + word CAMERA_PERSPECTIVE, RL_CAMERA_PERSPECTIVE + word CAMERA_ORTHOGRAPHIC, RL_CAMERA_ORTHOGRAPHIC +word NPatchLayout, RL_NPatchLayout + word NPATCH_NINE_PATCH, RL_NPATCH_NINE_PATCH + word NPATCH_THREE_PATCH_VERTICAL, RL_NPATCH_THREE_PATCH_VERTICAL + word NPATCH_THREE_PATCH_HORIZONTAL, RL_NPATCH_THREE_PATCH_HORIZONTAL + +word TraceLogCallback, RL_TraceLogCallback +word LoadFileDataCallback, RL_LoadFileDataCallback +word SaveFileDataCallback, RL_SaveFileDataCallback +word LoadFileTextCallback, RL_LoadFileTextCallback +word SaveFileTextCallback, RL_SaveFileTextCallback + +word InitWindow, RL_InitWindow +word CloseWindow, RL_CloseWindow +word WindowShouldClose, RL_WindowShouldClose +word IsWindowReady, RL_IsWindowReady +word IsWindowFullscreen, RL_IsWindowFullscreen +word IsWindowHidden, RL_IsWindowHidden +word IsWindowMinimized, RL_IsWindowMinimized +word IsWindowMaximized, RL_IsWindowMaximized +word IsWindowFocused, RL_IsWindowFocused +word IsWindowResized, RL_IsWindowResized +word IsWindowState, RL_IsWindowState +word SetWindowState, RL_SetWindowState +word ClearWindowState, RL_ClearWindowState +word ToggleFullscreen, RL_ToggleFullscreen +word ToggleBorderlessWindowed, RL_ToggleBorderlessWindowed +word MaximizeWindow, RL_MaximizeWindow +word MinimizeWindow, RL_MinimizeWindow +word RestoreWindow, RL_RestoreWindow +word SetWindowIcon, RL_SetWindowIcon +word SetWindowIcons, RL_SetWindowIcons +word SetWindowTitle, RL_SetWindowTitle +word SetWindowPosition, RL_SetWindowPosition +word SetWindowMonitor, RL_SetWindowMonitor +word SetWindowMinSize, RL_SetWindowMinSize +word SetWindowMaxSize, RL_SetWindowMaxSize +word SetWindowSize, RL_SetWindowSize +word SetWindowOpacity, RL_SetWindowOpacity +word SetWindowFocused, RL_SetWindowFocused +word GetWindowHandle, RL_GetWindowHandle +word GetScreenWidth, RL_GetScreenWidth +word GetScreenHeight, RL_GetScreenHeight +word GetRenderWidth, RL_GetRenderWidth +word GetRenderHeight, RL_GetRenderHeight +word GetMonitorCount, RL_GetMonitorCount +word GetCurrentMonitor, RL_GetCurrentMonitor +word GetMonitorPosition, RL_GetMonitorPosition +word GetMonitorWidth, RL_GetMonitorWidth +word GetMonitorHeight, RL_GetMonitorHeight +word GetMonitorPhysicalWidth, RL_GetMonitorPhysicalWidth +word GetMonitorPhysicalHeight, RL_GetMonitorPhysicalHeight +word GetMonitorRefreshRate, RL_GetMonitorRefreshRate +word GetWindowPosition, RL_GetWindowPosition +word GetWindowScaleDPI, RL_GetWindowScaleDPI +word GetMonitorName, RL_GetMonitorName +word SetClipboardText, RL_SetClipboardText +word GetClipboardText, RL_GetClipboardText +word EnableEventWaiting, RL_EnableEventWaiting +word DisableEventWaiting, RL_DisableEventWaiting +word ShowCursor, RL_ShowCursor +word HideCursor, RL_HideCursor +word IsCursorHidden, RL_IsCursorHidden +word EnableCursor, RL_EnableCursor +word DisableCursor, RL_DisableCursor +word IsCursorOnScreen, RL_IsCursorOnScreen +word ClearBackground, RL_ClearBackground +word BeginDrawing, RL_BeginDrawing +word EndDrawing, RL_EndDrawing +word BeginMode2D, RL_BeginMode2D +word EndMode2D, RL_EndMode2D +word BeginMode3D, RL_BeginMode3D +word EndMode3D, RL_EndMode3D +word BeginTextureMode, RL_BeginTextureMode +word EndTextureMode, RL_EndTextureMode +word BeginShaderMode, RL_BeginShaderMode +word EndShaderMode, RL_EndShaderMode +word BeginBlendMode, RL_BeginBlendMode +word EndBlendMode, RL_EndBlendMode +word BeginScissorMode, RL_BeginScissorMode +word EndScissorMode, RL_EndScissorMode +word BeginVrStereoMode, RL_BeginVrStereoMode +word EndVrStereoMode, RL_EndVrStereoMode +word LoadVrStereoConfig, RL_LoadVrStereoConfig +word UnloadVrStereoConfig, RL_UnloadVrStereoConfig +word LoadShader, RL_LoadShader +word LoadShaderFromMemory, RL_LoadShaderFromMemory +word IsShaderReady, RL_IsShaderReady +word GetShaderLocation, RL_GetShaderLocation +word GetShaderLocationAttrib, RL_GetShaderLocationAttrib +word SetShaderValue, RL_SetShaderValue +word SetShaderValueV, RL_SetShaderValueV +word SetShaderValueMatrix, RL_SetShaderValueMatrix +word SetShaderValueTexture, RL_SetShaderValueTexture +word UnloadShader, RL_UnloadShader +word GetMouseRay, RL_GetMouseRay +word GetCameraMatrix, RL_GetCameraMatrix +word GetCameraMatrix2D, RL_GetCameraMatrix2D +word GetWorldToScreen, RL_GetWorldToScreen +word GetScreenToWorld2D, RL_GetScreenToWorld2D +word GetWorldToScreenEx, RL_GetWorldToScreenEx +word GetWorldToScreen2D, RL_GetWorldToScreen2D +word SetTargetFPS, RL_SetTargetFPS +word GetFrameTime, RL_GetFrameTime +word GetTime, RL_GetTime +word GetFPS, RL_GetFPS +word SwapScreenBuffer, RL_SwapScreenBuffer +word PollInputEvents, RL_PollInputEvents +word WaitTime, RL_WaitTime +word GetRandomValue, RL_GetRandomValue +word SetRandomSeed, RL_SetRandomSeed +word TakeScreenshot, RL_TakeScreenshot +word SetConfigFlags, RL_SetConfigFlags +word OpenURL, RL_OpenURL +word TraceLog, RL_TraceLog +word SetTraceLogLevel, RL_SetTraceLogLevel +word MemAlloc, RL_MemAlloc +word MemRealloc, RL_MemRealloc +word MemFree, RL_MemFree +word SetTraceLogCallback, RL_SetTraceLogCallback +word SetLoadFileDataCallback, RL_SetLoadFileDataCallback +word SetSaveFileDataCallback, RL_SetSaveFileDataCallback +word SetLoadFileTextCallback, RL_SetLoadFileTextCallback +word SetSaveFileTextCallback, RL_SetSaveFileTextCallback +word LoadFileData, RL_LoadFileData +word UnloadFileData, RL_UnloadFileData +word SaveFileData, RL_SaveFileData +word ExportDataAsCode, RL_ExportDataAsCode +word LoadFileText, RL_LoadFileText +word UnloadFileText, RL_UnloadFileText +word SaveFileText, RL_SaveFileText +word FileExists, RL_FileExists +word DirectoryExists, RL_DirectoryExists +word IsFileExtension, RL_IsFileExtension +word GetFileLength, RL_GetFileLength +word GetFileExtension, RL_GetFileExtension +word GetFileName, RL_GetFileName +word GetFileNameWithoutExt, RL_GetFileNameWithoutExt +word GetDirectoryPath, RL_GetDirectoryPath +word GetPrevDirectoryPath, RL_GetPrevDirectoryPath +word GetWorkingDirectory, RL_GetWorkingDirectory +word GetApplicationDirectory, RL_GetApplicationDirectory +word ChangeDirectory, RL_ChangeDirectory +word IsPathFile, RL_IsPathFile +word LoadDirectoryFiles, RL_LoadDirectoryFiles +word LoadDirectoryFilesEx, RL_LoadDirectoryFilesEx +word UnloadDirectoryFiles, RL_UnloadDirectoryFiles +word IsFileDropped, RL_IsFileDropped +word LoadDroppedFiles, RL_LoadDroppedFiles +word UnloadDroppedFiles, RL_UnloadDroppedFiles +word GetFileModTime, RL_GetFileModTime +word CompressData, RL_CompressData +word DecompressData, RL_DecompressData +word EncodeDataBase64, RL_EncodeDataBase64 +word DecodeDataBase64, RL_DecodeDataBase64 +word LoadAutomationEventList, RL_LoadAutomationEventList +word UnloadAutomationEventList, RL_UnloadAutomationEventList +word ExportAutomationEventList, RL_ExportAutomationEventList +word SetAutomationEventList, RL_SetAutomationEventList +word SetAutomationEventBaseFrame, RL_SetAutomationEventBaseFrame +word StartAutomationEventRecording, RL_StartAutomationEventRecording +word StopAutomationEventRecording, RL_StopAutomationEventRecording +word PlayAutomationEvent, RL_PlayAutomationEvent +word IsKeyPressed, RL_IsKeyPressed +word IsKeyPressedRepeat, RL_IsKeyPressedRepeat +word IsKeyDown, RL_IsKeyDown +word IsKeyReleased, RL_IsKeyReleased +word IsKeyUp, RL_IsKeyUp +word GetKeyPressed, RL_GetKeyPressed +word GetCharPressed, RL_GetCharPressed +word SetExitKey, RL_SetExitKey +word IsGamepadAvailable, RL_IsGamepadAvailable +word GetGamepadName, RL_GetGamepadName +word IsGamepadButtonPressed, RL_IsGamepadButtonPressed +word IsGamepadButtonDown, RL_IsGamepadButtonDown +word IsGamepadButtonReleased, RL_IsGamepadButtonReleased +word IsGamepadButtonUp, RL_IsGamepadButtonUp +word GetGamepadButtonPressed, RL_GetGamepadButtonPressed +word GetGamepadAxisCount, RL_GetGamepadAxisCount +word GetGamepadAxisMovement, RL_GetGamepadAxisMovement +word SetGamepadMappings, RL_SetGamepadMappings +word IsMouseButtonPressed, RL_IsMouseButtonPressed +word IsMouseButtonDown, RL_IsMouseButtonDown +word IsMouseButtonReleased, RL_IsMouseButtonReleased +word IsMouseButtonUp, RL_IsMouseButtonUp +word GetMouseX, RL_GetMouseX +word GetMouseY, RL_GetMouseY +word GetMousePosition, RL_GetMousePosition +word GetMouseDelta, RL_GetMouseDelta +word SetMousePosition, RL_SetMousePosition +word SetMouseOffset, RL_SetMouseOffset +word SetMouseScale, RL_SetMouseScale +word GetMouseWheelMove, RL_GetMouseWheelMove +word GetMouseWheelMoveV, RL_GetMouseWheelMoveV +word SetMouseCursor, RL_SetMouseCursor +word GetTouchX, RL_GetTouchX +word GetTouchY, RL_GetTouchY +word GetTouchPosition, RL_GetTouchPosition +word GetTouchPointId, RL_GetTouchPointId +word GetTouchPointCount, RL_GetTouchPointCount +word SetGesturesEnabled, RL_SetGesturesEnabled +word IsGestureDetected, RL_IsGestureDetected +word GetGestureDetected, RL_GetGestureDetected +word GetGestureHoldDuration, RL_GetGestureHoldDuration +word GetGestureDragVector, RL_GetGestureDragVector +word GetGestureDragAngle, RL_GetGestureDragAngle +word GetGesturePinchVector, RL_GetGesturePinchVector +word GetGesturePinchAngle, RL_GetGesturePinchAngle +word UpdateCamera, RL_UpdateCamera +word UpdateCameraPro, RL_UpdateCameraPro +word SetShapesTexture, RL_SetShapesTexture +word DrawPixel, RL_DrawPixel +word DrawPixelV, RL_DrawPixelV +word DrawLine, RL_DrawLine +word DrawLineV, RL_DrawLineV +word DrawLineEx, RL_DrawLineEx +word DrawLineBezier, RL_DrawLineBezier +word DrawLineBezierQuad, RL_DrawLineBezierQuad +word DrawLineBezierCubic, RL_DrawLineBezierCubic +word DrawLineBSpline, RL_DrawLineBSpline +word DrawLineCatmullRom, RL_DrawLineCatmullRom +word DrawLineStrip, RL_DrawLineStrip +word DrawCircle, RL_DrawCircle +word DrawCircleSector, RL_DrawCircleSector +word DrawCircleSectorLines, RL_DrawCircleSectorLines +word DrawCircleGradient, RL_DrawCircleGradient +word DrawCircleV, RL_DrawCircleV +word DrawCircleLines, RL_DrawCircleLines +word DrawCircleLinesV, RL_DrawCircleLinesV +word DrawEllipse, RL_DrawEllipse +word DrawEllipseLines, RL_DrawEllipseLines +word DrawRing, RL_DrawRing +word DrawRingLines, RL_DrawRingLines +word DrawRectangle, RL_DrawRectangle +word DrawRectangleV, RL_DrawRectangleV +word DrawRectangleRec, RL_DrawRectangleRec +word DrawRectanglePro, RL_DrawRectanglePro +word DrawRectangleGradientV, RL_DrawRectangleGradientV +word DrawRectangleGradientH, RL_DrawRectangleGradientH +word DrawRectangleGradientEx, RL_DrawRectangleGradientEx +word DrawRectangleLines, RL_DrawRectangleLines +word DrawRectangleLinesEx, RL_DrawRectangleLinesEx +word DrawRectangleRounded, RL_DrawRectangleRounded +word DrawRectangleRoundedLines, RL_DrawRectangleRoundedLines +word DrawTriangle, RL_DrawTriangle +word DrawTriangleLines, RL_DrawTriangleLines +word DrawTriangleFan, RL_DrawTriangleFan +word DrawTriangleStrip, RL_DrawTriangleStrip +word DrawPoly, RL_DrawPoly +word DrawPolyLines, RL_DrawPolyLines +word DrawPolyLinesEx, RL_DrawPolyLinesEx +word CheckCollisionRecs, RL_CheckCollisionRecs +word CheckCollisionCircles, RL_CheckCollisionCircles +word CheckCollisionCircleRec, RL_CheckCollisionCircleRec +word CheckCollisionPointRec, RL_CheckCollisionPointRec +word CheckCollisionPointCircle, RL_CheckCollisionPointCircle +word CheckCollisionPointTriangle, RL_CheckCollisionPointTriangle +word CheckCollisionPointPoly, RL_CheckCollisionPointPoly +word CheckCollisionLines, RL_CheckCollisionLines +word CheckCollisionPointLine, RL_CheckCollisionPointLine +word GetCollisionRec, RL_GetCollisionRec +word LoadImage, RL_LoadImage +word LoadImageRaw, RL_LoadImageRaw +word LoadImageSvg, RL_LoadImageSvg +word LoadImageAnim, RL_LoadImageAnim +word LoadImageFromMemory, RL_LoadImageFromMemory +word LoadImageFromTexture, RL_LoadImageFromTexture +word LoadImageFromScreen, RL_LoadImageFromScreen +word IsImageReady, RL_IsImageReady +word UnloadImage, RL_UnloadImage +word ExportImage, RL_ExportImage +word ExportImageToMemory, RL_ExportImageToMemory +word ExportImageAsCode, RL_ExportImageAsCode +word GenImageColor, RL_GenImageColor +word GenImageGradientLinear, RL_GenImageGradientLinear +word GenImageGradientRadial, RL_GenImageGradientRadial +word GenImageGradientSquare, RL_GenImageGradientSquare +word GenImageChecked, RL_GenImageChecked +word GenImageWhiteNoise, RL_GenImageWhiteNoise +word GenImagePerlinNoise, RL_GenImagePerlinNoise +word GenImageCellular, RL_GenImageCellular +word GenImageText, RL_GenImageText +word ImageCopy, RL_ImageCopy +word ImageFromImage, RL_ImageFromImage +word ImageText, RL_ImageText +word ImageTextEx, RL_ImageTextEx +word ImageFormat, RL_ImageFormat +word ImageToPOT, RL_ImageToPOT +word ImageCrop, RL_ImageCrop +word ImageAlphaCrop, RL_ImageAlphaCrop +word ImageAlphaClear, RL_ImageAlphaClear +word ImageAlphaMask, RL_ImageAlphaMask +word ImageAlphaPremultiply, RL_ImageAlphaPremultiply +word ImageBlurGaussian, RL_ImageBlurGaussian +word ImageResize, RL_ImageResize +word ImageResizeNN, RL_ImageResizeNN +word ImageResizeCanvas, RL_ImageResizeCanvas +word ImageMipmaps, RL_ImageMipmaps +word ImageDither, RL_ImageDither +word ImageFlipVertical, RL_ImageFlipVertical +word ImageFlipHorizontal, RL_ImageFlipHorizontal +word ImageRotate, RL_ImageRotate +word ImageRotateCW, RL_ImageRotateCW +word ImageRotateCCW, RL_ImageRotateCCW +word ImageColorTint, RL_ImageColorTint +word ImageColorInvert, RL_ImageColorInvert +word ImageColorGrayscale, RL_ImageColorGrayscale +word ImageColorContrast, RL_ImageColorContrast +word ImageColorBrightness, RL_ImageColorBrightness +word ImageColorReplace, RL_ImageColorReplace +word LoadImageColors, RL_LoadImageColors +word LoadImagePalette, RL_LoadImagePalette +word UnloadImageColors, RL_UnloadImageColors +word UnloadImagePalette, RL_UnloadImagePalette +word GetImageAlphaBorder, RL_GetImageAlphaBorder +word GetImageColor, RL_GetImageColor +word ImageClearBackground, RL_ImageClearBackground +word ImageDrawPixel, RL_ImageDrawPixel +word ImageDrawPixelV, RL_ImageDrawPixelV +word ImageDrawLine, RL_ImageDrawLine +word ImageDrawLineV, RL_ImageDrawLineV +word ImageDrawCircle, RL_ImageDrawCircle +word ImageDrawCircleV, RL_ImageDrawCircleV +word ImageDrawCircleLines, RL_ImageDrawCircleLines +word ImageDrawCircleLinesV, RL_ImageDrawCircleLinesV +word ImageDrawRectangle, RL_ImageDrawRectangle +word ImageDrawRectangleV, RL_ImageDrawRectangleV +word ImageDrawRectangleRec, RL_ImageDrawRectangleRec +word ImageDrawRectangleLines, RL_ImageDrawRectangleLines +word ImageDraw, RL_ImageDraw +word ImageDrawText, RL_ImageDrawText +word ImageDrawTextEx, RL_ImageDrawTextEx +word LoadTexture, RL_LoadTexture +word LoadTextureFromImage, RL_LoadTextureFromImage +word LoadTextureCubemap, RL_LoadTextureCubemap +word LoadRenderTexture, RL_LoadRenderTexture +word IsTextureReady, RL_IsTextureReady +word UnloadTexture, RL_UnloadTexture +word IsRenderTextureReady, RL_IsRenderTextureReady +word UnloadRenderTexture, RL_UnloadRenderTexture +word UpdateTexture, RL_UpdateTexture +word UpdateTextureRec, RL_UpdateTextureRec +word GenTextureMipmaps, RL_GenTextureMipmaps +word SetTextureFilter, RL_SetTextureFilter +word SetTextureWrap, RL_SetTextureWrap +word DrawTexture, RL_DrawTexture +word DrawTextureV, RL_DrawTextureV +word DrawTextureEx, RL_DrawTextureEx +word DrawTextureRec, RL_DrawTextureRec +word DrawTexturePro, RL_DrawTexturePro +word DrawTextureNPatch, RL_DrawTextureNPatch +word Fade, RL_Fade +word ColorToInt, RL_ColorToInt +word ColorNormalize, RL_ColorNormalize +word ColorFromNormalized, RL_ColorFromNormalized +word ColorToHSV, RL_ColorToHSV +word ColorFromHSV, RL_ColorFromHSV +word ColorTint, RL_ColorTint +word ColorBrightness, RL_ColorBrightness +word ColorContrast, RL_ColorContrast +word ColorAlpha, RL_ColorAlpha +word ColorAlphaBlend, RL_ColorAlphaBlend +word GetColor, RL_GetColor +word GetPixelColor, RL_GetPixelColor +word SetPixelColor, RL_SetPixelColor +word GetPixelDataSize, RL_GetPixelDataSize +word GetFontDefault, RL_GetFontDefault +word LoadFont, RL_LoadFont +word LoadFontEx, RL_LoadFontEx +word LoadFontFromImage, RL_LoadFontFromImage +word LoadFontFromMemory, RL_LoadFontFromMemory +word IsFontReady, RL_IsFontReady +word LoadFontData, RL_LoadFontData +word GenImageFontAtlas, RL_GenImageFontAtlas +word UnloadFontData, RL_UnloadFontData +word UnloadFont, RL_UnloadFont +word ExportFontAsCode, RL_ExportFontAsCode +word DrawFPS, RL_DrawFPS +word DrawText, RL_DrawText +word DrawTextEx, RL_DrawTextEx +word DrawTextPro, RL_DrawTextPro +word DrawTextCodepoint, RL_DrawTextCodepoint +word DrawTextCodepoints, RL_DrawTextCodepoints +word SetTextLineSpacing, RL_SetTextLineSpacing +word MeasureText, RL_MeasureText +word MeasureTextEx, RL_MeasureTextEx +word GetGlyphIndex, RL_GetGlyphIndex +word GetGlyphInfo, RL_GetGlyphInfo +word GetGlyphAtlasRec, RL_GetGlyphAtlasRec +word LoadUTF8, RL_LoadUTF8 +word UnloadUTF8, RL_UnloadUTF8 +word LoadCodepoints, RL_LoadCodepoints +word UnloadCodepoints, RL_UnloadCodepoints +word GetCodepointCount, RL_GetCodepointCount +word GetCodepoint, RL_GetCodepoint +word GetCodepointNext, RL_GetCodepointNext +word GetCodepointPrevious, RL_GetCodepointPrevious +word CodepointToUTF8, RL_CodepointToUTF8 +word TextCopy, RL_TextCopy +word TextIsEqual, RL_TextIsEqual +word TextLength, RL_TextLength +word TextFormat, RL_TextFormat +word TextSubtext, RL_TextSubtext +word TextReplace, RL_TextReplace +word TextInsert, RL_TextInsert +word TextJoin, RL_TextJoin +word TextAppend, RL_TextAppend +word TextFindIndex, RL_TextFindIndex +word TextToUpper, RL_TextToUpper +word TextToLower, RL_TextToLower +word TextToPascal, RL_TextToPascal +word TextToInteger, RL_TextToInteger +word DrawLine3D, RL_DrawLine3D +word DrawPoint3D, RL_DrawPoint3D +word DrawCircle3D, RL_DrawCircle3D +word DrawTriangle3D, RL_DrawTriangle3D +word DrawTriangleStrip3D, RL_DrawTriangleStrip3D +word DrawCube, RL_DrawCube +word DrawCubeV, RL_DrawCubeV +word DrawCubeWires, RL_DrawCubeWires +word DrawCubeWiresV, RL_DrawCubeWiresV +word DrawSphere, RL_DrawSphere +word DrawSphereEx, RL_DrawSphereEx +word DrawSphereWires, RL_DrawSphereWires +word DrawCylinder, RL_DrawCylinder +word DrawCylinderEx, RL_DrawCylinderEx +word DrawCylinderWires, RL_DrawCylinderWires +word DrawCylinderWiresEx, RL_DrawCylinderWiresEx +word DrawCapsule, RL_DrawCapsule +word DrawCapsuleWires, RL_DrawCapsuleWires +word DrawPlane, RL_DrawPlane +word DrawRay, RL_DrawRay +word DrawGrid, RL_DrawGrid +word LoadModel, RL_LoadModel +word LoadModelFromMesh, RL_LoadModelFromMesh +word IsModelReady, RL_IsModelReady +word UnloadModel, RL_UnloadModel +word GetModelBoundingBox, RL_GetModelBoundingBox +word DrawModel, RL_DrawModel +word DrawModelEx, RL_DrawModelEx +word DrawModelWires, RL_DrawModelWires +word DrawModelWiresEx, RL_DrawModelWiresEx +word DrawBoundingBox, RL_DrawBoundingBox +word DrawBillboard, RL_DrawBillboard +word DrawBillboardRec, RL_DrawBillboardRec +word DrawBillboardPro, RL_DrawBillboardPro +word UploadMesh, RL_UploadMesh +word UpdateMeshBuffer, RL_UpdateMeshBuffer +word UnloadMesh, RL_UnloadMesh +word DrawMesh, RL_DrawMesh +word DrawMeshInstanced, RL_DrawMeshInstanced +word ExportMesh, RL_ExportMesh +word GetMeshBoundingBox, RL_GetMeshBoundingBox +word GenMeshTangents, RL_GenMeshTangents +word GenMeshPoly, RL_GenMeshPoly +word GenMeshPlane, RL_GenMeshPlane +word GenMeshCube, RL_GenMeshCube +word GenMeshSphere, RL_GenMeshSphere +word GenMeshHemiSphere, RL_GenMeshHemiSphere +word GenMeshCylinder, RL_GenMeshCylinder +word GenMeshCone, RL_GenMeshCone +word GenMeshTorus, RL_GenMeshTorus +word GenMeshKnot, RL_GenMeshKnot +word GenMeshHeightmap, RL_GenMeshHeightmap +word GenMeshCubicmap, RL_GenMeshCubicmap +word LoadMaterials, RL_LoadMaterials +word LoadMaterialDefault, RL_LoadMaterialDefault +word IsMaterialReady, RL_IsMaterialReady +word UnloadMaterial, RL_UnloadMaterial +word SetMaterialTexture, RL_SetMaterialTexture +word SetModelMeshMaterial, RL_SetModelMeshMaterial +word LoadModelAnimations, RL_LoadModelAnimations +word UpdateModelAnimation, RL_UpdateModelAnimation +word UnloadModelAnimation, RL_UnloadModelAnimation +word UnloadModelAnimations, RL_UnloadModelAnimations +word IsModelAnimationValid, RL_IsModelAnimationValid +word CheckCollisionSpheres, RL_CheckCollisionSpheres +word CheckCollisionBoxes, RL_CheckCollisionBoxes +word CheckCollisionBoxSphere, RL_CheckCollisionBoxSphere +word GetRayCollisionSphere, RL_GetRayCollisionSphere +word GetRayCollisionBox, RL_GetRayCollisionBox +word GetRayCollisionMesh, RL_GetRayCollisionMesh +word GetRayCollisionTriangle, RL_GetRayCollisionTriangle +word GetRayCollisionQuad, RL_GetRayCollisionQuad +word InitAudioDevice, RL_InitAudioDevice +word CloseAudioDevice, RL_CloseAudioDevice +word IsAudioDeviceReady, RL_IsAudioDeviceReady +word SetMasterVolume, RL_SetMasterVolume +word GetMasterVolume, RL_GetMasterVolume +word LoadWave, RL_LoadWave +word LoadWaveFromMemory, RL_LoadWaveFromMemory +word IsWaveReady, RL_IsWaveReady +word LoadSound, RL_LoadSound +word LoadSoundFromWave, RL_LoadSoundFromWave +word LoadSoundAlias, RL_LoadSoundAlias +word IsSoundReady, RL_IsSoundReady +word UpdateSound, RL_UpdateSound +word UnloadWave, RL_UnloadWave +word UnloadSound, RL_UnloadSound +word UnloadSoundAlias, RL_UnloadSoundAlias +word ExportWave, RL_ExportWave +word ExportWaveAsCode, RL_ExportWaveAsCode +word PlaySound, RL_PlaySound +word StopSound, RL_StopSound +word PauseSound, RL_PauseSound +word ResumeSound, RL_ResumeSound +word IsSoundPlaying, RL_IsSoundPlaying +word SetSoundVolume, RL_SetSoundVolume +word SetSoundPitch, RL_SetSoundPitch +word SetSoundPan, RL_SetSoundPan +word WaveCopy, RL_WaveCopy +word WaveCrop, RL_WaveCrop +word WaveFormat, RL_WaveFormat +word LoadWaveSamples, RL_LoadWaveSamples +word UnloadWaveSamples, RL_UnloadWaveSamples +word LoadMusicStream, RL_LoadMusicStream +word LoadMusicStreamFromMemory, RL_LoadMusicStreamFromMemory +word IsMusicReady, RL_IsMusicReady +word UnloadMusicStream, RL_UnloadMusicStream +word PlayMusicStream, RL_PlayMusicStream +word IsMusicStreamPlaying, RL_IsMusicStreamPlaying +word UpdateMusicStream, RL_UpdateMusicStream +word StopMusicStream, RL_StopMusicStream +word PauseMusicStream, RL_PauseMusicStream +word ResumeMusicStream, RL_ResumeMusicStream +word SeekMusicStream, RL_SeekMusicStream +word SetMusicVolume, RL_SetMusicVolume +word SetMusicPitch, RL_SetMusicPitch +word SetMusicPan, RL_SetMusicPan +word GetMusicTimeLength, RL_GetMusicTimeLength +word GetMusicTimePlayed, RL_GetMusicTimePlayed +word LoadAudioStream, RL_LoadAudioStream +word IsAudioStreamReady, RL_IsAudioStreamReady +word UnloadAudioStream, RL_UnloadAudioStream +word UpdateAudioStream, RL_UpdateAudioStream +word IsAudioStreamProcessed, RL_IsAudioStreamProcessed +word PlayAudioStream, RL_PlayAudioStream +word PauseAudioStream, RL_PauseAudioStream +word ResumeAudioStream, RL_ResumeAudioStream +word IsAudioStreamPlaying, RL_IsAudioStreamPlaying +word StopAudioStream, RL_StopAudioStream +word SetAudioStreamVolume, RL_SetAudioStreamVolume +word SetAudioStreamPitch, RL_SetAudioStreamPitch +word SetAudioStreamPan, RL_SetAudioStreamPan +word SetAudioStreamBufferSizeDefault, RL_SetAudioStreamBufferSizeDefault +word SetAudioStreamCallback, RL_SetAudioStreamCallback +word AttachAudioStreamProcessor, RL_AttachAudioStreamProcessor +word DetachAudioStreamProcessor, RL_DetachAudioStreamProcessor +word AttachAudioMixedProcessor, RL_AttachAudioMixedProcessor +word DetachAudioMixedProcessor, RL_DetachAudioMixedProcessor + +// raudio.c +// Since its a TU, only going to refactor if there is a symbol conflict + +// word NOGDICAPMASKS, RL_NOGDICAPMASKS +// word NOVIRTUALKEYCODES, RL_NOVIRTUALKEYCODES +// word NOWINMESSAGES, RL_NOWINMESSAGES +// word NOWINSTYLES, RL_NOWINSTYLES +// word NOSYSMETRICS, RL_NOSYSMETRICS +// word NOMENUS, RL_NOMENUS +// word NOICONS, RL_NOICONS +// word NOKEYSTATES, RL_NOKEYSTATES +// word NOSYSCOMMANDS, RL_NOSYSCOMMANDS +// word NORASTEROPS, RL_NORASTEROPS +// word NOSHOWWINDOW, RL_NOSHOWWINDOW +// word OEMRESOURCE, RL_OEMRESOURCE +// word NOATOM, RL_NOATOM +// word NOCLIPBOARD, RL_NOCLIPBOARD +// word NOCOLOR, RL_NOCOLOR +// word NOCTLMGR, RL_NOCTLMGR +// word NODRAWTEXT, RL_NODRAWTEXT +// word NOGDI, RL_NOGDI +// word NOKERNEL, RL_NOKERNEL +// word NOUSER, RL_NOUSER +// word NONLS, RL_NONLS +// word NOMB, RL_NOMB +// word NOMEMMGR, RL_NOMEMMGR +// word NOMETAFILE, RL_NOMETAFILE +// word NOMINMAX, RL_NOMINMAX +// word NOMSG, RL_NOMSG +// word NOOPENFILE, RL_NOOPENFILE +// word NOSCROLL, RL_NOSCROLL +// word NOSERVICE, RL_NOSERVICE +// word NOSOUND, RL_NOSOUND +// word NOTEXTMETRIC, RL_NOTEXTMETRIC +// word NOWH, RL_NOWH +// word NOWINOFFSETS, RL_NOWINOFFSETS +// word NOCOMM, RL_NOCOMM +// word NOKANJI, RL_NOKANJI +// word NOHELP, RL_NOHELP +// word NOPROFILER, RL_NOPROFILER +// word NODEFERWINDOWPOS, RL_NODEFERWINDOWPOS +// word NOMCX, RL_NOMCX + +// word tagMSG, RL_tagMSG; +// word tagBITMAPINFOHEADER, RL_tagBITMAPINFOHEADER; +// word BITMAPINFOHEADER, RL_BITMAPINFOHEADER; +// word PBITMAPINFOHEADER, RL_BITMAPINFOHEADER; + +// word MA_MALLOC RL_MALLOC, RL_MA_MALLOC RL_MALLOC +// word MA_FREE RL_FREE, RL_MA_FREE RL_FREE +// word MA_NO_JACK, RL_MA_NO_JACK +// word MA_NO_WAV, RL_MA_NO_WAV +// word MA_NO_FLAC, RL_MA_NO_FLAC +// word MA_NO_MP3, RL_MA_NO_MP3 +// word MA_COINIT_VALUE, RL_MA_COINIT_VALUE + +// raymath.h + +word MatrixToFloat, RL_MatrixToFloat +word Vector3ToFloat, RL_Vector3ToFloat + +word float3, RL_float3 +word float16, RL_float16 + +word Clamp, RL_Clamp +word Lerp, RL_Lerp +word Normalize, RL_Normalize +word Remap, RL_Remap +word Wrap, RL_Wrap +word FloatEquals, RL_FloatEquals +word Vector2Zero, RL_Vector2Zero +word Vector2One, RL_Vector2One +word Vector2Add, RL_Vector2Add +word Vector2AddValue, RL_Vector2AddValue +word Vector2Subtract, RL_Vector2Subtract +word Vector2SubtractValue, RL_Vector2SubtractValue +word Vector2Length, RL_Vector2Length +word Vector2LengthSqr, RL_Vector2LengthSqr +word Vector2DotProduct, RL_Vector2DotProduct +word Vector2Distance, RL_Vector2Distance +word Vector2DistanceSqr, RL_Vector2DistanceSqr +word Vector2Angle, RL_Vector2Angle +word Vector2LineAngle, RL_Vector2LineAngle +word Vector2Scale, RL_Vector2Scale +word Vector2Multiply, RL_Vector2Multiply +word Vector2Negate, RL_Vector2Negate +word Vector2Divide, RL_Vector2Divide +word Vector2Normalize, RL_Vector2Normalize +word Vector2Transform, RL_Vector2Transform +word Vector2Lerp, RL_Vector2Lerp +word Vector2Reflect, RL_Vector2Reflect +word Vector2Rotate, RL_Vector2Rotate +word Vector2MoveTowards, RL_Vector2MoveTowards +word Vector2Invert, RL_Vector2Invert +word Vector2Clamp, RL_Vector2Clamp +word Vector2ClampValue, RL_Vector2ClampValue +word Vector2Equals, RL_Vector2Equals +word Vector3Zero, RL_Vector3Zero +word Vector3One, RL_Vector3One +word Vector3Add, RL_Vector3Add +word Vector3AddValue, RL_Vector3AddValue +word Vector3Subtract, RL_Vector3Subtract +word Vector3SubtractValue, RL_Vector3SubtractValue +word Vector3Scale, RL_Vector3Scale +word Vector3Multiply, RL_Vector3Multiply +word Vector3CrossProduct, RL_Vector3CrossProduct +word Vector3Perpendicular, RL_Vector3Perpendicular +word Vector3Length, RL_Vector3Length +word Vector3LengthSqr, RL_Vector3LengthSqr +word Vector3DotProduct, RL_Vector3DotProduct +word Vector3Distance, RL_Vector3Distance +word Vector3DistanceSqr, RL_Vector3DistanceSqr +word Vector3Angle, RL_Vector3Angle +word Vector3Negate, RL_Vector3Negate +word Vector3Divide, RL_Vector3Divide +word Vector3Normalize, RL_Vector3Normalize +word Vector3Project, RL_Vector3Project +word Vector3Reject, RL_Vector3Reject +word Vector3OrthoNormalize, RL_Vector3OrthoNormalize +word Vector3Transform, RL_Vector3Transform +word Vector3RotateByQuaternion, RL_Vector3RotateByQuaternion +word Vector3RotateByAxisAngle, RL_Vector3RotateByAxisAngle +word Vector3Lerp, RL_Vector3Lerp +word Vector3Reflect, RL_Vector3Reflect +word Vector3Min, RL_Vector3Min +word Vector3Max, RL_Vector3Max +word Vector3Barycenter, RL_Vector3Barycenter +word Vector3Unproject, RL_Vector3Unproject +word Vector3ToFloatV, RL_Vector3ToFloatV +word Vector3Invert, RL_Vector3Invert +word Vector3Clamp, RL_Vector3Clamp +word Vector3ClampValue, RL_Vector3ClampValue +word Vector3Equals, RL_Vector3Equals +word Vector3Refract, RL_Vector3Refract +word MatrixDeterminant, RL_MatrixDeterminant +word MatrixTrace, RL_MatrixTrace +word MatrixTranspose, RL_MatrixTranspose +word MatrixInvert, RL_MatrixInvert +word MatrixIdentity, RL_MatrixIdentity +word MatrixAdd, RL_MatrixAdd +word MatrixSubtract, RL_MatrixSubtract +word MatrixMultiply, RL_MatrixMultiply +word MatrixTranslate, RL_MatrixTranslate +word MatrixRotate, RL_MatrixRotate +word MatrixRotateX, RL_MatrixRotateX +word MatrixRotateY, RL_MatrixRotateY +word MatrixRotateZ, RL_MatrixRotateZ +word MatrixRotateXYZ, RL_MatrixRotateXYZ +word MatrixRotateZYX, RL_MatrixRotateZYX +word MatrixScale, RL_MatrixScale +word MatrixFrustum, RL_MatrixFrustum +word MatrixPerspective, RL_MatrixPerspective +word MatrixOrtho, RL_MatrixOrtho +word MatrixLookAt, RL_MatrixLookAt +word MatrixToFloatV, RL_MatrixToFloatV +word QuaternionAdd, RL_QuaternionAdd +word QuaternionAddValue, RL_QuaternionAddValue +word QuaternionSubtract, RL_QuaternionSubtract +word QuaternionSubtractValue, RL_QuaternionSubtractValue +word QuaternionIdentity, RL_QuaternionIdentity +word QuaternionLength, RL_QuaternionLength +word QuaternionNormalize, RL_QuaternionNormalize +word QuaternionInvert, RL_QuaternionInvert +word QuaternionMultiply, RL_QuaternionMultiply +word QuaternionScale, RL_QuaternionScale +word QuaternionDivide, RL_QuaternionDivide +word QuaternionLerp, RL_QuaternionLerp +word QuaternionNlerp, RL_QuaternionNlerp +word QuaternionSlerp, RL_QuaternionSlerp +word QuaternionFromVector3ToVector3, RL_QuaternionFromVector3ToVector3 +word QuaternionFromMatrix, RL_QuaternionFromMatrix +word QuaternionToMatrix, RL_QuaternionToMatrix +word QuaternionFromAxisAngle, RL_QuaternionFromAxisAngle +word QuaternionToAxisAngle, RL_QuaternionToAxisAngle +word QuaternionFromEuler, RL_QuaternionFromEuler +word QuaternionToEuler, RL_QuaternionToEuler +word QuaternionTransform, RL_QuaternionTransform +word QuaternionEquals, RL_QuaternionEquals + +// rcamera.hMAX_MOUSE_BUTTONS + +word CAMERA_CULL_DISTANCE_NEAR, RL_CAMERA_CULL_DISTANCE_NEAR +word CAMERA_CULL_DISTANCE_FAR, RL_CAMERA_CULL_DISTANCE_FAR + +GetCameraForward +GetCameraUp +GetCameraRight +CameraMoveForward +CameraMoveUp +CameraMoveRight +CameraMoveToTarget +CameraYaw +CameraPitch +CameraRoll +GetCameraViewMatrix +GetCameraProjectionMatrix + +word CAMERA_MOVE_SPEED, RL_CAMERA_MOVE_SPEED +word CAMERA_ROTATION_SPEED, RL_CAMERA_ROTATION_SPEED +word CAMERA_PAN_SPEED, RL_CAMERA_PAN_SPEED +word CAMERA_MOUSE_MOVE_SENSITIVITY, RL_CAMERA_MOUSE_MOVE_SENSITIVITY +word CAMERA_MOUSE_SCROLL_SENSITIVITY, RL_CAMERA_MOUSE_SCROLL_SENSITIVITY +word CAMERA_ORBITAL_SPEED, RL_CAMERA_ORBITAL_SPEED +word CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER, RL_CAMERA_FIRST_PERSON_STEP_TRIGONOMETRIC_DIVIDER +word CAMERA_FIRST_PERSON_STEP_DIVIDER, RL_CAMERA_FIRST_PERSON_STEP_DIVIDER +word CAMERA_FIRST_PERSON_WAVING_DIVIDER, RL_CAMERA_FIRST_PERSON_WAVING_DIVIDER +word PLAYER_MOVEMENT_SENSITIVITY, RL_PLAYER_MOVEMENT_SENSITIVITY + +// rcore.h + +// config header has these covered +// MAX_FILEPATH_CAPACITY +// MAX_FILEPATH_LENGTH +// MAX_KEYBOARD_KEYS +// MAX_MOUSE_BUTTONS +// MAX_GAMEPADS +// MAX_GAMEPAD_AXIS +// MAX_GAMEPAD_BUTTONS +// MAX_TOUCH_POINTS +// MAX_KEY_PRESSED_QUEUE +// MAX_CHAR_PRESSED_QUEUE +// MAX_DECOMPRESSION_SIZE +// MAX_AUTOMATION_EVENTS + +word FLAG_SET, RL_FLAG_SET +word FLAG_CLEAR, RL_FLAG_CLEAR +word FLAG_TOGGLE, RL_FLAG_TOGGLE +word FLAG_CHECK, RL_FLAG_CHECK + +word Point, RL_Point +word Size, RL_Size +word CoreData, RL_CoreData +word CORE, RL_CORE + +// rgestures.h + +// MAX_TOUCH_POINTS + +word TouchAction, RL_TouchAction +word GestureEvent, RL_GestureEvent + +word ProcessGestureEvent, RL_ProcessGestureEvent +word UpdateGestures, RL_UpdateGestures +word SetGesturesEnabled, RL_SetGesturesEnabled +word IsGestureDetected, RL_IsGestureDetected +word GetGestureDetected, RL_GetGestureDetected +word GetGestureHoldDuration, RL_GetGestureHoldDuration +word GetGestureDragVector, RL_GetGestureDragVector +word GetGestureDragAngle, RL_GetGestureDragAngle +word GetGesturePinchVector, RL_GetGesturePinchVector +word GetGesturePinchAngle, RL_GetGesturePinchAngle +word QueryPerformanceCounter, RL_QueryPerformanceCounter +word QueryPerformanceFrequency, RL_QueryPerformanceFrequency + +word FORCE_TO_SWIPE, RL_FORCE_TO_SWIPE +word MINIMUM_DRAG, RL_MINIMUM_DRAG +word DRAG_TIMEOUT, RL_DRAG_TIMEOUT +word MINIMUM_PINCH, RL_MINIMUM_PINCH +word TAP_TIMEOUT, RL_TAP_TIMEOUT +word PINCH_TIMEOUT, RL_PINCH_TIMEOUT +word DOUBLETAP_RANGE, RL_DOUBLETAP_RANGE + +word GesturesData, RL_GesturesData + +word GESTURES, RL_GESTURES + +// word rgVector2Angle, RL_Vector2Angle +// word rgVector2Distance, RL_Vector2Distance +// word rgGetCurrentTime, RL_GetCurrentTime + +// rlgl.h +// This file has badly defined definitions, so I have to do a separate pass for it later. + +namespace rlgl, RLGL_ +namespace rl, RLGL_ + +namespace RL_OPENGL, RLGL_OPENGL + +// word RL_TEXTURE_MIN_FILTER, RLGL_TEXTURE_MIN_FILTE +// word RL_TEXTURE_MAG_FILTER, RLGL_TEXTURE_MAG_FILTER +// word RL_TEXTURE_FILTER_LINEAR, RLGL_TEXTURE_FILTER_LINEAR +// word RL_PROJECTION, RLGL_PROJECTION +// word RL_MODELVIEW, RLGL_MODELVIEW + +not include rlgl.h + +word TRACELOG, RL_TRACELOG + +word rlglInit, RLGL_Init +word rlglClose, RLGL_Close + +// utils.h + +// TRACELOG + +not include external/rl_gputex.h diff --git a/project/auxillary/vis_ast/dependencies/raylib/raylib_c_gl.refactor b/project/auxillary/vis_ast/dependencies/raylib/raylib_c_gl.refactor new file mode 100644 index 0000000..26b3975 --- /dev/null +++ b/project/auxillary/vis_ast/dependencies/raylib/raylib_c_gl.refactor @@ -0,0 +1,34 @@ +// rlgl.h + +//namespace rlgl, RL_ +namespace rl, RLGL_ +//namespace RL_, RLGL_ + +namespace RL_OPENGL, RLGL_OPENGL + +//word RLAPI, RLGLAPI + +not include rlgl.h + +word TRACELOG, RL_TRACELOG + +not word RL_TEXTURE_MIN_FILTER +not word RL_TEXTURE_MAG_FILTER +not word RL_TEXTURE_FILTER_LINEAR +not word RL_PROJECTION +not word RL_MODELVIEW +not word RL_LINES +not word RL_TRIANGLES +not word RL_QUADS +not word RL_FLOAT +not word RL_UNSIGNED_BYTE +not word RL_MATRIX + +word RLGL, RLGL_GLOBAL_DATA + +word Matrix, RL_Matrix + +word LOG_WARNING, RL_LOG_WARNING + +word rlglInit, RLGL_Init +word rlglClose, RLGL_Close diff --git a/project/auxillary/vis_ast/dependencies/raylib/raylib_refactor.cpp b/project/auxillary/vis_ast/dependencies/raylib/raylib_refactor.cpp index e66e773..7e5fddf 100644 --- a/project/auxillary/vis_ast/dependencies/raylib/raylib_refactor.cpp +++ b/project/auxillary/vis_ast/dependencies/raylib/raylib_refactor.cpp @@ -6,15 +6,24 @@ #include "gen.builder.cpp" -constexpr char const* path_config = "config.h"; -constexpr char const* path_raylib = "raylib.h"; -constexpr char const* path_raymath = "raymath.h"; -constexpr char const* path_rcamera = "rcamera.h"; -constexpr char const* path_rcore = "rcore.h"; -constexpr char const* path_rgestures = "rgestures.h"; -constexpr char const* path_rgl = "rgl.h"; -constexpr char const* path_rtext = "rtext.h"; +constexpr char const* path_config_h = "config.h"; +constexpr char const* path_raylib_h = "raylib.h"; +constexpr char const* path_raymath_h = "raymath.h"; +constexpr char const* path_rcamera_h = "rcamera.h"; +constexpr char const* path_rcore_h = "rcore.h"; +constexpr char const* path_rgestures_h = "rgestures.h"; +constexpr char const* path_rgl_h = "rgl.h"; +constexpr char const* path_rtext_h = "rtext.h"; +constexpr char const* path_rcore_desktop_c = "rcore_desktop.c"; + +constexpr char const* path_raudio_c = "raudio.c"; +constexpr char const* path_rcore_c = "rcore.c"; +constexpr char const* path_rglfw_c = "rglfw.c"; +constexpr char const* path_rmodels_c = "rmodels.c"; +constexpr char const* path_rtext_c = "rtext.c"; +constexpr char const* path_rtextures_c = "rtextures.c"; +constexpr char const* path_rutils_c = "rutils.c"; using namespace gen; @@ -117,6 +126,18 @@ StringCached pascal_to_lower_snake(StringCached str) return result; } +void refactor_define( CodeDefine& code ) +{ + local_persist String name_scratch = String::make_reserve( GlobalAllocator, kilobytes(1) ); + + if ( str_compare( elem->Name, txt("RL"), 2 ) == 0 || str_compare( elem->Name, txt("RAYLIB"), 6 ) == 0 ) + continue; + + name_scratch.append_fmt( "%RL_%S", elem->Name ); + elem->Name = get_cached_string( name_scratch ); + name_scratch.clear(); +} + void refactor_enum( CodeEnum& code ) { for ( Code elem : code->Body ) @@ -181,8 +202,11 @@ void refactor_typename( CodeType& type ) void refactor_fn( CodeFn& fn ) { + StringCached original_name = fn->Name; fn->Name = pascal_to_lower_snake( fn->Name ); + log_fmt( "%S", "Proc ID: %S -> %S", original_name, fn->Name ); + for ( CodeParam param : fn->Params ) { refactor_typename( param->ValueType ); @@ -206,9 +230,9 @@ void refactor_file( char const* path ) FileContents contents = file_read_contents( GlobalAllocator, true, path ); CodeBody code = parse_global_body( { contents.size, rcast(char const*, contents.data) } ); - String name_scratch = String::make_reserve( GlobalAllocator, kilobytes(1) ); + local_perist String name_scratch = String::make_reserve( GlobalAllocator, kilobytes(1) ); - // CodeBody includes + // CodeBody includes // CodeBody nspace_body = def_body( ECode::Namespace ); CodeBody new_code = def_body( ECode::Global_Body ); @@ -216,12 +240,7 @@ void refactor_file( char const* path ) { if ( elem->Type == ECode::Preprocess_Define ) { - if ( str_compare( elem->Name, txt("RL"), 2 ) == 0 || str_compare( elem->Name, txt("RAYLIB"), 6 ) == 0 ) - continue; - - name_scratch.append_fmt( "%RL_%S", elem->Name ); - elem->Name = get_cached_string( name_scratch ); - name_scratch.clear(); + refactor_define( elem.cast() ); } if ( elem->Type == ECode::Enum ) @@ -275,16 +294,29 @@ void refactor_file( char const* path ) Builder builder = Builder::open( path ); builder.print( new_code ); builder.write(); + + name_scratch.clear(); } int gen_main() { gen::init(); - refactor_file( path_config ); - refactor_file( path_raylib ); - refactor_file( path_raymath ); - refactor_file( path_rcamera ); + refactor_file( path_config_h ); + refactor_file( path_raylib_h ); + refactor_file( path_rcamera_h ); + refactor_file( path_raymath_h ); + refactor_file( path_rcore_h ); + refactor_file( path_rgl_h ); + refactor_file( path_rtext_h ); + + refactor_file( path_rcore_desktop_c ); + refactor_file( path_raudio_c ); + refactor_file( path_rcore_c ); + refactor_file( path_rglfw_c ); + refactor_file( path_rmodels_c ); + refactor_file( path_rtext_c ); + refactor_file( path_rutils_c ); return 0; } diff --git a/project/auxillary/vis_ast/update_deps.ps1 b/project/auxillary/vis_ast/update_deps.ps1 index 35367c7..77ffcc0 100644 --- a/project/auxillary/vis_ast/update_deps.ps1 +++ b/project/auxillary/vis_ast/update_deps.ps1 @@ -67,15 +67,17 @@ function setup-raylib { new-item -path $path_raylib_inc -ItemType Directory new-item -path $path_raylib_lib -ItemType Directory - $url_raylib_zip = 'https://github.com/raysan5/raylib/archive/refs/heads/master.zip' + $url_raylib_zip = 'https://github.com/Ed94/raylib_refactored/archive/refs/heads/refactor-support.zip' $path_raylib_zip = join-path $path_temp 'raylib.zip' - $path_raylib_master = join-path $path_temp 'raylib-master' + $path_raylib_master = join-path $path_temp 'raylib_refactored-refactor-support' $path_raylib_src = join-path $path_raylib_master 'src' + $path_raylib_platforms = join-path $path_raylib_src 'platforms' $path_raylib_glfw_inc = join-path $path_raylib_src 'external/glfw/include' + $path_raylib_gputex = join-path $path_raylib_src 'external/rl_gputex.h' remove-item $path_raylib_master -Recurse - # invoke-webrequest -uri $url_raylib_zip -outfile $path_raylib_zip + #invoke-webrequest -uri $url_raylib_zip -outfile $path_raylib_zip expand-archive -path $path_raylib_zip -destinationpath $path_temp write-host "Building raylib with $vendor" @@ -85,11 +87,79 @@ function setup-raylib { New-Item $path_build -ItemType Directory } - $raylib_headers = Get-ChildItem -Path $path_raylib_src -Filter "*.h" -File - $raylib_modules = get-childitem -path $path_raylib_src -filter "*.c" -file + $raylib_headers = Get-ChildItem -Path $path_raylib_src -Filter '*.h' -File + $raylib_modules = get-childitem -path $path_raylib_src -filter '*.c' -file - # Refactor raylib + # Refactor with refactor.exe if ( $true ) { + $path_refactor = join-path $path_raylib 'raylib_c.refactor' + $path_refactor_rlgl = join-path $path_raylib 'raylib_c_gl.refactor' + + $fmt_includes = @() + foreach ( $header in $raylib_headers ) { + $file_name = split-path $header -leaf + + if ( -not $file_name.Equals('rlgl.h' ) ) { + $fmt_includes += "$header" + } + } + foreach ( $module in $raylib_modules ) { + $fmt_includes += "$module" + } + + $fmt_includes += "$path_raylib_gputex" + + $platform_modules = @() + foreach ( $module in (get-childitem -path $path_raylib_platforms -filter '*.c' -file) ) { + $platform_modules += "$module" + } + + $path_rlgl = join-path $path_raylib_src 'rlgl.h' + + Push-Location $path_raylib_src + write-host "Beginning refactor...`n" + $refactors = @(@()) + $refactorParams = @( + "-debug", + "-num=$($fmt_includes.Count)" + "-src=$($fmt_includes)", + "-spec=$($path_refactor)" + ) + & refactor $refactorParams + Write-Host "`nRefactoring complete`n`n" + Pop-Location + + Push-Location $path_raylib_platforms + write-host "Beginning refactor...`n" + $refactors = @(@()) + $refactorParams = @( + "-debug", + "-num=$($platform_modules.Count)" + "-src=$($platform_modules)", + "-spec=$($path_refactor)" + ) + & refactor $refactorParams + Write-Host "`nRefactoring complete`n`n" + Pop-Location + + Push-Location $path_raylib_src + $gl_modules = @( "$path_rlgl", "$path_raylib_gputex" ) + + write-host "Beginning refactor just for rlgl.h...`n" + $refactors = @(@()) + $refactorParams = @( + "-debug", + "-num=$($gl_modules.Count)" + "-src=$($gl_modules)", + "-spec=$($path_refactor_rlgl)" + ) + & refactor $refactorParams + Write-Host "`nRefactoring complete`n`n" + Pop-Location + } + + # Refactor raylib with gencpp + if ( $false ) { # if ( $false ) { $path_gencpp = join-path $path_root 'project/gen' @@ -133,7 +203,7 @@ function setup-raylib { } # Build raylib - if ( $false ) { + if ( $true ) { # Microsoft $lib_gdi32 = 'Gdi32.lib' $lib_shell32 = 'Shell32.lib'