koffi 2.1.1 → 2.1.3

package/vendor/raylib/examples/textures/textures_draw_tiled.c

@@ -2,10 +2,14 @@
 *
 *   raylib [textures] example - Draw part of the texture tiled
 *
-*   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 4.2
 *
-*   Copyright (c) 2020 Vlad Adrian (@demizdor) and Ramon Santamaria (@raysan5)
+*   Example contributed by Vlad Adrian (@demizdor) and reviewed by 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 Vlad Adrian (@demizdor) and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 #include "raylib.h"
@@ -15,12 +19,15 @@
 #define MARGIN_SIZE       8       // Size for the margins
 #define COLOR_SIZE       16       // Size of the color select buttons
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(int argc, char **argv)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
+    const int screenWidth = 800;
+    const int screenHeight = 450;
 
     SetConfigFlags(FLAG_WINDOW_RESIZABLE); // Make the window resizable
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - Draw part of a texture tiled");
@@ -71,9 +78,6 @@ int main(int argc, char **argv)
     {
         // Update
         //----------------------------------------------------------------------------------
-        screenWidth = GetScreenWidth();
-        screenHeight = GetScreenHeight();
-
         // Handle mouse
         if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT))
         {
@@ -122,11 +126,11 @@ int main(int argc, char **argv)
             ClearBackground(RAYWHITE);
 
             // Draw the tiled area
-            DrawTextureTiled(texPattern, recPattern[activePattern], (Rectangle){(float)OPT_WIDTH+MARGIN_SIZE, (float)MARGIN_SIZE, screenWidth - OPT_WIDTH - 2.0f*MARGIN_SIZE, screenHeight - 2.0f*MARGIN_SIZE},
+            DrawTextureTiled(texPattern, recPattern[activePattern], (Rectangle){(float)OPT_WIDTH+MARGIN_SIZE, (float)MARGIN_SIZE, GetScreenWidth() - OPT_WIDTH - 2.0f*MARGIN_SIZE, GetScreenHeight() - 2.0f*MARGIN_SIZE},
                 (Vector2){0.0f, 0.0f}, rotation, scale, colors[activeCol]);
 
             // Draw options
-            DrawRectangle(MARGIN_SIZE, MARGIN_SIZE, OPT_WIDTH - MARGIN_SIZE, screenHeight - 2*MARGIN_SIZE, ColorAlpha(LIGHTGRAY, 0.5f));
+            DrawRectangle(MARGIN_SIZE, MARGIN_SIZE, OPT_WIDTH - MARGIN_SIZE, GetScreenHeight() - 2*MARGIN_SIZE, ColorAlpha(LIGHTGRAY, 0.5f));
 
             DrawText("Select Pattern", 2 + MARGIN_SIZE, 30 + MARGIN_SIZE, 10, BLACK);
             DrawTexture(texPattern, 2 + MARGIN_SIZE, 40 + MARGIN_SIZE, BLACK);

package/vendor/raylib/examples/textures/textures_fog_of_war.c

@@ -0,0 +1,154 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - Fog of war
+*
+*   Example originally created with raylib 4.2, last time updated with raylib 4.2
+*
+*   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) 2018-2022 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#include <stdlib.h>                 // Required for: calloc(), free()
+
+#define MAP_TILE_SIZE    32         // Tiles size 32x32 pixels
+#define PLAYER_SIZE      16         // Player size
+#define PLAYER_TILE_VISIBILITY  2   // Player can see 2 tiles around its position
+
+// Map data type
+typedef struct Map {
+    unsigned int tilesX;            // Number of tiles in X axis
+    unsigned int tilesY;            // Number of tiles in Y axis
+    unsigned char *tileIds;         // Tile ids (tilesX*tilesY), defines type of tile to draw
+    unsigned char *tileFog;         // Tile fog state (tilesX*tilesY), defines if a tile has fog or half-fog
+} Map;
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main(void)
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - fog of war");
+
+    Map map = { 0 };
+    map.tilesX = 25;
+    map.tilesY = 15;
+
+    // NOTE: We can have up to 256 values for tile ids and for tile fog state,
+    // probably we don't need that many values for fog state, it can be optimized
+    // to use only 2 bits per fog state (reducing size by 4) but logic will be a bit more complex
+    map.tileIds = (unsigned char *)calloc(map.tilesX*map.tilesY, sizeof(unsigned char));
+    map.tileFog = (unsigned char *)calloc(map.tilesX*map.tilesY, sizeof(unsigned char));
+
+    // Load map tiles (generating 2 random tile ids for testing)
+    // NOTE: Map tile ids should be probably loaded from an external map file
+    for (int i = 0; i < map.tilesY*map.tilesX; i++) map.tileIds[i] = GetRandomValue(0, 1);
+
+    // Player position on the screen (pixel coordinates, not tile coordinates)
+    Vector2 playerPosition = { 180, 130 };
+    int playerTileX = 0;
+    int playerTileY = 0;
+
+    // Render texture to render fog of war
+    // NOTE: To get an automatic smooth-fog effect we use a render texture to render fog
+    // at a smaller size (one pixel per tile) and scale it on drawing with bilinear filtering
+    RenderTexture2D fogOfWar = LoadRenderTexture(map.tilesX, map.tilesY);
+    SetTextureFilter(fogOfWar.texture, TEXTURE_FILTER_BILINEAR);
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        // Move player around
+        if (IsKeyDown(KEY_RIGHT)) playerPosition.x += 5;
+        if (IsKeyDown(KEY_LEFT)) playerPosition.x -= 5;
+        if (IsKeyDown(KEY_DOWN)) playerPosition.y += 5;
+        if (IsKeyDown(KEY_UP)) playerPosition.y -= 5;
+
+        // Check player position to avoid moving outside tilemap limits
+        if (playerPosition.x < 0) playerPosition.x = 0;
+        else if ((playerPosition.x + PLAYER_SIZE) > (map.tilesX*MAP_TILE_SIZE)) playerPosition.x = map.tilesX*MAP_TILE_SIZE - PLAYER_SIZE;
+        if (playerPosition.y < 0) playerPosition.y = 0;
+        else if ((playerPosition.y + PLAYER_SIZE) > (map.tilesY*MAP_TILE_SIZE)) playerPosition.y = map.tilesY*MAP_TILE_SIZE - PLAYER_SIZE;
+
+        // Previous visited tiles are set to partial fog
+        for (int i = 0; i < map.tilesX*map.tilesY; i++) if (map.tileFog[i] == 1) map.tileFog[i] = 2;
+
+        // Get current tile position from player pixel position
+        playerTileX = (int)((playerPosition.x + MAP_TILE_SIZE/2)/MAP_TILE_SIZE);
+        playerTileY = (int)((playerPosition.y + MAP_TILE_SIZE/2)/MAP_TILE_SIZE);
+
+        // Check visibility and update fog
+        // NOTE: We check tilemap limits to avoid processing tiles out-of-array-bounds (it could crash program)
+        for (int y = (playerTileY - PLAYER_TILE_VISIBILITY); y < (playerTileY + PLAYER_TILE_VISIBILITY); y++)
+            for (int x = (playerTileX - PLAYER_TILE_VISIBILITY); x < (playerTileX + PLAYER_TILE_VISIBILITY); x++)
+                if ((x >= 0) && (x < map.tilesX) && (y >= 0) && (y < map.tilesY)) map.tileFog[y*map.tilesX + x] = 1;
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        // Draw fog of war to a small render texture for automatic smoothing on scaling
+        BeginTextureMode(fogOfWar);
+            ClearBackground(BLANK);
+            for (int y = 0; y < map.tilesY; y++)
+                for (int x = 0; x < map.tilesX; x++)
+                    if (map.tileFog[y*map.tilesX + x] == 0) DrawRectangle(x, y, 1, 1, BLACK);
+                    else if (map.tileFog[y*map.tilesX + x] == 2) DrawRectangle(x, y, 1, 1, Fade(BLACK, 0.8f));
+        EndTextureMode();
+
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            for (int y = 0; y < map.tilesY; y++)
+            {
+                for (int x = 0; x < map.tilesX; x++)
+                {
+                    // Draw tiles from id (and tile borders)
+                    DrawRectangle(x*MAP_TILE_SIZE, y*MAP_TILE_SIZE, MAP_TILE_SIZE, MAP_TILE_SIZE,
+                                  (map.tileIds[y*map.tilesX + x] == 0)? BLUE : Fade(BLUE, 0.9f));
+                    DrawRectangleLines(x*MAP_TILE_SIZE, y*MAP_TILE_SIZE, MAP_TILE_SIZE, MAP_TILE_SIZE, Fade(DARKBLUE, 0.5f));
+                }
+            }
+
+            // Draw player
+            DrawRectangleV(playerPosition, (Vector2){ PLAYER_SIZE, PLAYER_SIZE }, RED);
+
+
+            // Draw fog of war (scaled to full map, bilinear filtering)
+            DrawTexturePro(fogOfWar.texture, (Rectangle){ 0, 0, fogOfWar.texture.width, -fogOfWar.texture.height },
+                           (Rectangle){ 0, 0, map.tilesX*MAP_TILE_SIZE, map.tilesY*MAP_TILE_SIZE },
+                           (Vector2){ 0, 0 }, 0.0f, WHITE);
+
+            // Draw player current tile
+            DrawText(TextFormat("Current tile: [%i,%i]", playerTileX, playerTileY), 10, 10, 20, LIME);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    free(map.tileIds);      // Free allocated map tile ids
+    free(map.tileFog);      // Free allocated map tile fog state
+
+    UnloadRenderTexture(fogOfWar);  // Unload render texture
+
+    CloseWindow();          // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

package/vendor/raylib/examples/textures/textures_gif_player.c

@@ -0,0 +1,121 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - gif playing
+*
+*   Example originally created with raylib 4.2, last time updated with raylib 4.2
+*
+*   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 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#define MAX_FRAME_DELAY     20
+#define MIN_FRAME_DELAY      1
+
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
+int main(void)
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - gif playing");
+
+    int animFrames = 0;
+
+    // Load all GIF animation frames into a single Image
+    // NOTE: GIF data is always loaded as RGBA (32bit) by default
+    // NOTE: Frames are just appended one after another in image.data memory
+    Image imScarfyAnim = LoadImageAnim("resources/scarfy_run.gif", &animFrames);
+
+    // Load texture from image
+    // NOTE: We will update this texture when required with next frame data
+    // WARNING: It's not recommended to use this technique for sprites animation,
+    // use spritesheets instead, like illustrated in textures_sprite_anim example
+    Texture2D texScarfyAnim = LoadTextureFromImage(imScarfyAnim);
+
+    unsigned int nextFrameDataOffset = 0;  // Current byte offset to next frame in image.data
+
+    int currentAnimFrame = 0;       // Current animation frame to load and draw
+    int frameDelay = 8;             // Frame delay to switch between animation frames
+    int frameCounter = 0;           // General frames counter
+
+    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        frameCounter++;
+        if (frameCounter >= frameDelay)
+        {
+            // Move to next frame
+            // NOTE: If final frame is reached we return to first frame
+            currentAnimFrame++;
+            if (currentAnimFrame >= animFrames) currentAnimFrame = 0;
+
+            // Get memory offset position for next frame data in image.data
+            nextFrameDataOffset = imScarfyAnim.width*imScarfyAnim.height*4*currentAnimFrame;
+
+            // Update GPU texture data with next frame image data
+            // WARNING: Data size (frame size) and pixel format must match already created texture
+            UpdateTexture(texScarfyAnim, ((unsigned char *)imScarfyAnim.data) + nextFrameDataOffset);
+
+            frameCounter = 0;
+        }
+
+        // Control frames delay
+        if (IsKeyPressed(KEY_RIGHT)) frameDelay++;
+        else if (IsKeyPressed(KEY_LEFT)) frameDelay--;
+
+        if (frameDelay > MAX_FRAME_DELAY) frameDelay = MAX_FRAME_DELAY;
+        else if (frameDelay < MIN_FRAME_DELAY) frameDelay = MIN_FRAME_DELAY;
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            DrawText(TextFormat("TOTAL GIF FRAMES:  %02i", animFrames), 50, 30, 20, LIGHTGRAY);
+            DrawText(TextFormat("CURRENT FRAME: %02i", currentAnimFrame), 50, 60, 20, GRAY);
+            DrawText(TextFormat("CURRENT FRAME IMAGE.DATA OFFSET: %02i", nextFrameDataOffset), 50, 90, 20, GRAY);
+
+            DrawText("FRAMES DELAY: ", 100, 305, 10, DARKGRAY);
+            DrawText(TextFormat("%02i frames", frameDelay), 620, 305, 10, DARKGRAY);
+            DrawText("PRESS RIGHT/LEFT KEYS to CHANGE SPEED!", 290, 350, 10, DARKGRAY);
+
+            for (int i = 0; i < MAX_FRAME_DELAY; i++)
+            {
+                if (i < frameDelay) DrawRectangle(190 + 21*i, 300, 20, 20, RED);
+                DrawRectangleLines(190 + 21*i, 300, 20, 20, MAROON);
+            }
+
+            DrawTexture(texScarfyAnim, GetScreenWidth()/2 - texScarfyAnim.width/2, 140, WHITE);
+
+            DrawText("(c) Scarfy sprite by Eiden Marsal", screenWidth - 200, screenHeight - 20, 10, GRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(texScarfyAnim);   // Unload texture
+    UnloadImage(imScarfyAnim);      // Unload image (contains all frames)
+
+    CloseWindow();                  // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

package/vendor/raylib/examples/textures/textures_image_drawing.c

@@ -4,15 +4,20 @@
 *
 *   NOTE: Images are loaded in CPU memory (RAM); textures are loaded in GPU memory (VRAM)
 *
-*   This example has been created using raylib 1.4 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 1.4, last time updated with raylib 1.4
 *
-*   Copyright (c) 2016 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) 2016-2022 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
 #include "raylib.h"
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization

package/vendor/raylib/examples/textures/textures_image_generation.c

@@ -2,10 +2,12 @@
 *
 *   raylib [textures] example - Procedural images generation
 *
-*   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 1.8
 *
-*   Copyright (c) 2O17-2021 Wilhem Barbier (@nounoursheureux) 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) 2O17-2022 Wilhem Barbier (@nounoursheureux) and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -13,6 +15,9 @@
 
 #define NUM_TEXTURES  6      // Currently we have 7 generation algorithms
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization

