Fixed line endings

- Line endings were not correct causing files to not display correctly.

Examples/audio/audio_music_stream.cs

@@ -3,5 +3,96 @@ using static Raylib.Raylib;
 
 public partial class audio_music_stream
 {
-    /*******************************************************************************************
    *
    *   raylib [audio] example - IntPtr playing (streaming)
    *
    *   NOTE: This example requires OpenAL Soft library installed
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [audio] example - music playing (streaming)");
    
        InitAudioDevice();              // Initialize audio device
    
        var music = LoadMusicStream("resources/guitar_noodling.ogg");
        
        PlayMusicStream(music);
    
        float timePlayed = 0.0f;
        bool pause = false;
    
        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
            //----------------------------------------------------------------------------------
            UpdateMusicStream(music);        // Update music buffer with new stream data
            
            // Restart music playing (stop and play)
            if (IsKeyPressed(KEY_SPACE)) 
            {
                StopMusicStream(music);
                PlayMusicStream(music);
            }
            
            // Pause/Resume music playing 
            if (IsKeyPressed(KEY_P))
            {
                pause = !pause;
                
                if (pause) PauseMusicStream(music);
                else ResumeMusicStream(music);
            }
            
            // Get timePlayed scaled to bar dimensions (400 pixels)
            timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*400;
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("MUSIC SHOULD BE PLAYING!", 255, 150, 20, LIGHTGRAY);
    
                DrawRectangle(200, 200, 400, 12, LIGHTGRAY);
                DrawRectangle(200, 200, (int)timePlayed, 12, MAROON);
                DrawRectangleLines(200, 200, 400, 12, GRAY);
                
                DrawText("PRESS SPACE TO RESTART MUSIC", 215, 250, 20, LIGHTGRAY);
                DrawText("PRESS P TO PAUSE/RESUME MUSIC", 208, 280, 20, LIGHTGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadMusicStream(music);   // Unload music stream buffers from RAM
    
        CloseAudioDevice();         // Close audio device (music streaming is automatically stopped)
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [audio] example - IntPtr playing (streaming)
+    *
+    *   NOTE: This example requires OpenAL Soft library installed
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [audio] example - music playing (streaming)");
+    
+        InitAudioDevice();              // Initialize audio device
+    
+        var music = LoadMusicStream("resources/guitar_noodling.ogg");
+        
+        PlayMusicStream(music);
+    
+        float timePlayed = 0.0f;
+        bool pause = false;
+    
+        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
+            //----------------------------------------------------------------------------------
+            UpdateMusicStream(music);        // Update music buffer with new stream data
+            
+            // Restart music playing (stop and play)
+            if (IsKeyPressed(KEY_SPACE)) 
+            {
+                StopMusicStream(music);
+                PlayMusicStream(music);
+            }
+            
+            // Pause/Resume music playing 
+            if (IsKeyPressed(KEY_P))
+            {
+                pause = !pause;
+                
+                if (pause) PauseMusicStream(music);
+                else ResumeMusicStream(music);
+            }
+            
+            // Get timePlayed scaled to bar dimensions (400 pixels)
+            timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*400;
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawText("MUSIC SHOULD BE PLAYING!", 255, 150, 20, LIGHTGRAY);
+    
+                DrawRectangle(200, 200, 400, 12, LIGHTGRAY);
+                DrawRectangle(200, 200, (int)timePlayed, 12, MAROON);
+                DrawRectangleLines(200, 200, 400, 12, GRAY);
+                
+                DrawText("PRESS SPACE TO RESTART MUSIC", 215, 250, 20, LIGHTGRAY);
+                DrawText("PRESS P TO PAUSE/RESUME MUSIC", 208, 280, 20, LIGHTGRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadMusicStream(music);   // Unload music stream buffers from RAM
+    
+        CloseAudioDevice();         // Close audio device (music streaming is automatically stopped)
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/audio/audio_raw_stream.cs

@@ -1,11 +1,119 @@
 using System;
-using Raylib;
+using Raylib;
 using static Raylib.Raylib;
 
 public partial class audio_raw_stream
 {
-    /*******************************************************************************************
    *
    *   raylib [audio] example - Raw audio streaming
    *
    *   NOTE: This example requires OpenAL Soft library installed
    *
    *   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) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public const int MAX_SAMPLES = 22050;
    public const int MAX_SAMPLES_PER_UPDATE = 4096;
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [audio] example - raw audio streaming");
    
        InitAudioDevice();              // Initialize audio device
    
        // Init raw audio stream (sample rate: 22050, sample size: 16bit-short, channels: 1-mono)
        AudioStream stream = InitAudioStream(22050, 16, 1);
+    /*******************************************************************************************
-
+    *
-        // Generate samples data from sine wave
+    *   raylib [audio] example - Raw audio streaming
-        short[] data = new short[MAX_SAMPLES];
        //short *data = (short *)malloc(sizeof(short)*MAX_SAMPLES);
        
        // TODO: Review data generation, it seems data is discontinued for loop,
        // for that reason, there is a clip everytime audio stream is looped...
        for (int i = 0; i < MAX_SAMPLES; i++)
        {
            data[i] = (short)(Math.Sin(((2*Math.PI*(float)i)/2)*DEG2RAD)*32000);
        }
        
        PlayAudioStream(stream);        // Start processing stream buffer (no data loaded currently)
        
        int totalSamples = MAX_SAMPLES;
        int samplesLeft = totalSamples;
        
        Vector2 position = new Vector2( 0, 0 );
    
        SetTargetFPS(30);               // Set our game to run at 30 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            
            // Refill audio stream if required
            // NOTE: Every update we check if stream data has been already consumed and we update
            // buffer with new data from the generated samples, we upload data at a rate (MAX_SAMPLES_PER_UPDATE),
            // but notice that at some point we update < MAX_SAMPLES_PER_UPDATE data...
            if (IsAudioBufferProcessed(stream)) 
            {
                int numSamples = 0;
                if (samplesLeft >= MAX_SAMPLES_PER_UPDATE) numSamples = MAX_SAMPLES_PER_UPDATE;
                else numSamples = samplesLeft;
    
                // UpdateAudioStream(stream, data + (totalSamples - samplesLeft), numSamples);
                
                samplesLeft -= numSamples;
                
                // Reset samples feeding (loop audio)
                if (samplesLeft <= 0) samplesLeft = totalSamples;
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("SINE WAVE SHOULD BE PLAYING!", 240, 140, 20, LIGHTGRAY);
                
                // NOTE: Draw a part of the sine wave (only screen width, proportional values)
                for (int i = 0; i < GetScreenWidth(); i++)
                {
                    position.x = i;
                    position.y = 250 + 50*data[i]/32000;
                    
                    DrawPixelV(position, RED);
                }
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        // free(data);                 // Unload sine wave data
        
        CloseAudioStream(stream);   // Close raw audio stream and delete buffers from RAM
    
        CloseAudioDevice();         // Close audio device (music streaming is automatically stopped)
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    *
+    *   NOTE: This example requires OpenAL Soft library installed
+    *
+    *   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) 2015 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    public const int MAX_SAMPLES = 22050;
+    public const int MAX_SAMPLES_PER_UPDATE = 4096;
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [audio] example - raw audio streaming");
+    
+        InitAudioDevice();              // Initialize audio device
+    
+        // Init raw audio stream (sample rate: 22050, sample size: 16bit-short, channels: 1-mono)
+        AudioStream stream = InitAudioStream(22050, 16, 1);
+
+        // Generate samples data from sine wave
+        short[] data = new short[MAX_SAMPLES];
+        //short *data = (short *)malloc(sizeof(short)*MAX_SAMPLES);
+        
+        // TODO: Review data generation, it seems data is discontinued for loop,
+        // for that reason, there is a clip everytime audio stream is looped...
+        for (int i = 0; i < MAX_SAMPLES; i++)
+        {
+            data[i] = (short)(Math.Sin(((2*Math.PI*(float)i)/2)*DEG2RAD)*32000);
+        }
+        
+        PlayAudioStream(stream);        // Start processing stream buffer (no data loaded currently)
+        
+        int totalSamples = MAX_SAMPLES;
+        int samplesLeft = totalSamples;
+        
+        Vector2 position = new Vector2( 0, 0 );
+    
+        SetTargetFPS(30);               // Set our game to run at 30 frames-per-second
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            
+            // Refill audio stream if required
+            // NOTE: Every update we check if stream data has been already consumed and we update
+            // buffer with new data from the generated samples, we upload data at a rate (MAX_SAMPLES_PER_UPDATE),
+            // but notice that at some point we update < MAX_SAMPLES_PER_UPDATE data...
+            if (IsAudioBufferProcessed(stream)) 
+            {
+                int numSamples = 0;
+                if (samplesLeft >= MAX_SAMPLES_PER_UPDATE) numSamples = MAX_SAMPLES_PER_UPDATE;
+                else numSamples = samplesLeft;
+    
+                // UpdateAudioStream(stream, data + (totalSamples - samplesLeft), numSamples);
+                
+                samplesLeft -= numSamples;
+                
+                // Reset samples feeding (loop audio)
+                if (samplesLeft <= 0) samplesLeft = totalSamples;
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawText("SINE WAVE SHOULD BE PLAYING!", 240, 140, 20, LIGHTGRAY);
+                
+                // NOTE: Draw a part of the sine wave (only screen width, proportional values)
+                for (int i = 0; i < GetScreenWidth(); i++)
+                {
+                    position.x = i;
+                    position.y = 250 + 50*data[i]/32000;
+                    
+                    DrawPixelV(position, RED);
+                }
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        // free(data);                 // Unload sine wave data
+        
+        CloseAudioStream(stream);   // Close raw audio stream and delete buffers from RAM
+    
+        CloseAudioDevice();         // Close audio device (music streaming is automatically stopped)
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/audio/audio_sound_loading.cs

@@ -3,5 +3,70 @@ using static Raylib.Raylib;
 
 public partial class audio_sound_loading
 {
-    /*******************************************************************************************
    *
    *   raylib [audio] example - Sound loading and playing
    *
    *   NOTE: This example requires OpenAL Soft library installed
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing");
    
        InitAudioDevice();      // Initialize audio device
    
        Sound fxWav = LoadSound("resources/sound.wav");         // Load WAV audio file
        Sound fxOgg = LoadSound("resources/tanatana.ogg");      // Load OGG audio file
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsKeyPressed(KEY_SPACE)) PlaySound(fxWav);      // Play WAV sound
            if (IsKeyPressed(KEY_ENTER)) PlaySound(fxOgg);      // Play OGG sound
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("Press SPACE to PLAY the WAV sound!", 200, 180, 20, LIGHTGRAY);
    
                DrawText("Press ENTER to PLAY the OGG sound!", 200, 220, 20, LIGHTGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadSound(fxWav);     // Unload sound data
        UnloadSound(fxOgg);     // Unload sound data
    
        CloseAudioDevice();     // Close audio device
    
        CloseWindow();          // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [audio] example - Sound loading and playing
+    *
+    *   NOTE: This example requires OpenAL Soft library installed
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing");
+    
+        InitAudioDevice();      // Initialize audio device
+    
+        Sound fxWav = LoadSound("resources/sound.wav");         // Load WAV audio file
+        Sound fxOgg = LoadSound("resources/tanatana.ogg");      // Load OGG audio file
+        
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            if (IsKeyPressed(KEY_SPACE)) PlaySound(fxWav);      // Play WAV sound
+            if (IsKeyPressed(KEY_ENTER)) PlaySound(fxOgg);      // Play OGG sound
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawText("Press SPACE to PLAY the WAV sound!", 200, 180, 20, LIGHTGRAY);
+    
+                DrawText("Press ENTER to PLAY the OGG sound!", 200, 220, 20, LIGHTGRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadSound(fxWav);     // Unload sound data
+        UnloadSound(fxOgg);     // Unload sound data
+    
+        CloseAudioDevice();     // Close audio device
+    
+        CloseWindow();          // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_3d_camera_first_person.cs

@@ -5,5 +5,100 @@ using static Raylib.CameraMode;
 
 public partial class core_3d_camera_first_person
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - 3d camera first person
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public const int MAX_COLUMNS = 20;
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera first person");
        
        // Define the camera to look into our 3d world (position, target, up vector)
        Camera3D camera = new Camera3D();
        camera.position = new Vector3( 4.0f, 2.0f, 4.0f );
        camera.target = new Vector3( 0.0f, 1.8f, 0.0f );
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );
        camera.fovy = 60.0f;
        camera.type = (int)CAMERA_PERSPECTIVE;
    
        // Generates some random columns
        float[] heights = new float[MAX_COLUMNS];
        Vector3[] positions = new Vector3[MAX_COLUMNS];
        Color[] colors = new Color[MAX_COLUMNS];
        
        for (int i = 0; i < MAX_COLUMNS; i++)
        {
            heights[i] = (float)GetRandomValue(1, 12);
            positions[i] = new Vector3( GetRandomValue(-15, 15), heights[i]/2, GetRandomValue(-15, 15) );
            colors[i] = new Color( GetRandomValue(20, 255), GetRandomValue(10, 55), 30, 255 );
        }
        
        SetCameraMode(camera, (int)CAMERA_FIRST_PERSON); // Set a first person camera mode
    
        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
            //----------------------------------------------------------------------------------
            UpdateCamera(ref camera);                  // Update camera
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawPlane(new Vector3( 0.0f, 0.0f, 0.0f ), new Vector2( 32.0f, 32.0f ), LIGHTGRAY); // Draw ground
                    DrawCube(new Vector3( -16.0f, 2.5f, 0.0f ), 1.0f, 5.0f, 32.0f, BLUE);     // Draw a blue wall
                    DrawCube(new Vector3( 16.0f, 2.5f, 0.0f ), 1.0f, 5.0f, 32.0f, LIME);      // Draw a green wall
                    DrawCube(new Vector3( 0.0f, 2.5f, 16.0f ), 32.0f, 5.0f, 1.0f, GOLD);      // Draw a yellow wall
                
                    // Draw some cubes around
                    for (int i = 0; i < MAX_COLUMNS; i++)
                    {
                        DrawCube(positions[i], 2.0f, heights[i], 2.0f, colors[i]);
                        DrawCubeWires(positions[i], 2.0f, heights[i], 2.0f, MAROON);
                    }
    
                EndMode3D();
                
                DrawRectangle( 10, 10, 220, 70, Fade(SKYBLUE, 0.5f));
                DrawRectangleLines( 10, 10, 220, 70, BLUE);
    
                DrawText("First person camera default controls:", 20, 20, 10, BLACK);
                DrawText("- Move with keys: W, A, S, D", 40, 40, 10, DARKGRAY);
                DrawText("- Mouse move to look around", 40, 60, 10, DARKGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------   
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - 3d camera first person
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public const int MAX_COLUMNS = 20;
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera first person");
+        
+        // Define the camera to look into our 3d world (position, target, up vector)
+        Camera3D camera = new Camera3D();
+        camera.position = new Vector3( 4.0f, 2.0f, 4.0f );
+        camera.target = new Vector3( 0.0f, 1.8f, 0.0f );
+        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );
+        camera.fovy = 60.0f;
+        camera.type = (int)CAMERA_PERSPECTIVE;
+    
+        // Generates some random columns
+        float[] heights = new float[MAX_COLUMNS];
+        Vector3[] positions = new Vector3[MAX_COLUMNS];
+        Color[] colors = new Color[MAX_COLUMNS];
+        
+        for (int i = 0; i < MAX_COLUMNS; i++)
+        {
+            heights[i] = (float)GetRandomValue(1, 12);
+            positions[i] = new Vector3( GetRandomValue(-15, 15), heights[i]/2, GetRandomValue(-15, 15) );
+            colors[i] = new Color( GetRandomValue(20, 255), GetRandomValue(10, 55), 30, 255 );
+        }
+        
+        SetCameraMode(camera, (int)CAMERA_FIRST_PERSON); // Set a first person camera mode
+    
+        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
+            //----------------------------------------------------------------------------------
+            UpdateCamera(ref camera);                  // Update camera
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawPlane(new Vector3( 0.0f, 0.0f, 0.0f ), new Vector2( 32.0f, 32.0f ), LIGHTGRAY); // Draw ground
+                    DrawCube(new Vector3( -16.0f, 2.5f, 0.0f ), 1.0f, 5.0f, 32.0f, BLUE);     // Draw a blue wall
+                    DrawCube(new Vector3( 16.0f, 2.5f, 0.0f ), 1.0f, 5.0f, 32.0f, LIME);      // Draw a green wall
+                    DrawCube(new Vector3( 0.0f, 2.5f, 16.0f ), 32.0f, 5.0f, 1.0f, GOLD);      // Draw a yellow wall
+                
+                    // Draw some cubes around
+                    for (int i = 0; i < MAX_COLUMNS; i++)
+                    {
+                        DrawCube(positions[i], 2.0f, heights[i], 2.0f, colors[i]);
+                        DrawCubeWires(positions[i], 2.0f, heights[i], 2.0f, MAROON);
+                    }
+    
+                EndMode3D();
+                
+                DrawRectangle( 10, 10, 220, 70, Fade(SKYBLUE, 0.5f));
+                DrawRectangleLines( 10, 10, 220, 70, BLUE);
+    
+                DrawText("First person camera default controls:", 20, 20, 10, BLACK);
+                DrawText("- Move with keys: W, A, S, D", 40, 40, 10, DARKGRAY);
+                DrawText("- Mouse move to look around", 40, 60, 10, DARKGRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------   
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_3d_camera_free.cs

@@ -5,5 +5,86 @@ using static Raylib.CameraMode;
 
 public partial class core_3d_camera_free
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - Initialize 3d camera free
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free");
    
        // Define the camera to look into our 3d world
        Camera3D camera;
        camera.position = new Vector3( 10.0f, 10.0f, 10.0f ); // Camera3D position
        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );      // Camera3D looking at point
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );          // Camera3D up vector (rotation towards target)
        camera.fovy = 45.0f;                                // Camera3D field-of-view Y
        camera.type = (int)CAMERA_PERSPECTIVE;                   // Camera3D mode type
        
        Vector3 cubePosition = new Vector3( 0.0f, 0.0f, 0.0f );
        
        SetCameraMode(camera, (int)CAMERA_FREE); // Set a free camera mode
    
        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
            //----------------------------------------------------------------------------------
            UpdateCamera(ref camera);          // Update camera
            
            if (IsKeyDown('Z')) camera.target = new Vector3( 0.0f, 0.0f, 0.0f );
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
                    DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
    
                    DrawGrid(10, 1.0f);
    
                EndMode3D();
                
                DrawRectangle( 10, 10, 320, 133, Fade(SKYBLUE, 0.5f));
                DrawRectangleLines( 10, 10, 320, 133, BLUE);
                
                DrawText("Free camera default controls:", 20, 20, 10, BLACK);
                DrawText("- Mouse Wheel to Zoom in-out", 40, 40, 10, DARKGRAY);
                DrawText("- Mouse Wheel Pressed to Pan", 40, 60, 10, DARKGRAY);
                DrawText("- Alt + Mouse Wheel Pressed to Rotate", 40, 80, 10, DARKGRAY);
                DrawText("- Alt + Ctrl + Mouse Wheel Pressed for Smooth Zoom", 40, 100, 10, DARKGRAY);
                DrawText("- Z to zoom to (0, 0, 0)", 40, 120, 10, DARKGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - Initialize 3d camera free
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free");
+    
+        // Define the camera to look into our 3d world
+        Camera3D camera;
+        camera.position = new Vector3( 10.0f, 10.0f, 10.0f ); // Camera3D position
+        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );      // Camera3D looking at point
+        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );          // Camera3D up vector (rotation towards target)
+        camera.fovy = 45.0f;                                // Camera3D field-of-view Y
+        camera.type = (int)CAMERA_PERSPECTIVE;                   // Camera3D mode type
+        
+        Vector3 cubePosition = new Vector3( 0.0f, 0.0f, 0.0f );
+        
+        SetCameraMode(camera, (int)CAMERA_FREE); // Set a free camera mode
+    
+        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
+            //----------------------------------------------------------------------------------
+            UpdateCamera(ref camera);          // Update camera
+            
+            if (IsKeyDown('Z')) camera.target = new Vector3( 0.0f, 0.0f, 0.0f );
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
+                    DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
+    
+                    DrawGrid(10, 1.0f);
+    
+                EndMode3D();
+                
+                DrawRectangle( 10, 10, 320, 133, Fade(SKYBLUE, 0.5f));
+                DrawRectangleLines( 10, 10, 320, 133, BLUE);
+                
+                DrawText("Free camera default controls:", 20, 20, 10, BLACK);
+                DrawText("- Mouse Wheel to Zoom in-out", 40, 40, 10, DARKGRAY);
+                DrawText("- Mouse Wheel Pressed to Pan", 40, 60, 10, DARKGRAY);
+                DrawText("- Alt + Mouse Wheel Pressed to Rotate", 40, 80, 10, DARKGRAY);
+                DrawText("- Alt + Ctrl + Mouse Wheel Pressed for Smooth Zoom", 40, 100, 10, DARKGRAY);
+                DrawText("- Z to zoom to (0, 0, 0)", 40, 120, 10, DARKGRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_3d_mode.cs

@@ -4,5 +4,76 @@ using static Raylib.CameraType;
 
 public partial class core_3d_mode
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - Initialize 3d mode
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d mode");
    
        // Define the camera to look into our 3d world
        Camera3D camera;
        camera.position = new Vector3( 0.0f, 10.0f, 10.0f );  // Camera3D position
        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );      // Camera3D looking at point
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );          // Camera3D up vector (rotation towards target)
        camera.fovy = 45.0f;                                // Camera3D field-of-view Y
        camera.type = CAMERA_PERSPECTIVE;                   // Camera3D mode type
    
        Vector3 cubePosition = new Vector3( 0.0f, 0.0f, 0.0f );
    
        SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update your variables here
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
                    DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
    
                    DrawGrid(10, 1.0f);
    
                EndMode3D();
    
                DrawText("Welcome to the third dimension!", 10, 40, 20, DARKGRAY);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - Initialize 3d mode
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d mode");
+    
+        // Define the camera to look into our 3d world
+        Camera3D camera;
+        camera.position = new Vector3( 0.0f, 10.0f, 10.0f );  // Camera3D position
+        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );      // Camera3D looking at point
+        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );          // Camera3D up vector (rotation towards target)
+        camera.fovy = 45.0f;                                // Camera3D field-of-view Y
+        camera.type = CAMERA_PERSPECTIVE;                   // Camera3D mode type
+    
+        Vector3 cubePosition = new Vector3( 0.0f, 0.0f, 0.0f );
+    
+        SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            // TODO: Update your variables here
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
+                    DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
+    
+                    DrawGrid(10, 1.0f);
+    
+                EndMode3D();
+    
+                DrawText("Welcome to the third dimension!", 10, 40, 20, DARKGRAY);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_3d_picking.cs

@@ -5,5 +5,106 @@ using static Raylib.CameraMode;
 
 public partial class core_3d_picking
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - Picking in 3d mode
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d picking");
    
        // Define the camera to look into our 3d world
        Camera3D camera;
        camera.position = new Vector3( 10.0f, 10.0f, 10.0f ); // Camera3D position
        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );      // Camera3D looking at point
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );          // Camera3D up vector (rotation towards target)
        camera.fovy = 45.0f;                                // Camera3D field-of-view Y
        camera.type = (int)CAMERA_PERSPECTIVE;                   // Camera3D mode type
    
        Vector3 cubePosition = new Vector3( 0.0f, 1.0f, 0.0f );
        Vector3 cubeSize = new Vector3( 2.0f, 2.0f, 2.0f );
    
        Ray ray = new Ray(new Vector3(0.0f, 0.0f, 0.0f), Vector3.Zero);        // Picking line ray
    
        bool collision = false;
    
        SetCameraMode(camera, (int)CAMERA_FREE); // Set a free camera mode
    
        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
            //----------------------------------------------------------------------------------
            UpdateCamera(ref camera);          // Update camera
    
            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
            {
                ray = GetMouseRay(GetMousePosition(), camera);
    
                // Check collision between ray and box
                collision = CheckCollisionRayBox(ray,
                            new BoundingBox(new Vector3( cubePosition.x - cubeSize.x/2, cubePosition.y - cubeSize.y/2, cubePosition.z - cubeSize.z/2 ),
                                          new Vector3( cubePosition.x + cubeSize.x/2, cubePosition.y + cubeSize.y/2, cubePosition.z + cubeSize.z/2 )));
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    if (collision)
                    {
                        DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, RED);
                        DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, MAROON);
    
                        DrawCubeWires(cubePosition, cubeSize.x + 0.2f, cubeSize.y + 0.2f, cubeSize.z + 0.2f, GREEN);
                    }
                    else
                    {
                        DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, GRAY);
                        DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, DARKGRAY);
                    }
    
                    DrawRay(ray, MAROON);
                    DrawGrid(10, 1.0f);
    
                EndMode3D();
    
                DrawText("Try selecting the box with mouse!", 240, 10, 20, DARKGRAY);
    
                if(collision) DrawText("BOX SELECTED", (screenWidth - MeasureText("BOX SELECTED", 30)) / 2, (int)(screenHeight * 0.1f), 30, GREEN);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - Picking in 3d mode
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d picking");
+    
+        // Define the camera to look into our 3d world
+        Camera3D camera;
+        camera.position = new Vector3( 10.0f, 10.0f, 10.0f ); // Camera3D position
+        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );      // Camera3D looking at point
+        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );          // Camera3D up vector (rotation towards target)
+        camera.fovy = 45.0f;                                // Camera3D field-of-view Y
+        camera.type = (int)CAMERA_PERSPECTIVE;                   // Camera3D mode type
+    
+        Vector3 cubePosition = new Vector3( 0.0f, 1.0f, 0.0f );
+        Vector3 cubeSize = new Vector3( 2.0f, 2.0f, 2.0f );
+    
+        Ray ray = new Ray(new Vector3(0.0f, 0.0f, 0.0f), Vector3.Zero);        // Picking line ray
+    
+        bool collision = false;
+    
+        SetCameraMode(camera, (int)CAMERA_FREE); // Set a free camera mode
+    
+        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
+            //----------------------------------------------------------------------------------
+            UpdateCamera(ref camera);          // Update camera
+    
+            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+            {
+                ray = GetMouseRay(GetMousePosition(), camera);
+    
+                // Check collision between ray and box
+                collision = CheckCollisionRayBox(ray,
+                            new BoundingBox(new Vector3( cubePosition.x - cubeSize.x/2, cubePosition.y - cubeSize.y/2, cubePosition.z - cubeSize.z/2 ),
+                                          new Vector3( cubePosition.x + cubeSize.x/2, cubePosition.y + cubeSize.y/2, cubePosition.z + cubeSize.z/2 )));
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    if (collision)
+                    {
+                        DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, RED);
+                        DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, MAROON);
+    
+                        DrawCubeWires(cubePosition, cubeSize.x + 0.2f, cubeSize.y + 0.2f, cubeSize.z + 0.2f, GREEN);
+                    }
+                    else
+                    {
+                        DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, GRAY);
+                        DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, DARKGRAY);
+                    }
+    
+                    DrawRay(ray, MAROON);
+                    DrawGrid(10, 1.0f);
+    
+                EndMode3D();
+    
+                DrawText("Try selecting the box with mouse!", 240, 10, 20, DARKGRAY);
+    
+                if(collision) DrawText("BOX SELECTED", (screenWidth - MeasureText("BOX SELECTED", 30)) / 2, (int)(screenHeight * 0.1f), 30, GREEN);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_basic_window.cs

@@ -1 +1,67 @@
-using Raylib;
using static Raylib.Raylib;

public partial class core_basic_window
{
    /*******************************************************************************************
    *
    *   raylib [core] example - Basic window
    *
    *   Welcome to raylib!
    *
    *   To test examples, just press F6 and execute raylib_compile_execute script
    *   Note that compiled executable is placed in the same folder as .c file
    *
    *   You can find all basic examples on C:\raylib\raylib\examples folder or
    *   raylib official webpage: www.raylib.com
    *
    *   Enjoy using raylib. :)
    *
    *   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) 2013-2016 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update your variables here
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("Congrats! You created your first window!", 190, 200, 20, MAROON);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------   
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
}
+using Raylib;
+using static Raylib.Raylib;
+
+public partial class core_basic_window
+{
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - Basic window
+    *
+    *   Welcome to raylib!
+    *
+    *   To test examples, just press F6 and execute raylib_compile_execute script
+    *   Note that compiled executable is placed in the same folder as .c file
+    *
+    *   You can find all basic examples on C:\raylib\raylib\examples folder or
+    *   raylib official webpage: www.raylib.com
+    *
+    *   Enjoy using raylib. :)
+    *
+    *   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) 2013-2016 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
+        
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            // TODO: Update your variables here
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawText("Congrats! You created your first window!", 190, 200, 20, MAROON);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------   
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
+}

Examples/core/core_basic_window_web.cs

@@ -3,5 +3,84 @@ using static Raylib.Raylib;
 
 public partial class Examples
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - Basic window (adapted for HTML5 platform)
    *
    *   This example is prepared to compile for PLATFORM_WEB, PLATFORM_DESKTOP and PLATFORM_RPI
    *   As you will notice, code structure is slightly diferent to the other examples...
    *   To compile it for PLATFORM_WEB just uncomment #define PLATFORM_WEB at beginning
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    //#define PLATFORM_WEB
    
        #include <emscripten/emscripten.h>
    
    //----------------------------------------------------------------------------------
    // Global Variables Definition
    //----------------------------------------------------------------------------------
    int screenWidth = 800;
    int screenHeight = 450;
    
    //----------------------------------------------------------------------------------
    // Module Functions Declaration
    //----------------------------------------------------------------------------------
    void UpdateDrawFrame(void);     // Update and Draw one frame
    
    //----------------------------------------------------------------------------------
    // Main Enry Point
    //----------------------------------------------------------------------------------
    public static void Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
    
        emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
    #else
        SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
        
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            UpdateDrawFrame();
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
    
    //----------------------------------------------------------------------------------
    // Module Functions Definition
    //----------------------------------------------------------------------------------
    void UpdateDrawFrame(void)
    {
        // Update
        //----------------------------------------------------------------------------------
        // TODO: Update your variables here
        //----------------------------------------------------------------------------------
    
        // Draw
        //----------------------------------------------------------------------------------
        BeginDrawing();
    
            ClearBackground(RAYWHITE);
    
            DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
    
        EndDrawing();
        //----------------------------------------------------------------------------------
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - Basic window (adapted for HTML5 platform)
+    *
+    *   This example is prepared to compile for PLATFORM_WEB, PLATFORM_DESKTOP and PLATFORM_RPI
+    *   As you will notice, code structure is slightly diferent to the other examples...
+    *   To compile it for PLATFORM_WEB just uncomment #define PLATFORM_WEB at beginning
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    //#define PLATFORM_WEB
+    
+        #include <emscripten/emscripten.h>
+    
+    //----------------------------------------------------------------------------------
+    // Global Variables Definition
+    //----------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+    
+    //----------------------------------------------------------------------------------
+    // Module Functions Declaration
+    //----------------------------------------------------------------------------------
+    void UpdateDrawFrame(void);     // Update and Draw one frame
+    
+    //----------------------------------------------------------------------------------
+    // Main Enry Point
+    //----------------------------------------------------------------------------------
+    public static void Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
+    
+        emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+    #else
+        SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+        //--------------------------------------------------------------------------------------
+        
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            UpdateDrawFrame();
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+    
+    //----------------------------------------------------------------------------------
+    // Module Functions Definition
+    //----------------------------------------------------------------------------------
+    void UpdateDrawFrame(void)
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        // TODO: Update your variables here
+        //----------------------------------------------------------------------------------
+    
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+    
+            ClearBackground(RAYWHITE);
+    
+            DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
+    
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }    
 }

Examples/core/core_color_select.cs

@@ -3,5 +3,97 @@ using static Raylib.Raylib;
 
 public partial class core_color_select
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - Color selection by mouse (collision detection)
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - color selection (collision detection)");
    
        Color[] colors = new Color[21] { DARKGRAY, MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, DARKBROWN,
                             GRAY, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK, YELLOW,
                             GREEN, SKYBLUE, PURPLE, BEIGE };
    
        Rectangle[] colorsRecs = new Rectangle[21];             // Rectangles array
    
        // Fills colorsRecs data (for every rectangle)
        for (int i = 0; i < 21; i++)
        {
            colorsRecs[i].x = 20 + 100*(i%7) + 10*(i%7);
            colorsRecs[i].y = 60 + 100*(i/7) + 10*(i/7);
            colorsRecs[i].width = 100;
            colorsRecs[i].height = 100;
        }
    
        bool[] selected = new bool[21];  // Selected rectangles indicator
    
        Vector2 mousePoint;
    
        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
            //----------------------------------------------------------------------------------
            mousePoint = GetMousePosition();
    
            for (int i = 0; i < 21; i++)    // Iterate along all the rectangles
            {
                if (CheckCollisionPointRec(mousePoint, colorsRecs[i]))
                {
                    colors[i].a = 120;
    
                    if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) selected[i] = !selected[i];
                }
                else colors[i].a = 255;
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                for (int i = 0; i < 21; i++)    // Draw all rectangles
                {
                    DrawRectangleRec(colorsRecs[i], colors[i]);
    
                    // Draw four rectangles around selected rectangle
                    if (selected[i])
                    {
                        DrawRectangle((int)colorsRecs[i].x, (int)colorsRecs[i].y, 100, 10, RAYWHITE);        // Square top rectangle
                        DrawRectangle((int)colorsRecs[i].x, (int)colorsRecs[i].y, 10, 100, RAYWHITE);        // Square left rectangle
                        DrawRectangle((int)colorsRecs[i].x + 90, (int)colorsRecs[i].y, 10, 100, RAYWHITE);   // Square right rectangle
                        DrawRectangle((int)colorsRecs[i].x, (int)colorsRecs[i].y + 90, 100, 10, RAYWHITE);   // Square bottom rectangle
                    }
                }
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();                // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - Color selection by mouse (collision detection)
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - color selection (collision detection)");
+    
+        Color[] colors = new Color[21] { DARKGRAY, MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, DARKBROWN,
+                             GRAY, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK, YELLOW,
+                             GREEN, SKYBLUE, PURPLE, BEIGE };
+    
+        Rectangle[] colorsRecs = new Rectangle[21];             // Rectangles array
+    
+        // Fills colorsRecs data (for every rectangle)
+        for (int i = 0; i < 21; i++)
+        {
+            colorsRecs[i].x = 20 + 100*(i%7) + 10*(i%7);
+            colorsRecs[i].y = 60 + 100*(i/7) + 10*(i/7);
+            colorsRecs[i].width = 100;
+            colorsRecs[i].height = 100;
+        }
+    
+        bool[] selected = new bool[21];  // Selected rectangles indicator
+    
+        Vector2 mousePoint;
+    
+        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
+            //----------------------------------------------------------------------------------
+            mousePoint = GetMousePosition();
+    
+            for (int i = 0; i < 21; i++)    // Iterate along all the rectangles
+            {
+                if (CheckCollisionPointRec(mousePoint, colorsRecs[i]))
+                {
+                    colors[i].a = 120;
+    
+                    if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) selected[i] = !selected[i];
+                }
+                else colors[i].a = 255;
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                for (int i = 0; i < 21; i++)    // Draw all rectangles
+                {
+                    DrawRectangleRec(colorsRecs[i], colors[i]);
+    
+                    // Draw four rectangles around selected rectangle
+                    if (selected[i])
+                    {
+                        DrawRectangle((int)colorsRecs[i].x, (int)colorsRecs[i].y, 100, 10, RAYWHITE);        // Square top rectangle
+                        DrawRectangle((int)colorsRecs[i].x, (int)colorsRecs[i].y, 10, 100, RAYWHITE);        // Square left rectangle
+                        DrawRectangle((int)colorsRecs[i].x + 90, (int)colorsRecs[i].y, 10, 100, RAYWHITE);   // Square right rectangle
+                        DrawRectangle((int)colorsRecs[i].x, (int)colorsRecs[i].y + 90, 100, 10, RAYWHITE);   // Square bottom rectangle
+                    }
+                }
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();                // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_custom_logging.cs

@@ -3,5 +3,84 @@ using static Raylib.Raylib;
 
 public partial class Examples
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - Custom logging
    *
    *   This example has been created using raylib 2.1 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2018 Ramon Santamaria (@raysan5) and Pablo Marcos Oltra (@pamarcos)
    *
    ********************************************************************************************/
    
    
    
    // Custom logging funtion
    void LogCustom(int msgType, const char *text, va_list args)
    {
    	char timeStr[64];
    	time_t now = time(NULL);
    	struct tm *tm_info = localtime(&now);
    
    	strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", tm_info);
    	printf("[%s] ", timeStr);
    
    	switch (msgType)
    	{
    		case LOG_INFO: printf("[INFO] : "); break;
    		case LOG_ERROR: printf("[ERROR]: "); break;
    		case LOG_WARNING: printf("[WARN] : "); break;
    		case LOG_DEBUG: printf("[DEBUG]: "); break;
    		default: break;
    	}
        
    	vprintf(text, args);
    	printf("\n");
    }
    
    public static int core_custom_logging()
    {
    	// Initialization
    	//--------------------------------------------------------------------------------------
    	int screenWidth = 800;
    	int screenHeight = 450;
    
    	// First thing we do is setting our custom logger to ensure everything raylib logs
    	// will use our own logger instead of its internal one
    	SetTraceLogCallback(LogCustom);
    
    	InitWindow(screenWidth, screenHeight, "raylib [core] example - custom logging");
    
    	SetTargetFPS(60);
    	//--------------------------------------------------------------------------------------
    
    	// Main game loop
    	while (!WindowShouldClose())    // Detect window close button or ESC key
    	{
    		// Update
    		//----------------------------------------------------------------------------------
    		// TODO: Update your variables here
    		//----------------------------------------------------------------------------------
    
    		// Draw
    		//----------------------------------------------------------------------------------
    		BeginDrawing();
    
    		ClearBackground(RAYWHITE);
    
    		DrawText("Check out the console output to see the custom logger in action!", 60, 200, 20, LIGHTGRAY);
    
    		EndDrawing();
    		//----------------------------------------------------------------------------------
    	}
    
    	// De-Initialization
    	//--------------------------------------------------------------------------------------
    	CloseWindow();        // Close window and OpenGL context
    	//--------------------------------------------------------------------------------------
    
    	return 0;
    }
        
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - Custom logging
+    *
+    *   This example has been created using raylib 2.1 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2018 Ramon Santamaria (@raysan5) and Pablo Marcos Oltra (@pamarcos)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    // Custom logging funtion
+    void LogCustom(int msgType, const char *text, va_list args)
+    {
+    	char timeStr[64];
+    	time_t now = time(NULL);
+    	struct tm *tm_info = localtime(&now);
+    
+    	strftime(timeStr, sizeof(timeStr), "%Y-%m-%d %H:%M:%S", tm_info);
+    	printf("[%s] ", timeStr);
+    
+    	switch (msgType)
+    	{
+    		case LOG_INFO: printf("[INFO] : "); break;
+    		case LOG_ERROR: printf("[ERROR]: "); break;
+    		case LOG_WARNING: printf("[WARN] : "); break;
+    		case LOG_DEBUG: printf("[DEBUG]: "); break;
+    		default: break;
+    	}
+        
+    	vprintf(text, args);
+    	printf("\n");
+    }
+    
+    public static int core_custom_logging()
+    {
+    	// Initialization
+    	//--------------------------------------------------------------------------------------
+    	int screenWidth = 800;
+    	int screenHeight = 450;
+    
+    	// First thing we do is setting our custom logger to ensure everything raylib logs
+    	// will use our own logger instead of its internal one
+    	SetTraceLogCallback(LogCustom);
+    
+    	InitWindow(screenWidth, screenHeight, "raylib [core] example - custom logging");
+    
+    	SetTargetFPS(60);
+    	//--------------------------------------------------------------------------------------
+    
+    	// Main game loop
+    	while (!WindowShouldClose())    // Detect window close button or ESC key
+    	{
+    		// Update
+    		//----------------------------------------------------------------------------------
+    		// TODO: Update your variables here
+    		//----------------------------------------------------------------------------------
+    
+    		// Draw
+    		//----------------------------------------------------------------------------------
+    		BeginDrawing();
+    
+    		ClearBackground(RAYWHITE);
+    
+    		DrawText("Check out the console output to see the custom logger in action!", 60, 200, 20, LIGHTGRAY);
+    
+    		EndDrawing();
+    		//----------------------------------------------------------------------------------
+    	}
+    
+    	// De-Initialization
+    	//--------------------------------------------------------------------------------------
+    	CloseWindow();        // Close window and OpenGL context
+    	//--------------------------------------------------------------------------------------
+    
+    	return 0;
+    }
+        
 }

