koffi 0.9.5 → 0.9.8

package/vendor/raylib/examples/shaders/shaders_spotlight.c

@@ -0,0 +1,254 @@
+/*******************************************************************************************
+*
+*   raylib [shaders] example - Simple shader mask
+*
+*   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 contributed by Chris Camacho (@chriscamacho -  http://bedroomcoders.co.uk/)
+*   and reviewed by Ramon Santamaria (@raysan5)
+*
+*   Copyright (c) 2019 Chris Camacho (@chriscamacho) and Ramon Santamaria (@raysan5)
+*
+********************************************************************************************
+*
+*   The shader makes alpha holes in the forground to give the apearance of a top
+*   down look at a spotlight casting a pool of light...
+*
+*   The right hand side of the screen there is just enough light to see whats
+*   going on without the spot light, great for a stealth type game where you
+*   have to avoid the spotlights.
+*
+*   The left hand side of the screen is in pitch dark except for where the spotlights are.
+*
+*   Although this example doesn't scale like the letterbox example, you could integrate
+*   the two techniques, but by scaling the actual colour of the render texture rather
+*   than using alpha as a mask.
+*
+********************************************************************************************/
+
+#include "raylib.h"
+#include "raymath.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#if defined(PLATFORM_DESKTOP)
+    #define GLSL_VERSION            330
+#else   // PLATFORM_RPI, PLATFORM_ANDROID, PLATFORM_WEB
+    #define GLSL_VERSION            100
+#endif
+
+#define MAX_SPOTS         3        // NOTE: It must be the same as define in shader
+#define MAX_STARS       400
+
+// Spot data
+typedef struct {
+    Vector2 pos;
+    Vector2 vel;
+    float inner;
+    float radius;
+
+    // Shader locations
+    unsigned int posLoc;
+    unsigned int innerLoc;
+    unsigned int radiusLoc;
+} Spot;
+
+// Stars in the star field have a position and velocity
+typedef struct Star {
+    Vector2 pos;
+    Vector2 vel;
+} Star;
+
+void UpdateStar(Star *s);
+void ResetStar(Star *s);
+
+int main(void)
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib - shader spotlight");
+    HideCursor();
+
+    Texture texRay = LoadTexture("resources/raysan.png");
+
+    Star stars[MAX_STARS] = { 0 };
+
+    for (int n = 0; n < MAX_STARS; n++) ResetStar(&stars[n]);
+
+    // Progress all the stars on, so they don't all start in the centre
+    for (int m = 0; m < screenWidth/2.0; m++)
+    {
+        for (int n = 0; n < MAX_STARS; n++) UpdateStar(&stars[n]);
+    }
+
+    int frameCounter = 0;
+
+    // Use default vert shader
+    Shader shdrSpot = LoadShader(0, TextFormat("resources/shaders/glsl%i/spotlight.fs", GLSL_VERSION));
+
+    // Get the locations of spots in the shader
+    Spot spots[MAX_SPOTS];
+
+    for (int i = 0; i < MAX_SPOTS; i++)
+    {
+        char posName[32] = "spots[x].pos\0";
+        char innerName[32] = "spots[x].inner\0";
+        char radiusName[32] = "spots[x].radius\0";
+
+        posName[6] = '0' + i;
+        innerName[6] = '0' + i;
+        radiusName[6] = '0' + i;
+
+        spots[i].posLoc = GetShaderLocation(shdrSpot, posName);
+        spots[i].innerLoc = GetShaderLocation(shdrSpot, innerName);
+        spots[i].radiusLoc = GetShaderLocation(shdrSpot, radiusName);
+
+    }
+
+    // Tell the shader how wide the screen is so we can have
+    // a pitch black half and a dimly lit half.
+    unsigned int wLoc = GetShaderLocation(shdrSpot, "screenWidth");
+    float sw = (float)GetScreenWidth();
+    SetShaderValue(shdrSpot, wLoc, &sw, SHADER_UNIFORM_FLOAT);
+
+    // Randomize the locations and velocities of the spotlights
+    // and initialize the shader locations
+    for (int i = 0; i < MAX_SPOTS; i++)
+    {
+        spots[i].pos.x = (float)GetRandomValue(64, screenWidth - 64);
+        spots[i].pos.y = (float)GetRandomValue(64, screenHeight - 64);
+        spots[i].vel = (Vector2){ 0, 0 };
+
+        while ((fabs(spots[i].vel.x) + fabs(spots[i].vel.y)) < 2)
+        {
+            spots[i].vel.x = GetRandomValue(-400, 40) / 10.0f;
+            spots[i].vel.y = GetRandomValue(-400, 40) / 10.0f;
+        }
+
+        spots[i].inner = 28.0f * (i + 1);
+        spots[i].radius = 48.0f * (i + 1);
+
+        SetShaderValue(shdrSpot, spots[i].posLoc, &spots[i].pos.x, SHADER_UNIFORM_VEC2);
+        SetShaderValue(shdrSpot, spots[i].innerLoc, &spots[i].inner, SHADER_UNIFORM_FLOAT);
+        SetShaderValue(shdrSpot, spots[i].radiusLoc, &spots[i].radius, SHADER_UNIFORM_FLOAT);
+    }
+
+    SetTargetFPS(60);               // Set  to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        frameCounter++;
+
+        // Move the stars, resetting them if the go offscreen
+        for (int n = 0; n < MAX_STARS; n++) UpdateStar(&stars[n]);
+
+        // Update the spots, send them to the shader
+        for (int i = 0; i < MAX_SPOTS; i++)
+        {
+            if (i == 0)
+            {
+                Vector2 mp = GetMousePosition();
+                spots[i].pos.x = mp.x;
+                spots[i].pos.y = screenHeight - mp.y;
+            }
+            else
+            {
+                spots[i].pos.x += spots[i].vel.x;
+                spots[i].pos.y += spots[i].vel.y;
+
+                if (spots[i].pos.x < 64) spots[i].vel.x = -spots[i].vel.x;
+                if (spots[i].pos.x > (screenWidth - 64)) spots[i].vel.x = -spots[i].vel.x;
+                if (spots[i].pos.y < 64) spots[i].vel.y = -spots[i].vel.y;
+                if (spots[i].pos.y > (screenHeight - 64)) spots[i].vel.y = -spots[i].vel.y;
+            }
+
+            SetShaderValue(shdrSpot, spots[i].posLoc, &spots[i].pos.x, SHADER_UNIFORM_VEC2);
+        }
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(DARKBLUE);
+
+            // Draw stars and bobs
+            for (int n = 0; n < MAX_STARS; n++)
+            {
+                // Single pixel is just too small these days!
+                DrawRectangle((int)stars[n].pos.x, (int)stars[n].pos.y, 2, 2, WHITE);
+            }
+
+            for (int i = 0; i < 16; i++)
+            {
+                DrawTexture(texRay,
+                    (int)((screenWidth/2.0f) + cos((frameCounter + i*8)/51.45f)*(screenWidth/2.2f) - 32),
+                    (int)((screenHeight/2.0f) + sin((frameCounter + i*8)/17.87f)*(screenHeight/4.2f)), WHITE);
+            }
+
+            // Draw spot lights
+            BeginShaderMode(shdrSpot);
+                // Instead of a blank rectangle you could render here
+                // a render texture of the full screen used to do screen
+                // scaling (slight adjustment to shader would be required
+                // to actually pay attention to the colour!)
+                DrawRectangle(0, 0, screenWidth, screenHeight, WHITE);
+            EndShaderMode();
+
+            DrawFPS(10, 10);
+
+            DrawText("Move the mouse!", 10, 30, 20, GREEN);
+            DrawText("Pitch Black", (int)(screenWidth*0.2f), screenHeight/2, 20, GREEN);
+            DrawText("Dark", (int)(screenWidth*.66f), screenHeight/2, 20, GREEN);
+
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(texRay);
+    UnloadShader(shdrSpot);
+
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+
+void ResetStar(Star *s)
+{
+    s->pos = (Vector2){ GetScreenWidth()/2.0f, GetScreenHeight()/2.0f };
+
+    do
+    {
+        s->vel.x = (float)GetRandomValue(-1000, 1000)/100.0f;
+        s->vel.y = (float)GetRandomValue(-1000, 1000)/100.0f;
+
+    } while (!(fabs(s->vel.x) + (fabs(s->vel.y) > 1)));
+
+    s->pos = Vector2Add(s->pos, Vector2Multiply(s->vel, (Vector2){ 8.0f, 8.0f }));
+}
+
+void UpdateStar(Star *s)
+{
+    s->pos = Vector2Add(s->pos, s->vel);
+
+    if ((s->pos.x < 0) || (s->pos.x > GetScreenWidth()) ||
+        (s->pos.y < 0) || (s->pos.y > GetScreenHeight()))
+    {
+        ResetStar(s);
+    }
+}
+
+

