├── .gitignore ├── raylib ├── libraylib.a ├── README ├── LICENSE ├── raymath.h └── raylib.h ├── Makefile ├── README.md ├── notes.txt ├── LICENSE └── game.asm /.gitignore: -------------------------------------------------------------------------------- 1 | game 2 | game.o -------------------------------------------------------------------------------- /raylib/libraylib.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/tsoding/fasm-raylib-simd/HEAD/raylib/libraylib.a -------------------------------------------------------------------------------- /raylib/README: -------------------------------------------------------------------------------- 1 | Custom build of original Raylib 5.0 https://github.com/raysan5/raylib/releases/tag/5.0 -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | game: game.o 2 | ld -o game game.o -dynamic-linker /lib64/ld-linux-x86-64.so.2 -L./raylib/ -lc -lraylib -lm 3 | 4 | game.o: game.asm 5 | fasm game.asm 6 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Raylib DEMO in Fasm with SIMD 2 | 3 | A simple demo of using SIMD instructions and [Raylib](https://www.raylib.com/) in [fasm](https://flatassembler.net/) 4 | 5 | ## Quick Start 6 | 7 | ```console 8 | $ make 9 | $ ./game 10 | ``` 11 | -------------------------------------------------------------------------------- /notes.txt: -------------------------------------------------------------------------------- 1 | p - position of the body 2 | v - velocity of the body 3 | s - size of the body 4 | w - size of the screen 5 | dt - delta time 6 | 7 | p' <- p + v*dt (* xmm0 *) 8 | C1 <- p' < 0 (* xmm1 *) 9 | C2 <- p' + s >= w (* xmm2 *) 10 | C <- C1 || C2 (* xmm1 *) 11 | ^C (* xmm2 *) 12 | p <- [C]*p + [^C]*p' 13 | v <- v*([^C] - [C]) 14 | -------------------------------------------------------------------------------- /raylib/LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) 2 | 3 | This software is provided "as-is", without any express or implied warranty. In no event 4 | will the authors be held liable for any damages arising from the use of this software. 5 | 6 | Permission is granted to anyone to use this software for any purpose, including commercial 7 | applications, and to alter it and redistribute it freely, subject to the following restrictions: 8 | 9 | 1. The origin of this software must not be misrepresented; you must not claim that you 10 | wrote the original software. If you use this software in a product, an acknowledgment 11 | in the product documentation would be appreciated but is not required. 12 | 13 | 2. Altered source versions must be plainly marked as such, and must not be misrepresented 14 | as being the original software. 15 | 16 | 3. This notice may not be removed or altered from any source distribution. 17 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright 2024 Alexey Kutepov 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining 4 | a copy of this software and associated documentation files (the 5 | "Software"), to deal in the Software without restriction, including 6 | without limitation the rights to use, copy, modify, merge, publish, 7 | distribute, sublicense, and/or sell copies of the Software, and to 8 | permit persons to whom the Software is furnished to do so, subject to 9 | the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be 12 | included in all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -------------------------------------------------------------------------------- /game.asm: -------------------------------------------------------------------------------- 1 | format ELF64 2 | 3 | section '.text' executable 4 | public _start 5 | extrn printf 6 | extrn _exit 7 | extrn InitWindow 8 | extrn WindowShouldClose 9 | extrn CloseWindow 10 | extrn BeginDrawing 11 | extrn EndDrawing 12 | extrn ClearBackground 13 | extrn DrawRectangle 14 | extrn DrawRectangleV 15 | extrn GetFrameTime 16 | extrn GetScreenWidth 17 | extrn GetScreenHeight 18 | 19 | _start: 20 | mov rdi, 800 21 | mov rsi, 600 22 | mov rdx, title 23 | call InitWindow 24 | 25 | .again: 26 | call WindowShouldClose 27 | test rax, rax 28 | jnz .over 29 | call BeginDrawing 30 | 31 | mov rdi, 0xFF181818 32 | call ClearBackground 33 | 34 | ;; getting the border 35 | call GetScreenWidth 36 | mov [border], eax 37 | mov [border+8], eax 38 | call GetScreenHeight 39 | mov [border+4], eax 40 | mov [border+12], eax 41 | movaps xmm0, [border] 42 | cvtdq2ps xmm0, xmm0 43 | movaps [border], xmm0 44 | 45 | ;; next position 46 | call GetFrameTime 47 | shufps xmm0, xmm0, 0 48 | mulps xmm0, [velocity] 49 | addps xmm0, [position] 50 | 51 | ;; check collisions 52 | movaps xmm1, xmm0 53 | cmpltps xmm1, [zero] 54 | movaps xmm2, xmm0 55 | addps xmm2, [size] 56 | cmpnltps xmm2, [border] 57 | orps xmm1, xmm2 58 | cvtdq2ps xmm1, xmm1 59 | mulps xmm1, [minus_one] 60 | movaps xmm2, [one] 61 | subps xmm2, xmm1 62 | 63 | ;; update position 64 | movaps xmm3, [position] 65 | mulps xmm3, xmm1 66 | movaps xmm4, xmm0 67 | mulps xmm4, xmm2 68 | addps xmm3, xmm4 69 | movaps [position], xmm3 70 | 71 | ;; update velocity 72 | subps xmm2, xmm1 73 | movaps xmm3, [velocity] 74 | mulps xmm2, xmm3 75 | movaps [velocity], xmm2 76 | 77 | ;; rendering rect 1 78 | movq xmm0, [position] 79 | movq xmm1, [size] 80 | mov rdi, 0xFF0000FF 81 | call DrawRectangleV 82 | 83 | ;; rendering rect 2 84 | movq xmm0, [position + 8] 85 | movq xmm1, [size + 8] 86 | mov rdi, 0xFF00FF00 87 | call DrawRectangleV 88 | 89 | call EndDrawing 90 | jmp .again 91 | 92 | .over: 93 | call CloseWindow 94 | mov rdi, 0 95 | call _exit 96 | 97 | section '.data' writeable 98 | position: 99 | dd 200.0 100 | dd 200.0 101 | dd 400.0 102 | dd 400.0 103 | velocity: 104 | dd -200.0 105 | dd -300.0 106 | dd 300.0 107 | dd 400.0 108 | size: 109 | dd 200.0 110 | dd 200.0 111 | dd 100.0 112 | dd 100.0 113 | border: 114 | dd 0.0 115 | dd 0.0 116 | dd 0.0 117 | dd 0.0 118 | zero: 119 | dd 0.0 120 | dd 0.0 121 | dd 0.0 122 | dd 0.0 123 | minus_one: 124 | dd -1.0 125 | dd -1.0 126 | dd -1.0 127 | dd -1.0 128 | one: 129 | dd 1.0 130 | dd 1.0 131 | dd 1.0 132 | dd 1.0 133 | title: db "Hello Raylib from Fasm", 0 134 | section '.note.GNU-stack' 135 | -------------------------------------------------------------------------------- /raylib/raymath.h: -------------------------------------------------------------------------------- 1 | /********************************************************************************************** 2 | * 3 | * raymath v1.5 - Math functions to work with Vector2, Vector3, Matrix and Quaternions 4 | * 5 | * CONVENTIONS: 6 | * - Matrix structure is defined as row-major (memory layout) but parameters naming AND all 7 | * math operations performed by the library consider the structure as it was column-major 8 | * It is like transposed versions of the matrices are used for all the maths 9 | * It benefits some functions making them cache-friendly and also avoids matrix 10 | * transpositions sometimes required by OpenGL 11 | * Example: In memory order, row0 is [m0 m4 m8 m12] but in semantic math row0 is [m0 m1 m2 m3] 12 | * - Functions are always self-contained, no function use another raymath function inside, 13 | * required code is directly re-implemented inside 14 | * - Functions input parameters are always received by value (2 unavoidable exceptions) 15 | * - Functions use always a "result" variable for return 16 | * - Functions are always defined inline 17 | * - Angles are always in radians (DEG2RAD/RAD2DEG macros provided for convenience) 18 | * - No compound literals used to make sure libray is compatible with C++ 19 | * 20 | * CONFIGURATION: 21 | * #define RAYMATH_IMPLEMENTATION 22 | * Generates the implementation of the library into the included file. 23 | * If not defined, the library is in header only mode and can be included in other headers 24 | * or source files without problems. But only ONE file should hold the implementation. 25 | * 26 | * #define RAYMATH_STATIC_INLINE 27 | * Define static inline functions code, so #include header suffices for use. 28 | * This may use up lots of memory. 29 | * 30 | * 31 | * LICENSE: zlib/libpng 32 | * 33 | * Copyright (c) 2015-2023 Ramon Santamaria (@raysan5) 34 | * 35 | * This software is provided "as-is", without any express or implied warranty. In no event 36 | * will the authors be held liable for any damages arising from the use of this software. 37 | * 38 | * Permission is granted to anyone to use this software for any purpose, including commercial 39 | * applications, and to alter it and redistribute it freely, subject to the following restrictions: 40 | * 41 | * 1. The origin of this software must not be misrepresented; you must not claim that you 42 | * wrote the original software. If you use this software in a product, an acknowledgment 43 | * in the product documentation would be appreciated but is not required. 44 | * 45 | * 2. Altered source versions must be plainly marked as such, and must not be misrepresented 46 | * as being the original software. 47 | * 48 | * 3. This notice may not be removed or altered from any source distribution. 49 | * 50 | **********************************************************************************************/ 51 | 52 | #ifndef RAYMATH_H 53 | #define RAYMATH_H 54 | 55 | #if defined(RAYMATH_IMPLEMENTATION) && defined(RAYMATH_STATIC_INLINE) 56 | #error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_STATIC_INLINE is contradictory" 57 | #endif 58 | 59 | // Function specifiers definition 60 | #if defined(RAYMATH_IMPLEMENTATION) 61 | #if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED) 62 | #define RMAPI __declspec(dllexport) extern inline // We are building raylib as a Win32 shared library (.dll). 63 | #elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED) 64 | #define RMAPI __declspec(dllimport) // We are using raylib as a Win32 shared library (.dll) 65 | #else 66 | #define RMAPI extern inline // Provide external definition 67 | #endif 68 | #elif defined(RAYMATH_STATIC_INLINE) 69 | #define RMAPI static inline // Functions may be inlined, no external out-of-line definition 70 | #else 71 | #if defined(__TINYC__) 72 | #define RMAPI static inline // plain inline not supported by tinycc (See issue #435) 73 | #else 74 | #define RMAPI inline // Functions may be inlined or external definition used 75 | #endif 76 | #endif 77 | 78 | //---------------------------------------------------------------------------------- 79 | // Defines and Macros 80 | //---------------------------------------------------------------------------------- 81 | #ifndef PI 82 | #define PI 3.14159265358979323846f 83 | #endif 84 | 85 | #ifndef EPSILON 86 | #define EPSILON 0.000001f 87 | #endif 88 | 89 | #ifndef DEG2RAD 90 | #define DEG2RAD (PI/180.0f) 91 | #endif 92 | 93 | #ifndef RAD2DEG 94 | #define RAD2DEG (180.0f/PI) 95 | #endif 96 | 97 | // Get float vector for Matrix 98 | #ifndef MatrixToFloat 99 | #define MatrixToFloat(mat) (MatrixToFloatV(mat).v) 100 | #endif 101 | 102 | // Get float vector for Vector3 103 | #ifndef Vector3ToFloat 104 | #define Vector3ToFloat(vec) (Vector3ToFloatV(vec).v) 105 | #endif 106 | 107 | //---------------------------------------------------------------------------------- 108 | // Types and Structures Definition 109 | //---------------------------------------------------------------------------------- 110 | #if !defined(RL_VECTOR2_TYPE) 111 | // Vector2 type 112 | typedef struct Vector2 { 113 | float x; 114 | float y; 115 | } Vector2; 116 | #define RL_VECTOR2_TYPE 117 | #endif 118 | 119 | #if !defined(RL_VECTOR3_TYPE) 120 | // Vector3 type 121 | typedef struct Vector3 { 122 | float x; 123 | float y; 124 | float z; 125 | } Vector3; 126 | #define RL_VECTOR3_TYPE 127 | #endif 128 | 129 | #if !defined(RL_VECTOR4_TYPE) 130 | // Vector4 type 131 | typedef struct Vector4 { 132 | float x; 133 | float y; 134 | float z; 135 | float w; 136 | } Vector4; 137 | #define RL_VECTOR4_TYPE 138 | #endif 139 | 140 | #if !defined(RL_QUATERNION_TYPE) 141 | // Quaternion type 142 | typedef Vector4 Quaternion; 143 | #define RL_QUATERNION_TYPE 144 | #endif 145 | 146 | #if !defined(RL_MATRIX_TYPE) 147 | // Matrix type (OpenGL style 4x4 - right handed, column major) 148 | typedef struct Matrix { 149 | float m0, m4, m8, m12; // Matrix first row (4 components) 150 | float m1, m5, m9, m13; // Matrix second row (4 components) 151 | float m2, m6, m10, m14; // Matrix third row (4 components) 152 | float m3, m7, m11, m15; // Matrix fourth row (4 components) 153 | } Matrix; 154 | #define RL_MATRIX_TYPE 155 | #endif 156 | 157 | // NOTE: Helper types to be used instead of array return types for *ToFloat functions 158 | typedef struct float3 { 159 | float v[3]; 160 | } float3; 161 | 162 | typedef struct float16 { 163 | float v[16]; 164 | } float16; 165 | 166 | #include // Required for: sinf(), cosf(), tan(), atan2f(), sqrtf(), floor(), fminf(), fmaxf(), fabs() 167 | 168 | //---------------------------------------------------------------------------------- 169 | // Module Functions Definition - Utils math 170 | //---------------------------------------------------------------------------------- 171 | 172 | // Clamp float value 173 | RMAPI float Clamp(float value, float min, float max) 174 | { 175 | float result = (value < min)? min : value; 176 | 177 | if (result > max) result = max; 178 | 179 | return result; 180 | } 181 | 182 | // Calculate linear interpolation between two floats 183 | RMAPI float Lerp(float start, float end, float amount) 184 | { 185 | float result = start + amount*(end - start); 186 | 187 | return result; 188 | } 189 | 190 | // Normalize input value within input range 191 | RMAPI float Normalize(float value, float start, float end) 192 | { 193 | float result = (value - start)/(end - start); 194 | 195 | return result; 196 | } 197 | 198 | // Remap input value within input range to output range 199 | RMAPI float Remap(float value, float inputStart, float inputEnd, float outputStart, float outputEnd) 200 | { 201 | float result = (value - inputStart)/(inputEnd - inputStart)*(outputEnd - outputStart) + outputStart; 202 | 203 | return result; 204 | } 205 | 206 | // Wrap input value from min to max 207 | RMAPI float Wrap(float value, float min, float max) 208 | { 209 | float result = value - (max - min)*floorf((value - min)/(max - min)); 210 | 211 | return result; 212 | } 213 | 214 | // Check whether two given floats are almost equal 215 | RMAPI int FloatEquals(float x, float y) 216 | { 217 | #if !defined(EPSILON) 218 | #define EPSILON 0.000001f 219 | #endif 220 | 221 | int result = (fabsf(x - y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(x), fabsf(y)))); 222 | 223 | return result; 224 | } 225 | 226 | //---------------------------------------------------------------------------------- 227 | // Module Functions Definition - Vector2 math 228 | //---------------------------------------------------------------------------------- 229 | 230 | // Vector with components value 0.0f 231 | RMAPI Vector2 Vector2Zero(void) 232 | { 233 | Vector2 result = { 0.0f, 0.0f }; 234 | 235 | return result; 236 | } 237 | 238 | // Vector with components value 1.0f 239 | RMAPI Vector2 Vector2One(void) 240 | { 241 | Vector2 result = { 1.0f, 1.0f }; 242 | 243 | return result; 244 | } 245 | 246 | // Add two vectors (v1 + v2) 247 | RMAPI Vector2 Vector2Add(Vector2 v1, Vector2 v2) 248 | { 249 | Vector2 result = { v1.x + v2.x, v1.y + v2.y }; 250 | 251 | return result; 252 | } 253 | 254 | // Add vector and float value 255 | RMAPI Vector2 Vector2AddValue(Vector2 v, float add) 256 | { 257 | Vector2 result = { v.x + add, v.y + add }; 258 | 259 | return result; 260 | } 261 | 262 | // Subtract two vectors (v1 - v2) 263 | RMAPI Vector2 Vector2Subtract(Vector2 v1, Vector2 v2) 264 | { 265 | Vector2 result = { v1.x - v2.x, v1.y - v2.y }; 266 | 267 | return result; 268 | } 269 | 270 | // Subtract vector by float value 271 | RMAPI Vector2 Vector2SubtractValue(Vector2 v, float sub) 272 | { 273 | Vector2 result = { v.x - sub, v.y - sub }; 274 | 275 | return result; 276 | } 277 | 278 | // Calculate vector length 279 | RMAPI float Vector2Length(Vector2 v) 280 | { 281 | float result = sqrtf((v.x*v.x) + (v.y*v.y)); 282 | 283 | return result; 284 | } 285 | 286 | // Calculate vector square length 287 | RMAPI float Vector2LengthSqr(Vector2 v) 288 | { 289 | float result = (v.x*v.x) + (v.y*v.y); 290 | 291 | return result; 292 | } 293 | 294 | // Calculate two vectors dot product 295 | RMAPI float Vector2DotProduct(Vector2 v1, Vector2 v2) 296 | { 297 | float result = (v1.x*v2.x + v1.y*v2.y); 298 | 299 | return result; 300 | } 301 | 302 | // Calculate distance between two vectors 303 | RMAPI float Vector2Distance(Vector2 v1, Vector2 v2) 304 | { 305 | float result = sqrtf((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y)); 306 | 307 | return result; 308 | } 309 | 310 | // Calculate square distance between two vectors 311 | RMAPI float Vector2DistanceSqr(Vector2 v1, Vector2 v2) 312 | { 313 | float result = ((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y)); 314 | 315 | return result; 316 | } 317 | 318 | // Calculate angle between two vectors 319 | // NOTE: Angle is calculated from origin point (0, 0) 320 | RMAPI float Vector2Angle(Vector2 v1, Vector2 v2) 321 | { 322 | float result = 0.0f; 323 | 324 | float dot = v1.x*v2.x + v1.y*v2.y; 325 | float det = v1.x*v2.y - v1.y*v2.x; 326 | 327 | result = atan2f(det, dot); 328 | 329 | return result; 330 | } 331 | 332 | // Calculate angle defined by a two vectors line 333 | // NOTE: Parameters need to be normalized 334 | // Current implementation should be aligned with glm::angle 335 | RMAPI float Vector2LineAngle(Vector2 start, Vector2 end) 336 | { 337 | float result = 0.0f; 338 | 339 | // TODO(10/9/2023): Currently angles move clockwise, determine if this is wanted behavior 340 | result = -atan2f(end.y - start.y, end.x - start.x); 341 | 342 | return result; 343 | } 344 | 345 | // Scale vector (multiply by value) 346 | RMAPI Vector2 Vector2Scale(Vector2 v, float scale) 347 | { 348 | Vector2 result = { v.x*scale, v.y*scale }; 349 | 350 | return result; 351 | } 352 | 353 | // Multiply vector by vector 354 | RMAPI Vector2 Vector2Multiply(Vector2 v1, Vector2 v2) 355 | { 356 | Vector2 result = { v1.x*v2.x, v1.y*v2.y }; 357 | 358 | return result; 359 | } 360 | 361 | // Negate vector 362 | RMAPI Vector2 Vector2Negate(Vector2 v) 363 | { 364 | Vector2 result = { -v.x, -v.y }; 365 | 366 | return result; 367 | } 368 | 369 | // Divide vector by vector 370 | RMAPI Vector2 Vector2Divide(Vector2 v1, Vector2 v2) 371 | { 372 | Vector2 result = { v1.x/v2.x, v1.y/v2.y }; 373 | 374 | return result; 375 | } 376 | 377 | // Normalize provided vector 378 | RMAPI Vector2 Vector2Normalize(Vector2 v) 379 | { 380 | Vector2 result = { 0 }; 381 | float length = sqrtf((v.x*v.x) + (v.y*v.y)); 382 | 383 | if (length > 0) 384 | { 385 | float ilength = 1.0f/length; 386 | result.x = v.x*ilength; 387 | result.y = v.y*ilength; 388 | } 389 | 390 | return result; 391 | } 392 | 393 | // Transforms a Vector2 by a given Matrix 394 | RMAPI Vector2 Vector2Transform(Vector2 v, Matrix mat) 395 | { 396 | Vector2 result = { 0 }; 397 | 398 | float x = v.x; 399 | float y = v.y; 400 | float z = 0; 401 | 402 | result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12; 403 | result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13; 404 | 405 | return result; 406 | } 407 | 408 | // Calculate linear interpolation between two vectors 409 | RMAPI Vector2 Vector2Lerp(Vector2 v1, Vector2 v2, float amount) 410 | { 411 | Vector2 result = { 0 }; 412 | 413 | result.x = v1.x + amount*(v2.x - v1.x); 414 | result.y = v1.y + amount*(v2.y - v1.y); 415 | 416 | return result; 417 | } 418 | 419 | // Calculate reflected vector to normal 420 | RMAPI Vector2 Vector2Reflect(Vector2 v, Vector2 normal) 421 | { 422 | Vector2 result = { 0 }; 423 | 424 | float dotProduct = (v.x*normal.x + v.y*normal.y); // Dot product 425 | 426 | result.x = v.x - (2.0f*normal.x)*dotProduct; 427 | result.y = v.y - (2.0f*normal.y)*dotProduct; 428 | 429 | return result; 430 | } 431 | 432 | // Rotate vector by angle 433 | RMAPI Vector2 Vector2Rotate(Vector2 v, float angle) 434 | { 435 | Vector2 result = { 0 }; 436 | 437 | float cosres = cosf(angle); 438 | float sinres = sinf(angle); 439 | 440 | result.x = v.x*cosres - v.y*sinres; 441 | result.y = v.x*sinres + v.y*cosres; 442 | 443 | return result; 444 | } 445 | 446 | // Move Vector towards target 447 | RMAPI Vector2 Vector2MoveTowards(Vector2 v, Vector2 target, float maxDistance) 448 | { 449 | Vector2 result = { 0 }; 450 | 451 | float dx = target.x - v.x; 452 | float dy = target.y - v.y; 453 | float value = (dx*dx) + (dy*dy); 454 | 455 | if ((value == 0) || ((maxDistance >= 0) && (value <= maxDistance*maxDistance))) return target; 456 | 457 | float dist = sqrtf(value); 458 | 459 | result.x = v.x + dx/dist*maxDistance; 460 | result.y = v.y + dy/dist*maxDistance; 461 | 462 | return result; 463 | } 464 | 465 | // Invert the given vector 466 | RMAPI Vector2 Vector2Invert(Vector2 v) 467 | { 468 | Vector2 result = { 1.0f/v.x, 1.0f/v.y }; 469 | 470 | return result; 471 | } 472 | 473 | // Clamp the components of the vector between 474 | // min and max values specified by the given vectors 475 | RMAPI Vector2 Vector2Clamp(Vector2 v, Vector2 min, Vector2 max) 476 | { 477 | Vector2 result = { 0 }; 478 | 479 | result.x = fminf(max.x, fmaxf(min.x, v.x)); 480 | result.y = fminf(max.y, fmaxf(min.y, v.y)); 481 | 482 | return result; 483 | } 484 | 485 | // Clamp the magnitude of the vector between two min and max values 486 | RMAPI Vector2 Vector2ClampValue(Vector2 v, float min, float max) 487 | { 488 | Vector2 result = v; 489 | 490 | float length = (v.x*v.x) + (v.y*v.y); 491 | if (length > 0.0f) 492 | { 493 | length = sqrtf(length); 494 | 495 | if (length < min) 496 | { 497 | float scale = min/length; 498 | result.x = v.x*scale; 499 | result.y = v.y*scale; 500 | } 501 | else if (length > max) 502 | { 503 | float scale = max/length; 504 | result.x = v.x*scale; 505 | result.y = v.y*scale; 506 | } 507 | } 508 | 509 | return result; 510 | } 511 | 512 | // Check whether two given vectors are almost equal 513 | RMAPI int Vector2Equals(Vector2 p, Vector2 q) 514 | { 515 | #if !defined(EPSILON) 516 | #define EPSILON 0.000001f 517 | #endif 518 | 519 | int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && 520 | ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))); 521 | 522 | return result; 523 | } 524 | 525 | //---------------------------------------------------------------------------------- 526 | // Module Functions Definition - Vector3 math 527 | //---------------------------------------------------------------------------------- 528 | 529 | // Vector with components value 0.0f 530 | RMAPI Vector3 Vector3Zero(void) 531 | { 532 | Vector3 result = { 0.0f, 0.0f, 0.0f }; 533 | 534 | return result; 535 | } 536 | 537 | // Vector with components value 1.0f 538 | RMAPI Vector3 Vector3One(void) 539 | { 540 | Vector3 result = { 1.0f, 1.0f, 1.0f }; 541 | 542 | return result; 543 | } 544 | 545 | // Add two vectors 546 | RMAPI Vector3 Vector3Add(Vector3 v1, Vector3 v2) 547 | { 548 | Vector3 result = { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z }; 549 | 550 | return result; 551 | } 552 | 553 | // Add vector and float value 554 | RMAPI Vector3 Vector3AddValue(Vector3 v, float add) 555 | { 556 | Vector3 result = { v.x + add, v.y + add, v.z + add }; 557 | 558 | return result; 559 | } 560 | 561 | // Subtract two vectors 562 | RMAPI Vector3 Vector3Subtract(Vector3 v1, Vector3 v2) 563 | { 564 | Vector3 result = { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z }; 565 | 566 | return result; 567 | } 568 | 569 | // Subtract vector by float value 570 | RMAPI Vector3 Vector3SubtractValue(Vector3 v, float sub) 571 | { 572 | Vector3 result = { v.x - sub, v.y - sub, v.z - sub }; 573 | 574 | return result; 575 | } 576 | 577 | // Multiply vector by scalar 578 | RMAPI Vector3 Vector3Scale(Vector3 v, float scalar) 579 | { 580 | Vector3 result = { v.x*scalar, v.y*scalar, v.z*scalar }; 581 | 582 | return result; 583 | } 584 | 585 | // Multiply vector by vector 586 | RMAPI Vector3 Vector3Multiply(Vector3 v1, Vector3 v2) 587 | { 588 | Vector3 result = { v1.x*v2.x, v1.y*v2.y, v1.z*v2.z }; 589 | 590 | return result; 591 | } 592 | 593 | // Calculate two vectors cross product 594 | RMAPI Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2) 595 | { 596 | Vector3 result = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x }; 597 | 598 | return result; 599 | } 600 | 601 | // Calculate one vector perpendicular vector 602 | RMAPI Vector3 Vector3Perpendicular(Vector3 v) 603 | { 604 | Vector3 result = { 0 }; 605 | 606 | float min = (float) fabs(v.x); 607 | Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f}; 608 | 609 | if (fabsf(v.y) < min) 610 | { 611 | min = (float) fabs(v.y); 612 | Vector3 tmp = {0.0f, 1.0f, 0.0f}; 613 | cardinalAxis = tmp; 614 | } 615 | 616 | if (fabsf(v.z) < min) 617 | { 618 | Vector3 tmp = {0.0f, 0.0f, 1.0f}; 619 | cardinalAxis = tmp; 620 | } 621 | 622 | // Cross product between vectors 623 | result.x = v.y*cardinalAxis.z - v.z*cardinalAxis.y; 624 | result.y = v.z*cardinalAxis.x - v.x*cardinalAxis.z; 625 | result.z = v.x*cardinalAxis.y - v.y*cardinalAxis.x; 626 | 627 | return result; 628 | } 629 | 630 | // Calculate vector length 631 | RMAPI float Vector3Length(const Vector3 v) 632 | { 633 | float result = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); 634 | 635 | return result; 636 | } 637 | 638 | // Calculate vector square length 639 | RMAPI float Vector3LengthSqr(const Vector3 v) 640 | { 641 | float result = v.x*v.x + v.y*v.y + v.z*v.z; 642 | 643 | return result; 644 | } 645 | 646 | // Calculate two vectors dot product 647 | RMAPI float Vector3DotProduct(Vector3 v1, Vector3 v2) 648 | { 649 | float result = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); 650 | 651 | return result; 652 | } 653 | 654 | // Calculate distance between two vectors 655 | RMAPI float Vector3Distance(Vector3 v1, Vector3 v2) 656 | { 657 | float result = 0.0f; 658 | 659 | float dx = v2.x - v1.x; 660 | float dy = v2.y - v1.y; 661 | float dz = v2.z - v1.z; 662 | result = sqrtf(dx*dx + dy*dy + dz*dz); 663 | 664 | return result; 665 | } 666 | 667 | // Calculate square distance between two vectors 668 | RMAPI float Vector3DistanceSqr(Vector3 v1, Vector3 v2) 669 | { 670 | float result = 0.0f; 671 | 672 | float dx = v2.x - v1.x; 673 | float dy = v2.y - v1.y; 674 | float dz = v2.z - v1.z; 675 | result = dx*dx + dy*dy + dz*dz; 676 | 677 | return result; 678 | } 679 | 680 | // Calculate angle between two vectors 681 | RMAPI float Vector3Angle(Vector3 v1, Vector3 v2) 682 | { 683 | float result = 0.0f; 684 | 685 | Vector3 cross = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x }; 686 | float len = sqrtf(cross.x*cross.x + cross.y*cross.y + cross.z*cross.z); 687 | float dot = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); 688 | result = atan2f(len, dot); 689 | 690 | return result; 691 | } 692 | 693 | // Negate provided vector (invert direction) 694 | RMAPI Vector3 Vector3Negate(Vector3 v) 695 | { 696 | Vector3 result = { -v.x, -v.y, -v.z }; 697 | 698 | return result; 699 | } 700 | 701 | // Divide vector by vector 702 | RMAPI Vector3 Vector3Divide(Vector3 v1, Vector3 v2) 703 | { 704 | Vector3 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z }; 705 | 706 | return result; 707 | } 708 | 709 | // Normalize provided vector 710 | RMAPI Vector3 Vector3Normalize(Vector3 v) 711 | { 712 | Vector3 result = v; 713 | 714 | float length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); 715 | if (length != 0.0f) 716 | { 717 | float ilength = 1.0f/length; 718 | 719 | result.x *= ilength; 720 | result.y *= ilength; 721 | result.z *= ilength; 722 | } 723 | 724 | return result; 725 | } 726 | 727 | //Calculate the projection of the vector v1 on to v2 728 | RMAPI Vector3 Vector3Project(Vector3 v1, Vector3 v2) 729 | { 730 | Vector3 result = { 0 }; 731 | 732 | float v1dv2 = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); 733 | float v2dv2 = (v2.x*v2.x + v2.y*v2.y + v2.z*v2.z); 734 | 735 | float mag = v1dv2/v2dv2; 736 | 737 | result.x = v2.x*mag; 738 | result.y = v2.y*mag; 739 | result.z = v2.z*mag; 740 | 741 | return result; 742 | } 743 | 744 | //Calculate the rejection of the vector v1 on to v2 745 | RMAPI Vector3 Vector3Reject(Vector3 v1, Vector3 v2) 746 | { 747 | Vector3 result = { 0 }; 748 | 749 | float v1dv2 = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z); 750 | float v2dv2 = (v2.x*v2.x + v2.y*v2.y + v2.z*v2.z); 751 | 752 | float mag = v1dv2/v2dv2; 753 | 754 | result.x = v1.x - (v2.x*mag); 755 | result.y = v1.y - (v2.y*mag); 756 | result.z = v1.z - (v2.z*mag); 757 | 758 | return result; 759 | } 760 | 761 | // Orthonormalize provided vectors 762 | // Makes vectors normalized and orthogonal to each other 763 | // Gram-Schmidt function implementation 764 | RMAPI void Vector3OrthoNormalize(Vector3 *v1, Vector3 *v2) 765 | { 766 | float length = 0.0f; 767 | float ilength = 0.0f; 768 | 769 | // Vector3Normalize(*v1); 770 | Vector3 v = *v1; 771 | length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); 772 | if (length == 0.0f) length = 1.0f; 773 | ilength = 1.0f/length; 774 | v1->x *= ilength; 775 | v1->y *= ilength; 776 | v1->z *= ilength; 777 | 778 | // Vector3CrossProduct(*v1, *v2) 779 | Vector3 vn1 = { v1->y*v2->z - v1->z*v2->y, v1->z*v2->x - v1->x*v2->z, v1->x*v2->y - v1->y*v2->x }; 780 | 781 | // Vector3Normalize(vn1); 782 | v = vn1; 783 | length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); 784 | if (length == 0.0f) length = 1.0f; 785 | ilength = 1.0f/length; 786 | vn1.x *= ilength; 787 | vn1.y *= ilength; 788 | vn1.z *= ilength; 789 | 790 | // Vector3CrossProduct(vn1, *v1) 791 | Vector3 vn2 = { vn1.y*v1->z - vn1.z*v1->y, vn1.z*v1->x - vn1.x*v1->z, vn1.x*v1->y - vn1.y*v1->x }; 792 | 793 | *v2 = vn2; 794 | } 795 | 796 | // Transforms a Vector3 by a given Matrix 797 | RMAPI Vector3 Vector3Transform(Vector3 v, Matrix mat) 798 | { 799 | Vector3 result = { 0 }; 800 | 801 | float x = v.x; 802 | float y = v.y; 803 | float z = v.z; 804 | 805 | result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12; 806 | result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13; 807 | result.z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14; 808 | 809 | return result; 810 | } 811 | 812 | // Transform a vector by quaternion rotation 813 | RMAPI Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q) 814 | { 815 | Vector3 result = { 0 }; 816 | 817 | result.x = v.x*(q.x*q.x + q.w*q.w - q.y*q.y - q.z*q.z) + v.y*(2*q.x*q.y - 2*q.w*q.z) + v.z*(2*q.x*q.z + 2*q.w*q.y); 818 | result.y = v.x*(2*q.w*q.z + 2*q.x*q.y) + v.y*(q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z) + v.z*(-2*q.w*q.x + 2*q.y*q.z); 819 | result.z = v.x*(-2*q.w*q.y + 2*q.x*q.z) + v.y*(2*q.w*q.x + 2*q.y*q.z)+ v.z*(q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z); 820 | 821 | return result; 822 | } 823 | 824 | // Rotates a vector around an axis 825 | RMAPI Vector3 Vector3RotateByAxisAngle(Vector3 v, Vector3 axis, float angle) 826 | { 827 | // Using Euler-Rodrigues Formula 828 | // Ref.: https://en.wikipedia.org/w/index.php?title=Euler%E2%80%93Rodrigues_formula 829 | 830 | Vector3 result = v; 831 | 832 | // Vector3Normalize(axis); 833 | float length = sqrtf(axis.x*axis.x + axis.y*axis.y + axis.z*axis.z); 834 | if (length == 0.0f) length = 1.0f; 835 | float ilength = 1.0f / length; 836 | axis.x *= ilength; 837 | axis.y *= ilength; 838 | axis.z *= ilength; 839 | 840 | angle /= 2.0f; 841 | float a = sinf(angle); 842 | float b = axis.x*a; 843 | float c = axis.y*a; 844 | float d = axis.z*a; 845 | a = cosf(angle); 846 | Vector3 w = { b, c, d }; 847 | 848 | // Vector3CrossProduct(w, v) 849 | Vector3 wv = { w.y*v.z - w.z*v.y, w.z*v.x - w.x*v.z, w.x*v.y - w.y*v.x }; 850 | 851 | // Vector3CrossProduct(w, wv) 852 | Vector3 wwv = { w.y*wv.z - w.z*wv.y, w.z*wv.x - w.x*wv.z, w.x*wv.y - w.y*wv.x }; 853 | 854 | // Vector3Scale(wv, 2*a) 855 | a *= 2; 856 | wv.x *= a; 857 | wv.y *= a; 858 | wv.z *= a; 859 | 860 | // Vector3Scale(wwv, 2) 861 | wwv.x *= 2; 862 | wwv.y *= 2; 863 | wwv.z *= 2; 864 | 865 | result.x += wv.x; 866 | result.y += wv.y; 867 | result.z += wv.z; 868 | 869 | result.x += wwv.x; 870 | result.y += wwv.y; 871 | result.z += wwv.z; 872 | 873 | return result; 874 | } 875 | 876 | // Calculate linear interpolation between two vectors 877 | RMAPI Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount) 878 | { 879 | Vector3 result = { 0 }; 880 | 881 | result.x = v1.x + amount*(v2.x - v1.x); 882 | result.y = v1.y + amount*(v2.y - v1.y); 883 | result.z = v1.z + amount*(v2.z - v1.z); 884 | 885 | return result; 886 | } 887 | 888 | // Calculate reflected vector to normal 889 | RMAPI Vector3 Vector3Reflect(Vector3 v, Vector3 normal) 890 | { 891 | Vector3 result = { 0 }; 892 | 893 | // I is the original vector 894 | // N is the normal of the incident plane 895 | // R = I - (2*N*(DotProduct[I, N])) 896 | 897 | float dotProduct = (v.x*normal.x + v.y*normal.y + v.z*normal.z); 898 | 899 | result.x = v.x - (2.0f*normal.x)*dotProduct; 900 | result.y = v.y - (2.0f*normal.y)*dotProduct; 901 | result.z = v.z - (2.0f*normal.z)*dotProduct; 902 | 903 | return result; 904 | } 905 | 906 | // Get min value for each pair of components 907 | RMAPI Vector3 Vector3Min(Vector3 v1, Vector3 v2) 908 | { 909 | Vector3 result = { 0 }; 910 | 911 | result.x = fminf(v1.x, v2.x); 912 | result.y = fminf(v1.y, v2.y); 913 | result.z = fminf(v1.z, v2.z); 914 | 915 | return result; 916 | } 917 | 918 | // Get max value for each pair of components 919 | RMAPI Vector3 Vector3Max(Vector3 v1, Vector3 v2) 920 | { 921 | Vector3 result = { 0 }; 922 | 923 | result.x = fmaxf(v1.x, v2.x); 924 | result.y = fmaxf(v1.y, v2.y); 925 | result.z = fmaxf(v1.z, v2.z); 926 | 927 | return result; 928 | } 929 | 930 | // Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c) 931 | // NOTE: Assumes P is on the plane of the triangle 932 | RMAPI Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c) 933 | { 934 | Vector3 result = { 0 }; 935 | 936 | Vector3 v0 = { b.x - a.x, b.y - a.y, b.z - a.z }; // Vector3Subtract(b, a) 937 | Vector3 v1 = { c.x - a.x, c.y - a.y, c.z - a.z }; // Vector3Subtract(c, a) 938 | Vector3 v2 = { p.x - a.x, p.y - a.y, p.z - a.z }; // Vector3Subtract(p, a) 939 | float d00 = (v0.x*v0.x + v0.y*v0.y + v0.z*v0.z); // Vector3DotProduct(v0, v0) 940 | float d01 = (v0.x*v1.x + v0.y*v1.y + v0.z*v1.z); // Vector3DotProduct(v0, v1) 941 | float d11 = (v1.x*v1.x + v1.y*v1.y + v1.z*v1.z); // Vector3DotProduct(v1, v1) 942 | float d20 = (v2.x*v0.x + v2.y*v0.y + v2.z*v0.z); // Vector3DotProduct(v2, v0) 943 | float d21 = (v2.x*v1.x + v2.y*v1.y + v2.z*v1.z); // Vector3DotProduct(v2, v1) 944 | 945 | float denom = d00*d11 - d01*d01; 946 | 947 | result.y = (d11*d20 - d01*d21)/denom; 948 | result.z = (d00*d21 - d01*d20)/denom; 949 | result.x = 1.0f - (result.z + result.y); 950 | 951 | return result; 952 | } 953 | 954 | // Projects a Vector3 from screen space into object space 955 | // NOTE: We are avoiding calling other raymath functions despite available 956 | RMAPI Vector3 Vector3Unproject(Vector3 source, Matrix projection, Matrix view) 957 | { 958 | Vector3 result = { 0 }; 959 | 960 | // Calculate unprojected matrix (multiply view matrix by projection matrix) and invert it 961 | Matrix matViewProj = { // MatrixMultiply(view, projection); 962 | view.m0*projection.m0 + view.m1*projection.m4 + view.m2*projection.m8 + view.m3*projection.m12, 963 | view.m0*projection.m1 + view.m1*projection.m5 + view.m2*projection.m9 + view.m3*projection.m13, 964 | view.m0*projection.m2 + view.m1*projection.m6 + view.m2*projection.m10 + view.m3*projection.m14, 965 | view.m0*projection.m3 + view.m1*projection.m7 + view.m2*projection.m11 + view.m3*projection.m15, 966 | view.m4*projection.m0 + view.m5*projection.m4 + view.m6*projection.m8 + view.m7*projection.m12, 967 | view.m4*projection.m1 + view.m5*projection.m5 + view.m6*projection.m9 + view.m7*projection.m13, 968 | view.m4*projection.m2 + view.m5*projection.m6 + view.m6*projection.m10 + view.m7*projection.m14, 969 | view.m4*projection.m3 + view.m5*projection.m7 + view.m6*projection.m11 + view.m7*projection.m15, 970 | view.m8*projection.m0 + view.m9*projection.m4 + view.m10*projection.m8 + view.m11*projection.m12, 971 | view.m8*projection.m1 + view.m9*projection.m5 + view.m10*projection.m9 + view.m11*projection.m13, 972 | view.m8*projection.m2 + view.m9*projection.m6 + view.m10*projection.m10 + view.m11*projection.m14, 973 | view.m8*projection.m3 + view.m9*projection.m7 + view.m10*projection.m11 + view.m11*projection.m15, 974 | view.m12*projection.m0 + view.m13*projection.m4 + view.m14*projection.m8 + view.m15*projection.m12, 975 | view.m12*projection.m1 + view.m13*projection.m5 + view.m14*projection.m9 + view.m15*projection.m13, 976 | view.m12*projection.m2 + view.m13*projection.m6 + view.m14*projection.m10 + view.m15*projection.m14, 977 | view.m12*projection.m3 + view.m13*projection.m7 + view.m14*projection.m11 + view.m15*projection.m15 }; 978 | 979 | // Calculate inverted matrix -> MatrixInvert(matViewProj); 980 | // Cache the matrix values (speed optimization) 981 | float a00 = matViewProj.m0, a01 = matViewProj.m1, a02 = matViewProj.m2, a03 = matViewProj.m3; 982 | float a10 = matViewProj.m4, a11 = matViewProj.m5, a12 = matViewProj.m6, a13 = matViewProj.m7; 983 | float a20 = matViewProj.m8, a21 = matViewProj.m9, a22 = matViewProj.m10, a23 = matViewProj.m11; 984 | float a30 = matViewProj.m12, a31 = matViewProj.m13, a32 = matViewProj.m14, a33 = matViewProj.m15; 985 | 986 | float b00 = a00*a11 - a01*a10; 987 | float b01 = a00*a12 - a02*a10; 988 | float b02 = a00*a13 - a03*a10; 989 | float b03 = a01*a12 - a02*a11; 990 | float b04 = a01*a13 - a03*a11; 991 | float b05 = a02*a13 - a03*a12; 992 | float b06 = a20*a31 - a21*a30; 993 | float b07 = a20*a32 - a22*a30; 994 | float b08 = a20*a33 - a23*a30; 995 | float b09 = a21*a32 - a22*a31; 996 | float b10 = a21*a33 - a23*a31; 997 | float b11 = a22*a33 - a23*a32; 998 | 999 | // Calculate the invert determinant (inlined to avoid double-caching) 1000 | float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); 1001 | 1002 | Matrix matViewProjInv = { 1003 | (a11*b11 - a12*b10 + a13*b09)*invDet, 1004 | (-a01*b11 + a02*b10 - a03*b09)*invDet, 1005 | (a31*b05 - a32*b04 + a33*b03)*invDet, 1006 | (-a21*b05 + a22*b04 - a23*b03)*invDet, 1007 | (-a10*b11 + a12*b08 - a13*b07)*invDet, 1008 | (a00*b11 - a02*b08 + a03*b07)*invDet, 1009 | (-a30*b05 + a32*b02 - a33*b01)*invDet, 1010 | (a20*b05 - a22*b02 + a23*b01)*invDet, 1011 | (a10*b10 - a11*b08 + a13*b06)*invDet, 1012 | (-a00*b10 + a01*b08 - a03*b06)*invDet, 1013 | (a30*b04 - a31*b02 + a33*b00)*invDet, 1014 | (-a20*b04 + a21*b02 - a23*b00)*invDet, 1015 | (-a10*b09 + a11*b07 - a12*b06)*invDet, 1016 | (a00*b09 - a01*b07 + a02*b06)*invDet, 1017 | (-a30*b03 + a31*b01 - a32*b00)*invDet, 1018 | (a20*b03 - a21*b01 + a22*b00)*invDet }; 1019 | 1020 | // Create quaternion from source point 1021 | Quaternion quat = { source.x, source.y, source.z, 1.0f }; 1022 | 1023 | // Multiply quat point by unprojecte matrix 1024 | Quaternion qtransformed = { // QuaternionTransform(quat, matViewProjInv) 1025 | matViewProjInv.m0*quat.x + matViewProjInv.m4*quat.y + matViewProjInv.m8*quat.z + matViewProjInv.m12*quat.w, 1026 | matViewProjInv.m1*quat.x + matViewProjInv.m5*quat.y + matViewProjInv.m9*quat.z + matViewProjInv.m13*quat.w, 1027 | matViewProjInv.m2*quat.x + matViewProjInv.m6*quat.y + matViewProjInv.m10*quat.z + matViewProjInv.m14*quat.w, 1028 | matViewProjInv.m3*quat.x + matViewProjInv.m7*quat.y + matViewProjInv.m11*quat.z + matViewProjInv.m15*quat.w }; 1029 | 1030 | // Normalized world points in vectors 1031 | result.x = qtransformed.x/qtransformed.w; 1032 | result.y = qtransformed.y/qtransformed.w; 1033 | result.z = qtransformed.z/qtransformed.w; 1034 | 1035 | return result; 1036 | } 1037 | 1038 | // Get Vector3 as float array 1039 | RMAPI float3 Vector3ToFloatV(Vector3 v) 1040 | { 1041 | float3 buffer = { 0 }; 1042 | 1043 | buffer.v[0] = v.x; 1044 | buffer.v[1] = v.y; 1045 | buffer.v[2] = v.z; 1046 | 1047 | return buffer; 1048 | } 1049 | 1050 | // Invert the given vector 1051 | RMAPI Vector3 Vector3Invert(Vector3 v) 1052 | { 1053 | Vector3 result = { 1.0f/v.x, 1.0f/v.y, 1.0f/v.z }; 1054 | 1055 | return result; 1056 | } 1057 | 1058 | // Clamp the components of the vector between 1059 | // min and max values specified by the given vectors 1060 | RMAPI Vector3 Vector3Clamp(Vector3 v, Vector3 min, Vector3 max) 1061 | { 1062 | Vector3 result = { 0 }; 1063 | 1064 | result.x = fminf(max.x, fmaxf(min.x, v.x)); 1065 | result.y = fminf(max.y, fmaxf(min.y, v.y)); 1066 | result.z = fminf(max.z, fmaxf(min.z, v.z)); 1067 | 1068 | return result; 1069 | } 1070 | 1071 | // Clamp the magnitude of the vector between two values 1072 | RMAPI Vector3 Vector3ClampValue(Vector3 v, float min, float max) 1073 | { 1074 | Vector3 result = v; 1075 | 1076 | float length = (v.x*v.x) + (v.y*v.y) + (v.z*v.z); 1077 | if (length > 0.0f) 1078 | { 1079 | length = sqrtf(length); 1080 | 1081 | if (length < min) 1082 | { 1083 | float scale = min/length; 1084 | result.x = v.x*scale; 1085 | result.y = v.y*scale; 1086 | result.z = v.z*scale; 1087 | } 1088 | else if (length > max) 1089 | { 1090 | float scale = max/length; 1091 | result.x = v.x*scale; 1092 | result.y = v.y*scale; 1093 | result.z = v.z*scale; 1094 | } 1095 | } 1096 | 1097 | return result; 1098 | } 1099 | 1100 | // Check whether two given vectors are almost equal 1101 | RMAPI int Vector3Equals(Vector3 p, Vector3 q) 1102 | { 1103 | #if !defined(EPSILON) 1104 | #define EPSILON 0.000001f 1105 | #endif 1106 | 1107 | int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && 1108 | ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && 1109 | ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))); 1110 | 1111 | return result; 1112 | } 1113 | 1114 | // Compute the direction of a refracted ray 1115 | // v: normalized direction of the incoming ray 1116 | // n: normalized normal vector of the interface of two optical media 1117 | // r: ratio of the refractive index of the medium from where the ray comes 1118 | // to the refractive index of the medium on the other side of the surface 1119 | RMAPI Vector3 Vector3Refract(Vector3 v, Vector3 n, float r) 1120 | { 1121 | Vector3 result = { 0 }; 1122 | 1123 | float dot = v.x*n.x + v.y*n.y + v.z*n.z; 1124 | float d = 1.0f - r*r*(1.0f - dot*dot); 1125 | 1126 | if (d >= 0.0f) 1127 | { 1128 | d = sqrtf(d); 1129 | v.x = r*v.x - (r*dot + d)*n.x; 1130 | v.y = r*v.y - (r*dot + d)*n.y; 1131 | v.z = r*v.z - (r*dot + d)*n.z; 1132 | 1133 | result = v; 1134 | } 1135 | 1136 | return result; 1137 | } 1138 | 1139 | //---------------------------------------------------------------------------------- 1140 | // Module Functions Definition - Matrix math 1141 | //---------------------------------------------------------------------------------- 1142 | 1143 | // Compute matrix determinant 1144 | RMAPI float MatrixDeterminant(Matrix mat) 1145 | { 1146 | float result = 0.0f; 1147 | 1148 | // Cache the matrix values (speed optimization) 1149 | float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; 1150 | float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; 1151 | float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; 1152 | float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; 1153 | 1154 | result = a30*a21*a12*a03 - a20*a31*a12*a03 - a30*a11*a22*a03 + a10*a31*a22*a03 + 1155 | a20*a11*a32*a03 - a10*a21*a32*a03 - a30*a21*a02*a13 + a20*a31*a02*a13 + 1156 | a30*a01*a22*a13 - a00*a31*a22*a13 - a20*a01*a32*a13 + a00*a21*a32*a13 + 1157 | a30*a11*a02*a23 - a10*a31*a02*a23 - a30*a01*a12*a23 + a00*a31*a12*a23 + 1158 | a10*a01*a32*a23 - a00*a11*a32*a23 - a20*a11*a02*a33 + a10*a21*a02*a33 + 1159 | a20*a01*a12*a33 - a00*a21*a12*a33 - a10*a01*a22*a33 + a00*a11*a22*a33; 1160 | 1161 | return result; 1162 | } 1163 | 1164 | // Get the trace of the matrix (sum of the values along the diagonal) 1165 | RMAPI float MatrixTrace(Matrix mat) 1166 | { 1167 | float result = (mat.m0 + mat.m5 + mat.m10 + mat.m15); 1168 | 1169 | return result; 1170 | } 1171 | 1172 | // Transposes provided matrix 1173 | RMAPI Matrix MatrixTranspose(Matrix mat) 1174 | { 1175 | Matrix result = { 0 }; 1176 | 1177 | result.m0 = mat.m0; 1178 | result.m1 = mat.m4; 1179 | result.m2 = mat.m8; 1180 | result.m3 = mat.m12; 1181 | result.m4 = mat.m1; 1182 | result.m5 = mat.m5; 1183 | result.m6 = mat.m9; 1184 | result.m7 = mat.m13; 1185 | result.m8 = mat.m2; 1186 | result.m9 = mat.m6; 1187 | result.m10 = mat.m10; 1188 | result.m11 = mat.m14; 1189 | result.m12 = mat.m3; 1190 | result.m13 = mat.m7; 1191 | result.m14 = mat.m11; 1192 | result.m15 = mat.m15; 1193 | 1194 | return result; 1195 | } 1196 | 1197 | // Invert provided matrix 1198 | RMAPI Matrix MatrixInvert(Matrix mat) 1199 | { 1200 | Matrix result = { 0 }; 1201 | 1202 | // Cache the matrix values (speed optimization) 1203 | float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3; 1204 | float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7; 1205 | float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11; 1206 | float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15; 1207 | 1208 | float b00 = a00*a11 - a01*a10; 1209 | float b01 = a00*a12 - a02*a10; 1210 | float b02 = a00*a13 - a03*a10; 1211 | float b03 = a01*a12 - a02*a11; 1212 | float b04 = a01*a13 - a03*a11; 1213 | float b05 = a02*a13 - a03*a12; 1214 | float b06 = a20*a31 - a21*a30; 1215 | float b07 = a20*a32 - a22*a30; 1216 | float b08 = a20*a33 - a23*a30; 1217 | float b09 = a21*a32 - a22*a31; 1218 | float b10 = a21*a33 - a23*a31; 1219 | float b11 = a22*a33 - a23*a32; 1220 | 1221 | // Calculate the invert determinant (inlined to avoid double-caching) 1222 | float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06); 1223 | 1224 | result.m0 = (a11*b11 - a12*b10 + a13*b09)*invDet; 1225 | result.m1 = (-a01*b11 + a02*b10 - a03*b09)*invDet; 1226 | result.m2 = (a31*b05 - a32*b04 + a33*b03)*invDet; 1227 | result.m3 = (-a21*b05 + a22*b04 - a23*b03)*invDet; 1228 | result.m4 = (-a10*b11 + a12*b08 - a13*b07)*invDet; 1229 | result.m5 = (a00*b11 - a02*b08 + a03*b07)*invDet; 1230 | result.m6 = (-a30*b05 + a32*b02 - a33*b01)*invDet; 1231 | result.m7 = (a20*b05 - a22*b02 + a23*b01)*invDet; 1232 | result.m8 = (a10*b10 - a11*b08 + a13*b06)*invDet; 1233 | result.m9 = (-a00*b10 + a01*b08 - a03*b06)*invDet; 1234 | result.m10 = (a30*b04 - a31*b02 + a33*b00)*invDet; 1235 | result.m11 = (-a20*b04 + a21*b02 - a23*b00)*invDet; 1236 | result.m12 = (-a10*b09 + a11*b07 - a12*b06)*invDet; 1237 | result.m13 = (a00*b09 - a01*b07 + a02*b06)*invDet; 1238 | result.m14 = (-a30*b03 + a31*b01 - a32*b00)*invDet; 1239 | result.m15 = (a20*b03 - a21*b01 + a22*b00)*invDet; 1240 | 1241 | return result; 1242 | } 1243 | 1244 | // Get identity matrix 1245 | RMAPI Matrix MatrixIdentity(void) 1246 | { 1247 | Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 1248 | 0.0f, 1.0f, 0.0f, 0.0f, 1249 | 0.0f, 0.0f, 1.0f, 0.0f, 1250 | 0.0f, 0.0f, 0.0f, 1.0f }; 1251 | 1252 | return result; 1253 | } 1254 | 1255 | // Add two matrices 1256 | RMAPI Matrix MatrixAdd(Matrix left, Matrix right) 1257 | { 1258 | Matrix result = { 0 }; 1259 | 1260 | result.m0 = left.m0 + right.m0; 1261 | result.m1 = left.m1 + right.m1; 1262 | result.m2 = left.m2 + right.m2; 1263 | result.m3 = left.m3 + right.m3; 1264 | result.m4 = left.m4 + right.m4; 1265 | result.m5 = left.m5 + right.m5; 1266 | result.m6 = left.m6 + right.m6; 1267 | result.m7 = left.m7 + right.m7; 1268 | result.m8 = left.m8 + right.m8; 1269 | result.m9 = left.m9 + right.m9; 1270 | result.m10 = left.m10 + right.m10; 1271 | result.m11 = left.m11 + right.m11; 1272 | result.m12 = left.m12 + right.m12; 1273 | result.m13 = left.m13 + right.m13; 1274 | result.m14 = left.m14 + right.m14; 1275 | result.m15 = left.m15 + right.m15; 1276 | 1277 | return result; 1278 | } 1279 | 1280 | // Subtract two matrices (left - right) 1281 | RMAPI Matrix MatrixSubtract(Matrix left, Matrix right) 1282 | { 1283 | Matrix result = { 0 }; 1284 | 1285 | result.m0 = left.m0 - right.m0; 1286 | result.m1 = left.m1 - right.m1; 1287 | result.m2 = left.m2 - right.m2; 1288 | result.m3 = left.m3 - right.m3; 1289 | result.m4 = left.m4 - right.m4; 1290 | result.m5 = left.m5 - right.m5; 1291 | result.m6 = left.m6 - right.m6; 1292 | result.m7 = left.m7 - right.m7; 1293 | result.m8 = left.m8 - right.m8; 1294 | result.m9 = left.m9 - right.m9; 1295 | result.m10 = left.m10 - right.m10; 1296 | result.m11 = left.m11 - right.m11; 1297 | result.m12 = left.m12 - right.m12; 1298 | result.m13 = left.m13 - right.m13; 1299 | result.m14 = left.m14 - right.m14; 1300 | result.m15 = left.m15 - right.m15; 1301 | 1302 | return result; 1303 | } 1304 | 1305 | // Get two matrix multiplication 1306 | // NOTE: When multiplying matrices... the order matters! 1307 | RMAPI Matrix MatrixMultiply(Matrix left, Matrix right) 1308 | { 1309 | Matrix result = { 0 }; 1310 | 1311 | result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12; 1312 | result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13; 1313 | result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14; 1314 | result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15; 1315 | result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12; 1316 | result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13; 1317 | result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14; 1318 | result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15; 1319 | result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12; 1320 | result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13; 1321 | result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14; 1322 | result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15; 1323 | result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12; 1324 | result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13; 1325 | result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14; 1326 | result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15; 1327 | 1328 | return result; 1329 | } 1330 | 1331 | // Get translation matrix 1332 | RMAPI Matrix MatrixTranslate(float x, float y, float z) 1333 | { 1334 | Matrix result = { 1.0f, 0.0f, 0.0f, x, 1335 | 0.0f, 1.0f, 0.0f, y, 1336 | 0.0f, 0.0f, 1.0f, z, 1337 | 0.0f, 0.0f, 0.0f, 1.0f }; 1338 | 1339 | return result; 1340 | } 1341 | 1342 | // Create rotation matrix from axis and angle 1343 | // NOTE: Angle should be provided in radians 1344 | RMAPI Matrix MatrixRotate(Vector3 axis, float angle) 1345 | { 1346 | Matrix result = { 0 }; 1347 | 1348 | float x = axis.x, y = axis.y, z = axis.z; 1349 | 1350 | float lengthSquared = x*x + y*y + z*z; 1351 | 1352 | if ((lengthSquared != 1.0f) && (lengthSquared != 0.0f)) 1353 | { 1354 | float ilength = 1.0f/sqrtf(lengthSquared); 1355 | x *= ilength; 1356 | y *= ilength; 1357 | z *= ilength; 1358 | } 1359 | 1360 | float sinres = sinf(angle); 1361 | float cosres = cosf(angle); 1362 | float t = 1.0f - cosres; 1363 | 1364 | result.m0 = x*x*t + cosres; 1365 | result.m1 = y*x*t + z*sinres; 1366 | result.m2 = z*x*t - y*sinres; 1367 | result.m3 = 0.0f; 1368 | 1369 | result.m4 = x*y*t - z*sinres; 1370 | result.m5 = y*y*t + cosres; 1371 | result.m6 = z*y*t + x*sinres; 1372 | result.m7 = 0.0f; 1373 | 1374 | result.m8 = x*z*t + y*sinres; 1375 | result.m9 = y*z*t - x*sinres; 1376 | result.m10 = z*z*t + cosres; 1377 | result.m11 = 0.0f; 1378 | 1379 | result.m12 = 0.0f; 1380 | result.m13 = 0.0f; 1381 | result.m14 = 0.0f; 1382 | result.m15 = 1.0f; 1383 | 1384 | return result; 1385 | } 1386 | 1387 | // Get x-rotation matrix 1388 | // NOTE: Angle must be provided in radians 1389 | RMAPI Matrix MatrixRotateX(float angle) 1390 | { 1391 | Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 1392 | 0.0f, 1.0f, 0.0f, 0.0f, 1393 | 0.0f, 0.0f, 1.0f, 0.0f, 1394 | 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() 1395 | 1396 | float cosres = cosf(angle); 1397 | float sinres = sinf(angle); 1398 | 1399 | result.m5 = cosres; 1400 | result.m6 = sinres; 1401 | result.m9 = -sinres; 1402 | result.m10 = cosres; 1403 | 1404 | return result; 1405 | } 1406 | 1407 | // Get y-rotation matrix 1408 | // NOTE: Angle must be provided in radians 1409 | RMAPI Matrix MatrixRotateY(float angle) 1410 | { 1411 | Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 1412 | 0.0f, 1.0f, 0.0f, 0.0f, 1413 | 0.0f, 0.0f, 1.0f, 0.0f, 1414 | 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() 1415 | 1416 | float cosres = cosf(angle); 1417 | float sinres = sinf(angle); 1418 | 1419 | result.m0 = cosres; 1420 | result.m2 = -sinres; 1421 | result.m8 = sinres; 1422 | result.m10 = cosres; 1423 | 1424 | return result; 1425 | } 1426 | 1427 | // Get z-rotation matrix 1428 | // NOTE: Angle must be provided in radians 1429 | RMAPI Matrix MatrixRotateZ(float angle) 1430 | { 1431 | Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 1432 | 0.0f, 1.0f, 0.0f, 0.0f, 1433 | 0.0f, 0.0f, 1.0f, 0.0f, 1434 | 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() 1435 | 1436 | float cosres = cosf(angle); 1437 | float sinres = sinf(angle); 1438 | 1439 | result.m0 = cosres; 1440 | result.m1 = sinres; 1441 | result.m4 = -sinres; 1442 | result.m5 = cosres; 1443 | 1444 | return result; 1445 | } 1446 | 1447 | 1448 | // Get xyz-rotation matrix 1449 | // NOTE: Angle must be provided in radians 1450 | RMAPI Matrix MatrixRotateXYZ(Vector3 angle) 1451 | { 1452 | Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 1453 | 0.0f, 1.0f, 0.0f, 0.0f, 1454 | 0.0f, 0.0f, 1.0f, 0.0f, 1455 | 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() 1456 | 1457 | float cosz = cosf(-angle.z); 1458 | float sinz = sinf(-angle.z); 1459 | float cosy = cosf(-angle.y); 1460 | float siny = sinf(-angle.y); 1461 | float cosx = cosf(-angle.x); 1462 | float sinx = sinf(-angle.x); 1463 | 1464 | result.m0 = cosz*cosy; 1465 | result.m1 = (cosz*siny*sinx) - (sinz*cosx); 1466 | result.m2 = (cosz*siny*cosx) + (sinz*sinx); 1467 | 1468 | result.m4 = sinz*cosy; 1469 | result.m5 = (sinz*siny*sinx) + (cosz*cosx); 1470 | result.m6 = (sinz*siny*cosx) - (cosz*sinx); 1471 | 1472 | result.m8 = -siny; 1473 | result.m9 = cosy*sinx; 1474 | result.m10= cosy*cosx; 1475 | 1476 | return result; 1477 | } 1478 | 1479 | // Get zyx-rotation matrix 1480 | // NOTE: Angle must be provided in radians 1481 | RMAPI Matrix MatrixRotateZYX(Vector3 angle) 1482 | { 1483 | Matrix result = { 0 }; 1484 | 1485 | float cz = cosf(angle.z); 1486 | float sz = sinf(angle.z); 1487 | float cy = cosf(angle.y); 1488 | float sy = sinf(angle.y); 1489 | float cx = cosf(angle.x); 1490 | float sx = sinf(angle.x); 1491 | 1492 | result.m0 = cz*cy; 1493 | result.m4 = cz*sy*sx - cx*sz; 1494 | result.m8 = sz*sx + cz*cx*sy; 1495 | result.m12 = 0; 1496 | 1497 | result.m1 = cy*sz; 1498 | result.m5 = cz*cx + sz*sy*sx; 1499 | result.m9 = cx*sz*sy - cz*sx; 1500 | result.m13 = 0; 1501 | 1502 | result.m2 = -sy; 1503 | result.m6 = cy*sx; 1504 | result.m10 = cy*cx; 1505 | result.m14 = 0; 1506 | 1507 | result.m3 = 0; 1508 | result.m7 = 0; 1509 | result.m11 = 0; 1510 | result.m15 = 1; 1511 | 1512 | return result; 1513 | } 1514 | 1515 | // Get scaling matrix 1516 | RMAPI Matrix MatrixScale(float x, float y, float z) 1517 | { 1518 | Matrix result = { x, 0.0f, 0.0f, 0.0f, 1519 | 0.0f, y, 0.0f, 0.0f, 1520 | 0.0f, 0.0f, z, 0.0f, 1521 | 0.0f, 0.0f, 0.0f, 1.0f }; 1522 | 1523 | return result; 1524 | } 1525 | 1526 | // Get perspective projection matrix 1527 | RMAPI Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far) 1528 | { 1529 | Matrix result = { 0 }; 1530 | 1531 | float rl = (float)(right - left); 1532 | float tb = (float)(top - bottom); 1533 | float fn = (float)(far - near); 1534 | 1535 | result.m0 = ((float)near*2.0f)/rl; 1536 | result.m1 = 0.0f; 1537 | result.m2 = 0.0f; 1538 | result.m3 = 0.0f; 1539 | 1540 | result.m4 = 0.0f; 1541 | result.m5 = ((float)near*2.0f)/tb; 1542 | result.m6 = 0.0f; 1543 | result.m7 = 0.0f; 1544 | 1545 | result.m8 = ((float)right + (float)left)/rl; 1546 | result.m9 = ((float)top + (float)bottom)/tb; 1547 | result.m10 = -((float)far + (float)near)/fn; 1548 | result.m11 = -1.0f; 1549 | 1550 | result.m12 = 0.0f; 1551 | result.m13 = 0.0f; 1552 | result.m14 = -((float)far*(float)near*2.0f)/fn; 1553 | result.m15 = 0.0f; 1554 | 1555 | return result; 1556 | } 1557 | 1558 | // Get perspective projection matrix 1559 | // NOTE: Fovy angle must be provided in radians 1560 | RMAPI Matrix MatrixPerspective(double fovY, double aspect, double nearPlane, double farPlane) 1561 | { 1562 | Matrix result = { 0 }; 1563 | 1564 | double top = nearPlane*tan(fovY*0.5); 1565 | double bottom = -top; 1566 | double right = top*aspect; 1567 | double left = -right; 1568 | 1569 | // MatrixFrustum(-right, right, -top, top, near, far); 1570 | float rl = (float)(right - left); 1571 | float tb = (float)(top - bottom); 1572 | float fn = (float)(farPlane - nearPlane); 1573 | 1574 | result.m0 = ((float)nearPlane*2.0f)/rl; 1575 | result.m5 = ((float)nearPlane*2.0f)/tb; 1576 | result.m8 = ((float)right + (float)left)/rl; 1577 | result.m9 = ((float)top + (float)bottom)/tb; 1578 | result.m10 = -((float)farPlane + (float)nearPlane)/fn; 1579 | result.m11 = -1.0f; 1580 | result.m14 = -((float)farPlane*(float)nearPlane*2.0f)/fn; 1581 | 1582 | return result; 1583 | } 1584 | 1585 | // Get orthographic projection matrix 1586 | RMAPI Matrix MatrixOrtho(double left, double right, double bottom, double top, double nearPlane, double farPlane) 1587 | { 1588 | Matrix result = { 0 }; 1589 | 1590 | float rl = (float)(right - left); 1591 | float tb = (float)(top - bottom); 1592 | float fn = (float)(farPlane - nearPlane); 1593 | 1594 | result.m0 = 2.0f/rl; 1595 | result.m1 = 0.0f; 1596 | result.m2 = 0.0f; 1597 | result.m3 = 0.0f; 1598 | result.m4 = 0.0f; 1599 | result.m5 = 2.0f/tb; 1600 | result.m6 = 0.0f; 1601 | result.m7 = 0.0f; 1602 | result.m8 = 0.0f; 1603 | result.m9 = 0.0f; 1604 | result.m10 = -2.0f/fn; 1605 | result.m11 = 0.0f; 1606 | result.m12 = -((float)left + (float)right)/rl; 1607 | result.m13 = -((float)top + (float)bottom)/tb; 1608 | result.m14 = -((float)farPlane + (float)nearPlane)/fn; 1609 | result.m15 = 1.0f; 1610 | 1611 | return result; 1612 | } 1613 | 1614 | // Get camera look-at matrix (view matrix) 1615 | RMAPI Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up) 1616 | { 1617 | Matrix result = { 0 }; 1618 | 1619 | float length = 0.0f; 1620 | float ilength = 0.0f; 1621 | 1622 | // Vector3Subtract(eye, target) 1623 | Vector3 vz = { eye.x - target.x, eye.y - target.y, eye.z - target.z }; 1624 | 1625 | // Vector3Normalize(vz) 1626 | Vector3 v = vz; 1627 | length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); 1628 | if (length == 0.0f) length = 1.0f; 1629 | ilength = 1.0f/length; 1630 | vz.x *= ilength; 1631 | vz.y *= ilength; 1632 | vz.z *= ilength; 1633 | 1634 | // Vector3CrossProduct(up, vz) 1635 | Vector3 vx = { up.y*vz.z - up.z*vz.y, up.z*vz.x - up.x*vz.z, up.x*vz.y - up.y*vz.x }; 1636 | 1637 | // Vector3Normalize(x) 1638 | v = vx; 1639 | length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); 1640 | if (length == 0.0f) length = 1.0f; 1641 | ilength = 1.0f/length; 1642 | vx.x *= ilength; 1643 | vx.y *= ilength; 1644 | vx.z *= ilength; 1645 | 1646 | // Vector3CrossProduct(vz, vx) 1647 | Vector3 vy = { vz.y*vx.z - vz.z*vx.y, vz.z*vx.x - vz.x*vx.z, vz.x*vx.y - vz.y*vx.x }; 1648 | 1649 | result.m0 = vx.x; 1650 | result.m1 = vy.x; 1651 | result.m2 = vz.x; 1652 | result.m3 = 0.0f; 1653 | result.m4 = vx.y; 1654 | result.m5 = vy.y; 1655 | result.m6 = vz.y; 1656 | result.m7 = 0.0f; 1657 | result.m8 = vx.z; 1658 | result.m9 = vy.z; 1659 | result.m10 = vz.z; 1660 | result.m11 = 0.0f; 1661 | result.m12 = -(vx.x*eye.x + vx.y*eye.y + vx.z*eye.z); // Vector3DotProduct(vx, eye) 1662 | result.m13 = -(vy.x*eye.x + vy.y*eye.y + vy.z*eye.z); // Vector3DotProduct(vy, eye) 1663 | result.m14 = -(vz.x*eye.x + vz.y*eye.y + vz.z*eye.z); // Vector3DotProduct(vz, eye) 1664 | result.m15 = 1.0f; 1665 | 1666 | return result; 1667 | } 1668 | 1669 | // Get float array of matrix data 1670 | RMAPI float16 MatrixToFloatV(Matrix mat) 1671 | { 1672 | float16 result = { 0 }; 1673 | 1674 | result.v[0] = mat.m0; 1675 | result.v[1] = mat.m1; 1676 | result.v[2] = mat.m2; 1677 | result.v[3] = mat.m3; 1678 | result.v[4] = mat.m4; 1679 | result.v[5] = mat.m5; 1680 | result.v[6] = mat.m6; 1681 | result.v[7] = mat.m7; 1682 | result.v[8] = mat.m8; 1683 | result.v[9] = mat.m9; 1684 | result.v[10] = mat.m10; 1685 | result.v[11] = mat.m11; 1686 | result.v[12] = mat.m12; 1687 | result.v[13] = mat.m13; 1688 | result.v[14] = mat.m14; 1689 | result.v[15] = mat.m15; 1690 | 1691 | return result; 1692 | } 1693 | 1694 | //---------------------------------------------------------------------------------- 1695 | // Module Functions Definition - Quaternion math 1696 | //---------------------------------------------------------------------------------- 1697 | 1698 | // Add two quaternions 1699 | RMAPI Quaternion QuaternionAdd(Quaternion q1, Quaternion q2) 1700 | { 1701 | Quaternion result = {q1.x + q2.x, q1.y + q2.y, q1.z + q2.z, q1.w + q2.w}; 1702 | 1703 | return result; 1704 | } 1705 | 1706 | // Add quaternion and float value 1707 | RMAPI Quaternion QuaternionAddValue(Quaternion q, float add) 1708 | { 1709 | Quaternion result = {q.x + add, q.y + add, q.z + add, q.w + add}; 1710 | 1711 | return result; 1712 | } 1713 | 1714 | // Subtract two quaternions 1715 | RMAPI Quaternion QuaternionSubtract(Quaternion q1, Quaternion q2) 1716 | { 1717 | Quaternion result = {q1.x - q2.x, q1.y - q2.y, q1.z - q2.z, q1.w - q2.w}; 1718 | 1719 | return result; 1720 | } 1721 | 1722 | // Subtract quaternion and float value 1723 | RMAPI Quaternion QuaternionSubtractValue(Quaternion q, float sub) 1724 | { 1725 | Quaternion result = {q.x - sub, q.y - sub, q.z - sub, q.w - sub}; 1726 | 1727 | return result; 1728 | } 1729 | 1730 | // Get identity quaternion 1731 | RMAPI Quaternion QuaternionIdentity(void) 1732 | { 1733 | Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; 1734 | 1735 | return result; 1736 | } 1737 | 1738 | // Computes the length of a quaternion 1739 | RMAPI float QuaternionLength(Quaternion q) 1740 | { 1741 | float result = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); 1742 | 1743 | return result; 1744 | } 1745 | 1746 | // Normalize provided quaternion 1747 | RMAPI Quaternion QuaternionNormalize(Quaternion q) 1748 | { 1749 | Quaternion result = { 0 }; 1750 | 1751 | float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); 1752 | if (length == 0.0f) length = 1.0f; 1753 | float ilength = 1.0f/length; 1754 | 1755 | result.x = q.x*ilength; 1756 | result.y = q.y*ilength; 1757 | result.z = q.z*ilength; 1758 | result.w = q.w*ilength; 1759 | 1760 | return result; 1761 | } 1762 | 1763 | // Invert provided quaternion 1764 | RMAPI Quaternion QuaternionInvert(Quaternion q) 1765 | { 1766 | Quaternion result = q; 1767 | 1768 | float lengthSq = q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w; 1769 | 1770 | if (lengthSq != 0.0f) 1771 | { 1772 | float invLength = 1.0f/lengthSq; 1773 | 1774 | result.x *= -invLength; 1775 | result.y *= -invLength; 1776 | result.z *= -invLength; 1777 | result.w *= invLength; 1778 | } 1779 | 1780 | return result; 1781 | } 1782 | 1783 | // Calculate two quaternion multiplication 1784 | RMAPI Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2) 1785 | { 1786 | Quaternion result = { 0 }; 1787 | 1788 | float qax = q1.x, qay = q1.y, qaz = q1.z, qaw = q1.w; 1789 | float qbx = q2.x, qby = q2.y, qbz = q2.z, qbw = q2.w; 1790 | 1791 | result.x = qax*qbw + qaw*qbx + qay*qbz - qaz*qby; 1792 | result.y = qay*qbw + qaw*qby + qaz*qbx - qax*qbz; 1793 | result.z = qaz*qbw + qaw*qbz + qax*qby - qay*qbx; 1794 | result.w = qaw*qbw - qax*qbx - qay*qby - qaz*qbz; 1795 | 1796 | return result; 1797 | } 1798 | 1799 | // Scale quaternion by float value 1800 | RMAPI Quaternion QuaternionScale(Quaternion q, float mul) 1801 | { 1802 | Quaternion result = { 0 }; 1803 | 1804 | result.x = q.x*mul; 1805 | result.y = q.y*mul; 1806 | result.z = q.z*mul; 1807 | result.w = q.w*mul; 1808 | 1809 | return result; 1810 | } 1811 | 1812 | // Divide two quaternions 1813 | RMAPI Quaternion QuaternionDivide(Quaternion q1, Quaternion q2) 1814 | { 1815 | Quaternion result = { q1.x/q2.x, q1.y/q2.y, q1.z/q2.z, q1.w/q2.w }; 1816 | 1817 | return result; 1818 | } 1819 | 1820 | // Calculate linear interpolation between two quaternions 1821 | RMAPI Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount) 1822 | { 1823 | Quaternion result = { 0 }; 1824 | 1825 | result.x = q1.x + amount*(q2.x - q1.x); 1826 | result.y = q1.y + amount*(q2.y - q1.y); 1827 | result.z = q1.z + amount*(q2.z - q1.z); 1828 | result.w = q1.w + amount*(q2.w - q1.w); 1829 | 1830 | return result; 1831 | } 1832 | 1833 | // Calculate slerp-optimized interpolation between two quaternions 1834 | RMAPI Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount) 1835 | { 1836 | Quaternion result = { 0 }; 1837 | 1838 | // QuaternionLerp(q1, q2, amount) 1839 | result.x = q1.x + amount*(q2.x - q1.x); 1840 | result.y = q1.y + amount*(q2.y - q1.y); 1841 | result.z = q1.z + amount*(q2.z - q1.z); 1842 | result.w = q1.w + amount*(q2.w - q1.w); 1843 | 1844 | // QuaternionNormalize(q); 1845 | Quaternion q = result; 1846 | float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); 1847 | if (length == 0.0f) length = 1.0f; 1848 | float ilength = 1.0f/length; 1849 | 1850 | result.x = q.x*ilength; 1851 | result.y = q.y*ilength; 1852 | result.z = q.z*ilength; 1853 | result.w = q.w*ilength; 1854 | 1855 | return result; 1856 | } 1857 | 1858 | // Calculates spherical linear interpolation between two quaternions 1859 | RMAPI Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount) 1860 | { 1861 | Quaternion result = { 0 }; 1862 | 1863 | #if !defined(EPSILON) 1864 | #define EPSILON 0.000001f 1865 | #endif 1866 | 1867 | float cosHalfTheta = q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w; 1868 | 1869 | if (cosHalfTheta < 0) 1870 | { 1871 | q2.x = -q2.x; q2.y = -q2.y; q2.z = -q2.z; q2.w = -q2.w; 1872 | cosHalfTheta = -cosHalfTheta; 1873 | } 1874 | 1875 | if (fabsf(cosHalfTheta) >= 1.0f) result = q1; 1876 | else if (cosHalfTheta > 0.95f) result = QuaternionNlerp(q1, q2, amount); 1877 | else 1878 | { 1879 | float halfTheta = acosf(cosHalfTheta); 1880 | float sinHalfTheta = sqrtf(1.0f - cosHalfTheta*cosHalfTheta); 1881 | 1882 | if (fabsf(sinHalfTheta) < EPSILON) 1883 | { 1884 | result.x = (q1.x*0.5f + q2.x*0.5f); 1885 | result.y = (q1.y*0.5f + q2.y*0.5f); 1886 | result.z = (q1.z*0.5f + q2.z*0.5f); 1887 | result.w = (q1.w*0.5f + q2.w*0.5f); 1888 | } 1889 | else 1890 | { 1891 | float ratioA = sinf((1 - amount)*halfTheta)/sinHalfTheta; 1892 | float ratioB = sinf(amount*halfTheta)/sinHalfTheta; 1893 | 1894 | result.x = (q1.x*ratioA + q2.x*ratioB); 1895 | result.y = (q1.y*ratioA + q2.y*ratioB); 1896 | result.z = (q1.z*ratioA + q2.z*ratioB); 1897 | result.w = (q1.w*ratioA + q2.w*ratioB); 1898 | } 1899 | } 1900 | 1901 | return result; 1902 | } 1903 | 1904 | // Calculate quaternion based on the rotation from one vector to another 1905 | RMAPI Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to) 1906 | { 1907 | Quaternion result = { 0 }; 1908 | 1909 | float cos2Theta = (from.x*to.x + from.y*to.y + from.z*to.z); // Vector3DotProduct(from, to) 1910 | Vector3 cross = { from.y*to.z - from.z*to.y, from.z*to.x - from.x*to.z, from.x*to.y - from.y*to.x }; // Vector3CrossProduct(from, to) 1911 | 1912 | result.x = cross.x; 1913 | result.y = cross.y; 1914 | result.z = cross.z; 1915 | result.w = 1.0f + cos2Theta; 1916 | 1917 | // QuaternionNormalize(q); 1918 | // NOTE: Normalize to essentially nlerp the original and identity to 0.5 1919 | Quaternion q = result; 1920 | float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); 1921 | if (length == 0.0f) length = 1.0f; 1922 | float ilength = 1.0f/length; 1923 | 1924 | result.x = q.x*ilength; 1925 | result.y = q.y*ilength; 1926 | result.z = q.z*ilength; 1927 | result.w = q.w*ilength; 1928 | 1929 | return result; 1930 | } 1931 | 1932 | // Get a quaternion for a given rotation matrix 1933 | RMAPI Quaternion QuaternionFromMatrix(Matrix mat) 1934 | { 1935 | Quaternion result = { 0 }; 1936 | 1937 | float fourWSquaredMinus1 = mat.m0 + mat.m5 + mat.m10; 1938 | float fourXSquaredMinus1 = mat.m0 - mat.m5 - mat.m10; 1939 | float fourYSquaredMinus1 = mat.m5 - mat.m0 - mat.m10; 1940 | float fourZSquaredMinus1 = mat.m10 - mat.m0 - mat.m5; 1941 | 1942 | int biggestIndex = 0; 1943 | float fourBiggestSquaredMinus1 = fourWSquaredMinus1; 1944 | if (fourXSquaredMinus1 > fourBiggestSquaredMinus1) 1945 | { 1946 | fourBiggestSquaredMinus1 = fourXSquaredMinus1; 1947 | biggestIndex = 1; 1948 | } 1949 | 1950 | if (fourYSquaredMinus1 > fourBiggestSquaredMinus1) 1951 | { 1952 | fourBiggestSquaredMinus1 = fourYSquaredMinus1; 1953 | biggestIndex = 2; 1954 | } 1955 | 1956 | if (fourZSquaredMinus1 > fourBiggestSquaredMinus1) 1957 | { 1958 | fourBiggestSquaredMinus1 = fourZSquaredMinus1; 1959 | biggestIndex = 3; 1960 | } 1961 | 1962 | float biggestVal = sqrtf(fourBiggestSquaredMinus1 + 1.0f)*0.5f; 1963 | float mult = 0.25f / biggestVal; 1964 | 1965 | switch (biggestIndex) 1966 | { 1967 | case 0: 1968 | result.w = biggestVal; 1969 | result.x = (mat.m6 - mat.m9)*mult; 1970 | result.y = (mat.m8 - mat.m2)*mult; 1971 | result.z = (mat.m1 - mat.m4)*mult; 1972 | break; 1973 | case 1: 1974 | result.x = biggestVal; 1975 | result.w = (mat.m6 - mat.m9)*mult; 1976 | result.y = (mat.m1 + mat.m4)*mult; 1977 | result.z = (mat.m8 + mat.m2)*mult; 1978 | break; 1979 | case 2: 1980 | result.y = biggestVal; 1981 | result.w = (mat.m8 - mat.m2)*mult; 1982 | result.x = (mat.m1 + mat.m4)*mult; 1983 | result.z = (mat.m6 + mat.m9)*mult; 1984 | break; 1985 | case 3: 1986 | result.z = biggestVal; 1987 | result.w = (mat.m1 - mat.m4)*mult; 1988 | result.x = (mat.m8 + mat.m2)*mult; 1989 | result.y = (mat.m6 + mat.m9)*mult; 1990 | break; 1991 | } 1992 | 1993 | return result; 1994 | } 1995 | 1996 | // Get a matrix for a given quaternion 1997 | RMAPI Matrix QuaternionToMatrix(Quaternion q) 1998 | { 1999 | Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f, 2000 | 0.0f, 1.0f, 0.0f, 0.0f, 2001 | 0.0f, 0.0f, 1.0f, 0.0f, 2002 | 0.0f, 0.0f, 0.0f, 1.0f }; // MatrixIdentity() 2003 | 2004 | float a2 = q.x*q.x; 2005 | float b2 = q.y*q.y; 2006 | float c2 = q.z*q.z; 2007 | float ac = q.x*q.z; 2008 | float ab = q.x*q.y; 2009 | float bc = q.y*q.z; 2010 | float ad = q.w*q.x; 2011 | float bd = q.w*q.y; 2012 | float cd = q.w*q.z; 2013 | 2014 | result.m0 = 1 - 2*(b2 + c2); 2015 | result.m1 = 2*(ab + cd); 2016 | result.m2 = 2*(ac - bd); 2017 | 2018 | result.m4 = 2*(ab - cd); 2019 | result.m5 = 1 - 2*(a2 + c2); 2020 | result.m6 = 2*(bc + ad); 2021 | 2022 | result.m8 = 2*(ac + bd); 2023 | result.m9 = 2*(bc - ad); 2024 | result.m10 = 1 - 2*(a2 + b2); 2025 | 2026 | return result; 2027 | } 2028 | 2029 | // Get rotation quaternion for an angle and axis 2030 | // NOTE: Angle must be provided in radians 2031 | RMAPI Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle) 2032 | { 2033 | Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f }; 2034 | 2035 | float axisLength = sqrtf(axis.x*axis.x + axis.y*axis.y + axis.z*axis.z); 2036 | 2037 | if (axisLength != 0.0f) 2038 | { 2039 | angle *= 0.5f; 2040 | 2041 | float length = 0.0f; 2042 | float ilength = 0.0f; 2043 | 2044 | // Vector3Normalize(axis) 2045 | Vector3 v = axis; 2046 | length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z); 2047 | if (length == 0.0f) length = 1.0f; 2048 | ilength = 1.0f/length; 2049 | axis.x *= ilength; 2050 | axis.y *= ilength; 2051 | axis.z *= ilength; 2052 | 2053 | float sinres = sinf(angle); 2054 | float cosres = cosf(angle); 2055 | 2056 | result.x = axis.x*sinres; 2057 | result.y = axis.y*sinres; 2058 | result.z = axis.z*sinres; 2059 | result.w = cosres; 2060 | 2061 | // QuaternionNormalize(q); 2062 | Quaternion q = result; 2063 | length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); 2064 | if (length == 0.0f) length = 1.0f; 2065 | ilength = 1.0f/length; 2066 | result.x = q.x*ilength; 2067 | result.y = q.y*ilength; 2068 | result.z = q.z*ilength; 2069 | result.w = q.w*ilength; 2070 | } 2071 | 2072 | return result; 2073 | } 2074 | 2075 | // Get the rotation angle and axis for a given quaternion 2076 | RMAPI void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle) 2077 | { 2078 | if (fabsf(q.w) > 1.0f) 2079 | { 2080 | // QuaternionNormalize(q); 2081 | float length = sqrtf(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w); 2082 | if (length == 0.0f) length = 1.0f; 2083 | float ilength = 1.0f/length; 2084 | 2085 | q.x = q.x*ilength; 2086 | q.y = q.y*ilength; 2087 | q.z = q.z*ilength; 2088 | q.w = q.w*ilength; 2089 | } 2090 | 2091 | Vector3 resAxis = { 0.0f, 0.0f, 0.0f }; 2092 | float resAngle = 2.0f*acosf(q.w); 2093 | float den = sqrtf(1.0f - q.w*q.w); 2094 | 2095 | if (den > EPSILON) 2096 | { 2097 | resAxis.x = q.x/den; 2098 | resAxis.y = q.y/den; 2099 | resAxis.z = q.z/den; 2100 | } 2101 | else 2102 | { 2103 | // This occurs when the angle is zero. 2104 | // Not a problem: just set an arbitrary normalized axis. 2105 | resAxis.x = 1.0f; 2106 | } 2107 | 2108 | *outAxis = resAxis; 2109 | *outAngle = resAngle; 2110 | } 2111 | 2112 | // Get the quaternion equivalent to Euler angles 2113 | // NOTE: Rotation order is ZYX 2114 | RMAPI Quaternion QuaternionFromEuler(float pitch, float yaw, float roll) 2115 | { 2116 | Quaternion result = { 0 }; 2117 | 2118 | float x0 = cosf(pitch*0.5f); 2119 | float x1 = sinf(pitch*0.5f); 2120 | float y0 = cosf(yaw*0.5f); 2121 | float y1 = sinf(yaw*0.5f); 2122 | float z0 = cosf(roll*0.5f); 2123 | float z1 = sinf(roll*0.5f); 2124 | 2125 | result.x = x1*y0*z0 - x0*y1*z1; 2126 | result.y = x0*y1*z0 + x1*y0*z1; 2127 | result.z = x0*y0*z1 - x1*y1*z0; 2128 | result.w = x0*y0*z0 + x1*y1*z1; 2129 | 2130 | return result; 2131 | } 2132 | 2133 | // Get the Euler angles equivalent to quaternion (roll, pitch, yaw) 2134 | // NOTE: Angles are returned in a Vector3 struct in radians 2135 | RMAPI Vector3 QuaternionToEuler(Quaternion q) 2136 | { 2137 | Vector3 result = { 0 }; 2138 | 2139 | // Roll (x-axis rotation) 2140 | float x0 = 2.0f*(q.w*q.x + q.y*q.z); 2141 | float x1 = 1.0f - 2.0f*(q.x*q.x + q.y*q.y); 2142 | result.x = atan2f(x0, x1); 2143 | 2144 | // Pitch (y-axis rotation) 2145 | float y0 = 2.0f*(q.w*q.y - q.z*q.x); 2146 | y0 = y0 > 1.0f ? 1.0f : y0; 2147 | y0 = y0 < -1.0f ? -1.0f : y0; 2148 | result.y = asinf(y0); 2149 | 2150 | // Yaw (z-axis rotation) 2151 | float z0 = 2.0f*(q.w*q.z + q.x*q.y); 2152 | float z1 = 1.0f - 2.0f*(q.y*q.y + q.z*q.z); 2153 | result.z = atan2f(z0, z1); 2154 | 2155 | return result; 2156 | } 2157 | 2158 | // Transform a quaternion given a transformation matrix 2159 | RMAPI Quaternion QuaternionTransform(Quaternion q, Matrix mat) 2160 | { 2161 | Quaternion result = { 0 }; 2162 | 2163 | result.x = mat.m0*q.x + mat.m4*q.y + mat.m8*q.z + mat.m12*q.w; 2164 | result.y = mat.m1*q.x + mat.m5*q.y + mat.m9*q.z + mat.m13*q.w; 2165 | result.z = mat.m2*q.x + mat.m6*q.y + mat.m10*q.z + mat.m14*q.w; 2166 | result.w = mat.m3*q.x + mat.m7*q.y + mat.m11*q.z + mat.m15*q.w; 2167 | 2168 | return result; 2169 | } 2170 | 2171 | // Check whether two given quaternions are almost equal 2172 | RMAPI int QuaternionEquals(Quaternion p, Quaternion q) 2173 | { 2174 | #if !defined(EPSILON) 2175 | #define EPSILON 0.000001f 2176 | #endif 2177 | 2178 | int result = (((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && 2179 | ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && 2180 | ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))) && 2181 | ((fabsf(p.w - q.w)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.w), fabsf(q.w)))))) || 2182 | (((fabsf(p.x + q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) && 2183 | ((fabsf(p.y + q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) && 2184 | ((fabsf(p.z + q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))) && 2185 | ((fabsf(p.w + q.w)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.w), fabsf(q.w)))))); 2186 | 2187 | return result; 2188 | } 2189 | 2190 | #endif // RAYMATH_H 2191 | -------------------------------------------------------------------------------- /raylib/raylib.h: -------------------------------------------------------------------------------- 1 | /********************************************************************************************** 2 | * 3 | * raylib v5.0 - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com) 4 | * 5 | * FEATURES: 6 | * - NO external dependencies, all required libraries included with raylib 7 | * - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly, 8 | * MacOS, Haiku, Android, Raspberry Pi, DRM native, HTML5. 9 | * - Written in plain C code (C99) in PascalCase/camelCase notation 10 | * - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3 or ES2 - choose at compile) 11 | * - Unique OpenGL abstraction layer (usable as standalone module): [rlgl] 12 | * - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts) 13 | * - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC) 14 | * - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more! 15 | * - Flexible Materials system, supporting classic maps and PBR maps 16 | * - Animated 3D models supported (skeletal bones animation) (IQM) 17 | * - Shaders support, including Model shaders and Postprocessing shaders 18 | * - Powerful math module for Vector, Matrix and Quaternion operations: [raymath] 19 | * - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD) 20 | * - VR stereo rendering with configurable HMD device parameters 21 | * - Bindings to multiple programming languages available! 22 | * 23 | * NOTES: 24 | * - One default Font is loaded on InitWindow()->LoadFontDefault() [core, text] 25 | * - One default Texture2D is loaded on rlglInit(), 1x1 white pixel R8G8B8A8 [rlgl] (OpenGL 3.3 or ES2) 26 | * - One default Shader is loaded on rlglInit()->rlLoadShaderDefault() [rlgl] (OpenGL 3.3 or ES2) 27 | * - One default RenderBatch is loaded on rlglInit()->rlLoadRenderBatch() [rlgl] (OpenGL 3.3 or ES2) 28 | * 29 | * DEPENDENCIES (included): 30 | * [rcore] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input (PLATFORM_DESKTOP) 31 | * [rlgl] glad (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (PLATFORM_DESKTOP) 32 | * [raudio] miniaudio (David Reid - github.com/mackron/miniaudio) for audio device/context management 33 | * 34 | * OPTIONAL DEPENDENCIES (included): 35 | * [rcore] msf_gif (Miles Fogle) for GIF recording 36 | * [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm 37 | * [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm 38 | * [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...) 39 | * [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG) 40 | * [rtextures] stb_image_resize (Sean Barret) for image resizing algorithms 41 | * [rtext] stb_truetype (Sean Barret) for ttf fonts loading 42 | * [rtext] stb_rect_pack (Sean Barret) for rectangles packing 43 | * [rmodels] par_shapes (Philip Rideout) for parametric 3d shapes generation 44 | * [rmodels] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL) 45 | * [rmodels] cgltf (Johannes Kuhlmann) for models loading (glTF) 46 | * [rmodels] Model3D (bzt) for models loading (M3D, https://bztsrc.gitlab.io/model3d) 47 | * [raudio] dr_wav (David Reid) for WAV audio file loading 48 | * [raudio] dr_flac (David Reid) for FLAC audio file loading 49 | * [raudio] dr_mp3 (David Reid) for MP3 audio file loading 50 | * [raudio] stb_vorbis (Sean Barret) for OGG audio loading 51 | * [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading 52 | * [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading 53 | * 54 | * 55 | * LICENSE: zlib/libpng 56 | * 57 | * raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, 58 | * BSD-like license that allows static linking with closed source software: 59 | * 60 | * Copyright (c) 2013-2023 Ramon Santamaria (@raysan5) 61 | * 62 | * This software is provided "as-is", without any express or implied warranty. In no event 63 | * will the authors be held liable for any damages arising from the use of this software. 64 | * 65 | * Permission is granted to anyone to use this software for any purpose, including commercial 66 | * applications, and to alter it and redistribute it freely, subject to the following restrictions: 67 | * 68 | * 1. The origin of this software must not be misrepresented; you must not claim that you 69 | * wrote the original software. If you use this software in a product, an acknowledgment 70 | * in the product documentation would be appreciated but is not required. 71 | * 72 | * 2. Altered source versions must be plainly marked as such, and must not be misrepresented 73 | * as being the original software. 74 | * 75 | * 3. This notice may not be removed or altered from any source distribution. 76 | * 77 | **********************************************************************************************/ 78 | 79 | #ifndef RAYLIB_H 80 | #define RAYLIB_H 81 | 82 | #include // Required for: va_list - Only used by TraceLogCallback 83 | 84 | #define RAYLIB_VERSION_MAJOR 5 85 | #define RAYLIB_VERSION_MINOR 0 86 | #define RAYLIB_VERSION_PATCH 0 87 | #define RAYLIB_VERSION "5.0" 88 | 89 | // Function specifiers in case library is build/used as a shared library (Windows) 90 | // NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll 91 | #if defined(_WIN32) 92 | #if defined(BUILD_LIBTYPE_SHARED) 93 | #if defined(__TINYC__) 94 | #define __declspec(x) __attribute__((x)) 95 | #endif 96 | #define RLAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) 97 | #elif defined(USE_LIBTYPE_SHARED) 98 | #define RLAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) 99 | #endif 100 | #endif 101 | 102 | #ifndef RLAPI 103 | #define RLAPI // Functions defined as 'extern' by default (implicit specifiers) 104 | #endif 105 | 106 | //---------------------------------------------------------------------------------- 107 | // Some basic Defines 108 | //---------------------------------------------------------------------------------- 109 | #ifndef PI 110 | #define PI 3.14159265358979323846f 111 | #endif 112 | #ifndef DEG2RAD 113 | #define DEG2RAD (PI/180.0f) 114 | #endif 115 | #ifndef RAD2DEG 116 | #define RAD2DEG (180.0f/PI) 117 | #endif 118 | 119 | // Allow custom memory allocators 120 | // NOTE: Require recompiling raylib sources 121 | #ifndef RL_MALLOC 122 | #define RL_MALLOC(sz) malloc(sz) 123 | #endif 124 | #ifndef RL_CALLOC 125 | #define RL_CALLOC(n,sz) calloc(n,sz) 126 | #endif 127 | #ifndef RL_REALLOC 128 | #define RL_REALLOC(ptr,sz) realloc(ptr,sz) 129 | #endif 130 | #ifndef RL_FREE 131 | #define RL_FREE(ptr) free(ptr) 132 | #endif 133 | 134 | // NOTE: MSVC C++ compiler does not support compound literals (C99 feature) 135 | // Plain structures in C++ (without constructors) can be initialized with { } 136 | // This is called aggregate initialization (C++11 feature) 137 | #if defined(__cplusplus) 138 | #define CLITERAL(type) type 139 | #else 140 | #define CLITERAL(type) (type) 141 | #endif 142 | 143 | // Some compilers (mostly macos clang) default to C++98, 144 | // where aggregate initialization can't be used 145 | // So, give a more clear error stating how to fix this 146 | #if !defined(_MSC_VER) && (defined(__cplusplus) && __cplusplus < 201103L) 147 | #error "C++11 or later is required. Add -std=c++11" 148 | #endif 149 | 150 | // NOTE: We set some defines with some data types declared by raylib 151 | // Other modules (raymath, rlgl) also require some of those types, so, 152 | // to be able to use those other modules as standalone (not depending on raylib) 153 | // this defines are very useful for internal check and avoid type (re)definitions 154 | #define RL_COLOR_TYPE 155 | #define RL_RECTANGLE_TYPE 156 | #define RL_VECTOR2_TYPE 157 | #define RL_VECTOR3_TYPE 158 | #define RL_VECTOR4_TYPE 159 | #define RL_QUATERNION_TYPE 160 | #define RL_MATRIX_TYPE 161 | 162 | // Some Basic Colors 163 | // NOTE: Custom raylib color palette for amazing visuals on WHITE background 164 | #define LIGHTGRAY CLITERAL(Color){ 200, 200, 200, 255 } // Light Gray 165 | #define GRAY CLITERAL(Color){ 130, 130, 130, 255 } // Gray 166 | #define DARKGRAY CLITERAL(Color){ 80, 80, 80, 255 } // Dark Gray 167 | #define YELLOW CLITERAL(Color){ 253, 249, 0, 255 } // Yellow 168 | #define GOLD CLITERAL(Color){ 255, 203, 0, 255 } // Gold 169 | #define ORANGE CLITERAL(Color){ 255, 161, 0, 255 } // Orange 170 | #define PINK CLITERAL(Color){ 255, 109, 194, 255 } // Pink 171 | #define RED CLITERAL(Color){ 230, 41, 55, 255 } // Red 172 | #define MAROON CLITERAL(Color){ 190, 33, 55, 255 } // Maroon 173 | #define GREEN CLITERAL(Color){ 0, 228, 48, 255 } // Green 174 | #define LIME CLITERAL(Color){ 0, 158, 47, 255 } // Lime 175 | #define DARKGREEN CLITERAL(Color){ 0, 117, 44, 255 } // Dark Green 176 | #define SKYBLUE CLITERAL(Color){ 102, 191, 255, 255 } // Sky Blue 177 | #define BLUE CLITERAL(Color){ 0, 121, 241, 255 } // Blue 178 | #define DARKBLUE CLITERAL(Color){ 0, 82, 172, 255 } // Dark Blue 179 | #define PURPLE CLITERAL(Color){ 200, 122, 255, 255 } // Purple 180 | #define VIOLET CLITERAL(Color){ 135, 60, 190, 255 } // Violet 181 | #define DARKPURPLE CLITERAL(Color){ 112, 31, 126, 255 } // Dark Purple 182 | #define BEIGE CLITERAL(Color){ 211, 176, 131, 255 } // Beige 183 | #define BROWN CLITERAL(Color){ 127, 106, 79, 255 } // Brown 184 | #define DARKBROWN CLITERAL(Color){ 76, 63, 47, 255 } // Dark Brown 185 | 186 | #define WHITE CLITERAL(Color){ 255, 255, 255, 255 } // White 187 | #define BLACK CLITERAL(Color){ 0, 0, 0, 255 } // Black 188 | #define BLANK CLITERAL(Color){ 0, 0, 0, 0 } // Blank (Transparent) 189 | #define MAGENTA CLITERAL(Color){ 255, 0, 255, 255 } // Magenta 190 | #define RAYWHITE CLITERAL(Color){ 245, 245, 245, 255 } // My own White (raylib logo) 191 | 192 | //---------------------------------------------------------------------------------- 193 | // Structures Definition 194 | //---------------------------------------------------------------------------------- 195 | // Boolean type 196 | #if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800) 197 | #include 198 | #elif !defined(__cplusplus) && !defined(bool) 199 | typedef enum bool { false = 0, true = !false } bool; 200 | #define RL_BOOL_TYPE 201 | #endif 202 | 203 | // Vector2, 2 components 204 | typedef struct Vector2 { 205 | float x; // Vector x component 206 | float y; // Vector y component 207 | } Vector2; 208 | 209 | // Vector3, 3 components 210 | typedef struct Vector3 { 211 | float x; // Vector x component 212 | float y; // Vector y component 213 | float z; // Vector z component 214 | } Vector3; 215 | 216 | // Vector4, 4 components 217 | typedef struct Vector4 { 218 | float x; // Vector x component 219 | float y; // Vector y component 220 | float z; // Vector z component 221 | float w; // Vector w component 222 | } Vector4; 223 | 224 | // Quaternion, 4 components (Vector4 alias) 225 | typedef Vector4 Quaternion; 226 | 227 | // Matrix, 4x4 components, column major, OpenGL style, right-handed 228 | typedef struct Matrix { 229 | float m0, m4, m8, m12; // Matrix first row (4 components) 230 | float m1, m5, m9, m13; // Matrix second row (4 components) 231 | float m2, m6, m10, m14; // Matrix third row (4 components) 232 | float m3, m7, m11, m15; // Matrix fourth row (4 components) 233 | } Matrix; 234 | 235 | // Color, 4 components, R8G8B8A8 (32bit) 236 | typedef struct Color { 237 | unsigned char r; // Color red value 238 | unsigned char g; // Color green value 239 | unsigned char b; // Color blue value 240 | unsigned char a; // Color alpha value 241 | } Color; 242 | 243 | // Rectangle, 4 components 244 | typedef struct Rectangle { 245 | float x; // Rectangle top-left corner position x 246 | float y; // Rectangle top-left corner position y 247 | float width; // Rectangle width 248 | float height; // Rectangle height 249 | } Rectangle; 250 | 251 | // Image, pixel data stored in CPU memory (RAM) 252 | typedef struct Image { 253 | void *data; // Image raw data 254 | int width; // Image base width 255 | int height; // Image base height 256 | int mipmaps; // Mipmap levels, 1 by default 257 | int format; // Data format (PixelFormat type) 258 | } Image; 259 | 260 | // Texture, tex data stored in GPU memory (VRAM) 261 | typedef struct Texture { 262 | unsigned int id; // OpenGL texture id 263 | int width; // Texture base width 264 | int height; // Texture base height 265 | int mipmaps; // Mipmap levels, 1 by default 266 | int format; // Data format (PixelFormat type) 267 | } Texture; 268 | 269 | // Texture2D, same as Texture 270 | typedef Texture Texture2D; 271 | 272 | // TextureCubemap, same as Texture 273 | typedef Texture TextureCubemap; 274 | 275 | // RenderTexture, fbo for texture rendering 276 | typedef struct RenderTexture { 277 | unsigned int id; // OpenGL framebuffer object id 278 | Texture texture; // Color buffer attachment texture 279 | Texture depth; // Depth buffer attachment texture 280 | } RenderTexture; 281 | 282 | // RenderTexture2D, same as RenderTexture 283 | typedef RenderTexture RenderTexture2D; 284 | 285 | // NPatchInfo, n-patch layout info 286 | typedef struct NPatchInfo { 287 | Rectangle source; // Texture source rectangle 288 | int left; // Left border offset 289 | int top; // Top border offset 290 | int right; // Right border offset 291 | int bottom; // Bottom border offset 292 | int layout; // Layout of the n-patch: 3x3, 1x3 or 3x1 293 | } NPatchInfo; 294 | 295 | // GlyphInfo, font characters glyphs info 296 | typedef struct GlyphInfo { 297 | int value; // Character value (Unicode) 298 | int offsetX; // Character offset X when drawing 299 | int offsetY; // Character offset Y when drawing 300 | int advanceX; // Character advance position X 301 | Image image; // Character image data 302 | } GlyphInfo; 303 | 304 | // Font, font texture and GlyphInfo array data 305 | typedef struct Font { 306 | int baseSize; // Base size (default chars height) 307 | int glyphCount; // Number of glyph characters 308 | int glyphPadding; // Padding around the glyph characters 309 | Texture2D texture; // Texture atlas containing the glyphs 310 | Rectangle *recs; // Rectangles in texture for the glyphs 311 | GlyphInfo *glyphs; // Glyphs info data 312 | } Font; 313 | 314 | // Camera, defines position/orientation in 3d space 315 | typedef struct Camera3D { 316 | Vector3 position; // Camera position 317 | Vector3 target; // Camera target it looks-at 318 | Vector3 up; // Camera up vector (rotation over its axis) 319 | float fovy; // Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic 320 | int projection; // Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC 321 | } Camera3D; 322 | 323 | typedef Camera3D Camera; // Camera type fallback, defaults to Camera3D 324 | 325 | // Camera2D, defines position/orientation in 2d space 326 | typedef struct Camera2D { 327 | Vector2 offset; // Camera offset (displacement from target) 328 | Vector2 target; // Camera target (rotation and zoom origin) 329 | float rotation; // Camera rotation in degrees 330 | float zoom; // Camera zoom (scaling), should be 1.0f by default 331 | } Camera2D; 332 | 333 | // Mesh, vertex data and vao/vbo 334 | typedef struct Mesh { 335 | int vertexCount; // Number of vertices stored in arrays 336 | int triangleCount; // Number of triangles stored (indexed or not) 337 | 338 | // Vertex attributes data 339 | float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0) 340 | float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) 341 | float *texcoords2; // Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5) 342 | float *normals; // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2) 343 | float *tangents; // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4) 344 | unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) 345 | unsigned short *indices; // Vertex indices (in case vertex data comes indexed) 346 | 347 | // Animation vertex data 348 | float *animVertices; // Animated vertex positions (after bones transformations) 349 | float *animNormals; // Animated normals (after bones transformations) 350 | unsigned char *boneIds; // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning) 351 | float *boneWeights; // Vertex bone weight, up to 4 bones influence by vertex (skinning) 352 | 353 | // OpenGL identifiers 354 | unsigned int vaoId; // OpenGL Vertex Array Object id 355 | unsigned int *vboId; // OpenGL Vertex Buffer Objects id (default vertex data) 356 | } Mesh; 357 | 358 | // Shader 359 | typedef struct Shader { 360 | unsigned int id; // Shader program id 361 | int *locs; // Shader locations array (RL_MAX_SHADER_LOCATIONS) 362 | } Shader; 363 | 364 | // MaterialMap 365 | typedef struct MaterialMap { 366 | Texture2D texture; // Material map texture 367 | Color color; // Material map color 368 | float value; // Material map value 369 | } MaterialMap; 370 | 371 | // Material, includes shader and maps 372 | typedef struct Material { 373 | Shader shader; // Material shader 374 | MaterialMap *maps; // Material maps array (MAX_MATERIAL_MAPS) 375 | float params[4]; // Material generic parameters (if required) 376 | } Material; 377 | 378 | // Transform, vertex transformation data 379 | typedef struct Transform { 380 | Vector3 translation; // Translation 381 | Quaternion rotation; // Rotation 382 | Vector3 scale; // Scale 383 | } Transform; 384 | 385 | // Bone, skeletal animation bone 386 | typedef struct BoneInfo { 387 | char name[32]; // Bone name 388 | int parent; // Bone parent 389 | } BoneInfo; 390 | 391 | // Model, meshes, materials and animation data 392 | typedef struct Model { 393 | Matrix transform; // Local transform matrix 394 | 395 | int meshCount; // Number of meshes 396 | int materialCount; // Number of materials 397 | Mesh *meshes; // Meshes array 398 | Material *materials; // Materials array 399 | int *meshMaterial; // Mesh material number 400 | 401 | // Animation data 402 | int boneCount; // Number of bones 403 | BoneInfo *bones; // Bones information (skeleton) 404 | Transform *bindPose; // Bones base transformation (pose) 405 | } Model; 406 | 407 | // ModelAnimation 408 | typedef struct ModelAnimation { 409 | int boneCount; // Number of bones 410 | int frameCount; // Number of animation frames 411 | BoneInfo *bones; // Bones information (skeleton) 412 | Transform **framePoses; // Poses array by frame 413 | char name[32]; // Animation name 414 | } ModelAnimation; 415 | 416 | // Ray, ray for raycasting 417 | typedef struct Ray { 418 | Vector3 position; // Ray position (origin) 419 | Vector3 direction; // Ray direction 420 | } Ray; 421 | 422 | // RayCollision, ray hit information 423 | typedef struct RayCollision { 424 | bool hit; // Did the ray hit something? 425 | float distance; // Distance to the nearest hit 426 | Vector3 point; // Point of the nearest hit 427 | Vector3 normal; // Surface normal of hit 428 | } RayCollision; 429 | 430 | // BoundingBox 431 | typedef struct BoundingBox { 432 | Vector3 min; // Minimum vertex box-corner 433 | Vector3 max; // Maximum vertex box-corner 434 | } BoundingBox; 435 | 436 | // Wave, audio wave data 437 | typedef struct Wave { 438 | unsigned int frameCount; // Total number of frames (considering channels) 439 | unsigned int sampleRate; // Frequency (samples per second) 440 | unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) 441 | unsigned int channels; // Number of channels (1-mono, 2-stereo, ...) 442 | void *data; // Buffer data pointer 443 | } Wave; 444 | 445 | // Opaque structs declaration 446 | // NOTE: Actual structs are defined internally in raudio module 447 | typedef struct rAudioBuffer rAudioBuffer; 448 | typedef struct rAudioProcessor rAudioProcessor; 449 | 450 | // AudioStream, custom audio stream 451 | typedef struct AudioStream { 452 | rAudioBuffer *buffer; // Pointer to internal data used by the audio system 453 | rAudioProcessor *processor; // Pointer to internal data processor, useful for audio effects 454 | 455 | unsigned int sampleRate; // Frequency (samples per second) 456 | unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) 457 | unsigned int channels; // Number of channels (1-mono, 2-stereo, ...) 458 | } AudioStream; 459 | 460 | // Sound 461 | typedef struct Sound { 462 | AudioStream stream; // Audio stream 463 | unsigned int frameCount; // Total number of frames (considering channels) 464 | } Sound; 465 | 466 | // Music, audio stream, anything longer than ~10 seconds should be streamed 467 | typedef struct Music { 468 | AudioStream stream; // Audio stream 469 | unsigned int frameCount; // Total number of frames (considering channels) 470 | bool looping; // Music looping enable 471 | 472 | int ctxType; // Type of music context (audio filetype) 473 | void *ctxData; // Audio context data, depends on type 474 | } Music; 475 | 476 | // VrDeviceInfo, Head-Mounted-Display device parameters 477 | typedef struct VrDeviceInfo { 478 | int hResolution; // Horizontal resolution in pixels 479 | int vResolution; // Vertical resolution in pixels 480 | float hScreenSize; // Horizontal size in meters 481 | float vScreenSize; // Vertical size in meters 482 | float vScreenCenter; // Screen center in meters 483 | float eyeToScreenDistance; // Distance between eye and display in meters 484 | float lensSeparationDistance; // Lens separation distance in meters 485 | float interpupillaryDistance; // IPD (distance between pupils) in meters 486 | float lensDistortionValues[4]; // Lens distortion constant parameters 487 | float chromaAbCorrection[4]; // Chromatic aberration correction parameters 488 | } VrDeviceInfo; 489 | 490 | // VrStereoConfig, VR stereo rendering configuration for simulator 491 | typedef struct VrStereoConfig { 492 | Matrix projection[2]; // VR projection matrices (per eye) 493 | Matrix viewOffset[2]; // VR view offset matrices (per eye) 494 | float leftLensCenter[2]; // VR left lens center 495 | float rightLensCenter[2]; // VR right lens center 496 | float leftScreenCenter[2]; // VR left screen center 497 | float rightScreenCenter[2]; // VR right screen center 498 | float scale[2]; // VR distortion scale 499 | float scaleIn[2]; // VR distortion scale in 500 | } VrStereoConfig; 501 | 502 | // File path list 503 | typedef struct FilePathList { 504 | unsigned int capacity; // Filepaths max entries 505 | unsigned int count; // Filepaths entries count 506 | char **paths; // Filepaths entries 507 | } FilePathList; 508 | 509 | // Automation event 510 | typedef struct AutomationEvent { 511 | unsigned int frame; // Event frame 512 | unsigned int type; // Event type (AutomationEventType) 513 | int params[4]; // Event parameters (if required) 514 | } AutomationEvent; 515 | 516 | // Automation event list 517 | typedef struct AutomationEventList { 518 | unsigned int capacity; // Events max entries (MAX_AUTOMATION_EVENTS) 519 | unsigned int count; // Events entries count 520 | AutomationEvent *events; // Events entries 521 | } AutomationEventList; 522 | 523 | //---------------------------------------------------------------------------------- 524 | // Enumerators Definition 525 | //---------------------------------------------------------------------------------- 526 | // System/Window config flags 527 | // NOTE: Every bit registers one state (use it with bit masks) 528 | // By default all flags are set to 0 529 | typedef enum { 530 | FLAG_VSYNC_HINT = 0x00000040, // Set to try enabling V-Sync on GPU 531 | FLAG_FULLSCREEN_MODE = 0x00000002, // Set to run program in fullscreen 532 | FLAG_WINDOW_RESIZABLE = 0x00000004, // Set to allow resizable window 533 | FLAG_WINDOW_UNDECORATED = 0x00000008, // Set to disable window decoration (frame and buttons) 534 | FLAG_WINDOW_HIDDEN = 0x00000080, // Set to hide window 535 | FLAG_WINDOW_MINIMIZED = 0x00000200, // Set to minimize window (iconify) 536 | FLAG_WINDOW_MAXIMIZED = 0x00000400, // Set to maximize window (expanded to monitor) 537 | FLAG_WINDOW_UNFOCUSED = 0x00000800, // Set to window non focused 538 | FLAG_WINDOW_TOPMOST = 0x00001000, // Set to window always on top 539 | FLAG_WINDOW_ALWAYS_RUN = 0x00000100, // Set to allow windows running while minimized 540 | FLAG_WINDOW_TRANSPARENT = 0x00000010, // Set to allow transparent framebuffer 541 | FLAG_WINDOW_HIGHDPI = 0x00002000, // Set to support HighDPI 542 | FLAG_WINDOW_MOUSE_PASSTHROUGH = 0x00004000, // Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED 543 | FLAG_BORDERLESS_WINDOWED_MODE = 0x00008000, // Set to run program in borderless windowed mode 544 | FLAG_MSAA_4X_HINT = 0x00000020, // Set to try enabling MSAA 4X 545 | FLAG_INTERLACED_HINT = 0x00010000 // Set to try enabling interlaced video format (for V3D) 546 | } ConfigFlags; 547 | 548 | // Trace log level 549 | // NOTE: Organized by priority level 550 | typedef enum { 551 | LOG_ALL = 0, // Display all logs 552 | LOG_TRACE, // Trace logging, intended for internal use only 553 | LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds 554 | LOG_INFO, // Info logging, used for program execution info 555 | LOG_WARNING, // Warning logging, used on recoverable failures 556 | LOG_ERROR, // Error logging, used on unrecoverable failures 557 | LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE) 558 | LOG_NONE // Disable logging 559 | } TraceLogLevel; 560 | 561 | // Keyboard keys (US keyboard layout) 562 | // NOTE: Use GetKeyPressed() to allow redefining 563 | // required keys for alternative layouts 564 | typedef enum { 565 | KEY_NULL = 0, // Key: NULL, used for no key pressed 566 | // Alphanumeric keys 567 | KEY_APOSTROPHE = 39, // Key: ' 568 | KEY_COMMA = 44, // Key: , 569 | KEY_MINUS = 45, // Key: - 570 | KEY_PERIOD = 46, // Key: . 571 | KEY_SLASH = 47, // Key: / 572 | KEY_ZERO = 48, // Key: 0 573 | KEY_ONE = 49, // Key: 1 574 | KEY_TWO = 50, // Key: 2 575 | KEY_THREE = 51, // Key: 3 576 | KEY_FOUR = 52, // Key: 4 577 | KEY_FIVE = 53, // Key: 5 578 | KEY_SIX = 54, // Key: 6 579 | KEY_SEVEN = 55, // Key: 7 580 | KEY_EIGHT = 56, // Key: 8 581 | KEY_NINE = 57, // Key: 9 582 | KEY_SEMICOLON = 59, // Key: ; 583 | KEY_EQUAL = 61, // Key: = 584 | KEY_A = 65, // Key: A | a 585 | KEY_B = 66, // Key: B | b 586 | KEY_C = 67, // Key: C | c 587 | KEY_D = 68, // Key: D | d 588 | KEY_E = 69, // Key: E | e 589 | KEY_F = 70, // Key: F | f 590 | KEY_G = 71, // Key: G | g 591 | KEY_H = 72, // Key: H | h 592 | KEY_I = 73, // Key: I | i 593 | KEY_J = 74, // Key: J | j 594 | KEY_K = 75, // Key: K | k 595 | KEY_L = 76, // Key: L | l 596 | KEY_M = 77, // Key: M | m 597 | KEY_N = 78, // Key: N | n 598 | KEY_O = 79, // Key: O | o 599 | KEY_P = 80, // Key: P | p 600 | KEY_Q = 81, // Key: Q | q 601 | KEY_R = 82, // Key: R | r 602 | KEY_S = 83, // Key: S | s 603 | KEY_T = 84, // Key: T | t 604 | KEY_U = 85, // Key: U | u 605 | KEY_V = 86, // Key: V | v 606 | KEY_W = 87, // Key: W | w 607 | KEY_X = 88, // Key: X | x 608 | KEY_Y = 89, // Key: Y | y 609 | KEY_Z = 90, // Key: Z | z 610 | KEY_LEFT_BRACKET = 91, // Key: [ 611 | KEY_BACKSLASH = 92, // Key: '\' 612 | KEY_RIGHT_BRACKET = 93, // Key: ] 613 | KEY_GRAVE = 96, // Key: ` 614 | // Function keys 615 | KEY_SPACE = 32, // Key: Space 616 | KEY_ESCAPE = 256, // Key: Esc 617 | KEY_ENTER = 257, // Key: Enter 618 | KEY_TAB = 258, // Key: Tab 619 | KEY_BACKSPACE = 259, // Key: Backspace 620 | KEY_INSERT = 260, // Key: Ins 621 | KEY_DELETE = 261, // Key: Del 622 | KEY_RIGHT = 262, // Key: Cursor right 623 | KEY_LEFT = 263, // Key: Cursor left 624 | KEY_DOWN = 264, // Key: Cursor down 625 | KEY_UP = 265, // Key: Cursor up 626 | KEY_PAGE_UP = 266, // Key: Page up 627 | KEY_PAGE_DOWN = 267, // Key: Page down 628 | KEY_HOME = 268, // Key: Home 629 | KEY_END = 269, // Key: End 630 | KEY_CAPS_LOCK = 280, // Key: Caps lock 631 | KEY_SCROLL_LOCK = 281, // Key: Scroll down 632 | KEY_NUM_LOCK = 282, // Key: Num lock 633 | KEY_PRINT_SCREEN = 283, // Key: Print screen 634 | KEY_PAUSE = 284, // Key: Pause 635 | KEY_F1 = 290, // Key: F1 636 | KEY_F2 = 291, // Key: F2 637 | KEY_F3 = 292, // Key: F3 638 | KEY_F4 = 293, // Key: F4 639 | KEY_F5 = 294, // Key: F5 640 | KEY_F6 = 295, // Key: F6 641 | KEY_F7 = 296, // Key: F7 642 | KEY_F8 = 297, // Key: F8 643 | KEY_F9 = 298, // Key: F9 644 | KEY_F10 = 299, // Key: F10 645 | KEY_F11 = 300, // Key: F11 646 | KEY_F12 = 301, // Key: F12 647 | KEY_LEFT_SHIFT = 340, // Key: Shift left 648 | KEY_LEFT_CONTROL = 341, // Key: Control left 649 | KEY_LEFT_ALT = 342, // Key: Alt left 650 | KEY_LEFT_SUPER = 343, // Key: Super left 651 | KEY_RIGHT_SHIFT = 344, // Key: Shift right 652 | KEY_RIGHT_CONTROL = 345, // Key: Control right 653 | KEY_RIGHT_ALT = 346, // Key: Alt right 654 | KEY_RIGHT_SUPER = 347, // Key: Super right 655 | KEY_KB_MENU = 348, // Key: KB menu 656 | // Keypad keys 657 | KEY_KP_0 = 320, // Key: Keypad 0 658 | KEY_KP_1 = 321, // Key: Keypad 1 659 | KEY_KP_2 = 322, // Key: Keypad 2 660 | KEY_KP_3 = 323, // Key: Keypad 3 661 | KEY_KP_4 = 324, // Key: Keypad 4 662 | KEY_KP_5 = 325, // Key: Keypad 5 663 | KEY_KP_6 = 326, // Key: Keypad 6 664 | KEY_KP_7 = 327, // Key: Keypad 7 665 | KEY_KP_8 = 328, // Key: Keypad 8 666 | KEY_KP_9 = 329, // Key: Keypad 9 667 | KEY_KP_DECIMAL = 330, // Key: Keypad . 668 | KEY_KP_DIVIDE = 331, // Key: Keypad / 669 | KEY_KP_MULTIPLY = 332, // Key: Keypad * 670 | KEY_KP_SUBTRACT = 333, // Key: Keypad - 671 | KEY_KP_ADD = 334, // Key: Keypad + 672 | KEY_KP_ENTER = 335, // Key: Keypad Enter 673 | KEY_KP_EQUAL = 336, // Key: Keypad = 674 | // Android key buttons 675 | KEY_BACK = 4, // Key: Android back button 676 | KEY_MENU = 82, // Key: Android menu button 677 | KEY_VOLUME_UP = 24, // Key: Android volume up button 678 | KEY_VOLUME_DOWN = 25 // Key: Android volume down button 679 | } KeyboardKey; 680 | 681 | // Add backwards compatibility support for deprecated names 682 | #define MOUSE_LEFT_BUTTON MOUSE_BUTTON_LEFT 683 | #define MOUSE_RIGHT_BUTTON MOUSE_BUTTON_RIGHT 684 | #define MOUSE_MIDDLE_BUTTON MOUSE_BUTTON_MIDDLE 685 | 686 | // Mouse buttons 687 | typedef enum { 688 | MOUSE_BUTTON_LEFT = 0, // Mouse button left 689 | MOUSE_BUTTON_RIGHT = 1, // Mouse button right 690 | MOUSE_BUTTON_MIDDLE = 2, // Mouse button middle (pressed wheel) 691 | MOUSE_BUTTON_SIDE = 3, // Mouse button side (advanced mouse device) 692 | MOUSE_BUTTON_EXTRA = 4, // Mouse button extra (advanced mouse device) 693 | MOUSE_BUTTON_FORWARD = 5, // Mouse button forward (advanced mouse device) 694 | MOUSE_BUTTON_BACK = 6, // Mouse button back (advanced mouse device) 695 | } MouseButton; 696 | 697 | // Mouse cursor 698 | typedef enum { 699 | MOUSE_CURSOR_DEFAULT = 0, // Default pointer shape 700 | MOUSE_CURSOR_ARROW = 1, // Arrow shape 701 | MOUSE_CURSOR_IBEAM = 2, // Text writing cursor shape 702 | MOUSE_CURSOR_CROSSHAIR = 3, // Cross shape 703 | MOUSE_CURSOR_POINTING_HAND = 4, // Pointing hand cursor 704 | MOUSE_CURSOR_RESIZE_EW = 5, // Horizontal resize/move arrow shape 705 | MOUSE_CURSOR_RESIZE_NS = 6, // Vertical resize/move arrow shape 706 | MOUSE_CURSOR_RESIZE_NWSE = 7, // Top-left to bottom-right diagonal resize/move arrow shape 707 | MOUSE_CURSOR_RESIZE_NESW = 8, // The top-right to bottom-left diagonal resize/move arrow shape 708 | MOUSE_CURSOR_RESIZE_ALL = 9, // The omnidirectional resize/move cursor shape 709 | MOUSE_CURSOR_NOT_ALLOWED = 10 // The operation-not-allowed shape 710 | } MouseCursor; 711 | 712 | // Gamepad buttons 713 | typedef enum { 714 | GAMEPAD_BUTTON_UNKNOWN = 0, // Unknown button, just for error checking 715 | GAMEPAD_BUTTON_LEFT_FACE_UP, // Gamepad left DPAD up button 716 | GAMEPAD_BUTTON_LEFT_FACE_RIGHT, // Gamepad left DPAD right button 717 | GAMEPAD_BUTTON_LEFT_FACE_DOWN, // Gamepad left DPAD down button 718 | GAMEPAD_BUTTON_LEFT_FACE_LEFT, // Gamepad left DPAD left button 719 | GAMEPAD_BUTTON_RIGHT_FACE_UP, // Gamepad right button up (i.e. PS3: Triangle, Xbox: Y) 720 | GAMEPAD_BUTTON_RIGHT_FACE_RIGHT, // Gamepad right button right (i.e. PS3: Square, Xbox: X) 721 | GAMEPAD_BUTTON_RIGHT_FACE_DOWN, // Gamepad right button down (i.e. PS3: Cross, Xbox: A) 722 | GAMEPAD_BUTTON_RIGHT_FACE_LEFT, // Gamepad right button left (i.e. PS3: Circle, Xbox: B) 723 | GAMEPAD_BUTTON_LEFT_TRIGGER_1, // Gamepad top/back trigger left (first), it could be a trailing button 724 | GAMEPAD_BUTTON_LEFT_TRIGGER_2, // Gamepad top/back trigger left (second), it could be a trailing button 725 | GAMEPAD_BUTTON_RIGHT_TRIGGER_1, // Gamepad top/back trigger right (one), it could be a trailing button 726 | GAMEPAD_BUTTON_RIGHT_TRIGGER_2, // Gamepad top/back trigger right (second), it could be a trailing button 727 | GAMEPAD_BUTTON_MIDDLE_LEFT, // Gamepad center buttons, left one (i.e. PS3: Select) 728 | GAMEPAD_BUTTON_MIDDLE, // Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX) 729 | GAMEPAD_BUTTON_MIDDLE_RIGHT, // Gamepad center buttons, right one (i.e. PS3: Start) 730 | GAMEPAD_BUTTON_LEFT_THUMB, // Gamepad joystick pressed button left 731 | GAMEPAD_BUTTON_RIGHT_THUMB // Gamepad joystick pressed button right 732 | } GamepadButton; 733 | 734 | // Gamepad axis 735 | typedef enum { 736 | GAMEPAD_AXIS_LEFT_X = 0, // Gamepad left stick X axis 737 | GAMEPAD_AXIS_LEFT_Y = 1, // Gamepad left stick Y axis 738 | GAMEPAD_AXIS_RIGHT_X = 2, // Gamepad right stick X axis 739 | GAMEPAD_AXIS_RIGHT_Y = 3, // Gamepad right stick Y axis 740 | GAMEPAD_AXIS_LEFT_TRIGGER = 4, // Gamepad back trigger left, pressure level: [1..-1] 741 | GAMEPAD_AXIS_RIGHT_TRIGGER = 5 // Gamepad back trigger right, pressure level: [1..-1] 742 | } GamepadAxis; 743 | 744 | // Material map index 745 | typedef enum { 746 | MATERIAL_MAP_ALBEDO = 0, // Albedo material (same as: MATERIAL_MAP_DIFFUSE) 747 | MATERIAL_MAP_METALNESS, // Metalness material (same as: MATERIAL_MAP_SPECULAR) 748 | MATERIAL_MAP_NORMAL, // Normal material 749 | MATERIAL_MAP_ROUGHNESS, // Roughness material 750 | MATERIAL_MAP_OCCLUSION, // Ambient occlusion material 751 | MATERIAL_MAP_EMISSION, // Emission material 752 | MATERIAL_MAP_HEIGHT, // Heightmap material 753 | MATERIAL_MAP_CUBEMAP, // Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP) 754 | MATERIAL_MAP_IRRADIANCE, // Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP) 755 | MATERIAL_MAP_PREFILTER, // Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP) 756 | MATERIAL_MAP_BRDF // Brdf material 757 | } MaterialMapIndex; 758 | 759 | #define MATERIAL_MAP_DIFFUSE MATERIAL_MAP_ALBEDO 760 | #define MATERIAL_MAP_SPECULAR MATERIAL_MAP_METALNESS 761 | 762 | // Shader location index 763 | typedef enum { 764 | SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position 765 | SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01 766 | SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02 767 | SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal 768 | SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent 769 | SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color 770 | SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection 771 | SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform) 772 | SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection 773 | SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform) 774 | SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal 775 | SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view 776 | SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color 777 | SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color 778 | SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color 779 | SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE) 780 | SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR) 781 | SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal 782 | SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness 783 | SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion 784 | SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission 785 | SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height 786 | SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap 787 | SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance 788 | SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter 789 | SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf 790 | } ShaderLocationIndex; 791 | 792 | #define SHADER_LOC_MAP_DIFFUSE SHADER_LOC_MAP_ALBEDO 793 | #define SHADER_LOC_MAP_SPECULAR SHADER_LOC_MAP_METALNESS 794 | 795 | // Shader uniform data type 796 | typedef enum { 797 | SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float 798 | SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float) 799 | SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float) 800 | SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float) 801 | SHADER_UNIFORM_INT, // Shader uniform type: int 802 | SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int) 803 | SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int) 804 | SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int) 805 | SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d 806 | } ShaderUniformDataType; 807 | 808 | // Shader attribute data types 809 | typedef enum { 810 | SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float 811 | SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float) 812 | SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float) 813 | SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float) 814 | } ShaderAttributeDataType; 815 | 816 | // Pixel formats 817 | // NOTE: Support depends on OpenGL version and platform 818 | typedef enum { 819 | PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha) 820 | PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels) 821 | PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp 822 | PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp 823 | PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha) 824 | PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha) 825 | PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp 826 | PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float) 827 | PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float) 828 | PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float) 829 | PIXELFORMAT_UNCOMPRESSED_R16, // 16 bpp (1 channel - half float) 830 | PIXELFORMAT_UNCOMPRESSED_R16G16B16, // 16*3 bpp (3 channels - half float) 831 | PIXELFORMAT_UNCOMPRESSED_R16G16B16A16, // 16*4 bpp (4 channels - half float) 832 | PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha) 833 | PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha) 834 | PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp 835 | PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp 836 | PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp 837 | PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp 838 | PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp 839 | PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp 840 | PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp 841 | PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp 842 | PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp 843 | } PixelFormat; 844 | 845 | // Texture parameters: filter mode 846 | // NOTE 1: Filtering considers mipmaps if available in the texture 847 | // NOTE 2: Filter is accordingly set for minification and magnification 848 | typedef enum { 849 | TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation 850 | TEXTURE_FILTER_BILINEAR, // Linear filtering 851 | TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps) 852 | TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x 853 | TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x 854 | TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x 855 | } TextureFilter; 856 | 857 | // Texture parameters: wrap mode 858 | typedef enum { 859 | TEXTURE_WRAP_REPEAT = 0, // Repeats texture in tiled mode 860 | TEXTURE_WRAP_CLAMP, // Clamps texture to edge pixel in tiled mode 861 | TEXTURE_WRAP_MIRROR_REPEAT, // Mirrors and repeats the texture in tiled mode 862 | TEXTURE_WRAP_MIRROR_CLAMP // Mirrors and clamps to border the texture in tiled mode 863 | } TextureWrap; 864 | 865 | // Cubemap layouts 866 | typedef enum { 867 | CUBEMAP_LAYOUT_AUTO_DETECT = 0, // Automatically detect layout type 868 | CUBEMAP_LAYOUT_LINE_VERTICAL, // Layout is defined by a vertical line with faces 869 | CUBEMAP_LAYOUT_LINE_HORIZONTAL, // Layout is defined by a horizontal line with faces 870 | CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR, // Layout is defined by a 3x4 cross with cubemap faces 871 | CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE, // Layout is defined by a 4x3 cross with cubemap faces 872 | CUBEMAP_LAYOUT_PANORAMA // Layout is defined by a panorama image (equirrectangular map) 873 | } CubemapLayout; 874 | 875 | // Font type, defines generation method 876 | typedef enum { 877 | FONT_DEFAULT = 0, // Default font generation, anti-aliased 878 | FONT_BITMAP, // Bitmap font generation, no anti-aliasing 879 | FONT_SDF // SDF font generation, requires external shader 880 | } FontType; 881 | 882 | // Color blending modes (pre-defined) 883 | typedef enum { 884 | BLEND_ALPHA = 0, // Blend textures considering alpha (default) 885 | BLEND_ADDITIVE, // Blend textures adding colors 886 | BLEND_MULTIPLIED, // Blend textures multiplying colors 887 | BLEND_ADD_COLORS, // Blend textures adding colors (alternative) 888 | BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative) 889 | BLEND_ALPHA_PREMULTIPLY, // Blend premultiplied textures considering alpha 890 | BLEND_CUSTOM, // Blend textures using custom src/dst factors (use rlSetBlendFactors()) 891 | BLEND_CUSTOM_SEPARATE // Blend textures using custom rgb/alpha separate src/dst factors (use rlSetBlendFactorsSeparate()) 892 | } BlendMode; 893 | 894 | // Gesture 895 | // NOTE: Provided as bit-wise flags to enable only desired gestures 896 | typedef enum { 897 | GESTURE_NONE = 0, // No gesture 898 | GESTURE_TAP = 1, // Tap gesture 899 | GESTURE_DOUBLETAP = 2, // Double tap gesture 900 | GESTURE_HOLD = 4, // Hold gesture 901 | GESTURE_DRAG = 8, // Drag gesture 902 | GESTURE_SWIPE_RIGHT = 16, // Swipe right gesture 903 | GESTURE_SWIPE_LEFT = 32, // Swipe left gesture 904 | GESTURE_SWIPE_UP = 64, // Swipe up gesture 905 | GESTURE_SWIPE_DOWN = 128, // Swipe down gesture 906 | GESTURE_PINCH_IN = 256, // Pinch in gesture 907 | GESTURE_PINCH_OUT = 512 // Pinch out gesture 908 | } Gesture; 909 | 910 | // Camera system modes 911 | typedef enum { 912 | CAMERA_CUSTOM = 0, // Custom camera 913 | CAMERA_FREE, // Free camera 914 | CAMERA_ORBITAL, // Orbital camera 915 | CAMERA_FIRST_PERSON, // First person camera 916 | CAMERA_THIRD_PERSON // Third person camera 917 | } CameraMode; 918 | 919 | // Camera projection 920 | typedef enum { 921 | CAMERA_PERSPECTIVE = 0, // Perspective projection 922 | CAMERA_ORTHOGRAPHIC // Orthographic projection 923 | } CameraProjection; 924 | 925 | // N-patch layout 926 | typedef enum { 927 | NPATCH_NINE_PATCH = 0, // Npatch layout: 3x3 tiles 928 | NPATCH_THREE_PATCH_VERTICAL, // Npatch layout: 1x3 tiles 929 | NPATCH_THREE_PATCH_HORIZONTAL // Npatch layout: 3x1 tiles 930 | } NPatchLayout; 931 | 932 | // Callbacks to hook some internal functions 933 | // WARNING: These callbacks are intended for advance users 934 | typedef void (*TraceLogCallback)(int logLevel, const char *text, va_list args); // Logging: Redirect trace log messages 935 | typedef unsigned char *(*LoadFileDataCallback)(const char *fileName, int *dataSize); // FileIO: Load binary data 936 | typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, int dataSize); // FileIO: Save binary data 937 | typedef char *(*LoadFileTextCallback)(const char *fileName); // FileIO: Load text data 938 | typedef bool (*SaveFileTextCallback)(const char *fileName, char *text); // FileIO: Save text data 939 | 940 | //------------------------------------------------------------------------------------ 941 | // Global Variables Definition 942 | //------------------------------------------------------------------------------------ 943 | // It's lonely here... 944 | 945 | //------------------------------------------------------------------------------------ 946 | // Window and Graphics Device Functions (Module: core) 947 | //------------------------------------------------------------------------------------ 948 | 949 | #if defined(__cplusplus) 950 | extern "C" { // Prevents name mangling of functions 951 | #endif 952 | 953 | // Window-related functions 954 | RLAPI void InitWindow(int width, int height, const char *title); // Initialize window and OpenGL context 955 | RLAPI void CloseWindow(void); // Close window and unload OpenGL context 956 | RLAPI bool WindowShouldClose(void); // Check if application should close (KEY_ESCAPE pressed or windows close icon clicked) 957 | RLAPI bool IsWindowReady(void); // Check if window has been initialized successfully 958 | RLAPI bool IsWindowFullscreen(void); // Check if window is currently fullscreen 959 | RLAPI bool IsWindowHidden(void); // Check if window is currently hidden (only PLATFORM_DESKTOP) 960 | RLAPI bool IsWindowMinimized(void); // Check if window is currently minimized (only PLATFORM_DESKTOP) 961 | RLAPI bool IsWindowMaximized(void); // Check if window is currently maximized (only PLATFORM_DESKTOP) 962 | RLAPI bool IsWindowFocused(void); // Check if window is currently focused (only PLATFORM_DESKTOP) 963 | RLAPI bool IsWindowResized(void); // Check if window has been resized last frame 964 | RLAPI bool IsWindowState(unsigned int flag); // Check if one specific window flag is enabled 965 | RLAPI void SetWindowState(unsigned int flags); // Set window configuration state using flags (only PLATFORM_DESKTOP) 966 | RLAPI void ClearWindowState(unsigned int flags); // Clear window configuration state flags 967 | RLAPI void ToggleFullscreen(void); // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP) 968 | RLAPI void ToggleBorderlessWindowed(void); // Toggle window state: borderless windowed (only PLATFORM_DESKTOP) 969 | RLAPI void MaximizeWindow(void); // Set window state: maximized, if resizable (only PLATFORM_DESKTOP) 970 | RLAPI void MinimizeWindow(void); // Set window state: minimized, if resizable (only PLATFORM_DESKTOP) 971 | RLAPI void RestoreWindow(void); // Set window state: not minimized/maximized (only PLATFORM_DESKTOP) 972 | RLAPI void SetWindowIcon(Image image); // Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP) 973 | RLAPI void SetWindowIcons(Image *images, int count); // Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP) 974 | RLAPI void SetWindowTitle(const char *title); // Set title for window (only PLATFORM_DESKTOP and PLATFORM_WEB) 975 | RLAPI void SetWindowPosition(int x, int y); // Set window position on screen (only PLATFORM_DESKTOP) 976 | RLAPI void SetWindowMonitor(int monitor); // Set monitor for the current window 977 | RLAPI void SetWindowMinSize(int width, int height); // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE) 978 | RLAPI void SetWindowMaxSize(int width, int height); // Set window maximum dimensions (for FLAG_WINDOW_RESIZABLE) 979 | RLAPI void SetWindowSize(int width, int height); // Set window dimensions 980 | RLAPI void SetWindowOpacity(float opacity); // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP) 981 | RLAPI void SetWindowFocused(void); // Set window focused (only PLATFORM_DESKTOP) 982 | RLAPI void *GetWindowHandle(void); // Get native window handle 983 | RLAPI int GetScreenWidth(void); // Get current screen width 984 | RLAPI int GetScreenHeight(void); // Get current screen height 985 | RLAPI int GetRenderWidth(void); // Get current render width (it considers HiDPI) 986 | RLAPI int GetRenderHeight(void); // Get current render height (it considers HiDPI) 987 | RLAPI int GetMonitorCount(void); // Get number of connected monitors 988 | RLAPI int GetCurrentMonitor(void); // Get current connected monitor 989 | RLAPI Vector2 GetMonitorPosition(int monitor); // Get specified monitor position 990 | RLAPI int GetMonitorWidth(int monitor); // Get specified monitor width (current video mode used by monitor) 991 | RLAPI int GetMonitorHeight(int monitor); // Get specified monitor height (current video mode used by monitor) 992 | RLAPI int GetMonitorPhysicalWidth(int monitor); // Get specified monitor physical width in millimetres 993 | RLAPI int GetMonitorPhysicalHeight(int monitor); // Get specified monitor physical height in millimetres 994 | RLAPI int GetMonitorRefreshRate(int monitor); // Get specified monitor refresh rate 995 | RLAPI Vector2 GetWindowPosition(void); // Get window position XY on monitor 996 | RLAPI Vector2 GetWindowScaleDPI(void); // Get window scale DPI factor 997 | RLAPI const char *GetMonitorName(int monitor); // Get the human-readable, UTF-8 encoded name of the specified monitor 998 | RLAPI void SetClipboardText(const char *text); // Set clipboard text content 999 | RLAPI const char *GetClipboardText(void); // Get clipboard text content 1000 | RLAPI void EnableEventWaiting(void); // Enable waiting for events on EndDrawing(), no automatic event polling 1001 | RLAPI void DisableEventWaiting(void); // Disable waiting for events on EndDrawing(), automatic events polling 1002 | 1003 | // Cursor-related functions 1004 | RLAPI void ShowCursor(void); // Shows cursor 1005 | RLAPI void HideCursor(void); // Hides cursor 1006 | RLAPI bool IsCursorHidden(void); // Check if cursor is not visible 1007 | RLAPI void EnableCursor(void); // Enables cursor (unlock cursor) 1008 | RLAPI void DisableCursor(void); // Disables cursor (lock cursor) 1009 | RLAPI bool IsCursorOnScreen(void); // Check if cursor is on the screen 1010 | 1011 | // Drawing-related functions 1012 | RLAPI void ClearBackground(Color color); // Set background color (framebuffer clear color) 1013 | RLAPI void BeginDrawing(void); // Setup canvas (framebuffer) to start drawing 1014 | RLAPI void EndDrawing(void); // End canvas drawing and swap buffers (double buffering) 1015 | RLAPI void BeginMode2D(Camera2D camera); // Begin 2D mode with custom camera (2D) 1016 | RLAPI void EndMode2D(void); // Ends 2D mode with custom camera 1017 | RLAPI void BeginMode3D(Camera3D camera); // Begin 3D mode with custom camera (3D) 1018 | RLAPI void EndMode3D(void); // Ends 3D mode and returns to default 2D orthographic mode 1019 | RLAPI void BeginTextureMode(RenderTexture2D target); // Begin drawing to render texture 1020 | RLAPI void EndTextureMode(void); // Ends drawing to render texture 1021 | RLAPI void BeginShaderMode(Shader shader); // Begin custom shader drawing 1022 | RLAPI void EndShaderMode(void); // End custom shader drawing (use default shader) 1023 | RLAPI void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied, subtract, custom) 1024 | RLAPI void EndBlendMode(void); // End blending mode (reset to default: alpha blending) 1025 | RLAPI void BeginScissorMode(int x, int y, int width, int height); // Begin scissor mode (define screen area for following drawing) 1026 | RLAPI void EndScissorMode(void); // End scissor mode 1027 | RLAPI void BeginVrStereoMode(VrStereoConfig config); // Begin stereo rendering (requires VR simulator) 1028 | RLAPI void EndVrStereoMode(void); // End stereo rendering (requires VR simulator) 1029 | 1030 | // VR stereo config functions for VR simulator 1031 | RLAPI VrStereoConfig LoadVrStereoConfig(VrDeviceInfo device); // Load VR stereo config for VR simulator device parameters 1032 | RLAPI void UnloadVrStereoConfig(VrStereoConfig config); // Unload VR stereo config 1033 | 1034 | // Shader management functions 1035 | // NOTE: Shader functionality is not available on OpenGL 1.1 1036 | RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName); // Load shader from files and bind default locations 1037 | RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations 1038 | RLAPI bool IsShaderReady(Shader shader); // Check if a shader is ready 1039 | RLAPI int GetShaderLocation(Shader shader, const char *uniformName); // Get shader uniform location 1040 | RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName); // Get shader attribute location 1041 | RLAPI void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType); // Set shader uniform value 1042 | RLAPI void SetShaderValueV(Shader shader, int locIndex, const void *value, int uniformType, int count); // Set shader uniform value vector 1043 | RLAPI void SetShaderValueMatrix(Shader shader, int locIndex, Matrix mat); // Set shader uniform value (matrix 4x4) 1044 | RLAPI void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture); // Set shader uniform value for texture (sampler2d) 1045 | RLAPI void UnloadShader(Shader shader); // Unload shader from GPU memory (VRAM) 1046 | 1047 | // Screen-space-related functions 1048 | RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera); // Get a ray trace from mouse position 1049 | RLAPI Matrix GetCameraMatrix(Camera camera); // Get camera transform matrix (view matrix) 1050 | RLAPI Matrix GetCameraMatrix2D(Camera2D camera); // Get camera 2d transform matrix 1051 | RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera); // Get the screen space position for a 3d world space position 1052 | RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Get the world space position for a 2d camera screen space position 1053 | RLAPI Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Get size position for a 3d world space position 1054 | RLAPI Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera); // Get the screen space position for a 2d camera world space position 1055 | 1056 | // Timing-related functions 1057 | RLAPI void SetTargetFPS(int fps); // Set target FPS (maximum) 1058 | RLAPI float GetFrameTime(void); // Get time in seconds for last frame drawn (delta time) 1059 | RLAPI double GetTime(void); // Get elapsed time in seconds since InitWindow() 1060 | RLAPI int GetFPS(void); // Get current FPS 1061 | 1062 | // Custom frame control functions 1063 | // NOTE: Those functions are intended for advance users that want full control over the frame processing 1064 | // By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents() 1065 | // To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL 1066 | RLAPI void SwapScreenBuffer(void); // Swap back buffer with front buffer (screen drawing) 1067 | RLAPI void PollInputEvents(void); // Register all input events 1068 | RLAPI void WaitTime(double seconds); // Wait for some time (halt program execution) 1069 | 1070 | // Random values generation functions 1071 | RLAPI void SetRandomSeed(unsigned int seed); // Set the seed for the random number generator 1072 | RLAPI int GetRandomValue(int min, int max); // Get a random value between min and max (both included) 1073 | RLAPI int *LoadRandomSequence(unsigned int count, int min, int max); // Load random values sequence, no values repeated 1074 | RLAPI void UnloadRandomSequence(int *sequence); // Unload random values sequence 1075 | 1076 | // Misc. functions 1077 | RLAPI void TakeScreenshot(const char *fileName); // Takes a screenshot of current screen (filename extension defines format) 1078 | RLAPI void SetConfigFlags(unsigned int flags); // Setup init configuration flags (view FLAGS) 1079 | RLAPI void OpenURL(const char *url); // Open URL with default system browser (if available) 1080 | 1081 | // NOTE: Following functions implemented in module [utils] 1082 | //------------------------------------------------------------------ 1083 | RLAPI void TraceLog(int logLevel, const char *text, ...); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...) 1084 | RLAPI void SetTraceLogLevel(int logLevel); // Set the current threshold (minimum) log level 1085 | RLAPI void *MemAlloc(unsigned int size); // Internal memory allocator 1086 | RLAPI void *MemRealloc(void *ptr, unsigned int size); // Internal memory reallocator 1087 | RLAPI void MemFree(void *ptr); // Internal memory free 1088 | 1089 | // Set custom callbacks 1090 | // WARNING: Callbacks setup is intended for advance users 1091 | RLAPI void SetTraceLogCallback(TraceLogCallback callback); // Set custom trace log 1092 | RLAPI void SetLoadFileDataCallback(LoadFileDataCallback callback); // Set custom file binary data loader 1093 | RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custom file binary data saver 1094 | RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader 1095 | RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver 1096 | 1097 | // Files management functions 1098 | RLAPI unsigned char *LoadFileData(const char *fileName, int *dataSize); // Load file data as byte array (read) 1099 | RLAPI void UnloadFileData(unsigned char *data); // Unload file data allocated by LoadFileData() 1100 | RLAPI bool SaveFileData(const char *fileName, void *data, int dataSize); // Save data to file from byte array (write), returns true on success 1101 | RLAPI bool ExportDataAsCode(const unsigned char *data, int dataSize, const char *fileName); // Export data to code (.h), returns true on success 1102 | RLAPI char *LoadFileText(const char *fileName); // Load text data from file (read), returns a '\0' terminated string 1103 | RLAPI void UnloadFileText(char *text); // Unload file text data allocated by LoadFileText() 1104 | RLAPI bool SaveFileText(const char *fileName, char *text); // Save text data to file (write), string must be '\0' terminated, returns true on success 1105 | //------------------------------------------------------------------ 1106 | 1107 | // File system functions 1108 | RLAPI bool FileExists(const char *fileName); // Check if file exists 1109 | RLAPI bool DirectoryExists(const char *dirPath); // Check if a directory path exists 1110 | RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav) 1111 | RLAPI int GetFileLength(const char *fileName); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h) 1112 | RLAPI const char *GetFileExtension(const char *fileName); // Get pointer to extension for a filename string (includes dot: '.png') 1113 | RLAPI const char *GetFileName(const char *filePath); // Get pointer to filename for a path string 1114 | RLAPI const char *GetFileNameWithoutExt(const char *filePath); // Get filename string without extension (uses static string) 1115 | RLAPI const char *GetDirectoryPath(const char *filePath); // Get full path for a given fileName with path (uses static string) 1116 | RLAPI const char *GetPrevDirectoryPath(const char *dirPath); // Get previous directory path for a given path (uses static string) 1117 | RLAPI const char *GetWorkingDirectory(void); // Get current working directory (uses static string) 1118 | RLAPI const char *GetApplicationDirectory(void); // Get the directory of the running application (uses static string) 1119 | RLAPI bool ChangeDirectory(const char *dir); // Change working directory, return true on success 1120 | RLAPI bool IsPathFile(const char *path); // Check if a given path is a file or a directory 1121 | RLAPI FilePathList LoadDirectoryFiles(const char *dirPath); // Load directory filepaths 1122 | RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and recursive directory scan 1123 | RLAPI void UnloadDirectoryFiles(FilePathList files); // Unload filepaths 1124 | RLAPI bool IsFileDropped(void); // Check if a file has been dropped into window 1125 | RLAPI FilePathList LoadDroppedFiles(void); // Load dropped filepaths 1126 | RLAPI void UnloadDroppedFiles(FilePathList files); // Unload dropped filepaths 1127 | RLAPI long GetFileModTime(const char *fileName); // Get file modification time (last write time) 1128 | 1129 | // Compression/Encoding functionality 1130 | RLAPI unsigned char *CompressData(const unsigned char *data, int dataSize, int *compDataSize); // Compress data (DEFLATE algorithm), memory must be MemFree() 1131 | RLAPI unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // Decompress data (DEFLATE algorithm), memory must be MemFree() 1132 | RLAPI char *EncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize); // Encode data to Base64 string, memory must be MemFree() 1133 | RLAPI unsigned char *DecodeDataBase64(const unsigned char *data, int *outputSize); // Decode Base64 string data, memory must be MemFree() 1134 | 1135 | // Automation events functionality 1136 | RLAPI AutomationEventList LoadAutomationEventList(const char *fileName); // Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS 1137 | RLAPI void UnloadAutomationEventList(AutomationEventList *list); // Unload automation events list from file 1138 | RLAPI bool ExportAutomationEventList(AutomationEventList list, const char *fileName); // Export automation events list as text file 1139 | RLAPI void SetAutomationEventList(AutomationEventList *list); // Set automation event list to record to 1140 | RLAPI void SetAutomationEventBaseFrame(int frame); // Set automation event internal base frame to start recording 1141 | RLAPI void StartAutomationEventRecording(void); // Start recording automation events (AutomationEventList must be set) 1142 | RLAPI void StopAutomationEventRecording(void); // Stop recording automation events 1143 | RLAPI void PlayAutomationEvent(AutomationEvent event); // Play a recorded automation event 1144 | 1145 | //------------------------------------------------------------------------------------ 1146 | // Input Handling Functions (Module: core) 1147 | //------------------------------------------------------------------------------------ 1148 | 1149 | // Input-related functions: keyboard 1150 | RLAPI bool IsKeyPressed(int key); // Check if a key has been pressed once 1151 | RLAPI bool IsKeyPressedRepeat(int key); // Check if a key has been pressed again (Only PLATFORM_DESKTOP) 1152 | RLAPI bool IsKeyDown(int key); // Check if a key is being pressed 1153 | RLAPI bool IsKeyReleased(int key); // Check if a key has been released once 1154 | RLAPI bool IsKeyUp(int key); // Check if a key is NOT being pressed 1155 | RLAPI int GetKeyPressed(void); // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty 1156 | RLAPI int GetCharPressed(void); // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty 1157 | RLAPI void SetExitKey(int key); // Set a custom key to exit program (default is ESC) 1158 | 1159 | // Input-related functions: gamepads 1160 | RLAPI bool IsGamepadAvailable(int gamepad); // Check if a gamepad is available 1161 | RLAPI const char *GetGamepadName(int gamepad); // Get gamepad internal name id 1162 | RLAPI bool IsGamepadButtonPressed(int gamepad, int button); // Check if a gamepad button has been pressed once 1163 | RLAPI bool IsGamepadButtonDown(int gamepad, int button); // Check if a gamepad button is being pressed 1164 | RLAPI bool IsGamepadButtonReleased(int gamepad, int button); // Check if a gamepad button has been released once 1165 | RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Check if a gamepad button is NOT being pressed 1166 | RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed 1167 | RLAPI int GetGamepadAxisCount(int gamepad); // Get gamepad axis count for a gamepad 1168 | RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Get axis movement value for a gamepad axis 1169 | RLAPI int SetGamepadMappings(const char *mappings); // Set internal gamepad mappings (SDL_GameControllerDB) 1170 | 1171 | // Input-related functions: mouse 1172 | RLAPI bool IsMouseButtonPressed(int button); // Check if a mouse button has been pressed once 1173 | RLAPI bool IsMouseButtonDown(int button); // Check if a mouse button is being pressed 1174 | RLAPI bool IsMouseButtonReleased(int button); // Check if a mouse button has been released once 1175 | RLAPI bool IsMouseButtonUp(int button); // Check if a mouse button is NOT being pressed 1176 | RLAPI int GetMouseX(void); // Get mouse position X 1177 | RLAPI int GetMouseY(void); // Get mouse position Y 1178 | RLAPI Vector2 GetMousePosition(void); // Get mouse position XY 1179 | RLAPI Vector2 GetMouseDelta(void); // Get mouse delta between frames 1180 | RLAPI void SetMousePosition(int x, int y); // Set mouse position XY 1181 | RLAPI void SetMouseOffset(int offsetX, int offsetY); // Set mouse offset 1182 | RLAPI void SetMouseScale(float scaleX, float scaleY); // Set mouse scaling 1183 | RLAPI float GetMouseWheelMove(void); // Get mouse wheel movement for X or Y, whichever is larger 1184 | RLAPI Vector2 GetMouseWheelMoveV(void); // Get mouse wheel movement for both X and Y 1185 | RLAPI void SetMouseCursor(int cursor); // Set mouse cursor 1186 | 1187 | // Input-related functions: touch 1188 | RLAPI int GetTouchX(void); // Get touch position X for touch point 0 (relative to screen size) 1189 | RLAPI int GetTouchY(void); // Get touch position Y for touch point 0 (relative to screen size) 1190 | RLAPI Vector2 GetTouchPosition(int index); // Get touch position XY for a touch point index (relative to screen size) 1191 | RLAPI int GetTouchPointId(int index); // Get touch point identifier for given index 1192 | RLAPI int GetTouchPointCount(void); // Get number of touch points 1193 | 1194 | //------------------------------------------------------------------------------------ 1195 | // Gestures and Touch Handling Functions (Module: rgestures) 1196 | //------------------------------------------------------------------------------------ 1197 | RLAPI void SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags 1198 | RLAPI bool IsGestureDetected(unsigned int gesture); // Check if a gesture have been detected 1199 | RLAPI int GetGestureDetected(void); // Get latest detected gesture 1200 | RLAPI float GetGestureHoldDuration(void); // Get gesture hold time in milliseconds 1201 | RLAPI Vector2 GetGestureDragVector(void); // Get gesture drag vector 1202 | RLAPI float GetGestureDragAngle(void); // Get gesture drag angle 1203 | RLAPI Vector2 GetGesturePinchVector(void); // Get gesture pinch delta 1204 | RLAPI float GetGesturePinchAngle(void); // Get gesture pinch angle 1205 | 1206 | //------------------------------------------------------------------------------------ 1207 | // Camera System Functions (Module: rcamera) 1208 | //------------------------------------------------------------------------------------ 1209 | RLAPI void UpdateCamera(Camera *camera, int mode); // Update camera position for selected mode 1210 | RLAPI void UpdateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, float zoom); // Update camera movement/rotation 1211 | 1212 | //------------------------------------------------------------------------------------ 1213 | // Basic Shapes Drawing Functions (Module: shapes) 1214 | //------------------------------------------------------------------------------------ 1215 | // Set texture and rectangle to be used on shapes drawing 1216 | // NOTE: It can be useful when using basic shapes and one single font, 1217 | // defining a font char white rectangle would allow drawing everything in a single draw call 1218 | RLAPI void SetShapesTexture(Texture2D texture, Rectangle source); // Set texture and rectangle to be used on shapes drawing 1219 | 1220 | // Basic shapes drawing functions 1221 | RLAPI void DrawPixel(int posX, int posY, Color color); // Draw a pixel 1222 | RLAPI void DrawPixelV(Vector2 position, Color color); // Draw a pixel (Vector version) 1223 | RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw a line 1224 | RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); // Draw a line (using gl lines) 1225 | RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line (using triangles/quads) 1226 | RLAPI void DrawLineStrip(Vector2 *points, int pointCount, Color color); // Draw lines sequence (using gl lines) 1227 | RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw line segment cubic-bezier in-out interpolation 1228 | RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle 1229 | RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw a piece of a circle 1230 | RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline 1231 | RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle 1232 | RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version) 1233 | RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline 1234 | RLAPI void DrawCircleLinesV(Vector2 center, float radius, Color color); // Draw circle outline (Vector version) 1235 | RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse 1236 | RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse outline 1237 | RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring 1238 | RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring outline 1239 | RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle 1240 | RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version) 1241 | RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle 1242 | RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters 1243 | RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle 1244 | RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle 1245 | RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // Draw a gradient-filled rectangle with custom vertex colors 1246 | RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline 1247 | RLAPI void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color); // Draw rectangle outline with extended parameters 1248 | RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color); // Draw rectangle with rounded edges 1249 | RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline 1250 | RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) 1251 | RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle outline (vertex in counter-clockwise order!) 1252 | RLAPI void DrawTriangleFan(Vector2 *points, int pointCount, Color color); // Draw a triangle fan defined by points (first vertex is the center) 1253 | RLAPI void DrawTriangleStrip(Vector2 *points, int pointCount, Color color); // Draw a triangle strip defined by points 1254 | RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version) 1255 | RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a polygon outline of n sides 1256 | RLAPI void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters 1257 | 1258 | // Splines drawing functions 1259 | RLAPI void DrawSplineLinear(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Linear, minimum 2 points 1260 | RLAPI void DrawSplineBasis(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: B-Spline, minimum 4 points 1261 | RLAPI void DrawSplineCatmullRom(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Catmull-Rom, minimum 4 points 1262 | RLAPI void DrawSplineBezierQuadratic(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...] 1263 | RLAPI void DrawSplineBezierCubic(Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...] 1264 | RLAPI void DrawSplineSegmentLinear(Vector2 p1, Vector2 p2, float thick, Color color); // Draw spline segment: Linear, 2 points 1265 | RLAPI void DrawSplineSegmentBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: B-Spline, 4 points 1266 | RLAPI void DrawSplineSegmentCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: Catmull-Rom, 4 points 1267 | RLAPI void DrawSplineSegmentBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float thick, Color color); // Draw spline segment: Quadratic Bezier, 2 points, 1 control point 1268 | RLAPI void DrawSplineSegmentBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float thick, Color color); // Draw spline segment: Cubic Bezier, 2 points, 2 control points 1269 | 1270 | // Spline segment point evaluation functions, for a given t [0.0f .. 1.0f] 1271 | RLAPI Vector2 GetSplinePointLinear(Vector2 startPos, Vector2 endPos, float t); // Get (evaluate) spline point: Linear 1272 | RLAPI Vector2 GetSplinePointBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t); // Get (evaluate) spline point: B-Spline 1273 | RLAPI Vector2 GetSplinePointCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t); // Get (evaluate) spline point: Catmull-Rom 1274 | RLAPI Vector2 GetSplinePointBezierQuad(Vector2 p1, Vector2 c2, Vector2 p3, float t); // Get (evaluate) spline point: Quadratic Bezier 1275 | RLAPI Vector2 GetSplinePointBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float t); // Get (evaluate) spline point: Cubic Bezier 1276 | 1277 | // Basic shapes collision detection functions 1278 | RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2); // Check collision between two rectangles 1279 | RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2); // Check collision between two circles 1280 | RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); // Check collision between circle and rectangle 1281 | RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle 1282 | RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); // Check if point is inside circle 1283 | RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); // Check if point is inside a triangle 1284 | RLAPI bool CheckCollisionPointPoly(Vector2 point, Vector2 *points, int pointCount); // Check if point is within a polygon described by array of vertices 1285 | RLAPI bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint); // Check the collision between two lines defined by two points each, returns collision point by reference 1286 | RLAPI bool CheckCollisionPointLine(Vector2 point, Vector2 p1, Vector2 p2, int threshold); // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold] 1287 | RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); // Get collision rectangle for two rectangles collision 1288 | 1289 | //------------------------------------------------------------------------------------ 1290 | // Texture Loading and Drawing Functions (Module: textures) 1291 | //------------------------------------------------------------------------------------ 1292 | 1293 | // Image loading functions 1294 | // NOTE: These functions do not require GPU access 1295 | RLAPI Image LoadImage(const char *fileName); // Load image from file into CPU memory (RAM) 1296 | RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize); // Load image from RAW file data 1297 | RLAPI Image LoadImageSvg(const char *fileNameOrString, int width, int height); // Load image from SVG file data or string with specified size 1298 | RLAPI Image LoadImageAnim(const char *fileName, int *frames); // Load image sequence from file (frames appended to image.data) 1299 | RLAPI Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load image from memory buffer, fileType refers to extension: i.e. '.png' 1300 | RLAPI Image LoadImageFromTexture(Texture2D texture); // Load image from GPU texture data 1301 | RLAPI Image LoadImageFromScreen(void); // Load image from screen buffer and (screenshot) 1302 | RLAPI bool IsImageReady(Image image); // Check if an image is ready 1303 | RLAPI void UnloadImage(Image image); // Unload image from CPU memory (RAM) 1304 | RLAPI bool ExportImage(Image image, const char *fileName); // Export image data to file, returns true on success 1305 | RLAPI unsigned char *ExportImageToMemory(Image image, const char *fileType, int *fileSize); // Export image to memory buffer 1306 | RLAPI bool ExportImageAsCode(Image image, const char *fileName); // Export image as code file defining an array of bytes, returns true on success 1307 | 1308 | // Image generation functions 1309 | RLAPI Image GenImageColor(int width, int height, Color color); // Generate image: plain color 1310 | RLAPI Image GenImageGradientLinear(int width, int height, int direction, Color start, Color end); // Generate image: linear gradient, direction in degrees [0..360], 0=Vertical gradient 1311 | RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer); // Generate image: radial gradient 1312 | RLAPI Image GenImageGradientSquare(int width, int height, float density, Color inner, Color outer); // Generate image: square gradient 1313 | RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2); // Generate image: checked 1314 | RLAPI Image GenImageWhiteNoise(int width, int height, float factor); // Generate image: white noise 1315 | RLAPI Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale); // Generate image: perlin noise 1316 | RLAPI Image GenImageCellular(int width, int height, int tileSize); // Generate image: cellular algorithm, bigger tileSize means bigger cells 1317 | RLAPI Image GenImageText(int width, int height, const char *text); // Generate image: grayscale image from text data 1318 | 1319 | // Image manipulation functions 1320 | RLAPI Image ImageCopy(Image image); // Create an image duplicate (useful for transformations) 1321 | RLAPI Image ImageFromImage(Image image, Rectangle rec); // Create an image from another image piece 1322 | RLAPI Image ImageText(const char *text, int fontSize, Color color); // Create an image from text (default font) 1323 | RLAPI Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint); // Create an image from text (custom sprite font) 1324 | RLAPI void ImageFormat(Image *image, int newFormat); // Convert image data to desired format 1325 | RLAPI void ImageToPOT(Image *image, Color fill); // Convert image to POT (power-of-two) 1326 | RLAPI void ImageCrop(Image *image, Rectangle crop); // Crop an image to a defined rectangle 1327 | RLAPI void ImageAlphaCrop(Image *image, float threshold); // Crop image depending on alpha value 1328 | RLAPI void ImageAlphaClear(Image *image, Color color, float threshold); // Clear alpha channel to desired color 1329 | RLAPI void ImageAlphaMask(Image *image, Image alphaMask); // Apply alpha mask to image 1330 | RLAPI void ImageAlphaPremultiply(Image *image); // Premultiply alpha channel 1331 | RLAPI void ImageBlurGaussian(Image *image, int blurSize); // Apply Gaussian blur using a box blur approximation 1332 | RLAPI void ImageResize(Image *image, int newWidth, int newHeight); // Resize image (Bicubic scaling algorithm) 1333 | RLAPI void ImageResizeNN(Image *image, int newWidth,int newHeight); // Resize image (Nearest-Neighbor scaling algorithm) 1334 | RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill); // Resize canvas and fill with color 1335 | RLAPI void ImageMipmaps(Image *image); // Compute all mipmap levels for a provided image 1336 | RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp); // Dither image data to 16bpp or lower (Floyd-Steinberg dithering) 1337 | RLAPI void ImageFlipVertical(Image *image); // Flip image vertically 1338 | RLAPI void ImageFlipHorizontal(Image *image); // Flip image horizontally 1339 | RLAPI void ImageRotate(Image *image, int degrees); // Rotate image by input angle in degrees (-359 to 359) 1340 | RLAPI void ImageRotateCW(Image *image); // Rotate image clockwise 90deg 1341 | RLAPI void ImageRotateCCW(Image *image); // Rotate image counter-clockwise 90deg 1342 | RLAPI void ImageColorTint(Image *image, Color color); // Modify image color: tint 1343 | RLAPI void ImageColorInvert(Image *image); // Modify image color: invert 1344 | RLAPI void ImageColorGrayscale(Image *image); // Modify image color: grayscale 1345 | RLAPI void ImageColorContrast(Image *image, float contrast); // Modify image color: contrast (-100 to 100) 1346 | RLAPI void ImageColorBrightness(Image *image, int brightness); // Modify image color: brightness (-255 to 255) 1347 | RLAPI void ImageColorReplace(Image *image, Color color, Color replace); // Modify image color: replace color 1348 | RLAPI Color *LoadImageColors(Image image); // Load color data from image as a Color array (RGBA - 32bit) 1349 | RLAPI Color *LoadImagePalette(Image image, int maxPaletteSize, int *colorCount); // Load colors palette from image as a Color array (RGBA - 32bit) 1350 | RLAPI void UnloadImageColors(Color *colors); // Unload color data loaded with LoadImageColors() 1351 | RLAPI void UnloadImagePalette(Color *colors); // Unload colors palette loaded with LoadImagePalette() 1352 | RLAPI Rectangle GetImageAlphaBorder(Image image, float threshold); // Get image alpha border rectangle 1353 | RLAPI Color GetImageColor(Image image, int x, int y); // Get image pixel color at (x, y) position 1354 | 1355 | // Image drawing functions 1356 | // NOTE: Image software-rendering functions (CPU) 1357 | RLAPI void ImageClearBackground(Image *dst, Color color); // Clear image background with given color 1358 | RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color); // Draw pixel within an image 1359 | RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color); // Draw pixel within an image (Vector version) 1360 | RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image 1361 | RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color); // Draw line within an image (Vector version) 1362 | RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color); // Draw a filled circle within an image 1363 | RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color); // Draw a filled circle within an image (Vector version) 1364 | RLAPI void ImageDrawCircleLines(Image *dst, int centerX, int centerY, int radius, Color color); // Draw circle outline within an image 1365 | RLAPI void ImageDrawCircleLinesV(Image *dst, Vector2 center, int radius, Color color); // Draw circle outline within an image (Vector version) 1366 | RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color); // Draw rectangle within an image 1367 | RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color); // Draw rectangle within an image (Vector version) 1368 | RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color); // Draw rectangle within an image 1369 | RLAPI void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color); // Draw rectangle lines within an image 1370 | RLAPI void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint); // Draw a source image within a destination image (tint applied to source) 1371 | RLAPI void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) within an image (destination) 1372 | RLAPI void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text (custom sprite font) within an image (destination) 1373 | 1374 | // Texture loading functions 1375 | // NOTE: These functions require GPU access 1376 | RLAPI Texture2D LoadTexture(const char *fileName); // Load texture from file into GPU memory (VRAM) 1377 | RLAPI Texture2D LoadTextureFromImage(Image image); // Load texture from image data 1378 | RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout); // Load cubemap from image, multiple image cubemap layouts supported 1379 | RLAPI RenderTexture2D LoadRenderTexture(int width, int height); // Load texture for rendering (framebuffer) 1380 | RLAPI bool IsTextureReady(Texture2D texture); // Check if a texture is ready 1381 | RLAPI void UnloadTexture(Texture2D texture); // Unload texture from GPU memory (VRAM) 1382 | RLAPI bool IsRenderTextureReady(RenderTexture2D target); // Check if a render texture is ready 1383 | RLAPI void UnloadRenderTexture(RenderTexture2D target); // Unload render texture from GPU memory (VRAM) 1384 | RLAPI void UpdateTexture(Texture2D texture, const void *pixels); // Update GPU texture with new data 1385 | RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels); // Update GPU texture rectangle with new data 1386 | 1387 | // Texture configuration functions 1388 | RLAPI void GenTextureMipmaps(Texture2D *texture); // Generate GPU mipmaps for a texture 1389 | RLAPI void SetTextureFilter(Texture2D texture, int filter); // Set texture scaling filter mode 1390 | RLAPI void SetTextureWrap(Texture2D texture, int wrap); // Set texture wrapping mode 1391 | 1392 | // Texture drawing functions 1393 | RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D 1394 | RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2 1395 | RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); // Draw a Texture2D with extended parameters 1396 | RLAPI void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint); // Draw a part of a texture defined by a rectangle 1397 | 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 1398 | RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely 1399 | 1400 | // Color/pixel related functions 1401 | RLAPI Color Fade(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f 1402 | RLAPI int ColorToInt(Color color); // Get hexadecimal value for a Color 1403 | RLAPI Vector4 ColorNormalize(Color color); // Get Color normalized as float [0..1] 1404 | RLAPI Color ColorFromNormalized(Vector4 normalized); // Get Color from normalized values [0..1] 1405 | RLAPI Vector3 ColorToHSV(Color color); // Get HSV values for a Color, hue [0..360], saturation/value [0..1] 1406 | RLAPI Color ColorFromHSV(float hue, float saturation, float value); // Get a Color from HSV values, hue [0..360], saturation/value [0..1] 1407 | RLAPI Color ColorTint(Color color, Color tint); // Get color multiplied with another color 1408 | RLAPI Color ColorBrightness(Color color, float factor); // Get color with brightness correction, brightness factor goes from -1.0f to 1.0f 1409 | RLAPI Color ColorContrast(Color color, float contrast); // Get color with contrast correction, contrast values between -1.0f and 1.0f 1410 | RLAPI Color ColorAlpha(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f 1411 | RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint); // Get src alpha-blended into dst color with tint 1412 | RLAPI Color GetColor(unsigned int hexValue); // Get Color structure from hexadecimal value 1413 | RLAPI Color GetPixelColor(void *srcPtr, int format); // Get Color from a source pixel pointer of certain format 1414 | RLAPI void SetPixelColor(void *dstPtr, Color color, int format); // Set color formatted into destination pixel pointer 1415 | RLAPI int GetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes for certain format 1416 | 1417 | //------------------------------------------------------------------------------------ 1418 | // Font Loading and Text Drawing Functions (Module: text) 1419 | //------------------------------------------------------------------------------------ 1420 | 1421 | // Font loading/unloading functions 1422 | RLAPI Font GetFontDefault(void); // Get the default Font 1423 | RLAPI Font LoadFont(const char *fileName); // Load font from file into GPU memory (VRAM) 1424 | RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set 1425 | RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style) 1426 | RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf' 1427 | RLAPI bool IsFontReady(Font font); // Check if a font is ready 1428 | RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount, int type); // Load font data for further use 1429 | RLAPI Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info 1430 | RLAPI void UnloadFontData(GlyphInfo *glyphs, int glyphCount); // Unload font chars info data (RAM) 1431 | RLAPI void UnloadFont(Font font); // Unload font from GPU memory (VRAM) 1432 | RLAPI bool ExportFontAsCode(Font font, const char *fileName); // Export font as code file, returns true on success 1433 | 1434 | // Text drawing functions 1435 | RLAPI void DrawFPS(int posX, int posY); // Draw current FPS 1436 | RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) 1437 | RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters 1438 | RLAPI void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation) 1439 | RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint) 1440 | RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int codepointCount, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint) 1441 | 1442 | // Text font info functions 1443 | RLAPI void SetTextLineSpacing(int spacing); // Set vertical line spacing when drawing with line-breaks 1444 | RLAPI int MeasureText(const char *text, int fontSize); // Measure string width for default font 1445 | RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing); // Measure string size for Font 1446 | RLAPI int GetGlyphIndex(Font font, int codepoint); // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found 1447 | RLAPI GlyphInfo GetGlyphInfo(Font font, int codepoint); // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found 1448 | RLAPI Rectangle GetGlyphAtlasRec(Font font, int codepoint); // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found 1449 | 1450 | // Text codepoints management functions (unicode characters) 1451 | RLAPI char *LoadUTF8(const int *codepoints, int length); // Load UTF-8 text encoded from codepoints array 1452 | RLAPI void UnloadUTF8(char *text); // Unload UTF-8 text encoded from codepoints array 1453 | RLAPI int *LoadCodepoints(const char *text, int *count); // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter 1454 | RLAPI void UnloadCodepoints(int *codepoints); // Unload codepoints data from memory 1455 | RLAPI int GetCodepointCount(const char *text); // Get total number of codepoints in a UTF-8 encoded string 1456 | RLAPI int GetCodepoint(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure 1457 | RLAPI int GetCodepointNext(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure 1458 | RLAPI int GetCodepointPrevious(const char *text, int *codepointSize); // Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure 1459 | RLAPI const char *CodepointToUTF8(int codepoint, int *utf8Size); // Encode one codepoint into UTF-8 byte array (array length returned as parameter) 1460 | 1461 | // Text strings management functions (no UTF-8 strings, only byte chars) 1462 | // NOTE: Some strings allocate memory internally for returned strings, just be careful! 1463 | RLAPI int TextCopy(char *dst, const char *src); // Copy one string to another, returns bytes copied 1464 | RLAPI bool TextIsEqual(const char *text1, const char *text2); // Check if two text string are equal 1465 | RLAPI unsigned int TextLength(const char *text); // Get text length, checks for '\0' ending 1466 | RLAPI const char *TextFormat(const char *text, ...); // Text formatting with variables (sprintf() style) 1467 | RLAPI const char *TextSubtext(const char *text, int position, int length); // Get a piece of a text string 1468 | RLAPI char *TextReplace(char *text, const char *replace, const char *by); // Replace text string (WARNING: memory must be freed!) 1469 | RLAPI char *TextInsert(const char *text, const char *insert, int position); // Insert text in a position (WARNING: memory must be freed!) 1470 | RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter); // Join text strings with delimiter 1471 | RLAPI const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings 1472 | RLAPI void TextAppend(char *text, const char *append, int *position); // Append text at specific position and move cursor! 1473 | RLAPI int TextFindIndex(const char *text, const char *find); // Find first text occurrence within a string 1474 | RLAPI const char *TextToUpper(const char *text); // Get upper case version of provided string 1475 | RLAPI const char *TextToLower(const char *text); // Get lower case version of provided string 1476 | RLAPI const char *TextToPascal(const char *text); // Get Pascal case notation version of provided string 1477 | RLAPI int TextToInteger(const char *text); // Get integer value from text (negative values not supported) 1478 | 1479 | //------------------------------------------------------------------------------------ 1480 | // Basic 3d Shapes Drawing Functions (Module: models) 1481 | //------------------------------------------------------------------------------------ 1482 | 1483 | // Basic geometric 3D shapes drawing functions 1484 | RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color); // Draw a line in 3D world space 1485 | RLAPI void DrawPoint3D(Vector3 position, Color color); // Draw a point in 3D space, actually a small line 1486 | RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space 1487 | RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) 1488 | RLAPI void DrawTriangleStrip3D(Vector3 *points, int pointCount, Color color); // Draw a triangle strip defined by points 1489 | RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color); // Draw cube 1490 | RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color); // Draw cube (Vector version) 1491 | RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color); // Draw cube wires 1492 | RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color); // Draw cube wires (Vector version) 1493 | RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color); // Draw sphere 1494 | RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere with extended parameters 1495 | RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires 1496 | RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone 1497 | 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 1498 | RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires 1499 | 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 1500 | RLAPI void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos 1501 | RLAPI void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos 1502 | RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color); // Draw a plane XZ 1503 | RLAPI void DrawRay(Ray ray, Color color); // Draw a ray line 1504 | RLAPI void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0)) 1505 | 1506 | //------------------------------------------------------------------------------------ 1507 | // Model 3d Loading and Drawing Functions (Module: models) 1508 | //------------------------------------------------------------------------------------ 1509 | 1510 | // Model management functions 1511 | RLAPI Model LoadModel(const char *fileName); // Load model from files (meshes and materials) 1512 | RLAPI Model LoadModelFromMesh(Mesh mesh); // Load model from generated mesh (default material) 1513 | RLAPI bool IsModelReady(Model model); // Check if a model is ready 1514 | RLAPI void UnloadModel(Model model); // Unload model (including meshes) from memory (RAM and/or VRAM) 1515 | RLAPI BoundingBox GetModelBoundingBox(Model model); // Compute model bounding box limits (considers all meshes) 1516 | 1517 | // Model drawing functions 1518 | RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint); // Draw a model (with texture if set) 1519 | RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters 1520 | RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint); // Draw a model wires (with texture if set) 1521 | 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 1522 | RLAPI void DrawBoundingBox(BoundingBox box, Color color); // Draw bounding box (wires) 1523 | RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float size, Color tint); // Draw a billboard texture 1524 | RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source 1525 | 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 1526 | 1527 | // Mesh management functions 1528 | RLAPI void UploadMesh(Mesh *mesh, bool dynamic); // Upload mesh vertex data in GPU and provide VAO/VBO ids 1529 | RLAPI void UpdateMeshBuffer(Mesh mesh, int index, const void *data, int dataSize, int offset); // Update mesh vertex data in GPU for a specific buffer index 1530 | RLAPI void UnloadMesh(Mesh mesh); // Unload mesh data from CPU and GPU 1531 | RLAPI void DrawMesh(Mesh mesh, Material material, Matrix transform); // Draw a 3d mesh with material and transform 1532 | RLAPI void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances); // Draw multiple mesh instances with material and different transforms 1533 | RLAPI bool ExportMesh(Mesh mesh, const char *fileName); // Export mesh data to file, returns true on success 1534 | RLAPI BoundingBox GetMeshBoundingBox(Mesh mesh); // Compute mesh bounding box limits 1535 | RLAPI void GenMeshTangents(Mesh *mesh); // Compute mesh tangents 1536 | 1537 | // Mesh generation functions 1538 | RLAPI Mesh GenMeshPoly(int sides, float radius); // Generate polygonal mesh 1539 | RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ); // Generate plane mesh (with subdivisions) 1540 | RLAPI Mesh GenMeshCube(float width, float height, float length); // Generate cuboid mesh 1541 | RLAPI Mesh GenMeshSphere(float radius, int rings, int slices); // Generate sphere mesh (standard sphere) 1542 | RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices); // Generate half-sphere mesh (no bottom cap) 1543 | RLAPI Mesh GenMeshCylinder(float radius, float height, int slices); // Generate cylinder mesh 1544 | RLAPI Mesh GenMeshCone(float radius, float height, int slices); // Generate cone/pyramid mesh 1545 | RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides); // Generate torus mesh 1546 | RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides); // Generate trefoil knot mesh 1547 | RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size); // Generate heightmap mesh from image data 1548 | RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); // Generate cubes-based map mesh from image data 1549 | 1550 | // Material loading/unloading functions 1551 | RLAPI Material *LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file 1552 | RLAPI Material LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps) 1553 | RLAPI bool IsMaterialReady(Material material); // Check if a material is ready 1554 | RLAPI void UnloadMaterial(Material material); // Unload material from GPU memory (VRAM) 1555 | RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...) 1556 | RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh 1557 | 1558 | // Model animations loading/unloading functions 1559 | RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, int *animCount); // Load model animations from file 1560 | RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); // Update model animation pose 1561 | RLAPI void UnloadModelAnimation(ModelAnimation anim); // Unload animation data 1562 | RLAPI void UnloadModelAnimations(ModelAnimation *animations, int animCount); // Unload animation array data 1563 | RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim); // Check model animation skeleton match 1564 | 1565 | // Collision detection functions 1566 | RLAPI bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2); // Check collision between two spheres 1567 | RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2); // Check collision between two bounding boxes 1568 | RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius); // Check collision between box and sphere 1569 | RLAPI RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius); // Get collision info between ray and sphere 1570 | RLAPI RayCollision GetRayCollisionBox(Ray ray, BoundingBox box); // Get collision info between ray and box 1571 | RLAPI RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform); // Get collision info between ray and mesh 1572 | RLAPI RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); // Get collision info between ray and triangle 1573 | RLAPI RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4); // Get collision info between ray and quad 1574 | 1575 | //------------------------------------------------------------------------------------ 1576 | // Audio Loading and Playing Functions (Module: audio) 1577 | //------------------------------------------------------------------------------------ 1578 | typedef void (*AudioCallback)(void *bufferData, unsigned int frames); 1579 | 1580 | // Audio device management functions 1581 | RLAPI void InitAudioDevice(void); // Initialize audio device and context 1582 | RLAPI void CloseAudioDevice(void); // Close the audio device and context 1583 | RLAPI bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully 1584 | RLAPI void SetMasterVolume(float volume); // Set master volume (listener) 1585 | RLAPI float GetMasterVolume(void); // Get master volume (listener) 1586 | 1587 | // Wave/Sound loading/unloading functions 1588 | RLAPI Wave LoadWave(const char *fileName); // Load wave data from file 1589 | RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav' 1590 | RLAPI bool IsWaveReady(Wave wave); // Checks if wave data is ready 1591 | RLAPI Sound LoadSound(const char *fileName); // Load sound from file 1592 | RLAPI Sound LoadSoundFromWave(Wave wave); // Load sound from wave data 1593 | RLAPI Sound LoadSoundAlias(Sound source); // Create a new sound that shares the same sample data as the source sound, does not own the sound data 1594 | RLAPI bool IsSoundReady(Sound sound); // Checks if a sound is ready 1595 | RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data 1596 | RLAPI void UnloadWave(Wave wave); // Unload wave data 1597 | RLAPI void UnloadSound(Sound sound); // Unload sound 1598 | RLAPI void UnloadSoundAlias(Sound alias); // Unload a sound alias (does not deallocate sample data) 1599 | RLAPI bool ExportWave(Wave wave, const char *fileName); // Export wave data to file, returns true on success 1600 | RLAPI bool ExportWaveAsCode(Wave wave, const char *fileName); // Export wave sample data to code (.h), returns true on success 1601 | 1602 | // Wave/Sound management functions 1603 | RLAPI void PlaySound(Sound sound); // Play a sound 1604 | RLAPI void StopSound(Sound sound); // Stop playing a sound 1605 | RLAPI void PauseSound(Sound sound); // Pause a sound 1606 | RLAPI void ResumeSound(Sound sound); // Resume a paused sound 1607 | RLAPI bool IsSoundPlaying(Sound sound); // Check if a sound is currently playing 1608 | RLAPI void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level) 1609 | RLAPI void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level) 1610 | RLAPI void SetSoundPan(Sound sound, float pan); // Set pan for a sound (0.5 is center) 1611 | RLAPI Wave WaveCopy(Wave wave); // Copy a wave to a new wave 1612 | RLAPI void WaveCrop(Wave *wave, int initSample, int finalSample); // Crop a wave to defined samples range 1613 | RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format 1614 | RLAPI float *LoadWaveSamples(Wave wave); // Load samples data from wave as a 32bit float data array 1615 | RLAPI void UnloadWaveSamples(float *samples); // Unload samples data loaded with LoadWaveSamples() 1616 | 1617 | // Music management functions 1618 | RLAPI Music LoadMusicStream(const char *fileName); // Load music stream from file 1619 | RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data 1620 | RLAPI bool IsMusicReady(Music music); // Checks if a music stream is ready 1621 | RLAPI void UnloadMusicStream(Music music); // Unload music stream 1622 | RLAPI void PlayMusicStream(Music music); // Start music playing 1623 | RLAPI bool IsMusicStreamPlaying(Music music); // Check if music is playing 1624 | RLAPI void UpdateMusicStream(Music music); // Updates buffers for music streaming 1625 | RLAPI void StopMusicStream(Music music); // Stop music playing 1626 | RLAPI void PauseMusicStream(Music music); // Pause music playing 1627 | RLAPI void ResumeMusicStream(Music music); // Resume playing paused music 1628 | RLAPI void SeekMusicStream(Music music, float position); // Seek music to a position (in seconds) 1629 | RLAPI void SetMusicVolume(Music music, float volume); // Set volume for music (1.0 is max level) 1630 | RLAPI void SetMusicPitch(Music music, float pitch); // Set pitch for a music (1.0 is base level) 1631 | RLAPI void SetMusicPan(Music music, float pan); // Set pan for a music (0.5 is center) 1632 | RLAPI float GetMusicTimeLength(Music music); // Get music time length (in seconds) 1633 | RLAPI float GetMusicTimePlayed(Music music); // Get current music time played (in seconds) 1634 | 1635 | // AudioStream management functions 1636 | RLAPI AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data) 1637 | RLAPI bool IsAudioStreamReady(AudioStream stream); // Checks if an audio stream is ready 1638 | RLAPI void UnloadAudioStream(AudioStream stream); // Unload audio stream and free memory 1639 | RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data 1640 | RLAPI bool IsAudioStreamProcessed(AudioStream stream); // Check if any audio stream buffers requires refill 1641 | RLAPI void PlayAudioStream(AudioStream stream); // Play audio stream 1642 | RLAPI void PauseAudioStream(AudioStream stream); // Pause audio stream 1643 | RLAPI void ResumeAudioStream(AudioStream stream); // Resume audio stream 1644 | RLAPI bool IsAudioStreamPlaying(AudioStream stream); // Check if audio stream is playing 1645 | RLAPI void StopAudioStream(AudioStream stream); // Stop audio stream 1646 | RLAPI void SetAudioStreamVolume(AudioStream stream, float volume); // Set volume for audio stream (1.0 is max level) 1647 | RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch); // Set pitch for audio stream (1.0 is base level) 1648 | RLAPI void SetAudioStreamPan(AudioStream stream, float pan); // Set pan for audio stream (0.5 is centered) 1649 | RLAPI void SetAudioStreamBufferSizeDefault(int size); // Default size for new audio streams 1650 | RLAPI void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data 1651 | 1652 | RLAPI void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream, receives the samples as s 1653 | RLAPI void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream 1654 | 1655 | RLAPI void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline, receives the samples as s 1656 | RLAPI void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline 1657 | 1658 | #if defined(__cplusplus) 1659 | } 1660 | #endif 1661 | 1662 | #endif // RAYLIB_H 1663 | --------------------------------------------------------------------------------