Review examples collection -WIP-

WARNING: Examples list has been reviewed but examples haven't been recompiled yet... that's not trivial...

9 files changed, 628 insertions, 25 deletions

diff --git a/examples/src/textures/textures_background_scrolling.c b/examples/src/textures/textures_background_scrolling.c
new file mode 100644
index 0000000..2be0810
--- /dev/null
+++ b/examples/src/textures/textures_background_scrolling.c
@@ -0,0 +1,87 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - Background scrolling
+*
+*   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)
+*
+*   Copyright (c) 2019 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - background scrolling");
+    
+    // NOTE: Be careful, background width must be equal or bigger than screen width
+    // if not, texture should be draw more than two times for scrolling effect
+    Texture2D background = LoadTexture("resources/cyberpunk_street_background.png");
+    Texture2D midground = LoadTexture("resources/cyberpunk_street_midground.png");
+    Texture2D foreground = LoadTexture("resources/cyberpunk_street_foreground.png");
+    
+    float scrollingBack = 0;
+    float scrollingMid = 0;
+    float scrollingFore = 0;
+    
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        scrollingBack -= 0.1f;
+        scrollingMid -= 0.5f;
+        scrollingFore -= 1.0f;
+        
+        // NOTE: Texture is scaled twice its size, so it sould be considered on scrolling
+        if (scrollingBack <= -background.width*2) scrollingBack = 0;
+        if (scrollingMid <= -midground.width*2) scrollingMid = 0;
+        if (scrollingFore <= -foreground.width*2) scrollingFore = 0;
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(GetColor(0x052c46ff));
+
+            // Draw background image twice
+            // NOTE: Texture is scaled twice its size
+            DrawTextureEx(background, (Vector2){ scrollingBack, 20 }, 0.0f, 2.0f, WHITE);
+            DrawTextureEx(background, (Vector2){ background.width*2 + scrollingBack, 20 }, 0.0f, 2.0f, WHITE);
+            
+            // Draw midground image twice
+            DrawTextureEx(midground, (Vector2){ scrollingMid, 20 }, 0.0f, 2.0f, WHITE);
+            DrawTextureEx(midground, (Vector2){ midground.width*2 + scrollingMid, 20 }, 0.0f, 2.0f, WHITE);
+            
+            // Draw foreground image twice
+            DrawTextureEx(foreground, (Vector2){ scrollingFore, 70 }, 0.0f, 2.0f, WHITE);
+            DrawTextureEx(foreground, (Vector2){ foreground.width*2 + scrollingFore, 70 }, 0.0f, 2.0f, WHITE);
+            
+            DrawText("BACKGROUND SCROLLING & PARALLAX", 10, 10, 20, RED);
+            DrawText("(c) Cyberpunk Street Environment by Luis Zuno (@ansimuz)", screenWidth - 330, screenHeight - 20, 10, RAYWHITE);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(background);  // Unload background texture
+    UnloadTexture(midground);   // Unload midground texture
+    UnloadTexture(foreground);  // Unload foreground texture
+
+    CloseWindow();              // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
\ No newline at end of file
diff --git a/examples/src/textures/textures_bunnymark.c b/examples/src/textures/textures_bunnymark.c
new file mode 100644
index 0000000..7607883
--- /dev/null
+++ b/examples/src/textures/textures_bunnymark.c
@@ -0,0 +1,116 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - Bunnymark
+*
+*   This example has been created using raylib 1.6 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2014-2019 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#include <stdlib.h>                 // Required for: malloc(), free()
+
+#define MAX_BUNNIES       100000    // 100K bunnies limit
+
+// This is the maximum amount of elements (quads) per batch
+// NOTE: This value is defined in [rlgl] module and can be changed there
+#define MAX_BATCH_ELEMENTS  8192
+
+typedef struct Bunny {
+    Vector2 position;
+    Vector2 speed;
+    Color color;
+} Bunny;
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - bunnymark");
+
+    Texture2D texBunny = LoadTexture("resources/wabbit_alpha.png");
+
+    Bunny *bunnies = (Bunny *)malloc(MAX_BUNNIES*sizeof(Bunny));          // Bunnies array
+
+    int bunniesCount = 0;    // Bunnies counter
+
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
+        {
+            // Create more bunnies
+            for (int i = 0; i < 100; i++)
+            {
+                bunnies[bunniesCount].position = GetMousePosition();
+                bunnies[bunniesCount].speed.x = (float)GetRandomValue(-250, 250)/60.0f;
+                bunnies[bunniesCount].speed.y = (float)GetRandomValue(-250, 250)/60.0f;
+                bunnies[bunniesCount].color = (Color){ GetRandomValue(50, 240), 
+                                                       GetRandomValue(80, 240), 
+                                                       GetRandomValue(100, 240), 255 };
+                bunniesCount++;
+            }
+        }
+
+        // Update bunnies
+        for (int i = 0; i < bunniesCount; i++)
+        {
+            bunnies[i].position.x += bunnies[i].speed.x;
+            bunnies[i].position.y += bunnies[i].speed.y;
+
+            if (((bunnies[i].position.x + texBunny.width/2) > GetScreenWidth()) || 
+                ((bunnies[i].position.x + texBunny.width/2) < 0)) bunnies[i].speed.x *= -1;
+            if (((bunnies[i].position.y + texBunny.height/2) > GetScreenHeight()) || 
+                ((bunnies[i].position.y + texBunny.height/2 - 40) < 0)) bunnies[i].speed.y *= -1;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            for (int i = 0; i < bunniesCount; i++)
+            {
+                // NOTE: When internal batch buffer limit is reached (MAX_BATCH_ELEMENTS), 
+                // a draw call is launched and buffer starts being filled again;
+                // before issuing a draw call, updated vertex data from internal CPU buffer is send to GPU... 
+                // Process of sending data is costly and it could happen that GPU data has not been completely
+                // processed for drawing while new data is tried to be sent (updating current in-use buffers)
+                // it could generates a stall and consequently a frame drop, limiting the number of drawn bunnies
+                DrawTexture(texBunny, bunnies[i].position.x, bunnies[i].position.y, bunnies[i].color);
+            }
+
+            DrawRectangle(0, 0, screenWidth, 40, BLACK);
+            DrawText(FormatText("bunnies: %i", bunniesCount), 120, 10, 20, GREEN);
+            DrawText(FormatText("batched draw calls: %i", 1 + bunniesCount/MAX_BATCH_ELEMENTS), 320, 10, 20, MAROON);
+            
+            DrawFPS(10, 10);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    free(bunnies);              // Unload bunnies data array
+    
+    UnloadTexture(texBunny);    // Unload bunny texture
+
+    CloseWindow();              // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
diff --git a/examples/src/textures/textures_image_processing.c b/examples/src/textures/textures_image_processing.c
index 58b746e..6d33d95 100644
--- a/examples/src/textures/textures_image_processing.c
+++ b/examples/src/textures/textures_image_processing.c
@@ -51,7 +51,7 @@ int main()
     // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
 
     Image image = LoadImage("resources/parrots.png");   // Loaded in CPU memory (RAM)
-    ImageFormat(&image, UNCOMPRESSED_R8G8B8A8);         // Format image to RGBA 32bit (required for texture update)
+    ImageFormat(&image, UNCOMPRESSED_R8G8B8A8);         // Format image to RGBA 32bit (required for texture update) <-- ISSUE
     Texture2D texture = LoadTextureFromImage(image);    // Image converted to texture, GPU memory (VRAM)
 
     int currentProcess = NONE;
@@ -59,7 +59,7 @@ int main()
 
     Rectangle selectRecs[NUM_PROCESSES];
     
-    for (int i = 0; i < NUM_PROCESSES; i++) selectRecs[i] = (Rectangle){ 40, 50 + 32*i, 150, 30 };
+    for (int i = 0; i < NUM_PROCESSES; i++) selectRecs[i] = (Rectangle){ 40.0f, (float)(50 + 32*i), 150.0f, 30.0f };
     
     SetTargetFPS(60);
     //---------------------------------------------------------------------------------------
@@ -121,18 +121,9 @@ int main()
             // Draw rectangles
             for (int i = 0; i < NUM_PROCESSES; i++)
             {
-                if (i == currentProcess)
-                {
-                    DrawRectangleRec(selectRecs[i], SKYBLUE);
-                    DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, BLUE);
-                    DrawText(processText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(processText[i], 10)/2, selectRecs[i].y + 11, 10, DARKBLUE);
-                }
-                else
-                {
-                    DrawRectangleRec(selectRecs[i], LIGHTGRAY);
-                    DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, GRAY);
-                    DrawText(processText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(processText[i], 10)/2, selectRecs[i].y + 11, 10, DARKGRAY);
-                }
+                DrawRectangleRec(selectRecs[i], (i == currentProcess) ? SKYBLUE : LIGHTGRAY);
+                DrawRectangleLines((int)selectRecs[i].x, (int) selectRecs[i].y, (int) selectRecs[i].width, (int) selectRecs[i].height, (i == currentProcess) ? BLUE : GRAY);
+                DrawText( processText[i], (int)( selectRecs[i].x + selectRecs[i].width/2 - MeasureText(processText[i], 10)/2), (int) selectRecs[i].y + 11, 10, (i == currentProcess) ? DARKBLUE : DARKGRAY);
             }
 
             DrawTexture(texture, screenWidth - texture.width - 60, screenHeight/2 - texture.height/2, WHITE);