Examples/core/core_drop_files.cs

@@ -3,5 +3,79 @@ using static Raylib.Raylib;
 
 public partial class core_drop_files
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - Windows drop files
    *
    *   This example only works on platforms that support drag ref drop (Windows, Linux, OSX, Html5?)
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - drop files");
        
        int count = 0;
        string[] droppedFiles = { };
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsFileDropped())
            {
                droppedFiles = GetDroppedFiles(ref count);
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                if (count == 0) DrawText("Drop your files to this window!", 100, 40, 20, DARKGRAY);
                else
                {
                    DrawText("Dropped files:", 100, 40, 20, DARKGRAY);
                    
                    for (int i = 0; i < count; i++)
                    {
                        if (i%2 == 0) DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.5f));
                        else DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.3f));
                        
                        DrawText(droppedFiles[i], 120, 100 + 40*i, 10, GRAY);
                    }
                    
                    DrawText("Drop new files...", 100, 110 + 40*count, 20, DARKGRAY);
                }
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        ClearDroppedFiles();    // Clear internal buffers
        
        CloseWindow();          // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - Windows drop files
+    *
+    *   This example only works on platforms that support drag ref drop (Windows, Linux, OSX, Html5?)
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - drop files");
+        
+        int count = 0;
+        string[] droppedFiles = { };
+        
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            if (IsFileDropped())
+            {
+                droppedFiles = GetDroppedFiles(ref count);
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                if (count == 0) DrawText("Drop your files to this window!", 100, 40, 20, DARKGRAY);
+                else
+                {
+                    DrawText("Dropped files:", 100, 40, 20, DARKGRAY);
+                    
+                    for (int i = 0; i < count; i++)
+                    {
+                        if (i%2 == 0) DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.5f));
+                        else DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.3f));
+                        
+                        DrawText(droppedFiles[i], 120, 100 + 40*i, 10, GRAY);
+                    }
+                    
+                    DrawText("Drop new files...", 100, 110 + 40*count, 20, DARKGRAY);
+                }
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        ClearDroppedFiles();    // Clear internal buffers
+        
+        CloseWindow();          // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_input_gamepad.cs

@@ -3,170 +3,196 @@ using static Raylib.Raylib;
 // using static Raylib.Gamepad;
 
 public partial class core_input_gamepad
-{
+{
-    /*******************************************************************************************
    *
    *   raylib [core] example - Gamepad input
    *
    *   NOTE: This example requires a Gamepad connected to the system
    *         raylib is configured to work with the following gamepads: 
    *                - Xbox 360 Controller (Xbox 360, Xbox One)
    *                - PLAYSTATION(R)3 Controller 
    *         Check raylib.h for buttons configuration
    *
    *   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) 2013-2016 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
+    /*******************************************************************************************
-
+    *
-
+    *   raylib [core] example - Gamepad input
-    // NOTE: Gamepad name ID depends on drivers and OS
+    *
-    //public const string XBOX360_NAME_ID = "Microsoft;
    //public const string PS3_NAME_ID = "PLAYSTATION(R)3;
    public const string XBOX360_NAME_ID = "Xbox";
    public const string PS3_NAME_ID = "PLAYSTATION(R)3";
+    *   NOTE: This example requires a Gamepad connected to the system
-    public static int Main()
    {
+    *         raylib is configured to work with the following gamepads: 
-        // Initialization
+    *                - Xbox 360 Controller (Xbox 360, Xbox One)
-        //--------------------------------------------------------------------------------------
+    *                - PLAYSTATION(R)3 Controller 
-        int screenWidth = 800;
        int screenHeight = 450;
+    *         Check raylib.h for buttons configuration
-
+    *
-        SetConfigFlags(FLAG_MSAA_4X_HINT);  // Set MSAA 4X hint before windows creation  
+    *   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)
-        InitWindow(screenWidth, screenHeight, "raylib [core] example - gamepad input");
+    *
-
+    *   Copyright (c) 2013-2016 Ramon Santamaria (@raysan5)
-        Texture2D texPs3Pad = LoadTexture("resources/ps3.png");
        Texture2D texXboxPad = LoadTexture("resources/xbox.png");
+    *
-
+    ********************************************************************************************/
-        SetTargetFPS(60);
+
-        //--------------------------------------------------------------------------------------
+
-
+    // NOTE: Gamepad name ID depends on drivers and OS
-        // Main game loop
+    //public const string XBOX360_NAME_ID = "Microsoft;
-        while (!WindowShouldClose())    // Detect window close button or ESC key
+    //public const string PS3_NAME_ID = "PLAYSTATION(R)3;
-        {
+    public const string XBOX360_NAME_ID = "Xbox";
-            // Update
+    public const string PS3_NAME_ID = "PLAYSTATION(R)3";
-            //----------------------------------------------------------------------------------
+
-            // ...
+    public static int Main()
-            //----------------------------------------------------------------------------------
+    {
-
+        // Initialization
-            // Draw
+        //--------------------------------------------------------------------------------------
-            //----------------------------------------------------------------------------------
+        int screenWidth = 800;
-            BeginDrawing();
+        int screenHeight = 450;
-
+
-            ClearBackground(RAYWHITE);
+        SetConfigFlags(FLAG_MSAA_4X_HINT);  // Set MSAA 4X hint before windows creation  
-
+
-            if (IsGamepadAvailable(GAMEPAD_PLAYER1))
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - gamepad input");
-            {
+
-                DrawText(FormatText("GP1: %s", GetGamepadName(GAMEPAD_PLAYER1)), 10, 10, 10, BLACK);
+        Texture2D texPs3Pad = LoadTexture("resources/ps3.png");
-
+        Texture2D texXboxPad = LoadTexture("resources/xbox.png");
-                if (IsGamepadName(GAMEPAD_PLAYER1, XBOX360_NAME_ID))
+
-                {
+        SetTargetFPS(60);
-                    DrawTexture(texXboxPad, 0, 0, DARKGRAY);
+        //--------------------------------------------------------------------------------------
-
+
-                    // Draw buttons: xbox home
+        // Main game loop
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_HOME)) DrawCircle(394, 89, 19, RED);
+        while (!WindowShouldClose())    // Detect window close button or ESC key
-
+        {
-                    // Draw buttons: basic
+            // Update
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_START)) DrawCircle(436, 150, 9, RED);
+            //----------------------------------------------------------------------------------
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_SELECT)) DrawCircle(352, 150, 9, RED);
+            // ...
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_X)) DrawCircle(501, 151, 15, BLUE);
+            //----------------------------------------------------------------------------------
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_A)) DrawCircle(536, 187, 15, LIME);
+
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_B)) DrawCircle(572, 151, 15, MAROON);
+            // Draw
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_Y)) DrawCircle(536, 115, 15, GOLD);
+            //----------------------------------------------------------------------------------
-
+            BeginDrawing();
-                    // Draw buttons: d-pad
+
-                    DrawRectangle(317, 202, 19, 71, BLACK);
+            ClearBackground(RAYWHITE);
-                    DrawRectangle(293, 228, 69, 19, BLACK);
+
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_UP)) DrawRectangle(317, 202, 19, 26, RED);
+            if (IsGamepadAvailable(GAMEPAD_PLAYER1))
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_DOWN)) DrawRectangle(317, 202 + 45, 19, 26, RED);
+            {
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_LEFT)) DrawRectangle(292, 228, 25, 19, RED);
+                DrawText(FormatText("GP1: %s", GetGamepadName(GAMEPAD_PLAYER1)), 10, 10, 10, BLACK);
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_RIGHT)) DrawRectangle(292 + 44, 228, 26, 19, RED);
+
-
+                if (IsGamepadName(GAMEPAD_PLAYER1, XBOX360_NAME_ID))
-                    // Draw buttons: left-right back
+                {
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_LB)) DrawCircle(259, 61, 20, RED);
+                    DrawTexture(texXboxPad, 0, 0, DARKGRAY);
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_RB)) DrawCircle(536, 61, 20, RED);
+
-
+                    // Draw buttons: xbox home
-                    // Draw axis: left joystick
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_HOME)) DrawCircle(394, 89, 19, RED);
-                    DrawCircle(259, 152, 39, BLACK);
+
-                    DrawCircle(259, 152, 34, LIGHTGRAY);
+                    // Draw buttons: basic
-                    DrawCircle(259 + (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LEFT_X) * 20),
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_START)) DrawCircle(436, 150, 9, RED);
-                               152 - (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LEFT_Y) * 20), 25, BLACK);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_SELECT)) DrawCircle(352, 150, 9, RED);
-
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_X)) DrawCircle(501, 151, 15, BLUE);
-                    // Draw axis: right joystick
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_A)) DrawCircle(536, 187, 15, LIME);
-                    DrawCircle(461, 237, 38, BLACK);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_B)) DrawCircle(572, 151, 15, MAROON);
-                    DrawCircle(461, 237, 33, LIGHTGRAY);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_Y)) DrawCircle(536, 115, 15, GOLD);
-                    DrawCircle(461 + (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RIGHT_X) * 20),
+
-                               237 - (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RIGHT_Y) * 20), 25, BLACK);
+                    // Draw buttons: d-pad
-
+                    DrawRectangle(317, 202, 19, 71, BLACK);
-                    // Draw axis: left-right triggers
+                    DrawRectangle(293, 228, 69, 19, BLACK);
-                    DrawRectangle(170, 30, 15, 70, GRAY);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_UP)) DrawRectangle(317, 202, 19, 26, RED);
-                    DrawRectangle(604, 30, 15, 70, GRAY);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_DOWN)) DrawRectangle(317, 202 + 45, 19, 26, RED);
-                    DrawRectangle(170, 30, 15, (int)(((1.0f + GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LT)) / 2.0f) * 70), RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_LEFT)) DrawRectangle(292, 228, 25, 19, RED);
-                    DrawRectangle(604, 30, 15, (int)(((1.0f + GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RT)) / 2.0f) * 70), RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_RIGHT)) DrawRectangle(292 + 44, 228, 26, 19, RED);
-
+
-                    //DrawText(FormatText("Xbox axis LT: %02.02f", GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LT)), 10, 40, 10, BLACK);
+                    // Draw buttons: left-right back
-                    //DrawText(FormatText("Xbox axis RT: %02.02f", GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RT)), 10, 60, 10, BLACK);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_LB)) DrawCircle(259, 61, 20, RED);
-                }
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_RB)) DrawCircle(536, 61, 20, RED);
-                else if (IsGamepadName(GAMEPAD_PLAYER1, PS3_NAME_ID))
+
-                {
+                    // Draw axis: left joystick
-                    DrawTexture(texPs3Pad, 0, 0, DARKGRAY);
+                    DrawCircle(259, 152, 39, BLACK);
-
+                    DrawCircle(259, 152, 34, LIGHTGRAY);
-                    // Draw buttons: ps
+                    DrawCircle(259 + (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LEFT_X) * 20),
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_PS)) DrawCircle(396, 222, 13, RED);
+                               152 - (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LEFT_Y) * 20), 25, BLACK);
-
+
-                    // Draw buttons: basic
+                    // Draw axis: right joystick
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_SELECT)) DrawRectangle(328, 170, 32, 13, RED);
+                    DrawCircle(461, 237, 38, BLACK);
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_START)) DrawTriangle(new Vector2(436, 168), new Vector2(436, 185), new Vector2(
+                    DrawCircle(461, 237, 33, LIGHTGRAY);
-                    464, 177 ), RED);
+                    DrawCircle(461 + (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RIGHT_X) * 20),
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_TRIANGLE)) DrawCircle(557, 144, 13, LIME);
+                               237 - (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RIGHT_Y) * 20), 25, BLACK);
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_CIRCLE)) DrawCircle(586, 173, 13, RED);
+
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_CROSS)) DrawCircle(557, 203, 13, VIOLET);
+                    // Draw axis: left-right triggers
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_SQUARE)) DrawCircle(527, 173, 13, PINK);
+                    DrawRectangle(170, 30, 15, 70, GRAY);
-
+                    DrawRectangle(604, 30, 15, 70, GRAY);
-                    // Draw buttons: d-pad
+                    DrawRectangle(170, 30, 15, (int)(((1.0f + GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LT)) / 2.0f) * 70), RED);
-                    DrawRectangle(225, 132, 24, 84, BLACK);
+                    DrawRectangle(604, 30, 15, (int)(((1.0f + GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RT)) / 2.0f) * 70), RED);
-                    DrawRectangle(195, 161, 84, 25, BLACK);
+
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_UP)) DrawRectangle(225, 132, 24, 29, RED);
+                    //DrawText(FormatText("Xbox axis LT: %02.02f", GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LT)), 10, 40, 10, BLACK);
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_DOWN)) DrawRectangle(225, 132 + 54, 24, 30, RED);
+                    //DrawText(FormatText("Xbox axis RT: %02.02f", GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RT)), 10, 60, 10, BLACK);
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_LEFT)) DrawRectangle(195, 161, 30, 25, RED);
+                }
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_RIGHT)) DrawRectangle(195 + 54, 161, 30, 25, RED);
+                else if (IsGamepadName(GAMEPAD_PLAYER1, PS3_NAME_ID))
-
+                {
-                    // Draw buttons: left-right back buttons
+                    DrawTexture(texPs3Pad, 0, 0, DARKGRAY);
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_L1)) DrawCircle(239, 82, 20, RED);
+
-                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_R1)) DrawCircle(557, 82, 20, RED);
+                    // Draw buttons: ps
-
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_PS)) DrawCircle(396, 222, 13, RED);
-                    // Draw axis: left joystick
+
-                    DrawCircle(319, 255, 35, BLACK);
+                    // Draw buttons: basic
-                    DrawCircle(319, 255, 31, LIGHTGRAY);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_SELECT)) DrawRectangle(328, 170, 32, 13, RED);
-                    DrawCircle(319 + (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_LEFT_X) * 20),
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_START)) DrawTriangle(new Vector2(436, 168), new Vector2(436, 185), new Vector2(
-                               255 + (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_LEFT_Y) * 20), 25, BLACK);
+                    464, 177 ), RED);
-
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_TRIANGLE)) DrawCircle(557, 144, 13, LIME);
-                    // Draw axis: right joystick
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_CIRCLE)) DrawCircle(586, 173, 13, RED);
-                    DrawCircle(475, 255, 35, BLACK);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_CROSS)) DrawCircle(557, 203, 13, VIOLET);
-                    DrawCircle(475, 255, 31, LIGHTGRAY);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_SQUARE)) DrawCircle(527, 173, 13, PINK);
-                    DrawCircle(475 + (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_RIGHT_X) * 20),
+
-                               255 + (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_RIGHT_Y) * 20), 25, BLACK);
+                    // Draw buttons: d-pad
-
+                    DrawRectangle(225, 132, 24, 84, BLACK);
-                    // Draw axis: left-right triggers
+                    DrawRectangle(195, 161, 84, 25, BLACK);
-                    DrawRectangle(169, 48, 15, 70, GRAY);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_UP)) DrawRectangle(225, 132, 24, 29, RED);
-                    DrawRectangle(611, 48, 15, 70, GRAY);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_DOWN)) DrawRectangle(225, 132 + 54, 24, 30, RED);
-                    DrawRectangle(169, 48, 15, (int)(((1.0f - GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_L2)) / 2.0f) * 70), RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_LEFT)) DrawRectangle(195, 161, 30, 25, RED);
-                    DrawRectangle(611, 48, 15, (int)(((1.0f - GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_R2)) / 2.0f) * 70), RED);
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_RIGHT)) DrawRectangle(195 + 54, 161, 30, 25, RED);
-                }
                    else
                    {
+
-                    DrawText("- GENERIC GAMEPAD -", 280, 180, 20, GRAY);
+                    // Draw buttons: left-right back buttons
-
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_L1)) DrawCircle(239, 82, 20, RED);
-                    // TODO: Draw generic gamepad
+                    if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_R1)) DrawCircle(557, 82, 20, RED);
-                }
+
-
+                    // Draw axis: left joystick
-                DrawText(FormatText("DETECTED AXIS [%i]:", GetGamepadAxisCount(GAMEPAD_PLAYER1)), 10, 50, 10, MAROON);
+                    DrawCircle(319, 255, 35, BLACK);
-
+                    DrawCircle(319, 255, 31, LIGHTGRAY);
-                for (int i = 0; i < GetGamepadAxisCount(GAMEPAD_PLAYER1); i++)
+                    DrawCircle(319 + (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_LEFT_X) * 20),
-                {
+                               255 + (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_LEFT_Y) * 20), 25, BLACK);
-                    DrawText(FormatText("AXIS %i: %.02f", i, GetGamepadAxisMovement(GAMEPAD_PLAYER1, i)), 20, 70 + 20 * i, 10, DARKGRAY);
+
-                }
+                    // Draw axis: right joystick
-
+                    DrawCircle(475, 255, 35, BLACK);
-                if (GetGamepadButtonPressed() != -1) DrawText(FormatText("DETECTED BUTTON: %i", GetGamepadButtonPressed()), 10, 430, 10, RED);
+                    DrawCircle(475, 255, 31, LIGHTGRAY);
-                else DrawText("DETECTED BUTTON: NONE", 10, 430, 10, GRAY);
+                    DrawCircle(475 + (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_RIGHT_X) * 20),
-            }
+                               255 + (int)(GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_RIGHT_Y) * 20), 25, BLACK);
-            else
+
-            {
+                    // Draw axis: left-right triggers
-                DrawText("GP1: NOT DETECTED", 10, 10, 10, GRAY);
+                    DrawRectangle(169, 48, 15, 70, GRAY);
-
+                    DrawRectangle(611, 48, 15, 70, GRAY);
-                DrawTexture(texXboxPad, 0, 0, LIGHTGRAY);
+                    DrawRectangle(169, 48, 15, (int)(((1.0f - GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_L2)) / 2.0f) * 70), RED);
-            }
+                    DrawRectangle(611, 48, 15, (int)(((1.0f - GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_R2)) / 2.0f) * 70), RED);
-
+                }
-            EndDrawing();
+                    else
-            //----------------------------------------------------------------------------------
+                    {
-        }
+                    DrawText("- GENERIC GAMEPAD -", 280, 180, 20, GRAY);
-
+
-        // De-Initialization
+                    // TODO: Draw generic gamepad
-        //--------------------------------------------------------------------------------------
+                }
-        UnloadTexture(texPs3Pad);
        UnloadTexture(texXboxPad);
+
-
+                DrawText(FormatText("DETECTED AXIS [%i]:", GetGamepadAxisCount(GAMEPAD_PLAYER1)), 10, 50, 10, MAROON);
-        CloseWindow();        // Close window and OpenGL context
+
-                              //--------------------------------------------------------------------------------------
+                for (int i = 0; i < GetGamepadAxisCount(GAMEPAD_PLAYER1); i++)
-
+                {
-        return 0;
    }
+                    DrawText(FormatText("AXIS %i: %.02f", i, GetGamepadAxisMovement(GAMEPAD_PLAYER1, i)), 20, 70 + 20 * i, 10, DARKGRAY);
+                }
+
+                if (GetGamepadButtonPressed() != -1) DrawText(FormatText("DETECTED BUTTON: %i", GetGamepadButtonPressed()), 10, 430, 10, RED);
+                else DrawText("DETECTED BUTTON: NONE", 10, 430, 10, GRAY);
+            }
+            else
+            {
+                DrawText("GP1: NOT DETECTED", 10, 10, 10, GRAY);
+
+                DrawTexture(texXboxPad, 0, 0, LIGHTGRAY);
+            }
+
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadTexture(texPs3Pad);
+        UnloadTexture(texXboxPad);
+
+        CloseWindow();        // Close window and OpenGL context
+                              //--------------------------------------------------------------------------------------
+
+        return 0;
+    }
 }

