koffi 2.1.0 → 2.1.2

package/vendor/raylib/examples/models/models_skybox.c

@@ -2,10 +2,12 @@
 *
 *   raylib [models] example - Skybox loading and drawing
 *
-*   This example has been created using raylib 3.5 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 1.8, last time updated with raylib 4.0
 *
-*   Copyright (c) 2017-2020 Ramon Santamaria (@raysan5)
+*   Example 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) 2017-2022 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -23,6 +25,9 @@
 // Generate cubemap (6 faces) from equirectangular (panorama) texture
 static TextureCubemap GenTextureCubemap(Shader shader, Texture2D panorama, int size, int format);
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization
@@ -92,23 +97,22 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
-        UpdateCamera(&camera);              // Update camera
+        UpdateCamera(&camera);
 
         // Load new cubemap texture on drag&drop
         if (IsFileDropped())
         {
-            int count = 0;
-            char **droppedFiles = GetDroppedFiles(&count);
+            FilePathList droppedFiles = LoadDroppedFiles();
 
-            if (count == 1)         // Only support one file dropped
+            if (droppedFiles.count == 1)         // Only support one file dropped
             {
-                if (IsFileExtension(droppedFiles[0], ".png;.jpg;.hdr;.bmp;.tga"))
+                if (IsFileExtension(droppedFiles.paths[0], ".png;.jpg;.hdr;.bmp;.tga"))
                 {
                     // Unload current cubemap texture and load new one
                     UnloadTexture(skybox.materials[0].maps[MATERIAL_MAP_CUBEMAP].texture);
                     if (useHDR)
                     {
-                        Texture2D panorama = LoadTexture(droppedFiles[0]);
+                        Texture2D panorama = LoadTexture(droppedFiles.paths[0]);
 
                         // Generate cubemap from panorama texture
                         skybox.materials[0].maps[MATERIAL_MAP_CUBEMAP].texture = GenTextureCubemap(shdrCubemap, panorama, 1024, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8);
@@ -116,16 +120,16 @@ int main(void)
                     }
                     else
                     {
-                        Image img = LoadImage(droppedFiles[0]);
+                        Image img = LoadImage(droppedFiles.paths[0]);
                         skybox.materials[0].maps[MATERIAL_MAP_CUBEMAP].texture = LoadTextureCubemap(img, CUBEMAP_LAYOUT_AUTO_DETECT);
                         UnloadImage(img);
                     }
 
-                    TextCopy(skyboxFileName, droppedFiles[0]);
+                    TextCopy(skyboxFileName, droppedFiles.paths[0]);
                 }
             }
 
-            ClearDroppedFiles();    // Clear internal buffers
+            UnloadDroppedFiles(droppedFiles);    // Unload filepaths from memory
         }
         //----------------------------------------------------------------------------------
 

package/vendor/raylib/examples/models/models_waving_cubes.c

@@ -2,19 +2,24 @@
 *
 *   raylib [models] example - Waving cubes
 *
-*   This example has been created using raylib 2.5 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 2.5, last time updated with raylib 3.7
 *
 *   Example contributed by Codecat (@codecat) and reviewed by Ramon Santamaria (@raysan5)
 *
-*   Copyright (c) 2019 Codecat (@codecat) and Ramon Santamaria (@raysan5)
+*   Example 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) 2019-2022 Codecat (@codecat) and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
 #include "raylib.h"
 
-#include <math.h>
+#include <math.h>       // Required for: sinf()
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main()
 {
     // Initialization

package/vendor/raylib/examples/models/models_yaw_pitch_roll.c

@@ -2,12 +2,14 @@
 *
 *   raylib [models] example - Plane rotations (yaw, pitch, roll)
 *
-*   This example has been created using raylib 1.8 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 1.8, last time updated with raylib 4.0
 *
 *   Example contributed by Berni (@Berni8k) and reviewed by Ramon Santamaria (@raysan5)
 *
-*   Copyright (c) 2017-2021 Berni (@Berni8k) and Ramon Santamaria (@raysan5)
+*   Example 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) 2017-2022 Berni (@Berni8k) and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -15,6 +17,9 @@
 
 #include "raymath.h"        // Required for: MatrixRotateXYZ()
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization
@@ -58,8 +63,8 @@ int main(void)
         }
 
         // Plane yaw (y-axis) controls