package/vendor/raylib/examples/textures/textures_image_loading.c

@@ -4,15 +4,20 @@
 *
 *   NOTE: Images are loaded in CPU memory (RAM); textures are loaded in GPU memory (VRAM)
 *
-*   This example has been created using raylib 1.3 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 1.3, last time updated with raylib 1.3
 *
-*   Copyright (c) 2015 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) 2015-2022 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
 #include "raylib.h"
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization

package/vendor/raylib/examples/textures/textures_image_processing.c

@@ -4,10 +4,12 @@
 *
 *   NOTE: Images are loaded in CPU memory (RAM); textures are loaded in GPU memory (VRAM)
 *
-*   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.4, last time updated with raylib 3.5
 *
-*   Copyright (c) 2016 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) 2016-2022 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -39,6 +41,9 @@ static const char *processText[] = {
     "FLIP HORIZONTAL"
 };
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization

package/vendor/raylib/examples/textures/textures_image_text.c

@@ -2,15 +2,20 @@
 *
 *   raylib [texture] example - Image text drawing using TTF generated font
 *
-*   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
 *
-*   Copyright (c) 2017 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)
 *
 ********************************************************************************************/
 
 #include "raylib.h"
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization

package/vendor/raylib/examples/textures/textures_logo_raylib.c