Examples/core/core_input_keys.cs

@@ -3,5 +3,62 @@ using static Raylib.Raylib;
 
 public partial class core_input_keys
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - Keyboard input
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - keyboard input");
    
        Vector2 ballPosition = new Vector2( (float)screenWidth/2, (float)screenHeight/2 );
    
        SetTargetFPS(60);       // Set target frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsKeyDown(KEY_RIGHT)) ballPosition.x += 2.0f;
            if (IsKeyDown(KEY_LEFT)) ballPosition.x -= 2.0f;
            if (IsKeyDown(KEY_UP)) ballPosition.y -= 2.0f;
            if (IsKeyDown(KEY_DOWN)) ballPosition.y += 2.0f;
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("move the ball with arrow keys", 10, 10, 20, DARKGRAY);
    
                DrawCircleV(ballPosition, 50, MAROON);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - Keyboard input
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - keyboard input");
+    
+        Vector2 ballPosition = new Vector2( (float)screenWidth/2, (float)screenHeight/2 );
+    
+        SetTargetFPS(60);       // Set target frames-per-second
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            if (IsKeyDown(KEY_RIGHT)) ballPosition.x += 2.0f;
+            if (IsKeyDown(KEY_LEFT)) ballPosition.x -= 2.0f;
+            if (IsKeyDown(KEY_UP)) ballPosition.y -= 2.0f;
+            if (IsKeyDown(KEY_DOWN)) ballPosition.y += 2.0f;
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawText("move the ball with arrow keys", 10, 10, 20, DARKGRAY);
+    
+                DrawCircleV(ballPosition, 50, MAROON);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_input_mouse.cs

@@ -3,5 +3,64 @@ using static Raylib.Raylib;
 
 public partial class core_input_mouse
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - Mouse input
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input");
    
        Vector2 ballPosition = new Vector2( -100.0f, -100.0f );
        Color ballColor = DARKBLUE;
        
        SetTargetFPS(60);
        //---------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            ballPosition = GetMousePosition();
            
            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) ballColor = MAROON;
            else if (IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) ballColor = LIME;
            else if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)) ballColor = DARKBLUE;
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawCircleV(ballPosition, 40, ballColor);
    
                DrawText("move ball with mouse and click mouse button to change color", 10, 10, 20, DARKGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - Mouse input
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input");
+    
+        Vector2 ballPosition = new Vector2( -100.0f, -100.0f );
+        Color ballColor = DARKBLUE;
+        
+        SetTargetFPS(60);
+        //---------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            ballPosition = GetMousePosition();
+            
+            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) ballColor = MAROON;
+            else if (IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) ballColor = LIME;
+            else if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)) ballColor = DARKBLUE;
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawCircleV(ballPosition, 40, ballColor);
+    
+                DrawText("move ball with mouse and click mouse button to change color", 10, 10, 20, DARKGRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_mouse_wheel.cs

@@ -3,9 +3,62 @@ using static Raylib.Raylib;
 
 public partial class core_mouse_wheel
 {
-    /*******************************************************************************************
    *
    *   raylib [core] examples - Mouse wheel
    *
    *   This test has been created using raylib 1.1 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    

    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse wheel");
    
        int boxPositionY = screenHeight/2 - 40;
        int scrollSpeed = 4;            // Scrolling speed in pixels
    
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            boxPositionY -= (GetMouseWheelMove()*scrollSpeed);
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawRectangle(screenWidth/2 - 40, boxPositionY, 80, 80, MAROON);
    
                DrawText("Use mouse wheel to move the cube up and down!", 10, 10, 20, GRAY);
+    /*******************************************************************************************
-                //DrawText(FormatText("Box position Y: %03i", boxPositionY), 10, 40, 20, LIGHTGRAY);
+    *
-                DrawText($"Box position Y: {boxPositionY}", 10, 40, 20, LIGHTGRAY);
+    *   raylib [core] examples - Mouse wheel
-
+    *
-            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    *   This test has been created using raylib 1.1 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse wheel");
+    
+        int boxPositionY = screenHeight/2 - 40;
+        int scrollSpeed = 4;            // Scrolling speed in pixels
+    
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            boxPositionY -= (GetMouseWheelMove()*scrollSpeed);
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawRectangle(screenWidth/2 - 40, boxPositionY, 80, 80, MAROON);
+    
+                DrawText("Use mouse wheel to move the cube up and down!", 10, 10, 20, GRAY);
+                //DrawText(FormatText("Box position Y: %03i", boxPositionY), 10, 40, 20, LIGHTGRAY);
+                DrawText($"Box position Y: {boxPositionY}", 10, 40, 20, LIGHTGRAY);
+
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_random_values.cs

@@ -3,6 +3,69 @@ using static Raylib.Raylib;
 
 public partial class core_random_values
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - Generate random values
    *
    *   This example has been created using raylib 1.1 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - generate random values");
    
        int framesCounter = 0;  // Variable used to count frames
    
        int randValue = GetRandomValue(-8, 5);   // Get a random integer number between -8 and 5 (both included)
    
        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
            //----------------------------------------------------------------------------------
            framesCounter++;
    
            // Every two seconds (120 frames) a new random value is generated
            if (((framesCounter/120)%2) == 1)
            {
                randValue = GetRandomValue(-8, 5);
                framesCounter = 0;
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("Every 2 seconds a new random value is generated:", 130, 100, 20, MAROON);
    
                //DrawText(FormatText("%i", randValue), 360, 180, 80, LIGHTGRAY);
+    /*******************************************************************************************
-                DrawText($"{randValue}", 360, 180, 80, LIGHTGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    *
+    *   raylib [core] example - Generate random values
+    *
+    *   This example has been created using raylib 1.1 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - generate random values");
+    
+        int framesCounter = 0;  // Variable used to count frames
+    
+        int randValue = GetRandomValue(-8, 5);   // Get a random integer number between -8 and 5 (both included)
+    
+        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
+            //----------------------------------------------------------------------------------
+            framesCounter++;
+    
+            // Every two seconds (120 frames) a new random value is generated
+            if (((framesCounter/120)%2) == 1)
+            {
+                randValue = GetRandomValue(-8, 5);
+                framesCounter = 0;
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawText("Every 2 seconds a new random value is generated:", 130, 100, 20, MAROON);
+    
+                //DrawText(FormatText("%i", randValue), 360, 180, 80, LIGHTGRAY);
+                DrawText($"{randValue}", 360, 180, 80, LIGHTGRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_storage_values.cs

@@ -3,15 +3,90 @@ using static Raylib.Raylib;
 
 public partial class core_storage_values
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - Storage save/load values
    *
    *   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) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    // NOTE: Storage positions must start with 0, directly related to file memory layout
    enum StorageData { STORAGE_SCORE = 0, STORAGE_HISCORE };

    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - storage save/load values");
        
        int score = 0;
        int hiscore = 0;
        
        int framesCounter = 0;
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsKeyPressed(KEY_R))
            {
                score = GetRandomValue(1000, 2000);
                hiscore = GetRandomValue(2000, 4000);
            }
            
            if (IsKeyPressed(KEY_ENTER))
            {
                StorageSaveValue((int)StorageData.STORAGE_SCORE, score);
                StorageSaveValue((int)StorageData.STORAGE_HISCORE, hiscore);
            }
            else if (IsKeyPressed(KEY_SPACE))
            {
                // NOTE: If requested position could not be found, value 0 is returned
                score = StorageLoadValue((int)StorageData.STORAGE_SCORE);
                hiscore = StorageLoadValue((int)StorageData.STORAGE_HISCORE);
            }
            
            framesCounter++;
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
+    /*******************************************************************************************
-
+    *
-                // DrawText(FormatText("SCORE: %i", score), 280, 130, 40, MAROON);
+    *   raylib [core] example - Storage save/load values
-                DrawText($"SCORE: {score}", 280, 130, 40, MAROON);
+    *
-                // DrawText(FormatText("HI-SCORE: %i", hiscore), 210, 200, 50, BLACK);
+    *   This example has been created using raylib 1.4 (www.raylib.com)
-                DrawText($"HI-SCORE: {hiscore}", 210, 200, 50, BLACK);
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-
+    *
-                // DrawText(FormatText("frames: %i", framesCounter), 10, 10, 20, LIME);
+    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
-                DrawText($"frames: {framesCounter}", 10, 10, 20, LIME);
+    *
-
+    ********************************************************************************************/
-                DrawText("Press R to generate random numbers", 220, 40, 20, LIGHTGRAY);
                DrawText("Press ENTER to SAVE values", 250, 310, 20, LIGHTGRAY);
                DrawText("Press SPACE to LOAD values", 252, 350, 20, LIGHTGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------   
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    
+    // NOTE: Storage positions must start with 0, directly related to file memory layout
+    enum StorageData { STORAGE_SCORE = 0, STORAGE_HISCORE };
+
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - storage save/load values");
+        
+        int score = 0;
+        int hiscore = 0;
+        
+        int framesCounter = 0;
+        
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            if (IsKeyPressed(KEY_R))
+            {
+                score = GetRandomValue(1000, 2000);
+                hiscore = GetRandomValue(2000, 4000);
+            }
+            
+            if (IsKeyPressed(KEY_ENTER))
+            {
+                StorageSaveValue((int)StorageData.STORAGE_SCORE, score);
+                StorageSaveValue((int)StorageData.STORAGE_HISCORE, hiscore);
+            }
+            else if (IsKeyPressed(KEY_SPACE))
+            {
+                // NOTE: If requested position could not be found, value 0 is returned
+                score = StorageLoadValue((int)StorageData.STORAGE_SCORE);
+                hiscore = StorageLoadValue((int)StorageData.STORAGE_HISCORE);
+            }
+            
+            framesCounter++;
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+
+                // DrawText(FormatText("SCORE: %i", score), 280, 130, 40, MAROON);
+                DrawText($"SCORE: {score}", 280, 130, 40, MAROON);
+                // DrawText(FormatText("HI-SCORE: %i", hiscore), 210, 200, 50, BLACK);
+                DrawText($"HI-SCORE: {hiscore}", 210, 200, 50, BLACK);
+
+                // DrawText(FormatText("frames: %i", framesCounter), 10, 10, 20, LIME);
+                DrawText($"frames: {framesCounter}", 10, 10, 20, LIME);
+
+                DrawText("Press R to generate random numbers", 220, 40, 20, LIGHTGRAY);
+                DrawText("Press ENTER to SAVE values", 250, 310, 20, LIGHTGRAY);
+                DrawText("Press SPACE to LOAD values", 252, 350, 20, LIGHTGRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------   
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_vr_simulator.cs

@@ -6,5 +6,90 @@ using static Raylib.VrDeviceType;
 
 public partial class core_vr_simulator
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - VR Simulator (Oculus Rift CV1 parameters)
    *
    *   This example has been created using raylib 1.7 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 1080;
        int screenHeight = 600;
        
        // NOTE: screenWidth/screenHeight should match VR device aspect ratio
        
        InitWindow(screenWidth, screenHeight, "raylib [core] example - vr simulator");
    
        // Init VR simulator (Oculus Rift CV1 parameters)
        // fails?
        InitVrSimulator(GetVrDeviceInfo((int)HMD_OCULUS_RIFT_CV1));
        
        // Define the camera to look into our 3d world
        Camera3D camera;
        camera.position = new Vector3( 5.0f, 2.0f, 5.0f );    // Camera3D position
        camera.target = new Vector3( 0.0f, 2.0f, 0.0f );      // Camera3D looking at point
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );          // Camera3D up vector (rotation towards target)
        camera.fovy = 60.0f;                                // Camera3D field-of-view Y
        camera.type = (int)CAMERA_PERSPECTIVE;                   // Camera3D type
        
        Vector3 cubePosition = new Vector3( 0.0f, 0.0f, 0.0f );
        
        SetCameraMode(camera, (int)CAMERA_FIRST_PERSON);         // Set first person camera mode
        
        SetTargetFPS(90);                   // Set our game to run at 90 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())        // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            UpdateCamera(ref camera);          // Update camera (simulator mode)
    
            if (IsKeyPressed(KEY_SPACE)) ToggleVrMode();    // Toggle VR mode
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
                
                BeginVrDrawing();
    
                    BeginMode3D(camera);
    
                        DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
                        DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
    
                        DrawGrid(40, 1.0f);
    
                    EndMode3D();
                
                EndVrDrawing();
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseVrSimulator();     // Close VR simulator
        
        CloseWindow();          // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - VR Simulator (Oculus Rift CV1 parameters)
+    *
+    *   This example has been created using raylib 1.7 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 1080;
+        int screenHeight = 600;
+        
+        // NOTE: screenWidth/screenHeight should match VR device aspect ratio
+        
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - vr simulator");
+    
+        // Init VR simulator (Oculus Rift CV1 parameters)
+        // fails?
+        InitVrSimulator(GetVrDeviceInfo((int)HMD_OCULUS_RIFT_CV1));
+        
+        // Define the camera to look into our 3d world
+        Camera3D camera;
+        camera.position = new Vector3( 5.0f, 2.0f, 5.0f );    // Camera3D position
+        camera.target = new Vector3( 0.0f, 2.0f, 0.0f );      // Camera3D looking at point
+        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );          // Camera3D up vector (rotation towards target)
+        camera.fovy = 60.0f;                                // Camera3D field-of-view Y
+        camera.type = (int)CAMERA_PERSPECTIVE;                   // Camera3D type
+        
+        Vector3 cubePosition = new Vector3( 0.0f, 0.0f, 0.0f );
+        
+        SetCameraMode(camera, (int)CAMERA_FIRST_PERSON);         // Set first person camera mode
+        
+        SetTargetFPS(90);                   // Set our game to run at 90 frames-per-second
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())        // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            UpdateCamera(ref camera);          // Update camera (simulator mode)
+    
+            if (IsKeyPressed(KEY_SPACE)) ToggleVrMode();    // Toggle VR mode
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+                
+                BeginVrDrawing();
+    
+                    BeginMode3D(camera);
+    
+                        DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
+                        DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
+    
+                        DrawGrid(40, 1.0f);
+    
+                    EndMode3D();
+                
+                EndVrDrawing();
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseVrSimulator();     // Close VR simulator
+        
+        CloseWindow();          // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/core/core_world_screen.cs

@@ -5,5 +5,82 @@ using static Raylib.CameraMode;
 
 public partial class core_world_screen
 {
-    /*******************************************************************************************
    *
    *   raylib [core] example - World to screen
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free");
    
        // Define the camera to look into our 3d world
        Camera3D camera = new Camera3D();
        camera.position = new Vector3( 10.0f, 10.0f, 10.0f );
        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );
        camera.fovy = 45.0f;
        camera.type = (int)CAMERA_PERSPECTIVE;
    
        Vector3 cubePosition = new Vector3( 0.0f, 0.0f, 0.0f );
        
        Vector2 cubeScreenPosition;
        
        SetCameraMode(camera, (int)CAMERA_FREE); // Set a free camera mode
    
        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
            //----------------------------------------------------------------------------------
            UpdateCamera(ref camera);          // Update camera
            
            // Calculate cube screen space position (with a little offset to be in top)
            cubeScreenPosition = GetWorldToScreen(new Vector3(cubePosition.x, cubePosition.y + 2.5f, cubePosition.z), camera);
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
                    DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
    
                    DrawGrid(10, 1.0f);
    
                EndMode3D();
                
                DrawText("Enemy: 100 / 100", (int)cubeScreenPosition.x - MeasureText("Enemy: 100 / 100", 20) / 2, (int)cubeScreenPosition.y, 20, BLACK);
                DrawText("Text is always on top of the cube", (screenWidth - MeasureText("Text is always on top of the cube", 20)) / 2, 25, 20, GRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - World to screen
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free");
+    
+        // Define the camera to look into our 3d world
+        Camera3D camera = new Camera3D();
+        camera.position = new Vector3( 10.0f, 10.0f, 10.0f );
+        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );
+        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );
+        camera.fovy = 45.0f;
+        camera.type = (int)CAMERA_PERSPECTIVE;
+    
+        Vector3 cubePosition = new Vector3( 0.0f, 0.0f, 0.0f );
+        
+        Vector2 cubeScreenPosition;
+        
+        SetCameraMode(camera, (int)CAMERA_FREE); // Set a free camera mode
+    
+        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
+            //----------------------------------------------------------------------------------
+            UpdateCamera(ref camera);          // Update camera
+            
+            // Calculate cube screen space position (with a little offset to be in top)
+            cubeScreenPosition = GetWorldToScreen(new Vector3(cubePosition.x, cubePosition.y + 2.5f, cubePosition.z), camera);
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
+                    DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
+    
+                    DrawGrid(10, 1.0f);
+    
+                EndMode3D();
+                
+                DrawText("Enemy: 100 / 100", (int)cubeScreenPosition.x - MeasureText("Enemy: 100 / 100", 20) / 2, (int)cubeScreenPosition.y, 20, BLACK);
+                DrawText("Text is always on top of the cube", (screenWidth - MeasureText("Text is always on top of the cube", 20)) / 2, 25, 20, GRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/models/models_billboard.cs

@@ -5,5 +5,78 @@ using static Raylib.CameraMode;
 
 public partial class models_billboard
 {
-    /*******************************************************************************************
    *
    *   raylib [models] example - Drawing billboards
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - drawing billboards");
    
        // Define the camera to look into our 3d world
        Camera3D camera = new Camera3D();
        camera.position = new Vector3( 5.0f, 4.0f, 5.0f );
        camera.target = new Vector3( 0.0f, 2.0f, 0.0f );
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );
        camera.fovy = 45.0f;
        camera.type = CAMERA_PERSPECTIVE;
           
        Texture2D bill = LoadTexture("resources/billboard.png");     // Our texture billboard
        Vector3 billPosition = new Vector3( 0.0f, 2.0f, 0.0f );                 // Position where draw billboard
        
        SetCameraMode(camera, (int)CAMERA_ORBITAL);  // Set an orbital camera mode
    
        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
            //----------------------------------------------------------------------------------
            UpdateCamera(ref camera);              // Update camera
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
                
                    DrawBillboard(camera, bill, billPosition, 2.0f, WHITE);
                    
                    DrawGrid(10, 1.0f);        // Draw a grid
    
                EndMode3D();
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadTexture(bill);        // Unload texture
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Drawing billboards
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - drawing billboards");
+    
+        // Define the camera to look into our 3d world
+        Camera3D camera = new Camera3D();
+        camera.position = new Vector3( 5.0f, 4.0f, 5.0f );
+        camera.target = new Vector3( 0.0f, 2.0f, 0.0f );
+        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );
+        camera.fovy = 45.0f;
+        camera.type = CAMERA_PERSPECTIVE;
+           
+        Texture2D bill = LoadTexture("resources/billboard.png");     // Our texture billboard
+        Vector3 billPosition = new Vector3( 0.0f, 2.0f, 0.0f );                 // Position where draw billboard
+        
+        SetCameraMode(camera, (int)CAMERA_ORBITAL);  // Set an orbital camera mode
+    
+        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
+            //----------------------------------------------------------------------------------
+            UpdateCamera(ref camera);              // Update camera
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+                
+                    DrawBillboard(camera, bill, billPosition, 2.0f, WHITE);
+                    
+                    DrawGrid(10, 1.0f);        // Draw a grid
+    
+                EndMode3D();
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadTexture(bill);        // Unload texture
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/models/models_cubicmap.cs

@@ -5,5 +5,90 @@ using static Raylib.TexmapIndex;
 
 public partial class models_cubicmap
 {
-    /*******************************************************************************************
    *
    *   raylib [models] example - Cubicmap loading and drawing
    *
    *   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) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - cubesmap loading and drawing");
    
        // Define the camera to look into our 3d world
        Camera3D camera = new Camera3D(new Vector3( 16.0f, 14.0f, 16.0f ), new Vector3( 0.0f, 0.0f, 0.0f ), new Vector3( 0.0f, 1.0f, 0.0f ), 45.0f, 0 );
    
        Image image = LoadImage("resources/cubicmap.png");      // Load cubicmap image (RAM)
        Texture2D cubicmap = LoadTextureFromImage(image);       // Convert image to texture to display (VRAM)
        
        Mesh mesh = GenMeshCubicmap(image, new Vector3( 1.0f, 1.0f, 1.0f ));
        Model model = LoadModelFromMesh(mesh);
        
        // NOTE: By default each cube is mapped to one part of texture atlas
        Texture2D texture = LoadTexture("resources/cubicmap_atlas.png");    // Load map texture
        model.material.maps[(int)MAP_ALBEDO].texture = texture;                 // Set map diffuse texture
        
        Vector3 mapPosition = new Vector3( -16.0f, 0.0f, -8.0f );          // Set model position
    
        UnloadImage(image);     // Unload cubesmap image from RAM, already uploaded to VRAM
        
        SetCameraMode(camera, (int)CAMERA_ORBITAL);  // Set an orbital camera mode
    
        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
            //----------------------------------------------------------------------------------
            UpdateCamera(ref camera);              // Update camera
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawModel(model, mapPosition, 1.0f, WHITE);
    
                EndMode3D();
                
                DrawTextureEx(cubicmap, new Vector2( screenWidth - cubicmap.width*4 - 20, 20 ), 0.0f, 4.0f, WHITE);
                DrawRectangleLines(screenWidth - cubicmap.width*4 - 20, 20, cubicmap.width*4, cubicmap.height*4, GREEN);
                
                DrawText("cubicmap image used to", 658, 90, 10, GRAY);
                DrawText("generate map 3d model", 658, 104, 10, GRAY);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadTexture(cubicmap);    // Unload cubicmap texture
        UnloadTexture(texture);     // Unload map texture
        UnloadModel(model);         // Unload map model
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }  
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Cubicmap loading and drawing
+    *
+    *   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) 2015 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - cubesmap loading and drawing");
+    
+        // Define the camera to look into our 3d world
+        Camera3D camera = new Camera3D(new Vector3( 16.0f, 14.0f, 16.0f ), new Vector3( 0.0f, 0.0f, 0.0f ), new Vector3( 0.0f, 1.0f, 0.0f ), 45.0f, 0 );
+    
+        Image image = LoadImage("resources/cubicmap.png");      // Load cubicmap image (RAM)
+        Texture2D cubicmap = LoadTextureFromImage(image);       // Convert image to texture to display (VRAM)
+        
+        Mesh mesh = GenMeshCubicmap(image, new Vector3( 1.0f, 1.0f, 1.0f ));
+        Model model = LoadModelFromMesh(mesh);
+        
+        // NOTE: By default each cube is mapped to one part of texture atlas
+        Texture2D texture = LoadTexture("resources/cubicmap_atlas.png");    // Load map texture
+        model.material.maps[(int)MAP_ALBEDO].texture = texture;                 // Set map diffuse texture
+        
+        Vector3 mapPosition = new Vector3( -16.0f, 0.0f, -8.0f );          // Set model position
+    
+        UnloadImage(image);     // Unload cubesmap image from RAM, already uploaded to VRAM
+        
+        SetCameraMode(camera, (int)CAMERA_ORBITAL);  // Set an orbital camera mode
+    
+        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
+            //----------------------------------------------------------------------------------
+            UpdateCamera(ref camera);              // Update camera
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawModel(model, mapPosition, 1.0f, WHITE);
+    
+                EndMode3D();
+                
+                DrawTextureEx(cubicmap, new Vector2( screenWidth - cubicmap.width*4 - 20, 20 ), 0.0f, 4.0f, WHITE);
+                DrawRectangleLines(screenWidth - cubicmap.width*4 - 20, 20, cubicmap.width*4, cubicmap.height*4, GREEN);
+                
+                DrawText("cubicmap image used to", 658, 90, 10, GRAY);
+                DrawText("generate map 3d model", 658, 104, 10, GRAY);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadTexture(cubicmap);    // Unload cubicmap texture
+        UnloadTexture(texture);     // Unload map texture
+        UnloadModel(model);         // Unload map model
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }  
 }

Examples/models/models_geometric_shapes.cs

@@ -4,5 +4,83 @@ using static Raylib.CameraType;
 
 public partial class models_geometric_shapes
 {
-    /*******************************************************************************************
    *
    *   raylib [models] example - Draw some basic geometric shapes (cube, sphere, cylinder...)
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
    
        // Define the camera to look into our 3d world
        Camera3D camera = new Camera3D();
        camera.position = new Vector3( 0.0f, 10.0f, 10.0f );
        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );
        camera.fovy = 45.0f;
        camera.type = CAMERA_PERSPECTIVE;
    
        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);
    
                BeginMode3D(camera);
    
                    DrawCube(new Vector3(-4.0f, 0.0f, 2.0f), 2.0f, 5.0f, 2.0f, RED);
                    DrawCubeWires(new Vector3(-4.0f, 0.0f, 2.0f), 2.0f, 5.0f, 2.0f, GOLD);
                    DrawCubeWires(new Vector3(-4.0f, 0.0f, -2.0f), 3.0f, 6.0f, 2.0f, MAROON);
    
                    DrawSphere(new Vector3(-1.0f, 0.0f, -2.0f), 1.0f, GREEN);
                    DrawSphereWires(new Vector3(1.0f, 0.0f, 2.0f), 2.0f, 16, 16, LIME);
    
                    DrawCylinder(new Vector3(4.0f, 0.0f, -2.0f), 1.0f, 2.0f, 3.0f, 4, SKYBLUE);
                    DrawCylinderWires(new Vector3(4.0f, 0.0f, -2.0f), 1.0f, 2.0f, 3.0f, 4, DARKBLUE);
                    DrawCylinderWires(new Vector3(4.5f, -1.0f, 2.0f), 1.0f, 1.0f, 2.0f, 6, BROWN);
    
                    DrawCylinder(new Vector3(1.0f, 0.0f, -4.0f), 0.0f, 1.5f, 3.0f, 8, GOLD);
                    DrawCylinderWires(new Vector3(1.0f, 0.0f, -4.0f), 0.0f, 1.5f, 3.0f, 8, PINK);
    
                    DrawGrid(10, 1.0f);        // Draw a grid
    
                EndMode3D();
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Draw some basic geometric shapes (cube, sphere, cylinder...)
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
+    
+        // Define the camera to look into our 3d world
+        Camera3D camera = new Camera3D();
+        camera.position = new Vector3( 0.0f, 10.0f, 10.0f );
+        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );
+        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );
+        camera.fovy = 45.0f;
+        camera.type = CAMERA_PERSPECTIVE;
+    
+        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);
+    
+                BeginMode3D(camera);
+    
+                    DrawCube(new Vector3(-4.0f, 0.0f, 2.0f), 2.0f, 5.0f, 2.0f, RED);
+                    DrawCubeWires(new Vector3(-4.0f, 0.0f, 2.0f), 2.0f, 5.0f, 2.0f, GOLD);
+                    DrawCubeWires(new Vector3(-4.0f, 0.0f, -2.0f), 3.0f, 6.0f, 2.0f, MAROON);
+    
+                    DrawSphere(new Vector3(-1.0f, 0.0f, -2.0f), 1.0f, GREEN);
+                    DrawSphereWires(new Vector3(1.0f, 0.0f, 2.0f), 2.0f, 16, 16, LIME);
+    
+                    DrawCylinder(new Vector3(4.0f, 0.0f, -2.0f), 1.0f, 2.0f, 3.0f, 4, SKYBLUE);
+                    DrawCylinderWires(new Vector3(4.0f, 0.0f, -2.0f), 1.0f, 2.0f, 3.0f, 4, DARKBLUE);
+                    DrawCylinderWires(new Vector3(4.5f, -1.0f, 2.0f), 1.0f, 1.0f, 2.0f, 6, BROWN);
+    
+                    DrawCylinder(new Vector3(1.0f, 0.0f, -4.0f), 0.0f, 1.5f, 3.0f, 8, GOLD);
+                    DrawCylinderWires(new Vector3(1.0f, 0.0f, -4.0f), 0.0f, 1.5f, 3.0f, 8, PINK);
+    
+                    DrawGrid(10, 1.0f);        // Draw a grid
+    
+                EndMode3D();
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/models/models_heightmap.cs

@@ -5,5 +5,85 @@ using static Raylib.TexmapIndex;
 
 public partial class models_heightmap
 {
-    /*******************************************************************************************
    *
    *   raylib [models] example - Heightmap loading and drawing
    *
    *   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) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - heightmap loading and drawing");
    
        // Define our custom camera to look into our 3d world
        Camera3D camera = new Camera3D(new Vector3( 18.0f, 16.0f, 18.0f ), new Vector3( 0.0f, 0.0f, 0.0f ), new Vector3( 0.0f, 1.0f, 0.0f ), 45.0f, 0 );
    
        Image image = LoadImage("resources/heightmap.png");             // Load heightmap image (RAM)
        Texture2D texture = LoadTextureFromImage(image);                // Convert image to texture (VRAM)
        
        Mesh mesh = GenMeshHeightmap(image, new Vector3( 16, 8, 16 ));    // Generate heightmap mesh (RAM and VRAM)
        Model model = LoadModelFromMesh(mesh);                          // Load model from generated mesh
    
        model.material.maps[(int)MAP_ALBEDO].texture = texture;             // Set map diffuse texture
        Vector3 mapPosition = new Vector3( -8.0f, 0.0f, -8.0f );                   // Define model position
    
        UnloadImage(image);                     // Unload heightmap image from RAM, already uploaded to VRAM
        
        SetCameraMode(camera, (int)CAMERA_ORBITAL);  // Set an orbital camera mode
    
        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
            //----------------------------------------------------------------------------------
            UpdateCamera(ref camera);              // Update camera
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawModel(model, mapPosition, 1.0f, RED);
    
                    DrawGrid(20, 1.0f);
    
                EndMode3D();
                
                DrawTexture(texture, screenWidth - texture.width - 20, 20, WHITE);
                DrawRectangleLines(screenWidth - texture.width - 20, 20, texture.width, texture.height, GREEN);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadTexture(texture);     // Unload texture
        UnloadModel(model);         // Unload model
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Heightmap loading and drawing
+    *
+    *   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) 2015 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - heightmap loading and drawing");
+    
+        // Define our custom camera to look into our 3d world
+        Camera3D camera = new Camera3D(new Vector3( 18.0f, 16.0f, 18.0f ), new Vector3( 0.0f, 0.0f, 0.0f ), new Vector3( 0.0f, 1.0f, 0.0f ), 45.0f, 0 );
+    
+        Image image = LoadImage("resources/heightmap.png");             // Load heightmap image (RAM)
+        Texture2D texture = LoadTextureFromImage(image);                // Convert image to texture (VRAM)
+        
+        Mesh mesh = GenMeshHeightmap(image, new Vector3( 16, 8, 16 ));    // Generate heightmap mesh (RAM and VRAM)
+        Model model = LoadModelFromMesh(mesh);                          // Load model from generated mesh
+    
+        model.material.maps[(int)MAP_ALBEDO].texture = texture;             // Set map diffuse texture
+        Vector3 mapPosition = new Vector3( -8.0f, 0.0f, -8.0f );                   // Define model position
+    
+        UnloadImage(image);                     // Unload heightmap image from RAM, already uploaded to VRAM
+        
+        SetCameraMode(camera, (int)CAMERA_ORBITAL);  // Set an orbital camera mode
+    
+        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
+            //----------------------------------------------------------------------------------
+            UpdateCamera(ref camera);              // Update camera
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawModel(model, mapPosition, 1.0f, RED);
+    
+                    DrawGrid(20, 1.0f);
+    
+                EndMode3D();
+                
+                DrawTexture(texture, screenWidth - texture.width - 20, 20, WHITE);
+                DrawRectangleLines(screenWidth - texture.width - 20, 20, texture.width, texture.height, GREEN);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadTexture(texture);     // Unload texture
+        UnloadModel(model);         // Unload model
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/models/models_material_pbr.cs

@@ -4,237 +4,270 @@ using static Raylib.Model;
 using static Raylib.CameraMode;
 using System;
 
-public enum LightType
+public enum LightType
-{
+{
-	LIGHT_DIRECTIONAL,
+	LIGHT_DIRECTIONAL,
 	LIGHT_POINT
-};
+};
-
+
-//TODO: move the light system out into it's own class file, rlights.h original
+//TODO: move the light system out into it's own class file, rlights.h original
-//also make it work properly
+//also make it work properly
-public struct Light
+public struct Light
-{
+{
-	public bool enabled;
+	public bool enabled;
-	public LightType type;
+	public LightType type;
-	public Vector3 position;
+	public Vector3 position;
-	public Vector3 target;
+	public Vector3 target;
-	public Color color;
+	public Color color;
-	public int enabledLoc;
+	public int enabledLoc;
-	public int typeLoc;
+	public int typeLoc;
-	public int posLoc;
+	public int posLoc;
-	public int targetLoc;
+	public int targetLoc;
-	public int colorLoc;
+	public int colorLoc;
 }
 
 
 public partial class models_material_pbr
-{
+{
-	/*******************************************************************************************
	*
	*   raylib [models] example - PBR material
	*
	*   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)
	*
	********************************************************************************************/
+	/*******************************************************************************************
-
+	*
-	public const int CUBEMAP_SIZE = 512;
+	*   raylib [models] example - PBR material
-	public const int IRRADIANCE_SIZE = 32;
+	*
-	public const int PREFILTERED_SIZE = 256;
+	*   This example has been created using raylib 1.8 (www.raylib.com)
-	public const int BRDF_SIZE = 512;
+	*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-
+	*
-	// PBR material loading
+	*   Copyright (c) 2017 Ramon Santamaria (@raysan5)
-	//private static Material LoadMaterialPBR(Color albedo, float metalness, float roughness);
+	*
-
+	********************************************************************************************/
-	public static int Main()
+
-	{
+	public const int CUBEMAP_SIZE = 512;
-		// Initialization
+	public const int IRRADIANCE_SIZE = 32;
-		//--------------------------------------------------------------------------------------
+	public const int PREFILTERED_SIZE = 256;
-		int screenWidth = 800;
+	public const int BRDF_SIZE = 512;
-		int screenHeight = 450;
+
-
+	// PBR material loading
-		float LIGHT_DISTANCE = 3.5f;
+	//private static Material LoadMaterialPBR(Color albedo, float metalness, float roughness);
-		float LIGHT_HEIGHT = 1.0f;
+
-
+	public static int Main()
-		SetConfigFlags(FLAG_MSAA_4X_HINT);  // Enable Multi Sampling Anti Aliasing 4x (if available)
+	{
-		InitWindow(screenWidth, screenHeight, "raylib [models] example - pbr material");
+		// Initialization
-
+		//--------------------------------------------------------------------------------------
-		// Define the camera to look into our 3d world
+		int screenWidth = 800;
-		Camera3D camera = new Camera3D(new Vector3(4.0f, 4.0f, 4.0f), new Vector3(0.0f, 0.5f, 0.0f), new Vector3(0.0f, 1.0f, 0.0f), 45.0f, 0);
+		int screenHeight = 450;
-
+
-		// Load model and PBR material
+		float LIGHT_DISTANCE = 3.5f;
-		Model model = LoadModel("resources/pbr/trooper.obj");
+		float LIGHT_HEIGHT = 1.0f;
-		MeshTangents(ref model.mesh);
+
-		model.material = LoadMaterialPBR(new Color(255, 255, 255, 255), 1.0f, 1.0f);
+		SetConfigFlags(FLAG_MSAA_4X_HINT);  // Enable Multi Sampling Anti Aliasing 4x (if available)
-
+		InitWindow(screenWidth, screenHeight, "raylib [models] example - pbr material");
-		// Define lights attributes
+
-		// NOTE: Shader is passed to every light on creation to define shader bindings internally
+		// Define the camera to look into our 3d world
-		Light[] lights = new Light[]
+		Camera3D camera = new Camera3D(new Vector3(4.0f, 4.0f, 4.0f), new Vector3(0.0f, 0.5f, 0.0f), new Vector3(0.0f, 1.0f, 0.0f), 45.0f, 0);
-		{
+
-			CreateLight(LightType.LIGHT_POINT, new Vector3( LIGHT_DISTANCE, LIGHT_HEIGHT, 0.0f ), new Vector3( 0.0f, 0.0f, 0.0f ), new Color( 255, 0, 0, 255 ), model.material.shader),
+		// Load model and PBR material
-			CreateLight(LightType.LIGHT_POINT, new Vector3( 0.0f, LIGHT_HEIGHT, LIGHT_DISTANCE ), new Vector3( 0.0f, 0.0f, 0.0f ), new Color( 0, 255, 0, 255 ), model.material.shader),
+		Model model = LoadModel("resources/pbr/trooper.obj");
-			CreateLight(LightType.LIGHT_POINT, new Vector3( -LIGHT_DISTANCE, LIGHT_HEIGHT, 0.0f ), new Vector3( 0.0f, 0.0f, 0.0f ),new Color( 0, 0, 255, 255 ), model.material.shader),
			CreateLight(LightType.LIGHT_DIRECTIONAL, new Vector3(0.0f, LIGHT_HEIGHT * 2.0f, -LIGHT_DISTANCE ), new Vector3( 0.0f, 0.0f, 0.0f ), new Color(255, 0, 255, 255 ), model.material.shader)
+		MeshTangents(ref model.mesh);
-		};
+		model.material = LoadMaterialPBR(new Color(255, 255, 255, 255), 1.0f, 1.0f);
-
+
-		SetCameraMode(camera, (int)CameraMode.CAMERA_ORBITAL);  // Set an orbital camera mode
+		// Define lights attributes
-
+		// NOTE: Shader is passed to every light on creation to define shader bindings internally
-		SetTargetFPS(60); // Set our game to run at 60 frames-per-second
+		Light[] lights = new Light[]
-						  //--------------------------------------------------------------------------------------
+		{
-
+			CreateLight(LightType.LIGHT_POINT, new Vector3( LIGHT_DISTANCE, LIGHT_HEIGHT, 0.0f ), new Vector3( 0.0f, 0.0f, 0.0f ), new Color( 255, 0, 0, 255 ), model.material.shader),
-		// Main game loop
+			CreateLight(LightType.LIGHT_POINT, new Vector3( 0.0f, LIGHT_HEIGHT, LIGHT_DISTANCE ), new Vector3( 0.0f, 0.0f, 0.0f ), new Color( 0, 255, 0, 255 ), model.material.shader),
-		while (!WindowShouldClose()) // Detect window close button or ESC key
+			CreateLight(LightType.LIGHT_POINT, new Vector3( -LIGHT_DISTANCE, LIGHT_HEIGHT, 0.0f ), new Vector3( 0.0f, 0.0f, 0.0f ),new Color( 0, 0, 255, 255 ), model.material.shader),
-		{
+			CreateLight(LightType.LIGHT_DIRECTIONAL, new Vector3(0.0f, LIGHT_HEIGHT * 2.0f, -LIGHT_DISTANCE ), new Vector3( 0.0f, 0.0f, 0.0f ), new Color(255, 0, 255, 255 ), model.material.shader)
-			// Update
+		};
-			//----------------------------------------------------------------------------------
+
-			UpdateCamera(ref camera);              // Update camera
+		SetCameraMode(camera, (int)CameraMode.CAMERA_ORBITAL);  // Set an orbital camera mode
-
+
-			// Send to material PBR shader camera view position
+		SetTargetFPS(60); // Set our game to run at 60 frames-per-second
-			float[] cameraPos = { camera.position.x, camera.position.y, camera.position.z };
+						  //--------------------------------------------------------------------------------------
-			SetShaderValue(model.material.shader, 0, cameraPos, 3); //(int)model.material.shader.locs, cameraPos, 3);
+
-																	//----------------------------------------------------------------------------------
+		// Main game loop
-																	// Draw
+		while (!WindowShouldClose()) // Detect window close button or ESC key
-																	//----------------------------------------------------------------------------------
+		{
-			BeginDrawing();
+			// Update
-
+			//----------------------------------------------------------------------------------
-			ClearBackground(RAYWHITE);
+			UpdateCamera(ref camera);              // Update camera
-
+
-			BeginMode3D(camera);
+			// Send to material PBR shader camera view position
-
+			float[] cameraPos = { camera.position.x, camera.position.y, camera.position.z };
-			DrawModel(model, Vector3Zero(), 1.0f, WHITE);
+			SetShaderValue(model.material.shader, 0, cameraPos, 3); //(int)model.material.shader.locs, cameraPos, 3);
-
+																	//----------------------------------------------------------------------------------
-			DrawGrid(10, 1.0f);
+																	// Draw
-
+																	//----------------------------------------------------------------------------------
-			EndMode3D();
+			BeginDrawing();
-
+
-			DrawFPS(10, 10);
+			ClearBackground(RAYWHITE);
-
+
-			EndDrawing();
+			BeginMode3D(camera);
-			//----------------------------------------------------------------------------------
+
-		}
+			DrawModel(model, Vector3Zero(), 1.0f, WHITE);
-
+
-		// De-Initialization
+			DrawGrid(10, 1.0f);
-		//--------------------------------------------------------------------------------------
+
-		UnloadModel(model);         // Unload skybox model
+			EndMode3D();
-
+
-		CloseWindow();              // Close window and OpenGL context
+			DrawFPS(10, 10);
-									//--------------------------------------------------------------------------------------
+
-		return 0;
	}

	public static Light CreateLight(LightType type, Vector3 pos, Vector3 targ, Color color, Shader shader)
+			EndDrawing();
-	{
+			//----------------------------------------------------------------------------------
-		Light light = new Light() {
+		}
-			enabled = true,
+
-			type = type,
+		// De-Initialization
-			position = pos,
+		//--------------------------------------------------------------------------------------
-			target = targ,
+		UnloadModel(model);         // Unload skybox model
-			color = color,
+
-		};
+		CloseWindow();              // Close window and OpenGL context
-
+									//--------------------------------------------------------------------------------------
-		string enabledName = "lights[x].enabled\0";
+		return 0;
-		string typeName = "lights[x].type\0";
+	}
-		string posName = "lights[x].position\0";
+
-		string targetName = "lights[x].target\0";
+	public static Light CreateLight(LightType type, Vector3 pos, Vector3 targ, Color color, Shader shader)
-		string colorName = "lights[x].color\0";
+	{
-
+		Light light = new Light() {
-		light.enabledLoc = GetShaderLocation(shader, enabledName);
+			enabled = true,
-		light.typeLoc = GetShaderLocation(shader, typeName);
+			type = type,
-		light.posLoc = GetShaderLocation(shader, posName);
+			position = pos,
-		light.targetLoc = GetShaderLocation(shader, targetName);
+			target = targ,
-		light.colorLoc = GetShaderLocation(shader, colorName);
+			color = color,
-
+		};
-		UpdateLightValues(shader, light);
+
-
+		string enabledName = "lights[x].enabled\0";
-		return light;
+		string typeName = "lights[x].type\0";
-	}
+		string posName = "lights[x].position\0";
-
+		string targetName = "lights[x].target\0";
-	public static void UpdateLightValues(Shader shader, Light light)
+		string colorName = "lights[x].color\0";
-	{
+
-		// Send to shader light enabled state and type
+		light.enabledLoc = GetShaderLocation(shader, enabledName);
-		SetShaderValuei(shader, light.enabledLoc, new int[] { Convert.ToInt32(light.enabled) }, 1);
+		light.typeLoc = GetShaderLocation(shader, typeName);
-		SetShaderValuei(shader, light.typeLoc, new int[] { Convert.ToInt32(light.type) }, 1);
+		light.posLoc = GetShaderLocation(shader, posName);
-
+		light.targetLoc = GetShaderLocation(shader, targetName);
-		// Send to shader light position values
+		light.colorLoc = GetShaderLocation(shader, colorName);
-		float[] position = { light.position.x, light.position.y, light.position.z };
+
-		SetShaderValue(shader, light.posLoc, position, 3);
+		UpdateLightValues(shader, light);
-
+
-		// Send to shader light target position values
+		return light;
-		float[] target = { light.target.x, light.target.y, light.target.z };
+	}
-		SetShaderValue(shader, light.targetLoc, target, 3);
+
-
+	public static void UpdateLightValues(Shader shader, Light light)
-		// Send to shader light color values
+	{
-		float[] diff = { light.color.r / 255, light.color.g / 255, light.color.b / 255, light.color.a / 255 };
+		// Send to shader light enabled state and type
-		SetShaderValue(shader, light.colorLoc, diff, 4);
+		SetShaderValuei(shader, light.enabledLoc, new int[] { Convert.ToInt32(light.enabled) }, 1);
-	}
+		SetShaderValuei(shader, light.typeLoc, new int[] { Convert.ToInt32(light.type) }, 1);
-
+
-	// Load PBR material (Supports: ALBEDO, NORMAL, METALNESS, ROUGHNESS, AO, EMMISIVE, HEIGHT maps)
+		// Send to shader light position values
-	// NOTE: PBR shader is loaded inside this function
+		float[] position = { light.position.x, light.position.y, light.position.z };
-	unsafe public static Material LoadMaterialPBR(Color albedo, float metalness, float roughness)
+		SetShaderValue(shader, light.posLoc, position, 3);
-	{
+
-		Material mat = new Material();   // NOTE: All maps textures are set to { 0 )
+		// Send to shader light target position values
-
+		float[] target = { light.target.x, light.target.y, light.target.z };
-		string PATH_PBR_VS = "resources/shaders/pbr.vs";
+		SetShaderValue(shader, light.targetLoc, target, 3);
-		string PATH_PBR_FS = "resources/shaders/pbr.fs";
+
-
+		// Send to shader light color values
-		mat.shader = LoadShader(PATH_PBR_VS, PATH_PBR_FS);
+		float[] diff = { light.color.r / 255, light.color.g / 255, light.color.b / 255, light.color.a / 255 };
-
+		SetShaderValue(shader, light.colorLoc, diff, 4);
-		// Get required locations points for PBR material
+	}
-		// NOTE: Those location names must be available and used in the shader code
+
-
+	// Load PBR material (Supports: ALBEDO, NORMAL, METALNESS, ROUGHNESS, AO, EMMISIVE, HEIGHT maps)
-		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_ALBEDO] = GetShaderLocation(mat.shader, "albedo.sampler");
+	// NOTE: PBR shader is loaded inside this function
-		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_METALNESS] = GetShaderLocation(mat.shader, "metalness.sampler");
+	unsafe public static Material LoadMaterialPBR(Color albedo, float metalness, float roughness)
-		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_NORMAL] = GetShaderLocation(mat.shader, "normals.sampler");
+	{
-		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_ROUGHNESS] = GetShaderLocation(mat.shader, "roughness.sampler");
+		Material mat = new Material();   // NOTE: All maps textures are set to { 0 )
-		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_OCCLUSION] = GetShaderLocation(mat.shader, "occlusion.sampler");
+
-		//mat.shader.locs[LOC_MAP_EMISSION] = GetShaderLocation(mat.shader, "emission.sampler");
+		string PATH_PBR_VS = "resources/shaders/pbr.vs";
-		//mat.shader.locs[LOC_MAP_HEIGHT] = GetShaderLocation(mat.shader, "height.sampler");
+		string PATH_PBR_FS = "resources/shaders/pbr.fs";
-		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_IRRADIANCE] = GetShaderLocation(mat.shader, "irradianceMap");
+
-		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_PREFILTER] = GetShaderLocation(mat.shader, "prefilterMap");
+		mat.shader = LoadShader(PATH_PBR_VS, PATH_PBR_FS);
-		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_BRDF] = GetShaderLocation(mat.shader, "brdfLUT");
+
-
+		// Get required locations points for PBR material
-		// Set view matrix location
+		// NOTE: Those location names must be available and used in the shader code
-		mat.shader.locs[(int)ShaderLocationIndex.LOC_MATRIX_MODEL] = GetShaderLocation(mat.shader, "matModel");
+
-		mat.shader.locs[(int)ShaderLocationIndex.LOC_MATRIX_VIEW] = GetShaderLocation(mat.shader, "view");
+		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_ALBEDO] = GetShaderLocation(mat.shader, "albedo.sampler");
-		mat.shader.locs[(int)ShaderLocationIndex.LOC_VECTOR_VIEW] = GetShaderLocation(mat.shader, "viewPos");
+		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_METALNESS] = GetShaderLocation(mat.shader, "metalness.sampler");
-
+		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_NORMAL] = GetShaderLocation(mat.shader, "normals.sampler");
-		// Set PBR standard maps
+		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_ROUGHNESS] = GetShaderLocation(mat.shader, "roughness.sampler");
-		mat.maps[(int)TexmapIndex.MAP_ALBEDO].texture = LoadTexture("resources/pbr/trooper_albedo.png");
+		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_OCCLUSION] = GetShaderLocation(mat.shader, "occlusion.sampler");
-		mat.maps[(int)TexmapIndex.MAP_NORMAL].texture = LoadTexture("resources/pbr/trooper_normals.png");
+		//mat.shader.locs[LOC_MAP_EMISSION] = GetShaderLocation(mat.shader, "emission.sampler");
-		mat.maps[(int)TexmapIndex.MAP_METALNESS].texture = LoadTexture("resources/pbr/trooper_metalness.png");
+		//mat.shader.locs[LOC_MAP_HEIGHT] = GetShaderLocation(mat.shader, "height.sampler");
-		mat.maps[(int)TexmapIndex.MAP_ROUGHNESS].texture = LoadTexture("resources/pbr/trooper_roughness.png");
+		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_IRRADIANCE] = GetShaderLocation(mat.shader, "irradianceMap");
-		mat.maps[(int)TexmapIndex.MAP_OCCLUSION].texture = LoadTexture("resources/pbr/trooper_ao.png");	
+		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_PREFILTER] = GetShaderLocation(mat.shader, "prefilterMap");
-		
+		mat.shader.locs[(int)ShaderLocationIndex.LOC_MAP_BRDF] = GetShaderLocation(mat.shader, "brdfLUT");
-		// Set environment maps
+
-		 const string PATH_CUBEMAP_VS = "resources/shaders/cubemap.vs";
+		// Set view matrix location
-		 const string PATH_CUBEMAP_FS = "resources/shaders/cubemap.fs";
+		mat.shader.locs[(int)ShaderLocationIndex.LOC_MATRIX_MODEL] = GetShaderLocation(mat.shader, "matModel");
-		 const string PATH_SKYBOX_VS = "resources/shaders/skybox.vs";
+		mat.shader.locs[(int)ShaderLocationIndex.LOC_MATRIX_VIEW] = GetShaderLocation(mat.shader, "view");
-		 const string PATH_IRRADIANCE_FS = "resources/shaders/irradiance.fs";
+		mat.shader.locs[(int)ShaderLocationIndex.LOC_VECTOR_VIEW] = GetShaderLocation(mat.shader, "viewPos");
-		 const string PATH_PREFILTER_FS = "resources/shaders/prefilter.fs";
+
-		 const string PATH_BRDF_VS = "resources/shaders/brdf.vs";
+		// Set PBR standard maps
-		 const string PATH_BRDF_FS = "resources/shaders/brdf.fs";
+		mat.maps[(int)TexmapIndex.MAP_ALBEDO].texture = LoadTexture("resources/pbr/trooper_albedo.png");
-
+		mat.maps[(int)TexmapIndex.MAP_NORMAL].texture = LoadTexture("resources/pbr/trooper_normals.png");
-		Shader shdrCubemap = LoadShader(PATH_CUBEMAP_VS, PATH_CUBEMAP_FS);
+		mat.maps[(int)TexmapIndex.MAP_METALNESS].texture = LoadTexture("resources/pbr/trooper_metalness.png");
-		Shader shdrIrradiance = LoadShader(PATH_SKYBOX_VS, PATH_IRRADIANCE_FS);
+		mat.maps[(int)TexmapIndex.MAP_ROUGHNESS].texture = LoadTexture("resources/pbr/trooper_roughness.png");
-		Shader shdrPrefilter = LoadShader(PATH_SKYBOX_VS, PATH_PREFILTER_FS);
+		mat.maps[(int)TexmapIndex.MAP_OCCLUSION].texture = LoadTexture("resources/pbr/trooper_ao.png");	
-		Shader shdrBRDF = LoadShader(PATH_BRDF_VS, PATH_BRDF_FS);
+		
-
+		// Set environment maps
-		// Setup required shader locations
+		 const string PATH_CUBEMAP_VS = "resources/shaders/cubemap.vs";
-		SetShaderValuei(shdrCubemap, GetShaderLocation(shdrCubemap, "equirectangularMap"), new int[] { 0 }, 1);
		SetShaderValuei(shdrIrradiance, GetShaderLocation(shdrIrradiance, "environmentMap"), new int[] { 0 }, 1);
		SetShaderValuei(shdrPrefilter, GetShaderLocation(shdrPrefilter, "environmentMap"), new int[] { 0 }, 1);
	
		Texture2D texHDR = LoadTexture("resources/dresden_square.hdr");
