Reorganize examples folder

examples/textures/textures_formats_loading.c

@@ -0,0 +1,244 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - texture formats loading (compressed and uncompressed)
+*
+*   NOTE: This example requires raylib OpenGL 3.3+ or ES2 versions for compressed textures,
+*         OpenGL 1.1 does not support compressed textures, only uncompressed ones.
+*
+*   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"
+
+#define NUM_TEXTURES    24
+
+typedef enum { 
+    PNG_R8G8B8A8 = 0, 
+    PVR_GRAYSCALE, 
+    PVR_GRAY_ALPHA, 
+    PVR_R5G6B5, 
+    PVR_R5G5B5A1, 
+    PVR_R4G4B4A4,
+    DDS_R5G6B5,
+    DDS_R5G5B5A1,
+    DDS_R4G4B4A4,
+    DDS_R8G8B8A8,
+    DDS_DXT1_RGB,
+    DDS_DXT1_RGBA,
+    DDS_DXT3_RGBA,
+    DDS_DXT5_RGBA,
+    PKM_ETC1_RGB,
+    PKM_ETC2_RGB,
+    PKM_ETC2_EAC_RGBA,
+    KTX_ETC1_RGB,
+    KTX_ETC2_RGB,
+    KTX_ETC2_EAC_RGBA,
+    ASTC_4x4_LDR,
+    ASTC_8x8_LDR,
+    PVR_PVRT_RGB,
+    PVR_PVRT_RGBA
+    
+} TextureFormats;
+
+static const char *formatText[] = {
+    "PNG_R8G8B8A8",
+    "PVR_GRAYSCALE",
+    "PVR_GRAY_ALPHA",
+    "PVR_R5G6B5",
+    "PVR_R5G5B5A1",
+    "PVR_R4G4B4A4",
+    "DDS_R5G6B5",
+    "DDS_R5G5B5A1",
+    "DDS_R4G4B4A4",
+    "DDS_R8G8B8A8",
+    "DDS_DXT1_RGB",
+    "DDS_DXT1_RGBA",
+    "DDS_DXT3_RGBA",
+    "DDS_DXT5_RGBA",
+    "PKM_ETC1_RGB",
+    "PKM_ETC2_RGB",
+    "PKM_ETC2_EAC_RGBA",
+    "KTX_ETC1_RGB",
+    "KTX_ETC2_RGB",
+    "KTX_ETC2_EAC_RGBA",
+    "ASTC_4x4_LDR",
+    "ASTC_8x8_LDR",
+    "PVR_PVRT_RGB",
+    "PVR_PVRT_RGBA"
+};
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture formats loading");
+    
+    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+    
+    Texture2D sonic[NUM_TEXTURES];
+
+    sonic[PNG_R8G8B8A8] = LoadTexture("resources/texture_formats/sonic.png");
+    
+    // Load UNCOMPRESSED PVR texture data
+    sonic[PVR_GRAYSCALE] = LoadTexture("resources/texture_formats/sonic_GRAYSCALE.pvr");
+    sonic[PVR_GRAY_ALPHA] = LoadTexture("resources/texture_formats/sonic_L8A8.pvr");
+    sonic[PVR_R5G6B5] = LoadTexture("resources/texture_formats/sonic_R5G6B5.pvr");
+    sonic[PVR_R5G5B5A1] = LoadTexture("resources/texture_formats/sonic_R5G5B5A1.pvr");
+    sonic[PVR_R4G4B4A4] = LoadTexture("resources/texture_formats/sonic_R4G4B4A4.pvr");
+    
+    // Load UNCOMPRESSED DDS texture data
+    sonic[DDS_R5G6B5] = LoadTexture("resources/texture_formats/sonic_R5G6B5.dds");
+    sonic[DDS_R5G5B5A1] = LoadTexture("resources/texture_formats/sonic_A1R5G5B5.dds");
+    sonic[DDS_R4G4B4A4] = LoadTexture("resources/texture_formats/sonic_A4R4G4B4.dds");
+    sonic[DDS_R8G8B8A8] = LoadTexture("resources/texture_formats/sonic_A8R8G8B8.dds");
+   
+    // Load COMPRESSED DXT DDS texture data (if supported)
+    sonic[DDS_DXT1_RGB] = LoadTexture("resources/texture_formats/sonic_DXT1_RGB.dds");
+    sonic[DDS_DXT1_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT1_RGBA.dds");
+    sonic[DDS_DXT3_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT3_RGBA.dds");
+    sonic[DDS_DXT5_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT5_RGBA.dds");
+    
+    // Load COMPRESSED ETC texture data (if supported)
+    sonic[PKM_ETC1_RGB] = LoadTexture("resources/texture_formats/sonic_ETC1_RGB.pkm");
+    sonic[PKM_ETC2_RGB] = LoadTexture("resources/texture_formats/sonic_ETC2_RGB.pkm");
+    sonic[PKM_ETC2_EAC_RGBA] = LoadTexture("resources/texture_formats/sonic_ETC2_EAC_RGBA.pkm");
+    
+    sonic[KTX_ETC1_RGB] = LoadTexture("resources/texture_formats/sonic_ETC1_RGB.ktx");
+    sonic[KTX_ETC2_RGB] = LoadTexture("resources/texture_formats/sonic_ETC2_RGB.ktx");
+    sonic[KTX_ETC2_EAC_RGBA] = LoadTexture("resources/texture_formats/sonic_ETC2_EAC_RGBA.ktx");
+    
+    // Load COMPRESSED ASTC texture data (if supported)
+    sonic[ASTC_4x4_LDR] = LoadTexture("resources/texture_formats/sonic_ASTC_4x4_ldr.astc");
+    sonic[ASTC_8x8_LDR] = LoadTexture("resources/texture_formats/sonic_ASTC_8x8_ldr.astc");
+
+    // Load COMPRESSED PVR texture data (if supported)
+    sonic[PVR_PVRT_RGB] = LoadTexture("resources/texture_formats/sonic_PVRT_RGB.pvr");
+    sonic[PVR_PVRT_RGBA] = LoadTexture("resources/texture_formats/sonic_PVRT_RGBA.pvr");
+    
+    int selectedFormat = PNG_R8G8B8A8;
+    
+    Rectangle selectRecs[NUM_TEXTURES];
+    
+    for (int i = 0; i < NUM_TEXTURES; i++)
+    {
+        if (i < NUM_TEXTURES/2) selectRecs[i] = (Rectangle){ 40, 30 + 32*i, 150, 30 };
+        else selectRecs[i] = (Rectangle){ 40 + 152, 30 + 32*(i - NUM_TEXTURES/2), 150, 30 };
+    }
+    
+    // Texture sizes in KB
+    float textureSizes[NUM_TEXTURES] = { 
+        512*512*32/8/1024,      //PNG_R8G8B8A8 (32 bpp)
+        512*512*8/8/1024,       //PVR_GRAYSCALE (8 bpp)
+        512*512*16/8/1024,      //PVR_GRAY_ALPHA (16 bpp) 
+        512*512*16/8/1024,      //PVR_R5G6B5 (16 bpp)
+        512*512*16/8/1024,      //PVR_R5G5B5A1 (16 bpp) 
+        512*512*16/8/1024,      //PVR_R4G4B4A4 (16 bpp)
+        512*512*16/8/1024,      //DDS_R5G6B5 (16 bpp)
+        512*512*16/8/1024,      //DDS_R5G5B5A1 (16 bpp)
+        512*512*16/8/1024,      //DDS_R4G4B4A4 (16 bpp)
+        512*512*32/8/1024,      //DDS_R8G8B8A8 (32 bpp)
+        512*512*4/8/1024,       //DDS_DXT1_RGB (4 bpp) -Compressed-
+        512*512*4/8/1024,       //DDS_DXT1_RGBA (4 bpp) -Compressed-
+        512*512*8/8/1024,       //DDS_DXT3_RGBA (8 bpp) -Compressed-
+        512*512*8/8/1024,       //DDS_DXT5_RGBA (8 bpp) -Compressed-
+        512*512*4/8/1024,       //PKM_ETC1_RGB (4 bpp) -Compressed-
+        512*512*4/8/1024,       //PKM_ETC2_RGB (4 bpp) -Compressed-
+        512*512*8/8/1024,       //PKM_ETC2_EAC_RGBA (8 bpp) -Compressed-
+        512*512*4/8/1024,       //KTX_ETC1_RGB (4 bpp) -Compressed-
+        512*512*4/8/1024,       //KTX_ETC2_RGB (4 bpp) -Compressed-
+        512*512*8/8/1024,       //KTX_ETC2_EAC_RGBA (8 bpp) -Compressed-
+        512*512*8/8/1024,       //ASTC_4x4_LDR (8 bpp) -Compressed-
+        512*512*2/8/1024,       //ASTC_8x8_LDR (2 bpp) -Compressed-
+        512*512*4/8/1024,       //PVR_PVRT_RGB (4 bpp) -Compressed-
+        512*512*4/8/1024,       //PVR_PVRT_RGBA (4 bpp) -Compressed-
+    };
+
+    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
+        //----------------------------------------------------------------------------------
+        if (IsKeyPressed(KEY_DOWN))
+        {
+            selectedFormat++;
+            if (selectedFormat >= NUM_TEXTURES) selectedFormat = 0;
+        }
+        else if (IsKeyPressed(KEY_UP))
+        {
+            selectedFormat--;
+            if (selectedFormat < 0) selectedFormat = NUM_TEXTURES - 1;
+        }
+        else if (IsKeyPressed(KEY_RIGHT))
+        {
+            if (selectedFormat < NUM_TEXTURES/2) selectedFormat += NUM_TEXTURES/2;
+        }
+        else if (IsKeyPressed(KEY_LEFT))
+        {
+            if (selectedFormat >= NUM_TEXTURES/2) selectedFormat -= NUM_TEXTURES/2;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+            
+            // Draw rectangles
+            for (int i = 0; i < NUM_TEXTURES; i++)
+            {
+                if (i == selectedFormat)
+                {
+                    DrawRectangleRec(selectRecs[i], SKYBLUE);
+                    DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, BLUE);
+                    DrawText(formatText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(formatText[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(formatText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(formatText[i], 10)/2, selectRecs[i].y + 11, 10, DARKGRAY);
+                }
+            }
+			
+            // Draw selected texture
+            if (sonic[selectedFormat].id != 0)
+            {
+                DrawTexture(sonic[selectedFormat], 350, -10, WHITE);
+            }
+            else 
+            {
+                DrawRectangleLines(488, 165, 200, 110, DARKGRAY);
+                DrawText("FORMAT", 550, 180, 20, MAROON);
+                DrawText("NOT SUPPORTED", 500, 210, 20, MAROON);
+                DrawText("ON YOUR GPU", 520, 240, 20, MAROON);
+            }
+            
+            DrawText("Select texture format (use cursor keys):", 40, 10, 10, DARKGRAY);
+            DrawText("Required GPU memory size (VRAM):", 40, 427, 10, DARKGRAY);
+            DrawText(FormatText("%4.0f KB", textureSizes[selectedFormat]), 240, 420, 20, DARKBLUE);
+            
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    for (int i = 0; i < NUM_TEXTURES; i++) UnloadTexture(sonic[i]);
+
+    CloseWindow();                  // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/textures/textures_image_drawing.c

@@ -0,0 +1,78 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - Image loading and drawing on it
+*
+*   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)
+*
+*   Copyright (c) 2016 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - image drawing");
+
+    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+
+    Image cat = LoadImage("resources/cat.png");             // Load image in CPU memory (RAM)
+    ImageCrop(&cat, (Rectangle){ 100, 10, 280, 380 });      // Crop an image piece
+    ImageFlipHorizontal(&cat);                              // Flip cropped image horizontally
+    ImageResize(&cat, 150, 200);                            // Resize flipped-cropped image
+    
+    Image parrots = LoadImage("resources/parrots.png");     // Load image in CPU memory (RAM)
+    
+    // Draw one image over the other with a scaling of 1.5f
+    ImageDraw(&parrots, cat, (Rectangle){ 0, 0, cat.width, cat.height }, (Rectangle){ 30, 40, cat.width*1.5f, cat.height*1.5f });
+    ImageCrop(&parrots, (Rectangle){ 0, 50, parrots.width, parrots.height - 100 }); // Crop resulting image
+    
+    UnloadImage(cat);       // Unload image from RAM
+
+    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
+    
+    SetTargetFPS(60);
+    //---------------------------------------------------------------------------------------
+
+    // 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 - 40, WHITE);
+            DrawRectangleLines(screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2 - 40, texture.width, texture.height, DARKGRAY);
+
+            DrawText("We are drawing only one texture from various images composed!", 240, 350, 10, DARKGRAY);
+            DrawText("Source images have been cropped, scaled, flipped and copied one over the other.", 190, 370, 10, DARKGRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(texture);       // Texture unloading
+
+    CloseWindow();                // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/textures/textures_image_loading.c

@@ -0,0 +1,63 @@
+/*******************************************************************************************
+*
+*   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()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    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
+    //---------------------------------------------------------------------------------------
+
+    // 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;
+}

examples/textures/textures_image_processing.c

@@ -0,0 +1,154 @@
+/*******************************************************************************************
+*
+*   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 1.4 (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()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - image processing");
+
+    // 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)
+    Texture2D texture = LoadTextureFromImage(image);    // Image converted to texture, GPU memory (VRAM)
+
+    int currentProcess = NONE;
+    bool textureReload = false;
+
+    Rectangle selectRecs[NUM_PROCESSES];
+    
+    for (int i = 0; i < NUM_PROCESSES; i++) selectRecs[i] = (Rectangle){ 40, 50 + 32*i, 150, 30 };
+    
+    SetTargetFPS(60);
+    //---------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (IsKeyPressed(KEY_DOWN))
+        {
+            currentProcess++;
+            if (currentProcess > 7) currentProcess = 0;
+            textureReload = true;
+        }
+        else if (IsKeyPressed(KEY_UP))
+        {
+            currentProcess--;
+            if (currentProcess < 0) currentProcess = 7;
+            textureReload = true;
+        }
+        
+        if (textureReload)
+        {
+            UnloadImage(image);                         // Unload current image data
+            image = LoadImage("resources/parrots.png"); // Re-load image data
+
+            // 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(&image); break;
+                case COLOR_TINT: ImageColorTint(&image, GREEN); break;
+                case COLOR_INVERT: ImageColorInvert(&image); break;
+                case COLOR_CONTRAST: ImageColorContrast(&image, -40); break;
+                case COLOR_BRIGHTNESS: ImageColorBrightness(&image, -80); break;
+                case FLIP_VERTICAL: ImageFlipVertical(&image); break;
+                case FLIP_HORIZONTAL: ImageFlipHorizontal(&image); break;
+                default: break;
+            }
+            
+            Color *pixels = GetImageData(image);        // Get pixel data from image (RGBA 32bit)
+            UpdateTexture(texture, pixels);             // Update texture with new image data
+            free(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++)
+            {
+                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);
+                }
+            }
+
+            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(image);           // Unload image from RAM
+
+    CloseWindow();                // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

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()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    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;
+}

examples/textures/textures_particles_trail_blending.c

@@ -0,0 +1,135 @@
+/*******************************************************************************************
+*
+*   raylib example - particles trail blending
+*
+*   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"
+
+#define MAX_PARTICLES 200
+
+// Particle structure with basic data
+typedef struct {
+    Vector2 position;
+    Color color;
+    float alpha;
+    float size;
+    float rotation;
+    bool active;        // NOTE: Use it to activate/deactive particle
+} Particle;
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - particles trail blending");
+    
+    // Particles pool, reuse them!
+    Particle mouseTail[MAX_PARTICLES]; 
+    
+    // Initialize particles
+    for (int i = 0; i < MAX_PARTICLES; i++)
+    {
+        mouseTail[i].position = (Vector2){ 0, 0 };
+        mouseTail[i].color = (Color){ GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255 };
+        mouseTail[i].alpha = 1.0f;
+        mouseTail[i].size = (float)GetRandomValue(1, 30)/20.0f;
+        mouseTail[i].rotation = GetRandomValue(0, 360);
+        mouseTail[i].active = false;
+    }
+    
+    float gravity = 3.0f;
+
+    Texture2D smoke = LoadTexture("resources/smoke.png");
+    
+    int blending = BLEND_ALPHA;
+    
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        
+        // Activate one particle every frame and Update active particles
+        // NOTE: Particles initial position should be mouse position when activated
+        // NOTE: Particles fall down with gravity and rotation... and disappear after 2 seconds (alpha = 0)
+        // NOTE: When a particle disappears, active = false and it can be reused.
+        for (int i = 0; i < MAX_PARTICLES; i++)
+        {
+            if (!mouseTail[i].active)
+            {
+                mouseTail[i].active = true;
+                mouseTail[i].alpha = 1.0f;
+                mouseTail[i].position = GetMousePosition();
+                i = MAX_PARTICLES;
+            }
+        }
+
+        for (int i = 0; i < MAX_PARTICLES; i++)
+        {
+            if (mouseTail[i].active)
+            {
+                mouseTail[i].position.y += gravity;
+                mouseTail[i].alpha -= 0.01f;
+                
+                if (mouseTail[i].alpha <= 0.0f) mouseTail[i].active = false;
+                
+                mouseTail[i].rotation += 5.0f;
+            }
+        }
+        
+        if (IsKeyPressed(KEY_SPACE))
+        {
+            if (blending == BLEND_ALPHA) blending = BLEND_ADDITIVE;
+            else blending = BLEND_ALPHA;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(DARKGRAY);
+            
+            BeginBlendMode(blending);
+
+                // Draw active particles
+                for (int i = 0; i < MAX_PARTICLES; i++)
+                {
+                    if (mouseTail[i].active) DrawTexturePro(smoke, (Rectangle){ 0, 0, smoke.width, smoke.height }, 
+                                                           (Rectangle){ mouseTail[i].position.x, mouseTail[i].position.y, smoke.width*mouseTail[i].size, smoke.height*mouseTail[i].size },
+                                                           (Vector2){ smoke.width*mouseTail[i].size/2, smoke.height*mouseTail[i].size/2 }, mouseTail[i].rotation,
+                                                           Fade(mouseTail[i].color, mouseTail[i].alpha));
+                }
+            
+            EndBlendMode();
+            
+            DrawText("PRESS SPACE to CHANGE BLENDING MODE", 180, 20, 20, BLACK);
+            
+            if (blending == BLEND_ALPHA) DrawText("ALPHA BLENDING", 290, screenHeight - 40, 20, BLACK);
+            else DrawText("ADDITIVE BLENDING", 280, screenHeight - 40, 20, RAYWHITE);
+            
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(smoke);
+    
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/textures/textures_raw_data.c

@@ -0,0 +1,93 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - Load textures from raw data
+*
+*   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"
+
+#include <stdlib.h>     // Required for malloc() and free()
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture from raw data");
+
+    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+ 
+    // Load RAW image data (512x512, 32bit RGBA, no file header)
+    Image sonicRaw = LoadImageRaw("resources/texture_formats/sonic_R8G8B8A8.raw", 512, 512, UNCOMPRESSED_R8G8B8A8, 0);
+    Texture2D sonic = LoadTextureFromImage(sonicRaw);   // Upload CPU (RAM) image to GPU (VRAM)
+    UnloadImage(sonicRaw);                              // Unload CPU (RAM) image data
+    
+    // Generate a checked texture by code (1024x1024 pixels)
+    int width = 1024;
+    int height = 1024;
+    
+    // Dynamic memory allocation to store pixels data (Color type)
+    Color *pixels = (Color *)malloc(width*height*sizeof(Color));
+    
+    for (int y = 0; y < height; y++)
+    {
+        for (int x = 0; x < width; x++)
+        {
+            if (((x/32+y/32)/1)%2 == 0) pixels[y*height + x] = DARKBLUE;
+            else pixels[y*height + x] = SKYBLUE;
+        }
+    }
+    
+    // Load pixels data into an image structure and create texture
+    Image checkedIm = LoadImageEx(pixels, width, height);
+    Texture2D checked = LoadTextureFromImage(checkedIm);
+    UnloadImage(checkedIm);     // Unload CPU (RAM) image data
+    
+    // Dynamic memory must be freed after using it
+    free(pixels);               // Unload CPU (RAM) pixels data
+    //---------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        // TODO: Update your variables here
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            DrawTexture(checked, screenWidth/2 - checked.width/2, screenHeight/2 - checked.height/2, Fade(WHITE, 0.3f));
+            DrawTexture(sonic, 330, -20, WHITE);
+
+            DrawText("CHECKED TEXTURE ", 84, 100, 30, DARKBLUE);
+            DrawText("GENERATED by CODE", 72, 164, 30, DARKBLUE);
+            DrawText("and RAW IMAGE LOADING", 46, 226, 30, DARKBLUE);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(sonic);       // Texture unloading
+    UnloadTexture(checked);     // Texture unloading
+
+    CloseWindow();              // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/textures/textures_rectangle.c

@@ -0,0 +1,78 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - Texture loading and drawing a part defined by a rectangle
+*
+*   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) 2014 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [texture] example - texture rectangle");
+
+    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+    Texture2D guybrush = LoadTexture("resources/guybrush.png");        // Texture loading
+
+    Vector2 position = { 350.0f, 240.0f };
+    Rectangle frameRec = { 0, 0, guybrush.width/7, guybrush.height };
+    int currentFrame = 0;
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (IsKeyPressed(KEY_RIGHT))
+        {
+            currentFrame++;
+            
+            if (currentFrame > 6) currentFrame = 0;
+            
+            frameRec.x = currentFrame*guybrush.width/7;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            DrawTexture(guybrush, 35, 40, WHITE);
+            DrawRectangleLines(35, 40, guybrush.width, guybrush.height, LIME);
+            
+            DrawTextureRec(guybrush, frameRec, position, WHITE);  // Draw part of the texture
+            
+            DrawRectangleLines(35 + frameRec.x, 40 + frameRec.y, frameRec.width, frameRec.height, RED);
+            
+            DrawText("PRESS RIGHT KEY to", 540, 310, 10, GRAY);
+            DrawText("CHANGE DRAWING RECTANGLE", 520, 330, 10, GRAY);
+            
+            DrawText("Guybrush Ulysses Threepwood,", 100, 300, 10, GRAY);
+            DrawText("main character of the Monkey Island series", 80, 320, 10, GRAY);
+            DrawText("of computer adventure games by LucasArts.", 80, 340, 10, GRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(guybrush);       // Texture unloading
+
+    CloseWindow();                // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/textures/textures_srcrec_dstrec.c

@@ -0,0 +1,79 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - Texture source and destination rectangles
+*
+*   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()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] examples - texture source and destination rectangles");
+
+    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+    Texture2D guybrush = LoadTexture("resources/guybrush.png");        // Texture loading
+
+    int frameWidth = guybrush.width/7;
+    int frameHeight = guybrush.height;
+    
+    // NOTE: Source rectangle (part of the texture to use for drawing)
+    Rectangle sourceRec = { 0, 0, frameWidth, frameHeight };
+
+    // NOTE: Destination rectangle (screen rectangle where drawing part of texture)
+    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 = { frameWidth, frameHeight };
+    
+    int rotation = 0;
+    
+    SetTargetFPS(60);
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        rotation++;
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            // NOTE: Using DrawTexturePro() we can easily rotate and scale the part of the texture we draw
+            // sourceRec defines the part of the texture we use for drawing
+            // destRec defines the rectangle where our texture part will fit (scaling it to fit)
+            // origin defines the point of the texture used as reference for rotation and scaling
+            // rotation defines the texture rotation (using origin as rotation point)
+            DrawTexturePro(guybrush, sourceRec, destRec, origin, rotation, WHITE);
+
+            DrawLine(destRec.x, 0, destRec.x, screenHeight, GRAY);
+            DrawLine(0, destRec.y, screenWidth, destRec.y, GRAY);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadTexture(guybrush);       // Texture unloading
+
+    CloseWindow();                // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/textures/textures_to_image.c

@@ -0,0 +1,68 @@
+/*******************************************************************************************
+*
+*   raylib [textures] example - Retrieve image data from texture: GetTextureData() 
+*
+*   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()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture to image");
+
+    // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+
+    Image image = LoadImage("resources/raylib_logo.png");  // Load image data into CPU memory (RAM)
+    Texture2D texture = LoadTextureFromImage(image);       // Image converted to texture, GPU memory (RAM -> VRAM)
+    UnloadImage(image);                                    // Unload image data from CPU memory (RAM)
+    
+    image = GetTextureData(texture);                       // Retrieve image data from GPU memory (VRAM -> RAM)
+    UnloadTexture(texture);                                // Unload texture from GPU memory (VRAM)
+    
+    texture = LoadTextureFromImage(image);                 // Recreate texture from retrieved image data (RAM -> VRAM)
+    UnloadImage(image);                                    // Unload retrieved image data from CPU memory (RAM)
+    //---------------------------------------------------------------------------------------
+
+    // 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;
+}