Changing examples to use makefile

- Testing a modified version of the makefile from raylib Instead of multiple project files for examples.
- Fixed readme example

Examples/core/core_3d_camera_first_person.cs

@@ -0,0 +1,7 @@
+using Raylib;
+using static Raylib.Raylib;
+
+public partial class Examples
+{
+    /*******************************************************************************************
    *
    *   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 #define MAX_COLUMNS 20

    public static void 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)
        Camera camera = { 0 };
        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 = 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, 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(&camera);                  // Update camera
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawPlane(new Vector3( 0.0f, 0.0f, 0.0f }, (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

@@ -0,0 +1,7 @@
+using Raylib;
+using static Raylib.Raylib;
+
+public partial class Examples
+{
+    /*******************************************************************************************
    *
    *   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 void 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 );; // Camera position
        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );;      // Camera looking at point
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );;          // Camera up vector (rotation towards target)
        camera.fovy = 45.0f;                                // Camera field-of-view Y
        camera.type = CAMERA_PERSPECTIVE;                   // Camera mode type
        
        Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
        
        SetCameraMode(camera, 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(&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

@@ -0,0 +1,7 @@
+using Raylib;
+using static Raylib.Raylib;
+
+public partial class Examples
+{
+    /*******************************************************************************************
    *
    *   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 void 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 );;  // Camera position
        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );;      // Camera looking at point
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );;          // Camera up vector (rotation towards target)
        camera.fovy = 45.0f;                                // Camera field-of-view Y
        camera.type = CAMERA_PERSPECTIVE;                   // Camera mode type
    
        Vector3 cubePosition = { 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

@@ -0,0 +1,7 @@
+using Raylib;
+using static Raylib.Raylib;
+
+public partial class Examples
+{
+    /*******************************************************************************************
    *
    *   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 void 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
        Camera camera;
        camera.position = new Vector3( 10.0f, 10.0f, 10.0f );; // Camera position
        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );;      // Camera looking at point
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );;          // Camera up vector (rotation towards target)
        camera.fovy = 45.0f;                                // Camera field-of-view Y
        camera.type = CAMERA_PERSPECTIVE;                   // Camera mode type
    
        Vector3 cubePosition = { 0.0f, 1.0f, 0.0f };
        Vector3 cubeSize = { 2.0f, 2.0f, 2.0f };
    
        Ray ray = {0.0f, 0.0f, 0.0f};        // Picking line ray
    
        bool collision = false;
    
        SetCameraMode(camera, 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(&camera);          // Update camera
    
            if (IsMouseButtonPressed((int)Mouse.LEFT_BUTTON))
            {
                ray = GetMouseRay(GetMousePosition(), camera);
    
                // Check collision between ray and box
                collision = CheckCollisionRayBox(ray,
                            new BoundingBox((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, 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

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

public partial class Examples
{
    /*******************************************************************************************
    *
    *   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 void 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
        //--------------------------------------------------------------------------------------
    
    }    
}

Examples/core/core_basic_window_web.cs

@@ -0,0 +1,7 @@
+using Raylib;
+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();
        //----------------------------------------------------------------------------------
    }    
+}

Examples/core/core_color_select.cs

@@ -0,0 +1,7 @@
+using Raylib;
+using static Raylib.Raylib;
+
+public partial class Examples
+{
+    /*******************************************************************************************
    *
    *   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 void Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - color selection (collision detection)");
    
        Color colors[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[21] = { false };  // 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((int)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(colorsRecs[i].x, colorsRecs[i].y, 100, 10, RAYWHITE);        // Square top rectangle
                        DrawRectangle(colorsRecs[i].x, colorsRecs[i].y, 10, 100, RAYWHITE);        // Square left rectangle
                        DrawRectangle(colorsRecs[i].x + 90, colorsRecs[i].y, 10, 100, RAYWHITE);   // Square right rectangle
                        DrawRectangle(colorsRecs[i].x, 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

@@ -0,0 +1,7 @@
+using Raylib;
+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;
    }
        
+}

Examples/core/core_drop_files.cs

@@ -0,0 +1,7 @@
+using Raylib;
+using static Raylib.Raylib;
+
+public partial class Examples
+{
+    /*******************************************************************************************
    *
    *   raylib [core] example - Windows drop files
    *
    *   This example only works on platforms that support drag & 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 void Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - drop files");
        
        int count = 0;
        char **droppedFiles = { 0 };
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsFileDropped())
            {
                droppedFiles = GetDroppedFiles(&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_keys.cs

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

public partial class Examples
{
    /*******************************************************************************************
    *
    *   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 void 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((int)Key.RIGHT)) ballPosition.x += 2.0f;
            if (IsKeyDown((int)Key.LEFT)) ballPosition.x -= 2.0f;
            if (IsKeyDown((int)Key.UP)) ballPosition.y -= 2.0f;
            if (IsKeyDown((int)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
        //--------------------------------------------------------------------------------------

    }    
}

Examples/core/core_input_mouse.cs

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

public partial class Examples
{
    /*******************************************************************************************
    *
    *   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 void 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((int)Mouse.LEFT_BUTTON)) ballColor = MAROON;
            else if (IsMouseButtonPressed((int)Mouse.MIDDLE_BUTTON)) ballColor = LIME;
            else if (IsMouseButtonPressed((int)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
        //--------------------------------------------------------------------------------------

    }    
}

Examples/core/core_mouse_wheel.cs

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

public partial class Examples
{
    /*******************************************************************************************
    *
    *   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 void 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);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
    }    
}

Examples/core/core_random_values.cs

@@ -0,0 +1,7 @@
+using Raylib;
+using static Raylib.Raylib;
+
+public partial class Examples
+{
+    /*******************************************************************************************
    *
    *   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 void 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);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+}

Examples/core/core_storage_values.cs

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

Examples/core/core_vr_simulator.cs

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

Examples/core/core_world_screen.cs

@@ -0,0 +1,7 @@
+using Raylib;
+using static Raylib.Raylib;
+
+public partial class Examples
+{
+    /*******************************************************************************************
    *
    *   raylib [core] example - World to screen
    *
    *   This example has been created using raylib 1.3 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    public static void 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
        Camera camera = { 0 };
        camera.position = new Vector3( 10.0f, 10.0f, 10.0f );;
        camera.target = new Vector3( 0.0f, 0.0f, 0.0f );;
        camera.up = new Vector3( 0.0f, 1.0f, 0.0f );;
        camera.fovy = 45.0f;
        camera.type = CAMERA_PERSPECTIVE;
    
        Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
        
        Vector2 cubeScreenPosition;
        
        SetCameraMode(camera, 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(&camera);          // Update camera
            
            // Calculate cube screen space position (with a little offset to be in top)
            cubeScreenPosition = GetWorldToScreen(new Vector3(cubePosition.x, cubePosition.y + 2.5f, cubePosition.z);, camera);
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
                    DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
    
                    DrawGrid(10, 1.0f);
    
                EndMode3D();
                
                DrawText("Enemy: 100 / 100", cubeScreenPosition.x - MeasureText("Enemy: 100 / 100", 20) / 2, cubeScreenPosition.y, 20, BLACK);
                DrawText("Text is always on top of the cube", (screenWidth - MeasureText("Text is always on top of the cube", 20)) / 2, 25, 20, GRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }    
+}