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;
+    }    
 }