MrMonopoly/raylib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'raysan5:master' into Add-RL_POINTS

Browse Source
This commit is contained in:
Maicon Santana 2026-06-04 10:05:15 +01:00 committed by GitHub
commit 4b28f75aeb
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
32 changed files with 860 additions and 652 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -65,7 +65,7 @@ src/external/SDL3
# Emscripten # Emscripten
emsdk emsdk
# Ignore wasm data in examples/ # Ignore binaries generated in examples/
examples/**/* examples/**/*
!examples/**/*.* !examples/**/*.*
!examples/**/*/ !examples/**/*/

8
BINDINGS.md
View File

@ -11,7 +11,7 @@ Some people ported raylib to other languages in the form of bindings or wrappers
| [raylib-beef](https://github.com/Starpelly/raylib-beef) | **5.5** | [Beef](https://www.beeflang.org) | MIT | | [raylib-beef](https://github.com/Starpelly/raylib-beef) | **5.5** | [Beef](https://www.beeflang.org) | MIT |
| [raybit](https://github.com/Alex-Velez/raybit) | **5.0** | [Brainfuck](https://en.wikipedia.org/wiki/Brainfuck) | MIT | | [raybit](https://github.com/Alex-Velez/raybit) | **5.0** | [Brainfuck](https://en.wikipedia.org/wiki/Brainfuck) | MIT |
| [raylib-c3](https://github.com/c3lang/vendor/tree/main/libraries/raylib6.c3l) | **6** | [C3](https://c3-lang.org) | MIT | | [raylib-c3](https://github.com/c3lang/vendor/tree/main/libraries/raylib6.c3l) | **6** | [C3](https://c3-lang.org) | MIT |
| [raylib-cs](https://github.com/raylib-cs/raylib-cs) | **5.5** | [C#](https://en.wikipedia.org/wiki/C_Sharp_(programming_language)) | Zlib | | [raylib-cs](https://github.com/raylib-cs/raylib-cs) | **6.0** | [C#](https://en.wikipedia.org/wiki/C_Sharp_(programming_language)) | Zlib |
| [Raylib-CsLo](https://github.com/NotNotTech/Raylib-CsLo) | 4.2 | [C#](https://en.wikipedia.org/wiki/C_Sharp_(programming_language)) | MPL-2.0 | | [Raylib-CsLo](https://github.com/NotNotTech/Raylib-CsLo) | 4.2 | [C#](https://en.wikipedia.org/wiki/C_Sharp_(programming_language)) | MPL-2.0 |
| [Raylib-CSharp-Vinculum](https://github.com/ZeroElectric/Raylib-CSharp-Vinculum) | **5.0** | [C#](https://en.wikipedia.org/wiki/C_Sharp_(programming_language)) | MPL-2.0 | | [Raylib-CSharp-Vinculum](https://github.com/ZeroElectric/Raylib-CSharp-Vinculum) | **5.0** | [C#](https://en.wikipedia.org/wiki/C_Sharp_(programming_language)) | MPL-2.0 |
| [Raylib-CSharp](https://github.com/MrScautHD/Raylib-CSharp) | **5.5** | [C#](https://en.wikipedia.org/wiki/C_Sharp_(programming_language)) | MIT | | [Raylib-CSharp](https://github.com/MrScautHD/Raylib-CSharp) | **5.5** | [C#](https://en.wikipedia.org/wiki/C_Sharp_(programming_language)) | MIT |
@ -37,7 +37,7 @@ Some people ported raylib to other languages in the form of bindings or wrappers
| [raylib-freebasic](https://github.com/WIITD/raylib-freebasic) | **5.0** | [FreeBASIC](https://www.freebasic.net) | MIT | | [raylib-freebasic](https://github.com/WIITD/raylib-freebasic) | **5.0** | [FreeBASIC](https://www.freebasic.net) | MIT |
| [raylib.f](https://github.com/cthulhuology/raylib.f) | **5.5** | [Forth](https://forth.com) | Zlib | | [raylib.f](https://github.com/cthulhuology/raylib.f) | **5.5** | [Forth](https://forth.com) | Zlib |
| [fortran-raylib](https://github.com/interkosmos/fortran-raylib) | **5.5** | [Fortran](https://fortran-lang.org) | ISC | | [fortran-raylib](https://github.com/interkosmos/fortran-raylib) | **5.5** | [Fortran](https://fortran-lang.org) | ISC |
| [raylib-go](https://github.com/gen2brain/raylib-go) | **5.5** | [Go](https://golang.org) | Zlib | | [raylib-go](https://github.com/gen2brain/raylib-go) | **6.0** | [Go](https://golang.org) | Zlib |
| [raylib-guile](https://github.com/petelliott/raylib-guile) | **auto** | [Guile](https://www.gnu.org/software/guile) | Zlib | | [raylib-guile](https://github.com/petelliott/raylib-guile) | **auto** | [Guile](https://www.gnu.org/software/guile) | Zlib |
| [gforth-raylib](https://github.com/ArnautDaniel/gforth-raylib) | 3.5 | [Gforth](https://gforth.org) | **???** | | [gforth-raylib](https://github.com/ArnautDaniel/gforth-raylib) | 3.5 | [Gforth](https://gforth.org) | **???** |
| [h-raylib](https://github.com/Anut-py/h-raylib) | **5.5-dev** | [Haskell](https://haskell.org) | Apache-2.0 | | [h-raylib](https://github.com/Anut-py/h-raylib) | **5.5-dev** | [Haskell](https://haskell.org) | Apache-2.0 |
@ -49,7 +49,7 @@ Some people ported raylib to other languages in the form of bindings or wrappers
| [Raylib.jl](https://github.com/chengchingwen/Raylib.jl) | 4.2 | [Julia](https://julialang.org) | Zlib | | [Raylib.jl](https://github.com/chengchingwen/Raylib.jl) | 4.2 | [Julia](https://julialang.org) | Zlib |
| [kaylib](https://github.com/electronstudio/kaylib) | 3.7 | [Kotlin/native](https://kotlinlang.org) | **???** | | [kaylib](https://github.com/electronstudio/kaylib) | 3.7 | [Kotlin/native](https://kotlinlang.org) | **???** |
| [KaylibKit](https://codeberg.org/Kenta/KaylibKit) | 4.5 | [Kotlin/native](https://kotlinlang.org) | Zlib | | [KaylibKit](https://codeberg.org/Kenta/KaylibKit) | 4.5 | [Kotlin/native](https://kotlinlang.org) | Zlib |
| [raylib-lua](https://github.com/TSnake41/raylib-lua) | 5.0 | [Lua](http://www.lua.org) | ISC | | [raylib-lua](https://github.com/TSnake41/raylib-lua) | 5.5 | [Lua](http://www.lua.org) | ISC |
| [raylib-lua-bindings (WIP)](https://github.com/legendaryredfox/raylib-lua-bindings) | 5.5 | [Lua](http://www.lua.org) | ISC | | [raylib-lua-bindings (WIP)](https://github.com/legendaryredfox/raylib-lua-bindings) | 5.5 | [Lua](http://www.lua.org) | ISC |
| [ReiLua](https://github.com/nullstare/ReiLua) | 5.5 | [Lua](http://www.lua.org) | MIT | | [ReiLua](https://github.com/nullstare/ReiLua) | 5.5 | [Lua](http://www.lua.org) | MIT |
| [raylib-lua-sol](https://github.com/RobLoach/raylib-lua-sol) | 5.5 | [Lua](http://www.lua.org) | Zlib | | [raylib-lua-sol](https://github.com/RobLoach/raylib-lua-sol) | 5.5 | [Lua](http://www.lua.org) | Zlib |
@ -90,7 +90,7 @@ Some people ported raylib to other languages in the form of bindings or wrappers
| [raylib-vapi](https://github.com/lxmcf/raylib-vapi) | **6.0** | [Vala](https://vala.dev) | Zlib | | [raylib-vapi](https://github.com/lxmcf/raylib-vapi) | **6.0** | [Vala](https://vala.dev) | Zlib |
| [raylib-wave](https://github.com/wavefnd/raylib-wave) | **auto** |[Wave](http://wave-lang.dev) | Zlib | | [raylib-wave](https://github.com/wavefnd/raylib-wave) | **auto** |[Wave](http://wave-lang.dev) | Zlib |
| [raylib-wren](https://github.com/TSnake41/raylib-wren) | 4.5 | [Wren](http://wren.io) | ISC | | [raylib-wren](https://github.com/TSnake41/raylib-wren) | 4.5 | [Wren](http://wren.io) | ISC |
| [raylib-zig](https://github.com/raylib-zig/raylib-zig) | **5.6-dev** | [Zig](https://ziglang.org) | MIT | | [raylib-zig](https://github.com/raylib-zig/raylib-zig) | **6.0** | [Zig](https://ziglang.org) | MIT |
| [raylib.zig](https://github.com/ryupold/raylib.zig) | **5.1-dev** | [Zig](https://ziglang.org) | MIT | | [raylib.zig](https://github.com/ryupold/raylib.zig) | **5.1-dev** | [Zig](https://ziglang.org) | MIT |
| [raylib-zig-bindings](https://github.com/L-Briand/raylib-zig-bindings) | **5.0** | [Zig](https://ziglang.org) | Zlib | | [raylib-zig-bindings](https://github.com/L-Briand/raylib-zig-bindings) | **5.0** | [Zig](https://ziglang.org) | Zlib |
| [hare-raylib](https://git.sr.ht/~evantj/hare-raylib) | **auto** | [Hare](https://harelang.org) | Zlib | | [hare-raylib](https://git.sr.ht/~evantj/hare-raylib) | **auto** | [Hare](https://harelang.org) | Zlib |

4
CMakeLists.txt
View File

@ -1,4 +1,4 @@
cmake_minimum_required(VERSION 3.25) cmake_minimum_required(VERSION 3.22)
#this change avoid the warning that appear when we include raylib using Cmake fatch content #this change avoid the warning that appear when we include raylib using Cmake fatch content
project(raylib) project(raylib)
@ -29,7 +29,7 @@ include(CompilerFlags)
# Registers build options that are exposed to cmake # Registers build options that are exposed to cmake
include(CMakeOptions.txt) include(CMakeOptions.txt)
if (UNIX AND NOT APPLE AND NOT "${PLATFORM}" MATCHES "DRM" AND NOT "${PLATFORM}" MATCHES "Web") if (UNIX AND NOT APPLE AND NOT "${PLATFORM}" MATCHES "DRM" AND NOT "${PLATFORM}" MATCHES "Web" AND NOT "${PLATFORM}" MATCHES "SDL")
if (NOT GLFW_BUILD_WAYLAND AND NOT GLFW_BUILD_X11) if (NOT GLFW_BUILD_WAYLAND AND NOT GLFW_BUILD_X11)
message(FATAL_ERROR "Cannot disable both Wayland and X11") message(FATAL_ERROR "Cannot disable both Wayland and X11")
endif() endif()

1
build.zig
View File

@ -739,7 +739,6 @@ fn addExamples(
.root_module = exe_mod, .root_module = exe_mod,
.use_lld = target.result.os.tag == .windows, .use_lld = target.result.os.tag == .windows,
}); });
b.installArtifact(exe);
const install_cmd = b.addInstallArtifact(exe, .{ .dest_sub_path = b.fmt("{s}/{s}", .{ module, filename }) }); const install_cmd = b.addInstallArtifact(exe, .{ .dest_sub_path = b.fmt("{s}/{s}", .{ module, filename }) });

20
examples/models/models_animation_blending.c
View File

@ -53,13 +53,19 @@ int main(void)
Model model = LoadModel("resources/models/gltf/robot.glb"); // Load character model Model model = LoadModel("resources/models/gltf/robot.glb"); // Load character model
Vector3 position = { 0.0f, 0.0f, 0.0f }; // Set model world position Vector3 position = { 0.0f, 0.0f, 0.0f }; // Set model world position
#if SUPPORT_GPU_SKINNING
// WARNING: SUPPORT_GPU_SKINNING is required to be enabled at raylib compile time (disabled by default)
// It will skip loading CPU required buffers to store animation updated data, so, both modes are exclusive
// Load skinning shader // Load skinning shader
// WARNING: It requires SUPPORT_GPU_SKINNING enabled on raylib (disabled by default) // NOTE: It must be a valid shader, following raylib attribs/uniform conventions for GPU skinning
Shader skinningShader = LoadShader(TextFormat("resources/shaders/glsl%i/skinning.vs", GLSL_VERSION), Shader skinningShader = LoadShader(TextFormat("resources/shaders/glsl%i/skinning.vs", GLSL_VERSION),
TextFormat("resources/shaders/glsl%i/skinning.fs", GLSL_VERSION)); TextFormat("resources/shaders/glsl%i/skinning.fs", GLSL_VERSION));
// Assign skinning shader to all materials shaders // Skinning shader could be required to be assigned to all materials shaders, just to make
//for (int i = 0; i < model.materialCount; i++) model.materials[i].shader = skinningShader; // sure required uniforms are being updated for the mesh using that material (and shader)
for (int i = 0; i < model.materialCount; i++) model.materials[i].shader = skinningShader;
#endif
// Load model animations // Load model animations
int animCount = 0; int animCount = 0;
@ -244,6 +250,12 @@ int main(void)
if (GuiDropdownBox((Rectangle){ GetScreenWidth() - 170.0f, 10, 160, 24 }, TextJoin(animNames, animCount, ";"), if (GuiDropdownBox((Rectangle){ GetScreenWidth() - 170.0f, 10, 160, 24 }, TextJoin(animNames, animCount, ";"),
&animIndex1, dropdownEditMode1)) dropdownEditMode1 = !dropdownEditMode1; &animIndex1, dropdownEditMode1)) dropdownEditMode1 = !dropdownEditMode1;
GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_CENTER);
GuiSetStyle(DEFAULT, TEXT_SIZE, GuiGetFont().baseSize*2);
GuiLabel((Rectangle){ 0, GetScreenHeight() - 100.0f, GetScreenWidth(), 40 }, "PRESS SPACE to START BLENDING");
GuiSetStyle(DEFAULT, TEXT_SIZE, GuiGetFont().baseSize);
GuiSetStyle(LABEL, TEXT_ALIGNMENT, TEXT_ALIGN_LEFT);
// Draw playing timeline with keyframes for anim0[] // Draw playing timeline with keyframes for anim0[]
GuiProgressBar((Rectangle){ 60, GetScreenHeight() - 60.0f, GetScreenWidth() - 180.0f, 20 }, "ANIM 0", GuiProgressBar((Rectangle){ 60, GetScreenHeight() - 60.0f, GetScreenWidth() - 180.0f, 20 }, "ANIM 0",
TextFormat("FRAME: %.2f / %i", animFrameProgress0, anims[animIndex0].keyframeCount), TextFormat("FRAME: %.2f / %i", animFrameProgress0, anims[animIndex0].keyframeCount),
@ -269,7 +281,9 @@ int main(void)
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
UnloadModelAnimations(anims, animCount); // Unload model animation UnloadModelAnimations(anims, animCount); // Unload model animation
UnloadModel(model); // Unload model and meshes/material UnloadModel(model); // Unload model and meshes/material
#if SUPPORT_GPU_SKINNING
UnloadShader(skinningShader); // Unload GPU skinning shader UnloadShader(skinningShader); // Unload GPU skinning shader
#endif
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------

17
examples/models/models_animation_gpu_skinning.c
View File

@ -52,12 +52,19 @@ int main(void)
Model model = LoadModel("resources/models/gltf/greenman.glb"); // Load character model Model model = LoadModel("resources/models/gltf/greenman.glb"); // Load character model
Vector3 position = { 0.0f, 0.0f, 0.0f }; // Set model position Vector3 position = { 0.0f, 0.0f, 0.0f }; // Set model position
#if SUPPORT_GPU_SKINNING
// WARNING: SUPPORT_GPU_SKINNING is required to be enabled at raylib compile time (disabled by default)
// It will skip loading CPU required buffers to store animation updated data, so, both modes are exclusive
// Load skinning shader // Load skinning shader
// WARNING: GPU skinning must be enabled in raylib with a compilation flag, // NOTE: It must be a valid shader, following raylib attribs/uniform conventions for GPU skinning
// if not enabled, CPU skinning will be used instead
Shader skinningShader = LoadShader(TextFormat("resources/shaders/glsl%i/skinning.vs", GLSL_VERSION), Shader skinningShader = LoadShader(TextFormat("resources/shaders/glsl%i/skinning.vs", GLSL_VERSION),
TextFormat("resources/shaders/glsl%i/skinning.fs", GLSL_VERSION)); TextFormat("resources/shaders/glsl%i/skinning.fs", GLSL_VERSION));
model.materials[1].shader = skinningShader;
// Skinning shader could be required to be assigned to all materials shaders, just to make
// sure required uniforms are being updated for the mesh using that material (and shader)
model.materials[1].shader = skinningShader; // Just assigning to materials[1] for this model
#endif
// Load gltf model animations // Load gltf model animations
int animCount = 0; int animCount = 0;
@ -111,7 +118,9 @@ int main(void)
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
UnloadModelAnimations(anims, animCount); // Unload model animation UnloadModelAnimations(anims, animCount); // Unload model animation
UnloadModel(model); // Unload model and meshes/material UnloadModel(model); // Unload model and meshes/material
#if SUPPORT_GPU_SKINNING
UnloadShader(skinningShader); // Unload GPU skinning shader UnloadShader(skinningShader); // Unload GPU skinning shader
#endif
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------

2
examples/others/raylib_opengl_interop.c
View File

@ -28,7 +28,7 @@
#include "raylib.h" #include "raylib.h"
#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL) #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_DESKTOP_SDL) || defined(PLATFORM_DESKTOP_RGFW)
#if defined(GRAPHICS_API_OPENGL_ES2) #if defined(GRAPHICS_API_OPENGL_ES2)
#include "glad_gles2.h" // Required for: OpenGL functionality #include "glad_gles2.h" // Required for: OpenGL functionality
#define glGenVertexArrays glGenVertexArraysOES #define glGenVertexArrays glGenVertexArraysOES

18
src/CMakeLists.txt
View File

@ -30,14 +30,22 @@ set(raylib_public_headers
# Sources to be compiled # Sources to be compiled
set(raylib_sources set(raylib_sources
raudio.c
rcore.c rcore.c
rmodels.c
rshapes.c rshapes.c
rtext.c rtext.c
rtextures.c rtextures.c
) )
# Only build raudio if it's enabled
if (NOT DEFINED SUPPORT_MODULE_RAUDIO OR SUPPORT_MODULE_RAUDIO)
list(APPEND raylib_sources raudio.c)
endif()
# Only build rmodels if it's enabled
if (NOT DEFINED SUPPORT_MODULE_RMODELS OR SUPPORT_MODULE_RMODELS)
list(APPEND raylib_sources rmodels.c)
endif()
# <root>/cmake/GlfwImport.cmake handles the details around the inclusion of glfw # <root>/cmake/GlfwImport.cmake handles the details around the inclusion of glfw
if (NOT ${PLATFORM} MATCHES "Web") if (NOT ${PLATFORM} MATCHES "Web")
include(GlfwImport) include(GlfwImport)
@ -48,10 +56,10 @@ endif ()
# Produces a variable LIBS_PRIVATE that will be used later # Produces a variable LIBS_PRIVATE that will be used later
include(LibraryConfigurations) include(LibraryConfigurations)
if (SUPPORT_MODULE_RAUDIO) if (DEFINED SUPPORT_MODULE_RAUDIO AND NOT SUPPORT_MODULE_RAUDIO)
MESSAGE(STATUS "Audio Backend: miniaudio")
else ()
MESSAGE(STATUS "Audio Backend: None (-DCUSTOMIZE_BUILD=ON -DSUPPORT_MODULE_RAUDIO=OFF)") MESSAGE(STATUS "Audio Backend: None (-DCUSTOMIZE_BUILD=ON -DSUPPORT_MODULE_RAUDIO=OFF)")
else ()
MESSAGE(STATUS "Audio Backend: miniaudio")
endif () endif ()
add_library(raylib ${raylib_sources} ${raylib_public_headers}) add_library(raylib ${raylib_sources} ${raylib_public_headers})

3
src/Makefile
View File

@ -240,6 +240,9 @@ ifeq ($(TARGET_PLATFORM),PLATFORM_ANDROID)
ifeq ($(ANDROID_ARCH),x86_64) ifeq ($(ANDROID_ARCH),x86_64)
ANDROID_COMPILER_ARCH = x86_64 ANDROID_COMPILER_ARCH = x86_64
endif endif
ifndef ANDROID_COMPILER_ARCH
$(error ANDROID_COMPILER_ARCH: Unknown ANDROID_ARCH=$(ANDROID_ARCH))
endif
endif endif
# Define raylib graphics api depending on selected platform # Define raylib graphics api depending on selected platform

4
src/external/miniaudio.h vendored
View File

@ -41495,11 +41495,11 @@ Web Audio Backend
#ifdef MA_HAS_WEBAUDIO #ifdef MA_HAS_WEBAUDIO
#include <emscripten/emscripten.h> #include <emscripten/emscripten.h>
#if (__EMSCRIPTEN_major__ > 3) || (__EMSCRIPTEN_major__ == 3 && (__EMSCRIPTEN_minor__ > 1 || (__EMSCRIPTEN_minor__ == 1 && __EMSCRIPTEN_tiny__ >= 32))) #if (__EMSCRIPTEN_MAJOR__ > 3) || (__EMSCRIPTEN_MAJOR__ == 3 && (__EMSCRIPTEN_MINOR__ > 1 || (__EMSCRIPTEN_MINOR__ == 1 && __EMSCRIPTEN_TINY__ >= 32)))
#include <emscripten/webaudio.h> #include <emscripten/webaudio.h>
#define MA_SUPPORT_AUDIO_WORKLETS #define MA_SUPPORT_AUDIO_WORKLETS
#if (__EMSCRIPTEN_major__ > 3) || (__EMSCRIPTEN_major__ == 3 && (__EMSCRIPTEN_minor__ > 1 || (__EMSCRIPTEN_minor__ == 1 && __EMSCRIPTEN_tiny__ >= 70))) #if (__EMSCRIPTEN_MAJOR__ > 3) || (__EMSCRIPTEN_MAJOR__ == 3 && (__EMSCRIPTEN_MINOR__ > 1 || (__EMSCRIPTEN_MINOR__ == 1 && __EMSCRIPTEN_TINY__ >= 70)))
#define MA_SUPPORT_AUDIO_WORKLETS_VARIABLE_BUFFER_SIZE #define MA_SUPPORT_AUDIO_WORKLETS_VARIABLE_BUFFER_SIZE
#endif #endif
#endif #endif

291
src/external/rlsw.h vendored
View File

@ -164,18 +164,10 @@
#endif #endif
#endif #endif
// Fast power-of-two texture wrap (SW_REPEAT mode only) // Full NPOT texture support (enabled by default)
// When defined, textures whose width/height are powers of two use a bitmask // When disabled, SW_REPEAT requires POT on its axis (fast bitmask wrap)
// wrap (`x & (size-1)`) instead of `floorf`-based fractional wrap or the // SW_CLAMP remains supported for any dimension, per-axis
// signed `%` chain in the linear sampler. Saves a software divide on Xtensa #define SW_SUPPORT_NPOT_TEXTURE true
// and a few instructions everywhere. NPOT textures keep using the original
// path via a runtime `(size & (size-1)) == 0` check, so SW_REPEAT remains
// correct for them. The only observable behavior change is for POT textures
// sampled with negative UV coordinates: bitmask wrap (two's complement) can
// differ from `sw_fract` by one texel. Off by default to keep bit-for-bit
// behavior; opt in if you control your asset UVs.
//
// #define SW_TEXTURE_REPEAT_POT_FAST
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// OpenGL Compatibility Types // OpenGL Compatibility Types
@ -860,11 +852,9 @@ SWAPI void swGetFramebufferAttachmentParameteriv(SWattachment attachment, SWatta
#endif #endif
// ESP-DSP acceleration: ESP-IDF ships an optimized math library that includes // ESP-DSP acceleration: ESP-IDF ships an optimized math library that includes
// `dspm_mult_4x4x4_f32` (4x4 matrix multiply) and `dspm_mult_4x4x1_f32` // `dspm_mult_4x4x4_f32` (4x4 matrix multiply) and `dspm_mult_4x4x1_f32` (matrix * vector)
// (matrix * vector). These are S3-tuned hand-vectorized kernels that beat the // These are S3-tuned hand-vectorized kernels that beat the scalar versions for both throughput and code-size
// scalar versions for both throughput and code-size. Detection is opt-in to // Detection is opt-in to keep the dependency optional: define SW_USE_ESP_DSP from your build system
// keep the dependency optional: define SW_USE_ESP_DSP from your build system
// (or rely on the `idf_component.yml` example shown in the rlsw docs).
#if defined(ESP_PLATFORM) && defined(SW_USE_ESP_DSP) #if defined(ESP_PLATFORM) && defined(SW_USE_ESP_DSP)
#define SW_HAS_ESP_DSP #define SW_HAS_ESP_DSP
#include "dspm_mult.h" #include "dspm_mult.h"
@ -884,41 +874,41 @@ SWAPI void swGetFramebufferAttachmentParameteriv(SWattachment attachment, SWatta
#define SW_DEG2RAD (SW_PI/180.0f) #define SW_DEG2RAD (SW_PI/180.0f)
#define SW_RAD2DEG (180.0f/SW_PI) #define SW_RAD2DEG (180.0f/SW_PI)
// When clipping a convex polygon against a plane, at most one vertex is added. // When clipping a convex polygon against a plane, at most one vertex is added
// Starting from a quadrilateral (4 vertices), clipped sequentially against // Starting from a quadrilateral (4 vertices), clipped sequentially against
// the frustum (6 planes) then the scissor rectangle (4 planes): // the frustum (6 planes) then the scissor rectangle (4 planes):
// 4 + 6 + 4 = 14 vertices maximum. // 4 + 6 + 4 = 14 vertices maximum
#define SW_MAX_CLIPPED_POLYGON_VERTICES 14 #define SW_MAX_CLIPPED_POLYGON_VERTICES 14
#define SW_CLIP_EPSILON 1e-4f #define SW_CLIP_EPSILON 1e-4f
#define SW_HANDLE_NULL 0u #define SW_HANDLE_NULL 0u
#define SW_POOL_SLOT_LIVE 0x80u // bit7 of the generation byte #define SW_POOL_SLOT_LIVE 0x80u // bit7 of the generation byte
#define SW_POOL_SLOT_VER_MASK 0x7Fu // bits6:0 = anti-ABA counter #define SW_POOL_SLOT_VER_MASK 0x7Fu // bits6:0 = anti-ABA counter
#define SW_CONCAT(a, b) a##b #define SW_CONCAT(a, b) a##b
#define SW_CONCATX(a, b) SW_CONCAT(a, b) #define SW_CONCATX(a, b) SW_CONCAT(a, b)
#define SW_FRAMEBUFFER_COLOR8_GET(c,p,o) SW_CONCATX(sw_pixel_read_color8_, SW_FRAMEBUFFER_COLOR_TYPE)((c),(p),(o)) #define SW_FRAMEBUFFER_COLOR8_GET(c,p,o) SW_CONCATX(sw_pixel_read_color8_, SW_FRAMEBUFFER_COLOR_TYPE)((c),(p),(o))
#define SW_FRAMEBUFFER_COLOR_GET(c,p,o) SW_CONCATX(sw_pixel_read_color_, SW_FRAMEBUFFER_COLOR_TYPE)((c),(p),(o)) #define SW_FRAMEBUFFER_COLOR_GET(c,p,o) SW_CONCATX(sw_pixel_read_color_, SW_FRAMEBUFFER_COLOR_TYPE)((c),(p),(o))
#define SW_FRAMEBUFFER_COLOR_SET(p,c,o) SW_CONCATX(sw_pixel_write_color_, SW_FRAMEBUFFER_COLOR_TYPE)((p),(c),(o)) #define SW_FRAMEBUFFER_COLOR_SET(p,c,o) SW_CONCATX(sw_pixel_write_color_, SW_FRAMEBUFFER_COLOR_TYPE)((p),(c),(o))
#define SW_FRAMEBUFFER_DEPTH_GET(p,o) SW_CONCATX(sw_pixel_read_depth_, SW_FRAMEBUFFER_DEPTH_TYPE)((p),(o)) #define SW_FRAMEBUFFER_DEPTH_GET(p,o) SW_CONCATX(sw_pixel_read_depth_, SW_FRAMEBUFFER_DEPTH_TYPE)((p),(o))
#define SW_FRAMEBUFFER_DEPTH_SET(p,d,o) SW_CONCATX(sw_pixel_write_depth_, SW_FRAMEBUFFER_DEPTH_TYPE)((p),(d),(o)) #define SW_FRAMEBUFFER_DEPTH_SET(p,d,o) SW_CONCATX(sw_pixel_write_depth_, SW_FRAMEBUFFER_DEPTH_TYPE)((p),(d),(o))
#define SW_FRAMEBUFFER_COLOR_FORMAT SW_CONCATX(SW_PIXELFORMAT_COLOR_, SW_FRAMEBUFFER_COLOR_TYPE) #define SW_FRAMEBUFFER_COLOR_FORMAT SW_CONCATX(SW_PIXELFORMAT_COLOR_, SW_FRAMEBUFFER_COLOR_TYPE)
#define SW_FRAMEBUFFER_DEPTH_FORMAT SW_CONCATX(SW_PIXELFORMAT_DEPTH_, SW_FRAMEBUFFER_DEPTH_TYPE) #define SW_FRAMEBUFFER_DEPTH_FORMAT SW_CONCATX(SW_PIXELFORMAT_DEPTH_, SW_FRAMEBUFFER_DEPTH_TYPE)
#define SW_FRAMEBUFFER_COLOR_SIZE SW_PIXELFORMAT_SIZE[SW_FRAMEBUFFER_COLOR_FORMAT] #define SW_FRAMEBUFFER_COLOR_SIZE SW_PIXELFORMAT_SIZE[SW_FRAMEBUFFER_COLOR_FORMAT]
#define SW_FRAMEBUFFER_DEPTH_SIZE SW_PIXELFORMAT_SIZE[SW_FRAMEBUFFER_DEPTH_FORMAT] #define SW_FRAMEBUFFER_DEPTH_SIZE SW_PIXELFORMAT_SIZE[SW_FRAMEBUFFER_DEPTH_FORMAT]
#define SW_STATE_SCISSOR_TEST (1 << 0) #define SW_STATE_SCISSOR_TEST (1 << 0)
#define SW_STATE_TEXTURE_2D (1 << 1) #define SW_STATE_TEXTURE_2D (1 << 1)
#define SW_STATE_DEPTH_TEST (1 << 2) #define SW_STATE_DEPTH_TEST (1 << 2)
#define SW_STATE_CULL_FACE (1 << 3) #define SW_STATE_CULL_FACE (1 << 3)
#define SW_STATE_BLEND (1 << 4) #define SW_STATE_BLEND (1 << 4)
#define SW_BLEND_FLAG_NOOP (1 << 0) #define SW_BLEND_FLAG_NOOP (1 << 0)
#define SW_BLEND_FLAG_NEEDS_ALPHA (1 << 1) #define SW_BLEND_FLAG_NEEDS_ALPHA (1 << 1)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Module Types and Structures Definition // Module Types and Structures Definition
@ -1175,7 +1165,7 @@ static inline void sw_matrix_mul_rst(float *SW_RESTRICT dst, const float *SW_RES
// column-major, so passing them flat is equivalent to passing transposes: // column-major, so passing them flat is equivalent to passing transposes:
// dspm_mult(L^T, R^T) computes (L^T)*(R^T) = (R*L)^T, written back into a // dspm_mult(L^T, R^T) computes (L^T)*(R^T) = (R*L)^T, written back into a
// flat array gives the same bit pattern as the column-major product (R*L) // flat array gives the same bit pattern as the column-major product (R*L)
// -- exactly the semantic the scalar fallback below has. // -- exactly the semantic the scalar fallback below has
dspm_mult_4x4x4_f32(left, right, dst); dspm_mult_4x4x4_f32(left, right, dst);
#else #else
float l00 = left[0], l01 = left[1], l02 = left[2], l03 = left[3]; float l00 = left[0], l01 = left[1], l02 = left[2], l03 = left[3];
@ -1248,12 +1238,12 @@ static inline float sw_fract(float x)
return (x - floorf(x)); return (x - floorf(x));
} }
// Fast reciprocal: 1-ULP accurate in ~7 instructions on Xtensa using the // Xtensa architecture optimization
// hardware `recip0.s` seed + two Newton-Raphson refinement steps. All work // Fast reciprocal: 1-ULP accurate in ~7 instructions using the
// stays in FPU registers — no `__divsf3` software call. Hot-path divisions // hardware `recip0.s` seed + two Newton-Raphson refinement steps
// in the rasterizer (span/triangle setup, perspective divide, etc.) call // All work stays in FPU registers — no `__divsf3` software call
// this. On non-Xtensa targets it transparently expands to `1.0f / x`, so // Hot-path divisions in the rasterizer (span/triangle setup, perspective divide, etc.) call this
// generated code is identical to before. // On non-Xtensa targets it transparently expands to `1.0f / x`, so generated code is identical to before
#if defined(__XTENSA__) #if defined(__XTENSA__)
__attribute__((always_inline)) __attribute__((always_inline))
static inline float sw_rcp(float x) static inline float sw_rcp(float x)
@ -2409,6 +2399,14 @@ static inline bool sw_texture_alloc(sw_texture_t *texture, const void *data, int
int bpp = SW_PIXELFORMAT_SIZE[format]; int bpp = SW_PIXELFORMAT_SIZE[format];
int newSize = w*h*bpp; int newSize = w*h*bpp;
if (texture->pixels == NULL)
{
texture->minFilter = SW_NEAREST;
texture->magFilter = SW_NEAREST;
texture->sWrap = SW_CLAMP;
texture->tWrap = SW_CLAMP;
}
if (newSize > texture->allocSz) if (newSize > texture->allocSz)
{ {
void *ptr = SW_REALLOC(texture->pixels, newSize); void *ptr = SW_REALLOC(texture->pixels, newSize);
@ -2473,38 +2471,25 @@ static inline void sw_texture_sample_nearest(float *SW_RESTRICT color, const sw_
{ {
int x, y; int x, y;
#ifdef SW_TEXTURE_REPEAT_POT_FAST #if SW_SUPPORT_NPOT_TEXTURE
if ((tex->sWrap == SW_REPEAT) && ((tex->width & tex->wMinus1) == 0)) if (tex->sWrap == SW_REPEAT) x = (int)(sw_fract(u)*tex->width);
{ else x = (int)(sw_saturate(u)*tex->width);
x = (int)(u*tex->width) & tex->wMinus1;
}
else
#endif
{
u = (tex->sWrap == SW_REPEAT)? sw_fract(u) : sw_saturate(u);
x = (int)(u*tex->width);
}
#ifdef SW_TEXTURE_REPEAT_POT_FAST if (tex->tWrap == SW_REPEAT) y = (int)(sw_fract(v)*tex->height);
if ((tex->tWrap == SW_REPEAT) && ((tex->height & tex->hMinus1) == 0)) else y = (int)(sw_saturate(v)*tex->height);
{ #else
y = (int)(v*tex->height) & tex->hMinus1; if (tex->sWrap == SW_REPEAT) x = (int)(u*tex->width) & tex->wMinus1;
} else x = (int)(sw_saturate(u)*tex->width);
else
if (tex->tWrap == SW_REPEAT) y = (int)(v*tex->height) & tex->hMinus1;
else y = (int)(sw_saturate(v)*tex->height);
#endif #endif
{
v = (tex->tWrap == SW_REPEAT)? sw_fract(v) : sw_saturate(v);
y = (int)(v*tex->height);
}
tex->readColor(color, tex->pixels, y*tex->width + x); tex->readColor(color, tex->pixels, y*tex->width + x);
} }
static inline void sw_texture_sample_linear(float *SW_RESTRICT color, const sw_texture_t *SW_RESTRICT tex, float u, float v) static inline void sw_texture_sample_linear(float *SW_RESTRICT color, const sw_texture_t *SW_RESTRICT tex, float u, float v)
{ {
// TODO: With a bit more cleverness the number of operations can
// be clearly reduced, but for now it works fine
float xf = (u*tex->width) - 0.5f; float xf = (u*tex->width) - 0.5f;
float yf = (v*tex->height) - 0.5f; float yf = (v*tex->height) - 0.5f;
@ -2517,41 +2502,36 @@ static inline void sw_texture_sample_linear(float *SW_RESTRICT color, const sw_t
int x1 = x0 + 1; int x1 = x0 + 1;
int y1 = y0 + 1; int y1 = y0 + 1;
if (tex->sWrap == SW_CLAMP) if (tex->sWrap == SW_REPEAT)
{
x0 = (x0 > tex->wMinus1)? tex->wMinus1 : x0;
x1 = (x1 > tex->wMinus1)? tex->wMinus1 : x1;
}
#ifdef SW_TEXTURE_REPEAT_POT_FAST
else if ((tex->width & tex->wMinus1) == 0)
{
// POT fast path: bitmask wrap covers negative ints via two's complement
x0 = x0 & tex->wMinus1;
x1 = x1 & tex->wMinus1;
}
#endif
else
{ {
#if SW_SUPPORT_NPOT_TEXTURE
x0 = (x0%tex->width + tex->width)%tex->width; x0 = (x0%tex->width + tex->width)%tex->width;
x1 = (x1%tex->width + tex->width)%tex->width; x1 = (x1%tex->width + tex->width)%tex->width;
#else
x0 = x0 & tex->wMinus1;
x1 = x1 & tex->wMinus1;
#endif
} }
if (tex->tWrap == SW_CLAMP)
{
y0 = (y0 > tex->hMinus1)? tex->hMinus1 : y0;
y1 = (y1 > tex->hMinus1)? tex->hMinus1 : y1;
}
#ifdef SW_TEXTURE_REPEAT_POT_FAST
else if ((tex->height & tex->hMinus1) == 0)
{
y0 = y0 & tex->hMinus1;
y1 = y1 & tex->hMinus1;
}
#endif
else else
{ {
x0 = sw_clamp_int(x0, 0, tex->wMinus1);
x1 = sw_clamp_int(x1, 0, tex->wMinus1);
}
if (tex->tWrap == SW_REPEAT)
{
#if SW_SUPPORT_NPOT_TEXTURE
y0 = (y0%tex->height + tex->height)%tex->height; y0 = (y0%tex->height + tex->height)%tex->height;
y1 = (y1%tex->height + tex->height)%tex->height; y1 = (y1%tex->height + tex->height)%tex->height;
#else
y0 = y0 & tex->hMinus1;
y1 = y1 & tex->hMinus1;
#endif
}
else
{
y0 = sw_clamp_int(y0, 0, tex->hMinus1);
y1 = sw_clamp_int(y1, 0, tex->hMinus1);
} }
float c00[4], c10[4], c01[4], c11[4]; float c00[4], c10[4], c01[4], c11[4];
@ -3558,8 +3538,8 @@ static inline bool sw_quad_face_culling(void)
// winding in the projected space when all w > 0 // winding in the projected space when all w > 0
// A value of 0 for sgnArea means P0, P1, P2 are collinear in (x, y, w) // A value of 0 for sgnArea means P0, P1, P2 are collinear in (x, y, w)
// space, which corresponds to a degenerate triangle projection // space, which corresponds to a degenerate triangle projection
// Such quads might also be degenerate or non-planar. They are typically // Such quads might also be degenerate or non-planar
// not culled by this test (0 < 0 is false, 0 > 0 is false) // They are typically not culled by this test (0 < 0 is false, 0 > 0 is false)
// and should be handled by the clipper if necessary // and should be handled by the clipper if necessary
return (RLSW.cullFace == SW_FRONT)? (sgnArea < 0.0f) : (sgnArea > 0.0f); // Cull if winding is "clockwise" : "counter-clockwise" return (RLSW.cullFace == SW_FRONT)? (sgnArea < 0.0f) : (sgnArea > 0.0f); // Cull if winding is "clockwise" : "counter-clockwise"
@ -3879,8 +3859,7 @@ static inline void sw_poly_fill_render(uint32_t state)
//------------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------------
static void sw_immediate_begin(SWdraw mode) static void sw_immediate_begin(SWdraw mode)
{ {
// NOTE: Any checks to ensure command recording can start // NOTE: Any checks to ensure command recording can start must be performed before calling this function
// must be performed before calling this function.
// Recalculate the MVP if this is needed // Recalculate the MVP if this is needed
if (RLSW.isDirtyMVP) if (RLSW.isDirtyMVP)
@ -3891,8 +3870,8 @@ static void sw_immediate_begin(SWdraw mode)
#ifdef SW_HAS_ESP_DSP #ifdef SW_HAS_ESP_DSP
// Pre-transpose to row-major so dspm_mult_4x4x1_f32(matMVP_rm, v, out) // Pre-transpose to row-major so dspm_mult_4x4x1_f32(matMVP_rm, v, out)
// computes M*v directly in the per-vertex hot path. 16 scalar copies // computes M*v directly in the per-vertex hot path; 16 scalar copies
// per MVP update vs. saving ~20 cycles per vertex transform. // per MVP update vs saving ~20 cycles per vertex transform
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
for (int j = 0; j < 4; j++) for (int j = 0; j < 4; j++)
@ -3955,7 +3934,7 @@ static void sw_immediate_push_vertex(const float position[4])
// Calculate clip coordinates // Calculate clip coordinates
#ifdef SW_HAS_ESP_DSP #ifdef SW_HAS_ESP_DSP
// dspm_mult_4x4x1_f32 declares its inputs non-const; rlsw treats them as // dspm_mult_4x4x1_f32 declares its inputs non-const; rlsw treats them as
// read-only and the cast is safe (the kernel only loads from B). // read-only and the cast is safe (the kernel only loads from B)
dspm_mult_4x4x1_f32(RLSW.matMVP_rm, (float *)position, vertex->position); dspm_mult_4x4x1_f32(RLSW.matMVP_rm, (float *)position, vertex->position);
#else #else
const float *m = RLSW.matMVP; const float *m = RLSW.matMVP;
@ -5191,11 +5170,25 @@ void swTexParameteri(int param, int value)
case SW_TEXTURE_WRAP_S: case SW_TEXTURE_WRAP_S:
{ {
if (!sw_is_texture_wrap_valid(value)) { RLSW.errCode = SW_INVALID_ENUM; return; } if (!sw_is_texture_wrap_valid(value)) { RLSW.errCode = SW_INVALID_ENUM; return; }
#if !SW_SUPPORT_NPOT_TEXTURE
if (value == SW_REPEAT && (RLSW.boundTexture->width & RLSW.boundTexture->wMinus1) != 0)
{
RLSW.errCode = SW_INVALID_OPERATION;
return;
}
#endif
RLSW.boundTexture->sWrap = (SWwrap)value; RLSW.boundTexture->sWrap = (SWwrap)value;
} break; } break;
case SW_TEXTURE_WRAP_T: case SW_TEXTURE_WRAP_T:
{ {
if (!sw_is_texture_wrap_valid(value)) { RLSW.errCode = SW_INVALID_ENUM; return; } if (!sw_is_texture_wrap_valid(value)) { RLSW.errCode = SW_INVALID_ENUM; return; }
#if !SW_SUPPORT_NPOT_TEXTURE
if (value == SW_REPEAT && (RLSW.boundTexture->height & RLSW.boundTexture->hMinus1) != 0)
{
RLSW.errCode = SW_INVALID_OPERATION;
return;
}
#endif
RLSW.boundTexture->tWrap = (SWwrap)value; RLSW.boundTexture->tWrap = (SWwrap)value;
} break; } break;
default: RLSW.errCode = SW_INVALID_ENUM; break; default: RLSW.errCode = SW_INVALID_ENUM; break;
@ -5389,6 +5382,16 @@ static void SW_RASTER_TRIANGLE_SPAN(const sw_vertex_t *start, const sw_vertex_t
int xEnd = (int)end->position[0]; int xEnd = (int)end->position[0];
if (xStart == xEnd) return; if (xStart == xEnd) return;
// Intercept the span bounds to ensure to not write before the framebuffer
int xLoopStart = (xStart >= 0)? xStart : 0;
int xLoopEnd = (xEnd <= RLSW.colorBuffer->width)? xEnd : RLSW.colorBuffer->width;
if (xLoopStart >= xLoopEnd) return; // Nothing to draw
// Get the current row and skip if outside the framebuffer
// Maybe this check is better suited elsewhere?
int y = (int)start->position[1];
if (y < 0 || y >= RLSW.colorBuffer->height) return;
// Compute the inverse horizontal distance along the X axis // Compute the inverse horizontal distance along the X axis
float dxRcp = sw_rcp(end->position[0] - start->position[0]); float dxRcp = sw_rcp(end->position[0] - start->position[0]);
@ -5409,27 +5412,29 @@ static void SW_RASTER_TRIANGLE_SPAN(const sw_vertex_t *start, const sw_vertex_t
#endif #endif
// Compute the subpixel distance to traverse before the first pixel // Compute the subpixel distance to traverse before the first pixel
// Also step further into them to move away from the colorbuffer edge
float xSubstep = 1.0f - sw_fract(start->position[0]); float xSubstep = 1.0f - sw_fract(start->position[0]);
float dxStart = (float)(xLoopStart - xStart);
float xOffset = xSubstep + dxStart;
// Initializing the interpolation starting values // Initializing the interpolation starting values
float w = start->position[3] + dWdx*xSubstep; float w = start->position[3] + dWdx*xOffset;
float color[4] = { float color[4] = {
start->color[0] + dCdx[0]*xSubstep, start->color[0] + dCdx[0]*xOffset,
start->color[1] + dCdx[1]*xSubstep, start->color[1] + dCdx[1]*xOffset,
start->color[2] + dCdx[2]*xSubstep, start->color[2] + dCdx[2]*xOffset,
start->color[3] + dCdx[3]*xSubstep start->color[3] + dCdx[3]*xOffset
}; };
#ifdef SW_ENABLE_DEPTH_TEST #ifdef SW_ENABLE_DEPTH_TEST
float z = start->position[2] + dZdx*xSubstep; float z = start->position[2] + dZdx*xOffset;
#endif #endif
#ifdef SW_ENABLE_TEXTURE #ifdef SW_ENABLE_TEXTURE
float u = start->texcoord[0] + dUdx*xSubstep; float u = start->texcoord[0] + dUdx*xOffset;
float v = start->texcoord[1] + dVdx*xSubstep; float v = start->texcoord[1] + dVdx*xOffset;
#endif #endif
// Pre-calculate the starting pointers for the framebuffer row // Pre-calculate the starting pointers for the framebuffer row
int y = (int)start->position[1]; int baseOffset = y*RLSW.colorBuffer->width + xLoopStart;
int baseOffset = y*RLSW.colorBuffer->width + xStart;
uint8_t *cPtr = (uint8_t *)(RLSW.colorBuffer->pixels) + baseOffset*SW_FRAMEBUFFER_COLOR_SIZE; uint8_t *cPtr = (uint8_t *)(RLSW.colorBuffer->pixels) + baseOffset*SW_FRAMEBUFFER_COLOR_SIZE;
#ifdef SW_ENABLE_DEPTH_TEST #ifdef SW_ENABLE_DEPTH_TEST
uint8_t *dPtr = (uint8_t *)(RLSW.depthBuffer->pixels) + baseOffset*SW_FRAMEBUFFER_DEPTH_SIZE; uint8_t *dPtr = (uint8_t *)(RLSW.depthBuffer->pixels) + baseOffset*SW_FRAMEBUFFER_DEPTH_SIZE;
@ -5437,12 +5442,12 @@ static void SW_RASTER_TRIANGLE_SPAN(const sw_vertex_t *start, const sw_vertex_t
#define SW_AFFINE_BLOCK 16 #define SW_AFFINE_BLOCK 16
int x = xStart; int x = xLoopStart;
while (x < xEnd) while (x < xLoopEnd)
{ {
// Clamp last block to remaining pixels // Clamp last block to remaining pixels
int blockEnd = x + SW_AFFINE_BLOCK; int blockEnd = x + SW_AFFINE_BLOCK;
if (blockEnd > xEnd) blockEnd = xEnd; if (blockEnd > xLoopEnd) blockEnd = xLoopEnd;
float blockLenF = (float)(blockEnd - x); float blockLenF = (float)(blockEnd - x);
float blockLenRcp = sw_rcp(blockLenF); float blockLenRcp = sw_rcp(blockLenF);
@ -5566,8 +5571,7 @@ static void SW_RASTER_TRIANGLE(const sw_vertex_t *v0, const sw_vertex_t *v1, con
if (v1->position[1] > v2->position[1]) { const sw_vertex_t *tmp = v1; v1 = v2; v2 = tmp; } if (v1->position[1] > v2->position[1]) { const sw_vertex_t *tmp = v1; v1 = v2; v2 = tmp; }
if (v0->position[1] > v1->position[1]) { const sw_vertex_t *tmp = v0; v0 = v1; v1 = tmp; } if (v0->position[1] > v1->position[1]) { const sw_vertex_t *tmp = v0; v0 = v1; v1 = tmp; }
// Extracting coordinates from the sorted vertices // Extracting Y coordinates from the sorted vertices
// Put x away for safe keeping. Only y is used right now. Silences warnings.
float y0 = v0->position[1]; float y0 = v0->position[1];
float y1 = v1->position[1]; float y1 = v1->position[1];
float y2 = v2->position[1]; float y2 = v2->position[1];
@ -5677,6 +5681,14 @@ static void SW_RASTER_QUAD(const sw_vertex_t *a, const sw_vertex_t *b,
int xMax = (int)br->position[0]; int xMax = (int)br->position[0];
int yMax = (int)br->position[1]; int yMax = (int)br->position[1];
// Exit early if no pixels to draw. Use these later for loop boundaries
int yLoopMin = (yMin >= 0)? yMin : 0;
int xLoopMin = (xMin >= 0)? xMin : 0;
int yLoopMax = (yMax <= RLSW.colorBuffer->height)? yMax : RLSW.colorBuffer->height;
int xLoopMax = (xMax <= RLSW.colorBuffer->width)? xMax : RLSW.colorBuffer->width;
if (yLoopMin >= yLoopMax || xLoopMin >= xLoopMax) return;
float w = (float)(xMax - xMin); float w = (float)(xMax - xMin);
float h = (float)(yMax - yMin); float h = (float)(yMax - yMin);
if ((w <= 0) || (h <= 0)) return; if ((w <= 0) || (h <= 0)) return;
@ -5730,21 +5742,44 @@ static void SW_RASTER_QUAD(const sw_vertex_t *a, const sw_vertex_t *b,
uint8_t *dPixels = RLSW.depthBuffer->pixels; uint8_t *dPixels = RLSW.depthBuffer->pixels;
#endif #endif
for (int y = yMin; y < yMax; y++) // Calculate the distance the in-bounds boundary is from the quad's edges, only on the left and top
float dxMin = (float)(xLoopMin - xMin);
float dyMin = (float)(yLoopMin - yMin);
// Correct our start by how far it's clipped outside the framebuffer
cRow[0] += dCdx[0]*dxMin + dCdy[0]*dyMin;
cRow[1] += dCdx[1]*dxMin + dCdy[1]*dyMin;
cRow[2] += dCdx[2]*dxMin + dCdy[2]*dyMin;
cRow[3] += dCdx[3]*dxMin + dCdy[3]*dyMin;
#ifdef SW_ENABLE_DEPTH_TEST
zRow += dZdy*dyMin + dZdx*dxMin;
#endif
#ifdef SW_ENABLE_TEXTURE
uRow += dUdy*dyMin + dUdx*dxMin;
vRow += dVdy*dyMin + dVdx*dxMin;
#endif
for (int y = yLoopMin; y < yLoopMax; y++)
{ {
int baseOffset = y*stride + xMin; int baseOffset = y*stride + xLoopMin;
uint8_t *cPtr = cPixels + baseOffset*SW_FRAMEBUFFER_COLOR_SIZE; uint8_t *cPtr = cPixels + baseOffset*SW_FRAMEBUFFER_COLOR_SIZE;
#ifdef SW_ENABLE_DEPTH_TEST #ifdef SW_ENABLE_DEPTH_TEST
uint8_t *dPtr = dPixels + baseOffset*SW_FRAMEBUFFER_DEPTH_SIZE; uint8_t *dPtr = dPixels + baseOffset*SW_FRAMEBUFFER_DEPTH_SIZE;
// Copy the cursors without destroying the offset maths
float z = zRow; float z = zRow;
#endif #endif
#ifdef SW_ENABLE_TEXTURE #ifdef SW_ENABLE_TEXTURE
float u = uRow; float u = uRow;
float v = vRow; float v = vRow;
#endif #endif
float color[4] = { cRow[0], cRow[1], cRow[2], cRow[3] }; float color[4] = {
cRow[0],
cRow[1],
cRow[2],
cRow[3]
};
for (int x = xMin; x < xMax; x++) for (int x = xLoopMin; x < xLoopMax; x++)
{ {
float srcColor[4] = { color[0], color[1], color[2], color[3] }; float srcColor[4] = { color[0], color[1], color[2], color[3] };
@ -5783,6 +5818,7 @@ static void SW_RASTER_QUAD(const sw_vertex_t *a, const sw_vertex_t *b,
#ifdef SW_ENABLE_DEPTH_TEST #ifdef SW_ENABLE_DEPTH_TEST
discard: discard:
#endif #endif
// Move one pixel over without touching the original "start offset"
color[0] += dCdx[0]; color[0] += dCdx[0];
color[1] += dCdx[1]; color[1] += dCdx[1];
color[2] += dCdx[2]; color[2] += dCdx[2];
@ -5805,6 +5841,9 @@ static void SW_RASTER_QUAD(const sw_vertex_t *a, const sw_vertex_t *b,
cPtr += SW_FRAMEBUFFER_COLOR_SIZE; cPtr += SW_FRAMEBUFFER_COLOR_SIZE;
} }
// The for loop is clamped to the right side of the screen
// However, these cursor start vars are still on the left
// That's fine, advancing to the next row
cRow[0] += dCdy[0]; cRow[0] += dCdy[0];
cRow[1] += dCdy[1]; cRow[1] += dCdy[1];
cRow[2] += dCdy[2]; cRow[2] += dCdy[2];

10
src/external/rprand.h vendored
View File

@ -1,6 +1,6 @@
/********************************************************************************************** /**********************************************************************************************
* *
* rprand v1.0 - A simple and easy-to-use pseudo-random numbers generator (PRNG) * rprand v1.1 - A simple and easy-to-use pseudo-random numbers generator (PRNG)
* *
* FEATURES: * FEATURES:
* - Pseudo-random values generation, 32 bits: [0..4294967295] * - Pseudo-random values generation, 32 bits: [0..4294967295]
@ -118,6 +118,7 @@ extern "C" { // Prevents name mangling of functions
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
RPRANDAPI void rprand_set_seed(unsigned long long seed); // Set rprand_state for Xoshiro128**, seed is 64bit RPRANDAPI void rprand_set_seed(unsigned long long seed); // Set rprand_state for Xoshiro128**, seed is 64bit
RPRANDAPI int rprand_get_value(int min, int max); // Get random value within a range, min and max included RPRANDAPI int rprand_get_value(int min, int max); // Get random value within a range, min and max included
RPRANDAPI int rprand_get_value_raw(void); // Get random value, Xoshiro128** generator (uses global rprand_state)
RPRANDAPI int *rprand_load_sequence(unsigned int count, int min, int max); // Load pseudo-random numbers sequence with no duplicates RPRANDAPI int *rprand_load_sequence(unsigned int count, int min, int max); // Load pseudo-random numbers sequence with no duplicates
RPRANDAPI void rprand_unload_sequence(int *sequence); // Unload pseudo-random numbers sequence RPRANDAPI void rprand_unload_sequence(int *sequence); // Unload pseudo-random numbers sequence
@ -186,6 +187,13 @@ int rprand_get_value(int min, int max)
return value; return value;
} }
int rprand_get_value_raw(void)
{
int value = rprand_xoshiro();
return value;
}
// Load pseudo-random numbers sequence with no duplicates, min and max included // Load pseudo-random numbers sequence with no duplicates, min and max included
int *rprand_load_sequence(unsigned int count, int min, int max) int *rprand_load_sequence(unsigned int count, int min, int max)
{ {

3
src/platforms/rcore_android.c
View File

@ -473,8 +473,7 @@ void SetWindowFocused(void)
// Get native window handle // Get native window handle
void *GetWindowHandle(void) void *GetWindowHandle(void)
{ {
TRACELOG(LOG_WARNING, "GetWindowHandle() not implemented on target platform"); return (void *)platform.app->window; // Type: ANativeWindow*
return NULL;
} }
// Get number of monitors // Get number of monitors

85
src/platforms/rcore_desktop_glfw.c
View File

@ -115,7 +115,7 @@ typedef struct {
// Local storage for the window handle returned by glfwGetX11Window // Local storage for the window handle returned by glfwGetX11Window
// This is needed as X11 handles are integers and may not fit inside a pointer depending on platform // This is needed as X11 handles are integers and may not fit inside a pointer depending on platform
// Storing the handle locally and returning a pointer in GetWindowHandle allows the code to work regardless of pointer width // Storing the handle locally and returning a pointer in GetWindowHandle allows the code to work regardless of pointer width
XID windowHandleX11; Window windowHandleX11; // Underlying type: unsigned long (XID, Window)
#endif #endif
} PlatformData; } PlatformData;
@ -764,9 +764,10 @@ void SetWindowFocused(void)
// Get native window handle // Get native window handle
void *GetWindowHandle(void) void *GetWindowHandle(void)
{ {
void *handle = NULL;
#if defined(_WIN32) #if defined(_WIN32)
// NOTE: Returned handle is: void *HWND (windows.h) handle = glfwGetWin32Window(platform.handle); // Type: HWND
return glfwGetWin32Window(platform.handle);
#endif #endif
#if defined(__linux__) #if defined(__linux__)
#if defined(_GLFW_WAYLAND) #if defined(_GLFW_WAYLAND)
@ -774,28 +775,27 @@ void *GetWindowHandle(void)
int platformID = glfwGetPlatform(); int platformID = glfwGetPlatform();
if (platformID == GLFW_PLATFORM_WAYLAND) if (platformID == GLFW_PLATFORM_WAYLAND)
{ {
return glfwGetWaylandWindow(platform.handle); handle = (void *)glfwGetWaylandWindow(platform.handle); // Type: struct wl_surface*
} }
else else
{ {
platform.windowHandleX11 = glfwGetX11Window(platform.handle); platform.windowHandleX11 = glfwGetX11Window(platform.handle); // Type: Window (unsigned long)
return &platform.windowHandleX11; handle = &platform.windowHandleX11;
} }
#else #else
return glfwGetWaylandWindow(platform.handle); handle = (void *)glfwGetWaylandWindow(platform.handle);
#endif #endif
#elif defined(_GLFW_X11) #elif defined(_GLFW_X11)
// Store the window handle localy and return a pointer to the variable instead // Store the window handle locally and return a pointer to the variable instead
platform.windowHandleX11 = glfwGetX11Window(platform.handle); platform.windowHandleX11 = glfwGetX11Window(platform.handle);
return &platform.windowHandleX11; handle = &platform.windowHandleX11;
#endif #endif
#endif #endif
#if defined(__APPLE__) #if defined(__APPLE__)
// NOTE: Returned handle is: (objc_object *) handle = (void *)glfwGetCocoaWindow(platform.handle); // Type: NSWindow*
return (void *)glfwGetCocoaWindow(platform.handle);
#endif #endif
return NULL; return handle;
} }
// Get number of monitors // Get number of monitors
@ -839,7 +839,7 @@ int GetCurrentMonitor(void)
// this is probably an overengineered solution for a side case // this is probably an overengineered solution for a side case
// trying to match SDL behaviour // trying to match SDL behaviour
int closestDist = 0x7FFFFFFF; unsigned int closestDist = 0xFFFFFFFFu;
// Window center position // Window center position
int wcx = 0; int wcx = 0;
@ -883,7 +883,14 @@ int GetCurrentMonitor(void)
int dx = wcx - xclosest; int dx = wcx - xclosest;
int dy = wcy - yclosest; int dy = wcy - yclosest;
int dist = (dx*dx) + (dy*dy);
// Unsigned to dodge signed overflow UB; (-x)^2 == x^2 mod 2^32 so sign drops out.
// If |dx| or |dy| >= 65536, dist wraps and the wrong monitor may win.
// Not a concern for realistic monitor layouts.
unsigned int ux = (unsigned int)dx;
unsigned int uy = (unsigned int)dy;
unsigned int dist = ux*ux + uy*uy;
if (dist < closestDist) if (dist < closestDist)
{ {
index = i; index = i;
@ -1042,11 +1049,6 @@ const char *GetClipboardText(void)
return glfwGetClipboardString(platform.handle); return glfwGetClipboardString(platform.handle);
} }
#if SUPPORT_CLIPBOARD_IMAGE && defined(__linux__) && defined(_GLFW_X11)
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#endif
// Get clipboard image // Get clipboard image
Image GetClipboardImage(void) Image GetClipboardImage(void)
{ {
@ -1066,32 +1068,30 @@ Image GetClipboardImage(void)
else image = LoadImageFromMemory(".bmp", (const unsigned char *)bmpData, (int)dataSize); else image = LoadImageFromMemory(".bmp", (const unsigned char *)bmpData, (int)dataSize);
#elif defined(__linux__) && defined(_GLFW_X11) #elif defined(__linux__) && defined(_GLFW_X11)
// REF: https://github.com/ColleagueRiley/Clipboard-Copy-Paste/blob/main/x11.c // REF: https://github.com/ColleagueRiley/Clipboard-Copy-Paste/blob/main/x11.c
Display *dpy = XOpenDisplay(NULL);
if (!dpy) return image;
Window root = DefaultRootWindow(dpy); static Atom clipboard = 0;
Window win = XCreateSimpleWindow( static Atom targetType = 0;
dpy, // The connection to the X Server static Atom property = 0;
root, // The 'Parent' window (usually the desktop/root)
0, 0, // X and Y position on the screen
1, 1, // Width and Height (1x1 pixel)
0, // Border width
0, // Border color
0 // Background color
);
Atom clipboard = XInternAtom(dpy, "CLIPBOARD", False); Display *display = glfwGetX11Display();
Atom targetType = XInternAtom(dpy, "image/png", False); // Ask for PNG XID window = glfwGetX11Window(platform.handle);
Atom property = XInternAtom(dpy, "RAYLIB_CLIPBOARD_MANAGER", False);
// Request the data: "Convert whatever is in CLIPBOARD to image/png and put it in RAYLIB_CLIPBOARD_MANAGER" // Lazy-load X11 atoms
XConvertSelection(dpy, clipboard, targetType, property, win, CurrentTime); if(clipboard == 0)
{
clipboard = XInternAtom(display, "CLIPBOARD", False);
targetType = XInternAtom(display, "image/png", False);
property = XInternAtom(display, "RAYLIB_CLIPBOARD_MANAGER", False);
}
XConvertSelection(display, clipboard, targetType, property, window, CurrentTime);
XSync(display, 0);
// Wait for the SelectionNotify event
XEvent ev = { 0 }; XEvent ev = { 0 };
XNextEvent(dpy, &ev);
// Keep calling until we get SelectionNotify
while (XCheckTypedEvent(display, SelectionNotify, &ev) == False);
Atom actualType = { 0 }; Atom actualType = { 0 };
int actualFormat = 0; int actualFormat = 0;
@ -1099,9 +1099,8 @@ Image GetClipboardImage(void)
unsigned long bytesAfter = 0; unsigned long bytesAfter = 0;
unsigned char *data = NULL; unsigned char *data = NULL;
// Read the data from our ghost window's property XGetWindowProperty(display, window, property, 0, ~0L, False, AnyPropertyType,
XGetWindowProperty(dpy, win, property, 0, ~0L, False, AnyPropertyType, &actualType, &actualFormat, &nitems, &bytesAfter, &data);
&actualType, &actualFormat, &nitems, &bytesAfter, &data);
if (data != NULL) if (data != NULL)
{ {
@ -1109,8 +1108,6 @@ Image GetClipboardImage(void)
XFree(data); XFree(data);
} }
XDestroyWindow(dpy, win);
XCloseDisplay(dpy);
#else #else
TRACELOG(LOG_WARNING, "GetClipboardImage() not implemented on target platform"); TRACELOG(LOG_WARNING, "GetClipboardImage() not implemented on target platform");
#endif // _WIN32 #endif // _WIN32

67
src/platforms/rcore_desktop_rgfw.c
View File

@ -184,6 +184,9 @@ typedef struct {
i32 surfaceWidth; i32 surfaceWidth;
i32 surfaceHeight; i32 surfaceHeight;
#endif #endif
#if defined(__linux__) && defined(RGFW_X11)
Window windowHandleX11; // Underlying type: unsigned long
#endif
} PlatformData; } PlatformData;
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -810,8 +813,8 @@ void SetWindowSize(int width, int height)
RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window); RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window);
CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f); CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f);
CORE.Window.render.width = CORE.Window.screen.width * currentMonitor->pixelRatio; CORE.Window.render.width = CORE.Window.screen.width*currentMonitor->pixelRatio;
CORE.Window.render.height = CORE.Window.screen.height * currentMonitor->pixelRatio; CORE.Window.render.height = CORE.Window.screen.height*currentMonitor->pixelRatio;
CORE.Window.currentFbo.width = CORE.Window.render.width; CORE.Window.currentFbo.width = CORE.Window.render.width;
CORE.Window.currentFbo.height = CORE.Window.render.height; CORE.Window.currentFbo.height = CORE.Window.render.height;
#else #else
@ -851,15 +854,25 @@ void SetWindowFocused(void)
// Get native window handle // Get native window handle
void *GetWindowHandle(void) void *GetWindowHandle(void)
{ {
if (platform.window == NULL) return NULL; void *handle = NULL;
#if defined(RGFW_WASM) if (platform.window != NULL)
return (void *)&platform.window->src.ctx; {
#elif defined(RGFW_WAYLAND) #if defined(_WIN32)
return (void *)platform.window->src.surface; handle = (void *)platform.window->src.window; // Type: HWND
#else #elif defined(__linux__)
return (void *)platform.window->src.window; #if defined(RGFW_X11)
platform.windowHandleX11 = platform.window->src.window; // Type: Window (unsigned long)
handle = &platform.window->src.window;
#elif defined(RGFW_WAYLAND)
handle = (void *)platform.window->src.surface; // Type: struct wl_surface*
#endif
#elif defined(__APPLE__)
handle = (void *)platform.window->src.window; // Type: id, NSWindow*
#endif #endif
}
return handle;
} }
// Get number of monitors // Get number of monitors
@ -1132,16 +1145,16 @@ void SwapScreenBuffer(void)
{ {
if (platform.surface) if (platform.surface)
{ {
// copy rlsw pixel data to the surface framebuffer // Copy rlsw pixel data to the surface framebuffer
swReadPixels(0, 0, platform.surfaceWidth, platform.surfaceHeight, SW_RGBA, SW_UNSIGNED_BYTE, platform.surfacePixels); rlCopyFramebuffer(0, 0, platform.surfaceWidth, platform.surfaceHeight, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, platform.surfacePixels);
// Mac wants a different pixel order. I cant seem to get this to work any other way // Mac wants a different pixel order. I cant seem to get this to work any other way
#if defined(__APPLE__) #if defined(__APPLE__)
unsigned char temp = 0; unsigned char temp = 0;
unsigned char *p = NULL; unsigned char *p = NULL;
for (int i = 0; i < (platform.surfaceWidth * platform.surfaceHeight); i += 1) for (int i = 0; i < (platform.surfaceWidth*platform.surfaceHeight); i += 1)
{ {
p = platform.surfacePixels + (i * 4); p = platform.surfacePixels + (i*4);
temp = p[0]; temp = p[0];
p[0] = p[2]; p[0] = p[2];
p[2] = temp; p[2] = temp;
@ -1357,13 +1370,13 @@ void PollInputEvents(void)
if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI)) if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
{ {
RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window); RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window);
SetupViewport(platform.window->w * currentMonitor->pixelRatio, platform.window->h * currentMonitor->pixelRatio); SetupViewport(platform.window->w*currentMonitor->pixelRatio, platform.window->h*currentMonitor->pixelRatio);
CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f); CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f);
CORE.Window.screen.width = platform.window->w; CORE.Window.screen.width = platform.window->w;
CORE.Window.screen.height = platform.window->h; CORE.Window.screen.height = platform.window->h;
CORE.Window.render.width = CORE.Window.screen.width * currentMonitor->pixelRatio; CORE.Window.render.width = CORE.Window.screen.width*currentMonitor->pixelRatio;
CORE.Window.render.height = CORE.Window.screen.height * currentMonitor->pixelRatio; CORE.Window.render.height = CORE.Window.screen.height*currentMonitor->pixelRatio;
} }
else else
{ {
@ -1406,10 +1419,10 @@ void PollInputEvents(void)
#if defined(__APPLE__) #if defined(__APPLE__)
RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window); RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window);
CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f); CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f);
SetupViewport(platform.window->w * currentMonitor->pixelRatio, platform.window->h * currentMonitor->pixelRatio); SetupViewport(platform.window->w*currentMonitor->pixelRatio, platform.window->h*currentMonitor->pixelRatio);
CORE.Window.render.width = CORE.Window.screen.width * currentMonitor->pixelRatio; CORE.Window.render.width = CORE.Window.screen.width*currentMonitor->pixelRatio;
CORE.Window.render.height = CORE.Window.screen.height * currentMonitor->pixelRatio; CORE.Window.render.height = CORE.Window.screen.height*currentMonitor->pixelRatio;
CORE.Window.currentFbo.width = CORE.Window.render.width; CORE.Window.currentFbo.width = CORE.Window.render.width;
CORE.Window.currentFbo.height = CORE.Window.render.height; CORE.Window.currentFbo.height = CORE.Window.render.height;
#endif #endif
@ -1427,7 +1440,7 @@ void PollInputEvents(void)
if (platform.surfacePixels != NULL) if (platform.surfacePixels != NULL)
{ {
RL_FREE(platform.surfacePixels); RL_FREE(platform.surfacePixels);
platform.surfacePixels = RL_MALLOC(platform.surfaceWidth * platform.surfaceHeight * 4); platform.surfacePixels = RL_MALLOC(platform.surfaceWidth*platform.surfaceHeight*4);
} }
if (platform.surface != NULL) if (platform.surface != NULL)
@ -1743,8 +1756,8 @@ int InitPlatform(void)
if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI)) if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
{ {
#if !defined(__APPLE__) #if !defined(__APPLE__)
CORE.Window.screen.width = CORE.Window.screen.width * GetWindowScaleDPI().x; CORE.Window.screen.width = CORE.Window.screen.width*GetWindowScaleDPI().x;
CORE.Window.screen.height = CORE.Window.screen.height * GetWindowScaleDPI().y; CORE.Window.screen.height = CORE.Window.screen.height*GetWindowScaleDPI().y;
#endif #endif
} }
@ -1828,8 +1841,8 @@ int InitPlatform(void)
RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window); RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window);
CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f); CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f);
CORE.Window.render.width = CORE.Window.screen.width * currentMonitor->pixelRatio; CORE.Window.render.width = CORE.Window.screen.width*currentMonitor->pixelRatio;
CORE.Window.render.height = CORE.Window.screen.height * currentMonitor->pixelRatio; CORE.Window.render.height = CORE.Window.screen.height*currentMonitor->pixelRatio;
CORE.Window.currentFbo.width = CORE.Window.render.width; CORE.Window.currentFbo.width = CORE.Window.render.width;
CORE.Window.currentFbo.height = CORE.Window.render.height; CORE.Window.currentFbo.height = CORE.Window.render.height;
#else #else
@ -1846,8 +1859,8 @@ int InitPlatform(void)
RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window); RGFW_monitor* currentMonitor = RGFW_window_getMonitor(platform.window);
CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f); CORE.Window.screenScale = MatrixScale(currentMonitor->pixelRatio, currentMonitor->pixelRatio, 1.0f);
CORE.Window.render.width = CORE.Window.screen.width * currentMonitor->pixelRatio; CORE.Window.render.width = CORE.Window.screen.width*currentMonitor->pixelRatio;
CORE.Window.render.height = CORE.Window.screen.height * currentMonitor->pixelRatio; CORE.Window.render.height = CORE.Window.screen.height*currentMonitor->pixelRatio;
CORE.Window.currentFbo.width = CORE.Window.render.width; CORE.Window.currentFbo.width = CORE.Window.render.width;
CORE.Window.currentFbo.height = CORE.Window.render.height; CORE.Window.currentFbo.height = CORE.Window.render.height;
#endif #endif
@ -1855,7 +1868,7 @@ int InitPlatform(void)
platform.surfaceWidth = CORE.Window.currentFbo.width; platform.surfaceWidth = CORE.Window.currentFbo.width;
platform.surfaceHeight = CORE.Window.currentFbo.height; platform.surfaceHeight = CORE.Window.currentFbo.height;
platform.surfacePixels = RL_MALLOC(platform.surfaceWidth * platform.surfaceHeight * 4); platform.surfacePixels = RL_MALLOC(platform.surfaceWidth*platform.surfaceHeight*4);
if (platform.surfacePixels == NULL) if (platform.surfacePixels == NULL)
{ {
TRACELOG(LOG_FATAL, "PLATFORM: Failed to initialize software pixel buffer"); TRACELOG(LOG_FATAL, "PLATFORM: Failed to initialize software pixel buffer");

61
src/platforms/rcore_desktop_sdl.c
View File

@ -56,6 +56,7 @@
#include "SDL3/SDL.h" #include "SDL3/SDL.h"
#elif defined(USING_SDL2_PROJECT) #elif defined(USING_SDL2_PROJECT)
#include "SDL2/SDL.h" #include "SDL2/SDL.h"
#include "SDL2/SDL_syswm.h" // Required to get window handlers
#else #else
#include "SDL.h" #include "SDL.h"
#endif #endif
@ -101,6 +102,13 @@ typedef struct {
SDL_GameController *gamepad[MAX_GAMEPADS]; SDL_GameController *gamepad[MAX_GAMEPADS];
SDL_JoystickID gamepadId[MAX_GAMEPADS]; // Joystick instance ids, they do not start from 0 SDL_JoystickID gamepadId[MAX_GAMEPADS]; // Joystick instance ids, they do not start from 0
SDL_Cursor *cursor; SDL_Cursor *cursor;
#if defined(__linux__)
// Local storage for the window handle (X11)
// NOTE: On SDL is not possible to know windowing backend at compile time, so,
// just in case, avoiding X11 specific types here
unsigned long windowHandleX11; // Underlying type for: XID, Window
#endif
} PlatformData; } PlatformData;
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -920,9 +928,60 @@ void SetWindowFocused(void)
} }
// Get native window handle // Get native window handle
// NOTE: Handle type depends on OS and windowing system
void *GetWindowHandle(void) void *GetWindowHandle(void)
{ {
return (void *)platform.window; void *handle = NULL;
#if defined(USING_SDL3_PROJECT)
// REF: https://github.com/libsdl-org/SDL/blob/main/include/SDL3/SDL_video.h#L1590
SDL_PropertiesID props = SDL_GetWindowProperties(platform.window);
#if defined(_WIN32)
handle = (void *)SDL_GetPointerProperty(props, SDL_PROP_WINDOW_WIN32_HWND_POINTER, NULL); // Type: HWND
#elif defined(__linux__)
unsigned long windowId = (unsigned long)SDL_GetNumberProperty(props, SDL_PROP_WINDOW_X11_WINDOW_NUMBER, 0); // Type: unsigned long (XID, Window)
if (windowId != 0)
{
// X11 window ID
platform.windowHandleX11 = windowId;
handle = &platform.windowHandleX11;
}
else
{
// Wayland, get display surface pointer
// NOTE: Alternative SDL_PROP_WINDOW_WAYLAND_DISPLAY_POINTER
handle = (void *)SDL_GetPointerProperty(props, SDL_PROP_WINDOW_WAYLAND_SURFACE_POINTER, NULL); // Type: struct wl_surface*
}
#elif defined(__APPLE__)
handle = (void *)SDL_GetPointerProperty(props, SDL_PROP_WINDOW_COCOA_WINDOW_POINTER, NULL); // Type: NSWindow*
#endif
#elif defined(USING_SDL2_PROJECT)
SDL_SysWMinfo wmInfo = { 0 };
SDL_VERSION(&wmInfo.version);
if (SDL_GetWindowWMInfo(platform.window, &wmInfo))
{
#if defined(_WIN32)
handle = (void *)wmInfo.info.win.window; // Type: HWND
#elif defined(__linux__)
if (wmInfo.subsystem == SDL_SYSWM_X11)
{
// X11, get window ID (unsigned long)
platform.windowHandleX11 = (unsigned long)wmInfo.info.x11.window;
handle = &platform.windowHandleX11;
}
else if (wmInfo.subsystem == SDL_SYSWM_WAYLAND)
{
// Wayland, get display surface pointer
// NOTE: Alternative: wmInfo.info.wl.display
handle = (void *)wmInfo.info.wl.surface; // Type: struct wl_surface*
}
#elif defined(__APPLE__)
handle = (void *)wmInfo.info.cocoa.window; // Type: NSWindow*
#endif
}
#endif
return handle;
} }
// Get number of monitors // Get number of monitors

12
src/platforms/rcore_desktop_win32.c
View File

@ -1023,7 +1023,7 @@ void SetWindowFocused(void)
// Get native window handle // Get native window handle
void *GetWindowHandle(void) void *GetWindowHandle(void)
{ {
return platform.hwnd; return (void *)platform.hwnd;
} }
int GetMonitorCount(void) int GetMonitorCount(void)
@ -1257,8 +1257,9 @@ void OpenURL(const char *url)
if (strchr(url, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'] character"); if (strchr(url, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'] character");
else else
{ {
char *cmd = (char *)RL_CALLOC(strlen(url) + 32, sizeof(char)); int len = strlen(url) + 32;
sprintf(cmd, "explorer \"%s\"", url); char *cmd = (char *)RL_CALLOC(len, sizeof(char));
snprintf(cmd, len, "explorer \"%s\"", url);
int result = system(cmd); int result = system(cmd);
if (result == -1) TRACELOG(LOG_WARNING, "OpenURL() child process could not be created"); if (result == -1) TRACELOG(LOG_WARNING, "OpenURL() child process could not be created");
RL_FREE(cmd); RL_FREE(cmd);
@ -2052,8 +2053,11 @@ static void HandleMouseButton(int button, char state)
static void HandleRawInput(LPARAM lparam) static void HandleRawInput(LPARAM lparam)
{ {
RAWINPUT input = { 0 }; RAWINPUT input = { 0 };
UINT inputSize = 0;
if (GetRawInputData((HRAWINPUT)lparam, RID_INPUT, NULL, &inputSize, sizeof(RAWINPUTHEADER)) != 0) return;
if (inputSize > sizeof(input)) return;
UINT inputSize = sizeof(input);
UINT size = GetRawInputData((HRAWINPUT)lparam, RID_INPUT, &input, &inputSize, sizeof(RAWINPUTHEADER)); UINT size = GetRawInputData((HRAWINPUT)lparam, RID_INPUT, &input, &inputSize, sizeof(RAWINPUTHEADER));
if (size == (UINT)-1) TRACELOG(LOG_ERROR, "WIN32: Failed to get raw input data [ERROR: %lu]", GetLastError()); if (size == (UINT)-1) TRACELOG(LOG_ERROR, "WIN32: Failed to get raw input data [ERROR: %lu]", GetLastError());

6
src/platforms/rcore_memory.c
View File

@ -91,7 +91,7 @@ bool InitGraphicsDevice(void); // Initialize graphics device
// Module Internal Functions Declaration // Module Internal Functions Declaration
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
#if !defined(_WIN32) #if !defined(_WIN32)
static int kbhit(void); // Check if a key has been pressed static int kbhit(void); // Check if key has been pressed
static char getch(void) { return getchar(); } // Get pressed character static char getch(void) { return getchar(); } // Get pressed character
#endif #endif
@ -374,6 +374,8 @@ double GetTime(void)
unsigned long long nanoSeconds = (unsigned long long)ts.tv_sec*1000000000LLU + (unsigned long long)ts.tv_nsec; unsigned long long nanoSeconds = (unsigned long long)ts.tv_sec*1000000000LLU + (unsigned long long)ts.tv_nsec;
time = (double)(nanoSeconds - CORE.Time.base)*1e-9; // Elapsed time since InitTimer() time = (double)(nanoSeconds - CORE.Time.base)*1e-9; // Elapsed time since InitTimer()
#elif defined(PICO_RP2350)
time = (double)to_ms_since_boot(get_absolute_time())/1000.0;
#endif #endif
return time; return time;
} }
@ -560,7 +562,7 @@ void ClosePlatform(void)
// Module Internal Functions Definition // Module Internal Functions Definition
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
#if !defined(_WIN32) #if !defined(_WIN32)
// Check if a key has been pressed // Check if key has been pressed
static int kbhit(void) static int kbhit(void)
{ {
struct termios oldt = { 0 }; struct termios oldt = { 0 };

6
src/raudio.c
View File

@ -1013,7 +1013,7 @@ Sound LoadSoundAlias(Sound source)
return sound; return sound;
} }
// Check if a sound is valid (data loaded and buffers initialized) // Check if sound is valid (data loaded and buffers initialized)
bool IsSoundValid(Sound sound) bool IsSoundValid(Sound sound)
{ {
bool result = false; bool result = false;
@ -1215,7 +1215,7 @@ void StopSound(Sound sound)
StopAudioBuffer(sound.stream.buffer); StopAudioBuffer(sound.stream.buffer);
} }
// Check if a sound is playing // Check if sound is playing
bool IsSoundPlaying(Sound sound) bool IsSoundPlaying(Sound sound)
{ {
bool result = false; bool result = false;
@ -1751,7 +1751,7 @@ Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data,
return music; return music;
} }
// Check if a music stream is valid (context and buffers initialized) // Check if music stream is valid (context and buffers initialized)
bool IsMusicValid(Music music) bool IsMusicValid(Music music)
{ {
return ((music.ctxData != NULL) && // Validate context loaded return ((music.ctxData != NULL) && // Validate context loaded

90
src/raylib.h
View File

@ -1070,7 +1070,7 @@ RLAPI void UnloadVrStereoConfig(VrStereoConfig config); // Unload VR s
// NOTE: Shader functionality is not available on OpenGL 1.1 // NOTE: Shader functionality is not available on OpenGL 1.1
RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName); // Load shader from files and bind default locations RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName); // Load shader from files and bind default locations
RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations
RLAPI bool IsShaderValid(Shader shader); // Check if a shader is valid (loaded on GPU) RLAPI bool IsShaderValid(Shader shader); // Check if shader is valid (loaded on GPU)
RLAPI int GetShaderLocation(Shader shader, const char *uniformName); // Get shader uniform location RLAPI int GetShaderLocation(Shader shader, const char *uniformName); // Get shader uniform location
RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName); // Get shader attribute location RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName); // Get shader attribute location
RLAPI void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType); // Set shader uniform value RLAPI void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType); // Set shader uniform value
@ -1141,14 +1141,14 @@ RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custo
RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader
RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver
RLAPI int FileRename(const char *fileName, const char *fileRename); // Rename file (if exists) RLAPI int FileRename(const char *fileName, const char *fileRename); // Rename file (if exists), returns 0 on success
RLAPI int FileRemove(const char *fileName); // Remove file (if exists) RLAPI int FileRemove(const char *fileName); // Remove file (if exists), returns 0 on success
RLAPI int FileCopy(const char *srcPath, const char *dstPath); // Copy file from one path to another, dstPath created if it doesn't exist RLAPI int FileCopy(const char *srcPath, const char *dstPath); // Copy file from one path to another, dstPath created if it doesn't exist, returns 0 on success
RLAPI int FileMove(const char *srcPath, const char *dstPath); // Move file from one directory to another, dstPath created if it doesn't exist RLAPI int FileMove(const char *srcPath, const char *dstPath); // Move file from one directory to another, dstPath created if it doesn't exist, returns 0 on success
RLAPI int FileTextReplace(const char *fileName, const char *search, const char *replacement); // Replace text in an existing file RLAPI int FileTextReplace(const char *fileName, const char *search, const char *replacement); // Replace text in an existing file, returns 0 on success
RLAPI int FileTextFindIndex(const char *fileName, const char *search); // Find text in existing file RLAPI int FileTextFindIndex(const char *fileName, const char *search); // Find text in existing file, returns -1 if index not found or index otherwise
RLAPI bool FileExists(const char *fileName); // Check if file exists RLAPI bool FileExists(const char *fileName); // Check if file exists
RLAPI bool DirectoryExists(const char *dirPath); // Check if a directory path exists RLAPI bool DirectoryExists(const char *dirPath); // Check if directory path exists
RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (recommended include point: .png, .wav) RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (recommended include point: .png, .wav)
RLAPI int GetFileLength(const char *fileName); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h) RLAPI int GetFileLength(const char *fileName); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h)
RLAPI long GetFileModTime(const char *fileName); // Get file modification time (last write time) RLAPI long GetFileModTime(const char *fileName); // Get file modification time (last write time)
@ -1160,13 +1160,13 @@ RLAPI const char *GetPrevDirectoryPath(const char *dirPath); // Get previ
RLAPI const char *GetWorkingDirectory(void); // Get current working directory (uses static string) RLAPI const char *GetWorkingDirectory(void); // Get current working directory (uses static string)
RLAPI const char *GetApplicationDirectory(void); // Get the directory of the running application (uses static string) RLAPI const char *GetApplicationDirectory(void); // Get the directory of the running application (uses static string)
RLAPI int MakeDirectory(const char *dirPath); // Create directories (including full path requested), returns 0 on success RLAPI int MakeDirectory(const char *dirPath); // Create directories (including full path requested), returns 0 on success
RLAPI bool ChangeDirectory(const char *dirPath); // Change working directory, return true on success RLAPI int ChangeDirectory(const char *dirPath); // Change working directory, returns 0 on success
RLAPI bool IsPathFile(const char *path); // Check if a given path is a file or a directory RLAPI bool IsPathFile(const char *path); // Check if given path is a file or a directory
RLAPI bool IsFileNameValid(const char *fileName); // Check if fileName is valid for the platform/OS RLAPI bool IsFileNameValid(const char *fileName); // Check if fileName is valid for the platform/OS
RLAPI FilePathList LoadDirectoryFiles(const char *dirPath); // Load directory filepaths, files and directories, no subdirs scan RLAPI FilePathList LoadDirectoryFiles(const char *dirPath); // Load directory filepaths, files and directories, no subdirs scan
RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and subdir scan; some filters available: `*.*`,`FILES*`,`DIRS*` RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and subdir scan; some filters available: '*.*','FILES*','DIRS*'
RLAPI void UnloadDirectoryFiles(FilePathList files); // Unload filepaths RLAPI void UnloadDirectoryFiles(FilePathList files); // Unload filepaths
RLAPI bool IsFileDropped(void); // Check if a file has been dropped into window RLAPI bool IsFileDropped(void); // Check if file has been dropped into window
RLAPI FilePathList LoadDroppedFiles(void); // Load dropped filepaths RLAPI FilePathList LoadDroppedFiles(void); // Load dropped filepaths
RLAPI void UnloadDroppedFiles(FilePathList files); // Unload dropped filepaths RLAPI void UnloadDroppedFiles(FilePathList files); // Unload dropped filepaths
RLAPI unsigned int GetDirectoryFileCount(const char *dirPath); // Get the file count in a directory RLAPI unsigned int GetDirectoryFileCount(const char *dirPath); // Get the file count in a directory
@ -1197,23 +1197,23 @@ RLAPI void PlayAutomationEvent(AutomationEvent event); // Play a reco
//------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------
// Input-related functions: keyboard // Input-related functions: keyboard
RLAPI bool IsKeyPressed(int key); // Check if a key has been pressed once RLAPI bool IsKeyPressed(int key); // Check if key has been pressed once
RLAPI bool IsKeyPressedRepeat(int key); // Check if a key has been pressed again RLAPI bool IsKeyPressedRepeat(int key); // Check if key has been pressed again
RLAPI bool IsKeyDown(int key); // Check if a key is being pressed RLAPI bool IsKeyDown(int key); // Check if key is being pressed
RLAPI bool IsKeyReleased(int key); // Check if a key has been released once RLAPI bool IsKeyReleased(int key); // Check if key has been released once
RLAPI bool IsKeyUp(int key); // Check if a key is NOT being pressed RLAPI bool IsKeyUp(int key); // Check if key is NOT being pressed
RLAPI int GetKeyPressed(void); // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty RLAPI int GetKeyPressed(void); // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty
RLAPI int GetCharPressed(void); // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty RLAPI int GetCharPressed(void); // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty
RLAPI const char *GetKeyName(int key); // Get name of a QWERTY key on the current keyboard layout (eg returns string 'q' for KEY_A on an AZERTY keyboard) RLAPI const char *GetKeyName(int key); // Get name of a QWERTY key on the current keyboard layout (eg returns string 'q' for KEY_A on an AZERTY keyboard)
RLAPI void SetExitKey(int key); // Set a custom key to exit program (default is ESC) RLAPI void SetExitKey(int key); // Set a custom key to exit program (default is ESC)
// Input-related functions: gamepads // Input-related functions: gamepads
RLAPI bool IsGamepadAvailable(int gamepad); // Check if a gamepad is available RLAPI bool IsGamepadAvailable(int gamepad); // Check if gamepad is available
RLAPI const char *GetGamepadName(int gamepad); // Get gamepad internal name id RLAPI const char *GetGamepadName(int gamepad); // Get gamepad internal name id
RLAPI bool IsGamepadButtonPressed(int gamepad, int button); // Check if a gamepad button has been pressed once RLAPI bool IsGamepadButtonPressed(int gamepad, int button); // Check if gamepad button has been pressed once
RLAPI bool IsGamepadButtonDown(int gamepad, int button); // Check if a gamepad button is being pressed RLAPI bool IsGamepadButtonDown(int gamepad, int button); // Check if gamepad button is being pressed
RLAPI bool IsGamepadButtonReleased(int gamepad, int button); // Check if a gamepad button has been released once RLAPI bool IsGamepadButtonReleased(int gamepad, int button); // Check if gamepad button has been released once
RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Check if a gamepad button is NOT being pressed RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Check if gamepad button is NOT being pressed
RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed
RLAPI int GetGamepadAxisCount(int gamepad); // Get axis count for a gamepad RLAPI int GetGamepadAxisCount(int gamepad); // Get axis count for a gamepad
RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Get movement value for a gamepad axis RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Get movement value for a gamepad axis
@ -1221,10 +1221,10 @@ RLAPI int SetGamepadMappings(const char *mappings); // Set internal ga
RLAPI void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float duration); // Set gamepad vibration for both motors (duration in seconds) RLAPI void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float duration); // Set gamepad vibration for both motors (duration in seconds)
// Input-related functions: mouse // Input-related functions: mouse
RLAPI bool IsMouseButtonPressed(int button); // Check if a mouse button has been pressed once RLAPI bool IsMouseButtonPressed(int button); // Check if mouse button has been pressed once
RLAPI bool IsMouseButtonDown(int button); // Check if a mouse button is being pressed RLAPI bool IsMouseButtonDown(int button); // Check if mouse button is being pressed
RLAPI bool IsMouseButtonReleased(int button); // Check if a mouse button has been released once RLAPI bool IsMouseButtonReleased(int button); // Check if mouse button has been released once
RLAPI bool IsMouseButtonUp(int button); // Check if a mouse button is NOT being pressed RLAPI bool IsMouseButtonUp(int button); // Check if mouse button is NOT being pressed
RLAPI int GetMouseX(void); // Get mouse position X RLAPI int GetMouseX(void); // Get mouse position X
RLAPI int GetMouseY(void); // Get mouse position Y RLAPI int GetMouseY(void); // Get mouse position Y
RLAPI Vector2 GetMousePosition(void); // Get mouse position XY RLAPI Vector2 GetMousePosition(void); // Get mouse position XY
@ -1247,7 +1247,7 @@ RLAPI int GetTouchPointCount(void); // Get number of t
// Gestures and Touch Handling Functions (Module: rgestures) // Gestures and Touch Handling Functions (Module: rgestures)
//------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------
RLAPI void SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags RLAPI void SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags
RLAPI bool IsGestureDetected(unsigned int gesture); // Check if a gesture has been detected RLAPI bool IsGestureDetected(unsigned int gesture); // Check if gesture has been detected
RLAPI int GetGestureDetected(void); // Get latest detected gesture RLAPI int GetGestureDetected(void); // Get latest detected gesture
RLAPI float GetGestureHoldDuration(void); // Get gesture hold time in seconds RLAPI float GetGestureHoldDuration(void); // Get gesture hold time in seconds
RLAPI Vector2 GetGestureDragVector(void); // Get gesture drag vector RLAPI Vector2 GetGestureDragVector(void); // Get gesture drag vector
@ -1267,7 +1267,7 @@ RLAPI void UpdateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, f
// Set texture and rectangle to be used on shapes drawing // Set texture and rectangle to be used on shapes drawing
// NOTE: It can be useful when using basic shapes and one single font, // 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 // defining a font char white rectangle would allow drawing everything in a single draw call
RLAPI void SetShapesTexture(Texture2D texture, Rectangle source); // Set texture and rectangle to be used on shapes drawing RLAPI void SetShapesTexture(Texture2D texture, Rectangle rec); // Set texture and rectangle to be used on shapes drawing
RLAPI Texture2D GetShapesTexture(void); // Get texture that is used for shapes drawing RLAPI Texture2D GetShapesTexture(void); // Get texture that is used for shapes drawing
RLAPI Rectangle GetShapesTextureRectangle(void); // Get texture source rectangle that is used for shapes drawing RLAPI Rectangle GetShapesTextureRectangle(void); // Get texture source rectangle that is used for shapes drawing
@ -1446,9 +1446,9 @@ RLAPI Texture2D LoadTexture(const char *fileName);
RLAPI Texture2D LoadTextureFromImage(Image image); // Load texture from image data RLAPI Texture2D LoadTextureFromImage(Image image); // Load texture from image data
RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout); // Load cubemap from image, multiple image cubemap layouts supported RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout); // Load cubemap from image, multiple image cubemap layouts supported
RLAPI RenderTexture2D LoadRenderTexture(int width, int height); // Load texture for rendering (framebuffer) RLAPI RenderTexture2D LoadRenderTexture(int width, int height); // Load texture for rendering (framebuffer)
RLAPI bool IsTextureValid(Texture2D texture); // Check if a texture is valid (loaded in GPU) RLAPI bool IsTextureValid(Texture2D texture); // Check if texture is valid (loaded in GPU)
RLAPI void UnloadTexture(Texture2D texture); // Unload texture from GPU memory (VRAM) RLAPI void UnloadTexture(Texture2D texture); // Unload texture from GPU memory (VRAM)
RLAPI bool IsRenderTextureValid(RenderTexture2D target); // Check if a render texture is valid (loaded in GPU) RLAPI bool IsRenderTextureValid(RenderTexture2D target); // Check if render texture is valid (loaded in GPU)
RLAPI void UnloadRenderTexture(RenderTexture2D target); // Unload render texture from GPU memory (VRAM) RLAPI void UnloadRenderTexture(RenderTexture2D target); // Unload render texture from GPU memory (VRAM)
RLAPI void UpdateTexture(Texture2D texture, const void *pixels); // Update GPU texture with new data (pixels should be able to fill texture) RLAPI void UpdateTexture(Texture2D texture, const void *pixels); // Update GPU texture with new data (pixels should be able to fill texture)
RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels); // Update GPU texture rectangle with new data (pixels and rec should fit in texture) RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels); // Update GPU texture rectangle with new data (pixels and rec should fit in texture)
@ -1462,9 +1462,9 @@ RLAPI void SetTextureWrap(Texture2D texture, int wrap);
RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D
RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2 RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2
RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); // Draw a Texture2D with extended parameters RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); // Draw a Texture2D with extended parameters
RLAPI void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint); // Draw a part of a texture defined by a rectangle RLAPI void DrawTextureRec(Texture2D texture, Rectangle rec, Vector2 position, Color tint); // Draw a part of a texture defined by a rectangle
RLAPI void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters RLAPI void DrawTexturePro(Texture2D texture, Rectangle srcrec, Rectangle dstrec, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a source rectangle to destination rectangle, with scaling and rotation
RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draw a texture (or part of it) that stretches or shrinks nicely RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dstrec, Vector2 origin, float rotation, Color tint); // Draw a texture (or part of it) that stretches or shrinks nicely
// Color/pixel related functions // Color/pixel related functions
RLAPI bool ColorIsEqual(Color col1, Color col2); // Check if two colors are equal RLAPI bool ColorIsEqual(Color col1, Color col2); // Check if two colors are equal
@ -1481,7 +1481,7 @@ RLAPI Color ColorAlpha(Color color, float alpha); // G
RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint); // Get src alpha-blended into dst color with tint RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint); // Get src alpha-blended into dst color with tint
RLAPI Color ColorLerp(Color color1, Color color2, float factor); // Get color lerp interpolation between two colors, factor [0.0f..1.0f] RLAPI Color ColorLerp(Color color1, Color color2, float factor); // Get color lerp interpolation between two colors, factor [0.0f..1.0f]
RLAPI Color GetColor(unsigned int hexValue); // Get Color structure from hexadecimal value RLAPI Color GetColor(unsigned int hexValue); // Get Color structure from hexadecimal value
RLAPI Color GetPixelColor(void *srcPtr, int format); // Get Color from a source pixel pointer of certain format RLAPI Color GetPixelColor(const void *srcPtr, int format); // Get Color from a source pixel pointer of certain format
RLAPI void SetPixelColor(void *dstPtr, Color color, int format); // Set color formatted into destination pixel pointer RLAPI void SetPixelColor(void *dstPtr, Color color, int format); // Set color formatted into destination pixel pointer
RLAPI int GetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes for certain format RLAPI int GetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes for certain format
@ -1495,7 +1495,7 @@ RLAPI Font LoadFont(const char *fileName);
RLAPI Font LoadFontEx(const char *fileName, int fontSize, const 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, font size is provided in pixels height RLAPI Font LoadFontEx(const char *fileName, int fontSize, const 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, font size is provided in pixels height
RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style) RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style)
RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, const int *codepoints, int codepointCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf' RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, const int *codepoints, int codepointCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf'
RLAPI bool IsFontValid(Font font); // Check if a font is valid (font data loaded, WARNING: GPU texture not checked) RLAPI bool IsFontValid(Font font); // Check if font is valid (font data loaded, WARNING: GPU texture not checked)
RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, const int *codepoints, int codepointCount, int type, int *glyphCount); // Load font data for further use RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, const int *codepoints, int codepointCount, int type, int *glyphCount); // Load font data for further use
RLAPI Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info RLAPI Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info
RLAPI void UnloadFontData(GlyphInfo *glyphs, int glyphCount); // Unload font chars info data (RAM) RLAPI void UnloadFontData(GlyphInfo *glyphs, int glyphCount); // Unload font chars info data (RAM)
@ -1577,10 +1577,10 @@ RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color);
RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color); // Draw sphere RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color); // Draw sphere
RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere with extended parameters RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere with extended parameters
RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires
RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int sides, Color color); // Draw a cylinder/cone
RLAPI void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder with base at startPos and top at endPos RLAPI void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder with base at startPos and top at endPos
RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int sides, Color color); // Draw a cylinder/cone wires
RLAPI void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int slices, Color color); // Draw a cylinder wires with base at startPos and top at endPos RLAPI void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder wires with base at startPos and top at endPos
RLAPI void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int rings, int slices, Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos RLAPI void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int rings, int slices, Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos
RLAPI void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int rings, int slices, Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos RLAPI void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int rings, int slices, Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos
RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color); // Draw a plane XZ RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color); // Draw a plane XZ
@ -1594,7 +1594,7 @@ RLAPI void DrawGrid(int slices, float spacing);
// Model management functions // Model management functions
RLAPI Model LoadModel(const char *fileName); // Load model from files (meshes and materials) RLAPI Model LoadModel(const char *fileName); // Load model from files (meshes and materials)
RLAPI Model LoadModelFromMesh(Mesh mesh); // Load model from generated mesh (default material) RLAPI Model LoadModelFromMesh(Mesh mesh); // Load model from generated mesh (default material)
RLAPI bool IsModelValid(Model model); // Check if a model is valid (loaded in GPU, VAO/VBOs) RLAPI bool IsModelValid(Model model); // Check if model is valid (loaded in GPU, VAO/VBOs)
RLAPI void UnloadModel(Model model); // Unload model (including meshes) from memory (RAM and/or VRAM) RLAPI void UnloadModel(Model model); // Unload model (including meshes) from memory (RAM and/or VRAM)
RLAPI BoundingBox GetModelBoundingBox(Model model); // Compute model bounding box limits (considers all meshes) RLAPI BoundingBox GetModelBoundingBox(Model model); // Compute model bounding box limits (considers all meshes)
@ -1605,8 +1605,8 @@ RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint
RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters
RLAPI void DrawBoundingBox(BoundingBox box, Color color); // Draw bounding box (wires) RLAPI void DrawBoundingBox(BoundingBox box, Color color); // Draw bounding box (wires)
RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float scale, Color tint); // Draw a billboard texture RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float scale, Color tint); // Draw a billboard texture
RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle rec, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by rectangle
RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source and rotation RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle rec, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source rectangle with scaling and rotation
// Mesh management functions // Mesh management functions
RLAPI void UploadMesh(Mesh *mesh, bool dynamic); // Upload mesh vertex data in GPU and provide VAO/VBO ids RLAPI void UploadMesh(Mesh *mesh, bool dynamic); // Upload mesh vertex data in GPU and provide VAO/VBO ids
@ -1635,7 +1635,7 @@ RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize);
// Material loading/unloading functions // Material loading/unloading functions
RLAPI Material *LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file RLAPI Material *LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file
RLAPI Material LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps) RLAPI Material LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
RLAPI bool IsMaterialValid(Material material); // Check if a material is valid (shader assigned, map textures loaded in GPU) RLAPI bool IsMaterialValid(Material material); // Check if material is valid (shader assigned, map textures loaded in GPU)
RLAPI void UnloadMaterial(Material material); // Unload material from GPU memory (VRAM) RLAPI void UnloadMaterial(Material material); // Unload material from GPU memory (VRAM)
RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...) RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh
@ -1676,7 +1676,7 @@ RLAPI bool IsWaveValid(Wave wave); // Check i
RLAPI Sound LoadSound(const char *fileName); // Load sound from file RLAPI Sound LoadSound(const char *fileName); // Load sound from file
RLAPI Sound LoadSoundFromWave(Wave wave); // Load sound from wave data RLAPI Sound LoadSoundFromWave(Wave wave); // Load sound from wave data
RLAPI Sound LoadSoundAlias(Sound source); // Load sound alias, new sound that shares the same sample data as the source sound, does not own the sound data RLAPI Sound LoadSoundAlias(Sound source); // Load sound alias, new sound that shares the same sample data as the source sound, does not own the sound data
RLAPI bool IsSoundValid(Sound sound); // Check if a sound is valid (data loaded and buffers initialized) RLAPI bool IsSoundValid(Sound sound); // Check if sound is valid (data loaded and buffers initialized)
RLAPI void UpdateSound(Sound sound, const void *data, int frameCount); // Update sound buffer with new data (default data format: 32 bit float, stereo) RLAPI void UpdateSound(Sound sound, const void *data, int frameCount); // Update sound buffer with new data (default data format: 32 bit float, stereo)
RLAPI void UnloadWave(Wave wave); // Unload wave data RLAPI void UnloadWave(Wave wave); // Unload wave data
RLAPI void UnloadSound(Sound sound); // Unload sound RLAPI void UnloadSound(Sound sound); // Unload sound
@ -1689,7 +1689,7 @@ RLAPI void PlaySound(Sound sound); // Play a
RLAPI void StopSound(Sound sound); // Stop playing a sound RLAPI void StopSound(Sound sound); // Stop playing a sound
RLAPI void PauseSound(Sound sound); // Pause a sound RLAPI void PauseSound(Sound sound); // Pause a sound
RLAPI void ResumeSound(Sound sound); // Resume a paused sound RLAPI void ResumeSound(Sound sound); // Resume a paused sound
RLAPI bool IsSoundPlaying(Sound sound); // Check if a sound is currently playing RLAPI bool IsSoundPlaying(Sound sound); // Check if sound is currently playing
RLAPI void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level) RLAPI void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level)
RLAPI void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level) RLAPI void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level)
RLAPI void SetSoundPan(Sound sound, float pan); // Set pan for a sound (-1.0 left, 0.0 center, 1.0 right) RLAPI void SetSoundPan(Sound sound, float pan); // Set pan for a sound (-1.0 left, 0.0 center, 1.0 right)
@ -1702,7 +1702,7 @@ RLAPI void UnloadWaveSamples(float *samples); // Unload
// Music management functions // Music management functions
RLAPI Music LoadMusicStream(const char *fileName); // Load music stream from file RLAPI Music LoadMusicStream(const char *fileName); // Load music stream from file
RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data
RLAPI bool IsMusicValid(Music music); // Check if a music stream is valid (context and buffers initialized) RLAPI bool IsMusicValid(Music music); // Check if music stream is valid (context and buffers initialized)
RLAPI void UnloadMusicStream(Music music); // Unload music stream RLAPI void UnloadMusicStream(Music music); // Unload music stream
RLAPI void PlayMusicStream(Music music); // Start music playing RLAPI void PlayMusicStream(Music music); // Start music playing
RLAPI bool IsMusicStreamPlaying(Music music); // Check if music is playing RLAPI bool IsMusicStreamPlaying(Music music); // Check if music is playing

86
src/rcore.c
View File

@ -506,11 +506,11 @@ __declspec(dllimport) void __stdcall Sleep(unsigned long msTimeout); // Required
const char *TextFormat(const char *text, ...); // Formatting of text with variables to 'embed' const char *TextFormat(const char *text, ...); // Formatting of text with variables to 'embed'
#endif #endif
// NOTE: PLATFORM_DESKTOP defaults to GLFW backend
#if defined(PLATFORM_DESKTOP) #if defined(PLATFORM_DESKTOP)
#define PLATFORM_DESKTOP_GLFW #define PLATFORM_DESKTOP_GLFW
#endif #endif
// Include platform-specific submodules // Include platform-specific submodules
#if defined(PLATFORM_DESKTOP_GLFW) #if defined(PLATFORM_DESKTOP_GLFW)
#include "platforms/rcore_desktop_glfw.c" #include "platforms/rcore_desktop_glfw.c"
@ -1293,7 +1293,7 @@ Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode)
return shader; return shader;
} }
// Check if a shader is valid (loaded on GPU) // Check if shader is valid (loaded on GPU)
bool IsShaderValid(Shader shader) bool IsShaderValid(Shader shader)
{ {
return ((shader.id > 0) && // Validate shader id (GPU loaded successfully) return ((shader.id > 0) && // Validate shader id (GPU loaded successfully)
@ -2205,13 +2205,12 @@ void SetSaveFileTextCallback(SaveFileTextCallback callback)
// NOTE: Only rename file name required, not full path // NOTE: Only rename file name required, not full path
int FileRename(const char *fileName, const char *fileRename) int FileRename(const char *fileName, const char *fileRename)
{ {
int result = 0; int result = -1;
if (FileExists(fileName)) if (FileExists(fileName))
{ {
result = rename(fileName, fileRename); result = rename(fileName, fileRename);
} }
else result = -1;
return result; return result;
} }
@ -2219,13 +2218,12 @@ int FileRename(const char *fileName, const char *fileRename)
// Remove file (if exists) // Remove file (if exists)
int FileRemove(const char *fileName) int FileRemove(const char *fileName)
{ {
int result = 0; int result = -1;
if (FileExists(fileName)) if (FileExists(fileName))
{ {
result = remove(fileName); result = remove(fileName);
} }
else result = -1;
return result; return result;
} }
@ -2234,7 +2232,7 @@ int FileRemove(const char *fileName)
// NOTE: If destination path does not exist, it is created! // NOTE: If destination path does not exist, it is created!
int FileCopy(const char *srcPath, const char *dstPath) int FileCopy(const char *srcPath, const char *dstPath)
{ {
int result = 0; int result = -1;
int srcDataSize = 0; int srcDataSize = 0;
unsigned char *srcFileData = LoadFileData(srcPath, &srcDataSize); unsigned char *srcFileData = LoadFileData(srcPath, &srcDataSize);
@ -2245,7 +2243,10 @@ int FileCopy(const char *srcPath, const char *dstPath)
if (result == 0) // Directory created successfully (or already exists) if (result == 0) // Directory created successfully (or already exists)
{ {
if ((srcFileData != NULL) && (srcDataSize > 0)) if ((srcFileData != NULL) && (srcDataSize > 0))
result = SaveFileData(dstPath, srcFileData, srcDataSize); {
bool saved = SaveFileData(dstPath, srcFileData, srcDataSize);
if (saved) result = 0;
}
} }
UnloadFileData(srcFileData); UnloadFileData(srcFileData);
@ -2261,11 +2262,18 @@ int FileMove(const char *srcPath, const char *dstPath)
if (FileExists(srcPath)) if (FileExists(srcPath))
{ {
FileCopy(srcPath, dstPath); result = FileCopy(srcPath, dstPath);
// Make sure file has been correctly copied before removing if (result == 0)
if (FileExists(dstPath) && (GetFileLength(srcPath) == GetFileLength(dstPath))) result = FileRemove(srcPath); {
else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to copy file to [%s]", srcPath, dstPath); // Make sure file has been correctly copied before removing
if (FileExists(dstPath) && (GetFileLength(srcPath) == GetFileLength(dstPath)))
{
result = FileRemove(srcPath);
if (result != 0) TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to remove source file after copy", srcPath);
}
else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to copy file to [%s]", srcPath, dstPath);
}
} }
else TRACELOG(LOG_WARNING, "FILEIO: [%s] Source file does not exist", srcPath); else TRACELOG(LOG_WARNING, "FILEIO: [%s] Source file does not exist", srcPath);
@ -2276,16 +2284,18 @@ int FileMove(const char *srcPath, const char *dstPath)
// WARNING: DEPENDENCY: [rtext] module // WARNING: DEPENDENCY: [rtext] module
int FileTextReplace(const char *fileName, const char *search, const char *replacement) int FileTextReplace(const char *fileName, const char *search, const char *replacement)
{ {
int result = 0; int result = -1;
#if SUPPORT_MODULE_RTEXT
char *fileText = NULL; char *fileText = NULL;
char *fileTextUpdated = { 0 }; char *fileTextUpdated = { 0 };
#if SUPPORT_MODULE_RTEXT
if (FileExists(fileName)) if (FileExists(fileName))
{ {
fileText = LoadFileText(fileName); fileText = LoadFileText(fileName);
fileTextUpdated = TextReplaceAlloc(fileText, search, replacement); fileTextUpdated = TextReplaceAlloc(fileText, search, replacement);
result = SaveFileText(fileName, fileTextUpdated); bool saved = SaveFileText(fileName, fileTextUpdated);
if (saved) result = 0;
MemFree(fileTextUpdated); MemFree(fileTextUpdated);
UnloadFileText(fileText); UnloadFileText(fileText);
} }
@ -2318,7 +2328,7 @@ bool FileExists(const char *fileName)
{ {
bool result = false; bool result = false;
if (ACCESS(fileName) != -1) result = true; if ((fileName != NULL) && (ACCESS(fileName) != -1)) result = true;
// NOTE: Alternatively, stat() can be used instead of access() // NOTE: Alternatively, stat() can be used instead of access()
//#include <sys/stat.h> //#include <sys/stat.h>
@ -2395,7 +2405,7 @@ bool IsFileExtension(const char *fileName, const char *ext)
return result; return result;
} }
// Check if a directory path exists // Check if directory path exists
bool DirectoryExists(const char *dirPath) bool DirectoryExists(const char *dirPath)
{ {
bool result = false; bool result = false;
@ -2800,17 +2810,19 @@ int MakeDirectory(const char *dirPath)
} }
// Change working directory, returns true on success // Change working directory, returns true on success
bool ChangeDirectory(const char *dirPath) int ChangeDirectory(const char *dirPath)
{ {
bool result = CHDIR(dirPath); // NOTE: On success, CHDIR() return 0; on error, returns -1 and errno is set to indicate the error,
// depending on the filesystem, other errors can be returned
int result = CHDIR(dirPath);
if (result != 0) TRACELOG(LOG_WARNING, "SYSTEM: Failed to change to directory: %s", dirPath); if (result != 0) TRACELOG(LOG_WARNING, "SYSTEM: Failed to change to directory: %s", dirPath);
else TRACELOG(LOG_INFO, "SYSTEM: Working Directory: %s", dirPath); else TRACELOG(LOG_INFO, "SYSTEM: Working Directory: %s", dirPath);
return (result == 0); return result;
} }
// Check if a given path point to a file // Check if given path point to a file
bool IsPathFile(const char *path) bool IsPathFile(const char *path)
{ {
struct stat result = { 0 }; struct stat result = { 0 };
@ -2875,7 +2887,7 @@ bool IsFileNameValid(const char *fileName)
return valid; return valid;
} }
// Check if a file has been dropped into window // Check if file has been dropped into window
bool IsFileDropped(void) bool IsFileDropped(void)
{ {
bool result = false; bool result = false;
@ -3786,7 +3798,7 @@ void PlayAutomationEvent(AutomationEvent event)
// Module Functions Definition: Input Handling: Keyboard // Module Functions Definition: Input Handling: Keyboard
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Check if a key has been pressed once // Check if key has been pressed once
bool IsKeyPressed(int key) bool IsKeyPressed(int key)
{ {
bool pressed = false; bool pressed = false;
@ -3799,7 +3811,7 @@ bool IsKeyPressed(int key)
return pressed; return pressed;
} }
// Check if a key has been pressed again // Check if key has been pressed again
bool IsKeyPressedRepeat(int key) bool IsKeyPressedRepeat(int key)
{ {
bool repeat = false; bool repeat = false;
@ -3812,7 +3824,7 @@ bool IsKeyPressedRepeat(int key)
return repeat; return repeat;
} }
// Check if a key is being pressed (key held down) // Check if key is being pressed (key held down)
bool IsKeyDown(int key) bool IsKeyDown(int key)
{ {
bool down = false; bool down = false;
@ -3825,7 +3837,7 @@ bool IsKeyDown(int key)
return down; return down;
} }
// Check if a key has been released once // Check if key has been released once
bool IsKeyReleased(int key) bool IsKeyReleased(int key)
{ {
bool released = false; bool released = false;
@ -3838,7 +3850,7 @@ bool IsKeyReleased(int key)
return released; return released;
} }
// Check if a key is NOT being pressed (key not held down) // Check if key is NOT being pressed (key not held down)
bool IsKeyUp(int key) bool IsKeyUp(int key)
{ {
bool up = false; bool up = false;
@ -3909,7 +3921,7 @@ void SetExitKey(int key)
// NOTE: Functions with a platform-specific implementation on rcore_<platform>.c // NOTE: Functions with a platform-specific implementation on rcore_<platform>.c
//int SetGamepadMappings(const char *mappings) //int SetGamepadMappings(const char *mappings)
// Check if a gamepad is available // Check if gamepad is available
bool IsGamepadAvailable(int gamepad) bool IsGamepadAvailable(int gamepad)
{ {
bool result = false; bool result = false;
@ -3925,7 +3937,7 @@ const char *GetGamepadName(int gamepad)
return CORE.Input.Gamepad.name[gamepad]; return CORE.Input.Gamepad.name[gamepad];
} }
// Check if a gamepad button has been pressed once // Check if gamepad button has been pressed once
bool IsGamepadButtonPressed(int gamepad, int button) bool IsGamepadButtonPressed(int gamepad, int button)
{ {
bool pressed = false; bool pressed = false;
@ -3938,7 +3950,7 @@ bool IsGamepadButtonPressed(int gamepad, int button)
return pressed; return pressed;
} }
// Check if a gamepad button is being pressed // Check if gamepad button is being pressed
bool IsGamepadButtonDown(int gamepad, int button) bool IsGamepadButtonDown(int gamepad, int button)
{ {
bool down = false; bool down = false;
@ -3951,7 +3963,7 @@ bool IsGamepadButtonDown(int gamepad, int button)
return down; return down;
} }
// Check if a gamepad button has NOT been pressed once // Check if gamepad button has NOT been pressed once
bool IsGamepadButtonReleased(int gamepad, int button) bool IsGamepadButtonReleased(int gamepad, int button)
{ {
bool released = false; bool released = false;
@ -3964,7 +3976,7 @@ bool IsGamepadButtonReleased(int gamepad, int button)
return released; return released;
} }
// Check if a gamepad button is NOT being pressed // Check if gamepad button is NOT being pressed
bool IsGamepadButtonUp(int gamepad, int button) bool IsGamepadButtonUp(int gamepad, int button)
{ {
bool up = false; bool up = false;
@ -4013,7 +4025,7 @@ float GetGamepadAxisMovement(int gamepad, int axis)
//void SetMousePosition(int x, int y) //void SetMousePosition(int x, int y)
//void SetMouseCursor(int cursor) //void SetMouseCursor(int cursor)
// Check if a mouse button has been pressed once // Check if mouse button has been pressed once
bool IsMouseButtonPressed(int button) bool IsMouseButtonPressed(int button)
{ {
bool pressed = false; bool pressed = false;
@ -4029,7 +4041,7 @@ bool IsMouseButtonPressed(int button)
return pressed; return pressed;
} }
// Check if a mouse button is being pressed // Check if mouse button is being pressed
bool IsMouseButtonDown(int button) bool IsMouseButtonDown(int button)
{ {
bool down = false; bool down = false;
@ -4045,7 +4057,7 @@ bool IsMouseButtonDown(int button)
return down; return down;
} }
// Check if a mouse button has been released once // Check if mouse button has been released once
bool IsMouseButtonReleased(int button) bool IsMouseButtonReleased(int button)
{ {
bool released = false; bool released = false;
@ -4061,7 +4073,7 @@ bool IsMouseButtonReleased(int button)
return released; return released;
} }
// Check if a mouse button is NOT being pressed // Check if mouse button is NOT being pressed
bool IsMouseButtonUp(int button) bool IsMouseButtonUp(int button)
{ {
bool up = false; bool up = false;

4
src/rgestures.h
View File

@ -127,7 +127,7 @@ void UpdateGestures(void); // Update gestures detec
#if defined(RGESTURES_STANDALONE) #if defined(RGESTURES_STANDALONE)
void SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags void SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags
bool IsGestureDetected(int gesture); // Check if a gesture has been detected bool IsGestureDetected(int gesture); // Check if gesture has been detected
int GetGestureDetected(void); // Get latest detected gesture int GetGestureDetected(void); // Get latest detected gesture
float GetGestureHoldDuration(void); // Get gesture hold time in seconds float GetGestureHoldDuration(void); // Get gesture hold time in seconds
@ -257,7 +257,7 @@ void SetGesturesEnabled(unsigned int flags)
GESTURES.enabledFlags = flags; GESTURES.enabledFlags = flags;
} }
// Check if a gesture have been detected // Check if gesture have been detected
bool IsGestureDetected(unsigned int gesture) bool IsGestureDetected(unsigned int gesture)
{ {
if ((GESTURES.enabledFlags & GESTURES.current) == gesture) return true; if ((GESTURES.enabledFlags & GESTURES.current) == gesture) return true;

2
src/rlgl.h
View File

@ -897,7 +897,7 @@ RLAPI void rlLoadDrawQuad(void); // Load and draw a quad
// It seems OpenGL ES 2.0 instancing entry points are not defined on Raspberry Pi // 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) // provided headers (despite being defined in official Khronos GLES2 headers)
// TODO: Avoid raylib platform-dependent code on rlgl, it should be a completely portable library // TODO: Avoid raylib platform-dependent code on rlgl, it should be a completely portable library
#if defined(PLATFORM_DRM) #if defined(PLATFORM_DRM) // Use CONFIG_DRM?
typedef void (GL_APIENTRYP PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount); 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 PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount);
typedef void (GL_APIENTRYP PFNGLVERTEXATTRIBDIVISOREXTPROC) (GLuint index, GLuint divisor); typedef void (GL_APIENTRYP PFNGLVERTEXATTRIBDIVISOREXTPROC) (GLuint index, GLuint divisor);

134
src/rmodels.c
View File

@ -1162,7 +1162,7 @@ Model LoadModelFromMesh(Mesh mesh)
return model; return model;
} }
// Check if a model is valid (loaded in GPU, VAO/VBOs) // Check if model is valid (loaded in GPU, VAO/VBOs)
bool IsModelValid(Model model) bool IsModelValid(Model model)
{ {
bool result = false; bool result = false;
@ -2223,7 +2223,7 @@ Material LoadMaterialDefault(void)
return material; return material;
} }
// Check if a material is valid (map textures loaded in GPU) // Check if material is valid (map textures loaded in GPU)
bool IsMaterialValid(Material material) bool IsMaterialValid(Material material)
{ {
bool result = false; bool result = false;
@ -3978,22 +3978,22 @@ void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float
// Draw a billboard // Draw a billboard
void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float scale, Color tint) void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float scale, Color tint)
{ {
Rectangle source = { 0.0f, 0.0f, (float)texture.width, (float)texture.height }; Rectangle rec = { 0.0f, 0.0f, (float)texture.width, (float)texture.height };
DrawBillboardRec(camera, texture, source, position, (Vector2){ scale*fabsf((float)source.width/source.height), scale }, tint); DrawBillboardRec(camera, texture, rec, position, (Vector2){ scale*fabsf((float)rec.width/rec.height), scale }, tint);
} }
// Draw a billboard (part of a texture defined by a rectangle) // Draw a billboard (part of a texture defined by a rectangle)
void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint) void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle rec, Vector3 position, Vector2 size, Color tint)
{ {
// NOTE: Billboard locked on axis-Y // NOTE: Billboard locked on axis-Y
Vector3 up = { 0.0f, 1.0f, 0.0f }; Vector3 up = { 0.0f, 1.0f, 0.0f };
DrawBillboardPro(camera, texture, source, position, up, size, Vector2Scale(size, 0.5), 0.0f, tint); DrawBillboardPro(camera, texture, rec, position, up, size, Vector2Scale(size, 0.5), 0.0f, tint);
} }
// Draw a billboard with additional parameters // Draw a billboard texture defined by source rectangle with scaling and rotation
void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint) void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle rec, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint)
{ {
// Compute the up vector and the right vector // Compute the up vector and the right vector
Matrix matView = MatrixLookAt(camera.position, camera.target, camera.up); Matrix matView = MatrixLookAt(camera.position, camera.target, camera.up);
@ -4004,20 +4004,20 @@ void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector
// Flip the content of the billboard while maintaining the counterclockwise edge rendering order // Flip the content of the billboard while maintaining the counterclockwise edge rendering order
if (size.x < 0.0f) if (size.x < 0.0f)
{ {
source.x -= size.x; rec.x -= size.x;
source.width *= -1.0; rec.width *= -1.0;
right = Vector3Negate(right); right = Vector3Negate(right);
origin.x *= -1.0f; origin.x *= -1.0f;
} }
if (size.y < 0.0f) if (size.y < 0.0f)
{ {
source.y -= size.y; rec.y -= size.y;
source.height *= -1.0; rec.height *= -1.0;
up = Vector3Negate(up); up = Vector3Negate(up);
origin.y *= -1.0f; origin.y *= -1.0f;
} }
// Draw the texture region described by source on the following rectangle in 3D space: // Draw the texture region described by rec on the following rectangle in 3D space:
// //
// size.x <--. // size.x <--.
// 3 ^---------------------------+ 2 \ rotation // 3 ^---------------------------+ 2 \ rotation
@ -4049,10 +4049,10 @@ void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector
} }
Vector2 texcoords[4]; Vector2 texcoords[4];
texcoords[0] = (Vector2){ (float)source.x/texture.width, (float)(source.y + source.height)/texture.height }; texcoords[0] = (Vector2){ (float)rec.x/texture.width, (float)(rec.y + rec.height)/texture.height };
texcoords[1] = (Vector2){ (float)(source.x + source.width)/texture.width, (float)(source.y + source.height)/texture.height }; texcoords[1] = (Vector2){ (float)(rec.x + rec.width)/texture.width, (float)(rec.y + rec.height)/texture.height };
texcoords[2] = (Vector2){ (float)(source.x + source.width)/texture.width, (float)source.y/texture.height }; texcoords[2] = (Vector2){ (float)(rec.x + rec.width)/texture.width, (float)rec.y/texture.height };
texcoords[3] = (Vector2){ (float)source.x/texture.width, (float)source.y/texture.height }; texcoords[3] = (Vector2){ (float)rec.x/texture.width, (float)rec.y/texture.height };
rlSetTexture(texture.id); rlSetTexture(texture.id);
rlBegin(RL_QUADS); rlBegin(RL_QUADS);
@ -5370,16 +5370,18 @@ static BoneInfo *LoadBoneInfoGLTF(cgltf_skin skin, int *boneCount)
cgltf_node node = *skin.joints[i]; cgltf_node node = *skin.joints[i];
if (node.name != NULL) strncpy(bones[i].name, node.name, sizeof(bones[i].name) - 1); if (node.name != NULL) strncpy(bones[i].name, node.name, sizeof(bones[i].name) - 1);
// Find parent bone index // Find parent bone index by walking up the node tree past any
// non-joint ancestors (intermediate transform nodes used by some
// DCC exporters), until we hit a node that is also in skin.joints.
int parentIndex = -1; int parentIndex = -1;
cgltf_node *ancestor = node.parent;
for (unsigned int j = 0; j < skin.joints_count; j++) while (ancestor != NULL && parentIndex == -1)
{ {
if (skin.joints[j] == node.parent) for (unsigned int j = 0; j < skin.joints_count; j++)
{ {
parentIndex = (int)j; if (skin.joints[j] == ancestor) { parentIndex = (int)j; break; }
break;
} }
if (parentIndex == -1) ancestor = ancestor->parent;
} }
bones[i].parent = parentIndex; bones[i].parent = parentIndex;
@ -6510,20 +6512,58 @@ static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCo
if (data->skins_count > 0) if (data->skins_count > 0)
{ {
cgltf_skin skin = data->skins[0]; cgltf_skin skin = data->skins[0];
// Precompute, per joint, the static transform contributed by any
// intermediate non-joint nodes between the joint and its nearest
// joint ancestor. This handles exporters (e.g. wow.export) that
// store bone offsets on dummy parent nodes rather than on the
// joints themselves. Depends only on the skin, not the animation.
int jointCount = (int)skin.joints_count;
Matrix *extOffset = (Matrix *)RL_MALLOC(jointCount*sizeof(Matrix));
if (extOffset == NULL)
{
// Allocation failed: abort animation loading at the source rather than
// propagating a NULL pointer into the per-frame transform loop below
TRACELOG(LOG_WARNING, "MODEL: [%s] Failed to allocate joint offset buffer", fileName);
cgltf_free(data);
UnloadFileData(fileData);
*animCount = 0;
return NULL;
}
*animCount = (int)data->animations_count; *animCount = (int)data->animations_count;
animations = (ModelAnimation *)RL_CALLOC(data->animations_count, sizeof(ModelAnimation)); animations = (ModelAnimation *)RL_CALLOC(data->animations_count, sizeof(ModelAnimation));
Transform worldTransform = { 0 }; for (int k = 0; k < jointCount; k++)
cgltf_float cgltf_worldTransform[16] = { 0 }; {
cgltf_node *node = skin.joints[0]; extOffset[k] = MatrixIdentity();
cgltf_node_transform_world(node->parent, cgltf_worldTransform); cgltf_node *n = skin.joints[k]->parent;
Matrix worldMatrix = {
cgltf_worldTransform[0], cgltf_worldTransform[4], cgltf_worldTransform[8], cgltf_worldTransform[12], while (n != NULL)
cgltf_worldTransform[1], cgltf_worldTransform[5], cgltf_worldTransform[9], cgltf_worldTransform[13], {
cgltf_worldTransform[2], cgltf_worldTransform[6], cgltf_worldTransform[10], cgltf_worldTransform[14], bool isJoint = false;
cgltf_worldTransform[3], cgltf_worldTransform[7], cgltf_worldTransform[11], cgltf_worldTransform[15] for (int jj = 0; jj < jointCount; jj++)
}; {
MatrixDecompose(worldMatrix, &worldTransform.translation, &worldTransform.rotation, &worldTransform.scale); if (skin.joints[jj] == n)
{
isJoint = true;
break;
}
}
if (isJoint) break;
// Compose the intermediate node's local TRS (scale, then rotation, then translation)
Matrix nodeScale = MatrixScale(n->scale[0], n->scale[1], n->scale[2]);
Matrix nodeRotation = QuaternionToMatrix((Quaternion){ n->rotation[0], n->rotation[1], n->rotation[2], n->rotation[3] });
Matrix nodeTranslation = MatrixTranslate(n->translation[0], n->translation[1], n->translation[2]);
Matrix nodeTransform = MatrixMultiply(MatrixMultiply(nodeScale, nodeRotation), nodeTranslation);
extOffset[k] = MatrixMultiply(extOffset[k], nodeTransform);
n = n->parent;
}
}
for (unsigned int a = 0; a < data->animations_count; a++) for (unsigned int a = 0; a < data->animations_count; a++)
{ {
@ -6632,19 +6672,19 @@ static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCo
} }
} }
animations[a].keyframePoses[j][k] = (Transform){ // Compose joint local TRS, then prepend the static
.translation = translation, // intermediate non-joint offsets so the final TRS is
.rotation = rotation, // expressed relative to the joint's skeleton parent.
.scale = scale Matrix S = MatrixScale(scale.x, scale.y, scale.z);
}; Matrix R = QuaternionToMatrix(rotation);
} Matrix T = MatrixTranslate(translation.x, translation.y, translation.z);
Matrix jointLocal = MatrixMultiply(MatrixMultiply(S, R), T);
Matrix combined = MatrixMultiply(jointLocal, extOffset[k]);
Transform *root = &animations[a].keyframePoses[j][0]; Transform tr;
root->rotation = QuaternionMultiply(worldTransform.rotation, root->rotation); MatrixDecompose(combined, &tr.translation, &tr.rotation, &tr.scale);
root->scale = Vector3Multiply(root->scale, worldTransform.scale); animations[a].keyframePoses[j][k] = tr;
root->translation = Vector3Multiply(root->translation, worldTransform.scale); }
root->translation = Vector3RotateByQuaternion(root->translation, worldTransform.rotation);
root->translation = Vector3Add(root->translation, worldTransform.translation);
BuildPoseFromParentJoints(bones, animations[a].boneCount, animations[a].keyframePoses[j]); BuildPoseFromParentJoints(bones, animations[a].boneCount, animations[a].keyframePoses[j]);
} }
@ -6653,6 +6693,8 @@ static ModelAnimation *LoadModelAnimationsGLTF(const char *fileName, int *animCo
RL_FREE(boneChannels); RL_FREE(boneChannels);
RL_FREE(bones); RL_FREE(bones);
} }
RL_FREE(extOffset);
} }
if (data->skins_count > 1) if (data->skins_count > 1)

18
src/rshapes.c
View File

@ -90,12 +90,12 @@ static float EaseCubicInOut(float t, float b, float c, float d); // Cubic eas
// Set texture and rectangle to be used on shapes drawing // Set texture and rectangle to be used on shapes drawing
// NOTE: It can be useful when using basic shapes and one single font, // 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 // defining a font char white rectangle would allow drawing everything in a single draw call
void SetShapesTexture(Texture2D texture, Rectangle source) void SetShapesTexture(Texture2D texture, Rectangle rec)
{ {
// Reset texture to default pixel if required // Reset texture to default pixel if required
// WARNING: Shapes texture should be probably better validated, // WARNING: Shapes texture should be probably better validated,
// it can break the rendering of all shapes if misused // it can break the rendering of all shapes if misused
if ((texture.id == 0) || (source.width == 0) || (source.height == 0)) if ((texture.id == 0) || (rec.width == 0) || (rec.height == 0))
{ {
texShapes = (Texture2D){ 1, 1, 1, 1, 7 }; texShapes = (Texture2D){ 1, 1, 1, 1, 7 };
texShapesRec = (Rectangle){ 0.0f, 0.0f, 1.0f, 1.0f }; texShapesRec = (Rectangle){ 0.0f, 0.0f, 1.0f, 1.0f };
@ -103,7 +103,7 @@ void SetShapesTexture(Texture2D texture, Rectangle source)
else else
{ {
texShapes = texture; texShapes = texture;
texShapesRec = source; texShapesRec = rec;
} }
} }
@ -326,7 +326,7 @@ void DrawCircleSector(Vector2 center, float radius, float startAngle, float endA
{ {
// Calculate the maximum angle between segments based on the error rate (usually 0.5f) // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1); float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1);
segments = (int)((endAngle - startAngle)*ceilf(2*PI/th)/360); segments = (int)ceilf((endAngle - startAngle)*(2*PI/th)/360.0f);
if (segments <= 0) segments = minSegments; if (segments <= 0) segments = minSegments;
} }
@ -418,7 +418,7 @@ void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float
{ {
// Calculate the maximum angle between segments based on the error rate (usually 0.5f) // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1); float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1);
segments = (int)((endAngle - startAngle)*ceilf(2*PI/th)/360); segments = (int)ceilf((endAngle - startAngle)*(2*PI/th)/360.0f);
if (segments <= 0) segments = minSegments; if (segments <= 0) segments = minSegments;
} }
@ -544,7 +544,7 @@ void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startA
{ {
// Calculate the maximum angle between segments based on the error rate (usually 0.5f) // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/outerRadius, 2) - 1); float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/outerRadius, 2) - 1);
segments = (int)((endAngle - startAngle)*ceilf(2*PI/th)/360); segments = (int)ceilf((endAngle - startAngle)*(2*PI/th)/360.0f);
if (segments <= 0) segments = minSegments; if (segments <= 0) segments = minSegments;
} }
@ -635,7 +635,7 @@ void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float s
{ {
// Calculate the maximum angle between segments based on the error rate (usually 0.5f) // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/outerRadius, 2) - 1); float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/outerRadius, 2) - 1);
segments = (int)((endAngle - startAngle)*ceilf(2*PI/th)/360); segments = (int)ceilf((endAngle - startAngle)*(2*PI/th)/360.0f);
if (segments <= 0) segments = minSegments; if (segments <= 0) segments = minSegments;
} }
@ -925,7 +925,7 @@ void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color co
{ {
// Calculate the maximum angle between segments based on the error rate (usually 0.5f) // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1); float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1);
segments = (int)(ceilf(2*PI/th)/4.0f); segments = (int)ceilf((2*PI/th)/4.0f);
if (segments <= 0) segments = 4; if (segments <= 0) segments = 4;
} }
@ -1160,7 +1160,7 @@ void DrawRectangleRoundedLinesEx(Rectangle rec, float roundness, int segments, f
{ {
// Calculate the maximum angle between segments based on the error rate (usually 0.5f) // Calculate the maximum angle between segments based on the error rate (usually 0.5f)
float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1); float th = acosf(2*powf(1 - SMOOTH_CIRCLE_ERROR_RATE/radius, 2) - 1);
segments = (int)(ceilf(2*PI/th)/2.0f); segments = (int)ceilf((2*PI/th)/4.0f);
if (segments <= 0) segments = 4; if (segments <= 0) segments = 4;
} }

15
src/rtext.c
View File

@ -580,15 +580,20 @@ Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int
TRACELOG(LOG_INFO, "FONT: Data loaded successfully (%i pixel size | %i glyphs)", font.baseSize, font.glyphCount); TRACELOG(LOG_INFO, "FONT: Data loaded successfully (%i pixel size | %i glyphs)", font.baseSize, font.glyphCount);
} }
else font = GetFontDefault(); else
{
TRACELOG(LOG_WARNING, "FONT: Font is not supported by LoadFontEx/LoadFontFromMemory or no glyphs found, reverted to default font");
font = GetFontDefault();
}
#else #else
TRACELOG(LOG_WARNING, "FONT: Font is not supported by LoadFontEx/LoadFontFromMemory or no glyphs found, reverted to default font");
font = GetFontDefault(); font = GetFontDefault();
#endif #endif
return font; return font;
} }
// Check if a font is valid (font data loaded) // Check if font is valid (font data loaded)
// WARNING: GPU texture not checked // WARNING: GPU texture not checked
bool IsFontValid(Font font) bool IsFontValid(Font font)
{ {
@ -678,7 +683,7 @@ GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSiz
// stbtt_GetCodepointBitmapBox() -- how big the bitmap must be // stbtt_GetCodepointBitmapBox() -- how big the bitmap must be
// stbtt_MakeCodepointBitmap() -- renders into a provided bitmap // stbtt_MakeCodepointBitmap() -- renders into a provided bitmap
// Check if a glyph is available in the font // Check if glyph is available in the font
// WARNING: if (index == 0), glyph not found, it could fallback to default .notdef glyph (if defined in font) // WARNING: if (index == 0), glyph not found, it could fallback to default .notdef glyph (if defined in font)
int index = stbtt_FindGlyphIndex(&fontInfo, cp); int index = stbtt_FindGlyphIndex(&fontInfo, cp);
@ -2667,8 +2672,8 @@ static Font LoadBMFont(const char *fileName)
for (int i = 1; i < pageCount; i++) for (int i = 1; i < pageCount; i++)
{ {
Rectangle srcRec = { 0.0f, 0.0f, (float)imWidth, (float)imHeight }; Rectangle srcRec = { 0.0f, 0.0f, (float)imWidth, (float)imHeight };
Rectangle destRec = { 0.0f, (float)imHeight*(float)i, (float)imWidth, (float)imHeight }; Rectangle dstRec = { 0.0f, (float)imHeight*(float)i, (float)imWidth, (float)imHeight };
ImageDraw(&fullFont, imFonts[i], srcRec, destRec, WHITE); ImageDraw(&fullFont, imFonts[i], srcRec, dstRec, WHITE);
} }
} }

112
src/rtextures.c
View File

@ -1744,7 +1744,7 @@ void ImageResize(Image *image, int newWidth, int newHeight)
// Security check to avoid program crash // Security check to avoid program crash
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return; if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
// Check if a fast path can be used on image scaling // Check if fast path can be used on image scaling
// It can be for 8 bit per channel images with 1 to 4 channels per pixel // It can be for 8 bit per channel images with 1 to 4 channels per pixel
if ((image->format == PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) || if ((image->format == PIXELFORMAT_UNCOMPRESSED_GRAYSCALE) ||
(image->format == PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) || (image->format == PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA) ||
@ -3506,7 +3506,7 @@ void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int en
} }
// Initialize variables for drawing loop // Initialize variables for drawing loop
int endVal = longLen; int endVal = longLen + 1;
int sgnInc = 1; int sgnInc = 1;
// Adjust direction increment based on longLen sign // Adjust direction increment based on longLen sign
@ -3514,6 +3514,7 @@ void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int en
{ {
longLen = -longLen; longLen = -longLen;
sgnInc = -1; sgnInc = -1;
endVal -= 2;
} }
// Calculate fixed-point increment for shorter length // Calculate fixed-point increment for shorter length
@ -3523,7 +3524,8 @@ void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int en
if (yLonger) if (yLonger)
{ {
// If line is more vertical, iterate over y-axis // If line is more vertical, iterate over y-axis
for (int i = 0, j = 0; i != endVal; i += sgnInc, j += decInc) // Init j with 0.5 in 16-bit fixed point (1 << 15) for better rounding.
for (int i = 0, j = (1 << 15); i != endVal; i += sgnInc, j += decInc)
{ {
// Calculate pixel position and draw it // Calculate pixel position and draw it
ImageDrawPixel(dst, startPosX + (j >> 16), startPosY + i, color); ImageDrawPixel(dst, startPosX + (j >> 16), startPosY + i, color);
@ -3532,7 +3534,7 @@ void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int en
else else
{ {
// If line is more horizontal, iterate over x-axis // If line is more horizontal, iterate over x-axis
for (int i = 0, j = 0; i != endVal; i += sgnInc, j += decInc) for (int i = 0, j = (1 << 15); i != endVal; i += sgnInc, j += decInc)
{ {
// Calculate pixel position and draw it // Calculate pixel position and draw it
ImageDrawPixel(dst, startPosX + i, startPosY + (j >> 16), color); ImageDrawPixel(dst, startPosX + i, startPosY + (j >> 16), color);
@ -4293,7 +4295,7 @@ RenderTexture2D LoadRenderTexture(int width, int height)
return target; return target;
} }
// Check if a texture is valid (loaded in GPU) // Check if texture is valid (loaded in GPU)
bool IsTextureValid(Texture2D texture) bool IsTextureValid(Texture2D texture)
{ {
bool result = false; bool result = false;
@ -4318,7 +4320,7 @@ void UnloadTexture(Texture2D texture)
} }
} }
// Check if a render texture is valid (loaded in GPU) // Check if render texture is valid (loaded in GPU)
bool IsRenderTextureValid(RenderTexture2D target) bool IsRenderTextureValid(RenderTexture2D target)
{ {
bool result = false; bool result = false;
@ -4489,25 +4491,25 @@ void DrawTextureV(Texture2D texture, Vector2 position, Color tint)
// Draw a texture with extended parameters // Draw a texture with extended parameters
void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint) void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint)
{ {
Rectangle source = { 0.0f, 0.0f, (float)texture.width, (float)texture.height }; Rectangle srcrec = { 0.0f, 0.0f, (float)texture.width, (float)texture.height };
Rectangle dest = { position.x, position.y, (float)texture.width*scale, (float)texture.height*scale }; Rectangle dstrec = { position.x, position.y, (float)texture.width*scale, (float)texture.height*scale };
Vector2 origin = { 0.0f, 0.0f }; Vector2 origin = { 0.0f, 0.0f };
DrawTexturePro(texture, source, dest, origin, rotation, tint); DrawTexturePro(texture, srcrec, dstrec, origin, rotation, tint);
} }
// Draw a part of a texture (defined by a rectangle) // Draw a part of a texture (defined by a rectangle)
void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint) void DrawTextureRec(Texture2D texture, Rectangle rec, Vector2 position, Color tint)
{ {
Rectangle dest = { position.x, position.y, fabsf(source.width), fabsf(source.height) }; Rectangle dstrec = { position.x, position.y, fabsf(rec.width), fabsf(rec.height) };
Vector2 origin = { 0.0f, 0.0f }; Vector2 origin = { 0.0f, 0.0f };
DrawTexturePro(texture, source, dest, origin, 0.0f, tint); DrawTexturePro(texture, rec, dstrec, origin, 0.0f, tint);
} }
// Draw a part of a texture (defined by a rectangle) with 'pro' parameters // Draw a part of a texture (defined by a rectangle) with 'pro' parameters
// NOTE: origin is relative to destination rectangle size // NOTE: origin is relative to destination rectangle size
void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint) void DrawTexturePro(Texture2D texture, Rectangle srcrec, Rectangle dstrec, Vector2 origin, float rotation, Color tint)
{ {
// Check if texture is valid // Check if texture is valid
if (texture.id > 0) if (texture.id > 0)
@ -4517,11 +4519,11 @@ void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2
bool flipX = false; bool flipX = false;
if (source.width < 0) { flipX = true; source.width *= -1; } if (srcrec.width < 0) { flipX = true; srcrec.width *= -1; }
if (source.height < 0) source.y -= source.height; if (srcrec.height < 0) srcrec.y -= srcrec.height;
if (dest.width < 0) dest.width *= -1; if (dstrec.width < 0) dstrec.width *= -1;
if (dest.height < 0) dest.height *= -1; if (dstrec.height < 0) dstrec.height *= -1;
Vector2 topLeft = { 0 }; Vector2 topLeft = { 0 };
Vector2 topRight = { 0 }; Vector2 topRight = { 0 };
@ -4531,33 +4533,33 @@ void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2
// Only calculate rotation if needed // Only calculate rotation if needed
if (rotation == 0.0f) if (rotation == 0.0f)
{ {
float x = dest.x - origin.x; float x = dstrec.x - origin.x;
float y = dest.y - origin.y; float y = dstrec.y - origin.y;
topLeft = (Vector2){ x, y }; topLeft = (Vector2){ x, y };
topRight = (Vector2){ x + dest.width, y }; topRight = (Vector2){ x + dstrec.width, y };
bottomLeft = (Vector2){ x, y + dest.height }; bottomLeft = (Vector2){ x, y + dstrec.height };
bottomRight = (Vector2){ x + dest.width, y + dest.height }; bottomRight = (Vector2){ x + dstrec.width, y + dstrec.height };
} }
else else
{ {
float sinRotation = sinf(rotation*DEG2RAD); float sinRotation = sinf(rotation*DEG2RAD);
float cosRotation = cosf(rotation*DEG2RAD); float cosRotation = cosf(rotation*DEG2RAD);
float x = dest.x; float x = dstrec.x;
float y = dest.y; float y = dstrec.y;
float dx = -origin.x; float dx = -origin.x;
float dy = -origin.y; float dy = -origin.y;
topLeft.x = x + dx*cosRotation - dy*sinRotation; topLeft.x = x + dx*cosRotation - dy*sinRotation;
topLeft.y = y + dx*sinRotation + dy*cosRotation; topLeft.y = y + dx*sinRotation + dy*cosRotation;
topRight.x = x + (dx + dest.width)*cosRotation - dy*sinRotation; topRight.x = x + (dx + dstrec.width)*cosRotation - dy*sinRotation;
topRight.y = y + (dx + dest.width)*sinRotation + dy*cosRotation; topRight.y = y + (dx + dstrec.width)*sinRotation + dy*cosRotation;
bottomLeft.x = x + dx*cosRotation - (dy + dest.height)*sinRotation; bottomLeft.x = x + dx*cosRotation - (dy + dstrec.height)*sinRotation;
bottomLeft.y = y + dx*sinRotation + (dy + dest.height)*cosRotation; bottomLeft.y = y + dx*sinRotation + (dy + dstrec.height)*cosRotation;
bottomRight.x = x + (dx + dest.width)*cosRotation - (dy + dest.height)*sinRotation; bottomRight.x = x + (dx + dstrec.width)*cosRotation - (dy + dstrec.height)*sinRotation;
bottomRight.y = y + (dx + dest.width)*sinRotation + (dy + dest.height)*cosRotation; bottomRight.y = y + (dx + dstrec.width)*sinRotation + (dy + dstrec.height)*cosRotation;
} }
rlSetTexture(texture.id); rlSetTexture(texture.id);
@ -4567,23 +4569,23 @@ void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2
rlNormal3f(0.0f, 0.0f, 1.0f); // Normal vector pointing towards viewer rlNormal3f(0.0f, 0.0f, 1.0f); // Normal vector pointing towards viewer
// Top-left corner for texture and quad // Top-left corner for texture and quad
if (flipX) rlTexCoord2f((source.x + source.width)/width, source.y/height); if (flipX) rlTexCoord2f((srcrec.x + srcrec.width)/width, srcrec.y/height);
else rlTexCoord2f(source.x/width, source.y/height); else rlTexCoord2f(srcrec.x/width, srcrec.y/height);
rlVertex2f(topLeft.x, topLeft.y); rlVertex2f(topLeft.x, topLeft.y);
// Bottom-left corner for texture and quad // Bottom-left corner for texture and quad
if (flipX) rlTexCoord2f((source.x + source.width)/width, (source.y + source.height)/height); if (flipX) rlTexCoord2f((srcrec.x + srcrec.width)/width, (srcrec.y + srcrec.height)/height);
else rlTexCoord2f(source.x/width, (source.y + source.height)/height); else rlTexCoord2f(srcrec.x/width, (srcrec.y + srcrec.height)/height);
rlVertex2f(bottomLeft.x, bottomLeft.y); rlVertex2f(bottomLeft.x, bottomLeft.y);
// Bottom-right corner for texture and quad // Bottom-right corner for texture and quad
if (flipX) rlTexCoord2f(source.x/width, (source.y + source.height)/height); if (flipX) rlTexCoord2f(srcrec.x/width, (srcrec.y + srcrec.height)/height);
else rlTexCoord2f((source.x + source.width)/width, (source.y + source.height)/height); else rlTexCoord2f((srcrec.x + srcrec.width)/width, (srcrec.y + srcrec.height)/height);
rlVertex2f(bottomRight.x, bottomRight.y); rlVertex2f(bottomRight.x, bottomRight.y);
// Top-right corner for texture and quad // Top-right corner for texture and quad
if (flipX) rlTexCoord2f(source.x/width, source.y/height); if (flipX) rlTexCoord2f(srcrec.x/width, srcrec.y/height);
else rlTexCoord2f((source.x + source.width)/width, source.y/height); else rlTexCoord2f((srcrec.x + srcrec.width)/width, srcrec.y/height);
rlVertex2f(topRight.x, topRight.y); rlVertex2f(topRight.x, topRight.y);
rlEnd(); rlEnd();
@ -4597,7 +4599,7 @@ void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2
/* /*
rlSetTexture(texture.id); rlSetTexture(texture.id);
rlPushMatrix(); rlPushMatrix();
rlTranslatef(dest.x, dest.y, 0.0f); rlTranslatef(dstrec.x, dstrec.y, 0.0f);
if (rotation != 0.0f) rlRotatef(rotation, 0.0f, 0.0f, 1.0f); if (rotation != 0.0f) rlRotatef(rotation, 0.0f, 0.0f, 1.0f);
rlTranslatef(-origin.x, -origin.y, 0.0f); rlTranslatef(-origin.x, -origin.y, 0.0f);
@ -4606,24 +4608,24 @@ void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2
rlNormal3f(0.0f, 0.0f, 1.0f); // Normal vector pointing towards viewer rlNormal3f(0.0f, 0.0f, 1.0f); // Normal vector pointing towards viewer
// Bottom-left corner for texture and quad // Bottom-left corner for texture and quad
if (flipX) rlTexCoord2f((source.x + source.width)/width, source.y/height); if (flipX) rlTexCoord2f((srcrec.x + srcrec.width)/width, srcrec.y/height);
else rlTexCoord2f(source.x/width, source.y/height); else rlTexCoord2f(srcrec.x/width, srcrec.y/height);
rlVertex2f(0.0f, 0.0f); rlVertex2f(0.0f, 0.0f);
// Bottom-right corner for texture and quad // Bottom-right corner for texture and quad
if (flipX) rlTexCoord2f((source.x + source.width)/width, (source.y + source.height)/height); if (flipX) rlTexCoord2f((srcrec.x + srcrec.width)/width, (srcrec.y + srcrec.height)/height);
else rlTexCoord2f(source.x/width, (source.y + source.height)/height); else rlTexCoord2f(srcrec.x/width, (srcrec.y + srcrec.height)/height);
rlVertex2f(0.0f, dest.height); rlVertex2f(0.0f, dstrec.height);
// Top-right corner for texture and quad // Top-right corner for texture and quad
if (flipX) rlTexCoord2f(source.x/width, (source.y + source.height)/height); if (flipX) rlTexCoord2f(srcrec.x/width, (srcrec.y + srcrec.height)/height);
else rlTexCoord2f((source.x + source.width)/width, (source.y + source.height)/height); else rlTexCoord2f((srcrec.x + srcrec.width)/width, (srcrec.y + srcrec.height)/height);
rlVertex2f(dest.width, dest.height); rlVertex2f(dstrec.width, dstrec.height);
// Top-left corner for texture and quad // Top-left corner for texture and quad
if (flipX) rlTexCoord2f(source.x/width, source.y/height); if (flipX) rlTexCoord2f(srcrec.x/width, srcrec.y/height);
else rlTexCoord2f((source.x + source.width)/width, source.y/height); else rlTexCoord2f((srcrec.x + srcrec.width)/width, srcrec.y/height);
rlVertex2f(dest.width, 0.0f); rlVertex2f(dstrec.width, 0.0f);
rlEnd(); rlEnd();
rlPopMatrix(); rlPopMatrix();
rlSetTexture(0); rlSetTexture(0);
@ -4632,15 +4634,15 @@ void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2
} }
// Draw a texture (or part of it) that stretches or shrinks nicely using n-patch info // Draw a texture (or part of it) that stretches or shrinks nicely using n-patch info
void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint) void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dstrec, Vector2 origin, float rotation, Color tint)
{ {
if (texture.id > 0) if (texture.id > 0)
{ {
float width = (float)texture.width; float width = (float)texture.width;
float height = (float)texture.height; float height = (float)texture.height;
float patchWidth = ((int)dest.width <= 0)? 0.0f : dest.width; float patchWidth = ((int)dstrec.width <= 0)? 0.0f : dstrec.width;
float patchHeight = ((int)dest.height <= 0)? 0.0f : dest.height; float patchHeight = ((int)dstrec.height <= 0)? 0.0f : dstrec.height;
if (nPatchInfo.source.width < 0) nPatchInfo.source.x -= nPatchInfo.source.width; if (nPatchInfo.source.width < 0) nPatchInfo.source.x -= nPatchInfo.source.width;
if (nPatchInfo.source.height < 0) nPatchInfo.source.y -= nPatchInfo.source.height; if (nPatchInfo.source.height < 0) nPatchInfo.source.y -= nPatchInfo.source.height;
@ -4699,7 +4701,7 @@ void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest,
rlSetTexture(texture.id); rlSetTexture(texture.id);
rlPushMatrix(); rlPushMatrix();
rlTranslatef(dest.x, dest.y, 0.0f); rlTranslatef(dstrec.x, dstrec.y, 0.0f);
rlRotatef(rotation, 0.0f, 0.0f, 1.0f); rlRotatef(rotation, 0.0f, 0.0f, 1.0f);
rlTranslatef(-origin.x, -origin.y, 0.0f); rlTranslatef(-origin.x, -origin.y, 0.0f);
@ -5178,7 +5180,7 @@ Color GetColor(unsigned int hexValue)
} }
// Get color from a pixel from certain format // Get color from a pixel from certain format
Color GetPixelColor(void *srcPtr, int format) Color GetPixelColor(const void *srcPtr, int format)
{ {
Color color = { 0 }; Color color = { 0 };

33
tools/rexm/rexm.c
View File

@ -675,13 +675,12 @@ int main(int argc, char *argv[])
// WARNING 2: raylib.a and raylib.web.a must be available when compiling locally // WARNING 2: raylib.a and raylib.web.a must be available when compiling locally
#if defined(_WIN32) #if defined(_WIN32)
LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: Win32)\n", GetFileNameWithoutExt(inFileName)); LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: Win32)\n", GetFileNameWithoutExt(inFileName));
//putenv("RAYLIB_DIR=C:\\GitHub\\raylib");
_putenv("PATH=%PATH%;C:\\raylib\\w64devkit\\bin"); _putenv("PATH=%PATH%;C:\\raylib\\w64devkit\\bin");
system(TextFormat("mingw32-make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B", exBasePath, exCategory, exName));
#else #else
LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: POSIX)\n", GetFileNameWithoutExt(inFileName)); LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: POSIX)\n", GetFileNameWithoutExt(inFileName));
system(TextFormat("make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B", exBasePath, exCategory, exName));
#endif #endif
system(TextFormat("make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B", exBasePath, exCategory, exName));
// Update generated .html metadata // Update generated .html metadata
LOG("INFO: [%s] Updating HTML Metadata...\n", TextFormat("%s.html", exName)); LOG("INFO: [%s] Updating HTML Metadata...\n", TextFormat("%s.html", exName));
UpdateWebMetadata(TextFormat("%s/%s/%s.html", exBasePath, exCategory, exName), UpdateWebMetadata(TextFormat("%s/%s/%s.html", exBasePath, exCategory, exName),
@ -778,10 +777,9 @@ int main(int argc, char *argv[])
// WARNING: EMSDK_PATH must be set to proper location when calling from GitHub Actions // WARNING: EMSDK_PATH must be set to proper location when calling from GitHub Actions
#if defined(_WIN32) #if defined(_WIN32)
_putenv("PATH=%PATH%;C:\\raylib\\w64devkit\\bin"); _putenv("PATH=%PATH%;C:\\raylib\\w64devkit\\bin");
system(TextFormat("mingw32-make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B", exBasePath, exRecategory, exRename));
#else
system(TextFormat("make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B", exBasePath, exRecategory, exRename));
#endif #endif
system(TextFormat("make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B", exBasePath, exRecategory, exRename));
// Update generated .html metadata // Update generated .html metadata
UpdateWebMetadata(TextFormat("%s/%s/%s.html", exBasePath, exCategory, exRename), UpdateWebMetadata(TextFormat("%s/%s/%s.html", exBasePath, exCategory, exRename),
TextFormat("%s/%s/%s.c", exBasePath, exCategory, exRename)); TextFormat("%s/%s/%s.c", exBasePath, exCategory, exRename));
@ -917,7 +915,7 @@ int main(int argc, char *argv[])
// Set required environment variables // Set required environment variables
//putenv(TextFormat("RAYLIB_DIR=%s\\..", exBasePath)); //putenv(TextFormat("RAYLIB_DIR=%s\\..", exBasePath));
_putenv("PATH=%PATH%;C:\\raylib\\w64devkit\\bin"); _putenv("PATH=%PATH%;C:\\raylib\\w64devkit\\bin");
//putenv("MAKE=mingw32-make"); //putenv("MAKE=make");
//ChangeDirectory(exBasePath); //ChangeDirectory(exBasePath);
#endif #endif
for (int i = 0; i < exBuildListCount; i++) for (int i = 0; i < exBuildListCount; i++)
@ -933,7 +931,7 @@ int main(int argc, char *argv[])
// Build example for PLATFORM_DESKTOP // Build example for PLATFORM_DESKTOP
#if defined(_WIN32) #if defined(_WIN32)
LOG("INFO: [%s] Building example for PLATFORM_DESKTOP (Host: Win32)\n", exName); LOG("INFO: [%s] Building example for PLATFORM_DESKTOP (Host: Win32)\n", exName);
system(TextFormat("mingw32-make -C %s %s/%s PLATFORM=PLATFORM_DESKTOP -B", exBasePath, exCategory, exName)); system(TextFormat("make -C %s %s/%s PLATFORM=PLATFORM_DESKTOP -B", exBasePath, exCategory, exName));
#elif defined(PLATFORM_DRM) #elif defined(PLATFORM_DRM)
LOG("INFO: [%s] Building example for PLATFORM_DRM (Host: POSIX)\n", exName); LOG("INFO: [%s] Building example for PLATFORM_DRM (Host: POSIX)\n", exName);
system(TextFormat("make -C %s %s/%s PLATFORM=PLATFORM_DRM -B > %s/%s/logs/%s.build.log 2>&1", system(TextFormat("make -C %s %s/%s PLATFORM=PLATFORM_DRM -B > %s/%s/logs/%s.build.log 2>&1",
@ -949,13 +947,9 @@ int main(int argc, char *argv[])
// Build: raylib.com/examples/<category>/<category>_example_name.data // Build: raylib.com/examples/<category>/<category>_example_name.data
// Build: raylib.com/examples/<category>/<category>_example_name.wasm // Build: raylib.com/examples/<category>/<category>_example_name.wasm
// Build: raylib.com/examples/<category>/<category>_example_name.js // Build: raylib.com/examples/<category>/<category>_example_name.js
#if defined(_WIN32) LOG("INFO: [%s] Building example for PLATFORM_WEB\n", exName);
LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: Win32)\n", exName);
system(TextFormat("mingw32-make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B", exBasePath, exCategory, exName));
#else
LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: POSIX)\n", exName);
system(TextFormat("make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B", exBasePath, exCategory, exName)); system(TextFormat("make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B", exBasePath, exCategory, exName));
#endif
// Update generated .html metadata // Update generated .html metadata
LOG("INFO: [%s] Updating HTML Metadata...\n", TextFormat("%s.html", exName)); LOG("INFO: [%s] Updating HTML Metadata...\n", TextFormat("%s.html", exName));
UpdateWebMetadata(TextFormat("%s/%s/%s.html", exBasePath, exCategory, exName), UpdateWebMetadata(TextFormat("%s/%s/%s.html", exBasePath, exCategory, exName),
@ -1312,11 +1306,10 @@ int main(int argc, char *argv[])
#if defined(_WIN32) #if defined(_WIN32)
LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: Win32)\n", exInfo->name); LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: Win32)\n", exInfo->name);
_putenv("PATH=%PATH%;C:\\raylib\\w64devkit\\bin"); _putenv("PATH=%PATH%;C:\\raylib\\w64devkit\\bin");
system(TextFormat("mingw32-make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B", exBasePath, exInfo->category, exInfo->name));
#else #else
LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: POSIX)\n", exInfo->name); LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: POSIX)\n", exInfo->name);
system(TextFormat("make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B", exBasePath, exInfo->category, exInfo->name));
#endif #endif
system(TextFormat("make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B", exBasePath, exInfo->category, exInfo->name));
// Update generated .html metadata // Update generated .html metadata
LOG("INFO: [%s.html] Updating HTML Metadata...\n", exInfo->name); LOG("INFO: [%s.html] Updating HTML Metadata...\n", exInfo->name);
@ -1495,7 +1488,7 @@ int main(int argc, char *argv[])
// Set required environment variables // Set required environment variables
//putenv(TextFormat("RAYLIB_DIR=%s\\..", exBasePath)); //putenv(TextFormat("RAYLIB_DIR=%s\\..", exBasePath));
//_putenv("PATH=%PATH%;C:\\raylib\\w64devkit\\bin"); //_putenv("PATH=%PATH%;C:\\raylib\\w64devkit\\bin");
//putenv("MAKE=mingw32-make"); //putenv("MAKE=make");
//ChangeDirectory(exBasePath); //ChangeDirectory(exBasePath);
//_putenv("MAKE_PATH=C:\\raylib\\w64devkit\\bin"); //_putenv("MAKE_PATH=C:\\raylib\\w64devkit\\bin");
//_putenv("EMSDK_PATH = C:\\raylib\\emsdk"); //_putenv("EMSDK_PATH = C:\\raylib\\emsdk");
@ -1592,7 +1585,7 @@ int main(int argc, char *argv[])
// Build: raylib.com/examples/<category>/<category>_example_name.js // Build: raylib.com/examples/<category>/<category>_example_name.js
#if defined(_WIN32) #if defined(_WIN32)
LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: Win32)\n", exName); LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: Win32)\n", exName);
system(TextFormat("mingw32-make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B > %s/%s/logs/%s.build.log 2>&1", system(TextFormat("make -C %s -f Makefile.Web %s/%s PLATFORM=PLATFORM_WEB -B > %s/%s/logs/%s.build.log 2>&1",
exBasePath, exCategory, exName, exBasePath, exCategory, exName)); exBasePath, exCategory, exName, exBasePath, exCategory, exName));
#else #else
LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: POSIX)\n", exName); LOG("INFO: [%s] Building example for PLATFORM_WEB (Host: POSIX)\n", exName);
@ -1641,13 +1634,13 @@ int main(int argc, char *argv[])
// Set required environment variables // Set required environment variables
//putenv(TextFormat("RAYLIB_DIR=%s\\..", exBasePath)); //putenv(TextFormat("RAYLIB_DIR=%s\\..", exBasePath));
_putenv("PATH=%PATH%;C:\\raylib\\w64devkit\\bin"); _putenv("PATH=%PATH%;C:\\raylib\\w64devkit\\bin");
//putenv("MAKE=mingw32-make"); //putenv("MAKE=make");
//ChangeDirectory(exBasePath); //ChangeDirectory(exBasePath);
#endif #endif
// Build example for PLATFORM_DESKTOP // Build example for PLATFORM_DESKTOP
#if defined(_WIN32) #if defined(_WIN32)
LOG("INFO: [%s] Building example for PLATFORM_DESKTOP (Host: Win32)\n", exName); LOG("INFO: [%s] Building example for PLATFORM_DESKTOP (Host: Win32)\n", exName);
system(TextFormat("mingw32-make -C %s %s/%s PLATFORM=PLATFORM_DESKTOP -B > %s/%s/logs/%s.build.log 2>&1", system(TextFormat("make -C %s %s/%s PLATFORM=PLATFORM_DESKTOP -B > %s/%s/logs/%s.build.log 2>&1",
exBasePath, exCategory, exName, exBasePath, exCategory, exName)); exBasePath, exCategory, exName, exBasePath, exCategory, exName));
#elif defined(PLATFORM_DRM) #elif defined(PLATFORM_DRM)
LOG("INFO: [%s] Building example for PLATFORM_DRM (Host: POSIX)\n", exName); LOG("INFO: [%s] Building example for PLATFORM_DRM (Host: POSIX)\n", exName);

100
tools/rlparser/output/raylib_api.json
View File

@ -3800,7 +3800,7 @@
}, },
{ {
"name": "IsShaderValid", "name": "IsShaderValid",
"description": "Check if a shader is valid (loaded on GPU)", "description": "Check if shader is valid (loaded on GPU)",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -4427,7 +4427,7 @@
}, },
{ {
"name": "FileRename", "name": "FileRename",
"description": "Rename file (if exists)", "description": "Rename file (if exists), returns 0 on success",
"returnType": "int", "returnType": "int",
"params": [ "params": [
{ {
@ -4442,7 +4442,7 @@
}, },
{ {
"name": "FileRemove", "name": "FileRemove",
"description": "Remove file (if exists)", "description": "Remove file (if exists), returns 0 on success",
"returnType": "int", "returnType": "int",
"params": [ "params": [
{ {
@ -4453,7 +4453,7 @@
}, },
{ {
"name": "FileCopy", "name": "FileCopy",
"description": "Copy file from one path to another, dstPath created if it doesn't exist", "description": "Copy file from one path to another, dstPath created if it doesn't exist, returns 0 on success",
"returnType": "int", "returnType": "int",
"params": [ "params": [
{ {
@ -4468,7 +4468,7 @@
}, },
{ {
"name": "FileMove", "name": "FileMove",
"description": "Move file from one directory to another, dstPath created if it doesn't exist", "description": "Move file from one directory to another, dstPath created if it doesn't exist, returns 0 on success",
"returnType": "int", "returnType": "int",
"params": [ "params": [
{ {
@ -4483,7 +4483,7 @@
}, },
{ {
"name": "FileTextReplace", "name": "FileTextReplace",
"description": "Replace text in an existing file", "description": "Replace text in an existing file, returns 0 on success",
"returnType": "int", "returnType": "int",
"params": [ "params": [
{ {
@ -4502,7 +4502,7 @@
}, },
{ {
"name": "FileTextFindIndex", "name": "FileTextFindIndex",
"description": "Find text in existing file", "description": "Find text in existing file, returns -1 if index not found or index otherwise",
"returnType": "int", "returnType": "int",
"params": [ "params": [
{ {
@ -4528,7 +4528,7 @@
}, },
{ {
"name": "DirectoryExists", "name": "DirectoryExists",
"description": "Check if a directory path exists", "description": "Check if directory path exists",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -4652,8 +4652,8 @@
}, },
{ {
"name": "ChangeDirectory", "name": "ChangeDirectory",
"description": "Change working directory, return true on success", "description": "Change working directory, returns 0 on success",
"returnType": "bool", "returnType": "int",
"params": [ "params": [
{ {
"type": "const char *", "type": "const char *",
@ -4663,7 +4663,7 @@
}, },
{ {
"name": "IsPathFile", "name": "IsPathFile",
"description": "Check if a given path is a file or a directory", "description": "Check if given path is a file or a directory",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -4696,7 +4696,7 @@
}, },
{ {
"name": "LoadDirectoryFilesEx", "name": "LoadDirectoryFilesEx",
"description": "Load directory filepaths with extension filtering and subdir scan; some filters available: `*.*`,`FILES*`,`DIRS*`", "description": "Load directory filepaths with extension filtering and subdir scan; some filters available: '*.*','FILES*','DIRS*'",
"returnType": "FilePathList", "returnType": "FilePathList",
"params": [ "params": [
{ {
@ -4726,7 +4726,7 @@
}, },
{ {
"name": "IsFileDropped", "name": "IsFileDropped",
"description": "Check if a file has been dropped into window", "description": "Check if file has been dropped into window",
"returnType": "bool" "returnType": "bool"
}, },
{ {
@ -4989,7 +4989,7 @@
}, },
{ {
"name": "IsKeyPressed", "name": "IsKeyPressed",
"description": "Check if a key has been pressed once", "description": "Check if key has been pressed once",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5000,7 +5000,7 @@
}, },
{ {
"name": "IsKeyPressedRepeat", "name": "IsKeyPressedRepeat",
"description": "Check if a key has been pressed again", "description": "Check if key has been pressed again",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5011,7 +5011,7 @@
}, },
{ {
"name": "IsKeyDown", "name": "IsKeyDown",
"description": "Check if a key is being pressed", "description": "Check if key is being pressed",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5022,7 +5022,7 @@
}, },
{ {
"name": "IsKeyReleased", "name": "IsKeyReleased",
"description": "Check if a key has been released once", "description": "Check if key has been released once",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5033,7 +5033,7 @@
}, },
{ {
"name": "IsKeyUp", "name": "IsKeyUp",
"description": "Check if a key is NOT being pressed", "description": "Check if key is NOT being pressed",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5076,7 +5076,7 @@
}, },
{ {
"name": "IsGamepadAvailable", "name": "IsGamepadAvailable",
"description": "Check if a gamepad is available", "description": "Check if gamepad is available",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5098,7 +5098,7 @@
}, },
{ {
"name": "IsGamepadButtonPressed", "name": "IsGamepadButtonPressed",
"description": "Check if a gamepad button has been pressed once", "description": "Check if gamepad button has been pressed once",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5113,7 +5113,7 @@
}, },
{ {
"name": "IsGamepadButtonDown", "name": "IsGamepadButtonDown",
"description": "Check if a gamepad button is being pressed", "description": "Check if gamepad button is being pressed",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5128,7 +5128,7 @@
}, },
{ {
"name": "IsGamepadButtonReleased", "name": "IsGamepadButtonReleased",
"description": "Check if a gamepad button has been released once", "description": "Check if gamepad button has been released once",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5143,7 +5143,7 @@
}, },
{ {
"name": "IsGamepadButtonUp", "name": "IsGamepadButtonUp",
"description": "Check if a gamepad button is NOT being pressed", "description": "Check if gamepad button is NOT being pressed",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5223,7 +5223,7 @@
}, },
{ {
"name": "IsMouseButtonPressed", "name": "IsMouseButtonPressed",
"description": "Check if a mouse button has been pressed once", "description": "Check if mouse button has been pressed once",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5234,7 +5234,7 @@
}, },
{ {
"name": "IsMouseButtonDown", "name": "IsMouseButtonDown",
"description": "Check if a mouse button is being pressed", "description": "Check if mouse button is being pressed",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5245,7 +5245,7 @@
}, },
{ {
"name": "IsMouseButtonReleased", "name": "IsMouseButtonReleased",
"description": "Check if a mouse button has been released once", "description": "Check if mouse button has been released once",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5256,7 +5256,7 @@
}, },
{ {
"name": "IsMouseButtonUp", "name": "IsMouseButtonUp",
"description": "Check if a mouse button is NOT being pressed", "description": "Check if mouse button is NOT being pressed",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5401,7 +5401,7 @@
}, },
{ {
"name": "IsGestureDetected", "name": "IsGestureDetected",
"description": "Check if a gesture has been detected", "description": "Check if gesture has been detected",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -5489,7 +5489,7 @@
}, },
{ {
"type": "Rectangle", "type": "Rectangle",
"name": "source" "name": "rec"
} }
] ]
}, },
@ -8716,7 +8716,7 @@
}, },
{ {
"name": "IsTextureValid", "name": "IsTextureValid",
"description": "Check if a texture is valid (loaded in GPU)", "description": "Check if texture is valid (loaded in GPU)",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -8738,7 +8738,7 @@
}, },
{ {
"name": "IsRenderTextureValid", "name": "IsRenderTextureValid",
"description": "Check if a render texture is valid (loaded in GPU)", "description": "Check if render texture is valid (loaded in GPU)",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -8913,7 +8913,7 @@
}, },
{ {
"type": "Rectangle", "type": "Rectangle",
"name": "source" "name": "rec"
}, },
{ {
"type": "Vector2", "type": "Vector2",
@ -8927,7 +8927,7 @@
}, },
{ {
"name": "DrawTexturePro", "name": "DrawTexturePro",
"description": "Draw a part of a texture defined by a rectangle with 'pro' parameters", "description": "Draw a part of a texture defined by a source rectangle to destination rectangle, with scaling and rotation",
"returnType": "void", "returnType": "void",
"params": [ "params": [
{ {
@ -8936,11 +8936,11 @@
}, },
{ {
"type": "Rectangle", "type": "Rectangle",
"name": "source" "name": "srcrec"
}, },
{ {
"type": "Rectangle", "type": "Rectangle",
"name": "dest" "name": "dstrec"
}, },
{ {
"type": "Vector2", "type": "Vector2",
@ -8971,7 +8971,7 @@
}, },
{ {
"type": "Rectangle", "type": "Rectangle",
"name": "dest" "name": "dstrec"
}, },
{ {
"type": "Vector2", "type": "Vector2",
@ -9195,7 +9195,7 @@
"returnType": "Color", "returnType": "Color",
"params": [ "params": [
{ {
"type": "void *", "type": "const void *",
"name": "srcPtr" "name": "srcPtr"
}, },
{ {
@ -9333,7 +9333,7 @@
}, },
{ {
"name": "IsFontValid", "name": "IsFontValid",
"description": "Check if a font is valid (font data loaded, WARNING: GPU texture not checked)", "description": "Check if font is valid (font data loaded, WARNING: GPU texture not checked)",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -10564,7 +10564,7 @@
}, },
{ {
"type": "int", "type": "int",
"name": "slices" "name": "sides"
}, },
{ {
"type": "Color", "type": "Color",
@ -10626,7 +10626,7 @@
}, },
{ {
"type": "int", "type": "int",
"name": "slices" "name": "sides"
}, },
{ {
"type": "Color", "type": "Color",
@ -10657,7 +10657,7 @@
}, },
{ {
"type": "int", "type": "int",
"name": "slices" "name": "sides"
}, },
{ {
"type": "Color", "type": "Color",
@ -10800,7 +10800,7 @@
}, },
{ {
"name": "IsModelValid", "name": "IsModelValid",
"description": "Check if a model is valid (loaded in GPU, VAO/VBOs)", "description": "Check if model is valid (loaded in GPU, VAO/VBOs)",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -10983,7 +10983,7 @@
}, },
{ {
"name": "DrawBillboardRec", "name": "DrawBillboardRec",
"description": "Draw a billboard texture defined by source", "description": "Draw a billboard texture defined by rectangle",
"returnType": "void", "returnType": "void",
"params": [ "params": [
{ {
@ -10996,7 +10996,7 @@
}, },
{ {
"type": "Rectangle", "type": "Rectangle",
"name": "source" "name": "rec"
}, },
{ {
"type": "Vector3", "type": "Vector3",
@ -11014,7 +11014,7 @@
}, },
{ {
"name": "DrawBillboardPro", "name": "DrawBillboardPro",
"description": "Draw a billboard texture defined by source and rotation", "description": "Draw a billboard texture defined by source rectangle with scaling and rotation",
"returnType": "void", "returnType": "void",
"params": [ "params": [
{ {
@ -11027,7 +11027,7 @@
}, },
{ {
"type": "Rectangle", "type": "Rectangle",
"name": "source" "name": "rec"
}, },
{ {
"type": "Vector3", "type": "Vector3",
@ -11433,7 +11433,7 @@
}, },
{ {
"name": "IsMaterialValid", "name": "IsMaterialValid",
"description": "Check if a material is valid (shader assigned, map textures loaded in GPU)", "description": "Check if material is valid (shader assigned, map textures loaded in GPU)",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -11853,7 +11853,7 @@
}, },
{ {
"name": "IsSoundValid", "name": "IsSoundValid",
"description": "Check if a sound is valid (data loaded and buffers initialized)", "description": "Check if sound is valid (data loaded and buffers initialized)",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -11990,7 +11990,7 @@
}, },
{ {
"name": "IsSoundPlaying", "name": "IsSoundPlaying",
"description": "Check if a sound is currently playing", "description": "Check if sound is currently playing",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {
@ -12151,7 +12151,7 @@
}, },
{ {
"name": "IsMusicValid", "name": "IsMusicValid",
"description": "Check if a music stream is valid (context and buffers initialized)", "description": "Check if music stream is valid (context and buffers initialized)",
"returnType": "bool", "returnType": "bool",
"params": [ "params": [
{ {

100
tools/rlparser/output/raylib_api.lua
View File

@ -3626,7 +3626,7 @@ return {
}, },
{ {
name = "IsShaderValid", name = "IsShaderValid",
description = "Check if a shader is valid (loaded on GPU)", description = "Check if shader is valid (loaded on GPU)",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "Shader", name = "shader"} {type = "Shader", name = "shader"}
@ -4022,7 +4022,7 @@ return {
}, },
{ {
name = "FileRename", name = "FileRename",
description = "Rename file (if exists)", description = "Rename file (if exists), returns 0 on success",
returnType = "int", returnType = "int",
params = { params = {
{type = "const char *", name = "fileName"}, {type = "const char *", name = "fileName"},
@ -4031,7 +4031,7 @@ return {
}, },
{ {
name = "FileRemove", name = "FileRemove",
description = "Remove file (if exists)", description = "Remove file (if exists), returns 0 on success",
returnType = "int", returnType = "int",
params = { params = {
{type = "const char *", name = "fileName"} {type = "const char *", name = "fileName"}
@ -4039,7 +4039,7 @@ return {
}, },
{ {
name = "FileCopy", name = "FileCopy",
description = "Copy file from one path to another, dstPath created if it doesn't exist", description = "Copy file from one path to another, dstPath created if it doesn't exist, returns 0 on success",
returnType = "int", returnType = "int",
params = { params = {
{type = "const char *", name = "srcPath"}, {type = "const char *", name = "srcPath"},
@ -4048,7 +4048,7 @@ return {
}, },
{ {
name = "FileMove", name = "FileMove",
description = "Move file from one directory to another, dstPath created if it doesn't exist", description = "Move file from one directory to another, dstPath created if it doesn't exist, returns 0 on success",
returnType = "int", returnType = "int",
params = { params = {
{type = "const char *", name = "srcPath"}, {type = "const char *", name = "srcPath"},
@ -4057,7 +4057,7 @@ return {
}, },
{ {
name = "FileTextReplace", name = "FileTextReplace",
description = "Replace text in an existing file", description = "Replace text in an existing file, returns 0 on success",
returnType = "int", returnType = "int",
params = { params = {
{type = "const char *", name = "fileName"}, {type = "const char *", name = "fileName"},
@ -4067,7 +4067,7 @@ return {
}, },
{ {
name = "FileTextFindIndex", name = "FileTextFindIndex",
description = "Find text in existing file", description = "Find text in existing file, returns -1 if index not found or index otherwise",
returnType = "int", returnType = "int",
params = { params = {
{type = "const char *", name = "fileName"}, {type = "const char *", name = "fileName"},
@ -4084,7 +4084,7 @@ return {
}, },
{ {
name = "DirectoryExists", name = "DirectoryExists",
description = "Check if a directory path exists", description = "Check if directory path exists",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "const char *", name = "dirPath"} {type = "const char *", name = "dirPath"}
@ -4175,15 +4175,15 @@ return {
}, },
{ {
name = "ChangeDirectory", name = "ChangeDirectory",
description = "Change working directory, return true on success", description = "Change working directory, returns 0 on success",
returnType = "bool", returnType = "int",
params = { params = {
{type = "const char *", name = "dirPath"} {type = "const char *", name = "dirPath"}
} }
}, },
{ {
name = "IsPathFile", name = "IsPathFile",
description = "Check if a given path is a file or a directory", description = "Check if given path is a file or a directory",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "const char *", name = "path"} {type = "const char *", name = "path"}
@ -4207,7 +4207,7 @@ return {
}, },
{ {
name = "LoadDirectoryFilesEx", name = "LoadDirectoryFilesEx",
description = "Load directory filepaths with extension filtering and subdir scan; some filters available: `*.*`,`FILES*`,`DIRS*`", description = "Load directory filepaths with extension filtering and subdir scan; some filters available: '*.*','FILES*','DIRS*'",
returnType = "FilePathList", returnType = "FilePathList",
params = { params = {
{type = "const char *", name = "basePath"}, {type = "const char *", name = "basePath"},
@ -4225,7 +4225,7 @@ return {
}, },
{ {
name = "IsFileDropped", name = "IsFileDropped",
description = "Check if a file has been dropped into window", description = "Check if file has been dropped into window",
returnType = "bool" returnType = "bool"
}, },
{ {
@ -4395,7 +4395,7 @@ return {
}, },
{ {
name = "IsKeyPressed", name = "IsKeyPressed",
description = "Check if a key has been pressed once", description = "Check if key has been pressed once",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "key"} {type = "int", name = "key"}
@ -4403,7 +4403,7 @@ return {
}, },
{ {
name = "IsKeyPressedRepeat", name = "IsKeyPressedRepeat",
description = "Check if a key has been pressed again", description = "Check if key has been pressed again",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "key"} {type = "int", name = "key"}
@ -4411,7 +4411,7 @@ return {
}, },
{ {
name = "IsKeyDown", name = "IsKeyDown",
description = "Check if a key is being pressed", description = "Check if key is being pressed",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "key"} {type = "int", name = "key"}
@ -4419,7 +4419,7 @@ return {
}, },
{ {
name = "IsKeyReleased", name = "IsKeyReleased",
description = "Check if a key has been released once", description = "Check if key has been released once",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "key"} {type = "int", name = "key"}
@ -4427,7 +4427,7 @@ return {
}, },
{ {
name = "IsKeyUp", name = "IsKeyUp",
description = "Check if a key is NOT being pressed", description = "Check if key is NOT being pressed",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "key"} {type = "int", name = "key"}
@ -4461,7 +4461,7 @@ return {
}, },
{ {
name = "IsGamepadAvailable", name = "IsGamepadAvailable",
description = "Check if a gamepad is available", description = "Check if gamepad is available",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "gamepad"} {type = "int", name = "gamepad"}
@ -4477,7 +4477,7 @@ return {
}, },
{ {
name = "IsGamepadButtonPressed", name = "IsGamepadButtonPressed",
description = "Check if a gamepad button has been pressed once", description = "Check if gamepad button has been pressed once",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "gamepad"}, {type = "int", name = "gamepad"},
@ -4486,7 +4486,7 @@ return {
}, },
{ {
name = "IsGamepadButtonDown", name = "IsGamepadButtonDown",
description = "Check if a gamepad button is being pressed", description = "Check if gamepad button is being pressed",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "gamepad"}, {type = "int", name = "gamepad"},
@ -4495,7 +4495,7 @@ return {
}, },
{ {
name = "IsGamepadButtonReleased", name = "IsGamepadButtonReleased",
description = "Check if a gamepad button has been released once", description = "Check if gamepad button has been released once",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "gamepad"}, {type = "int", name = "gamepad"},
@ -4504,7 +4504,7 @@ return {
}, },
{ {
name = "IsGamepadButtonUp", name = "IsGamepadButtonUp",
description = "Check if a gamepad button is NOT being pressed", description = "Check if gamepad button is NOT being pressed",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "gamepad"}, {type = "int", name = "gamepad"},
@ -4554,7 +4554,7 @@ return {
}, },
{ {
name = "IsMouseButtonPressed", name = "IsMouseButtonPressed",
description = "Check if a mouse button has been pressed once", description = "Check if mouse button has been pressed once",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "button"} {type = "int", name = "button"}
@ -4562,7 +4562,7 @@ return {
}, },
{ {
name = "IsMouseButtonDown", name = "IsMouseButtonDown",
description = "Check if a mouse button is being pressed", description = "Check if mouse button is being pressed",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "button"} {type = "int", name = "button"}
@ -4570,7 +4570,7 @@ return {
}, },
{ {
name = "IsMouseButtonReleased", name = "IsMouseButtonReleased",
description = "Check if a mouse button has been released once", description = "Check if mouse button has been released once",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "button"} {type = "int", name = "button"}
@ -4578,7 +4578,7 @@ return {
}, },
{ {
name = "IsMouseButtonUp", name = "IsMouseButtonUp",
description = "Check if a mouse button is NOT being pressed", description = "Check if mouse button is NOT being pressed",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "int", name = "button"} {type = "int", name = "button"}
@ -4690,7 +4690,7 @@ return {
}, },
{ {
name = "IsGestureDetected", name = "IsGestureDetected",
description = "Check if a gesture has been detected", description = "Check if gesture has been detected",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "unsigned int", name = "gesture"} {type = "unsigned int", name = "gesture"}
@ -4752,7 +4752,7 @@ return {
returnType = "void", returnType = "void",
params = { params = {
{type = "Texture2D", name = "texture"}, {type = "Texture2D", name = "texture"},
{type = "Rectangle", name = "source"} {type = "Rectangle", name = "rec"}
} }
}, },
{ {
@ -6361,7 +6361,7 @@ return {
}, },
{ {
name = "IsTextureValid", name = "IsTextureValid",
description = "Check if a texture is valid (loaded in GPU)", description = "Check if texture is valid (loaded in GPU)",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "Texture2D", name = "texture"} {type = "Texture2D", name = "texture"}
@ -6377,7 +6377,7 @@ return {
}, },
{ {
name = "IsRenderTextureValid", name = "IsRenderTextureValid",
description = "Check if a render texture is valid (loaded in GPU)", description = "Check if render texture is valid (loaded in GPU)",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "RenderTexture2D", name = "target"} {type = "RenderTexture2D", name = "target"}
@ -6475,19 +6475,19 @@ return {
returnType = "void", returnType = "void",
params = { params = {
{type = "Texture2D", name = "texture"}, {type = "Texture2D", name = "texture"},
{type = "Rectangle", name = "source"}, {type = "Rectangle", name = "rec"},
{type = "Vector2", name = "position"}, {type = "Vector2", name = "position"},
{type = "Color", name = "tint"} {type = "Color", name = "tint"}
} }
}, },
{ {
name = "DrawTexturePro", name = "DrawTexturePro",
description = "Draw a part of a texture defined by a rectangle with 'pro' parameters", description = "Draw a part of a texture defined by a source rectangle to destination rectangle, with scaling and rotation",
returnType = "void", returnType = "void",
params = { params = {
{type = "Texture2D", name = "texture"}, {type = "Texture2D", name = "texture"},
{type = "Rectangle", name = "source"}, {type = "Rectangle", name = "srcrec"},
{type = "Rectangle", name = "dest"}, {type = "Rectangle", name = "dstrec"},
{type = "Vector2", name = "origin"}, {type = "Vector2", name = "origin"},
{type = "float", name = "rotation"}, {type = "float", name = "rotation"},
{type = "Color", name = "tint"} {type = "Color", name = "tint"}
@ -6500,7 +6500,7 @@ return {
params = { params = {
{type = "Texture2D", name = "texture"}, {type = "Texture2D", name = "texture"},
{type = "NPatchInfo", name = "nPatchInfo"}, {type = "NPatchInfo", name = "nPatchInfo"},
{type = "Rectangle", name = "dest"}, {type = "Rectangle", name = "dstrec"},
{type = "Vector2", name = "origin"}, {type = "Vector2", name = "origin"},
{type = "float", name = "rotation"}, {type = "float", name = "rotation"},
{type = "Color", name = "tint"} {type = "Color", name = "tint"}
@ -6635,7 +6635,7 @@ return {
description = "Get Color from a source pixel pointer of certain format", description = "Get Color from a source pixel pointer of certain format",
returnType = "Color", returnType = "Color",
params = { params = {
{type = "void *", name = "srcPtr"}, {type = "const void *", name = "srcPtr"},
{type = "int", name = "format"} {type = "int", name = "format"}
} }
}, },
@ -6708,7 +6708,7 @@ return {
}, },
{ {
name = "IsFontValid", name = "IsFontValid",
description = "Check if a font is valid (font data loaded, WARNING: GPU texture not checked)", description = "Check if font is valid (font data loaded, WARNING: GPU texture not checked)",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "Font", name = "font"} {type = "Font", name = "font"}
@ -7364,7 +7364,7 @@ return {
{type = "float", name = "radiusTop"}, {type = "float", name = "radiusTop"},
{type = "float", name = "radiusBottom"}, {type = "float", name = "radiusBottom"},
{type = "float", name = "height"}, {type = "float", name = "height"},
{type = "int", name = "slices"}, {type = "int", name = "sides"},
{type = "Color", name = "color"} {type = "Color", name = "color"}
} }
}, },
@ -7390,7 +7390,7 @@ return {
{type = "float", name = "radiusTop"}, {type = "float", name = "radiusTop"},
{type = "float", name = "radiusBottom"}, {type = "float", name = "radiusBottom"},
{type = "float", name = "height"}, {type = "float", name = "height"},
{type = "int", name = "slices"}, {type = "int", name = "sides"},
{type = "Color", name = "color"} {type = "Color", name = "color"}
} }
}, },
@ -7403,7 +7403,7 @@ return {
{type = "Vector3", name = "endPos"}, {type = "Vector3", name = "endPos"},
{type = "float", name = "startRadius"}, {type = "float", name = "startRadius"},
{type = "float", name = "endRadius"}, {type = "float", name = "endRadius"},
{type = "int", name = "slices"}, {type = "int", name = "sides"},
{type = "Color", name = "color"} {type = "Color", name = "color"}
} }
}, },
@ -7479,7 +7479,7 @@ return {
}, },
{ {
name = "IsModelValid", name = "IsModelValid",
description = "Check if a model is valid (loaded in GPU, VAO/VBOs)", description = "Check if model is valid (loaded in GPU, VAO/VBOs)",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "Model", name = "model"} {type = "Model", name = "model"}
@ -7572,12 +7572,12 @@ return {
}, },
{ {
name = "DrawBillboardRec", name = "DrawBillboardRec",
description = "Draw a billboard texture defined by source", description = "Draw a billboard texture defined by rectangle",
returnType = "void", returnType = "void",
params = { params = {
{type = "Camera", name = "camera"}, {type = "Camera", name = "camera"},
{type = "Texture2D", name = "texture"}, {type = "Texture2D", name = "texture"},
{type = "Rectangle", name = "source"}, {type = "Rectangle", name = "rec"},
{type = "Vector3", name = "position"}, {type = "Vector3", name = "position"},
{type = "Vector2", name = "size"}, {type = "Vector2", name = "size"},
{type = "Color", name = "tint"} {type = "Color", name = "tint"}
@ -7585,12 +7585,12 @@ return {
}, },
{ {
name = "DrawBillboardPro", name = "DrawBillboardPro",
description = "Draw a billboard texture defined by source and rotation", description = "Draw a billboard texture defined by source rectangle with scaling and rotation",
returnType = "void", returnType = "void",
params = { params = {
{type = "Camera", name = "camera"}, {type = "Camera", name = "camera"},
{type = "Texture2D", name = "texture"}, {type = "Texture2D", name = "texture"},
{type = "Rectangle", name = "source"}, {type = "Rectangle", name = "rec"},
{type = "Vector3", name = "position"}, {type = "Vector3", name = "position"},
{type = "Vector3", name = "up"}, {type = "Vector3", name = "up"},
{type = "Vector2", name = "size"}, {type = "Vector2", name = "size"},
@ -7809,7 +7809,7 @@ return {
}, },
{ {
name = "IsMaterialValid", name = "IsMaterialValid",
description = "Check if a material is valid (shader assigned, map textures loaded in GPU)", description = "Check if material is valid (shader assigned, map textures loaded in GPU)",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "Material", name = "material"} {type = "Material", name = "material"}
@ -8055,7 +8055,7 @@ return {
}, },
{ {
name = "IsSoundValid", name = "IsSoundValid",
description = "Check if a sound is valid (data loaded and buffers initialized)", description = "Check if sound is valid (data loaded and buffers initialized)",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "Sound", name = "sound"} {type = "Sound", name = "sound"}
@ -8147,7 +8147,7 @@ return {
}, },
{ {
name = "IsSoundPlaying", name = "IsSoundPlaying",
description = "Check if a sound is currently playing", description = "Check if sound is currently playing",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "Sound", name = "sound"} {type = "Sound", name = "sound"}
@ -8245,7 +8245,7 @@ return {
}, },
{ {
name = "IsMusicValid", name = "IsMusicValid",
description = "Check if a music stream is valid (context and buffers initialized)", description = "Check if music stream is valid (context and buffers initialized)",
returnType = "bool", returnType = "bool",
params = { params = {
{type = "Music", name = "music"} {type = "Music", name = "music"}

100
tools/rlparser/output/raylib_api.txt
View File

@ -1397,7 +1397,7 @@ Function 076: LoadShaderFromMemory() (2 input parameters)
Function 077: IsShaderValid() (1 input parameters) Function 077: IsShaderValid() (1 input parameters)
Name: IsShaderValid Name: IsShaderValid
Return type: bool Return type: bool
Description: Check if a shader is valid (loaded on GPU) Description: Check if shader is valid (loaded on GPU)
Param[1]: shader (type: Shader) Param[1]: shader (type: Shader)
Function 078: GetShaderLocation() (2 input parameters) Function 078: GetShaderLocation() (2 input parameters)
Name: GetShaderLocation Name: GetShaderLocation
@ -1667,37 +1667,37 @@ Function 123: SetSaveFileTextCallback() (1 input parameters)
Function 124: FileRename() (2 input parameters) Function 124: FileRename() (2 input parameters)
Name: FileRename Name: FileRename
Return type: int Return type: int
Description: Rename file (if exists) Description: Rename file (if exists), returns 0 on success
Param[1]: fileName (type: const char *) Param[1]: fileName (type: const char *)
Param[2]: fileRename (type: const char *) Param[2]: fileRename (type: const char *)
Function 125: FileRemove() (1 input parameters) Function 125: FileRemove() (1 input parameters)
Name: FileRemove Name: FileRemove
Return type: int Return type: int
Description: Remove file (if exists) Description: Remove file (if exists), returns 0 on success
Param[1]: fileName (type: const char *) Param[1]: fileName (type: const char *)
Function 126: FileCopy() (2 input parameters) Function 126: FileCopy() (2 input parameters)
Name: FileCopy Name: FileCopy
Return type: int Return type: int
Description: Copy file from one path to another, dstPath created if it doesn't exist Description: Copy file from one path to another, dstPath created if it doesn't exist, returns 0 on success
Param[1]: srcPath (type: const char *) Param[1]: srcPath (type: const char *)
Param[2]: dstPath (type: const char *) Param[2]: dstPath (type: const char *)
Function 127: FileMove() (2 input parameters) Function 127: FileMove() (2 input parameters)
Name: FileMove Name: FileMove
Return type: int Return type: int
Description: Move file from one directory to another, dstPath created if it doesn't exist Description: Move file from one directory to another, dstPath created if it doesn't exist, returns 0 on success
Param[1]: srcPath (type: const char *) Param[1]: srcPath (type: const char *)
Param[2]: dstPath (type: const char *) Param[2]: dstPath (type: const char *)
Function 128: FileTextReplace() (3 input parameters) Function 128: FileTextReplace() (3 input parameters)
Name: FileTextReplace Name: FileTextReplace
Return type: int Return type: int
Description: Replace text in an existing file Description: Replace text in an existing file, returns 0 on success
Param[1]: fileName (type: const char *) Param[1]: fileName (type: const char *)
Param[2]: search (type: const char *) Param[2]: search (type: const char *)
Param[3]: replacement (type: const char *) Param[3]: replacement (type: const char *)
Function 129: FileTextFindIndex() (2 input parameters) Function 129: FileTextFindIndex() (2 input parameters)
Name: FileTextFindIndex Name: FileTextFindIndex
Return type: int Return type: int
Description: Find text in existing file Description: Find text in existing file, returns -1 if index not found or index otherwise
Param[1]: fileName (type: const char *) Param[1]: fileName (type: const char *)
Param[2]: search (type: const char *) Param[2]: search (type: const char *)
Function 130: FileExists() (1 input parameters) Function 130: FileExists() (1 input parameters)
@ -1708,7 +1708,7 @@ Function 130: FileExists() (1 input parameters)
Function 131: DirectoryExists() (1 input parameters) Function 131: DirectoryExists() (1 input parameters)
Name: DirectoryExists Name: DirectoryExists
Return type: bool Return type: bool
Description: Check if a directory path exists Description: Check if directory path exists
Param[1]: dirPath (type: const char *) Param[1]: dirPath (type: const char *)
Function 132: IsFileExtension() (2 input parameters) Function 132: IsFileExtension() (2 input parameters)
Name: IsFileExtension Name: IsFileExtension
@ -1768,13 +1768,13 @@ Function 142: MakeDirectory() (1 input parameters)
Param[1]: dirPath (type: const char *) Param[1]: dirPath (type: const char *)
Function 143: ChangeDirectory() (1 input parameters) Function 143: ChangeDirectory() (1 input parameters)
Name: ChangeDirectory Name: ChangeDirectory
Return type: bool Return type: int
Description: Change working directory, return true on success Description: Change working directory, returns 0 on success
Param[1]: dirPath (type: const char *) Param[1]: dirPath (type: const char *)
Function 144: IsPathFile() (1 input parameters) Function 144: IsPathFile() (1 input parameters)
Name: IsPathFile Name: IsPathFile
Return type: bool Return type: bool
Description: Check if a given path is a file or a directory Description: Check if given path is a file or a directory
Param[1]: path (type: const char *) Param[1]: path (type: const char *)
Function 145: IsFileNameValid() (1 input parameters) Function 145: IsFileNameValid() (1 input parameters)
Name: IsFileNameValid Name: IsFileNameValid
@ -1789,7 +1789,7 @@ Function 146: LoadDirectoryFiles() (1 input parameters)
Function 147: LoadDirectoryFilesEx() (3 input parameters) Function 147: LoadDirectoryFilesEx() (3 input parameters)
Name: LoadDirectoryFilesEx Name: LoadDirectoryFilesEx
Return type: FilePathList Return type: FilePathList
Description: Load directory filepaths with extension filtering and subdir scan; some filters available: `*.*`,`FILES*`,`DIRS*` Description: Load directory filepaths with extension filtering and subdir scan; some filters available: '*.*','FILES*','DIRS*'
Param[1]: basePath (type: const char *) Param[1]: basePath (type: const char *)
Param[2]: filter (type: const char *) Param[2]: filter (type: const char *)
Param[3]: scanSubdirs (type: bool) Param[3]: scanSubdirs (type: bool)
@ -1801,7 +1801,7 @@ Function 148: UnloadDirectoryFiles() (1 input parameters)
Function 149: IsFileDropped() (0 input parameters) Function 149: IsFileDropped() (0 input parameters)
Name: IsFileDropped Name: IsFileDropped
Return type: bool Return type: bool
Description: Check if a file has been dropped into window Description: Check if file has been dropped into window
No input parameters No input parameters
Function 150: LoadDroppedFiles() (0 input parameters) Function 150: LoadDroppedFiles() (0 input parameters)
Name: LoadDroppedFiles Name: LoadDroppedFiles
@ -1920,27 +1920,27 @@ Function 169: PlayAutomationEvent() (1 input parameters)
Function 170: IsKeyPressed() (1 input parameters) Function 170: IsKeyPressed() (1 input parameters)
Name: IsKeyPressed Name: IsKeyPressed
Return type: bool Return type: bool
Description: Check if a key has been pressed once Description: Check if key has been pressed once
Param[1]: key (type: int) Param[1]: key (type: int)
Function 171: IsKeyPressedRepeat() (1 input parameters) Function 171: IsKeyPressedRepeat() (1 input parameters)
Name: IsKeyPressedRepeat Name: IsKeyPressedRepeat
Return type: bool Return type: bool
Description: Check if a key has been pressed again Description: Check if key has been pressed again
Param[1]: key (type: int) Param[1]: key (type: int)
Function 172: IsKeyDown() (1 input parameters) Function 172: IsKeyDown() (1 input parameters)
Name: IsKeyDown Name: IsKeyDown
Return type: bool Return type: bool
Description: Check if a key is being pressed Description: Check if key is being pressed
Param[1]: key (type: int) Param[1]: key (type: int)
Function 173: IsKeyReleased() (1 input parameters) Function 173: IsKeyReleased() (1 input parameters)
Name: IsKeyReleased Name: IsKeyReleased
Return type: bool Return type: bool
Description: Check if a key has been released once Description: Check if key has been released once
Param[1]: key (type: int) Param[1]: key (type: int)
Function 174: IsKeyUp() (1 input parameters) Function 174: IsKeyUp() (1 input parameters)
Name: IsKeyUp Name: IsKeyUp
Return type: bool Return type: bool
Description: Check if a key is NOT being pressed Description: Check if key is NOT being pressed
Param[1]: key (type: int) Param[1]: key (type: int)
Function 175: GetKeyPressed() (0 input parameters) Function 175: GetKeyPressed() (0 input parameters)
Name: GetKeyPressed Name: GetKeyPressed
@ -1965,7 +1965,7 @@ Function 178: SetExitKey() (1 input parameters)
Function 179: IsGamepadAvailable() (1 input parameters) Function 179: IsGamepadAvailable() (1 input parameters)
Name: IsGamepadAvailable Name: IsGamepadAvailable
Return type: bool Return type: bool
Description: Check if a gamepad is available Description: Check if gamepad is available
Param[1]: gamepad (type: int) Param[1]: gamepad (type: int)
Function 180: GetGamepadName() (1 input parameters) Function 180: GetGamepadName() (1 input parameters)
Name: GetGamepadName Name: GetGamepadName
@ -1975,25 +1975,25 @@ Function 180: GetGamepadName() (1 input parameters)
Function 181: IsGamepadButtonPressed() (2 input parameters) Function 181: IsGamepadButtonPressed() (2 input parameters)
Name: IsGamepadButtonPressed Name: IsGamepadButtonPressed
Return type: bool Return type: bool
Description: Check if a gamepad button has been pressed once Description: Check if gamepad button has been pressed once
Param[1]: gamepad (type: int) Param[1]: gamepad (type: int)
Param[2]: button (type: int) Param[2]: button (type: int)
Function 182: IsGamepadButtonDown() (2 input parameters) Function 182: IsGamepadButtonDown() (2 input parameters)
Name: IsGamepadButtonDown Name: IsGamepadButtonDown
Return type: bool Return type: bool
Description: Check if a gamepad button is being pressed Description: Check if gamepad button is being pressed
Param[1]: gamepad (type: int) Param[1]: gamepad (type: int)
Param[2]: button (type: int) Param[2]: button (type: int)
Function 183: IsGamepadButtonReleased() (2 input parameters) Function 183: IsGamepadButtonReleased() (2 input parameters)
Name: IsGamepadButtonReleased Name: IsGamepadButtonReleased
Return type: bool Return type: bool
Description: Check if a gamepad button has been released once Description: Check if gamepad button has been released once
Param[1]: gamepad (type: int) Param[1]: gamepad (type: int)
Param[2]: button (type: int) Param[2]: button (type: int)
Function 184: IsGamepadButtonUp() (2 input parameters) Function 184: IsGamepadButtonUp() (2 input parameters)
Name: IsGamepadButtonUp Name: IsGamepadButtonUp
Return type: bool Return type: bool
Description: Check if a gamepad button is NOT being pressed Description: Check if gamepad button is NOT being pressed
Param[1]: gamepad (type: int) Param[1]: gamepad (type: int)
Param[2]: button (type: int) Param[2]: button (type: int)
Function 185: GetGamepadButtonPressed() (0 input parameters) Function 185: GetGamepadButtonPressed() (0 input parameters)
@ -2028,22 +2028,22 @@ Function 189: SetGamepadVibration() (4 input parameters)
Function 190: IsMouseButtonPressed() (1 input parameters) Function 190: IsMouseButtonPressed() (1 input parameters)
Name: IsMouseButtonPressed Name: IsMouseButtonPressed
Return type: bool Return type: bool
Description: Check if a mouse button has been pressed once Description: Check if mouse button has been pressed once
Param[1]: button (type: int) Param[1]: button (type: int)
Function 191: IsMouseButtonDown() (1 input parameters) Function 191: IsMouseButtonDown() (1 input parameters)
Name: IsMouseButtonDown Name: IsMouseButtonDown
Return type: bool Return type: bool
Description: Check if a mouse button is being pressed Description: Check if mouse button is being pressed
Param[1]: button (type: int) Param[1]: button (type: int)
Function 192: IsMouseButtonReleased() (1 input parameters) Function 192: IsMouseButtonReleased() (1 input parameters)
Name: IsMouseButtonReleased Name: IsMouseButtonReleased
Return type: bool Return type: bool
Description: Check if a mouse button has been released once Description: Check if mouse button has been released once
Param[1]: button (type: int) Param[1]: button (type: int)
Function 193: IsMouseButtonUp() (1 input parameters) Function 193: IsMouseButtonUp() (1 input parameters)
Name: IsMouseButtonUp Name: IsMouseButtonUp
Return type: bool Return type: bool
Description: Check if a mouse button is NOT being pressed Description: Check if mouse button is NOT being pressed
Param[1]: button (type: int) Param[1]: button (type: int)
Function 194: GetMouseX() (0 input parameters) Function 194: GetMouseX() (0 input parameters)
Name: GetMouseX Name: GetMouseX
@ -2131,7 +2131,7 @@ Function 209: SetGesturesEnabled() (1 input parameters)
Function 210: IsGestureDetected() (1 input parameters) Function 210: IsGestureDetected() (1 input parameters)
Name: IsGestureDetected Name: IsGestureDetected
Return type: bool Return type: bool
Description: Check if a gesture has been detected Description: Check if gesture has been detected
Param[1]: gesture (type: unsigned int) Param[1]: gesture (type: unsigned int)
Function 211: GetGestureDetected() (0 input parameters) Function 211: GetGestureDetected() (0 input parameters)
Name: GetGestureDetected Name: GetGestureDetected
@ -2182,7 +2182,7 @@ Function 219: SetShapesTexture() (2 input parameters)
Return type: void Return type: void
Description: Set texture and rectangle to be used on shapes drawing Description: Set texture and rectangle to be used on shapes drawing
Param[1]: texture (type: Texture2D) Param[1]: texture (type: Texture2D)
Param[2]: source (type: Rectangle) Param[2]: rec (type: Rectangle)
Function 220: GetShapesTexture() (0 input parameters) Function 220: GetShapesTexture() (0 input parameters)
Name: GetShapesTexture Name: GetShapesTexture
Return type: Texture2D Return type: Texture2D
@ -3340,7 +3340,7 @@ Function 372: LoadRenderTexture() (2 input parameters)
Function 373: IsTextureValid() (1 input parameters) Function 373: IsTextureValid() (1 input parameters)
Name: IsTextureValid Name: IsTextureValid
Return type: bool Return type: bool
Description: Check if a texture is valid (loaded in GPU) Description: Check if texture is valid (loaded in GPU)
Param[1]: texture (type: Texture2D) Param[1]: texture (type: Texture2D)
Function 374: UnloadTexture() (1 input parameters) Function 374: UnloadTexture() (1 input parameters)
Name: UnloadTexture Name: UnloadTexture
@ -3350,7 +3350,7 @@ Function 374: UnloadTexture() (1 input parameters)
Function 375: IsRenderTextureValid() (1 input parameters) Function 375: IsRenderTextureValid() (1 input parameters)
Name: IsRenderTextureValid Name: IsRenderTextureValid
Return type: bool Return type: bool
Description: Check if a render texture is valid (loaded in GPU) Description: Check if render texture is valid (loaded in GPU)
Param[1]: target (type: RenderTexture2D) Param[1]: target (type: RenderTexture2D)
Function 376: UnloadRenderTexture() (1 input parameters) Function 376: UnloadRenderTexture() (1 input parameters)
Name: UnloadRenderTexture Name: UnloadRenderTexture
@ -3416,16 +3416,16 @@ Function 385: DrawTextureRec() (4 input parameters)
Return type: void Return type: void
Description: Draw a part of a texture defined by a rectangle Description: Draw a part of a texture defined by a rectangle
Param[1]: texture (type: Texture2D) Param[1]: texture (type: Texture2D)
Param[2]: source (type: Rectangle) Param[2]: rec (type: Rectangle)
Param[3]: position (type: Vector2) Param[3]: position (type: Vector2)
Param[4]: tint (type: Color) Param[4]: tint (type: Color)
Function 386: DrawTexturePro() (6 input parameters) Function 386: DrawTexturePro() (6 input parameters)
Name: DrawTexturePro Name: DrawTexturePro
Return type: void Return type: void
Description: Draw a part of a texture defined by a rectangle with 'pro' parameters Description: Draw a part of a texture defined by a source rectangle to destination rectangle, with scaling and rotation
Param[1]: texture (type: Texture2D) Param[1]: texture (type: Texture2D)
Param[2]: source (type: Rectangle) Param[2]: srcrec (type: Rectangle)
Param[3]: dest (type: Rectangle) Param[3]: dstrec (type: Rectangle)
Param[4]: origin (type: Vector2) Param[4]: origin (type: Vector2)
Param[5]: rotation (type: float) Param[5]: rotation (type: float)
Param[6]: tint (type: Color) Param[6]: tint (type: Color)
@ -3435,7 +3435,7 @@ Function 387: DrawTextureNPatch() (6 input parameters)
Description: Draw a texture (or part of it) that stretches or shrinks nicely Description: Draw a texture (or part of it) that stretches or shrinks nicely
Param[1]: texture (type: Texture2D) Param[1]: texture (type: Texture2D)
Param[2]: nPatchInfo (type: NPatchInfo) Param[2]: nPatchInfo (type: NPatchInfo)
Param[3]: dest (type: Rectangle) Param[3]: dstrec (type: Rectangle)
Param[4]: origin (type: Vector2) Param[4]: origin (type: Vector2)
Param[5]: rotation (type: float) Param[5]: rotation (type: float)
Param[6]: tint (type: Color) Param[6]: tint (type: Color)
@ -3525,7 +3525,7 @@ Function 402: GetPixelColor() (2 input parameters)
Name: GetPixelColor Name: GetPixelColor
Return type: Color Return type: Color
Description: Get Color from a source pixel pointer of certain format Description: Get Color from a source pixel pointer of certain format
Param[1]: srcPtr (type: void *) Param[1]: srcPtr (type: const void *)
Param[2]: format (type: int) Param[2]: format (type: int)
Function 403: SetPixelColor() (3 input parameters) Function 403: SetPixelColor() (3 input parameters)
Name: SetPixelColor Name: SetPixelColor
@ -3579,7 +3579,7 @@ Function 409: LoadFontFromMemory() (6 input parameters)
Function 410: IsFontValid() (1 input parameters) Function 410: IsFontValid() (1 input parameters)
Name: IsFontValid Name: IsFontValid
Return type: bool Return type: bool
Description: Check if a font is valid (font data loaded, WARNING: GPU texture not checked) Description: Check if font is valid (font data loaded, WARNING: GPU texture not checked)
Param[1]: font (type: Font) Param[1]: font (type: Font)
Function 411: LoadFontData() (7 input parameters) Function 411: LoadFontData() (7 input parameters)
Name: LoadFontData Name: LoadFontData
@ -4035,7 +4035,7 @@ Function 476: DrawCylinder() (6 input parameters)
Param[2]: radiusTop (type: float) Param[2]: radiusTop (type: float)
Param[3]: radiusBottom (type: float) Param[3]: radiusBottom (type: float)
Param[4]: height (type: float) Param[4]: height (type: float)
Param[5]: slices (type: int) Param[5]: sides (type: int)
Param[6]: color (type: Color) Param[6]: color (type: Color)
Function 477: DrawCylinderEx() (6 input parameters) Function 477: DrawCylinderEx() (6 input parameters)
Name: DrawCylinderEx Name: DrawCylinderEx
@ -4055,7 +4055,7 @@ Function 478: DrawCylinderWires() (6 input parameters)
Param[2]: radiusTop (type: float) Param[2]: radiusTop (type: float)
Param[3]: radiusBottom (type: float) Param[3]: radiusBottom (type: float)
Param[4]: height (type: float) Param[4]: height (type: float)
Param[5]: slices (type: int) Param[5]: sides (type: int)
Param[6]: color (type: Color) Param[6]: color (type: Color)
Function 479: DrawCylinderWiresEx() (6 input parameters) Function 479: DrawCylinderWiresEx() (6 input parameters)
Name: DrawCylinderWiresEx Name: DrawCylinderWiresEx
@ -4065,7 +4065,7 @@ Function 479: DrawCylinderWiresEx() (6 input parameters)
Param[2]: endPos (type: Vector3) Param[2]: endPos (type: Vector3)
Param[3]: startRadius (type: float) Param[3]: startRadius (type: float)
Param[4]: endRadius (type: float) Param[4]: endRadius (type: float)
Param[5]: slices (type: int) Param[5]: sides (type: int)
Param[6]: color (type: Color) Param[6]: color (type: Color)
Function 480: DrawCapsule() (6 input parameters) Function 480: DrawCapsule() (6 input parameters)
Name: DrawCapsule Name: DrawCapsule
@ -4119,7 +4119,7 @@ Function 486: LoadModelFromMesh() (1 input parameters)
Function 487: IsModelValid() (1 input parameters) Function 487: IsModelValid() (1 input parameters)
Name: IsModelValid Name: IsModelValid
Return type: bool Return type: bool
Description: Check if a model is valid (loaded in GPU, VAO/VBOs) Description: Check if model is valid (loaded in GPU, VAO/VBOs)
Param[1]: model (type: Model) Param[1]: model (type: Model)
Function 488: UnloadModel() (1 input parameters) Function 488: UnloadModel() (1 input parameters)
Name: UnloadModel Name: UnloadModel
@ -4185,20 +4185,20 @@ Function 495: DrawBillboard() (5 input parameters)
Function 496: DrawBillboardRec() (6 input parameters) Function 496: DrawBillboardRec() (6 input parameters)
Name: DrawBillboardRec Name: DrawBillboardRec
Return type: void Return type: void
Description: Draw a billboard texture defined by source Description: Draw a billboard texture defined by rectangle
Param[1]: camera (type: Camera) Param[1]: camera (type: Camera)
Param[2]: texture (type: Texture2D) Param[2]: texture (type: Texture2D)
Param[3]: source (type: Rectangle) Param[3]: rec (type: Rectangle)
Param[4]: position (type: Vector3) Param[4]: position (type: Vector3)
Param[5]: size (type: Vector2) Param[5]: size (type: Vector2)
Param[6]: tint (type: Color) Param[6]: tint (type: Color)
Function 497: DrawBillboardPro() (9 input parameters) Function 497: DrawBillboardPro() (9 input parameters)
Name: DrawBillboardPro Name: DrawBillboardPro
Return type: void Return type: void
Description: Draw a billboard texture defined by source and rotation Description: Draw a billboard texture defined by source rectangle with scaling and rotation
Param[1]: camera (type: Camera) Param[1]: camera (type: Camera)
Param[2]: texture (type: Texture2D) Param[2]: texture (type: Texture2D)
Param[3]: source (type: Rectangle) Param[3]: rec (type: Rectangle)
Param[4]: position (type: Vector3) Param[4]: position (type: Vector3)
Param[5]: up (type: Vector3) Param[5]: up (type: Vector3)
Param[6]: size (type: Vector2) Param[6]: size (type: Vector2)
@ -4353,7 +4353,7 @@ Function 519: LoadMaterialDefault() (0 input parameters)
Function 520: IsMaterialValid() (1 input parameters) Function 520: IsMaterialValid() (1 input parameters)
Name: IsMaterialValid Name: IsMaterialValid
Return type: bool Return type: bool
Description: Check if a material is valid (shader assigned, map textures loaded in GPU) Description: Check if material is valid (shader assigned, map textures loaded in GPU)
Param[1]: material (type: Material) Param[1]: material (type: Material)
Function 521: UnloadMaterial() (1 input parameters) Function 521: UnloadMaterial() (1 input parameters)
Name: UnloadMaterial Name: UnloadMaterial
@ -4527,7 +4527,7 @@ Function 547: LoadSoundAlias() (1 input parameters)
Function 548: IsSoundValid() (1 input parameters) Function 548: IsSoundValid() (1 input parameters)
Name: IsSoundValid Name: IsSoundValid
Return type: bool Return type: bool
Description: Check if a sound is valid (data loaded and buffers initialized) Description: Check if sound is valid (data loaded and buffers initialized)
Param[1]: sound (type: Sound) Param[1]: sound (type: Sound)
Function 549: UpdateSound() (3 input parameters) Function 549: UpdateSound() (3 input parameters)
Name: UpdateSound Name: UpdateSound
@ -4586,7 +4586,7 @@ Function 558: ResumeSound() (1 input parameters)
Function 559: IsSoundPlaying() (1 input parameters) Function 559: IsSoundPlaying() (1 input parameters)
Name: IsSoundPlaying Name: IsSoundPlaying
Return type: bool Return type: bool
Description: Check if a sound is currently playing Description: Check if sound is currently playing
Param[1]: sound (type: Sound) Param[1]: sound (type: Sound)
Function 560: SetSoundVolume() (2 input parameters) Function 560: SetSoundVolume() (2 input parameters)
Name: SetSoundVolume Name: SetSoundVolume
@ -4651,7 +4651,7 @@ Function 569: LoadMusicStreamFromMemory() (3 input parameters)
Function 570: IsMusicValid() (1 input parameters) Function 570: IsMusicValid() (1 input parameters)
Name: IsMusicValid Name: IsMusicValid
Return type: bool Return type: bool
Description: Check if a music stream is valid (context and buffers initialized) Description: Check if music stream is valid (context and buffers initialized)
Param[1]: music (type: Music) Param[1]: music (type: Music)
Function 571: UnloadMusicStream() (1 input parameters) Function 571: UnloadMusicStream() (1 input parameters)
Name: UnloadMusicStream Name: UnloadMusicStream

98
tools/rlparser/output/raylib_api.xml
View File

@ -880,7 +880,7 @@
<Param type="const char *" name="vsCode" desc="" /> <Param type="const char *" name="vsCode" desc="" />
<Param type="const char *" name="fsCode" desc="" /> <Param type="const char *" name="fsCode" desc="" />
</Function> </Function>
<Function name="IsShaderValid" retType="bool" paramCount="1" desc="Check if a shader is valid (loaded on GPU)"> <Function name="IsShaderValid" retType="bool" paramCount="1" desc="Check if shader is valid (loaded on GPU)">
<Param type="Shader" name="shader" desc="" /> <Param type="Shader" name="shader" desc="" />
</Function> </Function>
<Function name="GetShaderLocation" retType="int" paramCount="2" desc="Get shader uniform location"> <Function name="GetShaderLocation" retType="int" paramCount="2" desc="Get shader uniform location">
@ -1051,34 +1051,34 @@
<Function name="SetSaveFileTextCallback" retType="void" paramCount="1" desc="Set custom file text data saver"> <Function name="SetSaveFileTextCallback" retType="void" paramCount="1" desc="Set custom file text data saver">
<Param type="SaveFileTextCallback" name="callback" desc="" /> <Param type="SaveFileTextCallback" name="callback" desc="" />
</Function> </Function>
<Function name="FileRename" retType="int" paramCount="2" desc="Rename file (if exists)"> <Function name="FileRename" retType="int" paramCount="2" desc="Rename file (if exists), returns 0 on success">
<Param type="const char *" name="fileName" desc="" /> <Param type="const char *" name="fileName" desc="" />
<Param type="const char *" name="fileRename" desc="" /> <Param type="const char *" name="fileRename" desc="" />
</Function> </Function>
<Function name="FileRemove" retType="int" paramCount="1" desc="Remove file (if exists)"> <Function name="FileRemove" retType="int" paramCount="1" desc="Remove file (if exists), returns 0 on success">
<Param type="const char *" name="fileName" desc="" /> <Param type="const char *" name="fileName" desc="" />
</Function> </Function>
<Function name="FileCopy" retType="int" paramCount="2" desc="Copy file from one path to another, dstPath created if it doesn't exist"> <Function name="FileCopy" retType="int" paramCount="2" desc="Copy file from one path to another, dstPath created if it doesn't exist, returns 0 on success">
<Param type="const char *" name="srcPath" desc="" /> <Param type="const char *" name="srcPath" desc="" />
<Param type="const char *" name="dstPath" desc="" /> <Param type="const char *" name="dstPath" desc="" />
</Function> </Function>
<Function name="FileMove" retType="int" paramCount="2" desc="Move file from one directory to another, dstPath created if it doesn't exist"> <Function name="FileMove" retType="int" paramCount="2" desc="Move file from one directory to another, dstPath created if it doesn't exist, returns 0 on success">
<Param type="const char *" name="srcPath" desc="" /> <Param type="const char *" name="srcPath" desc="" />
<Param type="const char *" name="dstPath" desc="" /> <Param type="const char *" name="dstPath" desc="" />
</Function> </Function>
<Function name="FileTextReplace" retType="int" paramCount="3" desc="Replace text in an existing file"> <Function name="FileTextReplace" retType="int" paramCount="3" desc="Replace text in an existing file, returns 0 on success">
<Param type="const char *" name="fileName" desc="" /> <Param type="const char *" name="fileName" desc="" />
<Param type="const char *" name="search" desc="" /> <Param type="const char *" name="search" desc="" />
<Param type="const char *" name="replacement" desc="" /> <Param type="const char *" name="replacement" desc="" />
</Function> </Function>
<Function name="FileTextFindIndex" retType="int" paramCount="2" desc="Find text in existing file"> <Function name="FileTextFindIndex" retType="int" paramCount="2" desc="Find text in existing file, returns -1 if index not found or index otherwise">
<Param type="const char *" name="fileName" desc="" /> <Param type="const char *" name="fileName" desc="" />
<Param type="const char *" name="search" desc="" /> <Param type="const char *" name="search" desc="" />
</Function> </Function>
<Function name="FileExists" retType="bool" paramCount="1" desc="Check if file exists"> <Function name="FileExists" retType="bool" paramCount="1" desc="Check if file exists">
<Param type="const char *" name="fileName" desc="" /> <Param type="const char *" name="fileName" desc="" />
</Function> </Function>
<Function name="DirectoryExists" retType="bool" paramCount="1" desc="Check if a directory path exists"> <Function name="DirectoryExists" retType="bool" paramCount="1" desc="Check if directory path exists">
<Param type="const char *" name="dirPath" desc="" /> <Param type="const char *" name="dirPath" desc="" />
</Function> </Function>
<Function name="IsFileExtension" retType="bool" paramCount="2" desc="Check file extension (recommended include point: .png, .wav)"> <Function name="IsFileExtension" retType="bool" paramCount="2" desc="Check file extension (recommended include point: .png, .wav)">
@ -1113,10 +1113,10 @@
<Function name="MakeDirectory" retType="int" paramCount="1" desc="Create directories (including full path requested), returns 0 on success"> <Function name="MakeDirectory" retType="int" paramCount="1" desc="Create directories (including full path requested), returns 0 on success">
<Param type="const char *" name="dirPath" desc="" /> <Param type="const char *" name="dirPath" desc="" />
</Function> </Function>
<Function name="ChangeDirectory" retType="bool" paramCount="1" desc="Change working directory, return true on success"> <Function name="ChangeDirectory" retType="int" paramCount="1" desc="Change working directory, returns 0 on success">
<Param type="const char *" name="dirPath" desc="" /> <Param type="const char *" name="dirPath" desc="" />
</Function> </Function>
<Function name="IsPathFile" retType="bool" paramCount="1" desc="Check if a given path is a file or a directory"> <Function name="IsPathFile" retType="bool" paramCount="1" desc="Check if given path is a file or a directory">
<Param type="const char *" name="path" desc="" /> <Param type="const char *" name="path" desc="" />
</Function> </Function>
<Function name="IsFileNameValid" retType="bool" paramCount="1" desc="Check if fileName is valid for the platform/OS"> <Function name="IsFileNameValid" retType="bool" paramCount="1" desc="Check if fileName is valid for the platform/OS">
@ -1125,7 +1125,7 @@
<Function name="LoadDirectoryFiles" retType="FilePathList" paramCount="1" desc="Load directory filepaths, files and directories, no subdirs scan"> <Function name="LoadDirectoryFiles" retType="FilePathList" paramCount="1" desc="Load directory filepaths, files and directories, no subdirs scan">
<Param type="const char *" name="dirPath" desc="" /> <Param type="const char *" name="dirPath" desc="" />
</Function> </Function>
<Function name="LoadDirectoryFilesEx" retType="FilePathList" paramCount="3" desc="Load directory filepaths with extension filtering and subdir scan; some filters available: `*.*`,`FILES*`,`DIRS*`"> <Function name="LoadDirectoryFilesEx" retType="FilePathList" paramCount="3" desc="Load directory filepaths with extension filtering and subdir scan; some filters available: '*.*','FILES*','DIRS*'">
<Param type="const char *" name="basePath" desc="" /> <Param type="const char *" name="basePath" desc="" />
<Param type="const char *" name="filter" desc="" /> <Param type="const char *" name="filter" desc="" />
<Param type="bool" name="scanSubdirs" desc="" /> <Param type="bool" name="scanSubdirs" desc="" />
@ -1133,7 +1133,7 @@
<Function name="UnloadDirectoryFiles" retType="void" paramCount="1" desc="Unload filepaths"> <Function name="UnloadDirectoryFiles" retType="void" paramCount="1" desc="Unload filepaths">
<Param type="FilePathList" name="files" desc="" /> <Param type="FilePathList" name="files" desc="" />
</Function> </Function>
<Function name="IsFileDropped" retType="bool" paramCount="0" desc="Check if a file has been dropped into window"> <Function name="IsFileDropped" retType="bool" paramCount="0" desc="Check if file has been dropped into window">
</Function> </Function>
<Function name="LoadDroppedFiles" retType="FilePathList" paramCount="0" desc="Load dropped filepaths"> <Function name="LoadDroppedFiles" retType="FilePathList" paramCount="0" desc="Load dropped filepaths">
</Function> </Function>
@ -1206,19 +1206,19 @@
<Function name="PlayAutomationEvent" retType="void" paramCount="1" desc="Play a recorded automation event"> <Function name="PlayAutomationEvent" retType="void" paramCount="1" desc="Play a recorded automation event">
<Param type="AutomationEvent" name="event" desc="" /> <Param type="AutomationEvent" name="event" desc="" />
</Function> </Function>
<Function name="IsKeyPressed" retType="bool" paramCount="1" desc="Check if a key has been pressed once"> <Function name="IsKeyPressed" retType="bool" paramCount="1" desc="Check if key has been pressed once">
<Param type="int" name="key" desc="" /> <Param type="int" name="key" desc="" />
</Function> </Function>
<Function name="IsKeyPressedRepeat" retType="bool" paramCount="1" desc="Check if a key has been pressed again"> <Function name="IsKeyPressedRepeat" retType="bool" paramCount="1" desc="Check if key has been pressed again">
<Param type="int" name="key" desc="" /> <Param type="int" name="key" desc="" />
</Function> </Function>
<Function name="IsKeyDown" retType="bool" paramCount="1" desc="Check if a key is being pressed"> <Function name="IsKeyDown" retType="bool" paramCount="1" desc="Check if key is being pressed">
<Param type="int" name="key" desc="" /> <Param type="int" name="key" desc="" />
</Function> </Function>
<Function name="IsKeyReleased" retType="bool" paramCount="1" desc="Check if a key has been released once"> <Function name="IsKeyReleased" retType="bool" paramCount="1" desc="Check if key has been released once">
<Param type="int" name="key" desc="" /> <Param type="int" name="key" desc="" />
</Function> </Function>
<Function name="IsKeyUp" retType="bool" paramCount="1" desc="Check if a key is NOT being pressed"> <Function name="IsKeyUp" retType="bool" paramCount="1" desc="Check if key is NOT being pressed">
<Param type="int" name="key" desc="" /> <Param type="int" name="key" desc="" />
</Function> </Function>
<Function name="GetKeyPressed" retType="int" paramCount="0" desc="Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty"> <Function name="GetKeyPressed" retType="int" paramCount="0" desc="Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty">
@ -1231,25 +1231,25 @@
<Function name="SetExitKey" retType="void" paramCount="1" desc="Set a custom key to exit program (default is ESC)"> <Function name="SetExitKey" retType="void" paramCount="1" desc="Set a custom key to exit program (default is ESC)">
<Param type="int" name="key" desc="" /> <Param type="int" name="key" desc="" />
</Function> </Function>
<Function name="IsGamepadAvailable" retType="bool" paramCount="1" desc="Check if a gamepad is available"> <Function name="IsGamepadAvailable" retType="bool" paramCount="1" desc="Check if gamepad is available">
<Param type="int" name="gamepad" desc="" /> <Param type="int" name="gamepad" desc="" />
</Function> </Function>
<Function name="GetGamepadName" retType="const char *" paramCount="1" desc="Get gamepad internal name id"> <Function name="GetGamepadName" retType="const char *" paramCount="1" desc="Get gamepad internal name id">
<Param type="int" name="gamepad" desc="" /> <Param type="int" name="gamepad" desc="" />
</Function> </Function>
<Function name="IsGamepadButtonPressed" retType="bool" paramCount="2" desc="Check if a gamepad button has been pressed once"> <Function name="IsGamepadButtonPressed" retType="bool" paramCount="2" desc="Check if gamepad button has been pressed once">
<Param type="int" name="gamepad" desc="" /> <Param type="int" name="gamepad" desc="" />
<Param type="int" name="button" desc="" /> <Param type="int" name="button" desc="" />
</Function> </Function>
<Function name="IsGamepadButtonDown" retType="bool" paramCount="2" desc="Check if a gamepad button is being pressed"> <Function name="IsGamepadButtonDown" retType="bool" paramCount="2" desc="Check if gamepad button is being pressed">
<Param type="int" name="gamepad" desc="" /> <Param type="int" name="gamepad" desc="" />
<Param type="int" name="button" desc="" /> <Param type="int" name="button" desc="" />
</Function> </Function>
<Function name="IsGamepadButtonReleased" retType="bool" paramCount="2" desc="Check if a gamepad button has been released once"> <Function name="IsGamepadButtonReleased" retType="bool" paramCount="2" desc="Check if gamepad button has been released once">
<Param type="int" name="gamepad" desc="" /> <Param type="int" name="gamepad" desc="" />
<Param type="int" name="button" desc="" /> <Param type="int" name="button" desc="" />
</Function> </Function>
<Function name="IsGamepadButtonUp" retType="bool" paramCount="2" desc="Check if a gamepad button is NOT being pressed"> <Function name="IsGamepadButtonUp" retType="bool" paramCount="2" desc="Check if gamepad button is NOT being pressed">
<Param type="int" name="gamepad" desc="" /> <Param type="int" name="gamepad" desc="" />
<Param type="int" name="button" desc="" /> <Param type="int" name="button" desc="" />
</Function> </Function>
@ -1271,16 +1271,16 @@
<Param type="float" name="rightMotor" desc="" /> <Param type="float" name="rightMotor" desc="" />
<Param type="float" name="duration" desc="" /> <Param type="float" name="duration" desc="" />
</Function> </Function>
<Function name="IsMouseButtonPressed" retType="bool" paramCount="1" desc="Check if a mouse button has been pressed once"> <Function name="IsMouseButtonPressed" retType="bool" paramCount="1" desc="Check if mouse button has been pressed once">
<Param type="int" name="button" desc="" /> <Param type="int" name="button" desc="" />
</Function> </Function>
<Function name="IsMouseButtonDown" retType="bool" paramCount="1" desc="Check if a mouse button is being pressed"> <Function name="IsMouseButtonDown" retType="bool" paramCount="1" desc="Check if mouse button is being pressed">
<Param type="int" name="button" desc="" /> <Param type="int" name="button" desc="" />
</Function> </Function>
<Function name="IsMouseButtonReleased" retType="bool" paramCount="1" desc="Check if a mouse button has been released once"> <Function name="IsMouseButtonReleased" retType="bool" paramCount="1" desc="Check if mouse button has been released once">
<Param type="int" name="button" desc="" /> <Param type="int" name="button" desc="" />
</Function> </Function>
<Function name="IsMouseButtonUp" retType="bool" paramCount="1" desc="Check if a mouse button is NOT being pressed"> <Function name="IsMouseButtonUp" retType="bool" paramCount="1" desc="Check if mouse button is NOT being pressed">
<Param type="int" name="button" desc="" /> <Param type="int" name="button" desc="" />
</Function> </Function>
<Function name="GetMouseX" retType="int" paramCount="0" desc="Get mouse position X"> <Function name="GetMouseX" retType="int" paramCount="0" desc="Get mouse position X">
@ -1325,7 +1325,7 @@
<Function name="SetGesturesEnabled" retType="void" paramCount="1" desc="Enable a set of gestures using flags"> <Function name="SetGesturesEnabled" retType="void" paramCount="1" desc="Enable a set of gestures using flags">
<Param type="unsigned int" name="flags" desc="" /> <Param type="unsigned int" name="flags" desc="" />
</Function> </Function>
<Function name="IsGestureDetected" retType="bool" paramCount="1" desc="Check if a gesture has been detected"> <Function name="IsGestureDetected" retType="bool" paramCount="1" desc="Check if gesture has been detected">
<Param type="unsigned int" name="gesture" desc="" /> <Param type="unsigned int" name="gesture" desc="" />
</Function> </Function>
<Function name="GetGestureDetected" retType="int" paramCount="0" desc="Get latest detected gesture"> <Function name="GetGestureDetected" retType="int" paramCount="0" desc="Get latest detected gesture">
@ -1352,7 +1352,7 @@
</Function> </Function>
<Function name="SetShapesTexture" retType="void" paramCount="2" desc="Set texture and rectangle to be used on shapes drawing"> <Function name="SetShapesTexture" retType="void" paramCount="2" desc="Set texture and rectangle to be used on shapes drawing">
<Param type="Texture2D" name="texture" desc="" /> <Param type="Texture2D" name="texture" desc="" />
<Param type="Rectangle" name="source" desc="" /> <Param type="Rectangle" name="rec" desc="" />
</Function> </Function>
<Function name="GetShapesTexture" retType="Texture2D" paramCount="0" desc="Get texture that is used for shapes drawing"> <Function name="GetShapesTexture" retType="Texture2D" paramCount="0" desc="Get texture that is used for shapes drawing">
</Function> </Function>
@ -2199,13 +2199,13 @@
<Param type="int" name="width" desc="" /> <Param type="int" name="width" desc="" />
<Param type="int" name="height" desc="" /> <Param type="int" name="height" desc="" />
</Function> </Function>
<Function name="IsTextureValid" retType="bool" paramCount="1" desc="Check if a texture is valid (loaded in GPU)"> <Function name="IsTextureValid" retType="bool" paramCount="1" desc="Check if texture is valid (loaded in GPU)">
<Param type="Texture2D" name="texture" desc="" /> <Param type="Texture2D" name="texture" desc="" />
</Function> </Function>
<Function name="UnloadTexture" retType="void" paramCount="1" desc="Unload texture from GPU memory (VRAM)"> <Function name="UnloadTexture" retType="void" paramCount="1" desc="Unload texture from GPU memory (VRAM)">
<Param type="Texture2D" name="texture" desc="" /> <Param type="Texture2D" name="texture" desc="" />
</Function> </Function>
<Function name="IsRenderTextureValid" retType="bool" paramCount="1" desc="Check if a render texture is valid (loaded in GPU)"> <Function name="IsRenderTextureValid" retType="bool" paramCount="1" desc="Check if render texture is valid (loaded in GPU)">
<Param type="RenderTexture2D" name="target" desc="" /> <Param type="RenderTexture2D" name="target" desc="" />
</Function> </Function>
<Function name="UnloadRenderTexture" retType="void" paramCount="1" desc="Unload render texture from GPU memory (VRAM)"> <Function name="UnloadRenderTexture" retType="void" paramCount="1" desc="Unload render texture from GPU memory (VRAM)">
@ -2251,14 +2251,14 @@
</Function> </Function>
<Function name="DrawTextureRec" retType="void" paramCount="4" desc="Draw a part of a texture defined by a rectangle"> <Function name="DrawTextureRec" retType="void" paramCount="4" desc="Draw a part of a texture defined by a rectangle">
<Param type="Texture2D" name="texture" desc="" /> <Param type="Texture2D" name="texture" desc="" />
<Param type="Rectangle" name="source" desc="" /> <Param type="Rectangle" name="rec" desc="" />
<Param type="Vector2" name="position" desc="" /> <Param type="Vector2" name="position" desc="" />
<Param type="Color" name="tint" desc="" /> <Param type="Color" name="tint" desc="" />
</Function> </Function>
<Function name="DrawTexturePro" retType="void" paramCount="6" desc="Draw a part of a texture defined by a rectangle with 'pro' parameters"> <Function name="DrawTexturePro" retType="void" paramCount="6" desc="Draw a part of a texture defined by a source rectangle to destination rectangle, with scaling and rotation">
<Param type="Texture2D" name="texture" desc="" /> <Param type="Texture2D" name="texture" desc="" />
<Param type="Rectangle" name="source" desc="" /> <Param type="Rectangle" name="srcrec" desc="" />
<Param type="Rectangle" name="dest" desc="" /> <Param type="Rectangle" name="dstrec" desc="" />
<Param type="Vector2" name="origin" desc="" /> <Param type="Vector2" name="origin" desc="" />
<Param type="float" name="rotation" desc="" /> <Param type="float" name="rotation" desc="" />
<Param type="Color" name="tint" desc="" /> <Param type="Color" name="tint" desc="" />
@ -2266,7 +2266,7 @@
<Function name="DrawTextureNPatch" retType="void" paramCount="6" desc="Draw a texture (or part of it) that stretches or shrinks nicely"> <Function name="DrawTextureNPatch" retType="void" paramCount="6" desc="Draw a texture (or part of it) that stretches or shrinks nicely">
<Param type="Texture2D" name="texture" desc="" /> <Param type="Texture2D" name="texture" desc="" />
<Param type="NPatchInfo" name="nPatchInfo" desc="" /> <Param type="NPatchInfo" name="nPatchInfo" desc="" />
<Param type="Rectangle" name="dest" desc="" /> <Param type="Rectangle" name="dstrec" desc="" />
<Param type="Vector2" name="origin" desc="" /> <Param type="Vector2" name="origin" desc="" />
<Param type="float" name="rotation" desc="" /> <Param type="float" name="rotation" desc="" />
<Param type="Color" name="tint" desc="" /> <Param type="Color" name="tint" desc="" />
@ -2326,7 +2326,7 @@
<Param type="unsigned int" name="hexValue" desc="" /> <Param type="unsigned int" name="hexValue" desc="" />
</Function> </Function>
<Function name="GetPixelColor" retType="Color" paramCount="2" desc="Get Color from a source pixel pointer of certain format"> <Function name="GetPixelColor" retType="Color" paramCount="2" desc="Get Color from a source pixel pointer of certain format">
<Param type="void *" name="srcPtr" desc="" /> <Param type="const void *" name="srcPtr" desc="" />
<Param type="int" name="format" desc="" /> <Param type="int" name="format" desc="" />
</Function> </Function>
<Function name="SetPixelColor" retType="void" paramCount="3" desc="Set color formatted into destination pixel pointer"> <Function name="SetPixelColor" retType="void" paramCount="3" desc="Set color formatted into destination pixel pointer">
@ -2363,7 +2363,7 @@
<Param type="const int *" name="codepoints" desc="" /> <Param type="const int *" name="codepoints" desc="" />
<Param type="int" name="codepointCount" desc="" /> <Param type="int" name="codepointCount" desc="" />
</Function> </Function>
<Function name="IsFontValid" retType="bool" paramCount="1" desc="Check if a font is valid (font data loaded, WARNING: GPU texture not checked)"> <Function name="IsFontValid" retType="bool" paramCount="1" desc="Check if font is valid (font data loaded, WARNING: GPU texture not checked)">
<Param type="Font" name="font" desc="" /> <Param type="Font" name="font" desc="" />
</Function> </Function>
<Function name="LoadFontData" retType="GlyphInfo *" paramCount="7" desc="Load font data for further use"> <Function name="LoadFontData" retType="GlyphInfo *" paramCount="7" desc="Load font data for further use">
@ -2687,7 +2687,7 @@
<Param type="float" name="radiusTop" desc="" /> <Param type="float" name="radiusTop" desc="" />
<Param type="float" name="radiusBottom" desc="" /> <Param type="float" name="radiusBottom" desc="" />
<Param type="float" name="height" desc="" /> <Param type="float" name="height" desc="" />
<Param type="int" name="slices" desc="" /> <Param type="int" name="sides" desc="" />
<Param type="Color" name="color" desc="" /> <Param type="Color" name="color" desc="" />
</Function> </Function>
<Function name="DrawCylinderEx" retType="void" paramCount="6" desc="Draw a cylinder with base at startPos and top at endPos"> <Function name="DrawCylinderEx" retType="void" paramCount="6" desc="Draw a cylinder with base at startPos and top at endPos">
@ -2703,7 +2703,7 @@
<Param type="float" name="radiusTop" desc="" /> <Param type="float" name="radiusTop" desc="" />
<Param type="float" name="radiusBottom" desc="" /> <Param type="float" name="radiusBottom" desc="" />
<Param type="float" name="height" desc="" /> <Param type="float" name="height" desc="" />
<Param type="int" name="slices" desc="" /> <Param type="int" name="sides" desc="" />
<Param type="Color" name="color" desc="" /> <Param type="Color" name="color" desc="" />
</Function> </Function>
<Function name="DrawCylinderWiresEx" retType="void" paramCount="6" desc="Draw a cylinder wires with base at startPos and top at endPos"> <Function name="DrawCylinderWiresEx" retType="void" paramCount="6" desc="Draw a cylinder wires with base at startPos and top at endPos">
@ -2711,7 +2711,7 @@
<Param type="Vector3" name="endPos" desc="" /> <Param type="Vector3" name="endPos" desc="" />
<Param type="float" name="startRadius" desc="" /> <Param type="float" name="startRadius" desc="" />
<Param type="float" name="endRadius" desc="" /> <Param type="float" name="endRadius" desc="" />
<Param type="int" name="slices" desc="" /> <Param type="int" name="sides" desc="" />
<Param type="Color" name="color" desc="" /> <Param type="Color" name="color" desc="" />
</Function> </Function>
<Function name="DrawCapsule" retType="void" paramCount="6" desc="Draw a capsule with the center of its sphere caps at startPos and endPos"> <Function name="DrawCapsule" retType="void" paramCount="6" desc="Draw a capsule with the center of its sphere caps at startPos and endPos">
@ -2749,7 +2749,7 @@
<Function name="LoadModelFromMesh" retType="Model" paramCount="1" desc="Load model from generated mesh (default material)"> <Function name="LoadModelFromMesh" retType="Model" paramCount="1" desc="Load model from generated mesh (default material)">
<Param type="Mesh" name="mesh" desc="" /> <Param type="Mesh" name="mesh" desc="" />
</Function> </Function>
<Function name="IsModelValid" retType="bool" paramCount="1" desc="Check if a model is valid (loaded in GPU, VAO/VBOs)"> <Function name="IsModelValid" retType="bool" paramCount="1" desc="Check if model is valid (loaded in GPU, VAO/VBOs)">
<Param type="Model" name="model" desc="" /> <Param type="Model" name="model" desc="" />
</Function> </Function>
<Function name="UnloadModel" retType="void" paramCount="1" desc="Unload model (including meshes) from memory (RAM and/or VRAM)"> <Function name="UnloadModel" retType="void" paramCount="1" desc="Unload model (including meshes) from memory (RAM and/or VRAM)">
@ -2797,18 +2797,18 @@
<Param type="float" name="scale" desc="" /> <Param type="float" name="scale" desc="" />
<Param type="Color" name="tint" desc="" /> <Param type="Color" name="tint" desc="" />
</Function> </Function>
<Function name="DrawBillboardRec" retType="void" paramCount="6" desc="Draw a billboard texture defined by source"> <Function name="DrawBillboardRec" retType="void" paramCount="6" desc="Draw a billboard texture defined by rectangle">
<Param type="Camera" name="camera" desc="" /> <Param type="Camera" name="camera" desc="" />
<Param type="Texture2D" name="texture" desc="" /> <Param type="Texture2D" name="texture" desc="" />
<Param type="Rectangle" name="source" desc="" /> <Param type="Rectangle" name="rec" desc="" />
<Param type="Vector3" name="position" desc="" /> <Param type="Vector3" name="position" desc="" />
<Param type="Vector2" name="size" desc="" /> <Param type="Vector2" name="size" desc="" />
<Param type="Color" name="tint" desc="" /> <Param type="Color" name="tint" desc="" />
</Function> </Function>
<Function name="DrawBillboardPro" retType="void" paramCount="9" desc="Draw a billboard texture defined by source and rotation"> <Function name="DrawBillboardPro" retType="void" paramCount="9" desc="Draw a billboard texture defined by source rectangle with scaling and rotation">
<Param type="Camera" name="camera" desc="" /> <Param type="Camera" name="camera" desc="" />
<Param type="Texture2D" name="texture" desc="" /> <Param type="Texture2D" name="texture" desc="" />
<Param type="Rectangle" name="source" desc="" /> <Param type="Rectangle" name="rec" desc="" />
<Param type="Vector3" name="position" desc="" /> <Param type="Vector3" name="position" desc="" />
<Param type="Vector3" name="up" desc="" /> <Param type="Vector3" name="up" desc="" />
<Param type="Vector2" name="size" desc="" /> <Param type="Vector2" name="size" desc="" />
@ -2916,7 +2916,7 @@
</Function> </Function>
<Function name="LoadMaterialDefault" retType="Material" paramCount="0" desc="Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)"> <Function name="LoadMaterialDefault" retType="Material" paramCount="0" desc="Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)">
</Function> </Function>
<Function name="IsMaterialValid" retType="bool" paramCount="1" desc="Check if a material is valid (shader assigned, map textures loaded in GPU)"> <Function name="IsMaterialValid" retType="bool" paramCount="1" desc="Check if material is valid (shader assigned, map textures loaded in GPU)">
<Param type="Material" name="material" desc="" /> <Param type="Material" name="material" desc="" />
</Function> </Function>
<Function name="UnloadMaterial" retType="void" paramCount="1" desc="Unload material from GPU memory (VRAM)"> <Function name="UnloadMaterial" retType="void" paramCount="1" desc="Unload material from GPU memory (VRAM)">
@ -3030,7 +3030,7 @@
<Function name="LoadSoundAlias" retType="Sound" paramCount="1" desc="Load sound alias, new sound that shares the same sample data as the source sound, does not own the sound data"> <Function name="LoadSoundAlias" retType="Sound" paramCount="1" desc="Load sound alias, new sound that shares the same sample data as the source sound, does not own the sound data">
<Param type="Sound" name="source" desc="" /> <Param type="Sound" name="source" desc="" />
</Function> </Function>
<Function name="IsSoundValid" retType="bool" paramCount="1" desc="Check if a sound is valid (data loaded and buffers initialized)"> <Function name="IsSoundValid" retType="bool" paramCount="1" desc="Check if sound is valid (data loaded and buffers initialized)">
<Param type="Sound" name="sound" desc="" /> <Param type="Sound" name="sound" desc="" />
</Function> </Function>
<Function name="UpdateSound" retType="void" paramCount="3" desc="Update sound buffer with new data (default data format: 32 bit float, stereo)"> <Function name="UpdateSound" retType="void" paramCount="3" desc="Update sound buffer with new data (default data format: 32 bit float, stereo)">
@ -3067,7 +3067,7 @@
<Function name="ResumeSound" retType="void" paramCount="1" desc="Resume a paused sound"> <Function name="ResumeSound" retType="void" paramCount="1" desc="Resume a paused sound">
<Param type="Sound" name="sound" desc="" /> <Param type="Sound" name="sound" desc="" />
</Function> </Function>
<Function name="IsSoundPlaying" retType="bool" paramCount="1" desc="Check if a sound is currently playing"> <Function name="IsSoundPlaying" retType="bool" paramCount="1" desc="Check if sound is currently playing">
<Param type="Sound" name="sound" desc="" /> <Param type="Sound" name="sound" desc="" />
</Function> </Function>
<Function name="SetSoundVolume" retType="void" paramCount="2" desc="Set volume for a sound (1.0 is max level)"> <Function name="SetSoundVolume" retType="void" paramCount="2" desc="Set volume for a sound (1.0 is max level)">
@ -3110,7 +3110,7 @@
<Param type="const unsigned char *" name="data" desc="" /> <Param type="const unsigned char *" name="data" desc="" />
<Param type="int" name="dataSize" desc="" /> <Param type="int" name="dataSize" desc="" />
</Function> </Function>
<Function name="IsMusicValid" retType="bool" paramCount="1" desc="Check if a music stream is valid (context and buffers initialized)"> <Function name="IsMusicValid" retType="bool" paramCount="1" desc="Check if music stream is valid (context and buffers initialized)">
<Param type="Music" name="music" desc="" /> <Param type="Music" name="music" desc="" />
</Function> </Function>
<Function name="UnloadMusicStream" retType="void" paramCount="1" desc="Unload music stream"> <Function name="UnloadMusicStream" retType="void" paramCount="1" desc="Unload music stream">