koffi 0.9.6 → 0.9.7

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

@@ -0,0 +1,64 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - Image loading and texture creation
+*
+*   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)
+*
+*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main(void)
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - image loading");
+
+    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+
+    Image image = LoadImage("resources/raylib_logo.png");     // Loaded in CPU memory (RAM)
+    Texture2D texture = LoadTextureFromImage(image);          // Image converted to texture, GPU memory (VRAM)
+    UnloadImage(image);   // Once image has been converted to texture and uploaded to VRAM, it can be unloaded from RAM
+
+    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);
+
+            DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE);
+
+            DrawText("this IS a texture loaded from an image!", 300, 370, 10, GRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(texture);       // Texture unloading
+
+    CloseWindow();                // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

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

@@ -0,0 +1,169 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - Image processing
+*
+*   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)
+*
+*   Copyright (c) 2016 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#include <stdlib.h>             // Required for: free()
+
+#define NUM_PROCESSES    8
+
+typedef enum {
+    NONE = 0,
+    COLOR_GRAYSCALE,
+    COLOR_TINT,
+    COLOR_INVERT,
+    COLOR_CONTRAST,
+    COLOR_BRIGHTNESS,
+    FLIP_VERTICAL,
+    FLIP_HORIZONTAL
+} ImageProcess;
+
+static const char *processText[] = {
+    "NO PROCESSING",
+    "COLOR GRAYSCALE",
+    "COLOR TINT",
+    "COLOR INVERT",
+    "COLOR CONTRAST",
+    "COLOR BRIGHTNESS",
+    "FLIP VERTICAL",
+    "FLIP HORIZONTAL"
+};
+
+int main(void)
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - image processing");
+
+    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+
+    Image imOrigin = LoadImage("resources/parrots.png");   // Loaded in CPU memory (RAM)
+    ImageFormat(&imOrigin, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8);         // Format image to RGBA 32bit (required for texture update) <-- ISSUE
+    Texture2D texture = LoadTextureFromImage(imOrigin);    // Image converted to texture, GPU memory (VRAM)
+
+    Image imCopy = ImageCopy(imOrigin);
+
+    int currentProcess = NONE;
+    bool textureReload = false;
+
+    Rectangle toggleRecs[NUM_PROCESSES] = { 0 };
+    int mouseHoverRec = -1;
+
+    for (int i = 0; i < NUM_PROCESSES; i++) toggleRecs[i] = (Rectangle){ 40.0f, (float)(50 + 32*i), 150.0f, 30.0f };
+
+    SetTargetFPS(60);
+    //---------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+
+        // Mouse toggle group logic
+        for (int i = 0; i < NUM_PROCESSES; i++)
+        {
+            if (CheckCollisionPointRec(GetMousePosition(), toggleRecs[i]))
+            {
+                mouseHoverRec = i;
+
+                if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT))
+                {
+                    currentProcess = i;
+                    textureReload = true;
+                }
+                break;
+            }
+            else mouseHoverRec = -1;
+        }
+
+        // Keyboard toggle group logic
+        if (IsKeyPressed(KEY_DOWN))
+        {
+            currentProcess++;
+            if (currentProcess > (NUM_PROCESSES - 1)) currentProcess = 0;
+            textureReload = true;
+        }
+        else if (IsKeyPressed(KEY_UP))
+        {
+            currentProcess--;
+            if (currentProcess < 0) currentProcess = 7;
+            textureReload = true;
+        }
+
+        // Reload texture when required
+        if (textureReload)
+        {
+            UnloadImage(imCopy);                // Unload image-copy data
+            imCopy = ImageCopy(imOrigin);     // Restore image-copy from image-origin
+
+            // NOTE: Image processing is a costly CPU process to be done every frame,
+            // If image processing is required in a frame-basis, it should be done
+            // with a texture and by shaders
+            switch (currentProcess)
+            {
+                case COLOR_GRAYSCALE: ImageColorGrayscale(&imCopy); break;
+                case COLOR_TINT: ImageColorTint(&imCopy, GREEN); break;
+                case COLOR_INVERT: ImageColorInvert(&imCopy); break;
+                case COLOR_CONTRAST: ImageColorContrast(&imCopy, -40); break;
+                case COLOR_BRIGHTNESS: ImageColorBrightness(&imCopy, -80); break;
+                case FLIP_VERTICAL: ImageFlipVertical(&imCopy); break;
+                case FLIP_HORIZONTAL: ImageFlipHorizontal(&imCopy); break;
+                default: break;
+            }
+
+            Color *pixels = LoadImageColors(imCopy);    // Load pixel data from image (RGBA 32bit)
+            UpdateTexture(texture, pixels);             // Update texture with new image data
+            UnloadImageColors(pixels);                  // Unload pixels data from RAM
+
+            textureReload = false;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            DrawText("IMAGE PROCESSING:", 40, 30, 10, DARKGRAY);
+
+            // Draw rectangles
+            for (int i = 0; i < NUM_PROCESSES; i++)
+            {
+                DrawRectangleRec(toggleRecs[i], ((i == currentProcess) || (i == mouseHoverRec)) ? SKYBLUE : LIGHTGRAY);
+                DrawRectangleLines((int)toggleRecs[i].x, (int) toggleRecs[i].y, (int) toggleRecs[i].width, (int) toggleRecs[i].height, ((i == currentProcess) || (i == mouseHoverRec)) ? BLUE : GRAY);
+                DrawText( processText[i], (int)( toggleRecs[i].x + toggleRecs[i].width/2 - MeasureText(processText[i], 10)/2), (int) toggleRecs[i].y + 11, 10, ((i == currentProcess) || (i == mouseHoverRec)) ? DARKBLUE : DARKGRAY);
+            }
+
+            DrawTexture(texture, screenWidth - texture.width - 60, screenHeight/2 - texture.height/2, WHITE);
+            DrawRectangleLines(screenWidth - texture.width - 60, screenHeight/2 - texture.height/2, texture.width, texture.height, BLACK);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(texture);       // Unload texture from VRAM
+    UnloadImage(imOrigin);        // Unload image-origin from RAM
+    UnloadImage(imCopy);          // Unload image-copy from RAM
+
+    CloseWindow();                // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

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

@@ -0,0 +1,83 @@
+/*******************************************************************************************
+*
+*   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)
+*
+*   Copyright (c) 2017 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main(void)
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [texture] example - image text drawing");
+
+    Image parrots = LoadImage("resources/parrots.png"); // Load image in CPU memory (RAM)
+
+    // TTF Font loading with custom generation parameters
+    Font font = LoadFontEx("resources/KAISG.ttf", 64, 0, 0);
+
+    // Draw over image using custom font
+    ImageDrawTextEx(&parrots, font, "[Parrots font drawing]", (Vector2){ 20.0f, 20.0f }, (float)font.baseSize, 0.0f, RED);
+
+    Texture2D texture = LoadTextureFromImage(parrots);  // Image converted to texture, uploaded to GPU memory (VRAM)
+    UnloadImage(parrots);   // Once image has been converted to texture and uploaded to VRAM, it can be unloaded from RAM
+
+    Vector2 position = { (float)(screenWidth/2 - texture.width/2), (float)(screenHeight/2 - texture.height/2 - 20) };
+
+    bool showFont = false;
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (IsKeyDown(KEY_SPACE)) showFont = true;
+        else showFont = false;
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            if (!showFont)
+            {
+                // Draw texture with text already drawn inside
+                DrawTextureV(texture, position, WHITE);
+
+                // Draw text directly using sprite font
+                DrawTextEx(font, "[Parrots font drawing]", (Vector2){ position.x + 20,
+                           position.y + 20 + 280 }, (float)font.baseSize, 0.0f, WHITE);
+            }
+            else DrawTexture(font.texture, screenWidth/2 - font.texture.width/2, 50, BLACK);
+
+            DrawText("PRESS SPACE to SHOW FONT ATLAS USED", 290, 420, 10, DARKGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(texture);     // Texture unloading
+
+    UnloadFont(font);           // Unload custom font
+
+    CloseWindow();              // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

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

@@ -0,0 +1,57 @@
+/*******************************************************************************************
+*
+*   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)
+*
+*   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 [textures] example - texture loading and drawing");
+
+    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+    Texture2D texture = LoadTexture("resources/raylib_logo.png");        // Texture loading
+    //---------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        // TODO: Update your variables here
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE);
+
+            DrawText("this IS a texture!", 360, 370, 10, GRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(texture);       // Texture unloading
+
+    CloseWindow();                // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

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

@@ -0,0 +1,221 @@
+/*******************************************************************************************
+*
+*   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 contributed by Chris Dill (@MysteriousSpace) and reviewed by Ramon Santamaria (@raysan5)
+*
+*   Copyright (c) 2019 Chris Dill (@MysteriousSpace) and Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#define MAX_COLORS_COUNT    23          // Number of colors available
+
+int main(void)
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - mouse painting");
+
+    // Colours 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,
+        LIGHTGRAY, GRAY, DARKGRAY, BLACK };
+
+    // Define colorsRecs data (for every rectangle)
+    Rectangle colorsRecs[MAX_COLORS_COUNT] = { 0 };
+
+    for (int i = 0; i < MAX_COLORS_COUNT; i++)
+    {
+        colorsRecs[i].x = 10 + 30.0f*i + 2*i;
+        colorsRecs[i].y = 10;
+        colorsRecs[i].width = 30;
+        colorsRecs[i].height = 30;
+    }
+
+    int colorSelected = 0;
+    int colorSelectedPrev = colorSelected;
+    int colorMouseHover = 0;
+    float brushSize = 20.0f;
+    bool mouseWasPressed = false;
+
+    Rectangle btnSaveRec = { 750, 10, 40, 30 };
+    bool btnSaveMouseHover = false;
+    bool showSaveMessage = false;
+    int saveMessageCounter = 0;
+
+    // Create a RenderTexture2D to use as a canvas
+    RenderTexture2D target = LoadRenderTexture(screenWidth, screenHeight);
+
+    // Clear render texture before entering the game loop
+    BeginTextureMode(target);
+    ClearBackground(colors[0]);
+    EndTextureMode();
+
+    SetTargetFPS(120);              // Set our game to run at 120 frames-per-second
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        Vector2 mousePos = GetMousePosition();
+
+        // Move between colors with keys
+        if (IsKeyPressed(KEY_RIGHT)) colorSelected++;
+        else if (IsKeyPressed(KEY_LEFT)) colorSelected--;
+
+        if (colorSelected >= MAX_COLORS_COUNT) colorSelected = MAX_COLORS_COUNT - 1;
+        else if (colorSelected < 0) colorSelected = 0;
+
+        // Choose color with mouse
+        for (int i = 0; i < MAX_COLORS_COUNT; i++)
+        {
+            if (CheckCollisionPointRec(mousePos, colorsRecs[i]))
+            {
+                colorMouseHover = i;
+                break;
+            }
+            else colorMouseHover = -1;
+        }
+
+        if ((colorMouseHover >= 0) && IsMouseButtonPressed(MOUSE_BUTTON_LEFT))
+        {
+            colorSelected = colorMouseHover;
+            colorSelectedPrev = colorSelected;
+        }
+
+        // Change brush size
+        brushSize += GetMouseWheelMove()*5;
+        if (brushSize < 2) brushSize = 2;
+        if (brushSize > 50) brushSize = 50;
+
+        if (IsKeyPressed(KEY_C))
+        {
+            // Clear render texture to clear color
+            BeginTextureMode(target);
+            ClearBackground(colors[0]);
+            EndTextureMode();
+        }
+
+        if (IsMouseButtonDown(MOUSE_BUTTON_LEFT) || (GetGestureDetected() == GESTURE_DRAG))
+        {
+            // Paint circle into render texture
+            // NOTE: To avoid discontinuous circles, we could store
+            // previous-next mouse points and just draw a line using brush size
+            BeginTextureMode(target);
+            if (mousePos.y > 50) DrawCircle((int)mousePos.x, (int)mousePos.y, brushSize, colors[colorSelected]);
+            EndTextureMode();
+        }
+
+        if (IsMouseButtonDown(MOUSE_BUTTON_RIGHT))
+        {
+            if (!mouseWasPressed)
+            {
+                colorSelectedPrev = colorSelected;
+                colorSelected = 0;
+            }
+
+            mouseWasPressed = true;
+
+            // Erase circle from render texture
+            BeginTextureMode(target);
+            if (mousePos.y > 50) DrawCircle((int)mousePos.x, (int)mousePos.y, brushSize, colors[0]);
+            EndTextureMode();
+        }
+        else if (IsMouseButtonReleased(MOUSE_BUTTON_RIGHT) && mouseWasPressed)
+        {
+            colorSelected = colorSelectedPrev;
+            mouseWasPressed = false;
+        }
+
+        // Check mouse hover save button
+        if (CheckCollisionPointRec(mousePos, btnSaveRec)) btnSaveMouseHover = true;
+        else btnSaveMouseHover = false;
+
+        // Image saving logic
+        // NOTE: Saving painted texture to a default named image
+        if ((btnSaveMouseHover && IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) || IsKeyPressed(KEY_S))
+        {
+            Image image = LoadImageFromTexture(target.texture);
+            ImageFlipVertical(&image);
+            ExportImage(image, "my_amazing_texture_painting.png");
+            UnloadImage(image);
+            showSaveMessage = true;
+        }
+
+        if (showSaveMessage)
+        {
+            // On saving, show a full screen message for 2 seconds
+            saveMessageCounter++;
+            if (saveMessageCounter > 240)
+            {
+                showSaveMessage = false;
+                saveMessageCounter = 0;
+            }
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+        ClearBackground(RAYWHITE);
+
+        // NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom)
+        DrawTextureRec(target.texture, (Rectangle) { 0, 0, (float)target.texture.width, (float)-target.texture.height }, (Vector2) { 0, 0 }, WHITE);
+
+        // Draw drawing circle for reference
+        if (mousePos.y > 50)
+        {
+            if (IsMouseButtonDown(MOUSE_BUTTON_RIGHT)) DrawCircleLines((int)mousePos.x, (int)mousePos.y, brushSize, GRAY);
+            else DrawCircle(GetMouseX(), GetMouseY(), brushSize, colors[colorSelected]);
+        }
+
+        // Draw top panel
+        DrawRectangle(0, 0, GetScreenWidth(), 50, RAYWHITE);
+        DrawLine(0, 50, GetScreenWidth(), 50, LIGHTGRAY);
+
+        // Draw color selection rectangles
+        for (int i = 0; i < MAX_COLORS_COUNT; i++) DrawRectangleRec(colorsRecs[i], colors[i]);
+        DrawRectangleLines(10, 10, 30, 30, LIGHTGRAY);
+
+        if (colorMouseHover >= 0) DrawRectangleRec(colorsRecs[colorMouseHover], Fade(WHITE, 0.6f));
+
+        DrawRectangleLinesEx((Rectangle){ colorsRecs[colorSelected].x - 2, colorsRecs[colorSelected].y - 2,
+                             colorsRecs[colorSelected].width + 4, colorsRecs[colorSelected].height + 4 }, 2, BLACK);
+
+        // Draw save image button
+        DrawRectangleLinesEx(btnSaveRec, 2, btnSaveMouseHover ? RED : BLACK);
+        DrawText("SAVE!", 755, 20, 10, btnSaveMouseHover ? RED : BLACK);
+
+        // Draw save image message
+        if (showSaveMessage)
+        {
+            DrawRectangle(0, 0, GetScreenWidth(), GetScreenHeight(), Fade(RAYWHITE, 0.8f));
+            DrawRectangle(0, 150, GetScreenWidth(), 80, BLACK);
+            DrawText("IMAGE SAVED:  my_amazing_texture_painting.png", 150, 180, 20, RAYWHITE);
+        }
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadRenderTexture(target);    // Unload render texture
+
+    CloseWindow();                  // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}