+		 const string PATH_CUBEMAP_FS = "resources/shaders/cubemap.fs";
-		Texture2D cubemap = GenTextureCubemap(shdrCubemap, texHDR, CUBEMAP_SIZE);
+		 const string PATH_SKYBOX_VS = "resources/shaders/skybox.vs";
-		mat.maps[(int)TexmapIndex.MAP_IRRADIANCE].texture = GenTextureIrradiance(shdrIrradiance, cubemap, IRRADIANCE_SIZE);
+		 const string PATH_IRRADIANCE_FS = "resources/shaders/irradiance.fs";
-		mat.maps[(int)TexmapIndex.MAP_PREFILTER].texture = GenTexturePrefilter(shdrPrefilter, cubemap, PREFILTERED_SIZE);
+		 const string PATH_PREFILTER_FS = "resources/shaders/prefilter.fs";
-		mat.maps[(int)TexmapIndex.MAP_BRDF].texture = GenTextureBRDF(shdrBRDF, cubemap, BRDF_SIZE);
+		 const string PATH_BRDF_VS = "resources/shaders/brdf.vs";
-		UnloadTexture(cubemap);
+		 const string PATH_BRDF_FS = "resources/shaders/brdf.fs";
-		UnloadTexture(texHDR);
+
-
+		Shader shdrCubemap = LoadShader(PATH_CUBEMAP_VS, PATH_CUBEMAP_FS);
-		// Unload already used shaders (to create specific textures)
+		Shader shdrIrradiance = LoadShader(PATH_SKYBOX_VS, PATH_IRRADIANCE_FS);
-		UnloadShader(shdrCubemap);
+		Shader shdrPrefilter = LoadShader(PATH_SKYBOX_VS, PATH_PREFILTER_FS);
-		UnloadShader(shdrIrradiance);
+		Shader shdrBRDF = LoadShader(PATH_BRDF_VS, PATH_BRDF_FS);
-		UnloadShader(shdrPrefilter);
+
-		UnloadShader(shdrBRDF);
+		// Setup required shader locations
-
+		SetShaderValuei(shdrCubemap, GetShaderLocation(shdrCubemap, "equirectangularMap"), new int[] { 0 }, 1);
-		// Set textures filtering for better quality
+		SetShaderValuei(shdrIrradiance, GetShaderLocation(shdrIrradiance, "environmentMap"), new int[] { 0 }, 1);
-		SetTextureFilter(mat.maps[(int)TexmapIndex.MAP_ALBEDO].texture, (int)TextureFilterMode.FILTER_BILINEAR);
+		SetShaderValuei(shdrPrefilter, GetShaderLocation(shdrPrefilter, "environmentMap"), new int[] { 0 }, 1);
-		SetTextureFilter(mat.maps[(int)TexmapIndex.MAP_NORMAL].texture, (int)TextureFilterMode.FILTER_BILINEAR);
+	
-		SetTextureFilter(mat.maps[(int)TexmapIndex.MAP_METALNESS].texture, (int)TextureFilterMode.FILTER_BILINEAR);
+		Texture2D texHDR = LoadTexture("resources/dresden_square.hdr");
-		SetTextureFilter(mat.maps[(int)TexmapIndex.MAP_ROUGHNESS].texture, (int)TextureFilterMode.FILTER_BILINEAR);
+		Texture2D cubemap = GenTextureCubemap(shdrCubemap, texHDR, CUBEMAP_SIZE);
-		SetTextureFilter(mat.maps[(int)TexmapIndex.MAP_OCCLUSION].texture, (int)TextureFilterMode.FILTER_BILINEAR);
+		mat.maps[(int)TexmapIndex.MAP_IRRADIANCE].texture = GenTextureIrradiance(shdrIrradiance, cubemap, IRRADIANCE_SIZE);
-
+		mat.maps[(int)TexmapIndex.MAP_PREFILTER].texture = GenTexturePrefilter(shdrPrefilter, cubemap, PREFILTERED_SIZE);
-		// Enable sample usage in shader for assigned textures
+		mat.maps[(int)TexmapIndex.MAP_BRDF].texture = GenTextureBRDF(shdrBRDF, cubemap, BRDF_SIZE);
-		SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "albedo.useSampler"), new int[] { 1 }, 1);
		SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "normals.useSampler"), new int[] { 1 }, 1);
		SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "metalness.useSampler"), new int[] { 1 }, 1);
		SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "roughness.useSampler"), new int[] { 1 }, 1);
		SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "occlusion.useSampler"), new int[] { 1 }, 1);
		
		int renderModeLoc = GetShaderLocation(mat.shader, "renderMode");
+		UnloadTexture(cubemap);
-		SetShaderValuei(mat.shader, renderModeLoc, new int[] { 0 }, 1);
	
				// Set up material properties color
		mat.maps[(int)TexmapIndex.MAP_ALBEDO].color = albedo;
		mat.maps[(int)TexmapIndex.MAP_NORMAL].color = new Color( 128, 128, 255, 255 );
+		UnloadTexture(texHDR);
-		mat.maps[(int)TexmapIndex.MAP_METALNESS].value = metalness;
		mat.maps[(int)TexmapIndex.MAP_ROUGHNESS].value = roughness;
		mat.maps[(int)TexmapIndex.MAP_OCCLUSION].value = 1.0f;
		mat.maps[(int)TexmapIndex.MAP_EMISSION].value = 0.5f;
		mat.maps[(int)TexmapIndex.MAP_HEIGHT].value = 0.5f;
	
		return mat;
+
-	}
+		// Unload already used shaders (to create specific textures)
-}
+		UnloadShader(shdrCubemap);
+		UnloadShader(shdrIrradiance);
+		UnloadShader(shdrPrefilter);
+		UnloadShader(shdrBRDF);
+
+		// Set textures filtering for better quality
+		SetTextureFilter(mat.maps[(int)TexmapIndex.MAP_ALBEDO].texture, (int)TextureFilterMode.FILTER_BILINEAR);
+		SetTextureFilter(mat.maps[(int)TexmapIndex.MAP_NORMAL].texture, (int)TextureFilterMode.FILTER_BILINEAR);
+		SetTextureFilter(mat.maps[(int)TexmapIndex.MAP_METALNESS].texture, (int)TextureFilterMode.FILTER_BILINEAR);
+		SetTextureFilter(mat.maps[(int)TexmapIndex.MAP_ROUGHNESS].texture, (int)TextureFilterMode.FILTER_BILINEAR);
+		SetTextureFilter(mat.maps[(int)TexmapIndex.MAP_OCCLUSION].texture, (int)TextureFilterMode.FILTER_BILINEAR);
+
+		// Enable sample usage in shader for assigned textures
+		SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "albedo.useSampler"), new int[] { 1 }, 1);
+		SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "normals.useSampler"), new int[] { 1 }, 1);
+		SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "metalness.useSampler"), new int[] { 1 }, 1);
+		SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "roughness.useSampler"), new int[] { 1 }, 1);
+		SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "occlusion.useSampler"), new int[] { 1 }, 1);
+		
+		int renderModeLoc = GetShaderLocation(mat.shader, "renderMode");
+		SetShaderValuei(mat.shader, renderModeLoc, new int[] { 0 }, 1);
+	
+				// Set up material properties color
+		mat.maps[(int)TexmapIndex.MAP_ALBEDO].color = albedo;
+		mat.maps[(int)TexmapIndex.MAP_NORMAL].color = new Color( 128, 128, 255, 255 );
+		mat.maps[(int)TexmapIndex.MAP_METALNESS].value = metalness;
+		mat.maps[(int)TexmapIndex.MAP_ROUGHNESS].value = roughness;
+		mat.maps[(int)TexmapIndex.MAP_OCCLUSION].value = 1.0f;
+		mat.maps[(int)TexmapIndex.MAP_EMISSION].value = 0.5f;
+		mat.maps[(int)TexmapIndex.MAP_HEIGHT].value = 0.5f;
+	
+		return mat;
+	}
+}
 
 