package/vendor/raylib/examples/shaders/shaders_texture_drawing.c

@@ -0,0 +1,80 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - Texture drawing
+*
+*   This example illustrates how to draw on a blank texture using a shader
+*
+*   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 contributed by Michał Ciesielski and reviewed by Ramon Santamaria (@raysan5)
+*
+*   Copyright (c) 2019 Michał Ciesielski and Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#if defined(PLATFORM_DESKTOP)
+    #define GLSL_VERSION            330
+#else   // PLATFORM_RPI, PLATFORM_ANDROID, PLATFORM_WEB
+    #define GLSL_VERSION            100
+#endif
+
+int main(void)
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [shaders] example - texture drawing");
+
+    Image imBlank = GenImageColor(1024, 1024, BLANK);
+    Texture2D texture = LoadTextureFromImage(imBlank);  // Load blank texture to fill on shader
+    UnloadImage(imBlank);
+
+    // NOTE: Using GLSL 330 shader version, on OpenGL ES 2.0 use GLSL 100 shader version
+    Shader shader = LoadShader(0, TextFormat("resources/shaders/glsl%i/cubes_panning.fs", GLSL_VERSION));
+
+    float time = 0.0f;
+    int timeLoc = GetShaderLocation(shader, "uTime");
+    SetShaderValue(shader, timeLoc, &time, SHADER_UNIFORM_FLOAT);
+
+    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
+        //----------------------------------------------------------------------------------
+        time = (float)GetTime();
+        SetShaderValue(shader, timeLoc, &time, SHADER_UNIFORM_FLOAT);
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            BeginShaderMode(shader);    // Enable our custom shader for next shapes/textures drawings
+                DrawTexture(texture, 0, 0, WHITE);  // Drawing BLANK texture, all magic happens on shader
+            EndShaderMode();            // Disable our custom shader, return to default shader
+
+            DrawText("BACKGROUND is PAINTED and ANIMATED on SHADER!", 10, 10, 20, MAROON);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadShader(shader);
+
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