@@ -2,15 +2,20 @@
 *
 *   raylib [textures] example - Texture loading and drawing
 *
-*   This example has been created using raylib 1.0 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 1.0, last time updated with raylib 1.0
 *
-*   Copyright (c) 2014 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) 2014-2022 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
 #include "raylib.h"
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization

package/vendor/raylib/examples/textures/textures_mouse_painting.c

@@ -2,12 +2,14 @@
 *
 *   raylib [textures] example - Mouse painting
 *
-*   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 3.0, last time updated with raylib 3.0
 *
 *   Example contributed by Chris Dill (@MysteriousSpace) and reviewed by Ramon Santamaria (@raysan5)
 *
-*   Copyright (c) 2019 Chris Dill (@MysteriousSpace) 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 Chris Dill (@MysteriousSpace) and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -15,6 +17,9 @@
 
 #define MAX_COLORS_COUNT    23          // Number of colors available
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization
@@ -24,7 +29,7 @@ int main(void)
 
     InitWindow(screenWidth, screenHeight, "raylib [textures] example - mouse painting");
 
-    // Colours to choose from
+    // Colors to choose from
     Color colors[MAX_COLORS_COUNT] = {
         RAYWHITE, YELLOW, GOLD, ORANGE, PINK, RED, MAROON, GREEN, LIME, DARKGREEN,
         SKYBLUE, BLUE, DARKBLUE, PURPLE, VIOLET, DARKPURPLE, BEIGE, BROWN, DARKBROWN,

package/vendor/raylib/examples/textures/textures_npatch_drawing.c

@@ -4,17 +4,22 @@
 *
 *   NOTE: Images are loaded in CPU memory (RAM); textures are loaded in GPU memory (VRAM)
 *
-*   This example has been created using raylib 2.0 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 2.0, last time updated with raylib 2.5
 *
 *   Example contributed by Jorge A. Gomes (@overdev) and reviewed by Ramon Santamaria (@raysan5)
 *
-*   Copyright (c) 2018 Jorge A. Gomes (@overdev) 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) 2018-2022 Jorge A. Gomes (@overdev) and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
 #include "raylib.h"
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization

package/vendor/raylib/examples/textures/textures_particles_blending.c

@@ -2,10 +2,12 @@
 *
 *   raylib example - particles blending
 *
-*   This example has been created using raylib 1.7 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 1.7, last time updated with raylib 3.5
 *
-*   Copyright (c) 2017 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 @@ typedef struct {
     bool active;        // NOTE: Use it to activate/deactive particle
 } Particle;
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization

package/vendor/raylib/examples/textures/textures_polygon.c

@@ -2,13 +2,14 @@
 *
 *   raylib [shapes] example - Draw Textured Polygon
 *
-*   This example has been created using raylib 3.7 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 3.7, last time updated with raylib 3.7
 *
-*   Example contributed by Chris Camacho (@codifies - bedroomcoders.co.uk) and
-*   reviewed by Ramon Santamaria (@raysan5)
+*   Example contributed by Chris Camacho (@codifies) and reviewed by Ramon Santamaria (@raysan5)
 *
-*   Copyright (c) 2021 Chris Camacho (@codifies) 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 Chris Camacho (@codifies) and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -17,6 +18,9 @@
 
 #define MAX_POINTS  11      // 10 points and back to the start
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization

package/vendor/raylib/examples/textures/textures_raw_data.c

@@ -4,10 +4,12 @@
 *
 *   NOTE: Images are loaded in CPU memory (RAM); textures are loaded in GPU memory (VRAM)
 *
-*   This example has been created using raylib 1.3 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*   Example originally created with raylib 1.3, last time updated with raylib 3.5
 *
-*   Copyright (c) 2015 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) 2015-2022 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -15,6 +17,9 @@
 
 #include <stdlib.h>         // Required for: malloc() and free()
 
+//------------------------------------------------------------------------------------
+// Program main entry point
+//------------------------------------------------------------------------------------
 int main(void)
 {
     // Initialization