Examples/models/models_obj_loading.cs

@@ -5,5 +5,83 @@ using static Raylib.TexmapIndex;
 
 public partial class models_obj_loading
 {
-    /*******************************************************************************************
    *
    *   raylib [models] example - Load and draw a 3d model (OBJ)
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - obj model loading");
    
        // Define the camera to look into our 3d world
        Camera3D camera = new Camera3D();
        camera.position = new Vector3( 8.0f, 8.0f, 8.0f );    // Camera3D position
        camera.target = new Vector3( 0.0f, 2.5f, 0.0f );      // Camera3D looking at point
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );          // Camera3D up vector (rotation towards target)
        camera.fovy = 45.0f;                                // Camera3D field-of-view Y
        camera.type = CAMERA_PERSPECTIVE;                   // Camera3D mode type
    
        Model model = LoadModel("resources/models/castle.obj");                 // Load OBJ model
        Texture2D texture = LoadTexture("resources/models/castle_diffuse.png"); // Load model texture
        model.material.maps[(int)MAP_ALBEDO].texture = texture;                     // Set map diffuse texture
        Vector3 position = new Vector3( 0.0f, 0.0f, 0.0f );                                // Set model position
    
        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
            //----------------------------------------------------------------------------------
            //...
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawModel(model, position, 0.2f, WHITE);   // Draw 3d model with texture
    
                    DrawGrid(10, 1.0f);         // Draw a grid
    
                    DrawGizmo(position);        // Draw gizmo
    
                EndMode3D();
                
                DrawText("(c) Castle 3D model by Alberto Cano", screenWidth - 200, screenHeight - 20, 10, GRAY);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadTexture(texture);     // Unload texture
        UnloadModel(model);         // Unload model
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Load and draw a 3d model (OBJ)
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - obj model loading");
+    
+        // Define the camera to look into our 3d world
+        Camera3D camera = new Camera3D();
+        camera.position = new Vector3( 8.0f, 8.0f, 8.0f );    // Camera3D position
+        camera.target = new Vector3( 0.0f, 2.5f, 0.0f );      // Camera3D looking at point
+        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );          // Camera3D up vector (rotation towards target)
+        camera.fovy = 45.0f;                                // Camera3D field-of-view Y
+        camera.type = CAMERA_PERSPECTIVE;                   // Camera3D mode type
+    
+        Model model = LoadModel("resources/models/castle.obj");                 // Load OBJ model
+        Texture2D texture = LoadTexture("resources/models/castle_diffuse.png"); // Load model texture
+        model.material.maps[(int)MAP_ALBEDO].texture = texture;                     // Set map diffuse texture
+        Vector3 position = new Vector3( 0.0f, 0.0f, 0.0f );                                // Set model position
+    
+        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
+            //----------------------------------------------------------------------------------
+            //...
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawModel(model, position, 0.2f, WHITE);   // Draw 3d model with texture
+    
+                    DrawGrid(10, 1.0f);         // Draw a grid
+    
+                    DrawGizmo(position);        // Draw gizmo
+    
+                EndMode3D();
+                
+                DrawText("(c) Castle 3D model by Alberto Cano", screenWidth - 200, screenHeight - 20, 10, GRAY);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadTexture(texture);     // Unload texture
+        UnloadModel(model);         // Unload model
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/models/models_orthographic_projection.cs

@@ -5,5 +5,100 @@ using static Raylib.CameraMode;
 
 public partial class models_orthographic_projection
 {
-    /*******************************************************************************************
    *
    *   raylib [models] example - Show the difference between perspective and orthographic projection 
    *
    *   This program is heavily based on the geometric objects example
    *
    *   This example has been created using raylib 1.9.7 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2018 Max Danielsson ref Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public const float FOVY_PERSPECTIVE = 45.0f;
    public const float WIDTH_ORTHOGRAPHIC = 10.0f;
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
    
        // Define the camera to look into our 3d world
        Camera3D camera = new Camera3D(new Vector3( 0.0f, 10.0f, 10.0f ), new Vector3( 0.0f, 0.0f, 0.0f ), new Vector3( 0.0f, 1.0f, 0.0f ), FOVY_PERSPECTIVE, CAMERA_PERSPECTIVE );
    
        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_SPACE)) 
            {
                if (camera.type == CAMERA_PERSPECTIVE) 
                {
                    camera.fovy = WIDTH_ORTHOGRAPHIC;
                    camera.type = CAMERA_ORTHOGRAPHIC;
                } 
                else 
                {
                    camera.fovy = FOVY_PERSPECTIVE;
                    camera.type = CAMERA_PERSPECTIVE;
                }
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawCube(new Vector3(-4.0f, 0.0f, 2.0f), 2.0f, 5.0f, 2.0f, RED);
                    DrawCubeWires(new Vector3(-4.0f, 0.0f, 2.0f), 2.0f, 5.0f, 2.0f, GOLD);
                    DrawCubeWires(new Vector3(-4.0f, 0.0f, -2.0f), 3.0f, 6.0f, 2.0f, MAROON);
    
                    DrawSphere(new Vector3(-1.0f, 0.0f, -2.0f), 1.0f, GREEN);
                    DrawSphereWires(new Vector3(1.0f, 0.0f, 2.0f), 2.0f, 16, 16, LIME);
    
                    DrawCylinder(new Vector3(4.0f, 0.0f, -2.0f), 1.0f, 2.0f, 3.0f, 4, SKYBLUE);
                    DrawCylinderWires(new Vector3(4.0f, 0.0f, -2.0f), 1.0f, 2.0f, 3.0f, 4, DARKBLUE);
                    DrawCylinderWires(new Vector3(4.5f, -1.0f, 2.0f), 1.0f, 1.0f, 2.0f, 6, BROWN);
    
                    DrawCylinder(new Vector3(1.0f, 0.0f, -4.0f), 0.0f, 1.5f, 3.0f, 8, GOLD);
                    DrawCylinderWires(new Vector3(1.0f, 0.0f, -4.0f), 0.0f, 1.5f, 3.0f, 8, PINK);
    
                    DrawGrid(10, 1.0f);        // Draw a grid
    
                EndMode3D();
    
                DrawText("Press Spacebar to switch camera type", 10, GetScreenHeight() - 30, 20, DARKGRAY);
    
                if (camera.type == CAMERA_ORTHOGRAPHIC) DrawText("ORTHOGRAPHIC", 10, 40, 20, BLACK);
                else if (camera.type == CAMERA_PERSPECTIVE) DrawText("PERSPECTIVE", 10, 40, 20, BLACK);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }  
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Show the difference between perspective and orthographic projection 
+    *
+    *   This program is heavily based on the geometric objects example
+    *
+    *   This example has been created using raylib 1.9.7 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2018 Max Danielsson ref Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public const float FOVY_PERSPECTIVE = 45.0f;
+    public const float WIDTH_ORTHOGRAPHIC = 10.0f;
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
+    
+        // Define the camera to look into our 3d world
+        Camera3D camera = new Camera3D(new Vector3( 0.0f, 10.0f, 10.0f ), new Vector3( 0.0f, 0.0f, 0.0f ), new Vector3( 0.0f, 1.0f, 0.0f ), FOVY_PERSPECTIVE, CAMERA_PERSPECTIVE );
+    
+        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_SPACE)) 
+            {
+                if (camera.type == CAMERA_PERSPECTIVE) 
+                {
+                    camera.fovy = WIDTH_ORTHOGRAPHIC;
+                    camera.type = CAMERA_ORTHOGRAPHIC;
+                } 
+                else 
+                {
+                    camera.fovy = FOVY_PERSPECTIVE;
+                    camera.type = CAMERA_PERSPECTIVE;
+                }
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawCube(new Vector3(-4.0f, 0.0f, 2.0f), 2.0f, 5.0f, 2.0f, RED);
+                    DrawCubeWires(new Vector3(-4.0f, 0.0f, 2.0f), 2.0f, 5.0f, 2.0f, GOLD);
+                    DrawCubeWires(new Vector3(-4.0f, 0.0f, -2.0f), 3.0f, 6.0f, 2.0f, MAROON);
+    
+                    DrawSphere(new Vector3(-1.0f, 0.0f, -2.0f), 1.0f, GREEN);
+                    DrawSphereWires(new Vector3(1.0f, 0.0f, 2.0f), 2.0f, 16, 16, LIME);
+    
+                    DrawCylinder(new Vector3(4.0f, 0.0f, -2.0f), 1.0f, 2.0f, 3.0f, 4, SKYBLUE);
+                    DrawCylinderWires(new Vector3(4.0f, 0.0f, -2.0f), 1.0f, 2.0f, 3.0f, 4, DARKBLUE);
+                    DrawCylinderWires(new Vector3(4.5f, -1.0f, 2.0f), 1.0f, 1.0f, 2.0f, 6, BROWN);
+    
+                    DrawCylinder(new Vector3(1.0f, 0.0f, -4.0f), 0.0f, 1.5f, 3.0f, 8, GOLD);
+                    DrawCylinderWires(new Vector3(1.0f, 0.0f, -4.0f), 0.0f, 1.5f, 3.0f, 8, PINK);
+    
+                    DrawGrid(10, 1.0f);        // Draw a grid
+    
+                EndMode3D();
+    
+                DrawText("Press Spacebar to switch camera type", 10, GetScreenHeight() - 30, 20, DARKGRAY);
+    
+                if (camera.type == CAMERA_ORTHOGRAPHIC) DrawText("ORTHOGRAPHIC", 10, 40, 20, BLACK);
+                else if (camera.type == CAMERA_PERSPECTIVE) DrawText("PERSPECTIVE", 10, 40, 20, BLACK);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }  
 }

Examples/models/models_skybox.cs

@@ -5,5 +5,93 @@ using static Raylib.TexmapIndex;
 
 public partial class models_skybox
 {
-    /*******************************************************************************************
    *
    *   raylib [models] example - Skybox loading and drawing
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - skybox loading and drawing");
    
        // Define the camera to look into our 3d world
        Camera3D camera = new Camera3D(new Vector3( 1.0f, 1.0f, 1.0f ), new Vector3( 0.0f, 0.0f, 0.0f ), new Vector3( 0.0f, 1.0f, 0.0f ), 45.0f, 0 );
    
        // Load skybox model   
        Mesh cube = GenMeshCube(1.0f, 1.0f, 1.0f);
        Model skybox = LoadModelFromMesh(cube);
        
        // Load skybox shader and set required locations
        // NOTE: Some locations are automatically set at shader loading
        skybox.material.shader = LoadShader("resources/shaders/skybox.vs", "resources/shaders/skybox.fs");
        SetShaderValuei(skybox.material.shader, GetShaderLocation(skybox.material.shader, "environmentMap"), new int[]{ (int)MAP_CUBEMAP }, 1);
    
        // Load cubemap shader and setup required shader locations
        Shader shdrCubemap = LoadShader("resources/shaders/cubemap.vs", "resources/shaders/cubemap.fs");
        SetShaderValuei(shdrCubemap, GetShaderLocation(shdrCubemap, "equirectangularMap"), new int[]{ 0 }, 1);
        
        // Load HDR panorama (sphere) texture
        Texture2D texHDR = LoadTexture("resources/dresden_square.hdr");
        
        // Generate cubemap (texture with 6 quads-cube-mapping) from panorama HDR texture
        // NOTE: New texture is generated rendering to texture, shader computes the sphre->cube coordinates mapping
        skybox.material.maps[(int)MAP_CUBEMAP].texture = GenTextureCubemap(shdrCubemap, texHDR, 512);
        
        UnloadTexture(texHDR);      // Texture not required anymore, cubemap already generated
        UnloadShader(shdrCubemap);  // Unload cubemap generation shader, not required anymore
        
        SetCameraMode(camera, (int)CAMERA_FIRST_PERSON);  // Set a first person camera mode
    
        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
            //----------------------------------------------------------------------------------
            UpdateCamera(ref camera);              // Update camera
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawModel(skybox, new Vector3(0, 0, 0), 1.0f, WHITE);
                    
                    DrawGrid(10, 1.0f);
    
                EndMode3D();
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadModel(skybox);        // Unload skybox model (and textures)
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }      
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Skybox loading and drawing
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - skybox loading and drawing");
+    
+        // Define the camera to look into our 3d world
+        Camera3D camera = new Camera3D(new Vector3( 1.0f, 1.0f, 1.0f ), new Vector3( 0.0f, 0.0f, 0.0f ), new Vector3( 0.0f, 1.0f, 0.0f ), 45.0f, 0 );
+    
+        // Load skybox model   
+        Mesh cube = GenMeshCube(1.0f, 1.0f, 1.0f);
+        Model skybox = LoadModelFromMesh(cube);
+        
+        // Load skybox shader and set required locations
+        // NOTE: Some locations are automatically set at shader loading
+        skybox.material.shader = LoadShader("resources/shaders/skybox.vs", "resources/shaders/skybox.fs");
+        SetShaderValuei(skybox.material.shader, GetShaderLocation(skybox.material.shader, "environmentMap"), new int[]{ (int)MAP_CUBEMAP }, 1);
+    
+        // Load cubemap shader and setup required shader locations
+        Shader shdrCubemap = LoadShader("resources/shaders/cubemap.vs", "resources/shaders/cubemap.fs");
+        SetShaderValuei(shdrCubemap, GetShaderLocation(shdrCubemap, "equirectangularMap"), new int[]{ 0 }, 1);
+        
+        // Load HDR panorama (sphere) texture
+        Texture2D texHDR = LoadTexture("resources/dresden_square.hdr");
+        
+        // Generate cubemap (texture with 6 quads-cube-mapping) from panorama HDR texture
+        // NOTE: New texture is generated rendering to texture, shader computes the sphre->cube coordinates mapping
+        skybox.material.maps[(int)MAP_CUBEMAP].texture = GenTextureCubemap(shdrCubemap, texHDR, 512);
+        
+        UnloadTexture(texHDR);      // Texture not required anymore, cubemap already generated
+        UnloadShader(shdrCubemap);  // Unload cubemap generation shader, not required anymore
+        
+        SetCameraMode(camera, (int)CAMERA_FIRST_PERSON);  // Set a first person camera mode
+    
+        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
+            //----------------------------------------------------------------------------------
+            UpdateCamera(ref camera);              // Update camera
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawModel(skybox, new Vector3(0, 0, 0), 1.0f, WHITE);
+                    
+                    DrawGrid(10, 1.0f);
+    
+                EndMode3D();
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadModel(skybox);        // Unload skybox model (and textures)
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }      
 }

Examples/others/bunnymark.cs

@@ -3,12 +3,104 @@ using static Raylib.Raylib;
 
 public partial class bunnymark
 {
-    /*******************************************************************************************
    *
    *   raylib 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 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public const int MAX_BUNNIES = 100000;
+    /*******************************************************************************************
-
+    *
-    struct Bunny
    {
+    *   raylib example - Bunnymark
-        public Vector2 position;
        public Vector2 speed;
        public Color color;
    }
    
    public static int Main()
    {
+    *
-        // Initialization
+    *   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)
-        int screenWidth = 1280;
        int screenHeight = 960;
    
        InitWindow(screenWidth, screenHeight, "raylib example - Bunnymark");
    
        Texture2D texBunny = LoadTexture("resources/wabbit_alpha.png");
    
        Bunny[] bunnies = new Bunny[MAX_BUNNIES];          // 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, 500)/60.0f;
                    bunnies[bunniesCount].speed.y = (float)(GetRandomValue(250, 500) - 500)/60.0f;
                    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 > GetScreenWidth()) || (bunnies[i].position.x < 0)) bunnies[i].speed.x *= -1;
                if ((bunnies[i].position.y > GetScreenHeight()) || (bunnies[i].position.y < 0)) bunnies[i].speed.y *= -1;
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                for (int i = 0; i < bunniesCount; i++)
                {
                    // NOTE: When internal QUADS batch limit is reached, a draw call is launched and
                    // batching buffer starts being filled again; before launching the draw call,
                    // updated vertex data from internal buffer is send to GPU... it seems it generates
                    // a stall and consequently a frame drop, limiting number of bunnies drawn at 60 fps
                    DrawTexture(texBunny, (int)bunnies[i].position.x, (int)bunnies[i].position.y, RAYWHITE);
                }
    
                DrawRectangle(0, 0, screenWidth, 40, LIGHTGRAY);
                DrawText("raylib bunnymark", 10, 10, 20, DARKGRAY);
                // DrawText(FormatText("bunnies: %i", bunniesCount), 400, 10, 20, RED);
+    *
-                DrawText($"bunnies: {bunniesCount}", 400, 10, 20, RED);
                DrawFPS(260, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
        
+    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public const int MAX_BUNNIES = 100000;
+
+    struct Bunny
+    {
+        public Vector2 position;
+        public Vector2 speed;
+        public Color color;
+    }
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 1280;
+        int screenHeight = 960;
+    
+        InitWindow(screenWidth, screenHeight, "raylib example - Bunnymark");
+    
+        Texture2D texBunny = LoadTexture("resources/wabbit_alpha.png");
+    
+        Bunny[] bunnies = new Bunny[MAX_BUNNIES];          // 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, 500)/60.0f;
+                    bunnies[bunniesCount].speed.y = (float)(GetRandomValue(250, 500) - 500)/60.0f;
+                    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 > GetScreenWidth()) || (bunnies[i].position.x < 0)) bunnies[i].speed.x *= -1;
+                if ((bunnies[i].position.y > GetScreenHeight()) || (bunnies[i].position.y < 0)) bunnies[i].speed.y *= -1;
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                for (int i = 0; i < bunniesCount; i++)
+                {
+                    // NOTE: When internal QUADS batch limit is reached, a draw call is launched and
+                    // batching buffer starts being filled again; before launching the draw call,
+                    // updated vertex data from internal buffer is send to GPU... it seems it generates
+                    // a stall and consequently a frame drop, limiting number of bunnies drawn at 60 fps
+                    DrawTexture(texBunny, (int)bunnies[i].position.x, (int)bunnies[i].position.y, RAYWHITE);
+                }
+    
+                DrawRectangle(0, 0, screenWidth, 40, LIGHTGRAY);
+                DrawText("raylib bunnymark", 10, 10, 20, DARKGRAY);
+                // DrawText(FormatText("bunnies: %i", bunniesCount), 400, 10, 20, RED);
+                DrawText($"bunnies: {bunniesCount}", 400, 10, 20, RED);
+                DrawFPS(260, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+        
 }

Examples/physac/physics_movement.cs

@@ -3,8 +3,132 @@ using static Raylib.Raylib;
 
 public partial class physics_movement
 {
-    /*******************************************************************************************
    *
    *   Physac - Physics movement
    *
    *   NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
    *   NOTE 2: Physac requires static C library linkage to avoid dependency on MinGW DLL (-static -lpthread)
    *
    *   Use the following line to compile:
    *
    *   gcc -o $(NAME_PART).exe $(FILE_NAME) -s $(RAYLIB_DIR)\raylib\raylib.rc.o -static -lraylib -lpthread 
    *   -lglfw3 -lopengl32 -lgdi32 -lopenal32 -lwinmm -std=c99 -Wl,--subsystem,windows -Wl,-allow-multiple-definition
    *   
    *   Copyright (c) 2016-2018 Victor Fisac
    *
    ********************************************************************************************/
    
    
    
    public const float VELOCITY = 0.5f;
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        SetConfigFlags(FLAG_MSAA_4X_HINT);
        InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics movement");
    
        // Physac logo drawing position
        int logoX = screenWidth - MeasureText("Physac", 30) - 10;
        int logoY = 15;
    
        // Initialize physics and default physics bodies
        InitPhysics();
+    /*******************************************************************************************
-
+    *
-        // Create floor and walls rectangle physics body
+    *   Physac - Physics movement
-        PhysicsBodyData floor = CreatePhysicsBodyRectangle(new Vector2( screenWidth/2, screenHeight ), screenWidth, 100, 10);
        PhysicsBodyData platformLeft = CreatePhysicsBodyRectangle(new Vector2( screenWidth*0.25f, screenHeight*0.6f ), screenWidth*0.25f, 10, 10);
        PhysicsBodyData platformRight = CreatePhysicsBodyRectangle(new Vector2( screenWidth*0.75f, screenHeight*0.6f ), screenWidth*0.25f, 10, 10);
        PhysicsBodyData wallLeft = CreatePhysicsBodyRectangle(new Vector2( -5, screenHeight/2 ), 10, screenHeight, 10);
        PhysicsBodyData wallRight = CreatePhysicsBodyRectangle(new Vector2( screenWidth + 5, screenHeight/2 ), 10, screenHeight, 10);
    
        // Disable dynamics to floor and walls physics bodies
        floor.enabled = false;
        platformLeft.enabled = false;
        platformRight.enabled = false;
        wallLeft.enabled = false;
        wallRight.enabled = false;
    
        // Create movement physics body
        PhysicsBodyData body = CreatePhysicsBodyRectangle(new Vector2( screenWidth/2, screenHeight/2 ), 50, 50, 1);
        body.freezeOrient = true;  // Constrain body rotation to avoid little collision torque amounts
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsKeyPressed('R'))    // Reset physics input
            {
                // Reset movement physics body position, velocity and rotation
                body.position = new Vector2( screenWidth/2, screenHeight/2 );
                body.velocity = new Vector2( 0, 0 );
                SetPhysicsBodyRotation(body, 0);
            }
    
            // Horizontal movement input
            if (IsKeyDown(KEY_RIGHT)) body.velocity.x = VELOCITY;
            else if (IsKeyDown(KEY_LEFT)) body.velocity.x = -VELOCITY;
    
            // Vertical movement input checking if player physics body is grounded
            if (IsKeyDown(KEY_UP) && body.isGrounded) body.velocity.y = -VELOCITY*4;
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(BLACK);
    
                DrawFPS(screenWidth - 90, screenHeight - 30);
    
                // Draw created physics bodies
                int bodiesCount = GetPhysicsBodiesCount();
                for (int i = 0; i < bodiesCount; i++)
                {
                    var ibody = GetPhysicsBody(i);
    
                    int vertexCount = GetPhysicsShapeVerticesCount(i);
                    for (int j = 0; j < vertexCount; j++)
                    {
                        // Get physics bodies shape vertices to draw lines
                        // Note: GetPhysicsShapeVertex() already calculates rotation transformations
                        Vector2 vertexA = GetPhysicsShapeVertex(ibody, j);
    
                        int jj = (((j + 1) < vertexCount) ? (j + 1) : 0);   // Get next vertex or first to close the shape
                        Vector2 vertexB = GetPhysicsShapeVertex(ibody, jj);
    
                        DrawLineV(vertexA, vertexB, GREEN);     // Draw a line between two vertex positions
                    }
                }
    
                DrawText("Use 'ARROWS' to move player", 10, 10, 10, WHITE);
                DrawText("Press 'R' to reset example", 10, 30, 10, WHITE);
    
                DrawText("Physac", logoX, logoY, 30, WHITE);
                DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------   
        ClosePhysics();       // Unitialize physics
        
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }      
+    *
+    *   NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
+    *   NOTE 2: Physac requires static C library linkage to avoid dependency on MinGW DLL (-static -lpthread)
+    *
+    *   Use the following line to compile:
+    *
+    *   gcc -o $(NAME_PART).exe $(FILE_NAME) -s $(RAYLIB_DIR)\raylib\raylib.rc.o -static -lraylib -lpthread
+    *   -lglfw3 -lopengl32 -lgdi32 -lopenal32 -lwinmm -std=c99 -Wl,--subsystem,windows -Wl,-allow-multiple-definition
+    *
+    *   Copyright (c) 2016-2018 Victor Fisac
+    *
+    ********************************************************************************************/
+
+
+
+    public const float VELOCITY = 0.5f;
+
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+
+        SetConfigFlags(FLAG_MSAA_4X_HINT);
+        InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics movement");
+
+        // Physac logo drawing position
+        int logoX = screenWidth - MeasureText("Physac", 30) - 10;
+        int logoY = 15;
+
+        // Initialize physics and default physics bodies
+        InitPhysics();
+
+        // Create floor and walls rectangle physics body
+        PhysicsBodyData floor = CreatePhysicsBodyRectangle(new Vector2( screenWidth/2, screenHeight ), screenWidth, 100, 10);
+        PhysicsBodyData platformLeft = CreatePhysicsBodyRectangle(new Vector2( screenWidth*0.25f, screenHeight*0.6f ), screenWidth*0.25f, 10, 10);
+        PhysicsBodyData platformRight = CreatePhysicsBodyRectangle(new Vector2( screenWidth*0.75f, screenHeight*0.6f ), screenWidth*0.25f, 10, 10);
+        PhysicsBodyData wallLeft = CreatePhysicsBodyRectangle(new Vector2( -5, screenHeight/2 ), 10, screenHeight, 10);
+        PhysicsBodyData wallRight = CreatePhysicsBodyRectangle(new Vector2( screenWidth + 5, screenHeight/2 ), 10, screenHeight, 10);
+
+        // Disable dynamics to floor and walls physics bodies
+        floor.enabled = false;
+        platformLeft.enabled = false;
+        platformRight.enabled = false;
+        wallLeft.enabled = false;
+        wallRight.enabled = false;
+
+        // Create movement physics body
+        PhysicsBodyData body = CreatePhysicsBodyRectangle(new Vector2( screenWidth/2, screenHeight/2 ), 50, 50, 1);
+        body.freezeOrient = true;  // Constrain body rotation to avoid little collision torque amounts
+
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            RunPhysicsStep();
+
+            if (IsKeyPressed('R'))    // Reset physics input
+            {
+                // Reset movement physics body position, velocity and rotation
+                body.position = new Vector2( screenWidth/2, screenHeight/2 );
+                body.velocity = new Vector2( 0, 0 );
+                SetPhysicsBodyRotation(body, 0);
+            }
+
+            // Horizontal movement input
+            if (IsKeyDown(KEY_RIGHT)) body.velocity.x = VELOCITY;
+            else if (IsKeyDown(KEY_LEFT)) body.velocity.x = -VELOCITY;
+
+            // Vertical movement input checking if player physics body is grounded
+            if (IsKeyDown(KEY_UP) && body.isGrounded) body.velocity.y = -VELOCITY*4;
+            //----------------------------------------------------------------------------------
+
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+
+                ClearBackground(BLACK);
+
+                DrawFPS(screenWidth - 90, screenHeight - 30);
+
+                // Draw created physics bodies
+                int bodiesCount = GetPhysicsBodiesCount();
+                for (int i = 0; i < bodiesCount; i++)
+                {
+                    var ibody = GetPhysicsBody(i);
+
+                    int vertexCount = GetPhysicsShapeVerticesCount(i);
+                    for (int j = 0; j < vertexCount; j++)
+                    {
+                        // Get physics bodies shape vertices to draw lines
+                        // Note: GetPhysicsShapeVertex() already calculates rotation transformations
+                        Vector2 vertexA = GetPhysicsShapeVertex(ibody, j);
+
+                        int jj = (((j + 1) < vertexCount) ? (j + 1) : 0);   // Get next vertex or first to close the shape
+                        Vector2 vertexB = GetPhysicsShapeVertex(ibody, jj);
+
+                        DrawLineV(vertexA, vertexB, GREEN);     // Draw a line between two vertex positions
+                    }
+                }
+
+                DrawText("Use 'ARROWS' to move player", 10, 10, 10, WHITE);
+                DrawText("Press 'R' to reset example", 10, 30, 10, WHITE);
+
+                DrawText("Physac", logoX, logoY, 30, WHITE);
+                DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
+
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        ClosePhysics();       // Unitialize physics
+
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+
+        return 0;
+    }
 }

Examples/physac/physics_shatter.cs