diff --git a/examples/src/textures/textures_image_text.c b/examples/src/textures/textures_image_text.c
new file mode 100644
index 0000000..ce91fbf
--- /dev/null
+++ b/examples/src/textures/textures_image_text.c
@@ -0,0 +1,83 @@
+/*******************************************************************************************
+*
+*   raylib [texture] example - Image text drawing using TTF generated spritefont
+*
+*   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()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [texture] example - image text drawing");
+    
+    // TTF Font loading with custom generation parameters
+    Font font = LoadFontEx("resources/KAISG.ttf", 64, 0, 0);
+    
+    Image parrots = LoadImage("resources/parrots.png"); // Load image in CPU memory (RAM)
+
+    // Draw over image using custom font
+    ImageDrawTextEx(&parrots, (Vector2){ 20.0f, 20.0f }, font, "[Parrots font drawing]", (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 SEE USED SPRITEFONT ", 290, 420, 10, DARKGRAY);
+        
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(texture);     // Texture unloading
+        
+    UnloadFont(font);     // Unload custom spritefont
+    
+    CloseWindow();              // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
\ No newline at end of file
diff --git a/examples/src/textures/textures_npatch_drawing.c b/examples/src/textures/textures_npatch_drawing.c
new file mode 100644
index 0000000..0514efe
--- /dev/null
+++ b/examples/src/textures/textures_npatch_drawing.c
@@ -0,0 +1,109 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - N-patch drawing
+*
+*   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 contributed by Jorge A. Gomes (@overdev) and reviewed by Ramon Santamaria (@raysan5)
+*
+*   Copyright (c) 2018 Jorge A. Gomes (@overdev) and Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - N-patch drawing");
+
+    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+    Texture2D nPatchTexture = LoadTexture("resources/ninepatch_button.png");
+    
+    Vector2 mousePosition = { 0 };
+    Vector2 origin = { 0.0f, 0.0f };
+
+    // Position and size of the n-patches
+    Rectangle dstRec1 = { 480.0f, 160.0f, 32.0f, 32.0f };
+    Rectangle dstRec2 = { 160.0f, 160.0f, 32.0f, 32.0f };
+    Rectangle dstRecH = { 160.0f, 93.0f, 32.0f, 32.0f };
+    Rectangle dstRecV = { 92.0f, 160.0f, 32.0f, 32.0f };
+
+    // A 9-patch (NPT_9PATCH) changes its sizes in both axis
+    NPatchInfo ninePatchInfo1 = { (Rectangle){ 0.0f, 0.0f, 64.0f, 64.0f }, 12, 40, 12, 12, NPT_9PATCH };
+    NPatchInfo ninePatchInfo2 = { (Rectangle){ 0.0f, 128.0f, 64.0f, 64.0f }, 16, 16, 16, 16, NPT_9PATCH };
+    
+    // A horizontal 3-patch (NPT_3PATCH_HORIZONTAL) changes its sizes along the x axis only
+    NPatchInfo h3PatchInfo = { (Rectangle){ 0.0f,  64.0f, 64.0f, 64.0f }, 8, 8, 8, 8, NPT_3PATCH_HORIZONTAL };
+    
+    // A vertical 3-patch (NPT_3PATCH_VERTICAL) changes its sizes along the y axis only
+    NPatchInfo v3PatchInfo = { (Rectangle){ 0.0f, 192.0f, 64.0f, 64.0f }, 6, 6, 6, 6, NPT_3PATCH_VERTICAL };
+    
+    SetTargetFPS(60);
+    //---------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        mousePosition = GetMousePosition();
+        
+        // Resize the n-patches based on mouse position
+        dstRec1.width = mousePosition.x - dstRec1.x;
+        dstRec1.height = mousePosition.y - dstRec1.y;
+        dstRec2.width = mousePosition.x - dstRec2.x;
+        dstRec2.height = mousePosition.y - dstRec2.y;
+        dstRecH.width = mousePosition.x - dstRecH.x;
+        dstRecV.height = mousePosition.y - dstRecV.y;
+
+        // Set a minimum width and/or height
+        if (dstRec1.width < 1.0f) dstRec1.width = 1.0f;
+        if (dstRec1.width > 300.0f) dstRec1.width = 300.0f;
+        if (dstRec1.height < 1.0f) dstRec1.height = 1.0f;
+        if (dstRec2.width < 1.0f) dstRec2.width = 1.0f;
+        if (dstRec2.width > 300.0f) dstRec2.width = 300.0f;
+        if (dstRec2.height < 1.0f) dstRec2.height = 1.0f;
+        if (dstRecH.width < 1.0f) dstRecH.width = 1.0f;
+        if (dstRecV.height < 1.0f) dstRecV.height = 1.0f;
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            // Draw the n-patches
+            DrawTextureNPatch(nPatchTexture, ninePatchInfo2, dstRec2, origin, 0.0f, WHITE);
+            DrawTextureNPatch(nPatchTexture, ninePatchInfo1, dstRec1, origin, 0.0f, WHITE);
+            DrawTextureNPatch(nPatchTexture, h3PatchInfo, dstRecH, origin, 0.0f, WHITE);
+            DrawTextureNPatch(nPatchTexture, v3PatchInfo, dstRecV, origin, 0.0f, WHITE);
+            
+            // Draw the source texture
+            DrawRectangleLines(5, 88, 74, 266, BLUE);
+            DrawTexture(nPatchTexture, 10, 93, WHITE);
+            DrawText("TEXTURE", 15, 360, 10, DARKGRAY);
+
+            DrawText("Move the mouse to stretch or shrink the n-patches", 10, 20, 20, DARKGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(nPatchTexture);       // Texture unloading
+
+    CloseWindow();                // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
diff --git a/examples/src/textures/textures_raw_data.c b/examples/src/textures/textures_raw_data.c
index b038792..481bd66 100644
--- a/examples/src/textures/textures_raw_data.c
+++ b/examples/src/textures/textures_raw_data.c
@@ -32,8 +32,8 @@ int main()
     UnloadImage(fudesumiRaw);                              // Unload CPU (RAM) image data
     
     // Generate a checked texture by code (1024x1024 pixels)
-    int width = 1024;
-    int height = 1024;
+    int width = 960;
+    int height = 480;
     
     // Dynamic memory allocation to store pixels data (Color type)
     Color *pixels = (Color *)malloc(width*height*sizeof(Color));
@@ -42,8 +42,8 @@ int main()
     {
         for (int x = 0; x < width; x++)
         {
-            if (((x/32+y/32)/1)%2 == 0) pixels[y*height + x] = ORANGE;
-            else pixels[y*height + x] = GOLD;
+            if (((x/32+y/32)/1)%2 == 0) pixels[y*width + x] = ORANGE;
+            else pixels[y*width + x] = GOLD;
         }
     }
     
@@ -73,9 +73,9 @@ int main()
             DrawTexture(checked, screenWidth/2 - checked.width/2, screenHeight/2 - checked.height/2, Fade(WHITE, 0.5f));
             DrawTexture(fudesumi, 430, -30, WHITE);
 
-            DrawText("CHECKED TEXTURE ", 84, 100, 30, BROWN);
-            DrawText("GENERATED by CODE", 72, 164, 30, BROWN);
-            DrawText("and RAW IMAGE LOADING", 46, 226, 30, BROWN);
+            DrawText("CHECKED TEXTURE ", 84, 85, 30, BROWN);
+            DrawText("GENERATED by CODE", 72, 148, 30, BROWN);
+            DrawText("and RAW IMAGE LOADING", 46, 210, 30, BROWN);
             
             DrawText("(c) Fudesumi sprite by Eiden Marsal", 310, screenHeight - 20, 10, BROWN);
 
diff --git a/examples/src/textures/textures_sprite_button.c b/examples/src/textures/textures_sprite_button.c
new file mode 100644
index 0000000..bbd5732
--- /dev/null
+++ b/examples/src/textures/textures_sprite_button.c
@@ -0,0 +1,97 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - sprite button
+*
+*   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)
+*
+*   Copyright (c) 2019 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#define NUM_FRAMES  3       // Number of frames (rectangles) for the button sprite texture
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+    
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - sprite button");
+
+    InitAudioDevice();      // Initialize audio device
+    
+    Sound fxButton = LoadSound("resources/buttonfx.wav");   // Load button sound
+    Texture2D button = LoadTexture("resources/button.png"); // Load button texture
+    
+    // Define frame rectangle for drawing
+    int frameHeight = button.height/NUM_FRAMES;
+    Rectangle sourceRec = { 0, 0, button.width, frameHeight };
+    
+    // Define button bounds on screen
+    Rectangle btnBounds = { screenWidth/2 - button.width/2, screenHeight/2 - button.height/NUM_FRAMES/2, button.width, frameHeight };
+    
+    int btnState = 0;               // Button state: 0-NORMAL, 1-MOUSE_HOVER, 2-PRESSED
+    bool btnAction = false;         // Button action should be activated
+    
+    Vector2 mousePoint = { 0.0f, 0.0f };
+    
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        mousePoint = GetMousePosition();
+        btnAction = false;
+        
+        // Check button state
+        if (CheckCollisionPointRec(mousePoint, btnBounds))
+        {
+            if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) btnState = 2;
+            else btnState = 1;
+
+            if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) btnAction = true;
+        }
+        else btnState = 0;
+        
+        if (btnAction)
+        {
+            PlaySound(fxButton);
+            
+            // TODO: Any desired action
+        }
+        
+        // Calculate button frame rectangle to draw depending on button state
+        sourceRec.y = btnState*frameHeight;
+        //----------------------------------------------------------------------------------
+        
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        
+            ClearBackground(RAYWHITE);
+
+            DrawTextureRec(button, sourceRec, (Vector2){ btnBounds.x, btnBounds.y }, WHITE); // Draw button frame
+        
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(button);  // Unload button texture
+    UnloadSound(fxButton);  // Unload sound
+
+    CloseAudioDevice();     // Close audio device
+    
+    CloseWindow();          // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+    
+    return 0;
+}
\ No newline at end of file
diff --git a/examples/src/textures/textures_sprite_explosion.c b/examples/src/textures/textures_sprite_explosion.c
new file mode 100644
index 0000000..aa10a76
--- /dev/null
+++ b/examples/src/textures/textures_sprite_explosion.c
@@ -0,0 +1,120 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - sprite explosion
+*
+*   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)
+*
+*   Copyright (c) 2019 Anata and Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#define NUM_FRAMES  8
+#define NUM_LINES   6
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    const int screenWidth = 800;
+    const int screenHeight = 450;
+    
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - sprite explosion");
+    
+    InitAudioDevice();
+    
+    // Load explosion sound
+    Sound fxBoom = LoadSound("resources/boom.wav");
+    
+    // Load explosion texture
+    Texture2D explosion = LoadTexture("resources/explosion2.png");
+    
+    // Init variables for animation
+    int frameWidth = explosion.width/NUM_FRAMES;    // Sprite one frame rectangle width
+    int frameHeight = explosion.height/NUM_LINES;   // Sprite one frame rectangle height
+    int currentFrame = 0;
+    int currentLine = 0;
+    
+    Rectangle frameRec = { 0, 0, frameWidth, frameHeight };
+    Vector2 position = { 0, 0 };
+    
+    bool active = false;
+    int framesCounter = 0;
+    
+    SetTargetFPS(120);
+    //--------------------------------------------------------------------------------------
+    
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        
+        // Check for mouse button pressed and activate explosion (if not active)
+        if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) && !active)
+        {
+            position = GetMousePosition();
+            active = true;
+            
+            position.x -= frameWidth/2;
+            position.y -= frameHeight/2;
+            
+            PlaySound(fxBoom);
+        }
+        
+        // Compute explosion animation frames
+        if (active)
+        {
+            framesCounter++;
+            
+            if (framesCounter > 2)
+            {
+                currentFrame++;
+                
+                if (currentFrame >= NUM_FRAMES)
+                {
+                    currentFrame = 0;
+                    currentLine++;
+                    
+                    if (currentLine >= NUM_LINES)
+                    {
+                        currentLine = 0;
+                        active = false;
+                    }
+                }
+            
+                framesCounter = 0;
+            }
+        }
+        
+        frameRec.x = frameWidth*currentFrame;
+        frameRec.y = frameHeight*currentLine;
+        //----------------------------------------------------------------------------------
+        
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        
+            ClearBackground(RAYWHITE);
+            
+            // Draw explosion required frame rectangle
+            if (active) DrawTextureRec(explosion, frameRec, position, WHITE);
+        
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(explosion);   // Unload texture
+    UnloadSound(fxBoom);          // Unload sound
+    
+    CloseAudioDevice();
+    
+    CloseWindow();              // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+    
+    return 0;
+}
\ No newline at end of file
diff --git a/examples/src/textures/textures_srcrec_dstrec.c b/examples/src/textures/textures_srcrec_dstrec.c
index cc08eb5..298a0c6 100644
--- a/examples/src/textures/textures_srcrec_dstrec.c
+++ b/examples/src/textures/textures_srcrec_dstrec.c
@@ -27,13 +27,13 @@ int main()
     int frameHeight = scarfy.height;
     
     // NOTE: Source rectangle (part of the texture to use for drawing)
-    Rectangle sourceRec = { 0.0f, 0.0f, (float)frameWidth, (float)frameHeight };
+    Rectangle sourceRec = { 0.0f, 0.0f, frameWidth, frameHeight };
 
     // NOTE: Destination rectangle (screen rectangle where drawing part of texture)
-    Rectangle destRec = { (float)screenWidth/2, (float)screenHeight/2, (float)frameWidth*2, (float)frameHeight*2 };
+    Rectangle destRec = { screenWidth/2, screenHeight/2, frameWidth*2, frameHeight*2 };
 
     // NOTE: Origin of the texture (rotation/scale point), it's relative to destination rectangle size
-    Vector2 origin = { (float)frameWidth, (float)frameHeight };
+    Vector2 origin = { frameWidth, frameHeight };
     
     int rotation = 0;
     
@@ -61,7 +61,7 @@ int main()
             // rotation defines the texture rotation (using origin as rotation point)
             DrawTexturePro(scarfy, sourceRec, destRec, origin, (float)rotation, WHITE);
 
-            DrawLine((int) destRec.x, 0, (int) destRec.x, screenHeight, GRAY);
+            DrawLine((int)destRec.x, 0, (int)destRec.x, screenHeight, GRAY);
             DrawLine(0, (int)destRec.y, screenWidth, (int)destRec.y, GRAY);
             
             DrawText("(c) Scarfy sprite by Eiden Marsal", screenWidth - 200, screenHeight - 20, 10, GRAY);