-        if (IsKeyDown(KEY_S)) yaw += 1.0f;
-        else if (IsKeyDown(KEY_A)) yaw -= 1.0f;
+        if (IsKeyDown(KEY_S)) yaw -= 1.0f;
+        else if (IsKeyDown(KEY_A)) yaw += 1.0f;
         else
         {
             if (yaw > 0.0f) yaw -= 0.5f;
@@ -67,8 +72,8 @@ int main(void)
         }
 
         // Plane roll (z-axis) controls
-        if (IsKeyDown(KEY_LEFT)) roll += 1.0f;
-        else if (IsKeyDown(KEY_RIGHT)) roll -= 1.0f;
+        if (IsKeyDown(KEY_LEFT)) roll -= 1.0f;
+        else if (IsKeyDown(KEY_RIGHT)) roll += 1.0f;
         else
         {
             if (roll > 0.0f) roll -= 0.5f;

package/vendor/raylib/examples/models/resources/LICENSE.md

@@ -1,16 +1,15 @@
 | resource             | author      | licence | notes |
 | :------------------- | :---------: | :------ | :---- |
-| models/obj/castle.obj,<br>models/castle_diffuse.png | [Alberto Cano](https://www.artstation.com/albertocano) | [CC-BY-NC](https://creativecommons.org/licenses/by-nc/4.0/legalcode) | - |
-| models/obj/bridge.obj,<br>models/bridge_diffuse.png | [Alberto Cano](https://www.artstation.com/albertocano) | [CC-BY-NC](https://creativecommons.org/licenses/by-nc/4.0/legalcode) | - |
-| models/obj/house.obj,<br>models/house_diffuse.png | [Alberto Cano](https://www.artstation.com/albertocano) | [CC-BY-NC](https://creativecommons.org/licenses/by-nc/4.0/legalcode)  | - |
-| models/obj/market.obj,<br>models/market_diffuse.png | [Alberto Cano](https://www.artstation.com/albertocano) | [CC-BY-NC](https://creativecommons.org/licenses/by-nc/4.0/legalcode)  | - |
-| models/obj/turret.obj,<br>models/turret_diffuse.png | [Alberto Cano](https://www.artstation.com/albertocano) | [CC-BY-NC](https://creativecommons.org/licenses/by-nc/4.0/legalcode) | - |
-| models/obj/well.obj,<br>models/well_diffuse.png | [Alberto Cano](https://www.artstation.com/albertocano) | [CC-BY-NC](https://creativecommons.org/licenses/by-nc/4.0/legalcode) | - |
-| models/obj/cube.obj,<br>models/cube_diffuse.png | [@raysan5](https://github.com/raysan5)    | [CC0](https://creativecommons.org/publicdomain/zero/1.0/) | - |
-| models/obj/plane.gltf,<br>models/gltf/plane/plane.bin,<br>models/gltf/plane/plane_diffuse.png | [GiaHanLam](https://sketchfab.com/GiaHanLam)  | [CC-BY](https://creativecommons.org/licenses/by/4.0/)  | Used by: [`models_yaw_pitch_roll.c`](https://github.com/raysan5/raylib/blob/master/examples/models/models_yaw_pitch_roll.c)
+| models/obj/castle.obj,<br>models/obj/castle_diffuse.png | [Alberto Cano](https://www.artstation.com/albertocano) | [CC-BY-NC](https://creativecommons.org/licenses/by-nc/4.0/legalcode) | - |
+| models/obj/bridge.obj,<br>models/obj/bridge_diffuse.png | [Alberto Cano](https://www.artstation.com/albertocano) | [CC-BY-NC](https://creativecommons.org/licenses/by-nc/4.0/legalcode) | - |
+| models/obj/house.obj,<br>models/obj/house_diffuse.png | [Alberto Cano](https://www.artstation.com/albertocano) | [CC-BY-NC](https://creativecommons.org/licenses/by-nc/4.0/legalcode)  | - |
+| models/obj/market.obj,<br>models/obj/market_diffuse.png | [Alberto Cano](https://www.artstation.com/albertocano) | [CC-BY-NC](https://creativecommons.org/licenses/by-nc/4.0/legalcode)  | - |
+| models/obj/turret.obj,<br>models/obj/turret_diffuse.png | [Alberto Cano](https://www.artstation.com/albertocano) | [CC-BY-NC](https://creativecommons.org/licenses/by-nc/4.0/legalcode) | - |
+| models/obj/well.obj,<br>models/obj/well_diffuse.png | [Alberto Cano](https://www.artstation.com/albertocano) | [CC-BY-NC](https://creativecommons.org/licenses/by-nc/4.0/legalcode) | - |
+| models/obj/cube.obj,<br>models/obj/cube_diffuse.png | [@raysan5](https://github.com/raysan5)    | [CC0](https://creativecommons.org/publicdomain/zero/1.0/) | - |
+| models/obj/plane.obj,<br>models/obj/plane_diffuse.png | [GiaHanLam](https://sketchfab.com/GiaHanLam)  | [CC-BY](https://creativecommons.org/licenses/by/4.0/)  | Used by: [`models_yaw_pitch_roll.c`](https://github.com/raysan5/raylib/blob/master/examples/models/models_yaw_pitch_roll.c)
 | models/iqm/guy.iqm,<br>models/iqm/guyanim.iqm,<br>models/iqm/guytex.png,<br>models/iqm/guy.blend | [@culacant](https://github.com/culacant)  | [CC0](https://creativecommons.org/publicdomain/zero/1.0/) | - |
-| models/iqm/vertex_colored_object.iqm   |  ❔    | ❔     | - |
-| models/gltf/...           | _various_  | Check [LICENSE](https://github.com/raysan5/raylib/blob/master/examples/models/resources/models/gltf/LICENSE) | - |
+| models/gltf/robot.glb,<br>models/gltf/robot.blend | [CC0](https://creativecommons.org/publicdomain/zero/1.0/) | - |
 | models/vox/chr_knight.vox |  ❔         | ❔     | - |
 | models/vox/chr_sword.vox  |  ❔         | ❔     | - |
 | models/vox/monu9.vox   |  ❔            | ❔     | - |

package/vendor/raylib/examples/models/resources/models/gltf/LICENSE

@@ -1,23 +1,2 @@
-Rigged Figure model has been created by Cesium (https://cesium.com/cesiumjs/),
-and licensed as Creative Commons Attribution 4.0 International License.
-
-Box Animated model has been created by Cesium (https://cesium.com/cesiumjs/)
-and is licensed as Creative Commons Attribution 4.0 International License
-
-Avocado model is provided by Microsoft
-and licensed as CC0 Universal Public Domain
-
-Animated Morph Cube model is provided by Microsoft
-and licensed as CC0 Universal Public Domain
-
-Animated Triangle model is licensed as CC0 Universal Public Domain
-
-Gearbox Assy model has been provided by Okino Computer Graphics, using Okino Polytrans Software.
-no license information was provided
-
-Girl model has been provided by Hristo Stamenov (https://thatonegamedev.com/)
-and licensed as CC0 Universal Public Domain
-
-Check for details on CC0: https://creativecommons.org/publicdomain/zero/1.0/
-Check for details on CC4: http://creativecommons.org/licenses/by/4.0/
-GLTF sample models for testing are taken from: https://github.com/KhronosGroup/glTF-Sample-Models/
+robot.glb model by @Quaternius (https://www.patreon.com/quaternius)
+Licensed under CC0 1.0 Universal (CC0 1.0) - Public Domain Dedication (https://creativecommons.org/publicdomain/zero/1.0/)

package/vendor/raylib/examples/others/easings_testbed.c

@@ -2,18 +2,20 @@
 *
 *   raylib [easings] example - Easings Testbed
 *
-*   This example has been created using raylib 2.5 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 2.5, last time updated with raylib 2.5
 *
 *   Example contributed by Juan Miguel López (@flashback-fx) and reviewed by Ramon Santamaria (@raysan5)
 *
-*   Copyright (c) 2019 Juan Miguel López (@flashback-fx ) and Ramon Santamaria (@raysan5)
+*   Example 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) 2019-2022 Juan Miguel López (@flashback-fx ) and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
-#include <raylib.h>
+#include "raylib.h"
 
-#include "easings.h"
+#include "reasings.h"       // Required for easing functions
 
 #define FONT_SIZE         20
 
@@ -56,10 +58,8 @@ enum EasingTypes {
     EASING_NONE = NUM_EASING_TYPES
 };
 
-
 static float NoEase(float t, float b, float c, float d);  // NoEase function declaration, function used when "no easing" is selected for any axis
 
-
 // Easing functions reference data
 static const struct {
     const char *name;
@@ -96,7 +96,9 @@ static const struct {
     [EASING_NONE] = { .name = "None", .func = NoEase },
 };
 
-
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization

package/vendor/raylib/examples/others/embedded_files_loading.c

@@ -2,12 +2,14 @@
 *
 *   raylib [others] example - Embedded files loading (Wave and Image)
 *
-*   This example has been created using raylib 3.0 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 3.0, last time updated with raylib 2.5
 *
 *   Example contributed by Kristian Holmgren (@defutura) and reviewed by Ramon Santamaria (@raysan5)
 *
-*   Copyright (c) 2020 Kristian Holmgren (@defutura) and Ramon Santamaria (@raysan5)
+*   Example 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) 2020-2022 Kristian Holmgren (@defutura) and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -16,6 +18,9 @@
 #include "resources/audio_data.h"   // Wave file exported with ExportWaveAsCode()
 #include "resources/image_data.h"   // Image file exported with ExportImageAsCode()
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization
@@ -82,8 +87,8 @@ int main(void)
 
             DrawTexture(texture, screenWidth/2 - texture.width/2, 40, WHITE);
 
-            DrawText("raylib logo and sound loaded from header files", 65, 320, 20, LIGHTGRAY);
-            DrawText("Press SPACE to PLAY the sound!", 200, 360, 20, LIGHTGRAY);
+            DrawText("raylib logo and sound loaded from header files", 150, 320, 20, LIGHTGRAY);
+            DrawText("Press SPACE to PLAY the sound!", 220, 370, 20, LIGHTGRAY);
 
         EndDrawing();
         //----------------------------------------------------------------------------------

package/vendor/raylib/examples/others/raylib_opengl_interop.c

@@ -2,13 +2,14 @@
 *
 *   raylib [shaders] example - OpenGL point particle system
 *
-*   This example has been created using raylib 3.8 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 3.8, last time updated with raylib 2.5
 *
-*   Example contributed by Stephan Soller (@arkanis -  http://arkanis.de/)
-*   and reviewed by Ramon Santamaria (@raysan5)
+*   Example contributed by Stephan Soller (@arkanis) and reviewed by Ramon Santamaria (@raysan5)
 *
-*   Copyright (c) 2021 Stephan Soller (@arkanis) and Ramon Santamaria (@raysan5)
+*   Example 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) 2021-2022 Stephan Soller (@arkanis) and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************
 *
@@ -49,7 +50,10 @@ typedef struct Particle {
     float period;
 } Particle;
 
-int main()
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------

package/vendor/raylib/{src/extras/easings.h → examples/others/reasings.h}

@@ -1,11 +1,11 @@
 /*******************************************************************************************
 *
-*   raylib easings (header only file)
+*   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.
+*       #define REASINGS_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:
@@ -60,7 +60,7 @@
 *   OF THE POSSIBILITY OF SUCH DAMAGE.
 *   ---------------------------------------------------------------------------------
 *
-*   Copyright (c) 2015 Ramon Santamaria
+*   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.
@@ -79,12 +79,12 @@
 *
 **********************************************************************************************/
 
-#ifndef EASINGS_H
-#define EASINGS_H
+#ifndef REASINGS_H
+#define REASINGS_H
 
-#define EASINGS_STATIC_INLINE     // NOTE: By default, compile functions as static inline
+#define REASINGS_STATIC_INLINE     // NOTE: By default, compile functions as static inline
 
-#if defined(EASINGS_STATIC_INLINE)
+#if defined(REASINGS_STATIC_INLINE)
     #define EASEDEF static inline
 #else
     #define EASEDEF extern
@@ -96,52 +96,52 @@
     #define PI 3.14159265358979323846f //Required as PI is not always defined in math.h
 #endif
 
-#ifdef __cplusplus
+#if defined(__cplusplus)
 extern "C" {            // Prevents name mangling of functions
 #endif
 
 // Linear Easing functions
-EASEDEF float EaseLinearNone(float t, float b, float c, float d) { return (c*t/d + b); }
-EASEDEF float EaseLinearIn(float t, float b, float c, float d) { return (c*t/d + b); }
-EASEDEF float EaseLinearOut(float t, float b, float c, float d) { return (c*t/d + b); }
-EASEDEF float EaseLinearInOut(float t,float b, float c, float d) { return (c*t/d + b); }
+EASEDEF float EaseLinearNone(float t, float b, float c, float d) { return (c*t/d + b); }                            // Ease: Linear
+EASEDEF float EaseLinearIn(float t, float b, float c, float d) { return (c*t/d + b); }                              // Ease: Linear In
+EASEDEF float EaseLinearOut(float t, float b, float c, float d) { return (c*t/d + b); }                             // Ease: Linear Out
+EASEDEF float EaseLinearInOut(float t, float b, float c, float d) { return (c*t/d + b); }                           // Ease: Linear In Out
 
 // Sine Easing functions
-EASEDEF float EaseSineIn(float t, float b, float c, float d) { return (-c*cosf(t/d*(PI/2.0f)) + c + b); }
-EASEDEF float EaseSineOut(float t, float b, float c, float d) { return (c*sinf(t/d*(PI/2.0f)) + b); }
-EASEDEF float EaseSineInOut(float t, float b, float c, float d) { return (-c/2.0f*(cosf(PI*t/d) - 1.0f) + b); }
+EASEDEF float EaseSineIn(float t, float b, float c, float d) { return (-c*cosf(t/d*(PI/2.0f)) + c + b); }            // Ease: Sine In
+EASEDEF float EaseSineOut(float t, float b, float c, float d) { return (c*sinf(t/d*(PI/2.0f)) + b); }                // Ease: Sine Out
+EASEDEF float EaseSineInOut(float t, float b, float c, float d) { return (-c/2.0f*(cosf(PI*t/d) - 1.0f) + b); }      // Ease: Sine Out
 
 // Circular Easing functions
-EASEDEF float EaseCircIn(float t, float b, float c, float d) { t /= d; return (-c*(sqrtf(1.0f - t*t) - 1.0f) + b); }
-EASEDEF float EaseCircOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*sqrtf(1.0f - t*t) + b); }
-EASEDEF float EaseCircInOut(float t, float b, float c, float d)
+EASEDEF float EaseCircIn(float t, float b, float c, float d) { t /= d; return (-c*(sqrtf(1.0f - t*t) - 1.0f) + b); } // Ease: Circular In
+EASEDEF float EaseCircOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*sqrtf(1.0f - t*t) + b); }  // Ease: Circular Out
+EASEDEF float EaseCircInOut(float t, float b, float c, float d)                                                      // Ease: Circular In Out
 {
     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
-EASEDEF float EaseCubicIn(float t, float b, float c, float d) { t /= d; return (c*t*t*t + b); }
-EASEDEF float EaseCubicOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*(t*t*t + 1.0f) + b); }
-EASEDEF float EaseCubicInOut(float t, float b, float c, float d)
+EASEDEF float EaseCubicIn(float t, float b, float c, float d) { t /= d; return (c*t*t*t + b); }                      // Ease: Cubic In
+EASEDEF float EaseCubicOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*(t*t*t + 1.0f) + b); }    // Ease: Cubic Out
+EASEDEF float EaseCubicInOut(float t, float b, float c, float d)                                                     // Ease: Cubic In Out
 {
     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
-EASEDEF float EaseQuadIn(float t, float b, float c, float d) { t /= d; return (c*t*t + b); }
-EASEDEF float EaseQuadOut(float t, float b, float c, float d) { t /= d; return (-c*t*(t - 2.0f) + b); }
-EASEDEF float EaseQuadInOut(float t, float b, float c, float d)
+EASEDEF float EaseQuadIn(float t, float b, float c, float d) { t /= d; return (c*t*t + b); }                         // Ease: Quadratic In
+EASEDEF float EaseQuadOut(float t, float b, float c, float d) { t /= d; return (-c*t*(t - 2.0f) + b); }              // Ease: Quadratic Out
+EASEDEF float EaseQuadInOut(float t, float b, float c, float d)                                                      // Ease: Quadratic In Out
 {
     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
-EASEDEF 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); }
-EASEDEF 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);    }
-EASEDEF float EaseExpoInOut(float t, float b, float c, float d)
+EASEDEF 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); }       // Ease: Exponential In
+EASEDEF 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); } // Ease: Exponential Out
+EASEDEF float EaseExpoInOut(float t, float b, float c, float d)                                                                         // Ease: Exponential In Out
 {
     if (t == 0.0f) return b;
     if (t == d) return (b + c);
@@ -151,21 +151,21 @@ EASEDEF float EaseExpoInOut(float t, float b, float c, float d)
 }
 
 // Back Easing functions
-EASEDEF float EaseBackIn(float t, float b, float c, float d)
+EASEDEF float EaseBackIn(float t, float b, float c, float d) // Ease: Back In
 {
     float s = 1.70158f;
     float postFix = t/=d;
     return (c*(postFix)*t*((s + 1.0f)*t - s) + b);
 }
 
-EASEDEF float EaseBackOut(float t, float b, float c, float d)
+EASEDEF float EaseBackOut(float t, float b, float c, float d) // Ease: Back Out
 {
     float s = 1.70158f;
     t = t/d - 1.0f;
     return (c*(t*t*((s + 1.0f)*t + s) + 1.0f) + b);
 }
 
-EASEDEF float EaseBackInOut(float t, float b, float c, float d)
+EASEDEF float EaseBackInOut(float t, float b, float c, float d) // Ease: Back In Out
 {
     float s = 1.70158f;
     if ((t/=d/2.0f) < 1.0f)
@@ -180,7 +180,7 @@ EASEDEF float EaseBackInOut(float t, float b, float c, float d)
 }
 
 // Bounce Easing functions
-EASEDEF float EaseBounceOut(float t, float b, float c, float d)
+EASEDEF float EaseBounceOut(float t, float b, float c, float d) // Ease: Bounce Out
 {
     if ((t/=d) < (1.0f/2.75f))
     {
@@ -203,15 +203,15 @@ EASEDEF float EaseBounceOut(float t, float b, float c, float d)
     }
 }
 
-EASEDEF float EaseBounceIn(float t, float b, float c, float d) { return (c - EaseBounceOut(d - t, 0.0f, c, d) + b); }
-EASEDEF float EaseBounceInOut(float t, float b, float c, float d)
+EASEDEF float EaseBounceIn(float t, float b, float c, float d) { return (c - EaseBounceOut(d - t, 0.0f, c, d) + b); } // Ease: Bounce In
+EASEDEF float EaseBounceInOut(float t, float b, float c, float d) // Ease: Bounce In Out
 {
     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
-EASEDEF float EaseElasticIn(float t, float b, float c, float d)
+EASEDEF float EaseElasticIn(float t, float b, float c, float d) // Ease: Elastic In
 {
     if (t == 0.0f) return b;
     if ((t/=d) == 1.0f) return (b + c);
@@ -224,7 +224,7 @@ EASEDEF float EaseElasticIn(float t, float b, float c, float d)
     return (-(postFix*sinf((t*d-s)*(2.0f*PI)/p )) + b);
 }
 
-EASEDEF float EaseElasticOut(float t, float b, float c, float d)
+EASEDEF float EaseElasticOut(float t, float b, float c, float d) // Ease: Elastic Out
 {
     if (t == 0.0f) return b;
     if ((t/=d) == 1.0f) return (b + c);
@@ -236,7 +236,7 @@ EASEDEF float EaseElasticOut(float t, float b, float c, float d)
     return (a*powf(2.0f,-10.0f*t)*sinf((t*d-s)*(2.0f*PI)/p) + c + b);
 }
 
-EASEDEF float EaseElasticInOut(float t, float b, float c, float d)
+EASEDEF float EaseElasticInOut(float t, float b, float c, float d) // Ease: Elastic In Out
 {
     if (t == 0.0f) return b;
     if ((t/=d/2.0f) == 2.0f) return (b + c);
@@ -256,8 +256,8 @@ EASEDEF float EaseElasticInOut(float t, float b, float c, float d)
     return (postFix*sinf((t*d-s)*(2.0f*PI)/p)*0.5f + c + b);
 }
 
-#ifdef __cplusplus
+#if defined(__cplusplus)
 }
 #endif
 
-#endif // EASINGS_H
+#endif // REASINGS_H

package/vendor/raylib/examples/others/rlgl_compute_shader.c

@@ -5,12 +5,14 @@
 *   NOTE: This example requires raylib OpenGL 4.3 versions for compute shaders support,
 *         shaders used in this example are #version 430 (OpenGL 4.3)
 *
-*   This example has been created using raylib 4.0 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 4.0, last time updated with raylib 2.5
 *
 *   Example contributed by Teddy Astie (@tsnake41) and reviewed by Ramon Santamaria (@raysan5)
 *
-*   Copyright (c) 2021 Teddy Astie (@tsnake41)
+*   Example 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) 2021-2022 Teddy Astie (@tsnake41)
 *
 ********************************************************************************************/
 
@@ -40,6 +42,9 @@ typedef struct GolUpdateSSBO {
     GolUpdateCmd commands[MAX_BUFFERED_TRANSFERTS];
 } GolUpdateSSBO;
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization
@@ -55,27 +60,25 @@ int main(void)
     unsigned int golLogicProgram = rlLoadComputeShaderProgram(golLogicShader);
     UnloadFileText(golLogicCode);
 
-    // Game of Life logic compute shader
+    // Game of Life logic render shader
     Shader golRenderShader = LoadShader(NULL, "resources/shaders/glsl430/gol_render.glsl");
     int resUniformLoc = GetShaderLocation(golRenderShader, "resolution");
 
-    // Game of Life transfert shader
+    // Game of Life transfert shader (CPU<->GPU download and upload)
     char *golTransfertCode = LoadFileText("resources/shaders/glsl430/gol_transfert.glsl");
     unsigned int golTransfertShader = rlCompileShader(golTransfertCode, RL_COMPUTE_SHADER);
     unsigned int golTransfertProgram = rlLoadComputeShaderProgram(golTransfertShader);
     UnloadFileText(golTransfertCode);
 
-    // SSBOs
+    // Load shader storage buffer object (SSBO), id returned
     unsigned int ssboA = rlLoadShaderBuffer(GOL_WIDTH*GOL_WIDTH*sizeof(unsigned int), NULL, RL_DYNAMIC_COPY);
     unsigned int ssboB = rlLoadShaderBuffer(GOL_WIDTH*GOL_WIDTH*sizeof(unsigned int), NULL, RL_DYNAMIC_COPY);
-
-    struct GolUpdateSSBO transfertBuffer;
-    transfertBuffer.count = 0;
-
-    int transfertSSBO = rlLoadShaderBuffer(sizeof(struct GolUpdateSSBO), NULL, RL_DYNAMIC_COPY);
+    unsigned int ssboTransfert = rlLoadShaderBuffer(sizeof(GolUpdateSSBO), NULL, RL_DYNAMIC_COPY);
+    
+    GolUpdateSSBO transfertBuffer = { 0 };
 
     // Create a white texture of the size of the window to update 
-    // each pixel of the window using the fragment shader
+    // each pixel of the window using the fragment shader: golRenderShader
     Image whiteImage = GenImageColor(GOL_WIDTH, GOL_WIDTH, WHITE);
     Texture whiteTex = LoadTextureFromImage(whiteImage);
     UnloadImage(whiteImage);
@@ -98,18 +101,16 @@ int main(void)
             transfertBuffer.commands[transfertBuffer.count].enabled = IsMouseButtonDown(MOUSE_BUTTON_LEFT);
             transfertBuffer.count++;
         }
-        else if (transfertBuffer.count > 0)
+        else if (transfertBuffer.count > 0)  // Process transfert buffer
         {
-            // Process transfert buffer
-
             // Send SSBO buffer to GPU
-            rlUpdateShaderBufferElements(transfertSSBO, &transfertBuffer, sizeof(struct GolUpdateSSBO), 0);
+            rlUpdateShaderBufferElements(ssboTransfert, &transfertBuffer, sizeof(GolUpdateSSBO), 0);
             
-            // Process ssbo command
+            // Process ssbo commands on GPU
             rlEnableShader(golTransfertProgram);
             rlBindShaderBuffer(ssboA, 1);
-            rlBindShaderBuffer(transfertSSBO, 3);
-            rlComputeShaderDispatch(transfertBuffer.count, 1, 1); // each GPU unit will process a command
+            rlBindShaderBuffer(ssboTransfert, 3);
+            rlComputeShaderDispatch(transfertBuffer.count, 1, 1); // Each GPU unit will process a command!
             rlDisableShader();
 
             transfertBuffer.count = 0;
@@ -157,7 +158,7 @@ int main(void)
     // Unload shader buffers objects.
     rlUnloadShaderBuffer(ssboA);
     rlUnloadShaderBuffer(ssboB);
-    rlUnloadShaderBuffer(transfertSSBO);
+    rlUnloadShaderBuffer(ssboTransfert);
 
     // Unload compute shader programs
     rlUnloadShaderProgram(golTransfertProgram);