@@ -3,6 +3,125 @@ using static Raylib.Raylib;
 
 public partial class physics_shatter
 {
-    /*******************************************************************************************
    *
    *   Physac - Body shatter
    *
    *   NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
    *   NOTE 2: Physac requires static C library linkage to avoid dependency on MinGW DLL (-static -lpthread)
    *
    *   Use the following line to compile:
    *
    *   gcc -o $(NAME_PART).exe $(FILE_NAME) -s $(RAYLIB_DIR)\raylib\raylib.rc.o -static -lraylib -lpthread 
    *   -lglfw3 -lopengl32 -lgdi32 -lopenal32 -lwinmm -std=c99 -Wl,--subsystem,windows -Wl,-allow-multiple-definition
    *   
    *   Copyright (c) 2016-2018 Victor Fisac
    *
    ********************************************************************************************/
    
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        SetConfigFlags(FLAG_MSAA_4X_HINT);
        InitWindow(screenWidth, screenHeight, "Physac [raylib] - Body shatter");
    
        // Physac logo drawing position
        int logoX = screenWidth - MeasureText("Physac", 30) - 10;
        int logoY = 15;
        bool needsReset = false;
    
        // Initialize physics and default physics bodies
        InitPhysics();
        SetPhysicsGravity(0, 0);
    
        // Create random polygon physics body to shatter
        CreatePhysicsBodyPolygon(new Vector2( screenWidth/2, screenHeight/2 ), GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
    
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // Delay initialization of variables due to physics reset asynchronous
            if (needsReset)
            {
                // Create random polygon physics body to shatter
                CreatePhysicsBodyPolygon(new Vector2( screenWidth/2, screenHeight/2 ), GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
            }
    
            if (IsKeyPressed('R'))    // Reset physics input
            {
                ResetPhysics();
                needsReset = true;
            }
    
            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))    // Physics shatter input
            {
                // Note: some values need to be stored in variables due to asynchronous changes during main thread
                int count = GetPhysicsBodiesCount();
                for (int i = count - 1; i >= 0; i--)
                {
                    PhysicsBodyData currentBody = GetPhysicsBody(i);
                    if (currentBody.id != 0) PhysicsShatter(currentBody, GetMousePosition(), 10/currentBody.inverseMass);
                }
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(BLACK);
    
                // Draw created physics bodies
                int bodiesCount = GetPhysicsBodiesCount();
                for (int i = 0; i < bodiesCount; i++)
                {
+    /*******************************************************************************************
-                    PhysicsBodyData currentBody = GetPhysicsBody(i);
    
                    int vertexCount = GetPhysicsShapeVerticesCount(i);
                    for (int j = 0; j < vertexCount; j++)
                    {
                        // Get physics bodies shape vertices to draw lines
                        // Note: GetPhysicsShapeVertex() already calculates rotation transformations
                        Vector2 vertexA = GetPhysicsShapeVertex(currentBody, j);
    
                        int jj = (((j + 1) < vertexCount) ? (j + 1) : 0);   // Get next vertex or first to close the shape
                        Vector2 vertexB = GetPhysicsShapeVertex(currentBody, jj);
    
                        DrawLineV(vertexA, vertexB, GREEN);     // Draw a line between two vertex positions
                    }
                }
    
                DrawText("Left mouse button in polygon area to shatter body\nPress 'R' to reset example", 10, 10, 10, WHITE);
    
                DrawText("Physac", logoX, logoY, 30, WHITE);
                DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------   
        ClosePhysics();       // Unitialize physics
        
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
    
        
+    *
+    *   Physac - Body shatter
+    *
+    *   NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
+    *   NOTE 2: Physac requires static C library linkage to avoid dependency on MinGW DLL (-static -lpthread)
+    *
+    *   Use the following line to compile:
+    *
+    *   gcc -o $(NAME_PART).exe $(FILE_NAME) -s $(RAYLIB_DIR)\raylib\raylib.rc.o -static -lraylib -lpthread 
+    *   -lglfw3 -lopengl32 -lgdi32 -lopenal32 -lwinmm -std=c99 -Wl,--subsystem,windows -Wl,-allow-multiple-definition
+    *   
+    *   Copyright (c) 2016-2018 Victor Fisac
+    *
+    ********************************************************************************************/
+    
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        SetConfigFlags(FLAG_MSAA_4X_HINT);
+        InitWindow(screenWidth, screenHeight, "Physac [raylib] - Body shatter");
+    
+        // Physac logo drawing position
+        int logoX = screenWidth - MeasureText("Physac", 30) - 10;
+        int logoY = 15;
+        bool needsReset = false;
+    
+        // Initialize physics and default physics bodies
+        InitPhysics();
+        SetPhysicsGravity(0, 0);
+    
+        // Create random polygon physics body to shatter
+        CreatePhysicsBodyPolygon(new Vector2( screenWidth/2, screenHeight/2 ), GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
+    
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            RunPhysicsStep();
+
+            // Delay initialization of variables due to physics reset asynchronous
+            if (needsReset)
+            {
+                // Create random polygon physics body to shatter
+                CreatePhysicsBodyPolygon(new Vector2( screenWidth/2, screenHeight/2 ), GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
+            }
+    
+            if (IsKeyPressed('R'))    // Reset physics input
+            {
+                ResetPhysics();
+                needsReset = true;
+            }
+    
+            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))    // Physics shatter input
+            {
+                // Note: some values need to be stored in variables due to asynchronous changes during main thread
+                int count = GetPhysicsBodiesCount();
+                for (int i = count - 1; i >= 0; i--)
+                {
+                    PhysicsBodyData currentBody = GetPhysicsBody(i);
+                    if (currentBody.id != 0) PhysicsShatter(currentBody, GetMousePosition(), 10/currentBody.inverseMass);
+                }
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(BLACK);
+    
+                // Draw created physics bodies
+                int bodiesCount = GetPhysicsBodiesCount();
+                for (int i = 0; i < bodiesCount; i++)
+                {
+                    PhysicsBodyData currentBody = GetPhysicsBody(i);
+    
+                    int vertexCount = GetPhysicsShapeVerticesCount(i);
+                    for (int j = 0; j < vertexCount; j++)
+                    {
+                        // Get physics bodies shape vertices to draw lines
+                        // Note: GetPhysicsShapeVertex() already calculates rotation transformations
+                        Vector2 vertexA = GetPhysicsShapeVertex(currentBody, j);
+    
+                        int jj = (((j + 1) < vertexCount) ? (j + 1) : 0);   // Get next vertex or first to close the shape
+                        Vector2 vertexB = GetPhysicsShapeVertex(currentBody, jj);
+    
+                        DrawLineV(vertexA, vertexB, GREEN);     // Draw a line between two vertex positions
+                    }
+                }
+    
+                DrawText("Left mouse button in polygon area to shatter body\nPress 'R' to reset example", 10, 10, 10, WHITE);
+    
+                DrawText("Physac", logoX, logoY, 30, WHITE);
+                DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------   
+        ClosePhysics();       // Unitialize physics
+        
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+    
+        
 }

Examples/shaders/shaders_model_shader.cs

@@ -6,5 +6,101 @@ using static Raylib.TexmapIndex;
 
 public partial class shaders_model_shader
 {
-    /*******************************************************************************************
    *
    *   raylib [shaders] example - Apply a shader to a 3d model
    *
    *   NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
    *         OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
    *
    *   NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
    *         on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
    *         raylib comes with shaders ready for both versions, check raylib/shaders install folder
    *
    *   This example has been created using raylib 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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
        
        SetConfigFlags(FLAG_MSAA_4X_HINT);      // Enable Multi Sampling Anti Aliasing 4x (if available)
    
        InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader");
    
        // Define the camera to look into our 3d world
        Camera3D camera = new Camera3D();
        camera.position = new Vector3( 4.0f, 4.0f, 4.0f );
        camera.target = new Vector3( 0.0f, 1.0f, -1.0f );
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );
        camera.fovy = 45.0f;
        camera.type = CAMERA_PERSPECTIVE;
    
        Model model = LoadModel("resources/models/watermill.obj");                   // Load OBJ model
        Texture2D texture = LoadTexture("resources/models/watermill_diffuse.png");   // Load model texture
        Shader shader = LoadShader("resources/shaders/glsl330/base.vs", 
                                   "resources/shaders/glsl330/grayscale.fs");   // Load model shader
    
        model.material.shader = shader;                     // Set shader effect to 3d model
        model.material.maps[(int)MAP_ALBEDO].texture = texture; // Bind texture to model
        
        Vector3 position = new Vector3( 0.0f, 0.0f, 0.0f );    // Set model position
        
        SetCameraMode(camera, (int)CAMERA_FREE);         // Set an orbital camera mode
    
        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
            //----------------------------------------------------------------------------------
            UpdateCamera(ref camera);                  // Update camera
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawModel(model, position, 0.2f, WHITE);   // Draw 3d model with texture
    
                    DrawGrid(10, 1.0f);     // Draw a grid
    
                EndMode3D();
                
                DrawText("(c) Watermill 3D model by Alberto Cano", screenWidth - 210, screenHeight - 20, 10, GRAY);
                
                DrawText(FormatText("Camera3D position: (%.2f, %.2f, %.2f)", camera.position.x, camera.position.y, camera.position.z), 600, 20, 10, BLACK);
                DrawText(FormatText("Camera3D target: (%.2f, %.2f, %.2f)", camera.target.x, camera.target.y, camera.target.z), 600, 40, 10, GRAY);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadShader(shader);       // Unload shader
        UnloadTexture(texture);     // Unload texture
        UnloadModel(model);         // Unload model
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [shaders] example - Apply a shader to a 3d model
+    *
+    *   NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
+    *         OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
+    *
+    *   NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
+    *         on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
+    *         raylib comes with shaders ready for both versions, check raylib/shaders install folder
+    *
+    *   This example has been created using raylib 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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+        
+        SetConfigFlags(FLAG_MSAA_4X_HINT);      // Enable Multi Sampling Anti Aliasing 4x (if available)
+    
+        InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader");
+    
+        // Define the camera to look into our 3d world
+        Camera3D camera = new Camera3D();
+        camera.position = new Vector3( 4.0f, 4.0f, 4.0f );
+        camera.target = new Vector3( 0.0f, 1.0f, -1.0f );
+        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );
+        camera.fovy = 45.0f;
+        camera.type = CAMERA_PERSPECTIVE;
+    
+        Model model = LoadModel("resources/models/watermill.obj");                   // Load OBJ model
+        Texture2D texture = LoadTexture("resources/models/watermill_diffuse.png");   // Load model texture
+        Shader shader = LoadShader("resources/shaders/glsl330/base.vs", 
+                                   "resources/shaders/glsl330/grayscale.fs");   // Load model shader
+    
+        model.material.shader = shader;                     // Set shader effect to 3d model
+        model.material.maps[(int)MAP_ALBEDO].texture = texture; // Bind texture to model
+        
+        Vector3 position = new Vector3( 0.0f, 0.0f, 0.0f );    // Set model position
+        
+        SetCameraMode(camera, (int)CAMERA_FREE);         // Set an orbital camera mode
+    
+        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
+            //----------------------------------------------------------------------------------
+            UpdateCamera(ref camera);                  // Update camera
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawModel(model, position, 0.2f, WHITE);   // Draw 3d model with texture
+    
+                    DrawGrid(10, 1.0f);     // Draw a grid
+    
+                EndMode3D();
+                
+                DrawText("(c) Watermill 3D model by Alberto Cano", screenWidth - 210, screenHeight - 20, 10, GRAY);
+                
+                DrawText(FormatText("Camera3D position: (%.2f, %.2f, %.2f)", camera.position.x, camera.position.y, camera.position.z), 600, 20, 10, BLACK);
+                DrawText(FormatText("Camera3D target: (%.2f, %.2f, %.2f)", camera.target.x, camera.target.y, camera.target.z), 600, 40, 10, GRAY);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadShader(shader);       // Unload shader
+        UnloadTexture(texture);     // Unload texture
+        UnloadModel(model);         // Unload model
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/shaders/shaders_shapes_textures.cs

@@ -3,5 +3,112 @@ using static Raylib.Raylib;
 
 public partial class shaders_shapes_textures
 {
-    /*******************************************************************************************
    *
    *   raylib [shaders] example - Apply a shader to some shape or texture
    *
    *   NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
    *         OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
    *
    *   NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
    *         on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
    *         raylib comes with shaders ready for both versions, check raylib/shaders install folder
    *
    *   This example has been created using raylib 1.7 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shapes and texture shaders");
        
        Texture2D fudesumi = LoadTexture("resources/fudesumi.png");
    
        // NOTE: Using GLSL 330 shader version, on OpenGL ES 2.0 use GLSL 100 shader version 
        Shader shader = LoadShader("resources/shaders/glsl330/base.vs", 
                                   "resources/shaders/glsl330/grayscale.fs");
    
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update your variables here
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
                
                // Start drawing with default shader
    
                DrawText("USING DEFAULT SHADER", 20, 40, 10, RED);
                
                DrawCircle(80, 120, 35, DARKBLUE);
                DrawCircleGradient(80, 220, 60, GREEN, SKYBLUE);
                DrawCircleLines(80, 340, 80, DARKBLUE);
    
                
                // Activate our custom shader to be applied on next shapes/textures drawings
                BeginShaderMode(shader);
                
                    DrawText("USING CUSTOM SHADER", 190, 40, 10, RED);
    
                    DrawRectangle(250 - 60, 90, 120, 60, RED);
                    DrawRectangleGradientH(250 - 90, 170, 180, 130, MAROON, GOLD);
                    DrawRectangleLines(250 - 40, 320, 80, 60, ORANGE);
    
                // Activate our default shader for next drawings
                EndShaderMode();
                
                DrawText("USING DEFAULT SHADER", 370, 40, 10, RED);
                
                DrawTriangle(new Vector2(430, 80),
                             new Vector2(430 - 60, 150),
                             new Vector2(430 + 60, 150), VIOLET);
                             
                DrawTriangleLines(new Vector2(430, 160),
                                  new Vector2(430 - 20, 230),
                                  new Vector2(430 + 20, 230), DARKBLUE);
    
                DrawPoly(new Vector2(430, 320), 6, 80, 0, BROWN);
                
                // Activate our custom shader to be applied on next shapes/textures drawings
                BeginShaderMode(shader);
    
                    DrawTexture(fudesumi, 500, -30, WHITE);    // Using custom shader
                
                // Activate our default shader for next drawings
                EndShaderMode();
                
                DrawText("(c) Fudesumi sprite by Eiden Marsal", 380, screenHeight - 20, 10, GRAY);
                
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadShader(shader);       // Unload shader
        UnloadTexture(fudesumi);    // Unload texture
        
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [shaders] example - Apply a shader to some shape or texture
+    *
+    *   NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
+    *         OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
+    *
+    *   NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
+    *         on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
+    *         raylib comes with shaders ready for both versions, check raylib/shaders install folder
+    *
+    *   This example has been created using raylib 1.7 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shapes and texture shaders");
+        
+        Texture2D fudesumi = LoadTexture("resources/fudesumi.png");
+    
+        // NOTE: Using GLSL 330 shader version, on OpenGL ES 2.0 use GLSL 100 shader version 
+        Shader shader = LoadShader("resources/shaders/glsl330/base.vs", 
+                                   "resources/shaders/glsl330/grayscale.fs");
+    
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            // TODO: Update your variables here
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+                
+                // Start drawing with default shader
+    
+                DrawText("USING DEFAULT SHADER", 20, 40, 10, RED);
+                
+                DrawCircle(80, 120, 35, DARKBLUE);
+                DrawCircleGradient(80, 220, 60, GREEN, SKYBLUE);
+                DrawCircleLines(80, 340, 80, DARKBLUE);
+    
+                
+                // Activate our custom shader to be applied on next shapes/textures drawings
+                BeginShaderMode(shader);
+                
+                    DrawText("USING CUSTOM SHADER", 190, 40, 10, RED);
+    
+                    DrawRectangle(250 - 60, 90, 120, 60, RED);
+                    DrawRectangleGradientH(250 - 90, 170, 180, 130, MAROON, GOLD);
+                    DrawRectangleLines(250 - 40, 320, 80, 60, ORANGE);
+    
+                // Activate our default shader for next drawings
+                EndShaderMode();
+                
+                DrawText("USING DEFAULT SHADER", 370, 40, 10, RED);
+                
+                DrawTriangle(new Vector2(430, 80),
+                             new Vector2(430 - 60, 150),
+                             new Vector2(430 + 60, 150), VIOLET);
+                             
+                DrawTriangleLines(new Vector2(430, 160),
+                                  new Vector2(430 - 20, 230),
+                                  new Vector2(430 + 20, 230), DARKBLUE);
+    
+                DrawPoly(new Vector2(430, 320), 6, 80, 0, BROWN);
+                
+                // Activate our custom shader to be applied on next shapes/textures drawings
+                BeginShaderMode(shader);
+    
+                    DrawTexture(fudesumi, 500, -30, WHITE);    // Using custom shader
+                
+                // Activate our default shader for next drawings
+                EndShaderMode();
+                
+                DrawText("(c) Fudesumi sprite by Eiden Marsal", 380, screenHeight - 20, 10, GRAY);
+                
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadShader(shader);       // Unload shader
+        UnloadTexture(fudesumi);    // Unload texture
+        
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/shapes/shapes_basic_shapes.cs

@@ -3,5 +3,75 @@ using static Raylib.Raylib;
 
 public partial class shapes_basic_shapes
 {
-    /*******************************************************************************************
    *
    *   raylib [shapes] example - Draw basic shapes 2d (rectangle, circle, line...)
    *
    *   This example has been created using raylib 1.0 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [shapes] example - basic shapes drawing");
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update your variables here
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("some basic shapes available on raylib", 20, 20, 20, DARKGRAY);
    
                DrawLine(18, 42, screenWidth - 18, 42, BLACK);
    
                DrawCircle(screenWidth/4, 120, 35, DARKBLUE);
                DrawCircleGradient(screenWidth/4, 220, 60, GREEN, SKYBLUE);
                DrawCircleLines(screenWidth/4, 340, 80, DARKBLUE);
    
                DrawRectangle(screenWidth/4*2 - 60, 100, 120, 60, RED);
                DrawRectangleGradientH(screenWidth/4*2 - 90, 170, 180, 130, MAROON, GOLD);
                DrawRectangleLines(screenWidth/4*2 - 40, 320, 80, 60, ORANGE);
    
                DrawTriangle(new Vector2(screenWidth/4*3, 80),
                             new Vector2(screenWidth/4*3 - 60, 150),
                             new Vector2(screenWidth/4*3 + 60, 150), VIOLET);
    
                DrawTriangleLines(new Vector2(screenWidth/4*3, 160),
                                  new Vector2(screenWidth/4*3 - 20, 230),
                                  new Vector2(screenWidth/4*3 + 20, 230), DARKBLUE);
    
                DrawPoly(new Vector2(screenWidth/4*3, 320), 6, 80, 0, BROWN);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [shapes] example - Draw basic shapes 2d (rectangle, circle, line...)
+    *
+    *   This example has been created using raylib 1.0 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [shapes] example - basic shapes drawing");
+        
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            // TODO: Update your variables here
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawText("some basic shapes available on raylib", 20, 20, 20, DARKGRAY);
+    
+                DrawLine(18, 42, screenWidth - 18, 42, BLACK);
+    
+                DrawCircle(screenWidth/4, 120, 35, DARKBLUE);
+                DrawCircleGradient(screenWidth/4, 220, 60, GREEN, SKYBLUE);
+                DrawCircleLines(screenWidth/4, 340, 80, DARKBLUE);
+    
+                DrawRectangle(screenWidth/4*2 - 60, 100, 120, 60, RED);
+                DrawRectangleGradientH(screenWidth/4*2 - 90, 170, 180, 130, MAROON, GOLD);
+                DrawRectangleLines(screenWidth/4*2 - 40, 320, 80, 60, ORANGE);
+    
+                DrawTriangle(new Vector2(screenWidth/4*3, 80),
+                             new Vector2(screenWidth/4*3 - 60, 150),
+                             new Vector2(screenWidth/4*3 + 60, 150), VIOLET);
+    
+                DrawTriangleLines(new Vector2(screenWidth/4*3, 160),
+                                  new Vector2(screenWidth/4*3 - 20, 230),
+                                  new Vector2(screenWidth/4*3 + 20, 230), DARKBLUE);
+    
+                DrawPoly(new Vector2(screenWidth/4*3, 320), 6, 80, 0, BROWN);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/shapes/shapes_colors_palette.cs

@@ -3,5 +3,100 @@ using static Raylib.Raylib;
 
 public partial class shapes_colors_palette
 {
-    /*******************************************************************************************
    *
    *   raylib [shapes] example - Draw raylib custom color palette
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib color palette");
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update your variables here
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("raylib color palette", 28, 42, 20, BLACK);
    
                DrawRectangle(26, 80, 100, 100, DARKGRAY);
                DrawRectangle(26, 188, 100, 100, GRAY);
                DrawRectangle(26, 296, 100, 100, LIGHTGRAY);
                DrawRectangle(134, 80, 100, 100, MAROON);
                DrawRectangle(134, 188, 100, 100, RED);
                DrawRectangle(134, 296, 100, 100, PINK);
                DrawRectangle(242, 80, 100, 100, ORANGE);
                DrawRectangle(242, 188, 100, 100, GOLD);
                DrawRectangle(242, 296, 100, 100, YELLOW);
                DrawRectangle(350, 80, 100, 100, DARKGREEN);
                DrawRectangle(350, 188, 100, 100, LIME);
                DrawRectangle(350, 296, 100, 100, GREEN);
                DrawRectangle(458, 80, 100, 100, DARKBLUE);
                DrawRectangle(458, 188, 100, 100, BLUE);
                DrawRectangle(458, 296, 100, 100, SKYBLUE);
                DrawRectangle(566, 80, 100, 100, DARKPURPLE);
                DrawRectangle(566, 188, 100, 100, VIOLET);
                DrawRectangle(566, 296, 100, 100, PURPLE);
                DrawRectangle(674, 80, 100, 100, DARKBROWN);
                DrawRectangle(674, 188, 100, 100, BROWN);
                DrawRectangle(674, 296, 100, 100, BEIGE);
    
    
                DrawText("DARKGRAY", 65, 166, 10, BLACK);
                DrawText("GRAY", 93, 274, 10, BLACK);
                DrawText("LIGHTGRAY", 61, 382, 10, BLACK);
                DrawText("MAROON", 186, 166, 10, BLACK);
                DrawText("RED", 208, 274, 10, BLACK);
                DrawText("PINK", 204, 382, 10, BLACK);
                DrawText("ORANGE", 295, 166, 10, BLACK);
                DrawText("GOLD", 310, 274, 10, BLACK);
                DrawText("YELLOW", 300, 382, 10, BLACK);
                DrawText("DARKGREEN", 382, 166, 10, BLACK);
                DrawText("LIME", 420, 274, 10, BLACK);
                DrawText("GREEN", 410, 382, 10, BLACK);
                DrawText("DARKBLUE", 498, 166, 10, BLACK);
                DrawText("BLUE", 526, 274, 10, BLACK);
                DrawText("SKYBLUE", 505, 382, 10, BLACK);
                DrawText("DARKPURPLE", 592, 166, 10, BLACK);
                DrawText("VIOLET", 621, 274, 10, BLACK);
                DrawText("PURPLE", 620, 382, 10, BLACK);
                DrawText("DARKBROWN", 705, 166, 10, BLACK);
                DrawText("BROWN", 733, 274, 10, BLACK);
                DrawText("BEIGE", 737, 382, 10, BLACK);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [shapes] example - Draw raylib custom color palette
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib color palette");
+        
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            // TODO: Update your variables here
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawText("raylib color palette", 28, 42, 20, BLACK);
+    
+                DrawRectangle(26, 80, 100, 100, DARKGRAY);
+                DrawRectangle(26, 188, 100, 100, GRAY);
+                DrawRectangle(26, 296, 100, 100, LIGHTGRAY);
+                DrawRectangle(134, 80, 100, 100, MAROON);
+                DrawRectangle(134, 188, 100, 100, RED);
+                DrawRectangle(134, 296, 100, 100, PINK);
+                DrawRectangle(242, 80, 100, 100, ORANGE);
+                DrawRectangle(242, 188, 100, 100, GOLD);
+                DrawRectangle(242, 296, 100, 100, YELLOW);
+                DrawRectangle(350, 80, 100, 100, DARKGREEN);
+                DrawRectangle(350, 188, 100, 100, LIME);
+                DrawRectangle(350, 296, 100, 100, GREEN);
+                DrawRectangle(458, 80, 100, 100, DARKBLUE);
+                DrawRectangle(458, 188, 100, 100, BLUE);
+                DrawRectangle(458, 296, 100, 100, SKYBLUE);
+                DrawRectangle(566, 80, 100, 100, DARKPURPLE);
+                DrawRectangle(566, 188, 100, 100, VIOLET);
+                DrawRectangle(566, 296, 100, 100, PURPLE);
+                DrawRectangle(674, 80, 100, 100, DARKBROWN);
+                DrawRectangle(674, 188, 100, 100, BROWN);
+                DrawRectangle(674, 296, 100, 100, BEIGE);
+    
+    
+                DrawText("DARKGRAY", 65, 166, 10, BLACK);
+                DrawText("GRAY", 93, 274, 10, BLACK);
+                DrawText("LIGHTGRAY", 61, 382, 10, BLACK);
+                DrawText("MAROON", 186, 166, 10, BLACK);
+                DrawText("RED", 208, 274, 10, BLACK);
+                DrawText("PINK", 204, 382, 10, BLACK);
+                DrawText("ORANGE", 295, 166, 10, BLACK);
+                DrawText("GOLD", 310, 274, 10, BLACK);
+                DrawText("YELLOW", 300, 382, 10, BLACK);
+                DrawText("DARKGREEN", 382, 166, 10, BLACK);
+                DrawText("LIME", 420, 274, 10, BLACK);
+                DrawText("GREEN", 410, 382, 10, BLACK);
+                DrawText("DARKBLUE", 498, 166, 10, BLACK);
+                DrawText("BLUE", 526, 274, 10, BLACK);
+                DrawText("SKYBLUE", 505, 382, 10, BLACK);
+                DrawText("DARKPURPLE", 592, 166, 10, BLACK);
+                DrawText("VIOLET", 621, 274, 10, BLACK);
+                DrawText("PURPLE", 620, 382, 10, BLACK);
+                DrawText("DARKBROWN", 705, 166, 10, BLACK);
+                DrawText("BROWN", 733, 274, 10, BLACK);
+                DrawText("BEIGE", 737, 382, 10, BLACK);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/shapes/shapes_lines_bezier.cs

@@ -3,5 +3,63 @@ using static Raylib.Raylib;
 
 public partial class shapes_lines_bezier
 {
-    /*******************************************************************************************
    *
    *   raylib [shapes] example - Cubic-bezier lines
    *
    *   This example has been created using raylib 1.7 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        SetConfigFlags(FLAG_MSAA_4X_HINT);
        InitWindow(screenWidth, screenHeight, "raylib [shapes] example - cubic-bezier lines");
        
        Vector2 start = new Vector2( 0, 0 );
        Vector2 end = new Vector2( screenWidth, screenHeight );
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) start = GetMousePosition();
            else if (IsMouseButtonDown(MOUSE_RIGHT_BUTTON)) end = GetMousePosition();
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
                
                DrawText("USE MOUSE LEFT-RIGHT CLICK to DEFINE LINE START and END POINTS", 15, 20, 20, GRAY);
    
                DrawLineBezier(start, end, 2.0f, RED);
                
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------   
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
        
+    /*******************************************************************************************
+    *
+    *   raylib [shapes] example - Cubic-bezier lines
+    *
+    *   This example has been created using raylib 1.7 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        SetConfigFlags(FLAG_MSAA_4X_HINT);
+        InitWindow(screenWidth, screenHeight, "raylib [shapes] example - cubic-bezier lines");
+        
+        Vector2 start = new Vector2( 0, 0 );
+        Vector2 end = new Vector2( screenWidth, screenHeight );
+        
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) start = GetMousePosition();
+            else if (IsMouseButtonDown(MOUSE_RIGHT_BUTTON)) end = GetMousePosition();
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+                
+                DrawText("USE MOUSE LEFT-RIGHT CLICK to DEFINE LINE START and END POINTS", 15, 20, 20, GRAY);
+    
+                DrawLineBezier(start, end, 2.0f, RED);
+                
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------   
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+        
 }

Examples/shapes/shapes_logo_raylib.cs

@@ -3,5 +3,59 @@ using static Raylib.Raylib;
 
 public partial class shapes_logo_raylib
 {
-    /*******************************************************************************************
    *
    *   raylib [shapes] example - Draw raylib logo using basic shapes
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo using shapes");
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update your variables here
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawRectangle(screenWidth/2 - 128, screenHeight/2 - 128, 256, 256, BLACK);
                DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, RAYWHITE);
                DrawText("raylib", screenWidth/2 - 44, screenHeight/2 + 48, 50, BLACK);
    
                DrawText("this is NOT a texture!", 350, 370, 10, GRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [shapes] example - Draw raylib logo using basic shapes
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo using shapes");
+        
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            // TODO: Update your variables here
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawRectangle(screenWidth/2 - 128, screenHeight/2 - 128, 256, 256, BLACK);
+                DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, RAYWHITE);
+                DrawText("raylib", screenWidth/2 - 44, screenHeight/2 + 48, 50, BLACK);
+    
+                DrawText("this is NOT a texture!", 350, 370, 10, GRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/shapes/shapes_logo_raylib_anim.cs

@@ -1,8 +1,168 @@
 using Raylib;
+using System;
 using static Raylib.Raylib;
 
 public partial class shapes_logo_raylib_anim
 {
-    /*******************************************************************************************
    *
    *   raylib [shapes] example - raylib logo animation
    *
    *   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) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo animation");
    
        int logoPositionX = screenWidth/2 - 128;
        int logoPositionY = screenHeight/2 - 128;
    
        int framesCounter = 0;
        int lettersCount = 0;
    
        int topSideRecWidth = 16;
        int leftSideRecHeight = 16;
    
        int bottomSideRecWidth = 16;
        int rightSideRecHeight = 16;
    
        int state = 0;                  // Tracking animation states (State Machine)
        float alpha = 1.0f;             // Useful for fading
    
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (state == 0)                 // State 0: Small box blinking
            {
                framesCounter++;
    
                if (framesCounter == 120)
                {
                    state = 1;
                    framesCounter = 0;      // Reset counter... will be used later...
                }
            }
            else if (state == 1)            // State 1: Top and left bars growing
            {
                topSideRecWidth += 4;
                leftSideRecHeight += 4;
    
                if (topSideRecWidth == 256) state = 2;
            }
            else if (state == 2)            // State 2: Bottom and right bars growing
            {
                bottomSideRecWidth += 4;
                rightSideRecHeight += 4;
    
                if (bottomSideRecWidth == 256) state = 3;
            }
            else if (state == 3)            // State 3: Letters appearing (one by one)
            {
                framesCounter++;
+    /*******************************************************************************************
-
                if (framesCounter/12 != 0)       // Every 12 frames, one more letter!
                {
                    lettersCount++;
                    framesCounter = 0;
                }
    
                if (lettersCount >= 10)     // When all letters have appeared, just fade out everything
                {
                    alpha -= 0.02f;
    
                    if (alpha <= 0.0f)
                    {
                        alpha = 0.0f;
                        state = 4;
                    }
                }
            }
            else if (state == 4)            // State 4: Reset and Replay
            {
                if (IsKeyPressed('R'))
                {
                    framesCounter = 0;
                    lettersCount = 0;
    
                    topSideRecWidth = 16;
                    leftSideRecHeight = 16;
    
                    bottomSideRecWidth = 16;
                    rightSideRecHeight = 16;
    
                    alpha = 1.0f;
                    state = 0;          // Return to State 0
                }
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                if (state == 0)
                {
                    if ((framesCounter/15)%2 != 0) DrawRectangle(logoPositionX, logoPositionY, 16, 16, BLACK);
                }
                else if (state == 1)
                {
                    DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, BLACK);
                    DrawRectangle(logoPositionX, logoPositionY, 16, leftSideRecHeight, BLACK);
                }
                else if (state == 2)
                {
                    DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, BLACK);
                    DrawRectangle(logoPositionX, logoPositionY, 16, leftSideRecHeight, BLACK);
    
                    DrawRectangle(logoPositionX + 240, logoPositionY, 16, rightSideRecHeight, BLACK);
                    DrawRectangle(logoPositionX, logoPositionY + 240, bottomSideRecWidth, 16, BLACK);
                }
                else if (state == 3)
                {
                    DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, Fade(BLACK, alpha));
                    DrawRectangle(logoPositionX, logoPositionY + 16, 16, leftSideRecHeight - 32, Fade(BLACK, alpha));
    
                    DrawRectangle(logoPositionX + 240, logoPositionY + 16, 16, rightSideRecHeight - 32, Fade(BLACK, alpha));
                    DrawRectangle(logoPositionX, logoPositionY + 240, bottomSideRecWidth, 16, Fade(BLACK, alpha));
    
                    DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, Fade(RAYWHITE, alpha));
    
                    //DrawText(SubText("raylib", 0, lettersCount), screenWidth/2 - 44, screenHeight/2 + 48, 50, Fade(BLACK, alpha));
                }
                else if (state == 4)
                {
                    DrawText("[R] REPLAY", 340, 200, 20, GRAY);
                }
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    *
+    *   raylib [shapes] example - raylib logo animation
+    *
+    *   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) 2014 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo animation");
+    
+        int logoPositionX = screenWidth/2 - 128;
+        int logoPositionY = screenHeight/2 - 128;
+    
+        int framesCounter = 0;
+        int lettersCount = 0;
+    
+        int topSideRecWidth = 16;
+        int leftSideRecHeight = 16;
+    
+        int bottomSideRecWidth = 16;
+        int rightSideRecHeight = 16;
+    
+        int state = 0;                  // Tracking animation states (State Machine)
+        float alpha = 1.0f;             // Useful for fading
+    
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            if (state == 0)                 // State 0: Small box blinking
+            {
+                framesCounter++;
+    
+                if (framesCounter == 120)
+                {
+                    state = 1;
+                    framesCounter = 0;      // Reset counter... will be used later...
+                }
+            }
+            else if (state == 1)            // State 1: Top and left bars growing
+            {
+                topSideRecWidth += 4;
+                leftSideRecHeight += 4;
+    
+                if (topSideRecWidth == 256) state = 2;
+            }
+            else if (state == 2)            // State 2: Bottom and right bars growing
+            {
+                bottomSideRecWidth += 4;
+                rightSideRecHeight += 4;
+    
+                if (bottomSideRecWidth == 256) state = 3;
+            }
+            else if (state == 3)            // State 3: Letters appearing (one by one)
+            {
+                framesCounter++;
+
+                if (framesCounter/12 != 0)       // Every 12 frames, one more letter!
+                {
+                    lettersCount++;
+                    framesCounter = 0;
+                }
+    
+                if (lettersCount >= 10)     // When all letters have appeared, just fade out everything
+                {
+                    alpha -= 0.02f;
+    
+                    if (alpha <= 0.0f)
+                    {
+                        alpha = 0.0f;
+                        state = 4;
+                    }
+                }
+            }
+            else if (state == 4)            // State 4: Reset and Replay
+            {
+                if (IsKeyPressed('R'))
+                {
+                    framesCounter = 0;
+                    lettersCount = 0;
+    
+                    topSideRecWidth = 16;
+                    leftSideRecHeight = 16;
+    
+                    bottomSideRecWidth = 16;
+                    rightSideRecHeight = 16;
+    
+                    alpha = 1.0f;
+                    state = 0;          // Return to State 0
+                }
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                if (state == 0)
+                {
+                    if ((framesCounter/15)%2 != 0) DrawRectangle(logoPositionX, logoPositionY, 16, 16, BLACK);
+                }
+                else if (state == 1)
+                {
+                    DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, BLACK);
+                    DrawRectangle(logoPositionX, logoPositionY, 16, leftSideRecHeight, BLACK);
+                }
+                else if (state == 2)
+                {
+                    DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, BLACK);
+                    DrawRectangle(logoPositionX, logoPositionY, 16, leftSideRecHeight, BLACK);
+    
+                    DrawRectangle(logoPositionX + 240, logoPositionY, 16, rightSideRecHeight, BLACK);
+                    DrawRectangle(logoPositionX, logoPositionY + 240, bottomSideRecWidth, 16, BLACK);
+                }
+                else if (state == 3)
+                {
+                    DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, Fade(BLACK, alpha));
+                    DrawRectangle(logoPositionX, logoPositionY + 16, 16, leftSideRecHeight - 32, Fade(BLACK, alpha));
+    
+                    DrawRectangle(logoPositionX + 240, logoPositionY + 16, 16, rightSideRecHeight - 32, Fade(BLACK, alpha));
+                    DrawRectangle(logoPositionX, logoPositionY + 240, bottomSideRecWidth, 16, Fade(BLACK, alpha));
+    
+                    DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, Fade(RAYWHITE, alpha));
+
+                    // DrawText(SubText("raylib", 0, lettersCount), screenWidth/2 - 44, screenHeight/2 + 48, 50, Fade(BLACK, alpha));
+                    var text = "raylib";
+                    DrawText(text.Substring(0, Math.Min(text.Length, lettersCount)), screenWidth/2 - 44, screenHeight/2 + 48, 50, Fade(BLACK, alpha));
+                }
+                else if (state == 4)
+                {
+                    DrawText("[R] REPLAY", 340, 200, 20, GRAY);
+                }
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/text/text_bmfont_ttf.cs

@@ -3,5 +3,71 @@ using static Raylib.Raylib;
 
 public partial class text_bmfont_ttf
 {
-    /*******************************************************************************************
    *
    *   raylib [text] example - BMFont and TTF Fonts loading
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [text] example - bmfont and ttf sprite fonts loading");
    
        string msgBm = "THIS IS AN AngelCode SPRITE FONT";
        string msgTtf = "THIS SPRITE FONT has been GENERATED from a TTF";
    
        // NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required)
        Font fontBm = LoadFont("resources/bmfont.fnt");       // BMFont (AngelCode)
        Font fontTtf = LoadFont("resources/pixantiqua.ttf");  // TTF font
    
        Vector2 fontPosition;
    
        fontPosition.x = screenWidth/2 - MeasureTextEx(fontBm, msgBm, fontBm.baseSize, 0).x/2;
        fontPosition.y = screenHeight/2 - fontBm.baseSize/2 - 80;
    
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update variables here...
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawTextEx(fontBm, msgBm, fontPosition, fontBm.baseSize, 0, MAROON);
                DrawTextEx(fontTtf, msgTtf, new Vector2( 75.0f, 240.0f ), fontTtf.baseSize*0.8f, 2, LIME);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadFont(fontBm);     // AngelCode Font unloading
        UnloadFont(fontTtf);    // TTF Font unloading
    
        CloseWindow();                // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [text] example - BMFont and TTF Fonts loading
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [text] example - bmfont and ttf sprite fonts loading");
+    
+        string msgBm = "THIS IS AN AngelCode SPRITE FONT";
+        string msgTtf = "THIS SPRITE FONT has been GENERATED from a TTF";
+    
+        // NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required)
+        Font fontBm = LoadFont("resources/bmfont.fnt");       // BMFont (AngelCode)
+        Font fontTtf = LoadFont("resources/pixantiqua.ttf");  // TTF font
+    
+        Vector2 fontPosition;
+    
+        fontPosition.x = screenWidth/2 - MeasureTextEx(fontBm, msgBm, fontBm.baseSize, 0).x/2;
+        fontPosition.y = screenHeight/2 - fontBm.baseSize/2 - 80;
+    
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            // TODO: Update variables here...
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawTextEx(fontBm, msgBm, fontPosition, fontBm.baseSize, 0, MAROON);
+                DrawTextEx(fontTtf, msgTtf, new Vector2( 75.0f, 240.0f ), fontTtf.baseSize*0.8f, 2, LIME);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadFont(fontBm);     // AngelCode Font unloading
+        UnloadFont(fontTtf);    // TTF Font unloading
+    
+        CloseWindow();                // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/text/text_font_sdf.cs

@@ -4,17 +4,132 @@ using static Raylib.TextureFilterMode;
 
 public partial class text_font_sdf
 {
-    /*******************************************************************************************
    *
    *   raylib [text] example - TTF loading and usage
    *
    *   This example has been created using raylib 1.3.0 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [text] example - SDF fonts");
    
        // NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required)
        
        string msg = "Signed Distance Fields";
    
        // Default font generation from TTF font
        Font fontDefault = new Font();
        fontDefault.baseSize = 16;
        fontDefault.charsCount = 95;
+    /*******************************************************************************************
-        // Parameters > font size: 16, no chars array provided (0), chars count: 95 (autogenerate chars array)
+    *
-        // TODO: fix conversion
+    *   raylib [text] example - TTF loading and usage
-        //fontDefault.chars = LoadFontData("resources/AnonymousPro-Bold.ttf", 16, null, 95, false);
+    *
-        // Parameters > chars count: 95, font size: 16, chars padding in image: 4 px, pack method: 0 (default)
+    *   This example has been created using raylib 1.3.0 (www.raylib.com)
-        //Image atlas = GenImageFontAtlas(fontDefault.chars, 95, 16, 4, 0);
        //fontDefault.texture = LoadTextureFromImage(atlas);
        //UnloadImage(atlas);
        
        // SDF font generation from TTF font
        // NOTE: SDF chars data is generated with LoadFontData(), it's just a bool option
        Font fontSDF = new Font();
        fontSDF.baseSize = 16;
        fontSDF.charsCount = 95;
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-        // Parameters > font size: 16, no chars array provided (0), chars count: 0 (defaults to 95)
+    *
-        // TODO: fix conversion
+    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
-        //fontSDF.chars = LoadFontData("resources/AnonymousPro-Bold.ttf", 16, null, 0, true);
+    *
-        // Parameters > chars count: 95, font size: 16, chars padding in image: 0 px, pack method: 1 (Skyline algorythm)
+    ********************************************************************************************/
-        // TODO: fix conversion
+    
-        //atlas = GenImageFontAtlas(fontSDF.chars, 95, 16, 0, 1);
+    
-        //fontSDF.texture = LoadTextureFromImage(atlas);
        //UnloadImage(atlas);
        
        // Load SDF required shader (we use default vertex shader)
        Shader shader = LoadShader(null, "resources/shaders/sdf.fs");
        SetTextureFilter(fontSDF.texture, (int)FILTER_BILINEAR);    // Required for SDF font
    
        Vector2 fontPosition = new Vector2( 40, screenHeight/2 - 50 );
        Vector2 textSize = new Vector2( 0.0f );
        float fontSize = 16.0f;
        int currentFont = 0;    // 0 - fontDefault, 1 - fontSDF
    
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
        
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            fontSize += GetMouseWheelMove()*8.0f;
            
            if (fontSize < 6) fontSize = 6;
            
            if (IsKeyDown(KEY_SPACE)) currentFont = 1;
            else currentFont = 0;
            
            if (currentFont == 0) textSize = MeasureTextEx(fontDefault, msg, fontSize, 0);
            else textSize = MeasureTextEx(fontSDF, msg, fontSize, 0);
            
            fontPosition.x = GetScreenWidth()/2 - textSize.x/2;
            fontPosition.y = GetScreenHeight()/2 - textSize.y/2 + 80;
            //----------------------------------------------------------------------------------
            
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
            
                ClearBackground(RAYWHITE);
                
                if (currentFont == 1)
                {
                    // NOTE: SDF fonts require a custom SDf shader to compute fragment color
                    BeginShaderMode(shader);    // Activate SDF font shader
                        DrawTextEx(fontSDF, msg, fontPosition, fontSize, 0, BLACK);
                    EndShaderMode();            // Activate our default shader for next drawings
                    
                    DrawTexture(fontSDF.texture, 10, 10, BLACK);
                }
                else 
                {
                    DrawTextEx(fontDefault, msg, fontPosition, fontSize, 0, BLACK);
                    DrawTexture(fontDefault.texture, 10, 10, BLACK);
                }
                
                if (currentFont == 1) DrawText("SDF!", 320, 20, 80, RED);
                else DrawText("default font", 315, 40, 30, GRAY);
    
                DrawText("FONT SIZE: 16.0", GetScreenWidth() - 240, 20, 20, DARKGRAY);
                DrawText(FormatText("RENDER SIZE: %02.02f", fontSize), GetScreenWidth() - 240, 50, 20, DARKGRAY);
                DrawText("Use MOUSE WHEEL to SCALE TEXT!", GetScreenWidth() - 240, 90, 10, DARKGRAY);
    
                DrawText("PRESS SPACE to USE SDF FONT VERSION!", 340, GetScreenHeight() - 30, 20, MAROON);
          
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadFont(fontDefault);    // Default font unloading
        UnloadFont(fontSDF);        // SDF font unloading
        
        UnloadShader(shader);       // Unload SDF shader
        
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
        
        return 0;
    }    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [text] example - SDF fonts");
+    
+        // NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required)
+        
+        string msg = "Signed Distance Fields";
+    
+        // Default font generation from TTF font
+        Font fontDefault = new Font();
+        fontDefault.baseSize = 16;
+        fontDefault.charsCount = 95;
+        // Parameters > font size: 16, no chars array provided (0), chars count: 95 (autogenerate chars array)
+        // TODO: fix conversion
+        //fontDefault.chars = LoadFontData("resources/AnonymousPro-Bold.ttf", 16, null, 95, false);
+        // Parameters > chars count: 95, font size: 16, chars padding in image: 4 px, pack method: 0 (default)
+        //Image atlas = GenImageFontAtlas(fontDefault.chars, 95, 16, 4, 0);
+        //fontDefault.texture = LoadTextureFromImage(atlas);
+        //UnloadImage(atlas);
+        
+        // SDF font generation from TTF font
+        // NOTE: SDF chars data is generated with LoadFontData(), it's just a bool option
+        Font fontSDF = new Font();
+        fontSDF.baseSize = 16;
+        fontSDF.charsCount = 95;
+        // Parameters > font size: 16, no chars array provided (0), chars count: 0 (defaults to 95)
+        // TODO: fix conversion
+        //fontSDF.chars = LoadFontData("resources/AnonymousPro-Bold.ttf", 16, null, 0, true);
+        // Parameters > chars count: 95, font size: 16, chars padding in image: 0 px, pack method: 1 (Skyline algorythm)
+        // TODO: fix conversion
+        //atlas = GenImageFontAtlas(fontSDF.chars, 95, 16, 0, 1);
+        //fontSDF.texture = LoadTextureFromImage(atlas);
+        //UnloadImage(atlas);
+        
+        // Load SDF required shader (we use default vertex shader)
+        Shader shader = LoadShader(null, "resources/shaders/sdf.fs");
+        SetTextureFilter(fontSDF.texture, (int)FILTER_BILINEAR);    // Required for SDF font
+    
+        Vector2 fontPosition = new Vector2( 40, screenHeight/2 - 50 );
+        Vector2 textSize = new Vector2( 0.0f );
+        float fontSize = 16.0f;
+        int currentFont = 0;    // 0 - fontDefault, 1 - fontSDF
+    
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+        
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            fontSize += GetMouseWheelMove()*8.0f;
+            
+            if (fontSize < 6) fontSize = 6;
+            
+            if (IsKeyDown(KEY_SPACE)) currentFont = 1;
+            else currentFont = 0;
+            
+            if (currentFont == 0) textSize = MeasureTextEx(fontDefault, msg, fontSize, 0);
+            else textSize = MeasureTextEx(fontSDF, msg, fontSize, 0);
+            
+            fontPosition.x = GetScreenWidth()/2 - textSize.x/2;
+            fontPosition.y = GetScreenHeight()/2 - textSize.y/2 + 80;
+            //----------------------------------------------------------------------------------
+            
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+            
+                ClearBackground(RAYWHITE);
+                
+                if (currentFont == 1)
+                {
+                    // NOTE: SDF fonts require a custom SDf shader to compute fragment color
+                    BeginShaderMode(shader);    // Activate SDF font shader
+                        DrawTextEx(fontSDF, msg, fontPosition, fontSize, 0, BLACK);
+                    EndShaderMode();            // Activate our default shader for next drawings
+                    
+                    DrawTexture(fontSDF.texture, 10, 10, BLACK);
+                }
+                else 
+                {
+                    DrawTextEx(fontDefault, msg, fontPosition, fontSize, 0, BLACK);
+                    DrawTexture(fontDefault.texture, 10, 10, BLACK);
+                }
+                
+                if (currentFont == 1) DrawText("SDF!", 320, 20, 80, RED);
+                else DrawText("default font", 315, 40, 30, GRAY);
+    
+                DrawText("FONT SIZE: 16.0", GetScreenWidth() - 240, 20, 20, DARKGRAY);
+                DrawText(FormatText("RENDER SIZE: %02.02f", fontSize), GetScreenWidth() - 240, 50, 20, DARKGRAY);
+                DrawText("Use MOUSE WHEEL to SCALE TEXT!", GetScreenWidth() - 240, 90, 10, DARKGRAY);
+    
+                DrawText("PRESS SPACE to USE SDF FONT VERSION!", 340, GetScreenHeight() - 30, 20, MAROON);
+          
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadFont(fontDefault);    // Default font unloading
+        UnloadFont(fontSDF);        // SDF font unloading
+        
+        UnloadShader(shader);       // Unload SDF shader
+        
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+        
+        return 0;
+    }    
 }

Examples/text/text_format_text.cs

@@ -3,5 +3,65 @@ using static Raylib.Raylib;
 
 public partial class text_format_text
 {
-    /*******************************************************************************************
    *
    *   raylib [text] example - Text formatting
    *
    *   This example has been created using raylib 1.1 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [text] example - text formatting");
    
        int score = 100020;
        int hiscore = 200450;
        int lives = 5;
    
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update your variables here
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText(FormatText("Score: %08i", score), 200, 80, 20, RED);
    
                DrawText(FormatText("HiScore: %08i", hiscore), 200, 120, 20, GREEN);
    
                DrawText(FormatText("Lives: %02i", lives), 200, 160, 40, BLUE);
    
                DrawText(FormatText("Elapsed Time: %02.02f ms", GetFrameTime()*1000), 200, 220, 20, BLACK);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [text] example - Text formatting
+    *
+    *   This example has been created using raylib 1.1 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [text] example - text formatting");
+    
+        int score = 100020;
+        int hiscore = 200450;
+        int lives = 5;
+    
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            // TODO: Update your variables here
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawText(FormatText("Score: %08i", score), 200, 80, 20, RED);
+    
+                DrawText(FormatText("HiScore: %08i", hiscore), 200, 120, 20, GREEN);
+    
+                DrawText(FormatText("Lives: %02i", lives), 200, 160, 40, BLUE);
+    
+                DrawText(FormatText("Elapsed Time: %02.02f ms", GetFrameTime()*1000), 200, 220, 20, BLACK);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/text/text_input_box.cs

@@ -1,10 +1,122 @@
 using Raylib;
-using System.Text;
+using System.Text;
 using static Raylib.Raylib;
 
 public partial class text_input_box
 {
-    /*******************************************************************************************
    *
    *   raylib [text] example - Input Box
    *
    *   This example has been created using raylib 1.7 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public const int MAX_INPUT_CHARS = 9;
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [text] example - input box");
+    /*******************************************************************************************
-
+    *
-        StringBuilder name = new StringBuilder(' ', MAX_INPUT_CHARS + 1);      // NOTE: One extra space required for line ending char '\0'
        int letterCount = 0;
    
        Rectangle textBox = new Rectangle( screenWidth/2 - 100, 180, 225, 50 );
        bool mouseOnText = false;
    
        int framesCounter = 0;
    
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (CheckCollisionPointRec(GetMousePosition(), textBox)) mouseOnText = true;
            else mouseOnText = false;
            
            if (mouseOnText)
            {
                int key = GetKeyPressed();
                
                // NOTE: Only allow keys in range [32..125]
                if ((key >= 32) && (key <= 125) && (letterCount < MAX_INPUT_CHARS))
                {
                    name[letterCount] = (char)key;
                    letterCount++;
                }
                
                if (IsKeyPressed(KEY_BACKSPACE))
                {
                    letterCount--;
                    name[letterCount] = '\0';
                    
                    if (letterCount < 0) letterCount = 0;
                }
            }
            
            if (mouseOnText) framesCounter++;
            else framesCounter = 0;
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
                
                DrawText("PLACE MOUSE OVER INPUT BOX!", 240, 140, 20, GRAY);
    
                DrawRectangleRec(textBox, LIGHTGRAY);
                if (mouseOnText) DrawRectangleLines((int)textBox.x, (int)textBox.y, (int)textBox.width, (int)textBox.height, RED);
                else DrawRectangleLines((int)textBox.x, (int)textBox.y, (int)textBox.width, (int)textBox.height, DARKGRAY);
                
                DrawText(name.ToString(), (int)textBox.x + 5, (int)textBox.y + 8, 40, MAROON);
                
                DrawText(FormatText("INPUT CHARS: %i/%i", letterCount, MAX_INPUT_CHARS), 315, 250, 20, DARKGRAY);
    
                if (mouseOnText)
                {
                    if (letterCount < MAX_INPUT_CHARS)
                    {
                        // Draw blinking underscore char
                        if (((framesCounter/20)%2) == 0) DrawText("_", (int)textBox.x + 8 + MeasureText(name.ToString(), 40), (int)textBox.y + 12, 40, MAROON);
                    }
                    else DrawText("Press BACKSPACE to delete chars...", 230, 300, 20, GRAY);
                }
                
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------   
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
    
    // Check if any key is pressed
    // NOTE: We limit keys check to keys between 32 (KEY_SPACE) and 126
    bool IsAnyKeyPressed()
    {
        bool keyPressed = false;
        int key = GetKeyPressed();
    
        if ((key >= 32) && (key <= 126)) keyPressed = true;
    
        return keyPressed;
    }    
+    *   raylib [text] example - Input Box
+    *
+    *   This example has been created using raylib 1.7 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public const int MAX_INPUT_CHARS = 9;
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [text] example - input box");
+
+        StringBuilder name = new StringBuilder(' ', MAX_INPUT_CHARS + 1);      // NOTE: One extra space required for line ending char '\0'
+        int letterCount = 0;
+    
+        Rectangle textBox = new Rectangle( screenWidth/2 - 100, 180, 225, 50 );
+        bool mouseOnText = false;
+    
+        int framesCounter = 0;
+    
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            if (CheckCollisionPointRec(GetMousePosition(), textBox)) mouseOnText = true;
+            else mouseOnText = false;
+            
+            if (mouseOnText)
+            {
+                int key = GetKeyPressed();
+                
+                // NOTE: Only allow keys in range [32..125]
+                if ((key >= 32) && (key <= 125) && (letterCount < MAX_INPUT_CHARS))
+                {
+                    name[letterCount] = (char)key;
+                    letterCount++;
+                }
+                
+                if (IsKeyPressed(KEY_BACKSPACE))
+                {
+                    letterCount--;
+                    name[letterCount] = '\0';
+                    
+                    if (letterCount < 0) letterCount = 0;
+                }
+            }
+            
+            if (mouseOnText) framesCounter++;
+            else framesCounter = 0;
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+                
+                DrawText("PLACE MOUSE OVER INPUT BOX!", 240, 140, 20, GRAY);
+    
+                DrawRectangleRec(textBox, LIGHTGRAY);
+                if (mouseOnText) DrawRectangleLines((int)textBox.x, (int)textBox.y, (int)textBox.width, (int)textBox.height, RED);
+                else DrawRectangleLines((int)textBox.x, (int)textBox.y, (int)textBox.width, (int)textBox.height, DARKGRAY);
+                
+                DrawText(name.ToString(), (int)textBox.x + 5, (int)textBox.y + 8, 40, MAROON);
+                
+                DrawText(FormatText("INPUT CHARS: %i/%i", letterCount, MAX_INPUT_CHARS), 315, 250, 20, DARKGRAY);
+    
+                if (mouseOnText)
+                {
+                    if (letterCount < MAX_INPUT_CHARS)
+                    {
+                        // Draw blinking underscore char
+                        if (((framesCounter/20)%2) == 0) DrawText("_", (int)textBox.x + 8 + MeasureText(name.ToString(), 40), (int)textBox.y + 12, 40, MAROON);
+                    }
+                    else DrawText("Press BACKSPACE to delete chars...", 230, 300, 20, GRAY);
+                }
+                
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------   
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+    
+    // Check if any key is pressed
+    // NOTE: We limit keys check to keys between 32 (KEY_SPACE) and 126
+    bool IsAnyKeyPressed()
+    {
+        bool keyPressed = false;
+        int key = GetKeyPressed();
+    
+        if ((key >= 32) && (key <= 126)) keyPressed = true;
+    
+        return keyPressed;
+    }    
 }

Examples/text/text_raylib_fonts.cs

@@ -3,5 +3,106 @@ using static Raylib.Raylib;
 
 public partial class text_raylib_fonts
 {
-    /*******************************************************************************************
    *
    *   raylib [text] example - raylib font loading and usage
    *
    *   NOTE: raylib is distributed with some free to use fonts (even for commercial pourposes!)
    *         To view details and credits for those fonts, check raylib license file
    *
    *   This example has been created using raylib 1.7 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public const int MAX_FONTS = 8;
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [text] example - raylib fonts");
    
        // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
        Font[] fonts = new Font[MAX_FONTS];
        
        fonts[0] = LoadFont("resources/fonts/alagard.png");
        fonts[1] = LoadFont("resources/fonts/pixelplay.png");
        fonts[2] = LoadFont("resources/fonts/mecha.png");
        fonts[3] = LoadFont("resources/fonts/setback.png");
        fonts[4] = LoadFont("resources/fonts/romulus.png");
        fonts[5] = LoadFont("resources/fonts/pixantiqua.png");
        fonts[6] = LoadFont("resources/fonts/alpha_beta.png");
        fonts[7] = LoadFont("resources/fonts/jupiter_crash.png");
        
        string[] messages = new string[MAX_FONTS] { "ALAGARD FONT designed by Hewett Tsoi", 
                                    "PIXELPLAY FONT designed by Aleksander Shevchuk",
                                    "MECHA FONT designed by Captain Falcon",  
                                    "SETBACK FONT designed by Brian Kent (AEnigma)", 
                                    "ROMULUS FONT designed by Hewett Tsoi", 
                                    "PIXANTIQUA FONT designed by Gerhard Grossmann",
                                    "ALPHA_BETA FONT designed by Brian Kent (AEnigma)",
                                    "JUPITER_CRASH FONT designed by Brian Kent (AEnigma)" };
                                    
        int[] spacings = new int[MAX_FONTS]{ 2, 4, 8, 4, 3, 4, 4, 1 };
        
        Vector2[] positions = new Vector2[MAX_FONTS];
        
        for (int i = 0; i < MAX_FONTS; i++)
        {
            positions[i].x = screenWidth/2 - MeasureTextEx(fonts[i], messages[i], fonts[i].baseSize*2, spacings[i]).x/2;
            positions[i].y = 60 + fonts[i].baseSize + 45*i;
        }
        
        // Small Y position corrections
        positions[3].y += 8;
        positions[4].y += 2;
        positions[7].y -= 8;
        
        Color[] colors = new Color[MAX_FONTS] { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD, RED };
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update your variables here
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
                
                DrawText("free fonts included with raylib", 250, 20, 20, DARKGRAY);
                DrawLine(220, 50, 590, 50, DARKGRAY);
                
                for (int i = 0; i < MAX_FONTS; i++)
                {
                    DrawTextEx(fonts[i], messages[i], positions[i], fonts[i].baseSize*2, spacings[i], colors[i]);
                }
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        
        // Fonts unloading
        for (int i = 0; i < MAX_FONTS; i++) UnloadFont(fonts[i]);
    
        CloseWindow();                 // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [text] example - raylib font loading and usage
+    *
+    *   NOTE: raylib is distributed with some free to use fonts (even for commercial pourposes!)
+    *         To view details and credits for those fonts, check raylib license file
+    *
+    *   This example has been created using raylib 1.7 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public const int MAX_FONTS = 8;
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [text] example - raylib fonts");
+    
+        // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+        Font[] fonts = new Font[MAX_FONTS];
+        
+        fonts[0] = LoadFont("resources/fonts/alagard.png");
+        fonts[1] = LoadFont("resources/fonts/pixelplay.png");
+        fonts[2] = LoadFont("resources/fonts/mecha.png");
+        fonts[3] = LoadFont("resources/fonts/setback.png");
+        fonts[4] = LoadFont("resources/fonts/romulus.png");
+        fonts[5] = LoadFont("resources/fonts/pixantiqua.png");
+        fonts[6] = LoadFont("resources/fonts/alpha_beta.png");
+        fonts[7] = LoadFont("resources/fonts/jupiter_crash.png");
+        
+        string[] messages = new string[MAX_FONTS] { "ALAGARD FONT designed by Hewett Tsoi", 
+                                    "PIXELPLAY FONT designed by Aleksander Shevchuk",
+                                    "MECHA FONT designed by Captain Falcon",  
+                                    "SETBACK FONT designed by Brian Kent (AEnigma)", 
+                                    "ROMULUS FONT designed by Hewett Tsoi", 
+                                    "PIXANTIQUA FONT designed by Gerhard Grossmann",
+                                    "ALPHA_BETA FONT designed by Brian Kent (AEnigma)",
+                                    "JUPITER_CRASH FONT designed by Brian Kent (AEnigma)" };
+                                    
+        int[] spacings = new int[MAX_FONTS]{ 2, 4, 8, 4, 3, 4, 4, 1 };
+        
+        Vector2[] positions = new Vector2[MAX_FONTS];
+        
+        for (int i = 0; i < MAX_FONTS; i++)
+        {
+            positions[i].x = screenWidth/2 - MeasureTextEx(fonts[i], messages[i], fonts[i].baseSize*2, spacings[i]).x/2;
+            positions[i].y = 60 + fonts[i].baseSize + 45*i;
+        }
+        
+        // Small Y position corrections
+        positions[3].y += 8;
+        positions[4].y += 2;
+        positions[7].y -= 8;
+        
+        Color[] colors = new Color[MAX_FONTS] { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD, RED };
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            // TODO: Update your variables here
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+                
+                DrawText("free fonts included with raylib", 250, 20, 20, DARKGRAY);
+                DrawLine(220, 50, 590, 50, DARKGRAY);
+                
+                for (int i = 0; i < MAX_FONTS; i++)
+                {
+                    DrawTextEx(fonts[i], messages[i], positions[i], fonts[i].baseSize*2, spacings[i], colors[i]);
+                }
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        
+        // Fonts unloading
+        for (int i = 0; i < MAX_FONTS; i++) UnloadFont(fonts[i]);
+    
+        CloseWindow();                 // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/text/text_sprite_fonts.cs

@@ -3,5 +3,80 @@ using static Raylib.Raylib;
 
 public partial class text_sprite_fonts
 {
-    /*******************************************************************************************
    *
    *   raylib [text] example - Font loading and usage
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [text] example - sprite fonts usage");
    
        string msg1 = "THIS IS A custom SPRITE FONT...";
        string msg2 = "...and this is ANOTHER CUSTOM font...";
        string msg3 = "...and a THIRD one! GREAT! :D";
    
        // NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required)
        Font font1 = LoadFont("resources/custom_mecha.png");          // Font loading
        Font font2 = LoadFont("resources/custom_alagard.png");        // Font loading
        Font font3 = LoadFont("resources/custom_jupiter_crash.png");  // Font loading
    
        Vector2 fontPosition1, fontPosition2, fontPosition3;
    
        fontPosition1.x = screenWidth/2 - MeasureTextEx(font1, msg1, font1.baseSize, -3).x/2;
        fontPosition1.y = screenHeight/2 - font1.baseSize/2 - 80;
    
        fontPosition2.x = screenWidth/2 - MeasureTextEx(font2, msg2, font2.baseSize, -2).x/2;
        fontPosition2.y = screenHeight/2 - font2.baseSize/2 - 10;
    
        fontPosition3.x = screenWidth/2 - MeasureTextEx(font3, msg3, font3.baseSize, 2).x/2;
        fontPosition3.y = screenHeight/2 - font3.baseSize/2 + 50;
    
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update variables here...
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawTextEx(font1, msg1, fontPosition1, font1.baseSize, -3, WHITE);
                DrawTextEx(font2, msg2, fontPosition2, font2.baseSize, -2, WHITE);
                DrawTextEx(font3, msg3, fontPosition3, font3.baseSize, 2, WHITE);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadFont(font1);      // Font unloading
        UnloadFont(font2);      // Font unloading
        UnloadFont(font3);      // Font unloading
    
        CloseWindow();                // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [text] example - Font loading and usage
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [text] example - sprite fonts usage");
+    
+        string msg1 = "THIS IS A custom SPRITE FONT...";
+        string msg2 = "...and this is ANOTHER CUSTOM font...";
+        string msg3 = "...and a THIRD one! GREAT! :D";
+    
+        // NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required)
+        Font font1 = LoadFont("resources/custom_mecha.png");          // Font loading
+        Font font2 = LoadFont("resources/custom_alagard.png");        // Font loading
+        Font font3 = LoadFont("resources/custom_jupiter_crash.png");  // Font loading
+    
+        Vector2 fontPosition1, fontPosition2, fontPosition3;
+    
+        fontPosition1.x = screenWidth/2 - MeasureTextEx(font1, msg1, font1.baseSize, -3).x/2;
+        fontPosition1.y = screenHeight/2 - font1.baseSize/2 - 80;
+    
+        fontPosition2.x = screenWidth/2 - MeasureTextEx(font2, msg2, font2.baseSize, -2).x/2;
+        fontPosition2.y = screenHeight/2 - font2.baseSize/2 - 10;
+    
+        fontPosition3.x = screenWidth/2 - MeasureTextEx(font3, msg3, font3.baseSize, 2).x/2;
+        fontPosition3.y = screenHeight/2 - font3.baseSize/2 + 50;
+    
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            // TODO: Update variables here...
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawTextEx(font1, msg1, fontPosition1, font1.baseSize, -3, WHITE);
+                DrawTextEx(font2, msg2, fontPosition2, font2.baseSize, -2, WHITE);
+                DrawTextEx(font3, msg3, fontPosition3, font3.baseSize, 2, WHITE);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadFont(font1);      // Font unloading
+        UnloadFont(font2);      // Font unloading
+        UnloadFont(font3);      // Font unloading
+    
+        CloseWindow();                // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/text/text_writing_anim.cs

@@ -3,5 +3,65 @@ using static Raylib.Raylib;
 
 public partial class text_writing_anim
 {
-    /*******************************************************************************************
    *
    *   raylib [text] example - Text Writing Animation
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [text] example - text writing anim");
        
        string message = "This sample illustrates a text writing\nanimation effect! Check it out! ;)";
        
        int framesCounter = 0;
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsKeyDown(KEY_SPACE)) framesCounter += 8;
            else framesCounter++;
            
            if (IsKeyPressed(KEY_ENTER)) framesCounter = 0;
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText(SubText(message, 0, framesCounter/10), 210, 160, 20, MAROON);
                
                DrawText("PRESS [ENTER] to RESTART!", 240, 260, 20, LIGHTGRAY);
                DrawText("PRESS [SPACE] to SPEED UP!", 239, 300, 20, LIGHTGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------   
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   raylib [text] example - Text Writing Animation
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [text] example - text writing anim");
+        
+        string message = "This sample illustrates a text writing\nanimation effect! Check it out! ;)";
+        
+        int framesCounter = 0;
+        
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            if (IsKeyDown(KEY_SPACE)) framesCounter += 8;
+            else framesCounter++;
+            
+            if (IsKeyPressed(KEY_ENTER)) framesCounter = 0;
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawText(SubText(message, 0, framesCounter/10), 210, 160, 20, MAROON);
+                
+                DrawText("PRESS [ENTER] to RESTART!", 240, 260, 20, LIGHTGRAY);
+                DrawText("PRESS [SPACE] to SPEED UP!", 239, 300, 20, LIGHTGRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------   
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/textures/textures_image_drawing.cs

@@ -3,5 +3,89 @@ using static Raylib.Raylib;
 
 public partial class textures_image_drawing
 {
-    /*******************************************************************************************
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static 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(ref cat, new Rectangle( 100, 10, 280, 380 ));      // Crop an image piece
        ImageFlipHorizontal(ref cat);                              // Flip cropped image horizontally
        ImageResize(ref 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(ref parrots, cat, new Rectangle( 0, 0, cat.width, cat.height ), new Rectangle( 30, 40, cat.width*1.5f, cat.height*1.5f ));
        ImageCrop(ref parrots, new Rectangle( 0, 50, parrots.width, parrots.height - 100 )); // Crop resulting image
        
        UnloadImage(cat);       // Unload image from RAM
        
        // Load custom font for frawing on image
        Font font = LoadFont("resources/custom_jupiter_crash.png");
        
        // Draw over image using custom font
        ImageDrawTextEx(ref parrots, new Vector2( 300, 230 ), font, "PARROTS ref CAT", font.baseSize, -2, WHITE);
        
        UnloadFont(font); // Unload custom spritefont (already drawn used on image)
    
        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;
    }    
+    /*******************************************************************************************
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static 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(ref cat, new Rectangle( 100, 10, 280, 380 ));      // Crop an image piece
+        ImageFlipHorizontal(ref cat);                              // Flip cropped image horizontally
+        ImageResize(ref 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(ref parrots, cat, new Rectangle( 0, 0, cat.width, cat.height ), new Rectangle( 30, 40, cat.width*1.5f, cat.height*1.5f ));
+        ImageCrop(ref parrots, new Rectangle( 0, 50, parrots.width, parrots.height - 100 )); // Crop resulting image
+        
+        UnloadImage(cat);       // Unload image from RAM
+        
+        // Load custom font for frawing on image
+        Font font = LoadFont("resources/custom_jupiter_crash.png");
+        
+        // Draw over image using custom font
+        ImageDrawTextEx(ref parrots, new Vector2( 300, 230 ), font, "PARROTS ref CAT", font.baseSize, -2, WHITE);
+        
+        UnloadFont(font); // Unload custom spritefont (already drawn used on image)
+    
+        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_generation.cs

@@ -3,5 +3,109 @@ using static Raylib.Raylib;
 
 public partial class textures_image_generation
 {
-    /*******************************************************************************************
    *
    *   raylib [textures] example - Procedural images generation
    *
    *   This example has been created using raylib 1.8 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2O17 Wilhem Barbier (@nounoursheureux)
    *
    ********************************************************************************************/
    
    
    public const int NUM_TEXTURES = 7;
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [textures] example - procedural images generation");
    
        Image verticalGradient = GenImageGradientV(screenWidth, screenHeight, RED, BLUE);
        Image horizontalGradient = GenImageGradientH(screenWidth, screenHeight, RED, BLUE);
        Image radialGradient = GenImageGradientRadial(screenWidth, screenHeight, 0.0f, WHITE, BLACK);
        Image isChecked = GenImageChecked(screenWidth, screenHeight, 32, 32, RED, BLUE);
        Image whiteNoise = GenImageWhiteNoise(screenWidth, screenHeight, 0.5f);
        Image perlinNoise = GenImagePerlinNoise(screenWidth, screenHeight, 50, 50, 4.0f);
        Image cellular = GenImageCellular(screenWidth, screenHeight, 32);
    
        Texture2D[] textures = new Texture2D[NUM_TEXTURES];
        textures[0] = LoadTextureFromImage(verticalGradient);
        textures[1] = LoadTextureFromImage(horizontalGradient);
        textures[2] = LoadTextureFromImage(radialGradient);
        textures[3] = LoadTextureFromImage(isChecked);
        textures[4] = LoadTextureFromImage(whiteNoise);
        textures[5] = LoadTextureFromImage(perlinNoise);
        textures[6] = LoadTextureFromImage(cellular);
        
        // Unload image data (CPU RAM)
        UnloadImage(verticalGradient);
        UnloadImage(horizontalGradient);
        UnloadImage(radialGradient);
        UnloadImage(isChecked);
        UnloadImage(whiteNoise);
        UnloadImage(perlinNoise);
        UnloadImage(cellular);
    
        int currentTexture = 0;
        
        SetTargetFPS(60);
        //---------------------------------------------------------------------------------------
        
        // Main game loop
        while (!WindowShouldClose())
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) || IsKeyPressed(KEY_RIGHT))
            {
                currentTexture = (currentTexture + 1)%NUM_TEXTURES; // Cycle between the textures
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
            
                ClearBackground(RAYWHITE);
                
                DrawTexture(textures[currentTexture], 0, 0, WHITE);
                
                DrawRectangle(30, 400, 325, 30, Fade(SKYBLUE, 0.5f));
                DrawRectangleLines(30, 400, 325, 30, Fade(WHITE, 0.5f));
                DrawText("MOUSE LEFT BUTTON to CYCLE PROCEDURAL TEXTURES", 40, 410, 10, WHITE);
                
                switch(currentTexture)
                {
                    case 0: DrawText("VERTICAL GRADIENT", 560, 10, 20, RAYWHITE); break;
                    case 1: DrawText("HORIZONTAL GRADIENT", 540, 10, 20, RAYWHITE); break;
                    case 2: DrawText("RADIAL GRADIENT", 580, 10, 20, LIGHTGRAY); break;
                    case 3: DrawText("CHECKED", 680, 10, 20, RAYWHITE); break;
                    case 4: DrawText("WHITE NOISE", 640, 10, 20, RED); break;
                    case 5: DrawText("PERLIN NOISE", 630, 10, 20, RAYWHITE); break;
                    case 6: DrawText("CELLULAR", 670, 10, 20, RAYWHITE); break;
                    default: break;
                }
                
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
           
        // Unload textures data (GPU VRAM)
        for (int i = 0; i < NUM_TEXTURES; i++) UnloadTexture(textures[i]);
        
        CloseWindow();                // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
        
        return 0;
    }
        