package/vendor/raylib/examples/shaders/shaders_texture_outline.c

@@ -0,0 +1,97 @@
+/*******************************************************************************************
+*
+*   raylib [shaders] example - Apply an shdrOutline to a texture
+*
+*   NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
+*         OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
+*
+*   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 contributed by Samuel Skiff (@GoldenThumbs) and reviewed by Ramon Santamaria (@raysan5)
+*
+*   Copyright (c) 2021 Samuel SKiff (@GoldenThumbs) and Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#if defined(PLATFORM_DESKTOP)
+    #define GLSL_VERSION            330
+#else   // PLATFORM_RPI, PLATFORM_ANDROID, PLATFORM_WEB
+    #define GLSL_VERSION            100
+#endif
+
+int main(void)
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [shaders] example - Apply an outline to a texture");
+
+    Texture2D texture = LoadTexture("resources/fudesumi.png");
+    
+    Shader shdrOutline = LoadShader(0, TextFormat("resources/shaders/glsl%i/outline.fs", GLSL_VERSION));
+
+    float outlineSize = 2.0f;
+    float outlineColor[4] = { 1.0f, 0.0f, 0.0f, 1.0f };     // Normalized RED color 
+    float textureSize[2] = { (float)texture.width, (float)texture.height };
+    
+    // Get shader locations
+    int outlineSizeLoc = GetShaderLocation(shdrOutline, "outlineSize");
+    int outlineColorLoc = GetShaderLocation(shdrOutline, "outlineColor");
+    int textureSizeLoc = GetShaderLocation(shdrOutline, "textureSize");
+    
+    // Set shader values (they can be changed later)
+    SetShaderValue(shdrOutline, outlineSizeLoc, &outlineSize, SHADER_UNIFORM_FLOAT);
+    SetShaderValue(shdrOutline, outlineColorLoc, outlineColor, SHADER_UNIFORM_VEC4);
+    SetShaderValue(shdrOutline, textureSizeLoc, textureSize, SHADER_UNIFORM_VEC2);
+
+    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
+        //----------------------------------------------------------------------------------
+        outlineSize += GetMouseWheelMove();
+        if (outlineSize < 1.0f) outlineSize = 1.0f;
+        
+        SetShaderValue(shdrOutline, outlineSizeLoc, &outlineSize, SHADER_UNIFORM_FLOAT);
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            BeginShaderMode(shdrOutline);
+            
+                DrawTexture(texture, GetScreenWidth()/2 - texture.width/2, -30, WHITE);
+                
+            EndShaderMode();
+
+            DrawText("Shader-based\ntexture\noutline", 10, 10, 20, GRAY);
+            
+            DrawText(TextFormat("Outline size: %i px", (int)outlineSize), 10, 120, 20, MAROON);
+
+            DrawFPS(710, 10);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(texture);
+    UnloadShader(shdrOutline);
+
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

package/vendor/raylib/examples/shaders/shaders_texture_waves.c

@@ -0,0 +1,110 @@
+/*******************************************************************************************
+*
+*   raylib [shaders] example - Texture Waves
+*
+*   NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
+*         OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
+*
+*   NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
+*         on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
+*         raylib comes with shaders ready for both versions, check raylib/shaders install folder
+*
+*   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 contributed by Anata (@anatagawa) and reviewed by Ramon Santamaria (@raysan5)
+*
+*   Copyright (c) 2019 Anata (@anatagawa) and Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#if defined(PLATFORM_DESKTOP)
+    #define GLSL_VERSION            330
+#else   // PLATFORM_RPI, PLATFORM_ANDROID, PLATFORM_WEB
+    #define GLSL_VERSION            100
+#endif
+
+int main(void)
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [shaders] example - texture waves");
+
+    // Load texture texture to apply shaders
+    Texture2D texture = LoadTexture("resources/space.png");
+
+    // Load shader and setup location points and values
+    Shader shader = LoadShader(0, TextFormat("resources/shaders/glsl%i/wave.fs", GLSL_VERSION));
+
+    int secondsLoc = GetShaderLocation(shader, "secondes");
+    int freqXLoc = GetShaderLocation(shader, "freqX");
+    int freqYLoc = GetShaderLocation(shader, "freqY");
+    int ampXLoc = GetShaderLocation(shader, "ampX");
+    int ampYLoc = GetShaderLocation(shader, "ampY");
+    int speedXLoc = GetShaderLocation(shader, "speedX");
+    int speedYLoc = GetShaderLocation(shader, "speedY");
+
+    // Shader uniform values that can be updated at any time
+    float freqX = 25.0f;
+    float freqY = 25.0f;
+    float ampX = 5.0f;
+    float ampY = 5.0f;
+    float speedX = 8.0f;
+    float speedY = 8.0f;
+
+    float screenSize[2] = { (float)GetScreenWidth(), (float)GetScreenHeight() };
+    SetShaderValue(shader, GetShaderLocation(shader, "size"), &screenSize, SHADER_UNIFORM_VEC2);
+    SetShaderValue(shader, freqXLoc, &freqX, SHADER_UNIFORM_FLOAT);
+    SetShaderValue(shader, freqYLoc, &freqY, SHADER_UNIFORM_FLOAT);
+    SetShaderValue(shader, ampXLoc, &ampX, SHADER_UNIFORM_FLOAT);
+    SetShaderValue(shader, ampYLoc, &ampY, SHADER_UNIFORM_FLOAT);
+    SetShaderValue(shader, speedXLoc, &speedX, SHADER_UNIFORM_FLOAT);
+    SetShaderValue(shader, speedYLoc, &speedY, SHADER_UNIFORM_FLOAT);
+
+    float seconds = 0.0f;
+
+    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
+        //----------------------------------------------------------------------------------
+        seconds += GetFrameTime();
+
+        SetShaderValue(shader, secondsLoc, &seconds, SHADER_UNIFORM_FLOAT);
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            BeginShaderMode(shader);
+
+                DrawTexture(texture, 0, 0, WHITE);
+                DrawTexture(texture, texture.width, 0, WHITE);
+
+            EndShaderMode();
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadShader(shader);         // Unload shader
+    UnloadTexture(texture);       // Unload texture
+
+    CloseWindow();              // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

package/vendor/raylib/examples/shapes/shapes_basic_shapes.c

@@ -0,0 +1,78 @@
+/*******************************************************************************************
+*
+*   raylib [shapes] example - Draw basic shapes 2d (rectangle, circle, line...)
+*
+*   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)
+*
+*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main(void)
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [shapes] example - basic shapes drawing");
+
+    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
+        //----------------------------------------------------------------------------------
+        // TODO: Update your variables here
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            DrawText("some basic shapes available on raylib", 20, 20, 20, DARKGRAY);
+
+            // Circle shapes and lines
+            DrawCircle(screenWidth/5, 120, 35, DARKBLUE);
+            DrawCircleGradient(screenWidth/5, 220, 60, GREEN, SKYBLUE);
+            DrawCircleLines(screenWidth/5, 340, 80, DARKBLUE);
+
+            // Rectangle shapes and ines
+            DrawRectangle(screenWidth/4*2 - 60, 100, 120, 60, RED);
+            DrawRectangleGradientH(screenWidth/4*2 - 90, 170, 180, 130, MAROON, GOLD);
+            DrawRectangleLines(screenWidth/4*2 - 40, 320, 80, 60, ORANGE);  // NOTE: Uses QUADS internally, not lines
+
+            // Triangle shapes and lines
+            DrawTriangle((Vector2){screenWidth/4.0f *3.0f, 80.0f},
+                         (Vector2){screenWidth/4.0f *3.0f - 60.0f, 150.0f},
+                         (Vector2){screenWidth/4.0f *3.0f + 60.0f, 150.0f}, VIOLET);
+
+            DrawTriangleLines((Vector2){screenWidth/4.0f*3.0f, 160.0f},
+                              (Vector2){screenWidth/4.0f*3.0f - 20.0f, 230.0f},
+                              (Vector2){screenWidth/4.0f*3.0f + 20.0f, 230.0f}, DARKBLUE);
+
+            // Polygon shapes and lines
+            DrawPoly((Vector2){screenWidth/4.0f*3, 320}, 6, 80, 0, BROWN);
+            DrawPolyLinesEx((Vector2){screenWidth/4.0f*3, 320}, 6, 80, 0, 6, BEIGE);
+
+            // NOTE: We draw all LINES based shapes together to optimize internal drawing,
+            // this way, all LINES are rendered in a single draw pass
+            DrawLine(18, 42, screenWidth - 18, 42, BLACK);
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}