Merge pull request #20 from schveiguy/update42

Update42

README.md

@@ -3,13 +3,24 @@
 # raylib-d [![DUB](https://img.shields.io/dub/v/raylib-d?style=for-the-badge)](https://code.dlang.org/packages/raylib-d)
 (static) D bindings for [raylib](https://www.raylib.com/), a simple and easy-to-use library to learn videogames programming.
 
-*Note: this is a resurrected copy of the original raylib-d. The original author, onroundit (Petro Romanovych) deleted his github acccount. Therefore, some links in this README are broken, and some of the history is lost for good. I will accept any PRs that fix broken links or replace original data, but the code history itself is intact.*
-
 # Installation
-`dub add raylib-d`
 
-## First, get a copy of Raylib
-You can get the library by compiling it from the [source](https://github.com/raysan5/raylib), download the [official precompiled binaries](https://github.com/raysan5/raylib/releases). The local copies of binaries are no longer available, as that history was lost.
+## Adding the dependency
+
+raylib-d is used via the [dub](https://code.dlang.org) build system.
+
+Use `dub add` to add raylib-d to the dependency list of an existing project:
+
+```sh
+> dub add raylib-d
+Adding dependency raylib-d ~>4.2.0
+>
+```
+
+Or you can add the dependency through the interactive prompts when creating your project with `dub init`
+
+## Get a copy of Raylib
+You can get the library by compiling it from the [source](https://github.com/raysan5/raylib), or download the [official precompiled binaries](https://github.com/raysan5/raylib/releases).
 
 *WARNING*: Make sure you get the correct copy of the raylib library based on the version of raylib-d! Getting the incorrect version will cause SILENT compatibility errors, including memory corruption. It is extremely important to match these together.
 
@@ -17,9 +28,23 @@ If you depend on raylib-d vX.Y.Z, then your raylib binary should be vX.Y.0. Note
 
 For example, if you depend on raylib-d version `v3.0.x`, then you should download raylib version `3.0.0`. If you depend on raylib-d version `3.7.x`, then you should download raylib version `3.7.0`.
 
-#### Linux/Mac:
+### Runtime validation of binding
+
+Starting with version 4.2.0, raylib-d includes a new module `raylib.binding`,
+which at the moment contains one function: `validateRaylibBinding`. @raysan5
+was kind enough to include a runtime-accessible version string for version
+4.2.0 of the library, so now we can validate the raylib binding mechanically
+without relying on proper environmental setup. So if you compile against one
+version, but link against another, you can call this function and it will exit
+the program with an error code if the binding is incorrect. This is better than
+creating memory corruption errors!
+
+If you link against an earlier verison of raylib, it should fail to link if
+this symbol doesn't exist.
 
-You must make raylib visible to the linkage binder. CD into the extracted raylib folder.
+### Linux/Mac:
+
+You must make raylib visible to the linker. `cd` into the extracted raylib folder (e.g. `raylib-4.2.0_macos`).
 
 Now we must make raylib visible to the compiler and linker system wide. Simply run the following.
 ```
@@ -31,28 +56,23 @@ Linux users must also update the linker with this command:
 sudo ldconfig
 ```
 
-#### Windows:
+### Windows:
 On Windows you must drag and drop all the required library files into the root directory of your project. These are `raylib.dll`, `raylib.lib`, and `raylibdll.lib`.
 
 ## In order to link against raylib, add it to your dub.json.
-#### Using version 4.0.0 as an example.
-### On Linux/Mac:
-```json
-"dependencies": { "raylib-d": "~>4.0.0" },
-"libs": [ "raylib" ],
-```
 
-### On Windows:
-Starting with `4.0.0`, raylib includes 2 windows linker files, `raylib.lib` for static linking (not recommended) and `raylibdll.lib` for dynamic linking. Even though the dll is called `raylib.dll`, use the `raylibdll` for the linker file to link dynamically.
-```json
-"dependencies": { "raylib-d": "~>4.0.0" },
-"libs": [ "raylibdll" ],
-```
 
+Starting with `4.0.0`, raylib on windows includes 2 windows linker files, `raylib.lib` for static linking (not recommended) and `raylibdll.lib` for dynamic linking. Even though the dll is called `raylib.dll`, use the `raylibdll` for the linker file to link dynamically.
+
+You can link against all oses correctly by using os-specific `libs` keys.
 
-(*Note: this is missing, but may be available from wayback machine*)
+Using version 4.2.0 as an example:
 
-For more information look into the [wiki](https://github.com/onroundit/raylib-d/wiki/Installation).
+```json
+"dependencies": { "raylib-d": "~>4.2.0" },
+"libs-posix": [ "raylib" ],
+"libs-windows": [ "raylibdll" ],
+```
 
 # Example
 ```D
@@ -60,6 +80,8 @@ import raylib;
 
 void main()
 {
+        // call this before using raylib
+        validateRaylibBinding();
 	InitWindow(800, 600, "Hello, Raylib-D!");
 	while (!WindowShouldClose())
 	{
@@ -72,9 +94,9 @@ void main()
 }
 ```
 
-*Note: this is missing, but may be available from wayback machine*
+# Docs/Cheatsheet
 
-# [Docs / cheatsheet](https://github.com/onroundit/raylib-d/wiki/Docs-(cheatsheet))
+At the moment, we do not properly ddoc the binding. This may change in the near future. However, all documentation is valid from the raylib [online cheatsheet](https://www.raylib.com/cheatsheet/cheatsheet.html), or you can view the binding source files directly.
 
 # License
 raylib-d is licensed under an unmodified zlib/libpng license. View [LICENSE](LICENSE).

dub.json

@@ -5,14 +5,16 @@
 	"authors": [
 		"ONROUNDIT"
 	],
-	"copyright": "Copyright (c) Ramon Santamaria (@raysan5), Petro Romanovych (@onroundit), Jan Hoenig (@m3m0ry), Steven Schveighoffer (@schveiguy)",
-	"configurations": [
-        {
-            "name": "unittest",
-            "dependencies": {
-                "fluent-asserts": "~>0.13.0"
+        "configurations" : [
+            {
+                "name": "library"
+            },
+            {
+                "name": "unittest",
+                "versions" : ["raylib_test"]
             }
-        }
-    ],	
+        ],
+	"copyright": "Copyright (c) Ramon Santamaria (@raysan5), Petro Romanovych (@onroundit), Jan Hoenig (@m3m0ry), Steven Schveighoffer (@schveiguy)",
+        "excludedSourceFiles": ["source/rlgl.d", "source/raymath.d", "source/easings.d", "source/raygui.d", "source/raymathext.d", "source/raylib_types.d"],
 	"targetType": "sourceLibrary"
 }

generating.md

@@ -7,7 +7,7 @@ Three modules should be regenerated: `raylib`, `raymath` and `rlgl`.
 Run the following command from the `raylib/src` directory. Note: path/to/raylib-d should be the path to the raylib-d repository that you have on your system.
 
 ```
-dstep raylib.h raymath.h rlgl.h -o path/to/raylib-d/source --space-after-function-name=false --skip Vector2 \
+dstep raylib.h raymath.h rlgl.h -o path/to/raylib-d/source/raylib --space-after-function-name=false --skip Vector2 \
     --skip Vector3 --skip Vector4 --skip Quaternion --skip Matrix --skip Rectangle --skip RL_MALLOC --skip RL_CALLOC \
     --skip RL_REALLOC --skip RL_FREE
 ```
@@ -15,6 +15,8 @@ dstep raylib.h raymath.h rlgl.h -o path/to/raylib-d/source --space-after-functio
 Note: we're skipping a couple symbols because we define them manually in `raylib_types`. We also skip memory functions
 because they only have effect when compiling Raylib in C.
 
+Finally, the `raylib.h` file will export as `raylib.d`, but it should be moved to `raylib/package.d`.
+
 After you regenerate them, they won't be ready to use yet. We need to add module declarations and imports at the top
 of each module:
 
@@ -23,22 +25,23 @@ module raylib;
 
 public
 {
-    import rlgl;
-    import easings;
-    import raymath;
-    import raymathext;
-    import raylib_types;
+    import raylib.rlgl;
+    import raylib.reasings;
+    import raylib.raymath;
+    import raylib.raymathext;
+    import raylib.raylib_types;
+    import raylib.binding;
 }
 ```
 
 ```d
-module raymath;
+module raylib.raymath;
 
 import raylib;
 ```
 
 ```d
-module rlgl;
+module raylib.rlgl;
 
 import raylib;
 ```
@@ -46,28 +49,6 @@ import raylib;
 Additionally, each of those modules will have an automatically generated `extern (C):` line. We need to find it and
 edit it to `extern (C) @nogc nothrow:`.
 
-## For version 3.7.0 and possibly earlier versions
-
-dstep will also make a mistake in `raylib.d` and incorrectly define a few `alias`es as `enum`s. Those must be fixed.
-Look for a block of code similar to this:
-
-```d
-// Temporal hacks to avoid breaking old codebases using
-// deprecated raylib implementation or definitions
-enum FormatText = TextFormat;
-enum LoadText = LoadFileText;
-enum GetExtension = GetFileExtension;
-enum GetImageData = LoadImageColors;
-enum FILTER_POINT = TextureFilter.TEXTURE_FILTER_POINT;
-enum FILTER_BILINEAR = TextureFilter.TEXTURE_FILTER_BILINEAR;
-enum MAP_DIFFUSE = MATERIAL_MAP_DIFFUSE;
-enum PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 = PixelFormat.PIXELFORMAT_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
-```
-
-Change `enum` for each of the functions `FormatText`, `LoadText`, `GetExtension`, and `GetImageData` to `alias`. The others can remain `enum`s.
-
-These definitions are not present since 4.0.0
-
 This should be enough. Run `dub test` and see if it compiles.
 
 [dstep]: https://github.com/jacob-carlborg/dstep

source/easings.d

@@ -1,243 +1,4 @@
-/*******************************************************************************************
-*
-*   raylib easings (header only file)
-*
-*   Useful easing functions for values animation
-*
-*   This header uses:
-*       #define EASINGS_STATIC_INLINE       // Inlines all functions code, so it runs faster.
-*                                           // This requires lots of memory on system.
-*   How to use:
-*   The four inputs t,b,c,d are defined as follows:
-*   t = current time (in any unit measure, but same unit as duration)
-*   b = starting value to interpolate
-*   c = the total change in value of b that needs to occur
-*   d = total time it should take to complete (duration)
-*
-*   Example:
-*
-*   int currentTime = 0;
-*   int duration = 100;
-*   float startPositionX = 0.0f;
-*   float finalPositionX = 30.0f;
-*   float currentPositionX = startPositionX;
-*
-*   while (currentPositionX < finalPositionX)
-*   {
-*       currentPositionX = EaseSineIn(currentTime, startPositionX, finalPositionX - startPositionX, duration);
-*       currentTime++;
-*   }
-*
-*   A port of Robert Penner's easing equations to C (http://robertpenner.com/easing/)
-*
-*   Robert Penner License
-*   ---------------------------------------------------------------------------------
-*   Open source under the BSD License.
-*
-*   Copyright (c) 2001 Robert Penner. All rights reserved.
-*
-*   Redistribution and use in source and binary forms, with or without modification,
-*   are permitted provided that the following conditions are met:
-*
-*       - Redistributions of source code must retain the above copyright notice,
-*         this list of conditions and the following disclaimer.
-*       - Redistributions in binary form must reproduce the above copyright notice,
-*         this list of conditions and the following disclaimer in the documentation
-*         and/or other materials provided with the distribution.
-*       - Neither the name of the author nor the names of contributors may be used
-*         to endorse or promote products derived from this software without specific
-*         prior written permission.
-*
-*   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-*   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-*   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-*   IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-*   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-*   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-*   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-*   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-*   OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-*   OF THE POSSIBILITY OF SUCH DAMAGE.
-*   ---------------------------------------------------------------------------------
-*
-*   Copyright (c) 2015 Ramon Santamaria
-*
-*   This software is provided "as-is", without any express or implied warranty. In no event
-*   will the authors be held liable for any damages arising from the use of this software.
-*
-*   Permission is granted to anyone to use this software for any purpose, including commercial
-*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
-*
-*     1. The origin of this software must not be misrepresented; you must not claim that you
-*     wrote the original software. If you use this software in a product, an acknowledgment
-*     in the product documentation would be appreciated but is not required.
-*
-*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
-*     as being the original software.
-*
-*     3. This notice may not be removed or altered from any source distribution.
-*
-**********************************************************************************************/
+deprecated("module easings is deprecated, import raylib.reasings instead")
+module easings;
 
-extern (C):
-pragma(inline, true): // NOTE: By default, compile functions as static inline
-
-import core.stdc.math; // Required for: sinf(), cosf(), sqrt(), pow()
-
-enum PI = 3.14159265358979323846f; //Required as PI is not always defined in math.h
-
-// Linear Easing functions
-static float EaseLinearNone(float t, float b, float c, float d) { return (c*t/d + b); }
-static float EaseLinearIn(float t, float b, float c, float d) { return (c*t/d + b); }
-static float EaseLinearOut(float t, float b, float c, float d) { return (c*t/d + b); }
-static float EaseLinearInOut(float t,float b, float c, float d) { return (c*t/d + b); }
-
-// Sine Easing functions
-static float EaseSineIn(float t, float b, float c, float d) { return (-c*cosf(t/d*(PI/2.0f)) + c + b); }
-static float EaseSineOut(float t, float b, float c, float d) { return (c*sinf(t/d*(PI/2.0f)) + b); }
-static float EaseSineInOut(float t, float b, float c, float d) { return (-c/2.0f*(cosf(PI*t/d) - 1.0f) + b); }
-
-// Circular Easing functions
-static float EaseCircIn(float t, float b, float c, float d) { t /= d; return (-c*(sqrtf(1.0f - t*t) - 1.0f) + b); }
-static float EaseCircOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*sqrtf(1.0f - t*t) + b); }
-static float EaseCircInOut(float t, float b, float c, float d)
-{
-    if ((t/=d/2.0f) < 1.0f) return (-c/2.0f*(sqrtf(1.0f - t*t) - 1.0f) + b);
-    t -= 2.0f; return (c/2.0f*(sqrtf(1.0f - t*t) + 1.0f) + b);
-}
-
-// Cubic Easing functions
-static float EaseCubicIn(float t, float b, float c, float d) { t /= d; return (c*t*t*t + b); }
-static float EaseCubicOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*(t*t*t + 1.0f) + b); }
-static float EaseCubicInOut(float t, float b, float c, float d)
-{
-    if ((t/=d/2.0f) < 1.0f) return (c/2.0f*t*t*t + b);
-    t -= 2.0f; return (c/2.0f*(t*t*t + 2.0f) + b);
-}
-
-// Quadratic Easing functions
-static float EaseQuadIn(float t, float b, float c, float d) { t /= d; return (c*t*t + b); }
-static float EaseQuadOut(float t, float b, float c, float d) { t /= d; return (-c*t*(t - 2.0f) + b); }
-static float EaseQuadInOut(float t, float b, float c, float d)
-{
-    if ((t/=d/2) < 1) return (((c/2)*(t*t)) + b);
-    return (-c/2.0f*(((t - 1.0f)*(t - 3.0f)) - 1.0f) + b);
-}
-
-// Exponential Easing functions
-static float EaseExpoIn(float t, float b, float c, float d) { return (t == 0.0f) ? b : (c*powf(2.0f, 10.0f*(t/d - 1.0f)) + b); }
-static float EaseExpoOut(float t, float b, float c, float d) { return (t == d) ? (b + c) : (c*(-powf(2.0f, -10.0f*t/d) + 1.0f) + b);    }
-static float EaseExpoInOut(float t, float b, float c, float d)
-{
-    if (t == 0.0f) return b;
-    if (t == d) return (b + c);
-    if ((t/=d/2.0f) < 1.0f) return (c/2.0f*powf(2.0f, 10.0f*(t - 1.0f)) + b);
-
-    return (c/2.0f*(-powf(2.0f, -10.0f*(t - 1.0f)) + 2.0f) + b);
-}
-
-// Back Easing functions
-static float EaseBackIn(float t, float b, float c, float d)
-{
-    float s = 1.70158f;
-    float postFix = t/=d;
-    return (c*(postFix)*t*((s + 1.0f)*t - s) + b);
-}
-
-static float EaseBackOut(float t, float b, float c, float d)
-{
-    float s = 1.70158f;
-    t = t/d - 1.0f;
-    return (c*(t*t*((s + 1.0f)*t + s) + 1.0f) + b);
-}
-
-static float EaseBackInOut(float t, float b, float c, float d)
-{
-    float s = 1.70158f;
-    if ((t/=d/2.0f) < 1.0f)
-    {
-        s *= 1.525f;
-        return (c/2.0f*(t*t*((s + 1.0f)*t - s)) + b);
-    }
-
-    float postFix = t-=2.0f;
-    s *= 1.525f;
-    return (c/2.0f*((postFix)*t*((s + 1.0f)*t + s) + 2.0f) + b);
-}
-
-// Bounce Easing functions
-static float EaseBounceOut(float t, float b, float c, float d)
-{
-    if ((t/=d) < (1.0f/2.75f))
-    {
-        return (c*(7.5625f*t*t) + b);
-    }
-    else if (t < (2.0f/2.75f))
-    {
-        float postFix = t-=(1.5f/2.75f);
-        return (c*(7.5625f*(postFix)*t + 0.75f) + b);
-    }
-    else if (t < (2.5/2.75))
-    {
-        float postFix = t-=(2.25f/2.75f);
-        return (c*(7.5625f*(postFix)*t + 0.9375f) + b);
-    }
-    else
-    {
-        float postFix = t-=(2.625f/2.75f);
-        return (c*(7.5625f*(postFix)*t + 0.984375f) + b);
-    }
-}
-
-static float EaseBounceIn(float t, float b, float c, float d) { return (c - EaseBounceOut(d - t, 0.0f, c, d) + b); }
-static float EaseBounceInOut(float t, float b, float c, float d)
-{
-    if (t < d/2.0f) return (EaseBounceIn(t*2.0f, 0.0f, c, d)*0.5f + b);
-    else return (EaseBounceOut(t*2.0f - d, 0.0f, c, d)*0.5f + c*0.5f + b);
-}
-
-// Elastic Easing functions
-static float EaseElasticIn(float t, float b, float c, float d)
-{
-    if (t == 0.0f) return b;
-    if ((t/=d) == 1.0f) return (b + c);
-
-    float p = d*0.3f;
-    float a = c;
-    float s = p/4.0f;
-    float postFix = a*powf(2.0f, 10.0f*(t-=1.0f));
-
-    return (-(postFix*sinf((t*d-s)*(2.0f*PI)/p )) + b);
-}
-
-static float EaseElasticOut(float t, float b, float c, float d)
-{
-    if (t == 0.0f) return b;
-    if ((t/=d) == 1.0f) return (b + c);
-
-    float p = d*0.3f;
-    float a = c;
-    float s = p/4.0f;
-
-    return (a*powf(2.0f,-10.0f*t)*sinf((t*d-s)*(2.0f*PI)/p) + c + b);
-}
-
-static float EaseElasticInOut(float t, float b, float c, float d)
-{
-    if (t == 0.0f) return b;
-    if ((t/=d/2.0f) == 2.0f) return (b + c);
-
-    float p = d*(0.3f*1.5f);
-    float a = c;
-    float s = p/4.0f;
-
-    if (t < 1.0f)
-    {
-        float postFix = a*powf(2.0f, 10.0f*(t-=1.0f));
-        return -0.5f*(postFix*sinf((t*d-s)*(2.0f*PI)/p)) + b;
-    }
-
-    float postFix = a*powf(2.0f, -10.0f*(t-=1.0f));
-
-    return (postFix*sinf((t*d-s)*(2.0f*PI)/p)*0.5f + c + b);
-}
+public import raylib.reasings;

source/raygui.d

@@ -1,3 +1,5 @@
+deprecated("raygui is not up to date and will be removed in a future version of raylib-d")
+module raygui;
 /*******************************************************************************************
 *
 *   raygui v2.7 - A simple and easy-to-use immediate-mode gui library

source/raylib/binding.d

@@ -0,0 +1,34 @@
+/**
+ * D-specialized raylib functions. These functions help the D experience on
+ * raylib.
+ */
+module raylib.binding;
+import raylib;
+
+// stored inside raylib to validate the binding
+private extern(C) extern __gshared const(char)* raylibVersion;
+
+/**
+ * Call this function before using any raylib functions to validate the binding
+ * matches what the header information says. If you don't call this, it's
+ * possible your binding will fail with such fun issues as memory corruption.
+ *
+ * If the binding is not valid, then the program will exit with a -1 error code.
+ *
+ * The function is not included when running raylib unittests, so there are no
+ * linker errors. (raylib-d unittests do not test the C binding)
+ */
+version(raylib_test) {} else
+void validateRaylibBinding() @nogc nothrow {
+    import core.stdc.stdio;
+    import core.stdc.stdlib;
+    import core.stdc.string;
+    auto rlv = raylibVersion[0 .. strlen(raylibVersion)];
+    if(rlv != RAYLIB_VERSION)
+    {
+        printf("FATAL ERROR: Raylib binding expected version %.*s, library version is %.*s\n",
+               cast(int)RAYLIB_VERSION.length, RAYLIB_VERSION.ptr,
+               cast(int)rlv.length, rlv.ptr);
+        exit(-1);
+    }
+}

source/raylib.d → source/raylib/package.d

@@ -1,16 +1,6 @@
-module raylib;
-
-public
-{
-    import rlgl;
-    import easings;
-    import raymath;
-    import raymathext;
-    import raylib_types;
-}
 /**********************************************************************************************
 *
-*   raylib v4.0 - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com)
+*   raylib v4.2 - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com)
 *
 *   FEATURES:
 *       - NO external dependencies, all required libraries included with raylib
@@ -43,8 +33,8 @@ public
 *
 *   OPTIONAL DEPENDENCIES (included):
 *       [rcore] msf_gif (Miles Fogle) for GIF recording
-*       [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorythm
-*       [rcore] sdefl (Micha Mettke) for DEFLATE compression algorythm
+*       [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm
+*       [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm
 *       [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...)
 *       [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG)
 *       [rtextures] stb_image_resize (Sean Barret) for image resizing algorithms
@@ -66,7 +56,7 @@ public
 *   raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified,
 *   BSD-like license that allows static linking with closed source software:
 *
-*   Copyright (c) 2013-2021 Ramon Santamaria (@raysan5)
+*   Copyright (c) 2013-2022 Ramon Santamaria (@raysan5)
 *
 *   This software is provided "as-is", without any express or implied warranty. In no event
 *   will the authors be held liable for any damages arising from the use of this software.
@@ -84,6 +74,17 @@ public
 *     3. This notice may not be removed or altered from any source distribution.
 *
 **********************************************************************************************/
+module raylib;
+
+public
+{
+    import raylib.rlgl;
+    import raylib.reasings;
+    import raylib.raymath;
+    import raylib.raymathext;
+    import raylib.raylib_types;
+    import raylib.binding;
+}
 
 import core.stdc.config;
 import core.stdc.stdarg;
@@ -92,7 +93,7 @@ extern (C) @nogc nothrow:
 
 // Required for: va_list - Only used by TraceLogCallback
 
-enum RAYLIB_VERSION = "4.0";
+enum RAYLIB_VERSION = "4.2";
 
 // Function specifiers in case library is build/used as a shared library (Windows)
 // NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
@@ -112,6 +113,7 @@ enum DEG2RAD = PI / 180.0f;
 enum RAD2DEG = 180.0f / PI;
 
 // Allow custom memory allocators
+// NOTE: Require recompiling raylib sources
 
 // NOTE: MSVC C++ compiler does not support compound literals (C99 feature)
 // Plain structures in C++ (without constructors) can be initialized with { }
@@ -276,7 +278,7 @@ struct Mesh
     // Vertex attributes data
     float* vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
     float* texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
-    float* texcoords2; // Vertex second texture coordinates (useful for lightmaps) (shader-location = 5)
+    float* texcoords2; // Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5)
     float* normals; // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
     float* tangents; // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
     ubyte* colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
@@ -390,12 +392,16 @@ struct Wave
     void* data; // Buffer data pointer
 }
 
+// Opaque structs declaration
+// NOTE: Actual structs are defined internally in raudio module
 struct rAudioBuffer;
+struct rAudioProcessor;
 
 // AudioStream, custom audio stream
 struct AudioStream
 {
     rAudioBuffer* buffer; // Pointer to internal data used by the audio system
+    rAudioProcessor* processor; // Pointer to internal data processor, useful for audio effects
 
     uint sampleRate; // Frequency (samples per second)
     uint sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
@@ -448,6 +454,14 @@ struct VrStereoConfig
     float[2] scaleIn; // VR distortion scale in
 }
 
+// File path list
+struct FilePathList
+{
+    uint capacity; // Filepaths max entries
+    uint count; // Filepaths entries count
+    char** paths; // Filepaths entries
+}
+
 //----------------------------------------------------------------------------------
 // Enumerators Definition
 //----------------------------------------------------------------------------------
@@ -468,6 +482,7 @@ enum ConfigFlags
     FLAG_WINDOW_ALWAYS_RUN = 0x00000100, // Set to allow windows running while minimized
     FLAG_WINDOW_TRANSPARENT = 0x00000010, // Set to allow transparent framebuffer
     FLAG_WINDOW_HIGHDPI = 0x00002000, // Set to support HighDPI
+    FLAG_WINDOW_MOUSE_PASSTHROUGH = 0x00004000, // Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED
     FLAG_MSAA_4X_HINT = 0x00000020, // Set to try enabling MSAA 4X
     FLAG_INTERLACED_HINT = 0x00010000 // Set to try enabling interlaced video format (for V3D)
 }
@@ -787,7 +802,7 @@ enum PixelFormat
 // NOTE 2: Filter is accordingly set for minification and magnification
 enum TextureFilter
 {
-    TEXTURE_FILTER_POINT = 0, // No filter, just pixel aproximation
+    TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation
     TEXTURE_FILTER_BILINEAR = 1, // Linear filtering
     TEXTURE_FILTER_TRILINEAR = 2, // Trilinear filtering (linear with mipmaps)
     TEXTURE_FILTER_ANISOTROPIC_4X = 3, // Anisotropic filtering 4x
@@ -831,7 +846,8 @@ enum BlendMode
     BLEND_MULTIPLIED = 2, // Blend textures multiplying colors
     BLEND_ADD_COLORS = 3, // Blend textures adding colors (alternative)
     BLEND_SUBTRACT_COLORS = 4, // Blend textures subtracting colors (alternative)
-    BLEND_CUSTOM = 5 // Belnd textures using custom src/dst factors (use rlSetBlendMode())
+    BLEND_ALPHA_PREMULTIPLY = 5, // Blend premultiplied textures considering alpha
+    BLEND_CUSTOM = 6 // Blend textures using custom src/dst factors (use rlSetBlendMode())
 }
 
 // Gesture
@@ -907,7 +923,7 @@ bool IsWindowMaximized(); // Check if window is currently maximized (only PLATFO
 bool IsWindowFocused(); // Check if window is currently focused (only PLATFORM_DESKTOP)
 bool IsWindowResized(); // Check if window has been resized last frame
 bool IsWindowState(uint flag); // Check if one specific window flag is enabled
-void SetWindowState(uint flags); // Set window configuration state using flags
+void SetWindowState(uint flags); // Set window configuration state using flags (only PLATFORM_DESKTOP)
 void ClearWindowState(uint flags); // Clear window configuration state flags
 void ToggleFullscreen(); // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)
 void MaximizeWindow(); // Set window state: maximized, if resizable (only PLATFORM_DESKTOP)
@@ -919,14 +935,17 @@ void SetWindowPosition(int x, int y); // Set window position on screen (only PLA
 void SetWindowMonitor(int monitor); // Set monitor for the current window (fullscreen mode)
 void SetWindowMinSize(int width, int height); // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
 void SetWindowSize(int width, int height); // Set window dimensions
+void SetWindowOpacity(float opacity); // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP)
 void* GetWindowHandle(); // Get native window handle
 int GetScreenWidth(); // Get current screen width
 int GetScreenHeight(); // Get current screen height
+int GetRenderWidth(); // Get current render width (it considers HiDPI)
+int GetRenderHeight(); // Get current render height (it considers HiDPI)
 int GetMonitorCount(); // Get number of connected monitors
 int GetCurrentMonitor(); // Get current connected monitor
 Vector2 GetMonitorPosition(int monitor); // Get specified monitor position
-int GetMonitorWidth(int monitor); // Get specified monitor width (max available by monitor)
-int GetMonitorHeight(int monitor); // Get specified monitor height (max available by monitor)
+int GetMonitorWidth(int monitor); // Get specified monitor width (current video mode used by monitor)
+int GetMonitorHeight(int monitor); // Get specified monitor height (current video mode used by monitor)
 int GetMonitorPhysicalWidth(int monitor); // Get specified monitor physical width in millimetres
 int GetMonitorPhysicalHeight(int monitor); // Get specified monitor physical height in millimetres
 int GetMonitorRefreshRate(int monitor); // Get specified monitor refresh rate
@@ -935,6 +954,8 @@ Vector2 GetWindowScaleDPI(); // Get window scale DPI factor
 const(char)* GetMonitorName(int monitor); // Get the human-readable, UTF-8 encoded name of the primary monitor
 void SetClipboardText(const(char)* text); // Set clipboard text content
 const(char)* GetClipboardText(); // Get clipboard text content
+void EnableEventWaiting(); // Enable waiting for events on EndDrawing(), no automatic event polling
+void DisableEventWaiting(); // Disable waiting for events on EndDrawing(), automatic events polling
 
 // Custom frame control functions
 // NOTE: Those functions are intended for advance users that want full control over the frame processing
@@ -942,7 +963,7 @@ const(char)* GetClipboardText(); // Get clipboard text content
 // To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL
 void SwapScreenBuffer(); // Swap back buffer with front buffer (screen drawing)
 void PollInputEvents(); // Register all input events
-void WaitTime(float ms); // Wait for some milliseconds (halt program execution)
+void WaitTime(double seconds); // Wait for some time (halt program execution)
 
 // Cursor-related functions
 void ShowCursor(); // Shows cursor
@@ -992,9 +1013,9 @@ Ray GetMouseRay(Vector2 mousePosition, Camera camera); // Get a ray trace from m
 Matrix GetCameraMatrix(Camera camera); // Get camera transform matrix (view matrix)
 Matrix GetCameraMatrix2D(Camera2D camera); // Get camera 2d transform matrix
 Vector2 GetWorldToScreen(Vector3 position, Camera camera); // Get the screen space position for a 3d world space position
+Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Get the world space position for a 2d camera screen space position
 Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Get size position for a 3d world space position
 Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera); // Get the screen space position for a 2d camera world space position
-Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Get the world space position for a 2d camera screen space position
 
 // Timing-related functions
 void SetTargetFPS(int fps); // Set target FPS (maximum)
@@ -1014,6 +1035,8 @@ void* MemAlloc(int size); // Internal memory allocator
 void* MemRealloc(void* ptr, int size); // Internal memory reallocator
 void MemFree(void* ptr); // Internal memory free
 
+void OpenURL(const(char)* url); // Open URL with default system browser (if available)
+
 // Set custom callbacks
 // WARNING: Callbacks setup is intended for advance users
 void SetTraceLogCallback(TraceLogCallback callback); // Set custom trace log
@@ -1026,37 +1049,36 @@ void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file
 ubyte* LoadFileData(const(char)* fileName, uint* bytesRead); // Load file data as byte array (read)
 void UnloadFileData(ubyte* data); // Unload file data allocated by LoadFileData()
 bool SaveFileData(const(char)* fileName, void* data, uint bytesToWrite); // Save data to file from byte array (write), returns true on success
+bool ExportDataAsCode(const(char)* data, uint size, const(char)* fileName); // Export data to code (.h), returns true on success
 char* LoadFileText(const(char)* fileName); // Load text data from file (read), returns a '\0' terminated string
 void UnloadFileText(char* text); // Unload file text data allocated by LoadFileText()
 bool SaveFileText(const(char)* fileName, char* text); // Save text data to file (write), string must be '\0' terminated, returns true on success
 bool FileExists(const(char)* fileName); // Check if file exists
 bool DirectoryExists(const(char)* dirPath); // Check if a directory path exists
 bool IsFileExtension(const(char)* fileName, const(char)* ext); // Check file extension (including point: .png, .wav)
+int GetFileLength(const(char)* fileName); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h)
 const(char)* GetFileExtension(const(char)* fileName); // Get pointer to extension for a filename string (includes dot: '.png')
 const(char)* GetFileName(const(char)* filePath); // Get pointer to filename for a path string
 const(char)* GetFileNameWithoutExt(const(char)* filePath); // Get filename string without extension (uses static string)
 const(char)* GetDirectoryPath(const(char)* filePath); // Get full path for a given fileName with path (uses static string)
 const(char)* GetPrevDirectoryPath(const(char)* dirPath); // Get previous directory path for a given path (uses static string)
 const(char)* GetWorkingDirectory(); // Get current working directory (uses static string)
-char** GetDirectoryFiles(const(char)* dirPath, int* count); // Get filenames in a directory path (memory should be freed)
-void ClearDirectoryFiles(); // Clear directory files paths buffers (free memory)
+const(char)* GetApplicationDirectory(); // Get the directory if the running application (uses static string)
 bool ChangeDirectory(const(char)* dir); // Change working directory, return true on success
+bool IsPathFile(const(char)* path); // Check if a given path is a file or a directory
+FilePathList LoadDirectoryFiles(const(char)* dirPath); // Load directory filepaths
+FilePathList LoadDirectoryFilesEx(const(char)* basePath, const(char)* filter, bool scanSubdirs); // Load directory filepaths with extension filtering and recursive directory scan
+void UnloadDirectoryFiles(FilePathList files); // Unload filepaths
 bool IsFileDropped(); // Check if a file has been dropped into window
-char** GetDroppedFiles(int* count); // Get dropped files names (memory should be freed)
-void ClearDroppedFiles(); // Clear dropped files paths buffer (free memory)
+FilePathList LoadDroppedFiles(); // Load dropped filepaths
+void UnloadDroppedFiles(FilePathList files); // Unload dropped filepaths
 c_long GetFileModTime(const(char)* fileName); // Get file modification time (last write time)
 
 // Compression/Encoding functionality
-ubyte* CompressData(ubyte* data, int dataLength, int* compDataLength); // Compress data (DEFLATE algorithm)
-ubyte* DecompressData(ubyte* compData, int compDataLength, int* dataLength); // Decompress data (DEFLATE algorithm)
-char* EncodeDataBase64(const(ubyte)* data, int dataLength, int* outputLength); // Encode data to Base64 string
-ubyte* DecodeDataBase64(ubyte* data, int* outputLength); // Decode Base64 string data
-
-// Persistent storage management
-bool SaveStorageValue(uint position, int value); // Save integer value to storage file (to defined position), returns true on success
-int LoadStorageValue(uint position); // Load integer value from storage file (from defined position)
-
-void OpenURL(const(char)* url); // Open URL with default system browser (if available)
+ubyte* CompressData(const(ubyte)* data, int dataSize, int* compDataSize); // Compress data (DEFLATE algorithm), memory must be MemFree()
+ubyte* DecompressData(const(ubyte)* compData, int compDataSize, int* dataSize); // Decompress data (DEFLATE algorithm), memory must be MemFree()
+char* EncodeDataBase64(const(ubyte)* data, int dataSize, int* outputSize); // Encode data to Base64 string, memory must be MemFree()
+ubyte* DecodeDataBase64(const(ubyte)* data, int* outputSize); // Decode Base64 string data, memory must be MemFree()
 
 //------------------------------------------------------------------------------------
 // Input Handling Functions (Module: core)
@@ -1095,7 +1117,8 @@ Vector2 GetMouseDelta(); // Get mouse delta between frames
 void SetMousePosition(int x, int y); // Set mouse position XY
 void SetMouseOffset(int offsetX, int offsetY); // Set mouse offset
 void SetMouseScale(float scaleX, float scaleY); // Set mouse scaling
-float GetMouseWheelMove(); // Get mouse wheel movement Y
+float GetMouseWheelMove(); // Get mouse wheel movement for X or Y, whichever is larger
+Vector2 GetMouseWheelMoveV(); // Get mouse wheel movement for both X and Y
 void SetMouseCursor(int cursor); // Set mouse cursor
 
 // Input-related functions: touch
@@ -1310,13 +1333,14 @@ int GetPixelDataSize(int width, int height, int format); // Get pixel data size
 // Font loading/unloading functions
 Font GetFontDefault(); // Get the default Font
 Font LoadFont(const(char)* fileName); // Load font from file into GPU memory (VRAM)
-Font LoadFontEx(const(char)* fileName, int fontSize, int* fontChars, int glyphCount); // Load font from file with extended parameters
+Font LoadFontEx(const(char)* fileName, int fontSize, int* fontChars, int glyphCount); // Load font from file with extended parameters, use NULL for fontChars and 0 for glyphCount to load the default character set
 Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style)
 Font LoadFontFromMemory(const(char)* fileType, const(ubyte)* fileData, int dataSize, int fontSize, int* fontChars, int glyphCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf'
 GlyphInfo* LoadFontData(const(ubyte)* fileData, int dataSize, int fontSize, int* fontChars, int glyphCount, int type); // Load font data for further use
 Image GenImageFontAtlas(const(GlyphInfo)* chars, Rectangle** recs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info
 void UnloadFontData(GlyphInfo* chars, int glyphCount); // Unload font chars info data (RAM)
-void UnloadFont(Font font); // Unload Font from GPU memory (VRAM)
+void UnloadFont(Font font); // Unload font from GPU memory (VRAM)
+bool ExportFontAsCode(Font font, const(char)* fileName); // Export font as code file, returns true on success
 
 // Text drawing functions
 void DrawFPS(int posX, int posY); // Draw current FPS
@@ -1324,6 +1348,7 @@ void DrawText(const(char)* text, int posX, int posY, int fontSize, Color color);
 void DrawTextEx(Font font, const(char)* text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters
 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)
 void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint)
+void DrawTextCodepoints(Font font, const(int)* codepoints, int count, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint)
 
 // Text font info functions
 int MeasureText(const(char)* text, int fontSize); // Measure string width for default font
@@ -1338,7 +1363,7 @@ void UnloadCodepoints(int* codepoints); // Unload codepoints data from memory
 int GetCodepointCount(const(char)* text); // Get total number of codepoints in a UTF-8 encoded string
 int GetCodepoint(const(char)* text, int* bytesProcessed); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
 const(char)* CodepointToUTF8(int codepoint, int* byteSize); // Encode one codepoint into UTF-8 byte array (array length returned as parameter)
-char* TextCodepointsToUTF8(int* codepoints, int length); // Encode text as codepoints array into UTF-8 text string (WARNING: memory must be freed!)
+char* TextCodepointsToUTF8(const(int)* codepoints, int length); // Encode text as codepoints array into UTF-8 text string (WARNING: memory must be freed!)
 
 // Text strings management functions (no UTF-8 strings, only byte chars)
 // NOTE: Some strings allocate memory internally for returned strings, just be careful!
@@ -1408,14 +1433,13 @@ void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector
 
 // Mesh management functions
 void UploadMesh(Mesh* mesh, bool dynamic); // Upload mesh vertex data in GPU and provide VAO/VBO ids
-void UpdateMeshBuffer(Mesh mesh, int index, void* data, int dataSize, int offset); // Update mesh vertex data in GPU for a specific buffer index
+void UpdateMeshBuffer(Mesh mesh, int index, const(void)* data, int dataSize, int offset); // Update mesh vertex data in GPU for a specific buffer index
 void UnloadMesh(Mesh mesh); // Unload mesh data from CPU and GPU
 void DrawMesh(Mesh mesh, Material material, Matrix transform); // Draw a 3d mesh with material and transform
-void DrawMeshInstanced(Mesh mesh, Material material, Matrix* transforms, int instances); // Draw multiple mesh instances with material and different transforms
+void DrawMeshInstanced(Mesh mesh, Material material, const(Matrix)* transforms, int instances); // Draw multiple mesh instances with material and different transforms
 bool ExportMesh(Mesh mesh, const(char)* fileName); // Export mesh data to file, returns true on success
 BoundingBox GetMeshBoundingBox(Mesh mesh); // Compute mesh bounding box limits
 void GenMeshTangents(Mesh* mesh); // Compute mesh tangents
-void GenMeshBinormals(Mesh* mesh); // Compute mesh binormals
 
 // Mesh generation functions
 Mesh GenMeshPoly(int sides, float radius); // Generate polygonal mesh
@@ -1450,7 +1474,6 @@ bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2); // Check collision
 bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius); // Check collision between box and sphere
 RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius); // Get collision info between ray and sphere
 RayCollision GetRayCollisionBox(Ray ray, BoundingBox box); // Get collision info between ray and box
-RayCollision GetRayCollisionModel(Ray ray, Model model); // Get collision info between ray and model
 RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform); // Get collision info between ray and mesh
 RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); // Get collision info between ray and triangle
 RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4); // Get collision info between ray and quad
@@ -1458,6 +1481,7 @@ RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Ve
 //------------------------------------------------------------------------------------
 // Audio Loading and Playing Functions (Module: audio)
 //------------------------------------------------------------------------------------
+alias AudioCallback = void function(void* bufferData, uint frames);
 
 // Audio device management functions
 void InitAudioDevice(); // Initialize audio device and context
@@ -1487,15 +1511,16 @@ int GetSoundsPlaying(); // Get number of sounds playing in the multichannel
 bool IsSoundPlaying(Sound sound); // Check if a sound is currently playing
 void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level)
 void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level)
-void WaveFormat(Wave* wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format
+void SetSoundPan(Sound sound, float pan); // Set pan for a sound (0.5 is center)
 Wave WaveCopy(Wave wave); // Copy a wave to a new wave
 void WaveCrop(Wave* wave, int initSample, int finalSample); // Crop a wave to defined samples range
-float* LoadWaveSamples(Wave wave); // Load samples data from wave as a floats array
+void WaveFormat(Wave* wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format
+float* LoadWaveSamples(Wave wave); // Load samples data from wave as a 32bit float data array
 void UnloadWaveSamples(float* samples); // Unload samples data loaded with LoadWaveSamples()
 
 // Music management functions
 Music LoadMusicStream(const(char)* fileName); // Load music stream from file
-Music LoadMusicStreamFromMemory(const(char)* fileType, ubyte* data, int dataSize); // Load music stream from data
+Music LoadMusicStreamFromMemory(const(char)* fileType, const(ubyte)* data, int dataSize); // Load music stream from data
 void UnloadMusicStream(Music music); // Unload music stream
 void PlayMusicStream(Music music); // Start music playing
 bool IsMusicStreamPlaying(Music music); // Check if music is playing
@@ -1506,6 +1531,7 @@ void ResumeMusicStream(Music music); // Resume playing paused music
 void SeekMusicStream(Music music, float position); // Seek music to a position (in seconds)
 void SetMusicVolume(Music music, float volume); // Set volume for music (1.0 is max level)
 void SetMusicPitch(Music music, float pitch); // Set pitch for a music (1.0 is base level)
+void SetMusicPan(Music music, float pan); // Set pan for a music (0.5 is center)
 float GetMusicTimeLength(Music music); // Get music time length (in seconds)
 float GetMusicTimePlayed(Music music); // Get current music time played (in seconds)
 
@@ -1521,6 +1547,11 @@ bool IsAudioStreamPlaying(AudioStream stream); // Check if audio stream is playi
 void StopAudioStream(AudioStream stream); // Stop audio stream
 void SetAudioStreamVolume(AudioStream stream, float volume); // Set volume for audio stream (1.0 is max level)
 void SetAudioStreamPitch(AudioStream stream, float pitch); // Set pitch for audio stream (1.0 is base level)
+void SetAudioStreamPan(AudioStream stream, float pan); // Set pan for audio stream (0.5 is centered)
 void SetAudioStreamBufferSizeDefault(int size); // Default size for new audio streams
+void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data
+
+void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream
+void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream
 
 // RAYLIB_H

source/raylib/raylib_types.d

@@ -0,0 +1,99 @@
+/// This module defines basic types from Raylib with local modifications to make them easier to use.
+module raylib.raylib_types;
+
+import raylib;
+
+// Vector2 type
+struct Vector2
+{
+    float x = 0.0f;
+    float y = 0.0f;
+    mixin Linear;
+}
+
+// Vector3 type
+struct Vector3
+{
+    float x = 0.0f;
+    float y = 0.0f;
+    float z = 0.0f;
+    mixin Linear;
+}
+
+// Vector4 type
+struct Vector4
+{
+    float x = 0.0f;
+    float y = 0.0f;
+    float z = 0.0f;
+    float w = 0.0f;
+    mixin Linear;
+}
+
+// Quaternion type, same as Vector4
+alias Quaternion = Vector4;
+
+// Matrix type (OpenGL style 4x4 - right handed, column major)
+struct Matrix
+{
+    float m0 = 0.0f;
+    float m4 = 0.0f;
+    float m8 = 0.0f;
+    float m12 = 0.0f;
+    float m1 = 0.0f;
+    float m5 = 0.0f;
+    float m9 = 0.0f;
+    float m13 = 0.0f;
+    float m2 = 0.0f;
+    float m6 = 0.0f;
+    float m10 = 0.0f;
+    float m14 = 0.0f;
+    float m3 = 0.0f;
+    float m7 = 0.0f;
+    float m11 = 0.0f;
+    float m15 = 0.0f;
+}
+
+// Rectangle type
+struct Rectangle
+{
+    float x;
+    float y;
+    float width;
+    float height;
+    alias w = width;
+    alias h = height;
+}
+
+enum Colors
+{
+    // Some Basic Colors
+    // NOTE: Custom raylib color palette for amazing visuals on WHITE background
+    LIGHTGRAY = Color(200, 200, 200, 255), // Light Gray
+    GRAY = Color(130, 130, 130, 255), // Gray
+    DARKGRAY = Color(80, 80, 80, 255), // Dark Gray
+    YELLOW = Color(253, 249, 0, 255), // Yellow
+    GOLD = Color(255, 203, 0, 255), // Gold
+    ORANGE = Color(255, 161, 0, 255), // Orange
+    PINK = Color(255, 109, 194, 255), // Pink
+    RED = Color(230, 41, 55, 255), // Red
+    MAROON = Color(190, 33, 55, 255), // Maroon
+    GREEN = Color(0, 228, 48, 255), // Green
+    LIME = Color(0, 158, 47, 255), // Lime
+    DARKGREEN = Color(0, 117, 44, 255), // Dark Green
+    SKYBLUE = Color(102, 191, 255, 255), // Sky Blue
+    BLUE = Color(0, 121, 241, 255), // Blue
+    DARKBLUE = Color(0, 82, 172, 255), // Dark Blue
+    PURPLE = Color(200, 122, 255, 255), // Purple
+    VIOLET = Color(135, 60, 190, 255), // Violet
+    DARKPURPLE = Color(112, 31, 126, 255), // Dark Purple
+    BEIGE = Color(211, 176, 131, 255), // Beige
+    BROWN = Color(127, 106, 79, 255), // Brown
+    DARKBROWN = Color(76, 63, 47, 255), // Dark Brown
+
+    WHITE = Color(255, 255, 255, 255), // White
+    BLACK = Color(0, 0, 0, 255), // Black
+    BLANK = Color(0, 0, 0, 0), // Blank (Transparent)
+    MAGENTA = Color(255, 0, 255, 255), // Magenta
+    RAYWHITE = Color(245, 245, 245, 255), // My own White (raylib logo)
+}

source/raylib/raymath.d

@@ -0,0 +1,624 @@
+module raylib.raymath;
+
+import raylib;
+/**********************************************************************************************
+*
+*   raymath v1.5 - Math functions to work with Vector2, Vector3, Matrix and Quaternions
+*
+*   CONFIGURATION:
+*
+*   #define RAYMATH_IMPLEMENTATION
+*       Generates the implementation of the library into the included file.
+*       If not defined, the library is in header only mode and can be included in other headers
+*       or source files without problems. But only ONE file should hold the implementation.
+*
+*   #define RAYMATH_STATIC_INLINE
+*       Define static inline functions code, so #include header suffices for use.
+*       This may use up lots of memory.
+*
+*   CONVENTIONS:
+*
+*     - Functions are always self-contained, no function use another raymath function inside,
+*       required code is directly re-implemented inside
+*     - Functions input parameters are always received by value (2 unavoidable exceptions)
+*     - Functions use always a "result" variable for return
+*     - Functions are always defined inline
+*     - Angles are always in radians (DEG2RAD/RAD2DEG macros provided for convenience)
+*
+*
+*   LICENSE: zlib/libpng
+*
+*   Copyright (c) 2015-2022 Ramon Santamaria (@raysan5)
+*
+*   This software is provided "as-is", without any express or implied warranty. In no event
+*   will the authors be held liable for any damages arising from the use of this software.
+*
+*   Permission is granted to anyone to use this software for any purpose, including commercial
+*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
+*
+*     1. The origin of this software must not be misrepresented; you must not claim that you
+*     wrote the original software. If you use this software in a product, an acknowledgment
+*     in the product documentation would be appreciated but is not required.
+*
+*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
+*     as being the original software.
+*
+*     3. This notice may not be removed or altered from any source distribution.
+*
+**********************************************************************************************/
+
+extern (C) @nogc nothrow:
+
+// Function specifiers definition
+
+// We are building raylib as a Win32 shared library (.dll).
+
+// We are using raylib as a Win32 shared library (.dll)
+
+// Provide external definition
+
+// Functions may be inlined, no external out-of-line definition
+
+// plain inline not supported by tinycc (See issue #435) // Functions may be inlined or external definition used
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+
+enum PI = 3.14159265358979323846f;
+
+enum EPSILON = 0.000001f;
+
+enum DEG2RAD = PI / 180.0f;
+
+enum RAD2DEG = 180.0f / PI;
+
+// Get float vector for Matrix
+
+extern (D) auto MatrixToFloat(T)(auto ref T mat)
+{
+    return MatrixToFloatV(mat).v;
+}
+
+// Get float vector for Vector3
+
+extern (D) auto Vector3ToFloat(T)(auto ref T vec)
+{
+    return Vector3ToFloatV(vec).v;
+}
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+
+// Vector2 type
+
+// Vector3 type
+
+// Vector4 type
+
+// Quaternion type
+
+// Matrix type (OpenGL style 4x4 - right handed, column major)
+
+// Matrix first row (4 components)
+// Matrix second row (4 components)
+// Matrix third row (4 components)
+// Matrix fourth row (4 components)
+
+// NOTE: Helper types to be used instead of array return types for *ToFloat functions
+struct float3
+{
+    float[3] v;
+}
+
+struct float16
+{
+    float[16] v;
+}
+
+// Required for: sinf(), cosf(), tan(), atan2f(), sqrtf(), floor(), fminf(), fmaxf(), fabs()
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Utils math
+//----------------------------------------------------------------------------------
+
+// Clamp float value
+float Clamp(float value, float min, float max);
+
+// Calculate linear interpolation between two floats
+float Lerp(float start, float end, float amount);
+
+// Normalize input value within input range
+float Normalize(float value, float start, float end);
+
+// Remap input value within input range to output range
+float Remap(
+    float value,
+    float inputStart,
+    float inputEnd,
+    float outputStart,
+    float outputEnd);
+
+// Wrap input value from min to max
+float Wrap(float value, float min, float max);
+
+// Check whether two given floats are almost equal
+int FloatEquals(float x, float y);
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Vector2 math
+//----------------------------------------------------------------------------------
+
+// Vector with components value 0.0f
+Vector2 Vector2Zero();
+
+// Vector with components value 1.0f
+Vector2 Vector2One();
+
+// Add two vectors (v1 + v2)
+Vector2 Vector2Add(Vector2 v1, Vector2 v2);
+
+// Add vector and float value
+Vector2 Vector2AddValue(Vector2 v, float add);
+
+// Subtract two vectors (v1 - v2)
+Vector2 Vector2Subtract(Vector2 v1, Vector2 v2);
+
+// Subtract vector by float value
+Vector2 Vector2SubtractValue(Vector2 v, float sub);
+
+// Calculate vector length
+float Vector2Length(Vector2 v);
+
+// Calculate vector square length
+float Vector2LengthSqr(Vector2 v);
+
+// Calculate two vectors dot product
+float Vector2DotProduct(Vector2 v1, Vector2 v2);
+
+// Calculate distance between two vectors
+float Vector2Distance(Vector2 v1, Vector2 v2);
+
+// Calculate square distance between two vectors
+float Vector2DistanceSqr(Vector2 v1, Vector2 v2);
+
+// Calculate angle from two vectors
+float Vector2Angle(Vector2 v1, Vector2 v2);
+
+// Scale vector (multiply by value)
+Vector2 Vector2Scale(Vector2 v, float scale);
+
+// Multiply vector by vector
+Vector2 Vector2Multiply(Vector2 v1, Vector2 v2);
+
+// Negate vector
+Vector2 Vector2Negate(Vector2 v);
+
+// Divide vector by vector
+Vector2 Vector2Divide(Vector2 v1, Vector2 v2);
+
+// Normalize provided vector
+Vector2 Vector2Normalize(Vector2 v);
+
+// Transforms a Vector2 by a given Matrix
+Vector2 Vector2Transform(Vector2 v, Matrix mat);
+
+// Calculate linear interpolation between two vectors
+Vector2 Vector2Lerp(Vector2 v1, Vector2 v2, float amount);
+
+// Calculate reflected vector to normal
+
+// Dot product
+Vector2 Vector2Reflect(Vector2 v, Vector2 normal);
+
+// Rotate vector by angle
+Vector2 Vector2Rotate(Vector2 v, float angle);
+
+// Move Vector towards target
+Vector2 Vector2MoveTowards(Vector2 v, Vector2 target, float maxDistance);
+
+// Invert the given vector
+Vector2 Vector2Invert(Vector2 v);
+
+// Clamp the components of the vector between
+// min and max values specified by the given vectors
+Vector2 Vector2Clamp(Vector2 v, Vector2 min, Vector2 max);
+
+// Clamp the magnitude of the vector between two min and max values
+Vector2 Vector2ClampValue(Vector2 v, float min, float max);
+
+// Check whether two given vectors are almost equal
+int Vector2Equals(Vector2 p, Vector2 q);
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Vector3 math
+//----------------------------------------------------------------------------------
+
+// Vector with components value 0.0f
+Vector3 Vector3Zero();
+
+// Vector with components value 1.0f
+Vector3 Vector3One();
+
+// Add two vectors
+Vector3 Vector3Add(Vector3 v1, Vector3 v2);
+
+// Add vector and float value
+Vector3 Vector3AddValue(Vector3 v, float add);
+
+// Subtract two vectors
+Vector3 Vector3Subtract(Vector3 v1, Vector3 v2);
+
+// Subtract vector by float value
+Vector3 Vector3SubtractValue(Vector3 v, float sub);
+
+// Multiply vector by scalar
+Vector3 Vector3Scale(Vector3 v, float scalar);
+
+// Multiply vector by vector
+Vector3 Vector3Multiply(Vector3 v1, Vector3 v2);
+
+// Calculate two vectors cross product
+Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2);
+
+// Calculate one vector perpendicular vector
+
+// Cross product between vectors
+Vector3 Vector3Perpendicular(Vector3 v);
+
+// Calculate vector length
+float Vector3Length(const Vector3 v);
+
+// Calculate vector square length
+float Vector3LengthSqr(const Vector3 v);
+
+// Calculate two vectors dot product
+float Vector3DotProduct(Vector3 v1, Vector3 v2);
+
+// Calculate distance between two vectors
+float Vector3Distance(Vector3 v1, Vector3 v2);
+
+// Calculate square distance between two vectors
+float Vector3DistanceSqr(Vector3 v1, Vector3 v2);
+
+// Calculate angle between two vectors
+float Vector3Angle(Vector3 v1, Vector3 v2);
+
+// Negate provided vector (invert direction)
+Vector3 Vector3Negate(Vector3 v);
+
+// Divide vector by vector
+Vector3 Vector3Divide(Vector3 v1, Vector3 v2);
+
+// Normalize provided vector
+Vector3 Vector3Normalize(Vector3 v);
+
+// Orthonormalize provided vectors
+// Makes vectors normalized and orthogonal to each other
+// Gram-Schmidt function implementation
+
+// Vector3Normalize(*v1);
+
+// Vector3CrossProduct(*v1, *v2)
+
+// Vector3Normalize(vn1);
+
+// Vector3CrossProduct(vn1, *v1)
+void Vector3OrthoNormalize(Vector3* v1, Vector3* v2);
+
+// Transforms a Vector3 by a given Matrix
+Vector3 Vector3Transform(Vector3 v, Matrix mat);
+
+// Transform a vector by quaternion rotation
+Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q);
+
+// Rotates a vector around an axis
+
+// Using Euler-Rodrigues Formula
+// Ref.: https://en.wikipedia.org/w/index.php?title=Euler%E2%80%93Rodrigues_formula
+
+// Vector3Normalize(axis);
+
+// Vector3CrossProduct(w, v)
+
+// Vector3CrossProduct(w, wv)
+
+// Vector3Scale(wv, 2 * a)
+
+// Vector3Scale(wwv, 2)
+Vector3 Vector3RotateByAxisAngle(Vector3 v, Vector3 axis, float angle);
+
+// Calculate linear interpolation between two vectors
+Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount);
+
+// Calculate reflected vector to normal
+
+// I is the original vector
+// N is the normal of the incident plane
+// R = I - (2*N*(DotProduct[I, N]))
+Vector3 Vector3Reflect(Vector3 v, Vector3 normal);
+
+// Get min value for each pair of components
+Vector3 Vector3Min(Vector3 v1, Vector3 v2);
+
+// Get max value for each pair of components
+Vector3 Vector3Max(Vector3 v1, Vector3 v2);
+
+// Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c)
+// NOTE: Assumes P is on the plane of the triangle
+
+// Vector3Subtract(b, a)
+// Vector3Subtract(c, a)
+// Vector3Subtract(p, a)
+// Vector3DotProduct(v0, v0)
+// Vector3DotProduct(v0, v1)
+// Vector3DotProduct(v1, v1)
+// Vector3DotProduct(v2, v0)
+// Vector3DotProduct(v2, v1)
+Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c);
+
+// Projects a Vector3 from screen space into object space
+// NOTE: We are avoiding calling other raymath functions despite available
+
+// Calculate unproject matrix (multiply view patrix by projection matrix) and invert it
+// MatrixMultiply(view, projection);
+
+// Calculate inverted matrix -> MatrixInvert(matViewProj);
+// Cache the matrix values (speed optimization)
+
+// Calculate the invert determinant (inlined to avoid double-caching)
+
+// Create quaternion from source point
+
+// Multiply quat point by unproject matrix
+// QuaternionTransform(quat, matViewProjInv)
+
+// Normalized world points in vectors
+Vector3 Vector3Unproject(Vector3 source, Matrix projection, Matrix view);
+
+// Get Vector3 as float array
+float3 Vector3ToFloatV(Vector3 v);
+
+// Invert the given vector
+Vector3 Vector3Invert(Vector3 v);
+
+// Clamp the components of the vector between
+// min and max values specified by the given vectors
+Vector3 Vector3Clamp(Vector3 v, Vector3 min, Vector3 max);
+
+// Clamp the magnitude of the vector between two values
+Vector3 Vector3ClampValue(Vector3 v, float min, float max);
+
+// Check whether two given vectors are almost equal
+int Vector3Equals(Vector3 p, Vector3 q);
+
+// Compute the direction of a refracted ray where v specifies the
+// normalized direction of the incoming ray, n specifies the
+// normalized normal vector of the interface of two optical media,
+// and r specifies the ratio of the refractive index of the medium
+// from where the ray comes to the refractive index of the medium
+// on the other side of the surface
+Vector3 Vector3Refract(Vector3 v, Vector3 n, float r);
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Matrix math
+//----------------------------------------------------------------------------------
+
+// Compute matrix determinant
+
+// Cache the matrix values (speed optimization)
+float MatrixDeterminant(Matrix mat);
+
+// Get the trace of the matrix (sum of the values along the diagonal)
+float MatrixTrace(Matrix mat);
+
+// Transposes provided matrix
+Matrix MatrixTranspose(Matrix mat);
+
+// Invert provided matrix
+
+// Cache the matrix values (speed optimization)
+
+// Calculate the invert determinant (inlined to avoid double-caching)
+Matrix MatrixInvert(Matrix mat);
+
+// Get identity matrix
+Matrix MatrixIdentity();
+
+// Add two matrices
+Matrix MatrixAdd(Matrix left, Matrix right);
+
+// Subtract two matrices (left - right)
+Matrix MatrixSubtract(Matrix left, Matrix right);
+
+// Get two matrix multiplication
+// NOTE: When multiplying matrices... the order matters!
+Matrix MatrixMultiply(Matrix left, Matrix right);
+
+// Get translation matrix
+Matrix MatrixTranslate(float x, float y, float z);
+
+// Create rotation matrix from axis and angle
+// NOTE: Angle should be provided in radians
+Matrix MatrixRotate(Vector3 axis, float angle);
+
+// Get x-rotation matrix
+// NOTE: Angle must be provided in radians
+
+// MatrixIdentity()
+Matrix MatrixRotateX(float angle);
+
+// Get y-rotation matrix
+// NOTE: Angle must be provided in radians
+
+// MatrixIdentity()
+Matrix MatrixRotateY(float angle);
+
+// Get z-rotation matrix
+// NOTE: Angle must be provided in radians
+
+// MatrixIdentity()
+Matrix MatrixRotateZ(float angle);
+
+// Get xyz-rotation matrix
+// NOTE: Angle must be provided in radians
+
+// MatrixIdentity()
+Matrix MatrixRotateXYZ(Vector3 angle);
+
+// Get zyx-rotation matrix
+// NOTE: Angle must be provided in radians
+Matrix MatrixRotateZYX(Vector3 angle);
+
+// Get scaling matrix
+Matrix MatrixScale(float x, float y, float z);
+
+// Get perspective projection matrix
+Matrix MatrixFrustum(
+    double left,
+    double right,
+    double bottom,
+    double top,
+    double near,
+    double far);
+
+// Get perspective projection matrix
+// NOTE: Fovy angle must be provided in radians
+
+// MatrixFrustum(-right, right, -top, top, near, far);
+Matrix MatrixPerspective(double fovy, double aspect, double near, double far);
+
+// Get orthographic projection matrix
+Matrix MatrixOrtho(
+    double left,
+    double right,
+    double bottom,
+    double top,
+    double near,
+    double far);
+
+// Get camera look-at matrix (view matrix)
+
+// Vector3Subtract(eye, target)
+
+// Vector3Normalize(vz)
+
+// Vector3CrossProduct(up, vz)
+
+// Vector3Normalize(x)
+
+// Vector3CrossProduct(vz, vx)
+
+// Vector3DotProduct(vx, eye)
+// Vector3DotProduct(vy, eye)
+// Vector3DotProduct(vz, eye)
+Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up);
+
+// Get float array of matrix data
+float16 MatrixToFloatV(Matrix mat);
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Quaternion math
+//----------------------------------------------------------------------------------
+
+// Add two quaternions
+Quaternion QuaternionAdd(Quaternion q1, Quaternion q2);
+
+// Add quaternion and float value
+Quaternion QuaternionAddValue(Quaternion q, float add);
+
+// Subtract two quaternions
+Quaternion QuaternionSubtract(Quaternion q1, Quaternion q2);
+
+// Subtract quaternion and float value
+Quaternion QuaternionSubtractValue(Quaternion q, float sub);
+
+// Get identity quaternion
+Quaternion QuaternionIdentity();
+
+// Computes the length of a quaternion
+float QuaternionLength(Quaternion q);
+
+// Normalize provided quaternion
+Quaternion QuaternionNormalize(Quaternion q);
+
+// Invert provided quaternion
+Quaternion QuaternionInvert(Quaternion q);
+
+// Calculate two quaternion multiplication
+Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2);
+
+// Scale quaternion by float value
+Quaternion QuaternionScale(Quaternion q, float mul);
+
+// Divide two quaternions
+Quaternion QuaternionDivide(Quaternion q1, Quaternion q2);
+
+// Calculate linear interpolation between two quaternions
+Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount);
+
+// Calculate slerp-optimized interpolation between two quaternions
+
+// QuaternionLerp(q1, q2, amount)
+
+// QuaternionNormalize(q);
+Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount);
+
+// Calculates spherical linear interpolation between two quaternions
+Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount);
+
+// Calculate quaternion based on the rotation from one vector to another
+
+// Vector3DotProduct(from, to)
+// Vector3CrossProduct(from, to)
+
+// QuaternionNormalize(q);
+// NOTE: Normalize to essentially nlerp the original and identity to 0.5
+Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to);
+
+// Get a quaternion for a given rotation matrix
+Quaternion QuaternionFromMatrix(Matrix mat);
+
+// Get a matrix for a given quaternion
+
+// MatrixIdentity()
+Matrix QuaternionToMatrix(Quaternion q);
+
+// Get rotation quaternion for an angle and axis
+// NOTE: Angle must be provided in radians
+
+// Vector3Normalize(axis)
+
+// QuaternionNormalize(q);
+Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle);
+
+// Get the rotation angle and axis for a given quaternion
+
+// QuaternionNormalize(q);
+
+// This occurs when the angle is zero.
+// Not a problem: just set an arbitrary normalized axis.
+void QuaternionToAxisAngle(Quaternion q, Vector3* outAxis, float* outAngle);
+
+// Get the quaternion equivalent to Euler angles
+// NOTE: Rotation order is ZYX
+Quaternion QuaternionFromEuler(float pitch, float yaw, float roll);
+
+// Get the Euler angles equivalent to quaternion (roll, pitch, yaw)
+// NOTE: Angles are returned in a Vector3 struct in radians
+
+// Roll (x-axis rotation)
+
+// Pitch (y-axis rotation)
+
+// Yaw (z-axis rotation)
+Vector3 QuaternionToEuler(Quaternion q);
+
+// Transform a quaternion given a transformation matrix
+Quaternion QuaternionTransform(Quaternion q, Matrix mat);
+
+// Check whether two given quaternions are almost equal
+int QuaternionEquals(Quaternion p, Quaternion q);
+
+// RAYMATH_H

source/raylib/raymathext.d

@@ -0,0 +1,320 @@
+module raylib.raymathext;
+
+import raylib;
+import std.math;
+
+pragma(inline, true):
+
+// Bivector2 type
+struct Bivector2
+{
+    float xy = 0.0f;
+    alias xy this;
+    mixin Linear;
+}
+
+// Bivector3 type
+/// Beware of the field order
+/// xy is the first field
+struct Bivector3
+{
+    float xy = 0.0f;
+    float yz = 0.0f;
+    float zx = 0.0f;
+    mixin Linear;
+}
+
+// Rotor type
+struct Rotor3
+{
+    float a = 1.0f;
+    float xy = 0.0f;
+    float yz = 0.0f;
+    float zx = 0.0f;
+    mixin Linear;
+
+    alias i = yz;
+    alias j = zx;
+    alias k = xy;
+
+    @property Bivector3 b()
+    {
+        return Bivector3(xy, yz, zx);
+    }
+
+    @property Bivector3 b(Bivector3 _b)
+    {
+        xy = _b.xy;
+        yz = _b.yz;
+        zx = _b.zx;
+        return _b;
+    }
+
+    this(float _a, Bivector3 _b)
+    {
+        a = _a;
+        b = _b;
+    }
+
+    this(float _a, float _xy, float _yz, float _zx)
+    {
+        a = _a;
+        xy = _xy;
+        yz = _yz;
+        zx = _zx;
+    }
+}
+
+alias Matrix4 = Matrix;
+
+mixin template Linear()
+{
+    import std.algorithm : canFind, map;
+    import std.range : join;
+    import std.traits : FieldNameTuple;
+
+    private static alias T = typeof(this);
+
+    static T zero()
+    {
+        enum fragment = [FieldNameTuple!T].map!(field => "0.").join(",");
+        return mixin("T(" ~ fragment ~ ")");
+    }
+
+    static T one()
+    {
+        enum fragment = [FieldNameTuple!T].map!(field => "1.").join(",");
+        return mixin("T(" ~ fragment ~ ")");
+    }
+
+    inout T opUnary(string op)() if (["+", "-"].canFind(op))
+    {
+        enum fragment = [FieldNameTuple!T].map!(field => op ~ field).join(",");
+        return mixin("T(" ~ fragment ~ ")");
+    }
+
+    static if (is(T == Rotor3))
+    {
+        /// Returns a rotor equivalent to first apply p, then apply q
+        inout Rotor3 opBinary(string op)(inout Rotor3 q) if (op == "*")
+        {
+            alias p = this;
+            Rotor3 r;
+            r.a = p.a * q.a - p.i * q.i - p.j * q.j - p.k * q.k;
+            r.i = p.i * q.a + p.a * q.i + p.j * q.k - p.k * q.j;
+            r.j = p.j * q.a + p.a * q.j + p.k * q.i - p.i * q.k;
+            r.k = p.k * q.a + p.a * q.k + p.i * q.j - p.j * q.i;
+            return r;
+        }
+
+        inout Vector3 opBinary(string op)(inout Vector3 v) if (op == "*")
+        {
+            Vector3 rv;
+            rv.x = a * v.x + xy * v.y - zx * v.z;
+            rv.y = a * v.y + yz * v.z - xy * v.x;
+            rv.z = a * v.z + zx * v.x - yz * v.y;
+            return rv;
+        }
+
+        inout Vector3 opBinaryRight(string op)(inout Vector3 v) if (op == "*")
+        {
+            Vector3 vr;
+            vr.x = v.x * a - v.y * xy + v.z * zx;
+            vr.y = v.y * a - v.z * yz + v.x * xy;
+            vr.z = v.z * a - v.x * zx + v.y * yz;
+            return vr;
+        }
+    }
+    else
+    {
+        inout T opBinary(string op)(inout T rhs) if (["+", "-"].canFind(op))
+        {
+            enum fragment = [FieldNameTuple!T].map!(field => field ~ op ~ "rhs." ~ field).join(",");
+            return mixin("T(" ~ fragment ~ ")");
+        }
+
+        ref T opOpAssign(string op)(inout T rhs) if (["+", "-"].canFind(op))
+        {
+            static foreach (field; [FieldNameTuple!T])
+                mixin(field ~ op ~ "= rhs." ~ field ~ ";");
+            return this;
+        }
+    }
+
+    inout T opBinary(string op)(inout float rhs) if (["+", "-", "*", "/"].canFind(op))
+    {
+        enum fragment = [FieldNameTuple!T].map!(field => field ~ op ~ "rhs").join(",");
+        return mixin("T(" ~ fragment ~ ")");
+    }
+
+    inout T opBinaryRight(string op)(inout float lhs) if (["+", "-", "*", "/"].canFind(op))
+    {
+        enum fragment = [FieldNameTuple!T].map!(field => "lhs" ~ op ~ field).join(",");
+        return mixin("T(" ~ fragment ~ ")");
+    }
+
+    ref T opOpAssign(string op)(inout float rhs) if (["+", "-", "*", "/"].canFind(op))
+    {
+        static foreach (field; [FieldNameTuple!T])
+            mixin(field ~ op ~ "= rhs;");
+        return this;
+    }
+}
+
+unittest
+{
+    assert(Vector2.init == Vector2.zero);
+    assert(Vector2() == Vector2.zero);
+    assert(-Vector2(1, 2) == Vector2(-1, -2));
+    auto a = Vector3(1, 2, 9);
+    immutable b = Vector3(3, 4, 9);
+    Vector3 c = a + b;
+    assert(c == Vector3(4, 6, 18));
+    assert(4.0f - Vector2.zero == Vector2(4, 4));
+    assert(Vector2.one - 3.0f == Vector2(-2, -2));
+    a += 5;
+    assert(a == Vector3(6, 7, 14));
+    a *= 0.5;
+    assert(a == Vector3(3, 3.5, 7));
+    a += Vector3(3, 2.5, -1);
+    assert(a == Vector3(6, 6, 6));
+}
+
+import std.traits : FieldNameTuple;
+import std.algorithm : map;
+import std.range : join;
+
+float length(T)(T v)
+{
+    enum fragment = [FieldNameTuple!T].map!(field => "v." ~ field ~ "*" ~ "v." ~ field).join("+");
+    return mixin("sqrt(" ~ fragment ~ ")");
+}
+
+T normal(T)(T v)
+{
+    return v / v.length;
+}
+
+float distance(T)(T lhs, T rhs)
+{
+    return (lhs - rhs).length;
+}
+
+float dot(T)(T lhs, T rhs)
+{
+    enum fragment = [FieldNameTuple!T].map!(field => "lhs." ~ field ~ "*" ~ "rhs." ~ field).join(
+                "+");
+    return mixin(fragment);
+}
+
+unittest
+{
+    assert(Vector2(3, 4).length == 5);
+    const a = Vector2(-3, 4);
+    assert(a.normal == Vector2(-3. / 5., 4. / 5.));
+    immutable b = Vector2(9, 8);
+    assert(b.distance(Vector2(-3, 3)) == 13);
+    assert(Vector3(2, 3, 4).dot(Vector3(4, 5, 6)) == 47);
+    assert(Vector2.one.length == sqrt(2.0f));
+}
+
+unittest
+{
+    assert(Rotor3(1, 2, 3, 4) == Rotor3(1, Bivector3(2, 3, 4)));
+}
+
+/// Mix `amount` of `lhs` with `1-amount` of `rhs`
+///   `amount` should be between 0 and 1, but can be anything
+///   lerp(lhs, rhs, 0) == lhs
+///   lerp(lhs, rhs, 1) == rhs
+T lerp(T)(T lhs, T rhs, float amount)
+{
+    return lhs + amount * (rhs - lhs);
+}
+
+/// angle betwenn vector and x-axis (+y +x -> positive)
+float angle(Vector2 v)
+{
+    return atan2(v.y, v.x);
+}
+
+Vector2 rotate(Vector2 v, float angle)
+{
+    return Vector2(v.x * cos(angle) - v.y * sin(angle), v.x * sin(angle) + v.y * cos(angle));
+}
+
+Vector2 slide(Vector2 v, Vector2 along)
+{
+    return along.normal * dot(v, along);
+}
+
+Bivector2 wedge(Vector2 lhs, Vector2 rhs)
+{
+    Bivector2 result = {xy: lhs.x * rhs.y - lhs.y * rhs.x};
+    return result;
+}
+
+// dfmt off
+Bivector3 wedge(Vector3 lhs, Vector3 rhs)
+{
+    Bivector3 result = {
+        xy: lhs.x * rhs.y - lhs.y * rhs.x,
+        yz: lhs.y * rhs.z - lhs.z * rhs.y,
+        zx: lhs.z * rhs.x - lhs.x * rhs.z,
+    };
+    return result;
+}
+
+Vector3 transform(Vector3 v, Matrix4 mat)
+{
+    with (v) with (mat)
+        return Vector3(
+            m0 * x + m4 * y + m8 * z + m12,
+            m1 * x + m5 * y + m9 * z + m13,
+            m2 * x + m6 * y + m10 * z + m14
+        );
+}
+// dfmt on
+
+Vector3 cross(Vector3 lhs, Vector3 rhs)
+{
+    auto v = wedge(lhs, rhs);
+    return Vector3(v.yz, v.zx, v.xy);
+}
+
+unittest {
+    // TODO
+}
+
+/// Returns a unit rotor that rotates `from` to `to`
+Rotor3 rotation(Vector3 from, Vector3 to)
+{
+    return Rotor3(1 + dot(to, from), wedge(to, from)).normal;
+}
+
+Rotor3 rotation(float angle, Bivector3 plane)
+{
+    return Rotor3(cos(angle / 2.0f), -sin(angle / 2.0f) * plane);
+}
+
+/// Rotate q by p
+Rotor3 rotate(Rotor3 p, Rotor3 q)
+{
+    return p * q * p.reverse;
+}
+
+/// Rotate v by r
+Vector3 rotate(Rotor3 r, Vector3 v)
+{
+    return r * v * r.reverse;
+}
+
+Rotor3 reverse(Rotor3 r)
+{
+    return Rotor3(r.a, -r.b);
+}
+
+unittest
+{
+    // TODO
+}

source/raylib/reasings.d

@@ -0,0 +1,244 @@
+/*******************************************************************************************
+*
+*   reasings - raylib easings library, based on Robert Penner library
+*
+*   Useful easing functions for values animation
+*
+*   This header uses:
+*       #define EASINGS_STATIC_INLINE       // Inlines all functions code, so it runs faster.
+*                                           // This requires lots of memory on system.
+*   How to use:
+*   The four inputs t,b,c,d are defined as follows:
+*   t = current time (in any unit measure, but same unit as duration)
+*   b = starting value to interpolate
+*   c = the total change in value of b that needs to occur
+*   d = total time it should take to complete (duration)
+*
+*   Example:
+*
+*   int currentTime = 0;
+*   int duration = 100;
+*   float startPositionX = 0.0f;
+*   float finalPositionX = 30.0f;
+*   float currentPositionX = startPositionX;
+*
+*   while (currentPositionX < finalPositionX)
+*   {
+*       currentPositionX = EaseSineIn(currentTime, startPositionX, finalPositionX - startPositionX, duration);
+*       currentTime++;
+*   }
+*
+*   A port of Robert Penner's easing equations to C (http://robertpenner.com/easing/)
+*
+*   Robert Penner License
+*   ---------------------------------------------------------------------------------
+*   Open source under the BSD License.
+*
+*   Copyright (c) 2001 Robert Penner. All rights reserved.
+*
+*   Redistribution and use in source and binary forms, with or without modification,
+*   are permitted provided that the following conditions are met:
+*
+*       - Redistributions of source code must retain the above copyright notice,
+*         this list of conditions and the following disclaimer.
+*       - Redistributions in binary form must reproduce the above copyright notice,
+*         this list of conditions and the following disclaimer in the documentation
+*         and/or other materials provided with the distribution.
+*       - Neither the name of the author nor the names of contributors may be used
+*         to endorse or promote products derived from this software without specific
+*         prior written permission.
+*
+*   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+*   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+*   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+*   IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+*   INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+*   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+*   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+*   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+*   OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+*   OF THE POSSIBILITY OF SUCH DAMAGE.
+*   ---------------------------------------------------------------------------------
+*
+*   Copyright (c) 2015-2022 Ramon Santamaria (@raysan5)
+*
+*   This software is provided "as-is", without any express or implied warranty. In no event
+*   will the authors be held liable for any damages arising from the use of this software.
+*
+*   Permission is granted to anyone to use this software for any purpose, including commercial
+*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
+*
+*     1. The origin of this software must not be misrepresented; you must not claim that you
+*     wrote the original software. If you use this software in a product, an acknowledgment
+*     in the product documentation would be appreciated but is not required.
+*
+*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
+*     as being the original software.
+*
+*     3. This notice may not be removed or altered from any source distribution.
+*
+**********************************************************************************************/
+module raylib.reasings;
+
+extern (C) nothrow @nogc:
+pragma(inline, true): // NOTE: By default, compile functions as static inline
+
+import core.stdc.math; // Required for: sinf(), cosf(), sqrt(), pow()
+
+enum PI = 3.14159265358979323846f; //Required as PI is not always defined in math.h
+
+// Linear Easing functions
+static float EaseLinearNone(float t, float b, float c, float d) { return (c*t/d + b); }
+static float EaseLinearIn(float t, float b, float c, float d) { return (c*t/d + b); }
+static float EaseLinearOut(float t, float b, float c, float d) { return (c*t/d + b); }
+static float EaseLinearInOut(float t,float b, float c, float d) { return (c*t/d + b); }
+
+// Sine Easing functions
+static float EaseSineIn(float t, float b, float c, float d) { return (-c*cosf(t/d*(PI/2.0f)) + c + b); }
+static float EaseSineOut(float t, float b, float c, float d) { return (c*sinf(t/d*(PI/2.0f)) + b); }
+static float EaseSineInOut(float t, float b, float c, float d) { return (-c/2.0f*(cosf(PI*t/d) - 1.0f) + b); }
+
+// Circular Easing functions
+static float EaseCircIn(float t, float b, float c, float d) { t /= d; return (-c*(sqrtf(1.0f - t*t) - 1.0f) + b); }
+static float EaseCircOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*sqrtf(1.0f - t*t) + b); }
+static float EaseCircInOut(float t, float b, float c, float d)
+{
+    if ((t/=d/2.0f) < 1.0f) return (-c/2.0f*(sqrtf(1.0f - t*t) - 1.0f) + b);
+    t -= 2.0f; return (c/2.0f*(sqrtf(1.0f - t*t) + 1.0f) + b);
+}
+
+// Cubic Easing functions
+static float EaseCubicIn(float t, float b, float c, float d) { t /= d; return (c*t*t*t + b); }
+static float EaseCubicOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*(t*t*t + 1.0f) + b); }
+static float EaseCubicInOut(float t, float b, float c, float d)
+{
+    if ((t/=d/2.0f) < 1.0f) return (c/2.0f*t*t*t + b);
+    t -= 2.0f; return (c/2.0f*(t*t*t + 2.0f) + b);
+}
+
+// Quadratic Easing functions
+static float EaseQuadIn(float t, float b, float c, float d) { t /= d; return (c*t*t + b); }
+static float EaseQuadOut(float t, float b, float c, float d) { t /= d; return (-c*t*(t - 2.0f) + b); }
+static float EaseQuadInOut(float t, float b, float c, float d)
+{
+    if ((t/=d/2) < 1) return (((c/2)*(t*t)) + b);
+    return (-c/2.0f*(((t - 1.0f)*(t - 3.0f)) - 1.0f) + b);
+}
+
+// Exponential Easing functions
+static float EaseExpoIn(float t, float b, float c, float d) { return (t == 0.0f) ? b : (c*powf(2.0f, 10.0f*(t/d - 1.0f)) + b); }
+static float EaseExpoOut(float t, float b, float c, float d) { return (t == d) ? (b + c) : (c*(-powf(2.0f, -10.0f*t/d) + 1.0f) + b);    }
+static float EaseExpoInOut(float t, float b, float c, float d)
+{
+    if (t == 0.0f) return b;
+    if (t == d) return (b + c);
+    if ((t/=d/2.0f) < 1.0f) return (c/2.0f*powf(2.0f, 10.0f*(t - 1.0f)) + b);
+
+    return (c/2.0f*(-powf(2.0f, -10.0f*(t - 1.0f)) + 2.0f) + b);
+}
+
+// Back Easing functions
+static float EaseBackIn(float t, float b, float c, float d)
+{
+    float s = 1.70158f;
+    float postFix = t/=d;
+    return (c*(postFix)*t*((s + 1.0f)*t - s) + b);
+}
+
+static float EaseBackOut(float t, float b, float c, float d)
+{
+    float s = 1.70158f;
+    t = t/d - 1.0f;
+    return (c*(t*t*((s + 1.0f)*t + s) + 1.0f) + b);
+}
+
+static float EaseBackInOut(float t, float b, float c, float d)
+{
+    float s = 1.70158f;
+    if ((t/=d/2.0f) < 1.0f)
+    {
+        s *= 1.525f;
+        return (c/2.0f*(t*t*((s + 1.0f)*t - s)) + b);
+    }
+
+    float postFix = t-=2.0f;
+    s *= 1.525f;
+    return (c/2.0f*((postFix)*t*((s + 1.0f)*t + s) + 2.0f) + b);
+}
+
+// Bounce Easing functions
+static float EaseBounceOut(float t, float b, float c, float d)
+{
+    if ((t/=d) < (1.0f/2.75f))
+    {
+        return (c*(7.5625f*t*t) + b);
+    }
+    else if (t < (2.0f/2.75f))
+    {
+        float postFix = t-=(1.5f/2.75f);
+        return (c*(7.5625f*(postFix)*t + 0.75f) + b);
+    }
+    else if (t < (2.5/2.75))
+    {
+        float postFix = t-=(2.25f/2.75f);
+        return (c*(7.5625f*(postFix)*t + 0.9375f) + b);
+    }
+    else
+    {
+        float postFix = t-=(2.625f/2.75f);
+        return (c*(7.5625f*(postFix)*t + 0.984375f) + b);
+    }
+}
+
+static float EaseBounceIn(float t, float b, float c, float d) { return (c - EaseBounceOut(d - t, 0.0f, c, d) + b); }
+static float EaseBounceInOut(float t, float b, float c, float d)
+{
+    if (t < d/2.0f) return (EaseBounceIn(t*2.0f, 0.0f, c, d)*0.5f + b);
+    else return (EaseBounceOut(t*2.0f - d, 0.0f, c, d)*0.5f + c*0.5f + b);
+}
+
+// Elastic Easing functions
+static float EaseElasticIn(float t, float b, float c, float d)
+{
+    if (t == 0.0f) return b;
+    if ((t/=d) == 1.0f) return (b + c);
+
+    float p = d*0.3f;
+    float a = c;
+    float s = p/4.0f;
+    float postFix = a*powf(2.0f, 10.0f*(t-=1.0f));
+
+    return (-(postFix*sinf((t*d-s)*(2.0f*PI)/p )) + b);
+}
+
+static float EaseElasticOut(float t, float b, float c, float d)
+{
+    if (t == 0.0f) return b;
+    if ((t/=d) == 1.0f) return (b + c);
+
+    float p = d*0.3f;
+    float a = c;
+    float s = p/4.0f;
+
+    return (a*powf(2.0f,-10.0f*t)*sinf((t*d-s)*(2.0f*PI)/p) + c + b);
+}
+
+static float EaseElasticInOut(float t, float b, float c, float d)
+{
+    if (t == 0.0f) return b;
+    if ((t/=d/2.0f) == 2.0f) return (b + c);
+
+    float p = d*(0.3f*1.5f);
+    float a = c;
+    float s = p/4.0f;
+
+    if (t < 1.0f)
+    {
+        float postFix = a*powf(2.0f, 10.0f*(t-=1.0f));
+        return -0.5f*(postFix*sinf((t*d-s)*(2.0f*PI)/p)) + b;
+    }
+
+    float postFix = a*powf(2.0f, -10.0f*(t-=1.0f));
+
+    return (postFix*sinf((t*d-s)*(2.0f*PI)/p)*0.5f + c + b);
+}

source/raylib/rlgl.d

@@ -0,0 +1,1926 @@
+module raylib.rlgl;
+
+import raylib;
+/**********************************************************************************************
+*
+*   rlgl v4.0 - A multi-OpenGL abstraction layer with an immediate-mode style API
+*
+*   An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0)
+*   that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...)
+*
+*   When chosing an OpenGL backend different than OpenGL 1.1, some internal buffer are
+*   initialized on rlglInit() to accumulate vertex data.
+*
+*   When an internal state change is required all the stored vertex data is renderer in batch,
+*   additioanlly, rlDrawRenderBatchActive() could be called to force flushing of the batch.
+*
+*   Some additional resources are also loaded for convenience, here the complete list:
+*      - Default batch (RLGL.defaultBatch): RenderBatch system to accumulate vertex data
+*      - Default texture (RLGL.defaultTextureId): 1x1 white pixel R8G8B8A8
+*      - Default shader (RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs)
+*
+*   Internal buffer (and additional resources) must be manually unloaded calling rlglClose().
+*
+*
+*   CONFIGURATION:
+*
+*   #define GRAPHICS_API_OPENGL_11
+*   #define GRAPHICS_API_OPENGL_21
+*   #define GRAPHICS_API_OPENGL_33
+*   #define GRAPHICS_API_OPENGL_43
+*   #define GRAPHICS_API_OPENGL_ES2
+*       Use selected OpenGL graphics backend, should be supported by platform
+*       Those preprocessor defines are only used on rlgl module, if OpenGL version is
+*       required by any other module, use rlGetVersion() to check it
+*
+*   #define RLGL_IMPLEMENTATION
+*       Generates the implementation of the library into the included file.
+*       If not defined, the library is in header only mode and can be included in other headers
+*       or source files without problems. But only ONE file should hold the implementation.
+*
+*   #define RLGL_RENDER_TEXTURES_HINT
+*       Enable framebuffer objects (fbo) support (enabled by default)
+*       Some GPUs could not support them despite the OpenGL version
+*
+*   #define RLGL_SHOW_GL_DETAILS_INFO
+*       Show OpenGL extensions and capabilities detailed logs on init
+*
+*   #define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT
+*       Enable debug context (only available on OpenGL 4.3)
+*
+*   rlgl capabilities could be customized just defining some internal
+*   values before library inclusion (default values listed):
+*
+*   #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS   8192    // Default internal render batch elements limits
+*   #define RL_DEFAULT_BATCH_BUFFERS              1    // Default number of batch buffers (multi-buffering)
+*   #define RL_DEFAULT_BATCH_DRAWCALLS          256    // Default number of batch draw calls (by state changes: mode, texture)
+*   #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS    4    // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
+*
+*   #define RL_MAX_MATRIX_STACK_SIZE             32    // Maximum size of internal Matrix stack
+*   #define RL_MAX_SHADER_LOCATIONS              32    // Maximum number of shader locations supported
+*   #define RL_CULL_DISTANCE_NEAR              0.01    // Default projection matrix near cull distance
+*   #define RL_CULL_DISTANCE_FAR             1000.0    // Default projection matrix far cull distance
+*
+*   When loading a shader, the following vertex attribute and uniform
+*   location names are tried to be set automatically:
+*
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Binded by default to shader location: 0
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Binded by default to shader location: 1
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL       "vertexNormal"      // Binded by default to shader location: 2
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR        "vertexColor"       // Binded by default to shader location: 3
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT      "vertexTangent"     // Binded by default to shader location: 4
+*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Binded by default to shader location: 5
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP         "mvp"               // model-view-projection matrix
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW        "matView"           // view matrix
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION  "matProjection"     // projection matrix
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL       "matModel"          // model matrix
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL      "matNormal"         // normal matrix (transpose(inverse(matModelView))
+*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR       "colDiffuse"        // color diffuse (base tint color, multiplied by texture color)
+*   #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0  "texture0"          // texture0 (texture slot active 0)
+*   #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1  "texture1"          // texture1 (texture slot active 1)
+*   #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2  "texture2"          // texture2 (texture slot active 2)
+*
+*   DEPENDENCIES:
+*
+*      - OpenGL libraries (depending on platform and OpenGL version selected)
+*      - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core, 4.3 Core)
+*
+*
+*   LICENSE: zlib/libpng
+*
+*   Copyright (c) 2014-2022 Ramon Santamaria (@raysan5)
+*
+*   This software is provided "as-is", without any express or implied warranty. In no event
+*   will the authors be held liable for any damages arising from the use of this software.
+*
+*   Permission is granted to anyone to use this software for any purpose, including commercial
+*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
+*
+*     1. The origin of this software must not be misrepresented; you must not claim that you
+*     wrote the original software. If you use this software in a product, an acknowledgment
+*     in the product documentation would be appreciated but is not required.
+*
+*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
+*     as being the original software.
+*
+*     3. This notice may not be removed or altered from any source distribution.
+*
+**********************************************************************************************/
+
+extern (C) @nogc nothrow:
+
+enum RLGL_VERSION = "4.0";
+
+// Function specifiers in case library is build/used as a shared library (Windows)
+// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
+
+// We are building the library as a Win32 shared library (.dll)
+
+// We are using the library as a Win32 shared library (.dll)
+
+// Function specifiers definition // Functions defined as 'extern' by default (implicit specifiers)
+
+// Support TRACELOG macros
+
+// Allow custom memory allocators
+
+// Security check in case no GRAPHICS_API_OPENGL_* defined
+
+// Security check in case multiple GRAPHICS_API_OPENGL_* defined
+
+// OpenGL 2.1 uses most of OpenGL 3.3 Core functionality
+// WARNING: Specific parts are checked with #if defines
+
+// OpenGL 4.3 uses OpenGL 3.3 Core functionality
+
+// Support framebuffer objects by default
+// NOTE: Some driver implementation do not support it, despite they should
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+
+// Default internal render batch elements limits
+
+// This is the maximum amount of elements (quads) per batch
+// NOTE: Be careful with text, every letter maps to a quad
+enum RL_DEFAULT_BATCH_BUFFER_ELEMENTS = 8192;
+
+// We reduce memory sizes for embedded systems (RPI and HTML5)
+// NOTE: On HTML5 (emscripten) this is allocated on heap,
+// by default it's only 16MB!...just take care...
+
+enum RL_DEFAULT_BATCH_BUFFERS = 1; // Default number of batch buffers (multi-buffering)
+
+enum RL_DEFAULT_BATCH_DRAWCALLS = 256; // Default number of batch draw calls (by state changes: mode, texture)
+
+enum RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS = 4; // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
+
+// Internal Matrix stack
+
+enum RL_MAX_MATRIX_STACK_SIZE = 32; // Maximum size of Matrix stack
+
+// Shader limits
+
+enum RL_MAX_SHADER_LOCATIONS = 32; // Maximum number of shader locations supported
+
+// Projection matrix culling
+
+enum RL_CULL_DISTANCE_NEAR = 0.01; // Default near cull distance
+
+enum RL_CULL_DISTANCE_FAR = 1000.0; // Default far cull distance
+
+// Texture parameters (equivalent to OpenGL defines)
+enum RL_TEXTURE_WRAP_S = 0x2802; // GL_TEXTURE_WRAP_S
+enum RL_TEXTURE_WRAP_T = 0x2803; // GL_TEXTURE_WRAP_T
+enum RL_TEXTURE_MAG_FILTER = 0x2800; // GL_TEXTURE_MAG_FILTER
+enum RL_TEXTURE_MIN_FILTER = 0x2801; // GL_TEXTURE_MIN_FILTER
+
+enum RL_TEXTURE_FILTER_NEAREST = 0x2600; // GL_NEAREST
+enum RL_TEXTURE_FILTER_LINEAR = 0x2601; // GL_LINEAR
+enum RL_TEXTURE_FILTER_MIP_NEAREST = 0x2700; // GL_NEAREST_MIPMAP_NEAREST
+enum RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR = 0x2702; // GL_NEAREST_MIPMAP_LINEAR
+enum RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST = 0x2701; // GL_LINEAR_MIPMAP_NEAREST
+enum RL_TEXTURE_FILTER_MIP_LINEAR = 0x2703; // GL_LINEAR_MIPMAP_LINEAR
+enum RL_TEXTURE_FILTER_ANISOTROPIC = 0x3000; // Anisotropic filter (custom identifier)
+
+enum RL_TEXTURE_WRAP_REPEAT = 0x2901; // GL_REPEAT
+enum RL_TEXTURE_WRAP_CLAMP = 0x812F; // GL_CLAMP_TO_EDGE
+enum RL_TEXTURE_WRAP_MIRROR_REPEAT = 0x8370; // GL_MIRRORED_REPEAT
+enum RL_TEXTURE_WRAP_MIRROR_CLAMP = 0x8742; // GL_MIRROR_CLAMP_EXT
+
+// Matrix modes (equivalent to OpenGL)
+enum RL_MODELVIEW = 0x1700; // GL_MODELVIEW
+enum RL_PROJECTION = 0x1701; // GL_PROJECTION
+enum RL_TEXTURE = 0x1702; // GL_TEXTURE
+
+// Primitive assembly draw modes
+enum RL_LINES = 0x0001; // GL_LINES
+enum RL_TRIANGLES = 0x0004; // GL_TRIANGLES
+enum RL_QUADS = 0x0007; // GL_QUADS
+
+// GL equivalent data types
+enum RL_UNSIGNED_BYTE = 0x1401; // GL_UNSIGNED_BYTE
+enum RL_FLOAT = 0x1406; // GL_FLOAT
+
+// Buffer usage hint
+enum RL_STREAM_DRAW = 0x88E0; // GL_STREAM_DRAW
+enum RL_STREAM_READ = 0x88E1; // GL_STREAM_READ
+enum RL_STREAM_COPY = 0x88E2; // GL_STREAM_COPY
+enum RL_STATIC_DRAW = 0x88E4; // GL_STATIC_DRAW
+enum RL_STATIC_READ = 0x88E5; // GL_STATIC_READ
+enum RL_STATIC_COPY = 0x88E6; // GL_STATIC_COPY
+enum RL_DYNAMIC_DRAW = 0x88E8; // GL_DYNAMIC_DRAW
+enum RL_DYNAMIC_READ = 0x88E9; // GL_DYNAMIC_READ
+enum RL_DYNAMIC_COPY = 0x88EA; // GL_DYNAMIC_COPY
+
+// GL Shader type
+enum RL_FRAGMENT_SHADER = 0x8B30; // GL_FRAGMENT_SHADER
+enum RL_VERTEX_SHADER = 0x8B31; // GL_VERTEX_SHADER
+enum RL_COMPUTE_SHADER = 0x91B9; // GL_COMPUTE_SHADER
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+enum rlGlVersion
+{
+    OPENGL_11 = 1,
+    OPENGL_21 = 2,
+    OPENGL_33 = 3,
+    OPENGL_43 = 4,
+    OPENGL_ES_20 = 5
+}
+
+enum rlFramebufferAttachType
+{
+    RL_ATTACHMENT_COLOR_CHANNEL0 = 0,
+    RL_ATTACHMENT_COLOR_CHANNEL1 = 1,
+    RL_ATTACHMENT_COLOR_CHANNEL2 = 2,
+    RL_ATTACHMENT_COLOR_CHANNEL3 = 3,
+    RL_ATTACHMENT_COLOR_CHANNEL4 = 4,
+    RL_ATTACHMENT_COLOR_CHANNEL5 = 5,
+    RL_ATTACHMENT_COLOR_CHANNEL6 = 6,
+    RL_ATTACHMENT_COLOR_CHANNEL7 = 7,
+    RL_ATTACHMENT_DEPTH = 100,
+    RL_ATTACHMENT_STENCIL = 200
+}
+
+enum rlFramebufferAttachTextureType
+{
+    RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0,
+    RL_ATTACHMENT_CUBEMAP_NEGATIVE_X = 1,
+    RL_ATTACHMENT_CUBEMAP_POSITIVE_Y = 2,
+    RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y = 3,
+    RL_ATTACHMENT_CUBEMAP_POSITIVE_Z = 4,
+    RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z = 5,
+    RL_ATTACHMENT_TEXTURE2D = 100,
+    RL_ATTACHMENT_RENDERBUFFER = 200
+}
+
+// Dynamic vertex buffers (position + texcoords + colors + indices arrays)
+struct rlVertexBuffer
+{
+    int elementCount; // Number of elements in the buffer (QUADS)
+
+    float* vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
+    float* texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
+    ubyte* colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
+
+    uint* indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad)
+
+    // Vertex indices (in case vertex data comes indexed) (6 indices per quad)
+
+    uint vaoId; // OpenGL Vertex Array Object id
+    uint[4] vboId; // OpenGL Vertex Buffer Objects id (4 types of vertex data)
+}
+
+// Draw call type
+// NOTE: Only texture changes register a new draw, other state-change-related elements are not
+// used at this moment (vaoId, shaderId, matrices), raylib just forces a batch draw call if any
+// of those state-change happens (this is done in core module)
+struct rlDrawCall
+{
+    int mode; // Drawing mode: LINES, TRIANGLES, QUADS
+    int vertexCount; // Number of vertex of the draw
+    int vertexAlignment; // Number of vertex required for index alignment (LINES, TRIANGLES)
+    //unsigned int vaoId;       // Vertex array id to be used on the draw -> Using RLGL.currentBatch->vertexBuffer.vaoId
+    //unsigned int shaderId;    // Shader id to be used on the draw -> Using RLGL.currentShaderId
+    uint textureId; // Texture id to be used on the draw -> Use to create new draw call if changes
+
+    //Matrix projection;      // Projection matrix for this draw -> Using RLGL.projection by default
+    //Matrix modelview;       // Modelview matrix for this draw -> Using RLGL.modelview by default
+}
+
+// rlRenderBatch type
+struct rlRenderBatch
+{
+    int bufferCount; // Number of vertex buffers (multi-buffering support)
+    int currentBuffer; // Current buffer tracking in case of multi-buffering
+    rlVertexBuffer* vertexBuffer; // Dynamic buffer(s) for vertex data
+
+    rlDrawCall* draws; // Draw calls array, depends on textureId
+    int drawCounter; // Draw calls counter
+    float currentDepth; // Current depth value for next draw
+}
+
+// Boolean type
+
+// Matrix, 4x4 components, column major, OpenGL style, right handed
+
+// Matrix first row (4 components)
+// Matrix second row (4 components)
+// Matrix third row (4 components)
+// Matrix fourth row (4 components)
+
+// Trace log level
+// NOTE: Organized by priority level
+enum rlTraceLogLevel
+{
+    RL_LOG_ALL = 0, // Display all logs
+    RL_LOG_TRACE = 1, // Trace logging, intended for internal use only
+    RL_LOG_DEBUG = 2, // Debug logging, used for internal debugging, it should be disabled on release builds
+    RL_LOG_INFO = 3, // Info logging, used for program execution info
+    RL_LOG_WARNING = 4, // Warning logging, used on recoverable failures
+    RL_LOG_ERROR = 5, // Error logging, used on unrecoverable failures
+    RL_LOG_FATAL = 6, // Fatal logging, used to abort program: exit(EXIT_FAILURE)
+    RL_LOG_NONE = 7 // Disable logging
+}
+
+// Texture formats (support depends on OpenGL version)
+enum rlPixelFormat
+{
+    RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
+    RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA = 2, // 8*2 bpp (2 channels)
+    RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5 = 3, // 16 bpp
+    RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8 = 4, // 24 bpp
+    RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 = 5, // 16 bpp (1 bit alpha)
+    RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 = 6, // 16 bpp (4 bit alpha)
+    RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 = 7, // 32 bpp
+    RL_PIXELFORMAT_UNCOMPRESSED_R32 = 8, // 32 bpp (1 channel - float)
+    RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32 = 9, // 32*3 bpp (3 channels - float)
+    RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 = 10, // 32*4 bpp (4 channels - float)
+    RL_PIXELFORMAT_COMPRESSED_DXT1_RGB = 11, // 4 bpp (no alpha)
+    RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA = 12, // 4 bpp (1 bit alpha)
+    RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA = 13, // 8 bpp
+    RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA = 14, // 8 bpp
+    RL_PIXELFORMAT_COMPRESSED_ETC1_RGB = 15, // 4 bpp
+    RL_PIXELFORMAT_COMPRESSED_ETC2_RGB = 16, // 4 bpp
+    RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA = 17, // 8 bpp
+    RL_PIXELFORMAT_COMPRESSED_PVRT_RGB = 18, // 4 bpp
+    RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA = 19, // 4 bpp
+    RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA = 20, // 8 bpp
+    RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA = 21 // 2 bpp
+}
+
+// Texture parameters: filter mode
+// NOTE 1: Filtering considers mipmaps if available in the texture
+// NOTE 2: Filter is accordingly set for minification and magnification
+enum rlTextureFilter
+{
+    RL_TEXTURE_FILTER_POINT = 0, // No filter, just pixel approximation
+    RL_TEXTURE_FILTER_BILINEAR = 1, // Linear filtering
+    RL_TEXTURE_FILTER_TRILINEAR = 2, // Trilinear filtering (linear with mipmaps)
+    RL_TEXTURE_FILTER_ANISOTROPIC_4X = 3, // Anisotropic filtering 4x
+    RL_TEXTURE_FILTER_ANISOTROPIC_8X = 4, // Anisotropic filtering 8x
+    RL_TEXTURE_FILTER_ANISOTROPIC_16X = 5 // Anisotropic filtering 16x
+}
+
+// Color blending modes (pre-defined)
+enum rlBlendMode
+{
+    RL_BLEND_ALPHA = 0, // Blend textures considering alpha (default)
+    RL_BLEND_ADDITIVE = 1, // Blend textures adding colors
+    RL_BLEND_MULTIPLIED = 2, // Blend textures multiplying colors
+    RL_BLEND_ADD_COLORS = 3, // Blend textures adding colors (alternative)
+    RL_BLEND_SUBTRACT_COLORS = 4, // Blend textures subtracting colors (alternative)
+    RL_BLEND_ALPHA_PREMULTIPLY = 5, // Blend premultiplied textures considering alpha
+    RL_BLEND_CUSTOM = 6 // Blend textures using custom src/dst factors (use rlSetBlendFactors())
+}
+
+// Shader location point type
+enum rlShaderLocationIndex
+{
+    RL_SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position
+    RL_SHADER_LOC_VERTEX_TEXCOORD01 = 1, // Shader location: vertex attribute: texcoord01
+    RL_SHADER_LOC_VERTEX_TEXCOORD02 = 2, // Shader location: vertex attribute: texcoord02
+    RL_SHADER_LOC_VERTEX_NORMAL = 3, // Shader location: vertex attribute: normal
+    RL_SHADER_LOC_VERTEX_TANGENT = 4, // Shader location: vertex attribute: tangent
+    RL_SHADER_LOC_VERTEX_COLOR = 5, // Shader location: vertex attribute: color
+    RL_SHADER_LOC_MATRIX_MVP = 6, // Shader location: matrix uniform: model-view-projection
+    RL_SHADER_LOC_MATRIX_VIEW = 7, // Shader location: matrix uniform: view (camera transform)
+    RL_SHADER_LOC_MATRIX_PROJECTION = 8, // Shader location: matrix uniform: projection
+    RL_SHADER_LOC_MATRIX_MODEL = 9, // Shader location: matrix uniform: model (transform)
+    RL_SHADER_LOC_MATRIX_NORMAL = 10, // Shader location: matrix uniform: normal
+    RL_SHADER_LOC_VECTOR_VIEW = 11, // Shader location: vector uniform: view
+    RL_SHADER_LOC_COLOR_DIFFUSE = 12, // Shader location: vector uniform: diffuse color
+    RL_SHADER_LOC_COLOR_SPECULAR = 13, // Shader location: vector uniform: specular color
+    RL_SHADER_LOC_COLOR_AMBIENT = 14, // Shader location: vector uniform: ambient color
+    RL_SHADER_LOC_MAP_ALBEDO = 15, // Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE)
+    RL_SHADER_LOC_MAP_METALNESS = 16, // Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR)
+    RL_SHADER_LOC_MAP_NORMAL = 17, // Shader location: sampler2d texture: normal
+    RL_SHADER_LOC_MAP_ROUGHNESS = 18, // Shader location: sampler2d texture: roughness
+    RL_SHADER_LOC_MAP_OCCLUSION = 19, // Shader location: sampler2d texture: occlusion
+    RL_SHADER_LOC_MAP_EMISSION = 20, // Shader location: sampler2d texture: emission
+    RL_SHADER_LOC_MAP_HEIGHT = 21, // Shader location: sampler2d texture: height
+    RL_SHADER_LOC_MAP_CUBEMAP = 22, // Shader location: samplerCube texture: cubemap
+    RL_SHADER_LOC_MAP_IRRADIANCE = 23, // Shader location: samplerCube texture: irradiance
+    RL_SHADER_LOC_MAP_PREFILTER = 24, // Shader location: samplerCube texture: prefilter
+    RL_SHADER_LOC_MAP_BRDF = 25 // Shader location: sampler2d texture: brdf
+}
+
+enum RL_SHADER_LOC_MAP_DIFFUSE = rlShaderLocationIndex.RL_SHADER_LOC_MAP_ALBEDO;
+enum RL_SHADER_LOC_MAP_SPECULAR = rlShaderLocationIndex.RL_SHADER_LOC_MAP_METALNESS;
+
+// Shader uniform data type
+enum rlShaderUniformDataType
+{
+    RL_SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float
+    RL_SHADER_UNIFORM_VEC2 = 1, // Shader uniform type: vec2 (2 float)
+    RL_SHADER_UNIFORM_VEC3 = 2, // Shader uniform type: vec3 (3 float)
+    RL_SHADER_UNIFORM_VEC4 = 3, // Shader uniform type: vec4 (4 float)
+    RL_SHADER_UNIFORM_INT = 4, // Shader uniform type: int
+    RL_SHADER_UNIFORM_IVEC2 = 5, // Shader uniform type: ivec2 (2 int)
+    RL_SHADER_UNIFORM_IVEC3 = 6, // Shader uniform type: ivec3 (3 int)
+    RL_SHADER_UNIFORM_IVEC4 = 7, // Shader uniform type: ivec4 (4 int)
+    RL_SHADER_UNIFORM_SAMPLER2D = 8 // Shader uniform type: sampler2d
+}
+
+// Shader attribute data types
+enum rlShaderAttributeDataType
+{
+    RL_SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float
+    RL_SHADER_ATTRIB_VEC2 = 1, // Shader attribute type: vec2 (2 float)
+    RL_SHADER_ATTRIB_VEC3 = 2, // Shader attribute type: vec3 (3 float)
+    RL_SHADER_ATTRIB_VEC4 = 3 // Shader attribute type: vec4 (4 float)
+}
+
+//------------------------------------------------------------------------------------
+// Functions Declaration - Matrix operations
+//------------------------------------------------------------------------------------
+
+// Prevents name mangling of functions
+
+void rlMatrixMode(int mode); // Choose the current matrix to be transformed
+void rlPushMatrix(); // Push the current matrix to stack
+void rlPopMatrix(); // Pop lattest inserted matrix from stack
+void rlLoadIdentity(); // Reset current matrix to identity matrix
+void rlTranslatef(float x, float y, float z); // Multiply the current matrix by a translation matrix
+void rlRotatef(float angle, float x, float y, float z); // Multiply the current matrix by a rotation matrix
+void rlScalef(float x, float y, float z); // Multiply the current matrix by a scaling matrix
+void rlMultMatrixf(float* matf); // Multiply the current matrix by another matrix
+void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar);
+void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar);
+void rlViewport(int x, int y, int width, int height); // Set the viewport area
+
+//------------------------------------------------------------------------------------
+// Functions Declaration - Vertex level operations
+//------------------------------------------------------------------------------------
+void rlBegin(int mode); // Initialize drawing mode (how to organize vertex)
+void rlEnd(); // Finish vertex providing
+void rlVertex2i(int x, int y); // Define one vertex (position) - 2 int
+void rlVertex2f(float x, float y); // Define one vertex (position) - 2 float
+void rlVertex3f(float x, float y, float z); // Define one vertex (position) - 3 float
+void rlTexCoord2f(float x, float y); // Define one vertex (texture coordinate) - 2 float
+void rlNormal3f(float x, float y, float z); // Define one vertex (normal) - 3 float
+void rlColor4ub(ubyte r, ubyte g, ubyte b, ubyte a); // Define one vertex (color) - 4 byte
+void rlColor3f(float x, float y, float z); // Define one vertex (color) - 3 float
+void rlColor4f(float x, float y, float z, float w); // Define one vertex (color) - 4 float
+
+//------------------------------------------------------------------------------------
+// Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2)
+// NOTE: This functions are used to completely abstract raylib code from OpenGL layer,
+// some of them are direct wrappers over OpenGL calls, some others are custom
+//------------------------------------------------------------------------------------
+
+// Vertex buffers state
+bool rlEnableVertexArray(uint vaoId); // Enable vertex array (VAO, if supported)
+void rlDisableVertexArray(); // Disable vertex array (VAO, if supported)
+void rlEnableVertexBuffer(uint id); // Enable vertex buffer (VBO)
+void rlDisableVertexBuffer(); // Disable vertex buffer (VBO)
+void rlEnableVertexBufferElement(uint id); // Enable vertex buffer element (VBO element)
+void rlDisableVertexBufferElement(); // Disable vertex buffer element (VBO element)
+void rlEnableVertexAttribute(uint index); // Enable vertex attribute index
+void rlDisableVertexAttribute(uint index); // Disable vertex attribute index
+
+// Enable attribute state pointer
+// Disable attribute state pointer
+
+// Textures state
+void rlActiveTextureSlot(int slot); // Select and active a texture slot
+void rlEnableTexture(uint id); // Enable texture
+void rlDisableTexture(); // Disable texture
+void rlEnableTextureCubemap(uint id); // Enable texture cubemap
+void rlDisableTextureCubemap(); // Disable texture cubemap
+void rlTextureParameters(uint id, int param, int value); // Set texture parameters (filter, wrap)
+
+// Shader state
+void rlEnableShader(uint id); // Enable shader program
+void rlDisableShader(); // Disable shader program
+
+// Framebuffer state
+void rlEnableFramebuffer(uint id); // Enable render texture (fbo)
+void rlDisableFramebuffer(); // Disable render texture (fbo), return to default framebuffer
+void rlActiveDrawBuffers(int count); // Activate multiple draw color buffers
+
+// General render state
+void rlEnableColorBlend(); // Enable color blending
+void rlDisableColorBlend(); // Disable color blending
+void rlEnableDepthTest(); // Enable depth test
+void rlDisableDepthTest(); // Disable depth test
+void rlEnableDepthMask(); // Enable depth write
+void rlDisableDepthMask(); // Disable depth write
+void rlEnableBackfaceCulling(); // Enable backface culling
+void rlDisableBackfaceCulling(); // Disable backface culling
+void rlEnableScissorTest(); // Enable scissor test
+void rlDisableScissorTest(); // Disable scissor test
+void rlScissor(int x, int y, int width, int height); // Scissor test
+void rlEnableWireMode(); // Enable wire mode
+void rlDisableWireMode(); // Disable wire mode
+void rlSetLineWidth(float width); // Set the line drawing width
+float rlGetLineWidth(); // Get the line drawing width
+void rlEnableSmoothLines(); // Enable line aliasing
+void rlDisableSmoothLines(); // Disable line aliasing
+void rlEnableStereoRender(); // Enable stereo rendering
+void rlDisableStereoRender(); // Disable stereo rendering
+bool rlIsStereoRenderEnabled(); // Check if stereo render is enabled
+
+void rlClearColor(ubyte r, ubyte g, ubyte b, ubyte a); // Clear color buffer with color
+void rlClearScreenBuffers(); // Clear used screen buffers (color and depth)
+void rlCheckErrors(); // Check and log OpenGL error codes
+void rlSetBlendMode(int mode); // Set blending mode
+void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation); // Set blending mode factor and equation (using OpenGL factors)
+
+//------------------------------------------------------------------------------------
+// Functions Declaration - rlgl functionality
+//------------------------------------------------------------------------------------
+// rlgl initialization functions
+void rlglInit(int width, int height); // Initialize rlgl (buffers, shaders, textures, states)
+void rlglClose(); // De-inititialize rlgl (buffers, shaders, textures)
+void rlLoadExtensions(void* loader); // Load OpenGL extensions (loader function required)
+int rlGetVersion(); // Get current OpenGL version
+void rlSetFramebufferWidth(int width); // Set current framebuffer width
+int rlGetFramebufferWidth(); // Get default framebuffer width
+void rlSetFramebufferHeight(int height); // Set current framebuffer height
+int rlGetFramebufferHeight(); // Get default framebuffer height
+
+uint rlGetTextureIdDefault(); // Get default texture id
+uint rlGetShaderIdDefault(); // Get default shader id
+int* rlGetShaderLocsDefault(); // Get default shader locations
+
+// Render batch management
+// NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode
+// but this render batch API is exposed in case of custom batches are required
+rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements); // Load a render batch system
+void rlUnloadRenderBatch(rlRenderBatch batch); // Unload render batch system
+void rlDrawRenderBatch(rlRenderBatch* batch); // Draw render batch data (Update->Draw->Reset)
+void rlSetRenderBatchActive(rlRenderBatch* batch); // Set the active render batch for rlgl (NULL for default internal)
+void rlDrawRenderBatchActive(); // Update and draw internal render batch
+bool rlCheckRenderBatchLimit(int vCount); // Check internal buffer overflow for a given number of vertex
+void rlSetTexture(uint id); // Set current texture for render batch and check buffers limits
+
+//------------------------------------------------------------------------------------------------------------------------
+
+// Vertex buffers management
+uint rlLoadVertexArray(); // Load vertex array (vao) if supported
+uint rlLoadVertexBuffer(const(void)* buffer, int size, bool dynamic); // Load a vertex buffer attribute
+uint rlLoadVertexBufferElement(const(void)* buffer, int size, bool dynamic); // Load a new attributes element buffer
+void rlUpdateVertexBuffer(uint bufferId, const(void)* data, int dataSize, int offset); // Update GPU buffer with new data
+void rlUpdateVertexBufferElements(uint id, const(void)* data, int dataSize, int offset); // Update vertex buffer elements with new data
+void rlUnloadVertexArray(uint vaoId);
+void rlUnloadVertexBuffer(uint vboId);
+void rlSetVertexAttribute(uint index, int compSize, int type, bool normalized, int stride, const(void)* pointer);
+void rlSetVertexAttributeDivisor(uint index, int divisor);
+void rlSetVertexAttributeDefault(int locIndex, const(void)* value, int attribType, int count); // Set vertex attribute default value
+void rlDrawVertexArray(int offset, int count);
+void rlDrawVertexArrayElements(int offset, int count, const(void)* buffer);
+void rlDrawVertexArrayInstanced(int offset, int count, int instances);
+void rlDrawVertexArrayElementsInstanced(int offset, int count, const(void)* buffer, int instances);
+
+// Textures management
+uint rlLoadTexture(const(void)* data, int width, int height, int format, int mipmapCount); // Load texture in GPU
+uint rlLoadTextureDepth(int width, int height, bool useRenderBuffer); // Load depth texture/renderbuffer (to be attached to fbo)
+uint rlLoadTextureCubemap(const(void)* data, int size, int format); // Load texture cubemap
+void rlUpdateTexture(uint id, int offsetX, int offsetY, int width, int height, int format, const(void)* data); // Update GPU texture with new data
+void rlGetGlTextureFormats(int format, uint* glInternalFormat, uint* glFormat, uint* glType); // Get OpenGL internal formats
+const(char)* rlGetPixelFormatName(uint format); // Get name string for pixel format
+void rlUnloadTexture(uint id); // Unload texture from GPU memory
+void rlGenTextureMipmaps(uint id, int width, int height, int format, int* mipmaps); // Generate mipmap data for selected texture
+void* rlReadTexturePixels(uint id, int width, int height, int format); // Read texture pixel data
+ubyte* rlReadScreenPixels(int width, int height); // Read screen pixel data (color buffer)
+
+// Framebuffer management (fbo)
+uint rlLoadFramebuffer(int width, int height); // Load an empty framebuffer
+void rlFramebufferAttach(uint fboId, uint texId, int attachType, int texType, int mipLevel); // Attach texture/renderbuffer to a framebuffer
+bool rlFramebufferComplete(uint id); // Verify framebuffer is complete
+void rlUnloadFramebuffer(uint id); // Delete framebuffer from GPU
+
+// Shaders management
+uint rlLoadShaderCode(const(char)* vsCode, const(char)* fsCode); // Load shader from code strings
+uint rlCompileShader(const(char)* shaderCode, int type); // Compile custom shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER)
+uint rlLoadShaderProgram(uint vShaderId, uint fShaderId); // Load custom shader program
+void rlUnloadShaderProgram(uint id); // Unload shader program
+int rlGetLocationUniform(uint shaderId, const(char)* uniformName); // Get shader location uniform
+int rlGetLocationAttrib(uint shaderId, const(char)* attribName); // Get shader location attribute
+void rlSetUniform(int locIndex, const(void)* value, int uniformType, int count); // Set shader value uniform
+void rlSetUniformMatrix(int locIndex, Matrix mat); // Set shader value matrix
+void rlSetUniformSampler(int locIndex, uint textureId); // Set shader value sampler
+void rlSetShader(uint id, int* locs); // Set shader currently active (id and locations)
+
+// Compute shader management
+uint rlLoadComputeShaderProgram(uint shaderId); // Load compute shader program
+void rlComputeShaderDispatch(uint groupX, uint groupY, uint groupZ); // Dispatch compute shader (equivalent to *draw* for graphics pilepine)
+
+// Shader buffer storage object management (ssbo)
+uint rlLoadShaderBuffer(ulong size, const(void)* data, int usageHint); // Load shader storage buffer object (SSBO)
+void rlUnloadShaderBuffer(uint ssboId); // Unload shader storage buffer object (SSBO)
+void rlUpdateShaderBufferElements(uint id, const(void)* data, ulong dataSize, ulong offset); // Update SSBO buffer data
+ulong rlGetShaderBufferSize(uint id); // Get SSBO buffer size
+void rlReadShaderBufferElements(uint id, void* dest, ulong count, ulong offset); // Bind SSBO buffer
+void rlBindShaderBuffer(uint id, uint index); // Copy SSBO buffer data
+
+// Buffer management
+void rlCopyBuffersElements(uint destId, uint srcId, ulong destOffset, ulong srcOffset, ulong count); // Copy SSBO buffer data
+void rlBindImageTexture(uint id, uint index, uint format, int readonly); // Bind image texture
+
+// Matrix state management
+Matrix rlGetMatrixModelview(); // Get internal modelview matrix
+Matrix rlGetMatrixProjection(); // Get internal projection matrix
+Matrix rlGetMatrixTransform(); // Get internal accumulated transform matrix
+Matrix rlGetMatrixProjectionStereo(int eye); // Get internal projection matrix for stereo render (selected eye)
+Matrix rlGetMatrixViewOffsetStereo(int eye); // Get internal view offset matrix for stereo render (selected eye)
+void rlSetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix)
+void rlSetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix)
+void rlSetMatrixProjectionStereo(Matrix right, Matrix left); // Set eyes projection matrices for stereo rendering
+void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left); // Set eyes view offsets matrices for stereo rendering
+
+// Quick and dirty cube/quad buffers load->draw->unload
+void rlLoadDrawCube(); // Load and draw a cube
+void rlLoadDrawQuad(); // Load and draw a quad
+
+// RLGL_H
+
+/***********************************************************************************
+*
+*   RLGL IMPLEMENTATION
+*
+************************************************************************************/
+
+// OpenGL 1.1 library for OSX
+// OpenGL extensions library
+
+// APIENTRY for OpenGL function pointer declarations is required
+
+// WINGDIAPI definition. Some Windows OpenGL headers need it
+
+// OpenGL 1.1 library
+
+// OpenGL 3 library for OSX
+// OpenGL 3 extensions library for OSX
+
+// GLAD extensions loading library, includes OpenGL headers
+
+//#include <EGL/egl.h>              // EGL library -> not required, platform layer
+// OpenGL ES 2.0 library
+// OpenGL ES 2.0 extensions library
+
+// It seems OpenGL ES 2.0 instancing entry points are not defined on Raspberry Pi
+// provided headers (despite being defined in official Khronos GLES2 headers)
+
+// Required for: malloc(), free()
+// Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading]
+// Required for: sqrtf(), sinf(), cosf(), floor(), log()
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+
+// Default shader vertex attribute names to set location points
+
+// Binded by default to shader location: 0
+
+// Binded by default to shader location: 1
+
+// Binded by default to shader location: 2
+
+// Binded by default to shader location: 3
+
+// Binded by default to shader location: 4
+
+// Binded by default to shader location: 5
+
+// model-view-projection matrix
+
+// view matrix
+
+// projection matrix
+
+// model matrix
+
+// normal matrix (transpose(inverse(matModelView))
+
+// color diffuse (base tint color, multiplied by texture color)
+
+// texture0 (texture slot active 0)
+
+// texture1 (texture slot active 1)
+
+// texture2 (texture slot active 2)
+
+//----------------------------------------------------------------------------------
+// Types and Structures Definition
+//----------------------------------------------------------------------------------
+
+// Current render batch
+// Default internal render batch
+
+// Current active render batch vertex counter (generic, used for all batches)
+// Current active texture coordinate (added on glVertex*())
+// Current active normal (added on glVertex*())
+// Current active color (added on glVertex*())
+
+// Current matrix mode
+// Current matrix pointer
+// Default modelview matrix
+// Default projection matrix
+// Transform matrix to be used with rlTranslate, rlRotate, rlScale
+// Require transform matrix application to current draw-call vertex (if required)
+// Matrix stack for push/pop
+// Matrix stack counter
+
+// Default texture used on shapes/poly drawing (required by shader)
+// Active texture ids to be enabled on batch drawing (0 active by default)
+// Default vertex shader id (used by default shader program)
+// Default fragment shader id (used by default shader program)
+// Default shader program id, supports vertex color and diffuse texture
+// Default shader locations pointer to be used on rendering
+// Current shader id to be used on rendering (by default, defaultShaderId)
+// Current shader locations pointer to be used on rendering (by default, defaultShaderLocs)
+
+// Stereo rendering flag
+// VR stereo rendering eyes projection matrices
+// VR stereo rendering eyes view offset matrices
+
+// Blending mode active
+// Blending source factor
+// Blending destination factor
+// Blending equation
+
+// Current framebuffer width
+// Current framebuffer height
+
+// Renderer state
+
+// VAO support (OpenGL ES2 could not support VAO extension) (GL_ARB_vertex_array_object)
+// Instancing supported (GL_ANGLE_instanced_arrays, GL_EXT_draw_instanced + GL_EXT_instanced_arrays)
+// NPOT textures full support (GL_ARB_texture_non_power_of_two, GL_OES_texture_npot)
+// Depth textures supported (GL_ARB_depth_texture, GL_WEBGL_depth_texture, GL_OES_depth_texture)
+// float textures support (32 bit per channel) (GL_OES_texture_float)
+// DDS texture compression support (GL_EXT_texture_compression_s3tc, GL_WEBGL_compressed_texture_s3tc, GL_WEBKIT_WEBGL_compressed_texture_s3tc)
+// ETC1 texture compression support (GL_OES_compressed_ETC1_RGB8_texture, GL_WEBGL_compressed_texture_etc1)
+// ETC2/EAC texture compression support (GL_ARB_ES3_compatibility)
+// PVR texture compression support (GL_IMG_texture_compression_pvrtc)
+// ASTC texture compression support (GL_KHR_texture_compression_astc_hdr, GL_KHR_texture_compression_astc_ldr)
+// Clamp mirror wrap mode supported (GL_EXT_texture_mirror_clamp)
+// Anisotropic texture filtering support (GL_EXT_texture_filter_anisotropic)
+// Compute shaders support (GL_ARB_compute_shader)
+// Shader storage buffer object support (GL_ARB_shader_storage_buffer_object)
+
+// Maximum anisotropy level supported (minimum is 2.0f)
+// Maximum bits for depth component
+
+// Extensions supported flags
+
+// OpenGL extension functions loader signature (same as GLADloadproc)
+
+// GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+
+// GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+
+// NOTE: VAO functionality is exposed through extensions (OES)
+
+// NOTE: Instancing functionality could also be available through extension
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Declaration
+//----------------------------------------------------------------------------------
+
+// Load default shader
+// Unload default shader
+
+// Get compressed format official GL identifier name
+// RLGL_SHOW_GL_DETAILS_INFO
+// GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+
+// Generate mipmaps data on CPU side
+// Generate next mipmap level on CPU side
+
+// Get pixel data size in bytes (image or texture)
+// Auxiliar matrix math functions
+// Get identity matrix
+// Multiply two matrices
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Matrix operations
+//----------------------------------------------------------------------------------
+
+// Fallback to OpenGL 1.1 function calls
+//---------------------------------------
+
+// Choose the current matrix to be transformed
+
+//else if (mode == RL_TEXTURE) // Not supported
+
+// Push the current matrix into RLGL.State.stack
+
+// Pop lattest inserted matrix from RLGL.State.stack
+
+// Reset current matrix to identity matrix
+
+// Multiply the current matrix by a translation matrix
+
+// NOTE: We transpose matrix with multiplication order
+
+// Multiply the current matrix by a rotation matrix
+// NOTE: The provided angle must be in degrees
+
+// Axis vector (x, y, z) normalization
+
+// Rotation matrix generation
+
+// NOTE: We transpose matrix with multiplication order
+
+// Multiply the current matrix by a scaling matrix
+
+// NOTE: We transpose matrix with multiplication order
+
+// Multiply the current matrix by another matrix
+
+// Matrix creation from array
+
+// Multiply the current matrix by a perspective matrix generated by parameters
+
+// Multiply the current matrix by an orthographic matrix generated by parameters
+
+// NOTE: If left-right and top-botton values are equal it could create a division by zero,
+// response to it is platform/compiler dependant
+
+// Set the viewport area (transformation from normalized device coordinates to window coordinates)
+// NOTE: We store current viewport dimensions
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Vertex level operations
+//----------------------------------------------------------------------------------
+
+// Fallback to OpenGL 1.1 function calls
+//---------------------------------------
+
+// Initialize drawing mode (how to organize vertex)
+
+// Draw mode can be RL_LINES, RL_TRIANGLES and RL_QUADS
+// NOTE: In all three cases, vertex are accumulated over default internal vertex buffer
+
+// Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4,
+// that way, following QUADS drawing will keep aligned with index processing
+// It implies adding some extra alignment vertex at the end of the draw,
+// those vertex are not processed but they are considered as an additional offset
+// for the next set of vertex to be drawn
+
+// Finish vertex providing
+
+// NOTE: Depth increment is dependant on rlOrtho(): z-near and z-far values,
+// as well as depth buffer bit-depth (16bit or 24bit or 32bit)
+// Correct increment formula would be: depthInc = (zfar - znear)/pow(2, bits)
+
+// Verify internal buffers limits
+// NOTE: This check is combined with usage of rlCheckRenderBatchLimit()
+
+// WARNING: If we are between rlPushMatrix() and rlPopMatrix() and we need to force a rlDrawRenderBatch(),
+// we need to call rlPopMatrix() before to recover *RLGL.State.currentMatrix (RLGL.State.modelview) for the next forced draw call!
+// If we have multiple matrix pushed, it will require "RLGL.State.stackCounter" pops before launching the draw
+
+// Define one vertex (position)
+// NOTE: Vertex position data is the basic information required for drawing
+
+// Transform provided vector if required
+
+// Verify that current vertex buffer elements limit has not been reached
+
+// Add vertices
+
+// Add current texcoord
+
+// TODO: Add current normal
+// By default rlVertexBuffer type does not store normals
+
+// Add current color
+
+// Define one vertex (position)
+
+// Define one vertex (position)
+
+// Define one vertex (texture coordinate)
+// NOTE: Texture coordinates are limited to QUADS only
+
+// Define one vertex (normal)
+// NOTE: Normals limited to TRIANGLES only?
+
+// Define one vertex (color)
+
+// Define one vertex (color)
+
+// Define one vertex (color)
+
+//--------------------------------------------------------------------------------------
+// Module Functions Definition - OpenGL style functions (common to 1.1, 3.3+, ES2)
+//--------------------------------------------------------------------------------------
+
+// Set current texture to use
+
+// NOTE: If quads batch limit is reached, we force a draw call and next batch starts
+
+// Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4,
+// that way, following QUADS drawing will keep aligned with index processing
+// It implies adding some extra alignment vertex at the end of the draw,
+// those vertex are not processed but they are considered as an additional offset
+// for the next set of vertex to be drawn
+
+// Select and active a texture slot
+
+// Enable texture
+
+// Disable texture
+
+// Enable texture cubemap
+
+// Disable texture cubemap
+
+// Set texture parameters (wrap mode/filter mode)
+
+// Reset anisotropy filter, in case it was set
+
+// Enable shader program
+
+// Disable shader program
+
+// Enable rendering to texture (fbo)
+
+// Disable rendering to texture
+
+// Activate multiple draw color buffers
+// NOTE: One color buffer is always active by default
+
+// NOTE: Maximum number of draw buffers supported is implementation dependant,
+// it can be queried with glGet*() but it must be at least 8
+//GLint maxDrawBuffers = 0;
+//glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
+
+//----------------------------------------------------------------------------------
+// General render state configuration
+//----------------------------------------------------------------------------------
+
+// Enable color blending
+
+// Disable color blending
+
+// Enable depth test
+
+// Disable depth test
+
+// Enable depth write
+
+// Disable depth write
+
+// Enable backface culling
+
+// Disable backface culling
+
+// Enable scissor test
+
+// Disable scissor test
+
+// Scissor test
+
+// Enable wire mode
+
+// NOTE: glPolygonMode() not available on OpenGL ES
+
+// Disable wire mode
+
+// NOTE: glPolygonMode() not available on OpenGL ES
+
+// Set the line drawing width
+
+// Get the line drawing width
+
+// Enable line aliasing
+
+// Disable line aliasing
+
+// Enable stereo rendering
+
+// Disable stereo rendering
+
+// Check if stereo render is enabled
+
+// Clear color buffer with color
+
+// Color values clamp to 0.0f(0) and 1.0f(255)
+
+// Clear used screen buffers (color and depth)
+
+// Clear used buffers: Color and Depth (Depth is used for 3D)
+//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);     // Stencil buffer not used...
+
+// Check and log OpenGL error codes
+
+// Set blend mode
+
+// NOTE: Using GL blend src/dst factors and GL equation configured with rlSetBlendFactors()
+
+// Set blending mode factor and equation
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - OpenGL Debug
+//----------------------------------------------------------------------------------
+
+// Ignore non-significant error/warning codes (NVidia drivers)
+// NOTE: Here there are the details with a sample output:
+// - #131169 - Framebuffer detailed info: The driver allocated storage for renderbuffer 2. (severity: low)
+// - #131185 - Buffer detailed info: Buffer object 1 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_ENUM_88e4)
+//             will use VIDEO memory as the source for buffer object operations. (severity: low)
+// - #131218 - Program/shader state performance warning: Vertex shader in program 7 is being recompiled based on GL state. (severity: medium)
+// - #131204 - Texture state usage warning: The texture object (0) bound to texture image unit 0 does not have
+//             a defined base level and cannot be used for texture mapping. (severity: low)
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - rlgl functionality
+//----------------------------------------------------------------------------------
+
+// Initialize rlgl: OpenGL extensions, default buffers/shaders/textures, OpenGL states
+
+// Enable OpenGL debug context if required
+
+// glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, GL_DEBUG_SEVERITY_HIGH, 0, 0, GL_TRUE); // TODO: Filter message
+
+// Debug context options:
+//  - GL_DEBUG_OUTPUT - Faster version but not useful for breakpoints
+//  - GL_DEBUG_OUTPUT_SYNCHRONUS - Callback is in sync with errors, so a breakpoint can be placed on the callback in order to get a stacktrace for the GL error
+
+// Init default white texture
+// 1 pixel RGBA (4 bytes)
+
+// Init default Shader (customized for GL 3.3 and ES2)
+// Loaded: RLGL.State.defaultShaderId + RLGL.State.defaultShaderLocs
+
+// Init default vertex arrays buffers
+
+// Init stack matrices (emulating OpenGL 1.1)
+
+// Init internal matrices
+
+// GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+
+// Initialize OpenGL default states
+//----------------------------------------------------------
+// Init state: Depth test
+// Type of depth testing to apply
+// Disable depth testing for 2D (only used for 3D)
+
+// Init state: Blending mode
+// Color blending function (how colors are mixed)
+// Enable color blending (required to work with transparencies)
+
+// Init state: Culling
+// NOTE: All shapes/models triangles are drawn CCW
+// Cull the back face (default)
+// Front face are defined counter clockwise (default)
+// Enable backface culling
+
+// Init state: Cubemap seamless
+
+// Seamless cubemaps (not supported on OpenGL ES 2.0)
+
+// Init state: Color hints (deprecated in OpenGL 3.0+)
+// Improve quality of color and texture coordinate interpolation
+// Smooth shading between vertex (vertex colors interpolation)
+
+// Store screen size into global variables
+
+//----------------------------------------------------------
+
+// Init state: Color/Depth buffers clear
+// Set clear color (black)
+// Set clear depth value (default)
+// Clear color and depth buffers (depth buffer required for 3D)
+
+// Vertex Buffer Object deinitialization (memory free)
+
+// Unload default shader
+
+// Unload default texture
+
+// Load OpenGL extensions
+// NOTE: External loader function must be provided
+
+// Also defined for GRAPHICS_API_OPENGL_21
+// NOTE: glad is generated and contains only required OpenGL 3.3 Core extensions (and lower versions)
+
+// Get number of supported extensions
+
+// Get supported extensions list
+// WARNING: glGetStringi() not available on OpenGL 2.1
+
+// Register supported extensions flags
+// OpenGL 3.3 extensions supported by default (core)
+
+// NOTE: With GLAD, we can check if an extension is supported using the GLAD_GL_xxx booleans
+// Texture compression: DXT
+// Texture compression: ETC2/EAC
+
+// GRAPHICS_API_OPENGL_33
+
+// Get supported extensions list
+
+// Allocate 512 strings pointers (2 KB)
+// One big const string
+
+// NOTE: We have to duplicate string because glGetString() returns a const string
+// Get extensions string size in bytes
+
+// Check required extensions
+
+// Check VAO support
+// NOTE: Only check on OpenGL ES, OpenGL 3.3 has VAO support as core feature
+
+// The extension is supported by our hardware and driver, try to get related functions pointers
+// NOTE: emscripten does not support VAOs natively, it uses emulation and it reduces overall performance...
+
+//glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)loader("glIsVertexArrayOES");     // NOTE: Fails in WebGL, omitted
+
+// Check instanced rendering support
+// Web ANGLE
+
+// Standard EXT
+
+// Check NPOT textures support
+// NOTE: Only check on OpenGL ES, OpenGL 3.3 has NPOT textures full support as core feature
+
+// Check texture float support
+
+// Check depth texture support
+
+// Check texture compression support: DXT
+
+// Check texture compression support: ETC1
+
+// Check texture compression support: ETC2/EAC
+
+// Check texture compression support: PVR
+
+// Check texture compression support: ASTC
+
+// Check anisotropic texture filter support
+
+// Check clamp mirror wrap mode support
+
+// Free extensions pointers
+
+// Duplicated string must be deallocated
+// GRAPHICS_API_OPENGL_ES2
+
+// Check OpenGL information and capabilities
+//------------------------------------------------------------------------------
+// Show current OpenGL and GLSL version
+
+// NOTE: Anisotropy levels capability is an extension
+
+// Show some OpenGL GPU capabilities
+
+// GRAPHICS_API_OPENGL_43
+// RLGL_SHOW_GL_DETAILS_INFO
+
+// Show some basic info about GL supported features
+
+// RLGL_SHOW_GL_DETAILS_INFO
+
+// GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+
+// Get current OpenGL version
+
+// NOTE: Force OpenGL 3.3 on OSX
+
+// Set current framebuffer width
+
+// Set current framebuffer height
+
+// Get default framebuffer width
+
+// Get default framebuffer height
+
+// Get default internal texture (white texture)
+// NOTE: Default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8
+
+// Get default shader id
+
+// Get default shader locs
+
+// Render batch management
+//------------------------------------------------------------------------------------------------
+// Load render batch
+
+// Initialize CPU (RAM) vertex buffers (position, texcoord, color data and indexes)
+//--------------------------------------------------------------------------------------------
+
+// 3 float by vertex, 4 vertex by quad
+// 2 float by texcoord, 4 texcoord by quad
+// 4 float by color, 4 colors by quad
+
+// 6 int by quad (indices)
+
+// 6 int by quad (indices)
+
+// Indices can be initialized right now
+
+//--------------------------------------------------------------------------------------------
+
+// Upload to GPU (VRAM) vertex data and initialize VAOs/VBOs
+//--------------------------------------------------------------------------------------------
+
+// Initialize Quads VAO
+
+// Quads - Vertex buffers binding and attributes enable
+// Vertex position buffer (shader-location = 0)
+
+// Vertex texcoord buffer (shader-location = 1)
+
+// Vertex color buffer (shader-location = 3)
+
+// Fill index buffer
+
+// Unbind the current VAO
+
+//--------------------------------------------------------------------------------------------
+
+// Init draw calls tracking system
+//--------------------------------------------------------------------------------------------
+
+//batch.draws[i].vaoId = 0;
+//batch.draws[i].shaderId = 0;
+
+//batch.draws[i].RLGL.State.projection = rlMatrixIdentity();
+//batch.draws[i].RLGL.State.modelview = rlMatrixIdentity();
+
+// Record buffer count
+// Reset draws counter
+// Reset depth value
+//--------------------------------------------------------------------------------------------
+
+// Unload default internal buffers vertex data from CPU and GPU
+
+// Unbind everything
+
+// Unload all vertex buffers data
+
+// Unbind VAO attribs data
+
+// Delete VBOs from GPU (VRAM)
+
+// Delete VAOs from GPU (VRAM)
+
+// Free vertex arrays memory from CPU (RAM)
+
+// Unload arrays
+
+// Draw render batch
+// NOTE: We require a pointer to reset batch and increase current buffer (multi-buffer)
+
+// Update batch vertex buffers
+//------------------------------------------------------------------------------------------------------------
+// NOTE: If there is not vertex data, buffers doesn't need to be updated (vertexCount > 0)
+// TODO: If no data changed on the CPU arrays --> No need to re-update GPU arrays (change flag required)
+
+// Activate elements VAO
+
+// Vertex positions buffer
+
+//glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].vertices, GL_DYNAMIC_DRAW);  // Update all buffer
+
+// Texture coordinates buffer
+
+//glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].texcoords, GL_DYNAMIC_DRAW); // Update all buffer
+
+// Colors buffer
+
+//glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].colors, GL_DYNAMIC_DRAW);    // Update all buffer
+
+// NOTE: glMapBuffer() causes sync issue.
+// If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job.
+// To avoid waiting (idle), you can call first glBufferData() with NULL pointer before glMapBuffer().
+// If you do that, the previous data in PBO will be discarded and glMapBuffer() returns a new
+// allocated pointer immediately even if GPU is still working with the previous data.
+
+// Another option: map the buffer object into client's memory
+// Probably this code could be moved somewhere else...
+// batch->vertexBuffer[batch->currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
+// if (batch->vertexBuffer[batch->currentBuffer].vertices)
+// {
+// Update vertex data
+// }
+// glUnmapBuffer(GL_ARRAY_BUFFER);
+
+// Unbind the current VAO
+
+//------------------------------------------------------------------------------------------------------------
+
+// Draw batch vertex buffers (considering VR stereo if required)
+//------------------------------------------------------------------------------------------------------------
+
+// Setup current eye viewport (half screen width)
+
+// Set current eye view offset to modelview matrix
+
+// Set current eye projection matrix
+
+// Draw buffers
+
+// Set current shader and upload current MVP matrix
+
+// Create modelview-projection matrix and upload to shader
+
+// Bind vertex attrib: position (shader-location = 0)
+
+// Bind vertex attrib: texcoord (shader-location = 1)
+
+// Bind vertex attrib: color (shader-location = 3)
+
+// Setup some default shader values
+
+// Active default sampler2D: texture0
+
+// Activate additional sampler textures
+// Those additional textures will be common for all draw calls of the batch
+
+// Activate default sampler2D texture0 (one texture is always active for default batch shader)
+// NOTE: Batch system accumulates calls by texture0 changes, additional textures are enabled for all the draw calls
+
+// Bind current draw call texture, activated as GL_TEXTURE0 and binded to sampler2D texture0 by default
+
+// We need to define the number of indices to be processed: elementCount*6
+// NOTE: The final parameter tells the GPU the offset in bytes from the
+// start of the index buffer to the location of the first index to process
+
+// Unbind textures
+
+// Unbind VAO
+
+// Unbind shader program
+
+// Restore viewport to default measures
+
+//------------------------------------------------------------------------------------------------------------
+
+// Reset batch buffers
+//------------------------------------------------------------------------------------------------------------
+// Reset vertex counter for next frame
+
+// Reset depth for next draw
+
+// Restore projection/modelview matrices
+
+// Reset RLGL.currentBatch->draws array
+
+// Reset active texture units for next batch
+
+// Reset draws counter to one draw for the batch
+
+//------------------------------------------------------------------------------------------------------------
+
+// Change to next buffer in the list (in case of multi-buffering)
+
+// Set the active render batch for rlgl
+
+// Update and draw internal render batch
+
+// NOTE: Stereo rendering is checked inside
+
+// Check internal buffer overflow for a given number of vertex
+// and force a rlRenderBatch draw call if required
+
+// NOTE: Stereo rendering is checked inside
+
+// Restore state of last batch so we can continue adding vertices
+
+// Textures data management
+//-----------------------------------------------------------------------------------------
+// Convert image data to OpenGL texture (returns OpenGL valid Id)
+
+// Free any old binding
+
+// Check texture format support by OpenGL 1.1 (compressed textures not supported)
+
+// GRAPHICS_API_OPENGL_11
+
+// Generate texture id
+
+// Mipmap data offset
+
+// Load the different mipmap levels
+
+// Security check for NPOT textures
+
+// Texture parameters configuration
+// NOTE: glTexParameteri does NOT affect texture uploading, just the way it's used
+
+// NOTE: OpenGL ES 2.0 with no GL_OES_texture_npot support (i.e. WebGL) has limited NPOT support, so CLAMP_TO_EDGE must be used
+
+// Set texture to repeat on x-axis
+// Set texture to repeat on y-axis
+
+// NOTE: If using negative texture coordinates (LoadOBJ()), it does not work!
+// Set texture to clamp on x-axis
+// Set texture to clamp on y-axis
+
+// Set texture to repeat on x-axis
+// Set texture to repeat on y-axis
+
+// Magnification and minification filters
+// Alternative: GL_LINEAR
+// Alternative: GL_LINEAR
+
+// Activate Trilinear filtering if mipmaps are available
+
+// At this point we have the texture loaded in GPU and texture parameters configured
+
+// NOTE: If mipmaps were not in data, they are not generated automatically
+
+// Unbind current texture
+
+// Load depth texture/renderbuffer (to be attached to fbo)
+// WARNING: OpenGL ES 2.0 requires GL_OES_depth_texture/WEBGL_depth_texture extensions
+
+// In case depth textures not supported, we force renderbuffer usage
+
+// NOTE: We let the implementation to choose the best bit-depth
+// Possible formats: GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32 and GL_DEPTH_COMPONENT32F
+
+// Create the renderbuffer that will serve as the depth attachment for the framebuffer
+// NOTE: A renderbuffer is simpler than a texture and could offer better performance on embedded devices
+
+// Load texture cubemap
+// NOTE: Cubemap data is expected to be 6 images in a single data array (one after the other),
+// expected the following convention: +X, -X, +Y, -Y, +Z, -Z
+
+// Load cubemap faces
+
+// Instead of using a sized internal texture format (GL_RGB16F, GL_RGB32F), we let the driver to choose the better format for us (GL_RGB)
+
+// Set cubemap texture sampling parameters
+
+// Flag not supported on OpenGL ES 2.0
+
+// Update already loaded texture in GPU with new data
+// NOTE: We don't know safely if internal texture format is the expected one...
+
+// Get OpenGL internal formats and data type from raylib PixelFormat
+
+// NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA
+
+// NOTE: Requires extension OES_texture_float
+// NOTE: Requires extension OES_texture_float
+// NOTE: Requires extension OES_texture_float
+
+// NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3
+// NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
+// NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
+// NOTE: Requires PowerVR GPU
+// NOTE: Requires PowerVR GPU
+// NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
+// NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
+
+// Unload texture from GPU memory
+
+// Generate mipmap data for selected texture
+
+// Check if texture is power-of-two (POT)
+
+// WARNING: Manual mipmap generation only works for RGBA 32bit textures!
+
+// Retrieve texture data from VRAM
+
+// NOTE: Texture data size is reallocated to fit mipmaps data
+// NOTE: CPU mipmap generation only supports RGBA 32bit data
+
+// Load the mipmaps
+
+// Once mipmaps have been generated and data has been uploaded to GPU VRAM, we can discard RAM data
+
+//glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE);   // Hint for mipmaps generation algorithm: GL_FASTEST, GL_NICEST, GL_DONT_CARE
+// Generate mipmaps automatically
+
+// Read texture pixel data
+
+// NOTE: Using texture id, we can retrieve some texture info (but not on OpenGL ES 2.0)
+// Possible texture info: GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE
+//int width, height, format;
+//glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
+//glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height);
+//glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format);
+
+// NOTE: Each row written to or read from by OpenGL pixel operations like glGetTexImage are aligned to a 4 byte boundary by default, which may add some padding.
+// Use glPixelStorei to modify padding with the GL_[UN]PACK_ALIGNMENT setting.
+// GL_PACK_ALIGNMENT affects operations that read from OpenGL memory (glReadPixels, glGetTexImage, etc.)
+// GL_UNPACK_ALIGNMENT affects operations that write to OpenGL memory (glTexImage, etc.)
+
+// glGetTexImage() is not available on OpenGL ES 2.0
+// Texture width and height are required on OpenGL ES 2.0. There is no way to get it from texture id.
+// Two possible Options:
+// 1 - Bind texture to color fbo attachment and glReadPixels()
+// 2 - Create an fbo, activate it, render quad with texture, glReadPixels()
+// We are using Option 1, just need to care for texture format on retrieval
+// NOTE: This behaviour could be conditioned by graphic driver...
+
+// Attach our texture to FBO
+
+// We read data as RGBA because FBO texture is configured as RGBA, despite binding another texture format
+
+// Clean up temporal fbo
+
+// Read screen pixel data (color buffer)
+
+// NOTE 1: glReadPixels returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer
+// NOTE 2: We are getting alpha channel! Be careful, it can be transparent if not cleared properly!
+
+// Flip image vertically!
+
+// Flip line
+
+// Set alpha component value to 255 (no trasparent image retrieval)
+// NOTE: Alpha value has already been applied to RGB in framebuffer, we don't need it!
+
+// NOTE: image data should be freed
+
+// Framebuffer management (fbo)
+//-----------------------------------------------------------------------------------------
+// Load a framebuffer to be used for rendering
+// NOTE: No textures attached
+
+// Create the framebuffer object
+// Unbind any framebuffer
+
+// Attach color buffer texture to an fbo (unloads previous attachment)
+// NOTE: Attach type: 0-Color, 1-Depth renderbuffer, 2-Depth texture
+
+// Verify render texture is complete
+
+// Unload framebuffer from GPU memory
+// NOTE: All attached textures/cubemaps/renderbuffers are also deleted
+
+// Query depth attachment to automatically delete texture/renderbuffer
+
+// Bind framebuffer to query depth texture type
+
+// NOTE: If a texture object is deleted while its image is attached to the *currently bound* framebuffer,
+// the texture image is automatically detached from the currently bound framebuffer.
+
+// Vertex data management
+//-----------------------------------------------------------------------------------------
+// Load a new attributes buffer
+
+// Load a new attributes element buffer
+
+// Enable vertex buffer (VBO)
+
+// Disable vertex buffer (VBO)
+
+// Enable vertex buffer element (VBO element)
+
+// Disable vertex buffer element (VBO element)
+
+// Update vertex buffer with new data
+// NOTE: dataSize and offset must be provided in bytes
+
+// Update vertex buffer elements with new data
+// NOTE: dataSize and offset must be provided in bytes
+
+// Enable vertex array object (VAO)
+
+// Disable vertex array object (VAO)
+
+// Enable vertex attribute index
+
+// Disable vertex attribute index
+
+// Draw vertex array
+
+// Draw vertex array elements
+
+// Draw vertex array instanced
+
+// Draw vertex array elements instanced
+
+// Enable vertex state pointer
+
+//case GL_INDEX_ARRAY: if (buffer != NULL) glIndexPointer(GL_SHORT, 0, buffer); break; // Indexed colors
+
+// Disable vertex state pointer
+
+// Load vertex array object (VAO)
+
+// Set vertex attribute
+
+// Set vertex attribute divisor
+
+// Unload vertex array object (VAO)
+
+// Unload vertex buffer (VBO)
+
+//TRACELOG(RL_LOG_INFO, "VBO: Unloaded vertex data from VRAM (GPU)");
+
+// Shaders management
+//-----------------------------------------------------------------------------------------------
+// Load shader from code strings
+// NOTE: If shader string is NULL, using default vertex/fragment shaders
+
+// Compile vertex shader (if provided)
+
+// In case no vertex shader was provided or compilation failed, we use default vertex shader
+
+// Compile fragment shader (if provided)
+
+// In case no fragment shader was provided or compilation failed, we use default fragment shader
+
+// In case vertex and fragment shader are the default ones, no need to recompile, we can just assign the default shader program id
+
+// One of or both shader are new, we need to compile a new shader program
+
+// We can detach and delete vertex/fragment shaders (if not default ones)
+// NOTE: We detach shader before deletion to make sure memory is freed
+
+// In case shader program loading failed, we assign default shader
+
+// In case shader loading fails, we return the default shader
+
+/*
+else
+{
+    // Get available shader uniforms
+    // NOTE: This information is useful for debug...
+    int uniformCount = -1;
+    glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &uniformCount);
+
+    for (int i = 0; i < uniformCount; i++)
+    {
+        int namelen = -1;
+        int num = -1;
+        char name[256] = { 0 };     // Assume no variable names longer than 256
+        GLenum type = GL_ZERO;
+
+        // Get the name of the uniforms
+        glGetActiveUniform(id, i, sizeof(name) - 1, &namelen, &num, &type, name);
+
+        name[namelen] = 0;
+        TRACELOGD("SHADER: [ID %i] Active uniform (%s) set at location: %i", id, name, glGetUniformLocation(id, name));
+    }
+}
+*/
+
+// Compile custom shader and return shader id
+
+//case GL_GEOMETRY_SHADER:
+
+//case GL_GEOMETRY_SHADER:
+
+// Load custom shader strings and return program id
+
+// NOTE: Default attribute shader locations must be binded before linking
+
+// NOTE: If some attrib name is no found on the shader, it locations becomes -1
+
+// NOTE: All uniform variables are intitialised to 0 when a program links
+
+// Get the size of compiled shader program (not available on OpenGL ES 2.0)
+// NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero.
+//GLint binarySize = 0;
+//glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize);
+
+// Unload shader program
+
+// Get shader location uniform
+
+// Get shader location attribute
+
+// Set shader value uniform
+
+// Set shader value attribute
+
+// Set shader value uniform matrix
+
+// Set shader value uniform sampler
+
+// Check if texture is already active
+
+// Register a new active texture for the internal batch system
+// NOTE: Default texture is always activated as GL_TEXTURE0
+
+// Activate new texture unit
+// Save texture id for binding on drawing
+
+// Set shader currently active (id and locations)
+
+// Load compute shader program
+
+// NOTE: All uniform variables are intitialised to 0 when a program links
+
+// Get the size of compiled shader program (not available on OpenGL ES 2.0)
+// NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero.
+//GLint binarySize = 0;
+//glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize);
+
+// Dispatch compute shader (equivalent to *draw* for graphics pilepine)
+
+// Load shader storage buffer object (SSBO)
+
+// Unload shader storage buffer object (SSBO)
+
+// Update SSBO buffer data
+
+// Get SSBO buffer size
+
+// Read SSBO buffer data
+
+// Bind SSBO buffer
+
+// Copy SSBO buffer data
+
+// Bind image texture
+
+// Matrix state management
+//-----------------------------------------------------------------------------------------
+// Get internal modelview matrix
+
+// Get internal projection matrix
+
+// Get internal accumulated transform matrix
+
+// TODO: Consider possible transform matrices in the RLGL.State.stack
+// Is this the right order? or should we start with the first stored matrix instead of the last one?
+//Matrix matStackTransform = rlMatrixIdentity();
+//for (int i = RLGL.State.stackCounter; i > 0; i--) matStackTransform = rlMatrixMultiply(RLGL.State.stack[i], matStackTransform);
+
+// Get internal projection matrix for stereo render (selected eye)
+
+// Get internal view offset matrix for stereo render (selected eye)
+
+// Set a custom modelview matrix (replaces internal modelview matrix)
+
+// Set a custom projection matrix (replaces internal projection matrix)
+
+// Set eyes projection matrices for stereo rendering
+
+// Set eyes view offsets matrices for stereo rendering
+
+// Load and draw a quad in NDC
+
+// Positions         Texcoords
+
+// Gen VAO to contain VBO
+
+// Gen and fill vertex buffer (VBO)
+
+// Bind vertex attributes (position, texcoords)
+
+// Positions
+
+// Texcoords
+
+// Draw quad
+
+// Delete buffers (VBO and VAO)
+
+// Load and draw a cube in NDC
+
+// Positions          Normals               Texcoords
+
+// Gen VAO to contain VBO
+
+// Gen and fill vertex buffer (VBO)
+
+// Bind vertex attributes (position, normals, texcoords)
+
+// Positions
+
+// Normals
+
+// Texcoords
+
+// Draw cube
+
+// Delete VBO and VAO
+
+// Get name string for pixel format
+
+// 8 bit per pixel (no alpha)
+// 8*2 bpp (2 channels)
+// 16 bpp
+// 24 bpp
+// 16 bpp (1 bit alpha)
+// 16 bpp (4 bit alpha)
+// 32 bpp
+// 32 bpp (1 channel - float)
+// 32*3 bpp (3 channels - float)
+// 32*4 bpp (4 channels - float)
+// 4 bpp (no alpha)
+// 4 bpp (1 bit alpha)
+// 8 bpp
+// 8 bpp
+// 4 bpp
+// 4 bpp
+// 8 bpp
+// 4 bpp
+// 4 bpp
+// 8 bpp
+// 2 bpp
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Definition
+//----------------------------------------------------------------------------------
+
+// Load default shader (just vertex positioning and texture coloring)
+// NOTE: This shader program is used for internal buffers
+// NOTE: Loaded: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs
+
+// NOTE: All locations must be reseted to -1 (no location)
+
+// Vertex shader directly defined, no external file required
+
+// Fragment shader directly defined, no external file required
+
+// Precision required for OpenGL ES2 (WebGL)
+
+// NOTE: Compiled vertex/fragment shaders are not deleted,
+// they are kept for re-use as default shaders in case some shader loading fails
+// Compile default vertex shader
+// Compile default fragment shader
+
+// Set default shader locations: attributes locations
+
+// Set default shader locations: uniform locations
+
+// Unload default shader
+// NOTE: Unloads: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs
+
+// Get compressed format official GL identifier name
+
+// GL_EXT_texture_compression_s3tc
+
+// GL_3DFX_texture_compression_FXT1
+
+// GL_IMG_texture_compression_pvrtc
+
+// GL_OES_compressed_ETC1_RGB8_texture
+
+// GL_ARB_texture_compression_rgtc
+
+// GL_ARB_texture_compression_bptc
+
+// GL_ARB_ES3_compatibility
+
+// GL_KHR_texture_compression_astc_hdr
+
+// RLGL_SHOW_GL_DETAILS_INFO
+
+// GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
+
+// Mipmaps data is generated after image data
+// NOTE: Only works with RGBA (4 bytes) data!
+
+// Required mipmap levels count (including base level)
+
+// Size in bytes (will include mipmaps...), RGBA only
+
+// Count mipmap levels required
+
+// Add mipmap size (in bytes)
+
+// RGBA: 4 bytes
+
+// Generate mipmaps
+// NOTE: Every mipmap data is stored after data (RGBA - 4 bytes)
+
+// Size of last mipmap
+
+// Mipmap size to store after offset
+
+// Add mipmap to data
+
+// free mipmap data
+
+// Manual mipmap generation (basic scaling algorithm)
+
+// Scaling algorithm works perfectly (box-filter)
+
+// GRAPHICS_API_OPENGL_11
+
+// Get pixel data size in bytes (image or texture)
+// NOTE: Size depends on pixel format
+
+// Size in bytes
+// Bits per pixel
+
+// Total data size in bytes
+
+// Most compressed formats works on 4x4 blocks,
+// if texture is smaller, minimum dataSize is 8 or 16
+
+// Auxiliar math functions
+
+// Get identity matrix
+
+// Get two matrix multiplication
+// NOTE: When multiplying matrices... the order matters!
+
+// RLGL_IMPLEMENTATION

source/raylib_types.d

@@ -1,99 +1,4 @@
-/// This module defines basic types from Raylib with local modifications to make them easier to use.
+deprecated("module raylib_types is deprecated, import raylib.raylib_types instead")
 module raylib_types;
 
-import raylib;
-
-// Vector2 type
-struct Vector2
-{
-    float x = 0.0f;
-    float y = 0.0f;
-    mixin Linear;
-}
-
-// Vector3 type
-struct Vector3
-{
-    float x = 0.0f;
-    float y = 0.0f;
-    float z = 0.0f;
-    mixin Linear;
-}
-
-// Vector4 type
-struct Vector4
-{
-    float x = 0.0f;
-    float y = 0.0f;
-    float z = 0.0f;
-    float w = 0.0f;
-    mixin Linear;
-}
-
-// Quaternion type, same as Vector4
-alias Quaternion = Vector4;
-
-// Matrix type (OpenGL style 4x4 - right handed, column major)
-struct Matrix
-{
-    float m0 = 0.0f;
-    float m4 = 0.0f;
-    float m8 = 0.0f;
-    float m12 = 0.0f;
-    float m1 = 0.0f;
-    float m5 = 0.0f;
-    float m9 = 0.0f;
-    float m13 = 0.0f;
-    float m2 = 0.0f;
-    float m6 = 0.0f;
-    float m10 = 0.0f;
-    float m14 = 0.0f;
-    float m3 = 0.0f;
-    float m7 = 0.0f;
-    float m11 = 0.0f;
-    float m15 = 0.0f;
-}
-
-// Rectangle type
-struct Rectangle
-{
-    float x;
-    float y;
-    float width;
-    float height;
-    alias w = width;
-    alias h = height;
-}
-
-enum Colors
-{
-    // Some Basic Colors
-    // NOTE: Custom raylib color palette for amazing visuals on WHITE background
-    LIGHTGRAY = Color(200, 200, 200, 255), // Light Gray
-    GRAY = Color(130, 130, 130, 255), // Gray
-    DARKGRAY = Color(80, 80, 80, 255), // Dark Gray
-    YELLOW = Color(253, 249, 0, 255), // Yellow
-    GOLD = Color(255, 203, 0, 255), // Gold
-    ORANGE = Color(255, 161, 0, 255), // Orange
-    PINK = Color(255, 109, 194, 255), // Pink
-    RED = Color(230, 41, 55, 255), // Red
-    MAROON = Color(190, 33, 55, 255), // Maroon
-    GREEN = Color(0, 228, 48, 255), // Green
-    LIME = Color(0, 158, 47, 255), // Lime
-    DARKGREEN = Color(0, 117, 44, 255), // Dark Green
-    SKYBLUE = Color(102, 191, 255, 255), // Sky Blue
-    BLUE = Color(0, 121, 241, 255), // Blue
-    DARKBLUE = Color(0, 82, 172, 255), // Dark Blue
-    PURPLE = Color(200, 122, 255, 255), // Purple
-    VIOLET = Color(135, 60, 190, 255), // Violet
-    DARKPURPLE = Color(112, 31, 126, 255), // Dark Purple
-    BEIGE = Color(211, 176, 131, 255), // Beige
-    BROWN = Color(127, 106, 79, 255), // Brown
-    DARKBROWN = Color(76, 63, 47, 255), // Dark Brown
-
-    WHITE = Color(255, 255, 255, 255), // White
-    BLACK = Color(0, 0, 0, 255), // Black
-    BLANK = Color(0, 0, 0, 0), // Blank (Transparent)
-    MAGENTA = Color(255, 0, 255, 255), // Magenta
-    RAYWHITE = Color(245, 245, 245, 255), // My own White (raylib logo)
-}
+public import raylib.raylib_types;

source/raymath.d

@@ -1,559 +1,4 @@
+deprecated("module raymath is deprecated, import raylib.raymath instead")
 module raymath;
 
-import raylib;
-/**********************************************************************************************
-*
-*   raymath v1.5 - Math functions to work with Vector2, Vector3, Matrix and Quaternions
-*
-*   CONFIGURATION:
-*
-*   #define RAYMATH_IMPLEMENTATION
-*       Generates the implementation of the library into the included file.
-*       If not defined, the library is in header only mode and can be included in other headers
-*       or source files without problems. But only ONE file should hold the implementation.
-*
-*   #define RAYMATH_STATIC_INLINE
-*       Define static inline functions code, so #include header suffices for use.
-*       This may use up lots of memory.
-*
-*   CONVENTIONS:
-*
-*     - Functions are always self-contained, no function use another raymath function inside,
-*       required code is directly re-implemented inside
-*     - Functions input parameters are always received by value (2 unavoidable exceptions)
-*     - Functions use always a "result" anmed variable for return
-*     - Functions are always defined inline
-*     - Angles are always in radians (DEG2RAD/RAD2DEG macros provided for convenience)
-*
-*
-*   LICENSE: zlib/libpng
-*
-*   Copyright (c) 2015-2021 Ramon Santamaria (@raysan5)
-*
-*   This software is provided "as-is", without any express or implied warranty. In no event
-*   will the authors be held liable for any damages arising from the use of this software.
-*
-*   Permission is granted to anyone to use this software for any purpose, including commercial
-*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
-*
-*     1. The origin of this software must not be misrepresented; you must not claim that you
-*     wrote the original software. If you use this software in a product, an acknowledgment
-*     in the product documentation would be appreciated but is not required.
-*
-*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
-*     as being the original software.
-*
-*     3. This notice may not be removed or altered from any source distribution.
-*
-**********************************************************************************************/
-
-extern (C) @nogc nothrow:
-
-// Function specifiers definition
-
-// We are building raylib as a Win32 shared library (.dll).
-
-// We are using raylib as a Win32 shared library (.dll)
-
-// Provide external definition
-
-// Functions may be inlined, no external out-of-line definition
-
-// plain inline not supported by tinycc (See issue #435) // Functions may be inlined or external definition used
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-
-enum PI = 3.14159265358979323846f;
-
-enum DEG2RAD = PI / 180.0f;
-
-enum RAD2DEG = 180.0f / PI;
-
-// Get float vector for Matrix
-
-extern (D) auto MatrixToFloat(T)(auto ref T mat)
-{
-    return MatrixToFloatV(mat).v;
-}
-
-// Get float vector for Vector3
-
-extern (D) auto Vector3ToFloat(T)(auto ref T vec)
-{
-    return Vector3ToFloatV(vec).v;
-}
-
-//----------------------------------------------------------------------------------
-// Types and Structures Definition
-//----------------------------------------------------------------------------------
-
-// Vector2 type
-
-// Vector3 type
-
-// Vector4 type
-
-// Quaternion type
-
-// Matrix type (OpenGL style 4x4 - right handed, column major)
-
-// Matrix first row (4 components)
-// Matrix second row (4 components)
-// Matrix third row (4 components)
-// Matrix fourth row (4 components)
-
-// NOTE: Helper types to be used instead of array return types for *ToFloat functions
-struct float3
-{
-    float[3] v;
-}
-
-struct float16
-{
-    float[16] v;
-}
-
-// Required for: sinf(), cosf(), tan(), atan2f(), sqrtf(), fminf(), fmaxf(), fabs()
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition - Utils math
-//----------------------------------------------------------------------------------
-
-// Clamp float value
-float Clamp(float value, float min, float max);
-
-// Calculate linear interpolation between two floats
-float Lerp(float start, float end, float amount);
-
-// Normalize input value within input range
-float Normalize(float value, float start, float end);
-
-// Remap input value within input range to output range
-float Remap(
-    float value,
-    float inputStart,
-    float inputEnd,
-    float outputStart,
-    float outputEnd);
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition - Vector2 math
-//----------------------------------------------------------------------------------
-
-// Vector with components value 0.0f
-Vector2 Vector2Zero();
-
-// Vector with components value 1.0f
-Vector2 Vector2One();
-
-// Add two vectors (v1 + v2)
-Vector2 Vector2Add(Vector2 v1, Vector2 v2);
-
-// Add vector and float value
-Vector2 Vector2AddValue(Vector2 v, float add);
-
-// Subtract two vectors (v1 - v2)
-Vector2 Vector2Subtract(Vector2 v1, Vector2 v2);
-
-// Subtract vector by float value
-Vector2 Vector2SubtractValue(Vector2 v, float sub);
-
-// Calculate vector length
-float Vector2Length(Vector2 v);
-
-// Calculate vector square length
-float Vector2LengthSqr(Vector2 v);
-
-// Calculate two vectors dot product
-float Vector2DotProduct(Vector2 v1, Vector2 v2);
-
-// Calculate distance between two vectors
-float Vector2Distance(Vector2 v1, Vector2 v2);
-
-// Calculate angle from two vectors in X-axis
-float Vector2Angle(Vector2 v1, Vector2 v2);
-
-// Scale vector (multiply by value)
-Vector2 Vector2Scale(Vector2 v, float scale);
-
-// Multiply vector by vector
-Vector2 Vector2Multiply(Vector2 v1, Vector2 v2);
-
-// Negate vector
-Vector2 Vector2Negate(Vector2 v);
-
-// Divide vector by vector
-Vector2 Vector2Divide(Vector2 v1, Vector2 v2);
-
-// Normalize provided vector
-Vector2 Vector2Normalize(Vector2 v);
-
-// Calculate linear interpolation between two vectors
-Vector2 Vector2Lerp(Vector2 v1, Vector2 v2, float amount);
-
-// Calculate reflected vector to normal
-
-// Dot product
-Vector2 Vector2Reflect(Vector2 v, Vector2 normal);
-
-// Rotate vector by angle
-Vector2 Vector2Rotate(Vector2 v, float angle);
-
-// Move Vector towards target
-Vector2 Vector2MoveTowards(Vector2 v, Vector2 target, float maxDistance);
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition - Vector3 math
-//----------------------------------------------------------------------------------
-
-// Vector with components value 0.0f
-Vector3 Vector3Zero();
-
-// Vector with components value 1.0f
-Vector3 Vector3One();
-
-// Add two vectors
-Vector3 Vector3Add(Vector3 v1, Vector3 v2);
-
-// Add vector and float value
-Vector3 Vector3AddValue(Vector3 v, float add);
-
-// Subtract two vectors
-Vector3 Vector3Subtract(Vector3 v1, Vector3 v2);
-
-// Subtract vector by float value
-Vector3 Vector3SubtractValue(Vector3 v, float sub);
-
-// Multiply vector by scalar
-Vector3 Vector3Scale(Vector3 v, float scalar);
-
-// Multiply vector by vector
-Vector3 Vector3Multiply(Vector3 v1, Vector3 v2);
-
-// Calculate two vectors cross product
-Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2);
-
-// Calculate one vector perpendicular vector
-
-// Cross product between vectors
-Vector3 Vector3Perpendicular(Vector3 v);
-
-// Calculate vector length
-float Vector3Length(const Vector3 v);
-
-// Calculate vector square length
-float Vector3LengthSqr(const Vector3 v);
-
-// Calculate two vectors dot product
-float Vector3DotProduct(Vector3 v1, Vector3 v2);
-
-// Calculate distance between two vectors
-float Vector3Distance(Vector3 v1, Vector3 v2);
-
-// Calculate angle between two vectors in XY and XZ
-
-// Angle in XZ
-// Angle in XY
-Vector2 Vector3Angle(Vector3 v1, Vector3 v2);
-
-// Negate provided vector (invert direction)
-Vector3 Vector3Negate(Vector3 v);
-
-// Divide vector by vector
-Vector3 Vector3Divide(Vector3 v1, Vector3 v2);
-
-// Normalize provided vector
-Vector3 Vector3Normalize(Vector3 v);
-
-// Orthonormalize provided vectors
-// Makes vectors normalized and orthogonal to each other
-// Gram-Schmidt function implementation
-
-// Vector3Normalize(*v1);
-
-// Vector3CrossProduct(*v1, *v2)
-
-// Vector3Normalize(vn1);
-
-// Vector3CrossProduct(vn1, *v1)
-void Vector3OrthoNormalize(Vector3* v1, Vector3* v2);
-
-// Transforms a Vector3 by a given Matrix
-Vector3 Vector3Transform(Vector3 v, Matrix mat);
-
-// Transform a vector by quaternion rotation
-Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q);
-
-// Calculate linear interpolation between two vectors
-Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount);
-
-// Calculate reflected vector to normal
-
-// I is the original vector
-// N is the normal of the incident plane
-// R = I - (2*N*(DotProduct[I, N]))
-Vector3 Vector3Reflect(Vector3 v, Vector3 normal);
-
-// Get min value for each pair of components
-Vector3 Vector3Min(Vector3 v1, Vector3 v2);
-
-// Get max value for each pair of components
-Vector3 Vector3Max(Vector3 v1, Vector3 v2);
-
-// Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c)
-// NOTE: Assumes P is on the plane of the triangle
-
-// Vector3Subtract(b, a)
-// Vector3Subtract(c, a)
-// Vector3Subtract(p, a)
-// Vector3DotProduct(v0, v0)
-// Vector3DotProduct(v0, v1)
-// Vector3DotProduct(v1, v1)
-// Vector3DotProduct(v2, v0)
-// Vector3DotProduct(v2, v1)
-Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c);
-
-// Projects a Vector3 from screen space into object space
-// NOTE: We are avoiding calling other raymath functions despite available
-
-// Calculate unproject matrix (multiply view patrix by projection matrix) and invert it
-// MatrixMultiply(view, projection);
-
-// Calculate inverted matrix -> MatrixInvert(matViewProj);
-// Cache the matrix values (speed optimization)
-
-// Calculate the invert determinant (inlined to avoid double-caching)
-
-// Create quaternion from source point
-
-// Multiply quat point by unproject matrix
-// QuaternionTransform(quat, matViewProjInv)
-
-// Normalized world points in vectors
-Vector3 Vector3Unproject(Vector3 source, Matrix projection, Matrix view);
-
-// Get Vector3 as float array
-float3 Vector3ToFloatV(Vector3 v);
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition - Matrix math
-//----------------------------------------------------------------------------------
-
-// Compute matrix determinant
-
-// Cache the matrix values (speed optimization)
-float MatrixDeterminant(Matrix mat);
-
-// Get the trace of the matrix (sum of the values along the diagonal)
-float MatrixTrace(Matrix mat);
-
-// Transposes provided matrix
-Matrix MatrixTranspose(Matrix mat);
-
-// Invert provided matrix
-
-// Cache the matrix values (speed optimization)
-
-// Calculate the invert determinant (inlined to avoid double-caching)
-Matrix MatrixInvert(Matrix mat);
-
-// Normalize provided matrix
-
-// Cache the matrix values (speed optimization)
-
-// MatrixDeterminant(mat)
-Matrix MatrixNormalize(Matrix mat);
-
-// Get identity matrix
-Matrix MatrixIdentity();
-
-// Add two matrices
-Matrix MatrixAdd(Matrix left, Matrix right);
-
-// Subtract two matrices (left - right)
-Matrix MatrixSubtract(Matrix left, Matrix right);
-
-// Get two matrix multiplication
-// NOTE: When multiplying matrices... the order matters!
-Matrix MatrixMultiply(Matrix left, Matrix right);
-
-// Get translation matrix
-Matrix MatrixTranslate(float x, float y, float z);
-
-// Create rotation matrix from axis and angle
-// NOTE: Angle should be provided in radians
-Matrix MatrixRotate(Vector3 axis, float angle);
-
-// Get x-rotation matrix (angle in radians)
-
-// MatrixIdentity()
-Matrix MatrixRotateX(float angle);
-
-// Get y-rotation matrix (angle in radians)
-
-// MatrixIdentity()
-Matrix MatrixRotateY(float angle);
-
-// Get z-rotation matrix (angle in radians)
-
-// MatrixIdentity()
-Matrix MatrixRotateZ(float angle);
-
-// Get xyz-rotation matrix (angles in radians)
-
-// MatrixIdentity()
-Matrix MatrixRotateXYZ(Vector3 ang);
-
-// Get zyx-rotation matrix (angles in radians)
-Matrix MatrixRotateZYX(Vector3 ang);
-
-// Get scaling matrix
-Matrix MatrixScale(float x, float y, float z);
-
-// Get perspective projection matrix
-Matrix MatrixFrustum(
-    double left,
-    double right,
-    double bottom,
-    double top,
-    double near,
-    double far);
-
-// Get perspective projection matrix
-// NOTE: Angle should be provided in radians
-
-// MatrixFrustum(-right, right, -top, top, near, far);
-Matrix MatrixPerspective(double fovy, double aspect, double near, double far);
-
-// Get orthographic projection matrix
-Matrix MatrixOrtho(
-    double left,
-    double right,
-    double bottom,
-    double top,
-    double near,
-    double far);
-
-// Get camera look-at matrix (view matrix)
-
-// Vector3Subtract(eye, target)
-
-// Vector3Normalize(vz)
-
-// Vector3CrossProduct(up, vz)
-
-// Vector3Normalize(x)
-
-// Vector3CrossProduct(vz, vx)
-
-// Vector3DotProduct(vx, eye)
-// Vector3DotProduct(vy, eye)
-// Vector3DotProduct(vz, eye)
-Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up);
-
-// Get float array of matrix data
-float16 MatrixToFloatV(Matrix mat);
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition - Quaternion math
-//----------------------------------------------------------------------------------
-
-// Add two quaternions
-Quaternion QuaternionAdd(Quaternion q1, Quaternion q2);
-
-// Add quaternion and float value
-Quaternion QuaternionAddValue(Quaternion q, float add);
-
-// Subtract two quaternions
-Quaternion QuaternionSubtract(Quaternion q1, Quaternion q2);
-
-// Subtract quaternion and float value
-Quaternion QuaternionSubtractValue(Quaternion q, float sub);
-
-// Get identity quaternion
-Quaternion QuaternionIdentity();
-
-// Computes the length of a quaternion
-float QuaternionLength(Quaternion q);
-
-// Normalize provided quaternion
-Quaternion QuaternionNormalize(Quaternion q);
-
-// Invert provided quaternion
-Quaternion QuaternionInvert(Quaternion q);
-
-// Calculate two quaternion multiplication
-Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2);
-
-// Scale quaternion by float value
-Quaternion QuaternionScale(Quaternion q, float mul);
-
-// Divide two quaternions
-Quaternion QuaternionDivide(Quaternion q1, Quaternion q2);
-
-// Calculate linear interpolation between two quaternions
-Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount);
-
-// Calculate slerp-optimized interpolation between two quaternions
-
-// QuaternionLerp(q1, q2, amount)
-
-// QuaternionNormalize(q);
-Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount);
-
-// Calculates spherical linear interpolation between two quaternions
-Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount);
-
-// Calculate quaternion based on the rotation from one vector to another
-
-// Vector3DotProduct(from, to)
-// Vector3CrossProduct(from, to)
-
-// QuaternionNormalize(q);
-// NOTE: Normalize to essentially nlerp the original and identity to 0.5
-Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to);
-
-// Get a quaternion for a given rotation matrix
-Quaternion QuaternionFromMatrix(Matrix mat);
-
-// Get a matrix for a given quaternion
-
-// MatrixIdentity()
-Matrix QuaternionToMatrix(Quaternion q);
-
-// Get rotation quaternion for an angle and axis
-// NOTE: angle must be provided in radians
-
-// Vector3Normalize(axis)
-
-// QuaternionNormalize(q);
-Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle);
-
-// Get the rotation angle and axis for a given quaternion
-
-// QuaternionNormalize(q);
-
-// This occurs when the angle is zero.
-// Not a problem: just set an arbitrary normalized axis.
-void QuaternionToAxisAngle(Quaternion q, Vector3* outAxis, float* outAngle);
-
-// Get the quaternion equivalent to Euler angles
-// NOTE: Rotation order is ZYX
-Quaternion QuaternionFromEuler(float pitch, float yaw, float roll);
-
-// Get the Euler angles equivalent to quaternion (roll, pitch, yaw)
-// NOTE: Angles are returned in a Vector3 struct in radians
-
-// Roll (x-axis rotation)
-
-// Pitch (y-axis rotation)
-
-// Yaw (z-axis rotation)
-Vector3 QuaternionToEuler(Quaternion q);
-
-// Transform a quaternion given a transformation matrix
-Quaternion QuaternionTransform(Quaternion q, Matrix mat);
-
-// RAYMATH_H
+public import raylib.raymath;

source/raymathext.d

@@ -1,325 +1,4 @@
+deprecated("module raymathext is deprecated, import raylib.raymathext instead")
 module raymathext;
 
-import raylib;
-import std.math;
-
-pragma(inline, true):
-
-// Bivector2 type
-struct Bivector2
-{
-    float xy = 0.0f;
-    alias xy this;
-    mixin Linear;
-}
-
-// Bivector3 type
-/// Beware of the field order
-/// xy is the first field
-struct Bivector3
-{
-    float xy = 0.0f;
-    float yz = 0.0f;
-    float zx = 0.0f;
-    mixin Linear;
-}
-
-// Rotor type
-struct Rotor3
-{
-    float a = 1.0f;
-    float xy = 0.0f;
-    float yz = 0.0f;
-    float zx = 0.0f;
-    mixin Linear;
-
-    alias i = yz;
-    alias j = zx;
-    alias k = xy;
-
-    @property Bivector3 b()
-    {
-        return Bivector3(xy, yz, zx);
-    }
-
-    @property Bivector3 b(Bivector3 _b)
-    {
-        xy = _b.xy;
-        yz = _b.yz;
-        zx = _b.zx;
-        return _b;
-    }
-
-    this(float _a, Bivector3 _b)
-    {
-        a = _a;
-        b = _b;
-    }
-
-    this(float _a, float _xy, float _yz, float _zx)
-    {
-        a = _a;
-        xy = _xy;
-        yz = _yz;
-        zx = _zx;
-    }
-}
-
-alias Matrix4 = Matrix;
-
-version (unittest)
-{
-    import fluent.asserts;
-}
-
-mixin template Linear()
-{
-    import std.algorithm : canFind, map;
-    import std.range : join;
-    import std.traits : FieldNameTuple;
-
-    private static alias T = typeof(this);
-
-    static T zero()
-    {
-        enum fragment = [FieldNameTuple!T].map!(field => "0.").join(",");
-        return mixin("T(" ~ fragment ~ ")");
-    }
-
-    static T one()
-    {
-        enum fragment = [FieldNameTuple!T].map!(field => "1.").join(",");
-        return mixin("T(" ~ fragment ~ ")");
-    }
-
-    inout T opUnary(string op)() if (["+", "-"].canFind(op))
-    {
-        enum fragment = [FieldNameTuple!T].map!(field => op ~ field).join(",");
-        return mixin("T(" ~ fragment ~ ")");
-    }
-
-    static if (is(T == Rotor3))
-    {
-        /// Returns a rotor equivalent to first apply p, then apply q
-        inout Rotor3 opBinary(string op)(inout Rotor3 q) if (op == "*")
-        {
-            alias p = this;
-            Rotor3 r;
-            r.a = p.a * q.a - p.i * q.i - p.j * q.j - p.k * q.k;
-            r.i = p.i * q.a + p.a * q.i + p.j * q.k - p.k * q.j;
-            r.j = p.j * q.a + p.a * q.j + p.k * q.i - p.i * q.k;
-            r.k = p.k * q.a + p.a * q.k + p.i * q.j - p.j * q.i;
-            return r;
-        }
-
-        inout Vector3 opBinary(string op)(inout Vector3 v) if (op == "*")
-        {
-            Vector3 rv;
-            rv.x = a * v.x + xy * v.y - zx * v.z;
-            rv.y = a * v.y + yz * v.z - xy * v.x;
-            rv.z = a * v.z + zx * v.x - yz * v.y;
-            return rv;
-        }
-
-        inout Vector3 opBinaryRight(string op)(inout Vector3 v) if (op == "*")
-        {
-            Vector3 vr;
-            vr.x = v.x * a - v.y * xy + v.z * zx;
-            vr.y = v.y * a - v.z * yz + v.x * xy;
-            vr.z = v.z * a - v.x * zx + v.y * yz;
-            return vr;
-        }
-    }
-    else
-    {
-        inout T opBinary(string op)(inout T rhs) if (["+", "-"].canFind(op))
-        {
-            enum fragment = [FieldNameTuple!T].map!(field => field ~ op ~ "rhs." ~ field).join(",");
-            return mixin("T(" ~ fragment ~ ")");
-        }
-
-        ref T opOpAssign(string op)(inout T rhs) if (["+", "-"].canFind(op))
-        {
-            static foreach (field; [FieldNameTuple!T])
-                mixin(field ~ op ~ "= rhs." ~ field ~ ";");
-            return this;
-        }
-    }
-
-    inout T opBinary(string op)(inout float rhs) if (["+", "-", "*", "/"].canFind(op))
-    {
-        enum fragment = [FieldNameTuple!T].map!(field => field ~ op ~ "rhs").join(",");
-        return mixin("T(" ~ fragment ~ ")");
-    }
-
-    inout T opBinaryRight(string op)(inout float lhs) if (["+", "-", "*", "/"].canFind(op))
-    {
-        enum fragment = [FieldNameTuple!T].map!(field => "lhs" ~ op ~ field).join(",");
-        return mixin("T(" ~ fragment ~ ")");
-    }
-
-    ref T opOpAssign(string op)(inout float rhs) if (["+", "-", "*", "/"].canFind(op))
-    {
-        static foreach (field; [FieldNameTuple!T])
-            mixin(field ~ op ~ "= rhs;");
-        return this;
-    }
-}
-
-unittest
-{
-    Assert.equal(Vector2.init, Vector2.zero);
-    Assert.equal(Vector2(), Vector2.zero);
-    Assert.equal(-Vector2(1, 2), Vector2(-1, -2));
-    auto a = Vector3(1, 2, 9);
-    immutable b = Vector3(3, 4, 9);
-    Vector3 c = a + b;
-    Assert.equal(c, Vector3(4, 6, 18));
-    Assert.equal(4.0f - Vector2.zero, Vector2(4, 4));
-    Assert.equal(Vector2.one - 3.0f, Vector2(-2, -2));
-    a += 5;
-    Assert.equal(a, Vector3(6, 7, 14));
-    a *= 0.5;
-    Assert.equal(a, Vector3(3, 3.5, 7));
-    a += Vector3(3, 2.5, -1);
-    Assert.equal(a, Vector3(6, 6, 6));
-}
-
-import std.traits : FieldNameTuple;
-import std.algorithm : map;
-import std.range : join;
-
-float length(T)(T v)
-{
-    enum fragment = [FieldNameTuple!T].map!(field => "v." ~ field ~ "*" ~ "v." ~ field).join("+");
-    return mixin("sqrt(" ~ fragment ~ ")");
-}
-
-T normal(T)(T v)
-{
-    return v / v.length;
-}
-
-float distance(T)(T lhs, T rhs)
-{
-    return (lhs - rhs).length;
-}
-
-float dot(T)(T lhs, T rhs)
-{
-    enum fragment = [FieldNameTuple!T].map!(field => "lhs." ~ field ~ "*" ~ "rhs." ~ field).join(
-                "+");
-    return mixin(fragment);
-}
-
-unittest
-{
-    Assert.equal(Vector2(3, 4).length, 5);
-    const a = Vector2(-3, 4);
-    Assert.equal(a.normal, Vector2(-3. / 5., 4. / 5.));
-    immutable b = Vector2(9, 8);
-    Assert.equal(b.distance(Vector2(-3, 3)), 13);
-    Assert.equal(Vector3(2, 3, 4).dot(Vector3(4, 5, 6)), 47);
-    Assert.equal(Vector2.one.length, sqrt(2.0f));
-}
-
-unittest
-{
-    Assert.equal(Rotor3(1, 2, 3, 4), Rotor3(1, Bivector3(2, 3, 4)));
-}
-
-/// Mix `amount` of `lhs` with `1-amount` of `rhs`
-///   `amount` should be between 0 and 1, but can be anything
-///   lerp(lhs, rhs, 0) == lhs
-///   lerp(lhs, rhs, 1) == rhs
-T lerp(T)(T lhs, T rhs, float amount)
-{
-    return lhs + amount * (rhs - lhs);
-}
-
-/// angle betwenn vector and x-axis (+y +x -> positive)
-float angle(Vector2 v)
-{
-    return atan2(v.y, v.x);
-}
-
-Vector2 rotate(Vector2 v, float angle)
-{
-    return Vector2(v.x * cos(angle) - v.y * sin(angle), v.x * sin(angle) + v.y * cos(angle));
-}
-
-Vector2 slide(Vector2 v, Vector2 along)
-{
-    return along.normal * dot(v, along);
-}
-
-Bivector2 wedge(Vector2 lhs, Vector2 rhs)
-{
-    Bivector2 result = {xy: lhs.x * rhs.y - lhs.y * rhs.x};
-    return result;
-}
-
-// dfmt off
-Bivector3 wedge(Vector3 lhs, Vector3 rhs)
-{
-    Bivector3 result = {
-        xy: lhs.x * rhs.y - lhs.y * rhs.x,
-        yz: lhs.y * rhs.z - lhs.z * rhs.y,
-        zx: lhs.z * rhs.x - lhs.x * rhs.z,
-    };
-    return result;
-}
-
-Vector3 transform(Vector3 v, Matrix4 mat)
-{
-    with (v) with (mat)
-        return Vector3(
-            m0 * x + m4 * y + m8 * z + m12,
-            m1 * x + m5 * y + m9 * z + m13,
-            m2 * x + m6 * y + m10 * z + m14
-        );
-}
-// dfmt on
-
-Vector3 cross(Vector3 lhs, Vector3 rhs)
-{
-    auto v = wedge(lhs, rhs);
-    return Vector3(v.yz, v.zx, v.xy);
-}
-
-unittest {
-    // TODO
-}
-
-/// Returns a unit rotor that rotates `from` to `to`
-Rotor3 rotation(Vector3 from, Vector3 to)
-{
-    return Rotor3(1 + dot(to, from), wedge(to, from)).normal;
-}
-
-Rotor3 rotation(float angle, Bivector3 plane)
-{
-    return Rotor3(cos(angle / 2.0f), -sin(angle / 2.0f) * plane);
-}
-
-/// Rotate q by p
-Rotor3 rotate(Rotor3 p, Rotor3 q)
-{
-    return p * q * p.reverse;
-}
-
-/// Rotate v by r
-Vector3 rotate(Rotor3 r, Vector3 v)
-{
-    return r * v * r.reverse;
-}
-
-Rotor3 reverse(Rotor3 r)
-{
-    return Rotor3(r.a, -r.b);
-}
-
-unittest
-{
-    // TODO
-}
+public import raylib.raymathext;

source/rlgl.d

@@ -1,1886 +1,4 @@
+deprecated("module rlgl is deprecated, import raylib.rlgl instead")
 module rlgl;
 
-import raylib;
-/**********************************************************************************************
-*
-*   rlgl v4.0 - A multi-OpenGL abstraction layer with an immediate-mode style API
-*
-*   An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, 4.3 Core, ES 2.0)
-*   that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...)
-*
-*   When chosing an OpenGL backend different than OpenGL 1.1, some internal buffer are
-*   initialized on rlglInit() to accumulate vertex data.
-*
-*   When an internal state change is required all the stored vertex data is renderer in batch,
-*   additioanlly, rlDrawRenderBatchActive() could be called to force flushing of the batch.
-*
-*   Some additional resources are also loaded for convenience, here the complete list:
-*      - Default batch (RLGL.defaultBatch): RenderBatch system to accumulate vertex data
-*      - Default texture (RLGL.defaultTextureId): 1x1 white pixel R8G8B8A8
-*      - Default shader (RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs)
-*
-*   Internal buffer (and additional resources) must be manually unloaded calling rlglClose().
-*
-*
-*   CONFIGURATION:
-*
-*   #define GRAPHICS_API_OPENGL_11
-*   #define GRAPHICS_API_OPENGL_21
-*   #define GRAPHICS_API_OPENGL_33
-*   #define GRAPHICS_API_OPENGL_43
-*   #define GRAPHICS_API_OPENGL_ES2
-*       Use selected OpenGL graphics backend, should be supported by platform
-*       Those preprocessor defines are only used on rlgl module, if OpenGL version is
-*       required by any other module, use rlGetVersion() to check it
-*
-*   #define RLGL_IMPLEMENTATION
-*       Generates the implementation of the library into the included file.
-*       If not defined, the library is in header only mode and can be included in other headers
-*       or source files without problems. But only ONE file should hold the implementation.
-*
-*   #define RLGL_RENDER_TEXTURES_HINT
-*       Enable framebuffer objects (fbo) support (enabled by default)
-*       Some GPUs could not support them despite the OpenGL version
-*
-*   #define RLGL_SHOW_GL_DETAILS_INFO
-*       Show OpenGL extensions and capabilities detailed logs on init
-*
-*   #define RLGL_ENABLE_OPENGL_DEBUG_CONTEXT
-*       Enable debug context (only available on OpenGL 4.3)
-*
-*   rlgl capabilities could be customized just defining some internal
-*   values before library inclusion (default values listed):
-*
-*   #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS   8192    // Default internal render batch elements limits
-*   #define RL_DEFAULT_BATCH_BUFFERS              1    // Default number of batch buffers (multi-buffering)
-*   #define RL_DEFAULT_BATCH_DRAWCALLS          256    // Default number of batch draw calls (by state changes: mode, texture)
-*   #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS    4    // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
-*
-*   #define RL_MAX_MATRIX_STACK_SIZE             32    // Maximum size of internal Matrix stack
-*   #define RL_MAX_SHADER_LOCATIONS              32    // Maximum number of shader locations supported
-*   #define RL_CULL_DISTANCE_NEAR              0.01    // Default projection matrix near cull distance
-*   #define RL_CULL_DISTANCE_FAR             1000.0    // Default projection matrix far cull distance
-*
-*   When loading a shader, the following vertex attribute and uniform
-*   location names are tried to be set automatically:
-*
-*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION     "vertexPosition"    // Binded by default to shader location: 0
-*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD     "vertexTexCoord"    // Binded by default to shader location: 1
-*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL       "vertexNormal"      // Binded by default to shader location: 2
-*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR        "vertexColor"       // Binded by default to shader location: 3
-*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT      "vertexTangent"     // Binded by default to shader location: 4
-*   #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2    "vertexTexCoord2"   // Binded by default to shader location: 5
-*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP         "mvp"               // model-view-projection matrix
-*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW        "matView"           // view matrix
-*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION  "matProjection"     // projection matrix
-*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL       "matModel"          // model matrix
-*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL      "matNormal"         // normal matrix (transpose(inverse(matModelView))
-*   #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR       "colDiffuse"        // color diffuse (base tint color, multiplied by texture color)
-*   #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0  "texture0"          // texture0 (texture slot active 0)
-*   #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1  "texture1"          // texture1 (texture slot active 1)
-*   #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2  "texture2"          // texture2 (texture slot active 2)
-*
-*   DEPENDENCIES:
-*
-*      - OpenGL libraries (depending on platform and OpenGL version selected)
-*      - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core, 4.3 Core)
-*
-*
-*   LICENSE: zlib/libpng
-*
-*   Copyright (c) 2014-2021 Ramon Santamaria (@raysan5)
-*
-*   This software is provided "as-is", without any express or implied warranty. In no event
-*   will the authors be held liable for any damages arising from the use of this software.
-*
-*   Permission is granted to anyone to use this software for any purpose, including commercial
-*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
-*
-*     1. The origin of this software must not be misrepresented; you must not claim that you
-*     wrote the original software. If you use this software in a product, an acknowledgment
-*     in the product documentation would be appreciated but is not required.
-*
-*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
-*     as being the original software.
-*
-*     3. This notice may not be removed or altered from any source distribution.
-*
-**********************************************************************************************/
-
-extern (C) @nogc nothrow:
-
-enum RLGL_VERSION = "4.0";
-
-// Function specifiers in case library is build/used as a shared library (Windows)
-// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
-
-// We are building the library as a Win32 shared library (.dll)
-
-// We are using the library as a Win32 shared library (.dll)
-
-// Function specifiers definition // Functions defined as 'extern' by default (implicit specifiers)
-
-// Support TRACELOG macros
-
-// Allow custom memory allocators
-
-// Security check in case no GRAPHICS_API_OPENGL_* defined
-
-// Security check in case multiple GRAPHICS_API_OPENGL_* defined
-
-// OpenGL 2.1 uses most of OpenGL 3.3 Core functionality
-// WARNING: Specific parts are checked with #if defines
-
-// OpenGL 4.3 uses OpenGL 3.3 Core functionality
-
-// Support framebuffer objects by default
-// NOTE: Some driver implementation do not support it, despite they should
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-
-// Default internal render batch elements limits
-
-// This is the maximum amount of elements (quads) per batch
-// NOTE: Be careful with text, every letter maps to a quad
-enum RL_DEFAULT_BATCH_BUFFER_ELEMENTS = 8192;
-
-// We reduce memory sizes for embedded systems (RPI and HTML5)
-// NOTE: On HTML5 (emscripten) this is allocated on heap,
-// by default it's only 16MB!...just take care...
-
-enum RL_DEFAULT_BATCH_BUFFERS = 1; // Default number of batch buffers (multi-buffering)
-
-enum RL_DEFAULT_BATCH_DRAWCALLS = 256; // Default number of batch draw calls (by state changes: mode, texture)
-
-enum RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS = 4; // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
-
-// Internal Matrix stack
-
-enum RL_MAX_MATRIX_STACK_SIZE = 32; // Maximum size of Matrix stack
-
-// Shader limits
-
-enum RL_MAX_SHADER_LOCATIONS = 32; // Maximum number of shader locations supported
-
-// Projection matrix culling
-
-enum RL_CULL_DISTANCE_NEAR = 0.01; // Default near cull distance
-
-enum RL_CULL_DISTANCE_FAR = 1000.0; // Default far cull distance
-
-// Texture parameters (equivalent to OpenGL defines)
-enum RL_TEXTURE_WRAP_S = 0x2802; // GL_TEXTURE_WRAP_S
-enum RL_TEXTURE_WRAP_T = 0x2803; // GL_TEXTURE_WRAP_T
-enum RL_TEXTURE_MAG_FILTER = 0x2800; // GL_TEXTURE_MAG_FILTER
-enum RL_TEXTURE_MIN_FILTER = 0x2801; // GL_TEXTURE_MIN_FILTER
-
-enum RL_TEXTURE_FILTER_NEAREST = 0x2600; // GL_NEAREST
-enum RL_TEXTURE_FILTER_LINEAR = 0x2601; // GL_LINEAR
-enum RL_TEXTURE_FILTER_MIP_NEAREST = 0x2700; // GL_NEAREST_MIPMAP_NEAREST
-enum RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR = 0x2702; // GL_NEAREST_MIPMAP_LINEAR
-enum RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST = 0x2701; // GL_LINEAR_MIPMAP_NEAREST
-enum RL_TEXTURE_FILTER_MIP_LINEAR = 0x2703; // GL_LINEAR_MIPMAP_LINEAR
-enum RL_TEXTURE_FILTER_ANISOTROPIC = 0x3000; // Anisotropic filter (custom identifier)
-
-enum RL_TEXTURE_WRAP_REPEAT = 0x2901; // GL_REPEAT
-enum RL_TEXTURE_WRAP_CLAMP = 0x812F; // GL_CLAMP_TO_EDGE
-enum RL_TEXTURE_WRAP_MIRROR_REPEAT = 0x8370; // GL_MIRRORED_REPEAT
-enum RL_TEXTURE_WRAP_MIRROR_CLAMP = 0x8742; // GL_MIRROR_CLAMP_EXT
-
-// Matrix modes (equivalent to OpenGL)
-enum RL_MODELVIEW = 0x1700; // GL_MODELVIEW
-enum RL_PROJECTION = 0x1701; // GL_PROJECTION
-enum RL_TEXTURE = 0x1702; // GL_TEXTURE
-
-// Primitive assembly draw modes
-enum RL_LINES = 0x0001; // GL_LINES
-enum RL_TRIANGLES = 0x0004; // GL_TRIANGLES
-enum RL_QUADS = 0x0007; // GL_QUADS
-
-// GL equivalent data types
-enum RL_UNSIGNED_BYTE = 0x1401; // GL_UNSIGNED_BYTE
-enum RL_FLOAT = 0x1406; // GL_FLOAT
-
-// Buffer usage hint
-enum RL_STREAM_DRAW = 0x88E0; // GL_STREAM_DRAW
-enum RL_STREAM_READ = 0x88E1; // GL_STREAM_READ
-enum RL_STREAM_COPY = 0x88E2; // GL_STREAM_COPY
-enum RL_STATIC_DRAW = 0x88E4; // GL_STATIC_DRAW
-enum RL_STATIC_READ = 0x88E5; // GL_STATIC_READ
-enum RL_STATIC_COPY = 0x88E6; // GL_STATIC_COPY
-enum RL_DYNAMIC_DRAW = 0x88E8; // GL_DYNAMIC_DRAW
-enum RL_DYNAMIC_READ = 0x88E9; // GL_DYNAMIC_READ
-enum RL_DYNAMIC_COPY = 0x88EA; // GL_DYNAMIC_COPY
-
-// GL Shader type
-enum RL_FRAGMENT_SHADER = 0x8B30; // GL_FRAGMENT_SHADER
-enum RL_VERTEX_SHADER = 0x8B31; // GL_VERTEX_SHADER
-enum RL_COMPUTE_SHADER = 0x91B9; // GL_COMPUTE_SHADER
-
-//----------------------------------------------------------------------------------
-// Types and Structures Definition
-//----------------------------------------------------------------------------------
-enum rlGlVersion
-{
-    OPENGL_11 = 1,
-    OPENGL_21 = 2,
-    OPENGL_33 = 3,
-    OPENGL_43 = 4,
-    OPENGL_ES_20 = 5
-}
-
-enum rlFramebufferAttachType
-{
-    RL_ATTACHMENT_COLOR_CHANNEL0 = 0,
-    RL_ATTACHMENT_COLOR_CHANNEL1 = 1,
-    RL_ATTACHMENT_COLOR_CHANNEL2 = 2,
-    RL_ATTACHMENT_COLOR_CHANNEL3 = 3,
-    RL_ATTACHMENT_COLOR_CHANNEL4 = 4,
-    RL_ATTACHMENT_COLOR_CHANNEL5 = 5,
-    RL_ATTACHMENT_COLOR_CHANNEL6 = 6,
-    RL_ATTACHMENT_COLOR_CHANNEL7 = 7,
-    RL_ATTACHMENT_DEPTH = 100,
-    RL_ATTACHMENT_STENCIL = 200
-}
-
-enum rlFramebufferAttachTextureType
-{
-    RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0,
-    RL_ATTACHMENT_CUBEMAP_NEGATIVE_X = 1,
-    RL_ATTACHMENT_CUBEMAP_POSITIVE_Y = 2,
-    RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y = 3,
-    RL_ATTACHMENT_CUBEMAP_POSITIVE_Z = 4,
-    RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z = 5,
-    RL_ATTACHMENT_TEXTURE2D = 100,
-    RL_ATTACHMENT_RENDERBUFFER = 200
-}
-
-// Dynamic vertex buffers (position + texcoords + colors + indices arrays)
-struct rlVertexBuffer
-{
-    int elementCount; // Number of elements in the buffer (QUADS)
-
-    float* vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
-    float* texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
-    ubyte* colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
-
-    uint* indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad)
-
-    // Vertex indices (in case vertex data comes indexed) (6 indices per quad)
-
-    uint vaoId; // OpenGL Vertex Array Object id
-    uint[4] vboId; // OpenGL Vertex Buffer Objects id (4 types of vertex data)
-}
-
-// Draw call type
-// NOTE: Only texture changes register a new draw, other state-change-related elements are not
-// used at this moment (vaoId, shaderId, matrices), raylib just forces a batch draw call if any
-// of those state-change happens (this is done in core module)
-struct rlDrawCall
-{
-    int mode; // Drawing mode: LINES, TRIANGLES, QUADS
-    int vertexCount; // Number of vertex of the draw
-    int vertexAlignment; // Number of vertex required for index alignment (LINES, TRIANGLES)
-    //unsigned int vaoId;       // Vertex array id to be used on the draw -> Using RLGL.currentBatch->vertexBuffer.vaoId
-    //unsigned int shaderId;    // Shader id to be used on the draw -> Using RLGL.currentShaderId
-    uint textureId; // Texture id to be used on the draw -> Use to create new draw call if changes
-
-    //Matrix projection;      // Projection matrix for this draw -> Using RLGL.projection by default
-    //Matrix modelview;       // Modelview matrix for this draw -> Using RLGL.modelview by default
-}
-
-// rlRenderBatch type
-struct rlRenderBatch
-{
-    int bufferCount; // Number of vertex buffers (multi-buffering support)
-    int currentBuffer; // Current buffer tracking in case of multi-buffering
-    rlVertexBuffer* vertexBuffer; // Dynamic buffer(s) for vertex data
-
-    rlDrawCall* draws; // Draw calls array, depends on textureId
-    int drawCounter; // Draw calls counter
-    float currentDepth; // Current depth value for next draw
-}
-
-// Boolean type
-
-// Matrix, 4x4 components, column major, OpenGL style, right handed
-
-// Matrix first row (4 components)
-// Matrix second row (4 components)
-// Matrix third row (4 components)
-// Matrix fourth row (4 components)
-
-// Trace log level
-// NOTE: Organized by priority level
-enum rlTraceLogLevel
-{
-    RL_LOG_ALL = 0, // Display all logs
-    RL_LOG_TRACE = 1, // Trace logging, intended for internal use only
-    RL_LOG_DEBUG = 2, // Debug logging, used for internal debugging, it should be disabled on release builds
-    RL_LOG_INFO = 3, // Info logging, used for program execution info
-    RL_LOG_WARNING = 4, // Warning logging, used on recoverable failures
-    RL_LOG_ERROR = 5, // Error logging, used on unrecoverable failures
-    RL_LOG_FATAL = 6, // Fatal logging, used to abort program: exit(EXIT_FAILURE)
-    RL_LOG_NONE = 7 // Disable logging
-}
-
-// Texture formats (support depends on OpenGL version)
-enum rlPixelFormat
-{
-    RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
-    RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA = 2, // 8*2 bpp (2 channels)
-    RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5 = 3, // 16 bpp
-    RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8 = 4, // 24 bpp
-    RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 = 5, // 16 bpp (1 bit alpha)
-    RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 = 6, // 16 bpp (4 bit alpha)
-    RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 = 7, // 32 bpp
-    RL_PIXELFORMAT_UNCOMPRESSED_R32 = 8, // 32 bpp (1 channel - float)
-    RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32 = 9, // 32*3 bpp (3 channels - float)
-    RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 = 10, // 32*4 bpp (4 channels - float)
-    RL_PIXELFORMAT_COMPRESSED_DXT1_RGB = 11, // 4 bpp (no alpha)
-    RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA = 12, // 4 bpp (1 bit alpha)
-    RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA = 13, // 8 bpp
-    RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA = 14, // 8 bpp
-    RL_PIXELFORMAT_COMPRESSED_ETC1_RGB = 15, // 4 bpp
-    RL_PIXELFORMAT_COMPRESSED_ETC2_RGB = 16, // 4 bpp
-    RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA = 17, // 8 bpp
-    RL_PIXELFORMAT_COMPRESSED_PVRT_RGB = 18, // 4 bpp
-    RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA = 19, // 4 bpp
-    RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA = 20, // 8 bpp
-    RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA = 21 // 2 bpp
-}
-
-// Texture parameters: filter mode
-// NOTE 1: Filtering considers mipmaps if available in the texture
-// NOTE 2: Filter is accordingly set for minification and magnification
-enum rlTextureFilter
-{
-    RL_TEXTURE_FILTER_POINT = 0, // No filter, just pixel aproximation
-    RL_TEXTURE_FILTER_BILINEAR = 1, // Linear filtering
-    RL_TEXTURE_FILTER_TRILINEAR = 2, // Trilinear filtering (linear with mipmaps)
-    RL_TEXTURE_FILTER_ANISOTROPIC_4X = 3, // Anisotropic filtering 4x
-    RL_TEXTURE_FILTER_ANISOTROPIC_8X = 4, // Anisotropic filtering 8x
-    RL_TEXTURE_FILTER_ANISOTROPIC_16X = 5 // Anisotropic filtering 16x
-}
-
-// Color blending modes (pre-defined)
-enum rlBlendMode
-{
-    RL_BLEND_ALPHA = 0, // Blend textures considering alpha (default)
-    RL_BLEND_ADDITIVE = 1, // Blend textures adding colors
-    RL_BLEND_MULTIPLIED = 2, // Blend textures multiplying colors
-    RL_BLEND_ADD_COLORS = 3, // Blend textures adding colors (alternative)
-    RL_BLEND_SUBTRACT_COLORS = 4, // Blend textures subtracting colors (alternative)
-    RL_BLEND_CUSTOM = 5 // Belnd textures using custom src/dst factors (use SetBlendModeCustom())
-}
-
-// Shader location point type
-enum rlShaderLocationIndex
-{
-    RL_SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position
-    RL_SHADER_LOC_VERTEX_TEXCOORD01 = 1, // Shader location: vertex attribute: texcoord01
-    RL_SHADER_LOC_VERTEX_TEXCOORD02 = 2, // Shader location: vertex attribute: texcoord02
-    RL_SHADER_LOC_VERTEX_NORMAL = 3, // Shader location: vertex attribute: normal
-    RL_SHADER_LOC_VERTEX_TANGENT = 4, // Shader location: vertex attribute: tangent
-    RL_SHADER_LOC_VERTEX_COLOR = 5, // Shader location: vertex attribute: color
-    RL_SHADER_LOC_MATRIX_MVP = 6, // Shader location: matrix uniform: model-view-projection
-    RL_SHADER_LOC_MATRIX_VIEW = 7, // Shader location: matrix uniform: view (camera transform)
-    RL_SHADER_LOC_MATRIX_PROJECTION = 8, // Shader location: matrix uniform: projection
-    RL_SHADER_LOC_MATRIX_MODEL = 9, // Shader location: matrix uniform: model (transform)
-    RL_SHADER_LOC_MATRIX_NORMAL = 10, // Shader location: matrix uniform: normal
-    RL_SHADER_LOC_VECTOR_VIEW = 11, // Shader location: vector uniform: view
-    RL_SHADER_LOC_COLOR_DIFFUSE = 12, // Shader location: vector uniform: diffuse color
-    RL_SHADER_LOC_COLOR_SPECULAR = 13, // Shader location: vector uniform: specular color
-    RL_SHADER_LOC_COLOR_AMBIENT = 14, // Shader location: vector uniform: ambient color
-    RL_SHADER_LOC_MAP_ALBEDO = 15, // Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE)
-    RL_SHADER_LOC_MAP_METALNESS = 16, // Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR)
-    RL_SHADER_LOC_MAP_NORMAL = 17, // Shader location: sampler2d texture: normal
-    RL_SHADER_LOC_MAP_ROUGHNESS = 18, // Shader location: sampler2d texture: roughness
-    RL_SHADER_LOC_MAP_OCCLUSION = 19, // Shader location: sampler2d texture: occlusion
-    RL_SHADER_LOC_MAP_EMISSION = 20, // Shader location: sampler2d texture: emission
-    RL_SHADER_LOC_MAP_HEIGHT = 21, // Shader location: sampler2d texture: height
-    RL_SHADER_LOC_MAP_CUBEMAP = 22, // Shader location: samplerCube texture: cubemap
-    RL_SHADER_LOC_MAP_IRRADIANCE = 23, // Shader location: samplerCube texture: irradiance
-    RL_SHADER_LOC_MAP_PREFILTER = 24, // Shader location: samplerCube texture: prefilter
-    RL_SHADER_LOC_MAP_BRDF = 25 // Shader location: sampler2d texture: brdf
-}
-
-enum RL_SHADER_LOC_MAP_DIFFUSE = rlShaderLocationIndex.RL_SHADER_LOC_MAP_ALBEDO;
-enum RL_SHADER_LOC_MAP_SPECULAR = rlShaderLocationIndex.RL_SHADER_LOC_MAP_METALNESS;
-
-// Shader uniform data type
-enum rlShaderUniformDataType
-{
-    RL_SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float
-    RL_SHADER_UNIFORM_VEC2 = 1, // Shader uniform type: vec2 (2 float)
-    RL_SHADER_UNIFORM_VEC3 = 2, // Shader uniform type: vec3 (3 float)
-    RL_SHADER_UNIFORM_VEC4 = 3, // Shader uniform type: vec4 (4 float)
-    RL_SHADER_UNIFORM_INT = 4, // Shader uniform type: int
-    RL_SHADER_UNIFORM_IVEC2 = 5, // Shader uniform type: ivec2 (2 int)
-    RL_SHADER_UNIFORM_IVEC3 = 6, // Shader uniform type: ivec3 (3 int)
-    RL_SHADER_UNIFORM_IVEC4 = 7, // Shader uniform type: ivec4 (4 int)
-    RL_SHADER_UNIFORM_SAMPLER2D = 8 // Shader uniform type: sampler2d
-}
-
-// Shader attribute data types
-enum rlShaderAttributeDataType
-{
-    RL_SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float
-    RL_SHADER_ATTRIB_VEC2 = 1, // Shader attribute type: vec2 (2 float)
-    RL_SHADER_ATTRIB_VEC3 = 2, // Shader attribute type: vec3 (3 float)
-    RL_SHADER_ATTRIB_VEC4 = 3 // Shader attribute type: vec4 (4 float)
-}
-
-//------------------------------------------------------------------------------------
-// Functions Declaration - Matrix operations
-//------------------------------------------------------------------------------------
-
-// Prevents name mangling of functions
-
-void rlMatrixMode(int mode); // Choose the current matrix to be transformed
-void rlPushMatrix(); // Push the current matrix to stack
-void rlPopMatrix(); // Pop lattest inserted matrix from stack
-void rlLoadIdentity(); // Reset current matrix to identity matrix
-void rlTranslatef(float x, float y, float z); // Multiply the current matrix by a translation matrix
-void rlRotatef(float angle, float x, float y, float z); // Multiply the current matrix by a rotation matrix
-void rlScalef(float x, float y, float z); // Multiply the current matrix by a scaling matrix
-void rlMultMatrixf(float* matf); // Multiply the current matrix by another matrix
-void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar);
-void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar);
-void rlViewport(int x, int y, int width, int height); // Set the viewport area
-
-//------------------------------------------------------------------------------------
-// Functions Declaration - Vertex level operations
-//------------------------------------------------------------------------------------
-void rlBegin(int mode); // Initialize drawing mode (how to organize vertex)
-void rlEnd(); // Finish vertex providing
-void rlVertex2i(int x, int y); // Define one vertex (position) - 2 int
-void rlVertex2f(float x, float y); // Define one vertex (position) - 2 float
-void rlVertex3f(float x, float y, float z); // Define one vertex (position) - 3 float
-void rlTexCoord2f(float x, float y); // Define one vertex (texture coordinate) - 2 float
-void rlNormal3f(float x, float y, float z); // Define one vertex (normal) - 3 float
-void rlColor4ub(ubyte r, ubyte g, ubyte b, ubyte a); // Define one vertex (color) - 4 byte
-void rlColor3f(float x, float y, float z); // Define one vertex (color) - 3 float
-void rlColor4f(float x, float y, float z, float w); // Define one vertex (color) - 4 float
-
-//------------------------------------------------------------------------------------
-// Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2)
-// NOTE: This functions are used to completely abstract raylib code from OpenGL layer,
-// some of them are direct wrappers over OpenGL calls, some others are custom
-//------------------------------------------------------------------------------------
-
-// Vertex buffers state
-bool rlEnableVertexArray(uint vaoId); // Enable vertex array (VAO, if supported)
-void rlDisableVertexArray(); // Disable vertex array (VAO, if supported)
-void rlEnableVertexBuffer(uint id); // Enable vertex buffer (VBO)
-void rlDisableVertexBuffer(); // Disable vertex buffer (VBO)
-void rlEnableVertexBufferElement(uint id); // Enable vertex buffer element (VBO element)
-void rlDisableVertexBufferElement(); // Disable vertex buffer element (VBO element)
-void rlEnableVertexAttribute(uint index); // Enable vertex attribute index
-void rlDisableVertexAttribute(uint index); // Disable vertex attribute index
-
-// Enable attribute state pointer
-// Disable attribute state pointer
-
-// Textures state
-void rlActiveTextureSlot(int slot); // Select and active a texture slot
-void rlEnableTexture(uint id); // Enable texture
-void rlDisableTexture(); // Disable texture
-void rlEnableTextureCubemap(uint id); // Enable texture cubemap
-void rlDisableTextureCubemap(); // Disable texture cubemap
-void rlTextureParameters(uint id, int param, int value); // Set texture parameters (filter, wrap)
-
-// Shader state
-void rlEnableShader(uint id); // Enable shader program
-void rlDisableShader(); // Disable shader program
-
-// Framebuffer state
-void rlEnableFramebuffer(uint id); // Enable render texture (fbo)
-void rlDisableFramebuffer(); // Disable render texture (fbo), return to default framebuffer
-void rlActiveDrawBuffers(int count); // Activate multiple draw color buffers
-
-// General render state
-void rlEnableColorBlend(); // Enable color blending
-void rlDisableColorBlend(); // Disable color blending
-void rlEnableDepthTest(); // Enable depth test
-void rlDisableDepthTest(); // Disable depth test
-void rlEnableDepthMask(); // Enable depth write
-void rlDisableDepthMask(); // Disable depth write
-void rlEnableBackfaceCulling(); // Enable backface culling
-void rlDisableBackfaceCulling(); // Disable backface culling
-void rlEnableScissorTest(); // Enable scissor test
-void rlDisableScissorTest(); // Disable scissor test
-void rlScissor(int x, int y, int width, int height); // Scissor test
-void rlEnableWireMode(); // Enable wire mode
-void rlDisableWireMode(); // Disable wire mode
-void rlSetLineWidth(float width); // Set the line drawing width
-float rlGetLineWidth(); // Get the line drawing width
-void rlEnableSmoothLines(); // Enable line aliasing
-void rlDisableSmoothLines(); // Disable line aliasing
-void rlEnableStereoRender(); // Enable stereo rendering
-void rlDisableStereoRender(); // Disable stereo rendering
-bool rlIsStereoRenderEnabled(); // Check if stereo render is enabled
-
-void rlClearColor(ubyte r, ubyte g, ubyte b, ubyte a); // Clear color buffer with color
-void rlClearScreenBuffers(); // Clear used screen buffers (color and depth)
-void rlCheckErrors(); // Check and log OpenGL error codes
-void rlSetBlendMode(int mode); // Set blending mode
-void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation); // Set blending mode factor and equation (using OpenGL factors)
-
-//------------------------------------------------------------------------------------
-// Functions Declaration - rlgl functionality
-//------------------------------------------------------------------------------------
-// rlgl initialization functions
-void rlglInit(int width, int height); // Initialize rlgl (buffers, shaders, textures, states)
-void rlglClose(); // De-inititialize rlgl (buffers, shaders, textures)
-void rlLoadExtensions(void* loader); // Load OpenGL extensions (loader function required)
-int rlGetVersion(); // Get current OpenGL version
-int rlGetFramebufferWidth(); // Get default framebuffer width
-int rlGetFramebufferHeight(); // Get default framebuffer height
-
-uint rlGetTextureIdDefault(); // Get default texture id
-uint rlGetShaderIdDefault(); // Get default shader id
-int* rlGetShaderLocsDefault(); // Get default shader locations
-
-// Render batch management
-// NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode
-// but this render batch API is exposed in case of custom batches are required
-rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements); // Load a render batch system
-void rlUnloadRenderBatch(rlRenderBatch batch); // Unload render batch system
-void rlDrawRenderBatch(rlRenderBatch* batch); // Draw render batch data (Update->Draw->Reset)
-void rlSetRenderBatchActive(rlRenderBatch* batch); // Set the active render batch for rlgl (NULL for default internal)
-void rlDrawRenderBatchActive(); // Update and draw internal render batch
-bool rlCheckRenderBatchLimit(int vCount); // Check internal buffer overflow for a given number of vertex
-void rlSetTexture(uint id); // Set current texture for render batch and check buffers limits
-
-//------------------------------------------------------------------------------------------------------------------------
-
-// Vertex buffers management
-uint rlLoadVertexArray(); // Load vertex array (vao) if supported
-uint rlLoadVertexBuffer(void* buffer, int size, bool dynamic); // Load a vertex buffer attribute
-uint rlLoadVertexBufferElement(void* buffer, int size, bool dynamic); // Load a new attributes element buffer
-void rlUpdateVertexBuffer(uint bufferId, void* data, int dataSize, int offset); // Update GPU buffer with new data
-void rlUnloadVertexArray(uint vaoId);
-void rlUnloadVertexBuffer(uint vboId);
-void rlSetVertexAttribute(uint index, int compSize, int type, bool normalized, int stride, void* pointer);
-void rlSetVertexAttributeDivisor(uint index, int divisor);
-void rlSetVertexAttributeDefault(int locIndex, const(void)* value, int attribType, int count); // Set vertex attribute default value
-void rlDrawVertexArray(int offset, int count);
-void rlDrawVertexArrayElements(int offset, int count, void* buffer);
-void rlDrawVertexArrayInstanced(int offset, int count, int instances);
-void rlDrawVertexArrayElementsInstanced(int offset, int count, void* buffer, int instances);
-
-// Textures management
-uint rlLoadTexture(void* data, int width, int height, int format, int mipmapCount); // Load texture in GPU
-uint rlLoadTextureDepth(int width, int height, bool useRenderBuffer); // Load depth texture/renderbuffer (to be attached to fbo)
-uint rlLoadTextureCubemap(void* data, int size, int format); // Load texture cubemap
-void rlUpdateTexture(uint id, int offsetX, int offsetY, int width, int height, int format, const(void)* data); // Update GPU texture with new data
-void rlGetGlTextureFormats(int format, int* glInternalFormat, int* glFormat, int* glType); // Get OpenGL internal formats
-const(char)* rlGetPixelFormatName(uint format); // Get name string for pixel format
-void rlUnloadTexture(uint id); // Unload texture from GPU memory
-void rlGenTextureMipmaps(uint id, int width, int height, int format, int* mipmaps); // Generate mipmap data for selected texture
-void* rlReadTexturePixels(uint id, int width, int height, int format); // Read texture pixel data
-ubyte* rlReadScreenPixels(int width, int height); // Read screen pixel data (color buffer)
-
-// Framebuffer management (fbo)
-uint rlLoadFramebuffer(int width, int height); // Load an empty framebuffer
-void rlFramebufferAttach(uint fboId, uint texId, int attachType, int texType, int mipLevel); // Attach texture/renderbuffer to a framebuffer
-bool rlFramebufferComplete(uint id); // Verify framebuffer is complete
-void rlUnloadFramebuffer(uint id); // Delete framebuffer from GPU
-
-// Shaders management
-uint rlLoadShaderCode(const(char)* vsCode, const(char)* fsCode); // Load shader from code strings
-uint rlCompileShader(const(char)* shaderCode, int type); // Compile custom shader and return shader id (type: RL_VERTEX_SHADER, RL_FRAGMENT_SHADER, RL_COMPUTE_SHADER)
-uint rlLoadShaderProgram(uint vShaderId, uint fShaderId); // Load custom shader program
-void rlUnloadShaderProgram(uint id); // Unload shader program
-int rlGetLocationUniform(uint shaderId, const(char)* uniformName); // Get shader location uniform
-int rlGetLocationAttrib(uint shaderId, const(char)* attribName); // Get shader location attribute
-void rlSetUniform(int locIndex, const(void)* value, int uniformType, int count); // Set shader value uniform
-void rlSetUniformMatrix(int locIndex, Matrix mat); // Set shader value matrix
-void rlSetUniformSampler(int locIndex, uint textureId); // Set shader value sampler
-void rlSetShader(uint id, int* locs); // Set shader currently active (id and locations)
-
-// Compute shader management
-uint rlLoadComputeShaderProgram(uint shaderId); // Load compute shader program
-void rlComputeShaderDispatch(uint groupX, uint groupY, uint groupZ); // Dispatch compute shader (equivalent to *draw* for graphics pilepine)
-
-// Shader buffer storage object management (ssbo)
-uint rlLoadShaderBuffer(ulong size, const(void)* data, int usageHint); // Load shader storage buffer object (SSBO)
-void rlUnloadShaderBuffer(uint ssboId); // Unload shader storage buffer object (SSBO)
-void rlUpdateShaderBufferElements(uint id, const(void)* data, ulong dataSize, ulong offset); // Update SSBO buffer data
-ulong rlGetShaderBufferSize(uint id); // Get SSBO buffer size
-void rlReadShaderBufferElements(uint id, void* dest, ulong count, ulong offset); // Bind SSBO buffer
-void rlBindShaderBuffer(uint id, uint index); // Copy SSBO buffer data
-
-// Buffer management
-void rlCopyBuffersElements(uint destId, uint srcId, ulong destOffset, ulong srcOffset, ulong count); // Copy SSBO buffer data
-void rlBindImageTexture(uint id, uint index, uint format, int readonly); // Bind image texture
-
-// Matrix state management
-Matrix rlGetMatrixModelview(); // Get internal modelview matrix
-Matrix rlGetMatrixProjection(); // Get internal projection matrix
-Matrix rlGetMatrixTransform(); // Get internal accumulated transform matrix
-Matrix rlGetMatrixProjectionStereo(int eye); // Get internal projection matrix for stereo render (selected eye)
-Matrix rlGetMatrixViewOffsetStereo(int eye); // Get internal view offset matrix for stereo render (selected eye)
-void rlSetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix)
-void rlSetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix)
-void rlSetMatrixProjectionStereo(Matrix right, Matrix left); // Set eyes projection matrices for stereo rendering
-void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left); // Set eyes view offsets matrices for stereo rendering
-
-// Quick and dirty cube/quad buffers load->draw->unload
-void rlLoadDrawCube(); // Load and draw a cube
-void rlLoadDrawQuad(); // Load and draw a quad
-
-// RLGL_H
-
-/***********************************************************************************
-*
-*   RLGL IMPLEMENTATION
-*
-************************************************************************************/
-
-// OpenGL 1.1 library for OSX
-// OpenGL extensions library
-
-// APIENTRY for OpenGL function pointer declarations is required
-
-// WINGDIAPI definition. Some Windows OpenGL headers need it
-
-// OpenGL 1.1 library
-
-// OpenGL 3 library for OSX
-// OpenGL 3 extensions library for OSX
-
-// GLAD extensions loading library, includes OpenGL headers
-
-//#include <EGL/egl.h>              // EGL library -> not required, platform layer
-// OpenGL ES 2.0 library
-// OpenGL ES 2.0 extensions library
-
-// It seems OpenGL ES 2.0 instancing entry points are not defined on Raspberry Pi
-// provided headers (despite being defined in official Khronos GLES2 headers)
-
-// Required for: malloc(), free()
-// Required for: strcmp(), strlen() [Used in rlglInit(), on extensions loading]
-// Required for: sqrtf(), sinf(), cosf(), floor(), log()
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-
-// Default shader vertex attribute names to set location points
-
-// Binded by default to shader location: 0
-
-// Binded by default to shader location: 1
-
-// Binded by default to shader location: 2
-
-// Binded by default to shader location: 3
-
-// Binded by default to shader location: 4
-
-// Binded by default to shader location: 5
-
-// model-view-projection matrix
-
-// view matrix
-
-// projection matrix
-
-// model matrix
-
-// normal matrix (transpose(inverse(matModelView))
-
-// color diffuse (base tint color, multiplied by texture color)
-
-// texture0 (texture slot active 0)
-
-// texture1 (texture slot active 1)
-
-// texture2 (texture slot active 2)
-
-//----------------------------------------------------------------------------------
-// Types and Structures Definition
-//----------------------------------------------------------------------------------
-
-// Current render batch
-// Default internal render batch
-
-// Current active render batch vertex counter (generic, used for all batches)
-// Current active texture coordinate (added on glVertex*())
-// Current active normal (added on glVertex*())
-// Current active color (added on glVertex*())
-
-// Current matrix mode
-// Current matrix pointer
-// Default modelview matrix
-// Default projection matrix
-// Transform matrix to be used with rlTranslate, rlRotate, rlScale
-// Require transform matrix application to current draw-call vertex (if required)
-// Matrix stack for push/pop
-// Matrix stack counter
-
-// Default texture used on shapes/poly drawing (required by shader)
-// Active texture ids to be enabled on batch drawing (0 active by default)
-// Default vertex shader id (used by default shader program)
-// Default fragment shader id (used by default shader program)
-// Default shader program id, supports vertex color and diffuse texture
-// Default shader locations pointer to be used on rendering
-// Current shader id to be used on rendering (by default, defaultShaderId)
-// Current shader locations pointer to be used on rendering (by default, defaultShaderLocs)
-
-// Stereo rendering flag
-// VR stereo rendering eyes projection matrices
-// VR stereo rendering eyes view offset matrices
-
-// Blending mode active
-// Blending source factor
-// Blending destination factor
-// Blending equation
-
-// Default framebuffer width
-// Default framebuffer height
-
-// Renderer state
-
-// VAO support (OpenGL ES2 could not support VAO extension) (GL_ARB_vertex_array_object)
-// Instancing supported (GL_ANGLE_instanced_arrays, GL_EXT_draw_instanced + GL_EXT_instanced_arrays)
-// NPOT textures full support (GL_ARB_texture_non_power_of_two, GL_OES_texture_npot)
-// Depth textures supported (GL_ARB_depth_texture, GL_WEBGL_depth_texture, GL_OES_depth_texture)
-// float textures support (32 bit per channel) (GL_OES_texture_float)
-// DDS texture compression support (GL_EXT_texture_compression_s3tc, GL_WEBGL_compressed_texture_s3tc, GL_WEBKIT_WEBGL_compressed_texture_s3tc)
-// ETC1 texture compression support (GL_OES_compressed_ETC1_RGB8_texture, GL_WEBGL_compressed_texture_etc1)
-// ETC2/EAC texture compression support (GL_ARB_ES3_compatibility)
-// PVR texture compression support (GL_IMG_texture_compression_pvrtc)
-// ASTC texture compression support (GL_KHR_texture_compression_astc_hdr, GL_KHR_texture_compression_astc_ldr)
-// Clamp mirror wrap mode supported (GL_EXT_texture_mirror_clamp)
-// Anisotropic texture filtering support (GL_EXT_texture_filter_anisotropic)
-// Compute shaders support (GL_ARB_compute_shader)
-// Shader storage buffer object support (GL_ARB_shader_storage_buffer_object)
-
-// Maximum anisotropy level supported (minimum is 2.0f)
-// Maximum bits for depth component
-
-// Extensions supported flags
-
-// OpenGL extension functions loader signature (same as GLADloadproc)
-
-// GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-
-// GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
-
-// NOTE: VAO functionality is exposed through extensions (OES)
-
-// NOTE: Instancing functionality could also be available through extension
-
-//----------------------------------------------------------------------------------
-// Module specific Functions Declaration
-//----------------------------------------------------------------------------------
-
-// Load default shader
-// Unload default shader
-
-// Get compressed format official GL identifier name
-// RLGL_SHOW_GL_DETAILS_INFO
-// GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
-
-// Generate mipmaps data on CPU side
-// Generate next mipmap level on CPU side
-
-// Get pixel data size in bytes (image or texture)
-// Auxiliar matrix math functions
-// Get identity matrix
-// Multiply two matrices
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition - Matrix operations
-//----------------------------------------------------------------------------------
-
-// Fallback to OpenGL 1.1 function calls
-//---------------------------------------
-
-// Choose the current matrix to be transformed
-
-//else if (mode == RL_TEXTURE) // Not supported
-
-// Push the current matrix into RLGL.State.stack
-
-// Pop lattest inserted matrix from RLGL.State.stack
-
-// Reset current matrix to identity matrix
-
-// Multiply the current matrix by a translation matrix
-
-// NOTE: We transpose matrix with multiplication order
-
-// Multiply the current matrix by a rotation matrix
-// NOTE: The provided angle must be in degrees
-
-// Axis vector (x, y, z) normalization
-
-// Rotation matrix generation
-
-// NOTE: We transpose matrix with multiplication order
-
-// Multiply the current matrix by a scaling matrix
-
-// NOTE: We transpose matrix with multiplication order
-
-// Multiply the current matrix by another matrix
-
-// Matrix creation from array
-
-// Multiply the current matrix by a perspective matrix generated by parameters
-
-// Multiply the current matrix by an orthographic matrix generated by parameters
-
-// NOTE: If left-right and top-botton values are equal it could create a division by zero,
-// response to it is platform/compiler dependant
-
-// Set the viewport area (transformation from normalized device coordinates to window coordinates)
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition - Vertex level operations
-//----------------------------------------------------------------------------------
-
-// Fallback to OpenGL 1.1 function calls
-//---------------------------------------
-
-// Initialize drawing mode (how to organize vertex)
-
-// Draw mode can be RL_LINES, RL_TRIANGLES and RL_QUADS
-// NOTE: In all three cases, vertex are accumulated over default internal vertex buffer
-
-// Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4,
-// that way, following QUADS drawing will keep aligned with index processing
-// It implies adding some extra alignment vertex at the end of the draw,
-// those vertex are not processed but they are considered as an additional offset
-// for the next set of vertex to be drawn
-
-// Finish vertex providing
-
-// NOTE: Depth increment is dependant on rlOrtho(): z-near and z-far values,
-// as well as depth buffer bit-depth (16bit or 24bit or 32bit)
-// Correct increment formula would be: depthInc = (zfar - znear)/pow(2, bits)
-
-// Verify internal buffers limits
-// NOTE: This check is combined with usage of rlCheckRenderBatchLimit()
-
-// WARNING: If we are between rlPushMatrix() and rlPopMatrix() and we need to force a rlDrawRenderBatch(),
-// we need to call rlPopMatrix() before to recover *RLGL.State.currentMatrix (RLGL.State.modelview) for the next forced draw call!
-// If we have multiple matrix pushed, it will require "RLGL.State.stackCounter" pops before launching the draw
-
-// Define one vertex (position)
-// NOTE: Vertex position data is the basic information required for drawing
-
-// Transform provided vector if required
-
-// Verify that current vertex buffer elements limit has not been reached
-
-// Add vertices
-
-// Add current texcoord
-
-// TODO: Add current normal
-// By default rlVertexBuffer type does not store normals
-
-// Add current color
-
-// Define one vertex (position)
-
-// Define one vertex (position)
-
-// Define one vertex (texture coordinate)
-// NOTE: Texture coordinates are limited to QUADS only
-
-// Define one vertex (normal)
-// NOTE: Normals limited to TRIANGLES only?
-
-// Define one vertex (color)
-
-// Define one vertex (color)
-
-// Define one vertex (color)
-
-//--------------------------------------------------------------------------------------
-// Module Functions Definition - OpenGL style functions (common to 1.1, 3.3+, ES2)
-//--------------------------------------------------------------------------------------
-
-// Set current texture to use
-
-// NOTE: If quads batch limit is reached, we force a draw call and next batch starts
-
-// Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4,
-// that way, following QUADS drawing will keep aligned with index processing
-// It implies adding some extra alignment vertex at the end of the draw,
-// those vertex are not processed but they are considered as an additional offset
-// for the next set of vertex to be drawn
-
-// Select and active a texture slot
-
-// Enable texture
-
-// Disable texture
-
-// Enable texture cubemap
-
-// Disable texture cubemap
-
-// Set texture parameters (wrap mode/filter mode)
-
-// Enable shader program
-
-// Disable shader program
-
-// Enable rendering to texture (fbo)
-
-// Disable rendering to texture
-
-// Activate multiple draw color buffers
-// NOTE: One color buffer is always active by default
-
-// NOTE: Maximum number of draw buffers supported is implementation dependant,
-// it can be queried with glGet*() but it must be at least 8
-//GLint maxDrawBuffers = 0;
-//glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
-
-//----------------------------------------------------------------------------------
-// General render state configuration
-//----------------------------------------------------------------------------------
-
-// Enable color blending
-
-// Disable color blending
-
-// Enable depth test
-
-// Disable depth test
-
-// Enable depth write
-
-// Disable depth write
-
-// Enable backface culling
-
-// Disable backface culling
-
-// Enable scissor test
-
-// Disable scissor test
-
-// Scissor test
-
-// Enable wire mode
-
-// NOTE: glPolygonMode() not available on OpenGL ES
-
-// Disable wire mode
-
-// NOTE: glPolygonMode() not available on OpenGL ES
-
-// Set the line drawing width
-
-// Get the line drawing width
-
-// Enable line aliasing
-
-// Disable line aliasing
-
-// Enable stereo rendering
-
-// Disable stereo rendering
-
-// Check if stereo render is enabled
-
-// Clear color buffer with color
-
-// Color values clamp to 0.0f(0) and 1.0f(255)
-
-// Clear used screen buffers (color and depth)
-
-// Clear used buffers: Color and Depth (Depth is used for 3D)
-//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);     // Stencil buffer not used...
-
-// Check and log OpenGL error codes
-
-// Set blend mode
-
-// Set blending mode factor and equation
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition - OpenGL Debug
-//----------------------------------------------------------------------------------
-
-// Ignore non-significant error/warning codes (NVidia drivers)
-// NOTE: Here there are the details with a sample output:
-// - #131169 - Framebuffer detailed info: The driver allocated storage for renderbuffer 2. (severity: low)
-// - #131185 - Buffer detailed info: Buffer object 1 (bound to GL_ELEMENT_ARRAY_BUFFER_ARB, usage hint is GL_ENUM_88e4)
-//             will use VIDEO memory as the source for buffer object operations. (severity: low)
-// - #131218 - Program/shader state performance warning: Vertex shader in program 7 is being recompiled based on GL state. (severity: medium)
-// - #131204 - Texture state usage warning: The texture object (0) bound to texture image unit 0 does not have
-//             a defined base level and cannot be used for texture mapping. (severity: low)
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition - rlgl functionality
-//----------------------------------------------------------------------------------
-
-// Initialize rlgl: OpenGL extensions, default buffers/shaders/textures, OpenGL states
-
-// Enable OpenGL debug context if required
-
-// glDebugMessageControl(GL_DEBUG_SOURCE_API, GL_DEBUG_TYPE_ERROR, GL_DEBUG_SEVERITY_HIGH, 0, 0, GL_TRUE); // TODO: Filter message
-
-// Debug context options:
-//  - GL_DEBUG_OUTPUT - Faster version but not useful for breakpoints
-//  - GL_DEBUG_OUTPUT_SYNCHRONUS - Callback is in sync with errors, so a breakpoint can be placed on the callback in order to get a stacktrace for the GL error
-
-// Init default white texture
-// 1 pixel RGBA (4 bytes)
-
-// Init default Shader (customized for GL 3.3 and ES2)
-// Loaded: RLGL.State.defaultShaderId + RLGL.State.defaultShaderLocs
-
-// Init default vertex arrays buffers
-
-// Init stack matrices (emulating OpenGL 1.1)
-
-// Init internal matrices
-
-// GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
-
-// Initialize OpenGL default states
-//----------------------------------------------------------
-// Init state: Depth test
-// Type of depth testing to apply
-// Disable depth testing for 2D (only used for 3D)
-
-// Init state: Blending mode
-// Color blending function (how colors are mixed)
-// Enable color blending (required to work with transparencies)
-
-// Init state: Culling
-// NOTE: All shapes/models triangles are drawn CCW
-// Cull the back face (default)
-// Front face are defined counter clockwise (default)
-// Enable backface culling
-
-// Init state: Cubemap seamless
-
-// Seamless cubemaps (not supported on OpenGL ES 2.0)
-
-// Init state: Color hints (deprecated in OpenGL 3.0+)
-// Improve quality of color and texture coordinate interpolation
-// Smooth shading between vertex (vertex colors interpolation)
-
-// Store screen size into global variables
-
-//----------------------------------------------------------
-
-// Init state: Color/Depth buffers clear
-// Set clear color (black)
-// Set clear depth value (default)
-// Clear color and depth buffers (depth buffer required for 3D)
-
-// Vertex Buffer Object deinitialization (memory free)
-
-// Unload default shader
-
-// Unload default texture
-
-// Load OpenGL extensions
-// NOTE: External loader function must be provided
-
-// Also defined for GRAPHICS_API_OPENGL_21
-// NOTE: glad is generated and contains only required OpenGL 3.3 Core extensions (and lower versions)
-
-// Get number of supported extensions
-
-// Get supported extensions list
-// WARNING: glGetStringi() not available on OpenGL 2.1
-
-// Register supported extensions flags
-// OpenGL 3.3 extensions supported by default (core)
-
-// NOTE: With GLAD, we can check if an extension is supported using the GLAD_GL_xxx booleans
-// Texture compression: DXT
-// Texture compression: ETC2/EAC
-
-// GRAPHICS_API_OPENGL_33
-
-// Get supported extensions list
-
-// Allocate 512 strings pointers (2 KB)
-// One big const string
-
-// NOTE: We have to duplicate string because glGetString() returns a const string
-// Get extensions string size in bytes
-
-// Check required extensions
-
-// Check VAO support
-// NOTE: Only check on OpenGL ES, OpenGL 3.3 has VAO support as core feature
-
-// The extension is supported by our hardware and driver, try to get related functions pointers
-// NOTE: emscripten does not support VAOs natively, it uses emulation and it reduces overall performance...
-
-//glIsVertexArray = (PFNGLISVERTEXARRAYOESPROC)loader("glIsVertexArrayOES");     // NOTE: Fails in WebGL, omitted
-
-// Check instanced rendering support
-// Web ANGLE
-
-// Standard EXT
-
-// Check NPOT textures support
-// NOTE: Only check on OpenGL ES, OpenGL 3.3 has NPOT textures full support as core feature
-
-// Check texture float support
-
-// Check depth texture support
-
-// Check texture compression support: DXT
-
-// Check texture compression support: ETC1
-
-// Check texture compression support: ETC2/EAC
-
-// Check texture compression support: PVR
-
-// Check texture compression support: ASTC
-
-// Check anisotropic texture filter support
-
-// Check clamp mirror wrap mode support
-
-// Free extensions pointers
-
-// Duplicated string must be deallocated
-// GRAPHICS_API_OPENGL_ES2
-
-// Check OpenGL information and capabilities
-//------------------------------------------------------------------------------
-// Show current OpenGL and GLSL version
-
-// NOTE: Anisotropy levels capability is an extension
-
-// Show some OpenGL GPU capabilities
-
-/*
-// Following capabilities are only supported by OpenGL 4.3 or greater
-glGetIntegerv(GL_MAX_VERTEX_ATTRIB_BINDINGS, &capability);
-TRACELOG(RL_LOG_INFO, "    GL_MAX_VERTEX_ATTRIB_BINDINGS: %i", capability);
-glGetIntegerv(GL_MAX_UNIFORM_LOCATIONS, &capability);
-TRACELOG(RL_LOG_INFO, "    GL_MAX_UNIFORM_LOCATIONS: %i", capability);
-*/
-// RLGL_SHOW_GL_DETAILS_INFO
-
-// Show some basic info about GL supported features
-
-// RLGL_SHOW_GL_DETAILS_INFO
-
-// GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
-
-// Get current OpenGL version
-
-// NOTE: Force OpenGL 3.3 on OSX
-
-// Get default framebuffer width
-
-// Get default framebuffer height
-
-// Get default internal texture (white texture)
-// NOTE: Default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8
-
-// Get default shader id
-
-// Get default shader locs
-
-// Render batch management
-//------------------------------------------------------------------------------------------------
-// Load render batch
-
-// Initialize CPU (RAM) vertex buffers (position, texcoord, color data and indexes)
-//--------------------------------------------------------------------------------------------
-
-// 3 float by vertex, 4 vertex by quad
-// 2 float by texcoord, 4 texcoord by quad
-// 4 float by color, 4 colors by quad
-
-// 6 int by quad (indices)
-
-// 6 int by quad (indices)
-
-// Indices can be initialized right now
-
-//--------------------------------------------------------------------------------------------
-
-// Upload to GPU (VRAM) vertex data and initialize VAOs/VBOs
-//--------------------------------------------------------------------------------------------
-
-// Initialize Quads VAO
-
-// Quads - Vertex buffers binding and attributes enable
-// Vertex position buffer (shader-location = 0)
-
-// Vertex texcoord buffer (shader-location = 1)
-
-// Vertex color buffer (shader-location = 3)
-
-// Fill index buffer
-
-// Unbind the current VAO
-
-//--------------------------------------------------------------------------------------------
-
-// Init draw calls tracking system
-//--------------------------------------------------------------------------------------------
-
-//batch.draws[i].vaoId = 0;
-//batch.draws[i].shaderId = 0;
-
-//batch.draws[i].RLGL.State.projection = rlMatrixIdentity();
-//batch.draws[i].RLGL.State.modelview = rlMatrixIdentity();
-
-// Record buffer count
-// Reset draws counter
-// Reset depth value
-//--------------------------------------------------------------------------------------------
-
-// Unload default internal buffers vertex data from CPU and GPU
-
-// Unbind everything
-
-// Unload all vertex buffers data
-
-// Unbind VAO attribs data
-
-// Delete VBOs from GPU (VRAM)
-
-// Delete VAOs from GPU (VRAM)
-
-// Free vertex arrays memory from CPU (RAM)
-
-// Unload arrays
-
-// Draw render batch
-// NOTE: We require a pointer to reset batch and increase current buffer (multi-buffer)
-
-// Update batch vertex buffers
-//------------------------------------------------------------------------------------------------------------
-// NOTE: If there is not vertex data, buffers doesn't need to be updated (vertexCount > 0)
-// TODO: If no data changed on the CPU arrays --> No need to re-update GPU arrays (change flag required)
-
-// Activate elements VAO
-
-// Vertex positions buffer
-
-//glBufferData(GL_ARRAY_BUFFER, sizeof(float)*3*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].vertices, GL_DYNAMIC_DRAW);  // Update all buffer
-
-// Texture coordinates buffer
-
-//glBufferData(GL_ARRAY_BUFFER, sizeof(float)*2*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].texcoords, GL_DYNAMIC_DRAW); // Update all buffer
-
-// Colors buffer
-
-//glBufferData(GL_ARRAY_BUFFER, sizeof(float)*4*4*batch->vertexBuffer[batch->currentBuffer].elementCount, batch->vertexBuffer[batch->currentBuffer].colors, GL_DYNAMIC_DRAW);    // Update all buffer
-
-// NOTE: glMapBuffer() causes sync issue.
-// If GPU is working with this buffer, glMapBuffer() will wait(stall) until GPU to finish its job.
-// To avoid waiting (idle), you can call first glBufferData() with NULL pointer before glMapBuffer().
-// If you do that, the previous data in PBO will be discarded and glMapBuffer() returns a new
-// allocated pointer immediately even if GPU is still working with the previous data.
-
-// Another option: map the buffer object into client's memory
-// Probably this code could be moved somewhere else...
-// batch->vertexBuffer[batch->currentBuffer].vertices = (float *)glMapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
-// if (batch->vertexBuffer[batch->currentBuffer].vertices)
-// {
-// Update vertex data
-// }
-// glUnmapBuffer(GL_ARRAY_BUFFER);
-
-// Unbind the current VAO
-
-//------------------------------------------------------------------------------------------------------------
-
-// Draw batch vertex buffers (considering VR stereo if required)
-//------------------------------------------------------------------------------------------------------------
-
-// Setup current eye viewport (half screen width)
-
-// Set current eye view offset to modelview matrix
-
-// Set current eye projection matrix
-
-// Draw buffers
-
-// Set current shader and upload current MVP matrix
-
-// Create modelview-projection matrix and upload to shader
-
-// Bind vertex attrib: position (shader-location = 0)
-
-// Bind vertex attrib: texcoord (shader-location = 1)
-
-// Bind vertex attrib: color (shader-location = 3)
-
-// Setup some default shader values
-
-// Active default sampler2D: texture0
-
-// Activate additional sampler textures
-// Those additional textures will be common for all draw calls of the batch
-
-// Activate default sampler2D texture0 (one texture is always active for default batch shader)
-// NOTE: Batch system accumulates calls by texture0 changes, additional textures are enabled for all the draw calls
-
-// Bind current draw call texture, activated as GL_TEXTURE0 and binded to sampler2D texture0 by default
-
-// We need to define the number of indices to be processed: elementCount*6
-// NOTE: The final parameter tells the GPU the offset in bytes from the
-// start of the index buffer to the location of the first index to process
-
-// Unbind textures
-
-// Unbind VAO
-
-// Unbind shader program
-
-//------------------------------------------------------------------------------------------------------------
-
-// Reset batch buffers
-//------------------------------------------------------------------------------------------------------------
-// Reset vertex counter for next frame
-
-// Reset depth for next draw
-
-// Restore projection/modelview matrices
-
-// Reset RLGL.currentBatch->draws array
-
-// Reset active texture units for next batch
-
-// Reset draws counter to one draw for the batch
-
-//------------------------------------------------------------------------------------------------------------
-
-// Change to next buffer in the list (in case of multi-buffering)
-
-// Set the active render batch for rlgl
-
-// Update and draw internal render batch
-
-// NOTE: Stereo rendering is checked inside
-
-// Check internal buffer overflow for a given number of vertex
-// and force a rlRenderBatch draw call if required
-
-// NOTE: Stereo rendering is checked inside
-
-// Restore state of last batch so we can continue adding vertices
-
-// Textures data management
-//-----------------------------------------------------------------------------------------
-// Convert image data to OpenGL texture (returns OpenGL valid Id)
-
-// Free any old binding
-
-// Check texture format support by OpenGL 1.1 (compressed textures not supported)
-
-// GRAPHICS_API_OPENGL_11
-
-// Generate texture id
-
-// Mipmap data offset
-
-// Load the different mipmap levels
-
-// Security check for NPOT textures
-
-// Texture parameters configuration
-// NOTE: glTexParameteri does NOT affect texture uploading, just the way it's used
-
-// NOTE: OpenGL ES 2.0 with no GL_OES_texture_npot support (i.e. WebGL) has limited NPOT support, so CLAMP_TO_EDGE must be used
-
-// Set texture to repeat on x-axis
-// Set texture to repeat on y-axis
-
-// NOTE: If using negative texture coordinates (LoadOBJ()), it does not work!
-// Set texture to clamp on x-axis
-// Set texture to clamp on y-axis
-
-// Set texture to repeat on x-axis
-// Set texture to repeat on y-axis
-
-// Magnification and minification filters
-// Alternative: GL_LINEAR
-// Alternative: GL_LINEAR
-
-// Activate Trilinear filtering if mipmaps are available
-
-// At this point we have the texture loaded in GPU and texture parameters configured
-
-// NOTE: If mipmaps were not in data, they are not generated automatically
-
-// Unbind current texture
-
-// Load depth texture/renderbuffer (to be attached to fbo)
-// WARNING: OpenGL ES 2.0 requires GL_OES_depth_texture/WEBGL_depth_texture extensions
-
-// In case depth textures not supported, we force renderbuffer usage
-
-// NOTE: We let the implementation to choose the best bit-depth
-// Possible formats: GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32 and GL_DEPTH_COMPONENT32F
-
-// Create the renderbuffer that will serve as the depth attachment for the framebuffer
-// NOTE: A renderbuffer is simpler than a texture and could offer better performance on embedded devices
-
-// Load texture cubemap
-// NOTE: Cubemap data is expected to be 6 images in a single data array (one after the other),
-// expected the following convention: +X, -X, +Y, -Y, +Z, -Z
-
-// Load cubemap faces
-
-// Instead of using a sized internal texture format (GL_RGB16F, GL_RGB32F), we let the driver to choose the better format for us (GL_RGB)
-
-// Set cubemap texture sampling parameters
-
-// Flag not supported on OpenGL ES 2.0
-
-// Update already loaded texture in GPU with new data
-// NOTE: We don't know safely if internal texture format is the expected one...
-
-// Get OpenGL internal formats and data type from raylib PixelFormat
-
-// NOTE: on OpenGL ES 2.0 (WebGL), internalFormat must match format and options allowed are: GL_LUMINANCE, GL_RGB, GL_RGBA
-
-// NOTE: Requires extension OES_texture_float
-// NOTE: Requires extension OES_texture_float
-// NOTE: Requires extension OES_texture_float
-
-// NOTE: Requires OpenGL ES 2.0 or OpenGL 4.3
-// NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
-// NOTE: Requires OpenGL ES 3.0 or OpenGL 4.3
-// NOTE: Requires PowerVR GPU
-// NOTE: Requires PowerVR GPU
-// NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
-// NOTE: Requires OpenGL ES 3.1 or OpenGL 4.3
-
-// Unload texture from GPU memory
-
-// Generate mipmap data for selected texture
-
-// Check if texture is power-of-two (POT)
-
-// WARNING: Manual mipmap generation only works for RGBA 32bit textures!
-
-// Retrieve texture data from VRAM
-
-// NOTE: Texture data size is reallocated to fit mipmaps data
-// NOTE: CPU mipmap generation only supports RGBA 32bit data
-
-// Load the mipmaps
-
-// Once mipmaps have been generated and data has been uploaded to GPU VRAM, we can discard RAM data
-
-//glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE);   // Hint for mipmaps generation algorythm: GL_FASTEST, GL_NICEST, GL_DONT_CARE
-// Generate mipmaps automatically
-
-// Activate Trilinear filtering for mipmaps
-
-// Read texture pixel data
-
-// NOTE: Using texture id, we can retrieve some texture info (but not on OpenGL ES 2.0)
-// Possible texture info: GL_TEXTURE_RED_SIZE, GL_TEXTURE_GREEN_SIZE, GL_TEXTURE_BLUE_SIZE, GL_TEXTURE_ALPHA_SIZE
-//int width, height, format;
-//glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &width);
-//glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &height);
-//glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &format);
-
-// NOTE: Each row written to or read from by OpenGL pixel operations like glGetTexImage are aligned to a 4 byte boundary by default, which may add some padding.
-// Use glPixelStorei to modify padding with the GL_[UN]PACK_ALIGNMENT setting.
-// GL_PACK_ALIGNMENT affects operations that read from OpenGL memory (glReadPixels, glGetTexImage, etc.)
-// GL_UNPACK_ALIGNMENT affects operations that write to OpenGL memory (glTexImage, etc.)
-
-// glGetTexImage() is not available on OpenGL ES 2.0
-// Texture width and height are required on OpenGL ES 2.0. There is no way to get it from texture id.
-// Two possible Options:
-// 1 - Bind texture to color fbo attachment and glReadPixels()
-// 2 - Create an fbo, activate it, render quad with texture, glReadPixels()
-// We are using Option 1, just need to care for texture format on retrieval
-// NOTE: This behaviour could be conditioned by graphic driver...
-
-// Attach our texture to FBO
-
-// We read data as RGBA because FBO texture is configured as RGBA, despite binding another texture format
-
-// Clean up temporal fbo
-
-// Read screen pixel data (color buffer)
-
-// NOTE 1: glReadPixels returns image flipped vertically -> (0,0) is the bottom left corner of the framebuffer
-// NOTE 2: We are getting alpha channel! Be careful, it can be transparent if not cleared properly!
-
-// Flip image vertically!
-
-// Flip line
-
-// Set alpha component value to 255 (no trasparent image retrieval)
-// NOTE: Alpha value has already been applied to RGB in framebuffer, we don't need it!
-
-// NOTE: image data should be freed
-
-// Framebuffer management (fbo)
-//-----------------------------------------------------------------------------------------
-// Load a framebuffer to be used for rendering
-// NOTE: No textures attached
-
-// Create the framebuffer object
-// Unbind any framebuffer
-
-// Attach color buffer texture to an fbo (unloads previous attachment)
-// NOTE: Attach type: 0-Color, 1-Depth renderbuffer, 2-Depth texture
-
-// Verify render texture is complete
-
-// Unload framebuffer from GPU memory
-// NOTE: All attached textures/cubemaps/renderbuffers are also deleted
-
-// Query depth attachment to automatically delete texture/renderbuffer
-
-// Bind framebuffer to query depth texture type
-
-// NOTE: If a texture object is deleted while its image is attached to the *currently bound* framebuffer,
-// the texture image is automatically detached from the currently bound framebuffer.
-
-// Vertex data management
-//-----------------------------------------------------------------------------------------
-// Load a new attributes buffer
-
-// Load a new attributes element buffer
-
-// Enable vertex buffer (VBO)
-
-// Disable vertex buffer (VBO)
-
-// Enable vertex buffer element (VBO element)
-
-// Disable vertex buffer element (VBO element)
-
-// Update vertex buffer with new data
-// NOTE: dataSize and offset must be provided in bytes
-
-// Update vertex buffer elements with new data
-// NOTE: dataSize and offset must be provided in bytes
-
-// Enable vertex array object (VAO)
-
-// Disable vertex array object (VAO)
-
-// Enable vertex attribute index
-
-// Disable vertex attribute index
-
-// Draw vertex array
-
-// Draw vertex array elements
-
-// Draw vertex array instanced
-
-// Draw vertex array elements instanced
-
-// Enable vertex state pointer
-
-//case GL_INDEX_ARRAY: if (buffer != NULL) glIndexPointer(GL_SHORT, 0, buffer); break; // Indexed colors
-
-// Disable vertex state pointer
-
-// Load vertex array object (VAO)
-
-// Set vertex attribute
-
-// Set vertex attribute divisor
-
-// Unload vertex array object (VAO)
-
-// Unload vertex buffer (VBO)
-
-//TRACELOG(RL_LOG_INFO, "VBO: Unloaded vertex data from VRAM (GPU)");
-
-// Shaders management
-//-----------------------------------------------------------------------------------------------
-// Load shader from code strings
-// NOTE: If shader string is NULL, using default vertex/fragment shaders
-
-// Detach shader before deletion to make sure memory is freed
-
-// Detach shader before deletion to make sure memory is freed
-
-// Get available shader uniforms
-// NOTE: This information is useful for debug...
-
-// Assume no variable names longer than 256
-
-// Get the name of the uniforms
-
-// Compile custom shader and return shader id
-
-//case GL_GEOMETRY_SHADER:
-
-//case GL_GEOMETRY_SHADER:
-
-// Load custom shader strings and return program id
-
-// NOTE: Default attribute shader locations must be binded before linking
-
-// NOTE: If some attrib name is no found on the shader, it locations becomes -1
-
-// NOTE: All uniform variables are intitialised to 0 when a program links
-
-// Get the size of compiled shader program (not available on OpenGL ES 2.0)
-// NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero.
-//GLint binarySize = 0;
-//glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize);
-
-// Unload shader program
-
-// Get shader location uniform
-
-// Get shader location attribute
-
-// Set shader value uniform
-
-// Set shader value attribute
-
-// Set shader value uniform matrix
-
-// Set shader value uniform sampler
-
-// Check if texture is already active
-
-// Register a new active texture for the internal batch system
-// NOTE: Default texture is always activated as GL_TEXTURE0
-
-// Activate new texture unit
-// Save texture id for binding on drawing
-
-// Set shader currently active (id and locations)
-
-// Load compute shader program
-
-// NOTE: All uniform variables are intitialised to 0 when a program links
-
-// Get the size of compiled shader program (not available on OpenGL ES 2.0)
-// NOTE: If GL_LINK_STATUS is GL_FALSE, program binary length is zero.
-//GLint binarySize = 0;
-//glGetProgramiv(id, GL_PROGRAM_BINARY_LENGTH, &binarySize);
-
-// Dispatch compute shader (equivalent to *draw* for graphics pilepine)
-
-// Load shader storage buffer object (SSBO)
-
-// Unload shader storage buffer object (SSBO)
-
-// Update SSBO buffer data
-
-// Get SSBO buffer size
-
-// Read SSBO buffer data
-
-// Bind SSBO buffer
-
-// Copy SSBO buffer data
-
-// Bind image texture
-
-// Matrix state management
-//-----------------------------------------------------------------------------------------
-// Get internal modelview matrix
-
-// Get internal projection matrix
-
-// Get internal accumulated transform matrix
-
-// TODO: Consider possible transform matrices in the RLGL.State.stack
-// Is this the right order? or should we start with the first stored matrix instead of the last one?
-//Matrix matStackTransform = rlMatrixIdentity();
-//for (int i = RLGL.State.stackCounter; i > 0; i--) matStackTransform = rlMatrixMultiply(RLGL.State.stack[i], matStackTransform);
-
-// Get internal projection matrix for stereo render (selected eye)
-
-// Get internal view offset matrix for stereo render (selected eye)
-
-// Set a custom modelview matrix (replaces internal modelview matrix)
-
-// Set a custom projection matrix (replaces internal projection matrix)
-
-// Set eyes projection matrices for stereo rendering
-
-// Set eyes view offsets matrices for stereo rendering
-
-// Load and draw a quad in NDC
-
-// Positions         Texcoords
-
-// Gen VAO to contain VBO
-
-// Gen and fill vertex buffer (VBO)
-
-// Bind vertex attributes (position, texcoords)
-
-// Positions
-
-// Texcoords
-
-// Draw quad
-
-// Delete buffers (VBO and VAO)
-
-// Load and draw a cube in NDC
-
-// Positions          Normals               Texcoords
-
-// Gen VAO to contain VBO
-
-// Gen and fill vertex buffer (VBO)
-
-// Bind vertex attributes (position, normals, texcoords)
-
-// Positions
-
-// Normals
-
-// Texcoords
-
-// Draw cube
-
-// Delete VBO and VAO
-
-// Get name string for pixel format
-
-// 8 bit per pixel (no alpha)
-// 8*2 bpp (2 channels)
-// 16 bpp
-// 24 bpp
-// 16 bpp (1 bit alpha)
-// 16 bpp (4 bit alpha)
-// 32 bpp
-// 32 bpp (1 channel - float)
-// 32*3 bpp (3 channels - float)
-// 32*4 bpp (4 channels - float)
-// 4 bpp (no alpha)
-// 4 bpp (1 bit alpha)
-// 8 bpp
-// 8 bpp
-// 4 bpp
-// 4 bpp
-// 8 bpp
-// 4 bpp
-// 4 bpp
-// 8 bpp
-// 2 bpp
-
-//----------------------------------------------------------------------------------
-// Module specific Functions Definition
-//----------------------------------------------------------------------------------
-
-// Load default shader (just vertex positioning and texture coloring)
-// NOTE: This shader program is used for internal buffers
-// NOTE: Loaded: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs
-
-// NOTE: All locations must be reseted to -1 (no location)
-
-// Vertex shader directly defined, no external file required
-
-// Fragment shader directly defined, no external file required
-
-// Precision required for OpenGL ES2 (WebGL)
-
-// NOTE: Compiled vertex/fragment shaders are kept for re-use
-// Compile default vertex shader
-// Compile default fragment shader
-
-// Set default shader locations: attributes locations
-
-// Set default shader locations: uniform locations
-
-// Unload default shader
-// NOTE: Unloads: RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs
-
-// Get compressed format official GL identifier name
-
-// GL_EXT_texture_compression_s3tc
-
-// GL_3DFX_texture_compression_FXT1
-
-// GL_IMG_texture_compression_pvrtc
-
-// GL_OES_compressed_ETC1_RGB8_texture
-
-// GL_ARB_texture_compression_rgtc
-
-// GL_ARB_texture_compression_bptc
-
-// GL_ARB_ES3_compatibility
-
-// GL_KHR_texture_compression_astc_hdr
-
-// RLGL_SHOW_GL_DETAILS_INFO
-
-// GRAPHICS_API_OPENGL_33 || GRAPHICS_API_OPENGL_ES2
-
-// Mipmaps data is generated after image data
-// NOTE: Only works with RGBA (4 bytes) data!
-
-// Required mipmap levels count (including base level)
-
-// Size in bytes (will include mipmaps...), RGBA only
-
-// Count mipmap levels required
-
-// Add mipmap size (in bytes)
-
-// RGBA: 4 bytes
-
-// Generate mipmaps
-// NOTE: Every mipmap data is stored after data (RGBA - 4 bytes)
-
-// Size of last mipmap
-
-// Mipmap size to store after offset
-
-// Add mipmap to data
-
-// free mipmap data
-
-// Manual mipmap generation (basic scaling algorithm)
-
-// Scaling algorithm works perfectly (box-filter)
-
-// GRAPHICS_API_OPENGL_11
-
-// Get pixel data size in bytes (image or texture)
-// NOTE: Size depends on pixel format
-
-// Size in bytes
-// Bits per pixel
-
-// Total data size in bytes
-
-// Most compressed formats works on 4x4 blocks,
-// if texture is smaller, minimum dataSize is 8 or 16
-
-// Auxiliar math functions
-
-// Get identity matrix
-
-// Get two matrix multiplication
-// NOTE: When multiplying matrices... the order matters!
-
-// RLGL_IMPLEMENTATION
+public import raylib.rlgl;