+    /*******************************************************************************************
+    *
+    *   raylib [textures] example - Procedural images generation
+    *
+    *   This example has been created using raylib 1.8 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2O17 Wilhem Barbier (@nounoursheureux)
+    *
+    ********************************************************************************************/
+    
+    
+    public const int NUM_TEXTURES = 7;
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [textures] example - procedural images generation");
+    
+        Image verticalGradient = GenImageGradientV(screenWidth, screenHeight, RED, BLUE);
+        Image horizontalGradient = GenImageGradientH(screenWidth, screenHeight, RED, BLUE);
+        Image radialGradient = GenImageGradientRadial(screenWidth, screenHeight, 0.0f, WHITE, BLACK);
+        Image isChecked = GenImageChecked(screenWidth, screenHeight, 32, 32, RED, BLUE);
+        Image whiteNoise = GenImageWhiteNoise(screenWidth, screenHeight, 0.5f);
+        Image perlinNoise = GenImagePerlinNoise(screenWidth, screenHeight, 50, 50, 4.0f);
+        Image cellular = GenImageCellular(screenWidth, screenHeight, 32);
+    
+        Texture2D[] textures = new Texture2D[NUM_TEXTURES];
+        textures[0] = LoadTextureFromImage(verticalGradient);
+        textures[1] = LoadTextureFromImage(horizontalGradient);
+        textures[2] = LoadTextureFromImage(radialGradient);
+        textures[3] = LoadTextureFromImage(isChecked);
+        textures[4] = LoadTextureFromImage(whiteNoise);
+        textures[5] = LoadTextureFromImage(perlinNoise);
+        textures[6] = LoadTextureFromImage(cellular);
+        
+        // Unload image data (CPU RAM)
+        UnloadImage(verticalGradient);
+        UnloadImage(horizontalGradient);
+        UnloadImage(radialGradient);
+        UnloadImage(isChecked);
+        UnloadImage(whiteNoise);
+        UnloadImage(perlinNoise);
+        UnloadImage(cellular);
+    
+        int currentTexture = 0;
+        
+        SetTargetFPS(60);
+        //---------------------------------------------------------------------------------------
+        
+        // Main game loop
+        while (!WindowShouldClose())
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON) || IsKeyPressed(KEY_RIGHT))
+            {
+                currentTexture = (currentTexture + 1)%NUM_TEXTURES; // Cycle between the textures
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+            
+                ClearBackground(RAYWHITE);
+                
+                DrawTexture(textures[currentTexture], 0, 0, WHITE);
+                
+                DrawRectangle(30, 400, 325, 30, Fade(SKYBLUE, 0.5f));
+                DrawRectangleLines(30, 400, 325, 30, Fade(WHITE, 0.5f));
+                DrawText("MOUSE LEFT BUTTON to CYCLE PROCEDURAL TEXTURES", 40, 410, 10, WHITE);
+                
+                switch(currentTexture)
+                {
+                    case 0: DrawText("VERTICAL GRADIENT", 560, 10, 20, RAYWHITE); break;
+                    case 1: DrawText("HORIZONTAL GRADIENT", 540, 10, 20, RAYWHITE); break;
+                    case 2: DrawText("RADIAL GRADIENT", 580, 10, 20, LIGHTGRAY); break;
+                    case 3: DrawText("CHECKED", 680, 10, 20, RAYWHITE); break;
+                    case 4: DrawText("WHITE NOISE", 640, 10, 20, RED); break;
+                    case 5: DrawText("PERLIN NOISE", 630, 10, 20, RAYWHITE); break;
+                    case 6: DrawText("CELLULAR", 670, 10, 20, RAYWHITE); break;
+                    default: break;
+                }
+                
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+           
+        // Unload textures data (GPU VRAM)
+        for (int i = 0; i < NUM_TEXTURES; i++) UnloadTexture(textures[i]);
+        
+        CloseWindow();                // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+        
+        return 0;
+    }
+        
 }

Examples/textures/textures_image_loading.cs

@@ -3,5 +3,66 @@ using static Raylib.Raylib;
 
 public partial class textures_image_loading
 {
-    /*******************************************************************************************
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static 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;
    }    
+    /*******************************************************************************************
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static 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_text.cs

@@ -3,5 +3,86 @@ using static Raylib.Raylib;
 
 public partial class textures_image_text
 {
-    /*******************************************************************************************
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static 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, 95, null);
        
        Image parrots = LoadImage("resources/parrots.png"); // Load image in CPU memory (RAM)
    
        // Draw over image using custom font
        ImageDrawTextEx(ref parrots, new Vector2( 20, 20 ), font, "[Parrots font drawing]", font.baseSize, 0, WHITE);
    
        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 = new Vector2( screenWidth/2 - texture.width/2, 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]", new Vector2( position.x + 20, 
                               position.y + 20 + 280 ), font.baseSize, 0, 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;
    }    
+    /*******************************************************************************************
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static 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, 95, null);
+        
+        Image parrots = LoadImage("resources/parrots.png"); // Load image in CPU memory (RAM)
+    
+        // Draw over image using custom font
+        ImageDrawTextEx(ref parrots, new Vector2( 20, 20 ), font, "[Parrots font drawing]", font.baseSize, 0, WHITE);
+    
+        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 = new Vector2( screenWidth/2 - texture.width/2, 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]", new Vector2( position.x + 20, 
+                               position.y + 20 + 280 ), font.baseSize, 0, 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;
+    }    
 }

Examples/textures/textures_logo_raylib.cs

@@ -3,5 +3,60 @@ using static Raylib.Raylib;
 
 public partial class textures_logo_raylib
 {
-    /*******************************************************************************************
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static 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;
    }    
+    /*******************************************************************************************
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static 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_blending.cs

@@ -4,10 +4,139 @@ using static Raylib.BlendMode;
 
 public partial class textures_particles_blending
 {
-    /*******************************************************************************************
    *
    *   raylib example - particles blending
    *
    *   This example has been created using raylib 1.7 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public const int MAX_PARTICLES = 200;
+    /*******************************************************************************************
-
+    *
-    // Particle structure with basic data
+    *   raylib example - particles blending
-    struct Particle
    {
+    *
-        public Vector2 position;
        public Color color;
        public float alpha;
        public float size;
        public float rotation;
        public bool active;        // NOTE: Use it to activate/deactive particle
+    *   This example has been created using raylib 1.7 (www.raylib.com)
-    }
    
    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [textures] example - particles blending");
        
        // Particles pool, reuse them!
        Particle[] mouseTail = new Particle[MAX_PARTICLES]; 
        
        // Initialize particles
        for (int i = 0; i < MAX_PARTICLES; i++)
        {
            mouseTail[i].position = new Vector2( 0, 0 );
            mouseTail[i].color = new 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 = (int)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 == (int)BLEND_ALPHA) blending = (int)BLEND_ADDITIVE;
                else blending = (int)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, new Rectangle( 0, 0, smoke.width, smoke.height ), 
                                                               new Rectangle( mouseTail[i].position.x, mouseTail[i].position.y, smoke.width*mouseTail[i].size, smoke.height*mouseTail[i].size ),
                                                               new 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 == (int)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;
    }    
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    public const int MAX_PARTICLES = 200;
+
+    // Particle structure with basic data
+    struct Particle
+    {
+        public Vector2 position;
+        public Color color;
+        public float alpha;
+        public float size;
+        public float rotation;
+        public bool active;        // NOTE: Use it to activate/deactive particle
+    }
+    
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [textures] example - particles blending");
+        
+        // Particles pool, reuse them!
+        Particle[] mouseTail = new Particle[MAX_PARTICLES]; 
+        
+        // Initialize particles
+        for (int i = 0; i < MAX_PARTICLES; i++)
+        {
+            mouseTail[i].position = new Vector2( 0, 0 );
+            mouseTail[i].color = new 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 = (int)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 == (int)BLEND_ALPHA) blending = (int)BLEND_ADDITIVE;
+                else blending = (int)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, new Rectangle( 0, 0, smoke.width, smoke.height ), 
+                                                               new Rectangle( mouseTail[i].position.x, mouseTail[i].position.y, smoke.width*mouseTail[i].size, smoke.height*mouseTail[i].size ),
+                                                               new 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 == (int)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.cs

@@ -4,5 +4,98 @@ using static Raylib.PixelFormat;
 
 public partial class textures_raw_data
 {
-    /*******************************************************************************************
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    
    public static 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 fudesumiRaw = LoadImageRaw("resources/fudesumi.raw", 384, 512, (int)UNCOMPRESSED_R8G8B8A8, 0);
        Texture2D fudesumi = LoadTextureFromImage(fudesumiRaw);   // Upload CPU (RAM) image to GPU (VRAM)
        UnloadImage(fudesumiRaw);                              // Unload CPU (RAM) image data
        
        // Generate a isChecked 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));
        Color[] pixels = new Color[width*height];
        
        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] = ORANGE;
                else pixels[y*height + x] = GOLD;
            }
        }
        
        // Load pixels data into an image structure and create texture
        Image isCheckedIm = LoadImageEx(pixels, width, height);
        Texture2D isChecked = LoadTextureFromImage(isCheckedIm);
        UnloadImage(isCheckedIm);     // 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(isChecked, screenWidth/2 - isChecked.width/2, screenHeight/2 - isChecked.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("(c) Fudesumi sprite by Eiden Marsal", 310, screenHeight - 20, 10, BROWN);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadTexture(fudesumi);    // Texture unloading
        UnloadTexture(isChecked);     // Texture unloading
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    public static 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 fudesumiRaw = LoadImageRaw("resources/fudesumi.raw", 384, 512, (int)UNCOMPRESSED_R8G8B8A8, 0);
+        Texture2D fudesumi = LoadTextureFromImage(fudesumiRaw);   // Upload CPU (RAM) image to GPU (VRAM)
+        UnloadImage(fudesumiRaw);                              // Unload CPU (RAM) image data
+        
+        // Generate a isChecked 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));
+        Color[] pixels = new Color[width*height];
+        
+        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] = ORANGE;
+                else pixels[y*height + x] = GOLD;
+            }
+        }
+        
+        // Load pixels data into an image structure and create texture
+        Image isCheckedIm = LoadImageEx(pixels, width, height);
+        Texture2D isChecked = LoadTextureFromImage(isCheckedIm);
+        UnloadImage(isCheckedIm);     // 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(isChecked, screenWidth/2 - isChecked.width/2, screenHeight/2 - isChecked.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("(c) Fudesumi sprite by Eiden Marsal", 310, screenHeight - 20, 10, BROWN);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadTexture(fudesumi);    // Texture unloading
+        UnloadTexture(isChecked);     // Texture unloading
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/textures/textures_rectangle.cs

@@ -3,5 +3,102 @@ using static Raylib.Raylib;
 
 public partial class textures_rectangle
 {
-    /*******************************************************************************************
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public const int MAX_FRAME_SPEED = 15;
    public const int MIN_FRAME_SPEED = 1;
    
    public static 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 scarfy = LoadTexture("resources/scarfy.png");        // Texture loading
    
        Vector2 position = new Vector2( 350.0f, 280.0f );
        Rectangle frameRec = new Rectangle( 0.0f, 0.0f, (float)scarfy.width/6, (float)scarfy.height );
        int currentFrame = 0;
        
        int framesCounter = 0;
        int framesSpeed = 8;           // Number of spritesheet frames shown by second
        
        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
            //----------------------------------------------------------------------------------
            framesCounter++;
            
            if (framesCounter >= (60/framesSpeed))
            {
                framesCounter = 0;
                currentFrame++;
                
                if (currentFrame > 5) currentFrame = 0;
                
                frameRec.x = (float)currentFrame*(float)scarfy.width/6;
            }
            
            if (IsKeyPressed(KEY_RIGHT)) framesSpeed++;
            else if (IsKeyPressed(KEY_LEFT)) framesSpeed--;
            
            if (framesSpeed > MAX_FRAME_SPEED) framesSpeed = MAX_FRAME_SPEED;
            else if (framesSpeed < MIN_FRAME_SPEED) framesSpeed = MIN_FRAME_SPEED;
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawTexture(scarfy, 15, 40, WHITE);
                DrawRectangleLines(15, 40, scarfy.width, scarfy.height, LIME);
                DrawRectangleLines(15 + (int)frameRec.x, 40 + (int)frameRec.y, (int)frameRec.width, (int)frameRec.height, RED);
                
                DrawText("FRAME SPEED: ", 165, 210, 10, DARKGRAY);
                DrawText(FormatText("%02i FPS", framesSpeed), 575, 210, 10, DARKGRAY);
                DrawText("PRESS RIGHT/LEFT KEYS to CHANGE SPEED!", 290, 240, 10, DARKGRAY);
                
                for (int i = 0; i < MAX_FRAME_SPEED; i++)
                {
                    if (i < framesSpeed) DrawRectangle(250 + 21*i, 205, 20, 20, RED);
                    DrawRectangleLines(250 + 21*i, 205, 20, 20, MAROON);
                }
                
                DrawTextureRec(scarfy, frameRec, position, WHITE);  // Draw part of the texture
    
                DrawText("(c) Scarfy sprite by Eiden Marsal", screenWidth - 200, screenHeight - 20, 10, GRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadTexture(scarfy);       // Texture unloading
    
        CloseWindow();                // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public const int MAX_FRAME_SPEED = 15;
+    public const int MIN_FRAME_SPEED = 1;
+    
+    public static 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 scarfy = LoadTexture("resources/scarfy.png");        // Texture loading
+    
+        Vector2 position = new Vector2( 350.0f, 280.0f );
+        Rectangle frameRec = new Rectangle( 0.0f, 0.0f, (float)scarfy.width/6, (float)scarfy.height );
+        int currentFrame = 0;
+        
+        int framesCounter = 0;
+        int framesSpeed = 8;           // Number of spritesheet frames shown by second
+        
+        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
+            //----------------------------------------------------------------------------------
+            framesCounter++;
+            
+            if (framesCounter >= (60/framesSpeed))
+            {
+                framesCounter = 0;
+                currentFrame++;
+                
+                if (currentFrame > 5) currentFrame = 0;
+                
+                frameRec.x = (float)currentFrame*(float)scarfy.width/6;
+            }
+            
+            if (IsKeyPressed(KEY_RIGHT)) framesSpeed++;
+            else if (IsKeyPressed(KEY_LEFT)) framesSpeed--;
+            
+            if (framesSpeed > MAX_FRAME_SPEED) framesSpeed = MAX_FRAME_SPEED;
+            else if (framesSpeed < MIN_FRAME_SPEED) framesSpeed = MIN_FRAME_SPEED;
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                DrawTexture(scarfy, 15, 40, WHITE);
+                DrawRectangleLines(15, 40, scarfy.width, scarfy.height, LIME);
+                DrawRectangleLines(15 + (int)frameRec.x, 40 + (int)frameRec.y, (int)frameRec.width, (int)frameRec.height, RED);
+                
+                DrawText("FRAME SPEED: ", 165, 210, 10, DARKGRAY);
+                DrawText(FormatText("%02i FPS", framesSpeed), 575, 210, 10, DARKGRAY);
+                DrawText("PRESS RIGHT/LEFT KEYS to CHANGE SPEED!", 290, 240, 10, DARKGRAY);
+                
+                for (int i = 0; i < MAX_FRAME_SPEED; i++)
+                {
+                    if (i < framesSpeed) DrawRectangle(250 + 21*i, 205, 20, 20, RED);
+                    DrawRectangleLines(250 + 21*i, 205, 20, 20, MAROON);
+                }
+                
+                DrawTextureRec(scarfy, frameRec, position, WHITE);  // Draw part of the texture
+    
+                DrawText("(c) Scarfy sprite by Eiden Marsal", screenWidth - 200, screenHeight - 20, 10, GRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadTexture(scarfy);       // Texture unloading
+    
+        CloseWindow();                // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/textures/textures_srcrec_dstrec.cs

@@ -3,5 +3,84 @@ using static Raylib.Raylib;
 
 public partial class textures_srcrec_dstrec
 {
-    /*******************************************************************************************
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static 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 scarfy = LoadTexture("resources/scarfy.png");        // Texture loading
    
        int frameWidth = scarfy.width/6;
        int frameHeight = scarfy.height;
        
        // NOTE: Source rectangle (part of the texture to use for drawing)
        Rectangle sourceRec = new Rectangle( 0, 0, frameWidth, frameHeight );
    
        // NOTE: Destination rectangle (screen rectangle where drawing part of texture)
        Rectangle destRec = new Rectangle( 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 = new Vector2( 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(scarfy, sourceRec, destRec, origin, rotation, WHITE);
    
                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);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadTexture(scarfy);        // Texture unloading
    
        CloseWindow();                // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+    /*******************************************************************************************
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static 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 scarfy = LoadTexture("resources/scarfy.png");        // Texture loading
+    
+        int frameWidth = scarfy.width/6;
+        int frameHeight = scarfy.height;
+        
+        // NOTE: Source rectangle (part of the texture to use for drawing)
+        Rectangle sourceRec = new Rectangle( 0, 0, frameWidth, frameHeight );
+    
+        // NOTE: Destination rectangle (screen rectangle where drawing part of texture)
+        Rectangle destRec = new Rectangle( 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 = new Vector2( 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(scarfy, sourceRec, destRec, origin, rotation, WHITE);
+    
+                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);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadTexture(scarfy);        // Texture unloading
+    
+        CloseWindow();                // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }    
 }

Examples/textures/textures_to_image.cs

@@ -3,5 +3,71 @@ using static Raylib.Raylib;
 
 public partial class textures_to_image
 {
-    /*******************************************************************************************
    *
    *   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)
    *
    ********************************************************************************************/
    
    
    public static 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;
    }    
+    /*******************************************************************************************
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    public static 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;
+    }    
 }