Setting up examples project

- Dedicated project for raylib examples using Bindings as a class library.

Bindings/Bindings.csproj

@@ -74,6 +74,9 @@
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>true</Prefer32Bit>
   </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject />
+  </PropertyGroup>
   <ItemGroup>
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="System" />
@@ -82,12 +85,12 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="core_basic_window.cs" />
-    <Compile Include="DrawControl.cs">
+    <Compile Include="Program.cs" />
+    <Compile Include="RayForm.cs">
       <SubType>Form</SubType>
     </Compile>
     <Compile Include="Easings.cs" />
     <Compile Include="Physac.cs" />
-    <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Raygui.cs" />
     <Compile Include="Raylib.cs" />
@@ -98,8 +101,8 @@
     <None Include="App.config" />
   </ItemGroup>
   <ItemGroup>
-    <EmbeddedResource Include="DrawControl.resx">
+    <EmbeddedResource Include="RayForm.resx">
-      <DependentUpon>DrawControl.cs</DependentUpon>
+      <DependentUpon>RayForm.cs</DependentUpon>
     </EmbeddedResource>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

Examples/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
+    </startup>
+</configuration>

Examples/Examples.csproj

@@ -0,0 +1,87 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{2B152086-45AD-4DD2-A9A5-32AEC4FE608C}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <RootNamespace>Examples</RootNamespace>
+    <AssemblyName>Examples</AssemblyName>
+    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <Deterministic>true</Deterministic>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>true</Prefer32Bit>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Examples\core\core_basic_window.cs" />
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Bindings\Bindings.csproj">
+      <Project>{a2b3bbc8-3d48-46dd-b3cf-263f554e4474}</Project>
+      <Name>Bindings</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="Examples\core\core_basic_window.png" />
+    <Content Include="Examples\core\resources\ps3.png" />
+    <Content Include="Examples\core\resources\xbox.png" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

Examples/Examples/audio/audio_module_playing.cs

@@ -0,0 +1,155 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [audio] example - Module playing (streaming)
+    *
+    *   NOTE: This example requires OpenAL Soft library installed
+    *
+    *   This example has been created using raylib 1.5 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2016 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    private const int MAX_CIRCLES = 64;
+    
+    typedef struct {
+        Vector2 position;
+        float radius;
+        float alpha;
+        float speed;
+        Color color;
+    } CircleWave;
+    
+    public static int audio_module_playing()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        SetConfigFlags(FLAG_MSAA_4X_HINT);      // NOTE: Try to enable MSAA 4X
+        
+        InitWindow(screenWidth, screenHeight, "raylib [audio] example - module playing (streaming)");
+    
+        InitAudioDevice();              // Initialize audio device
+        
+        Color colors[14] = { ORANGE, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK,
+                             YELLOW, GREEN, SKYBLUE, PURPLE, BEIGE };
+        
+        // Creates ome circles for visual effect
+        CircleWave circles[MAX_CIRCLES];
+        
+        for (int i = MAX_CIRCLES - 1; i >= 0; i--)
+        {
+            circles[i].alpha = 0.0f;
+            circles[i].radius = GetRandomValue(10, 40);
+            circles[i].position.x = GetRandomValue(circles[i].radius, screenWidth - circles[i].radius);
+            circles[i].position.y = GetRandomValue(circles[i].radius, screenHeight - circles[i].radius);
+            circles[i].speed = (float)GetRandomValue(1, 100)/20000.0f;
+            circles[i].color = colors[GetRandomValue(0, 13)];
+        }
+    
+        Music xm = LoadMusicStream("resources/mini1111.xm");
+        
+        PlayMusicStream(xm);
+    
+        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(xm);        // Update music buffer with new stream data
+            
+            // Restart music playing (stop and play)
+            if (IsKeyPressed(KEY_SPACE)) 
+            {
+                StopMusicStream(xm);
+                PlayMusicStream(xm);
+            }
+            
+            // Pause/Resume music playing 
+            if (IsKeyPressed(KEY_P))
+            {
+                pause = !pause;
+                
+                if (pause) PauseMusicStream(xm);
+                else ResumeMusicStream(xm);
+            }
+            
+            // Get timePlayed scaled to bar dimensions
+            timePlayed = GetMusicTimePlayed(xm)/GetMusicTimeLength(xm)*(screenWidth - 40);
+            
+            // Color circles animation
+            for (int i = MAX_CIRCLES - 1; (i >= 0) && !pause; i--)
+            {
+                circles[i].alpha += circles[i].speed;
+                circles[i].radius += circles[i].speed*10.0f;
+                
+                if (circles[i].alpha > 1.0f) circles[i].speed *= -1;
+                
+                if (circles[i].alpha <= 0.0f)
+                {
+                    circles[i].alpha = 0.0f;
+                    circles[i].radius = GetRandomValue(10, 40);
+                    circles[i].position.x = GetRandomValue(circles[i].radius, screenWidth - circles[i].radius);
+                    circles[i].position.y = GetRandomValue(circles[i].radius, screenHeight - circles[i].radius);
+                    circles[i].color = colors[GetRandomValue(0, 13)];
+                    circles[i].speed = (float)GetRandomValue(1, 100)/20000.0f;
+                }
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+                
+                for (int i = MAX_CIRCLES - 1; i >= 0; i--)
+                {
+                    DrawCircleV(circles[i].position, circles[i].radius, Fade(circles[i].color, circles[i].alpha));
+                }
+                
+                // Draw time bar
+                DrawRectangle(20, screenHeight - 20 - 12, screenWidth - 40, 12, LIGHTGRAY);
+                DrawRectangle(20, screenHeight - 20 - 12, (int)timePlayed, 12, MAROON);
+                DrawRectangleLines(20, screenHeight - 20 - 12, screenWidth - 40, 12, GRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadMusicStream(xm);          // Unload music stream buffers from RAM
+        
+        CloseAudioDevice();     // Close audio device (music streaming is automatically stopped)
+    
+        CloseWindow();          // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+
+}

Examples/Examples/audio/audio_music_stream.cs

@@ -0,0 +1,107 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [audio] example - Music 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 audio_music_stream()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [audio] example - music playing (streaming)");
+    
+        InitAudioDevice();              // Initialize audio device
+    
+        Music 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/Examples/audio/audio_raw_stream.cs

@@ -0,0 +1,128 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    #include <stdlib.h>         // Required for: malloc(), free()
+    #include <math.h>           // Required for: sinf()
+    
+    private const int MAX_SAMPLES = 22050;
+    private const int MAX_SAMPLES_PER_UPDATE = 4096;
+    
+    public static int audio_raw_stream()
+    {
+        // 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 = (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)(sinf(((2*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 = { 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/Examples/audio/audio_sound_loading.cs

@@ -0,0 +1,81 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   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 audio_sound_loading()
+    {
+        // 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/Examples/core/core_2d_camera.cs

@@ -0,0 +1,153 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - 2d camera
+    *
+    *   This example has been created using raylib 1.5 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2016 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    private const int MAX_BUILDINGS = 100;
+    
+    public static int core_2d_camera()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera");
+        
+        Rectangle player = { 400, 280, 40, 40 };
+        Rectangle buildings[MAX_BUILDINGS];
+        Color buildColors[MAX_BUILDINGS];
+        
+        int spacing = 0;
+        
+        for (int i = 0; i < MAX_BUILDINGS; i++)
+        {
+            buildings[i].width = GetRandomValue(50, 200);
+            buildings[i].height = GetRandomValue(100, 800);
+            buildings[i].y = screenHeight - 130 - buildings[i].height;
+            buildings[i].x = -6000 + spacing;
+    
+            spacing += buildings[i].width;
+            
+            buildColors[i] = (Color){ GetRandomValue(200, 240), GetRandomValue(200, 240), GetRandomValue(200, 250), 255 };
+        }
+        
+        Camera2D camera;
+        
+        camera.target = (Vector2){ player.x + 20, player.y + 20 };
+        camera.offset = (Vector2){ 0, 0 };
+        camera.rotation = 0.0f;
+        camera.zoom = 1.0f;
+        
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            if (IsKeyDown(KEY_RIGHT))
+            {
+                player.x += 2;              // Player movement
+                camera.offset.x -= 2;       // Camera displacement with player movement
+            }
+            else if (IsKeyDown(KEY_LEFT))
+            {
+                player.x -= 2;              // Player movement
+                camera.offset.x += 2;       // Camera displacement with player movement
+            }
+            
+            // Camera target follows player
+            camera.target = (Vector2){ player.x + 20, player.y + 20 };
+            
+            // Camera rotation controls
+            if (IsKeyDown(KEY_A)) camera.rotation--;
+            else if (IsKeyDown(KEY_S)) camera.rotation++;
+            
+            // Limit camera rotation to 80 degrees (-40 to 40)
+            if (camera.rotation > 40) camera.rotation = 40;         
+            else if (camera.rotation < -40) camera.rotation = -40;
+            
+            // Camera zoom controls
+            camera.zoom += ((float)GetMouseWheelMove()*0.05f);
+            
+            if (camera.zoom > 3.0f) camera.zoom = 3.0f;
+            else if (camera.zoom < 0.1f) camera.zoom = 0.1f;
+            
+            // Camera reset (zoom and rotation)
+            if (IsKeyPressed(KEY_R)) 
+            {
+                camera.zoom = 1.0f;
+                camera.rotation = 0.0f;
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+            
+                ClearBackground(RAYWHITE);
+            
+                BeginMode2D(camera);
+    
+                    DrawRectangle(-6000, 320, 13000, 8000, DARKGRAY);
+                    
+                    for (int i = 0; i < MAX_BUILDINGS; i++) DrawRectangleRec(buildings[i], buildColors[i]);
+                    
+                    DrawRectangleRec(player, RED);
+                    
+                    DrawRectangle(camera.target.x, -500, 1, screenHeight*4, GREEN);
+                    DrawRectangle(-500, camera.target.y, screenWidth*4, 1, GREEN);
+                    
+                EndMode2D();
+                
+                DrawText("SCREEN AREA", 640, 10, 20, RED);
+                
+                DrawRectangle(0, 0, screenWidth, 5, RED);
+                DrawRectangle(0, 5, 5, screenHeight - 10, RED);
+                DrawRectangle(screenWidth - 5, 5, 5, screenHeight - 10, RED);
+                DrawRectangle(0, screenHeight - 5, screenWidth, 5, RED);
+                
+                DrawRectangle( 10, 10, 250, 113, Fade(SKYBLUE, 0.5f));
+                DrawRectangleLines( 10, 10, 250, 113, BLUE);
+                
+                DrawText("Free 2d camera controls:", 20, 20, 10, BLACK);
+                DrawText("- Right/Left to move Offset", 40, 40, 10, DARKGRAY);
+                DrawText("- Mouse Wheel to Zoom in-out", 40, 60, 10, DARKGRAY);
+                DrawText("- A / S to Rotate", 40, 80, 10, DARKGRAY);
+                DrawText("- R to reset Zoom and Rotation", 40, 100, 10, DARKGRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------   
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+
+}

Examples/Examples/core/core_3d_camera_first_person.cs

@@ -0,0 +1,111 @@
+
+
+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)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    private const int MAX_COLUMNS = 20;
+    
+    public static int core_3d_camera_first_person()
+    {
+        // 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 = (Vector3){ 4.0f, 2.0f, 4.0f };
+        camera.target = (Vector3){ 0.0f, 1.8f, 0.0f };
+        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
+        camera.fovy = 60.0f;
+        camera.type = CAMERA_PERSPECTIVE;
+    
+        // Generates some random columns
+        float heights[MAX_COLUMNS];
+        Vector3 positions[MAX_COLUMNS];
+        Color colors[MAX_COLUMNS];
+        
+        for (int i = 0; i < MAX_COLUMNS; i++)
+        {
+            heights[i] = (float)GetRandomValue(1, 12);
+            positions[i] = (Vector3){ GetRandomValue(-15, 15), heights[i]/2, GetRandomValue(-15, 15) };
+            colors[i] = (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((Vector3){ 0.0f, 0.0f, 0.0f }, (Vector2){ 32.0f, 32.0f }, LIGHTGRAY); // Draw ground
+                    DrawCube((Vector3){ -16.0f, 2.5f, 0.0f }, 1.0f, 5.0f, 32.0f, BLUE);     // Draw a blue wall
+                    DrawCube((Vector3){ 16.0f, 2.5f, 0.0f }, 1.0f, 5.0f, 32.0f, LIME);      // Draw a green wall
+                    DrawCube((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/Examples/core/core_3d_camera_free.cs

@@ -0,0 +1,97 @@
+
+
+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 int core_3d_camera_free()
+    {
+        // 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 = (Vector3){ 10.0f, 10.0f, 10.0f }; // Camera position
+        camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
+        camera.up = (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 = (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/Examples/core/core_3d_mode.cs

@@ -0,0 +1,87 @@
+
+
+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 int core_3d_mode()
+    {
+        // 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 = (Vector3){ 0.0f, 10.0f, 10.0f };  // Camera position
+        camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
+        camera.up = (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/Examples/core/core_3d_picking.cs

@@ -0,0 +1,118 @@
+
+
+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 int core_3d_picking()
+    {
+        // 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 = (Vector3){ 10.0f, 10.0f, 10.0f }; // Camera position
+        camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
+        camera.up = (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(MOUSE_LEFT_BUTTON))
+            {
+                ray = GetMouseRay(GetMousePosition(), camera);
+    
+                // Check collision between ray and box
+                collision = CheckCollisionRayBox(ray,
+                            (BoundingBox){(Vector3){ cubePosition.x - cubeSize.x/2, cubePosition.y - cubeSize.y/2, cubePosition.z - cubeSize.z/2 },
+                                          (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/Examples/core/core_basic_window.cs

@@ -0,0 +1,67 @@
+
+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 int core_basic_window()
+    {
+        // 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/Examples/core/core_basic_window_web.cs

@@ -0,0 +1,99 @@
+
+
+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
+    
+    #if defined(PLATFORM_WEB)
+        #include <emscripten/emscripten.h>
+    #endif
+    
+    //----------------------------------------------------------------------------------
+    // 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 int core_basic_window_web()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
+    
+    #if defined(PLATFORM_WEB)
+        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();
+        }
+    #endif
+    
+        // 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/Examples/core/core_color_select.cs

@@ -0,0 +1,108 @@
+
+
+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 int core_color_select()
+    {
+        // 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[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(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/Examples/core/core_drop_files.cs

@@ -0,0 +1,90 @@
+
+
+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 int core_drop_files()
+    {
+        // 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/Examples/core/core_gestures_detection.cs

@@ -0,0 +1,129 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [core] example - Gestures Detection
+    *
+    *   This example has been created using raylib 1.4 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2016 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    #include <string.h>
+    
+    private const int MAX_GESTURE_STRINGS = 20;
+    
+    public static int core_gestures_detection()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+        
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - gestures detection");
+        
+        Vector2 touchPosition = { 0, 0 };
+        Rectangle touchArea = { 220, 10, screenWidth - 230, screenHeight - 20 };
+        
+        int gesturesCount = 0;
+        char gestureStrings[MAX_GESTURE_STRINGS][32];
+    
+        int currentGesture = GESTURE_NONE;
+        int lastGesture = GESTURE_NONE;
+        
+        //SetGesturesEnabled(0b0000000000001001);   // Enable only some gestures to be detected
+        
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            lastGesture = currentGesture;
+            currentGesture = GetGestureDetected();
+            touchPosition = GetTouchPosition(0);
+    
+            if (CheckCollisionPointRec(touchPosition, touchArea) && (currentGesture != GESTURE_NONE))
+            {
+                if (currentGesture != lastGesture)
+                {
+                    // Store gesture string
+                    switch (currentGesture)
+                    {
+                        case GESTURE_TAP: strcpy(gestureStrings[gesturesCount], "GESTURE TAP"); break;
+                        case GESTURE_DOUBLETAP: strcpy(gestureStrings[gesturesCount], "GESTURE DOUBLETAP"); break;
+                        case GESTURE_HOLD: strcpy(gestureStrings[gesturesCount], "GESTURE HOLD"); break;
+                        case GESTURE_DRAG: strcpy(gestureStrings[gesturesCount], "GESTURE DRAG"); break;
+                        case GESTURE_SWIPE_RIGHT: strcpy(gestureStrings[gesturesCount], "GESTURE SWIPE RIGHT"); break;
+                        case GESTURE_SWIPE_LEFT: strcpy(gestureStrings[gesturesCount], "GESTURE SWIPE LEFT"); break;
+                        case GESTURE_SWIPE_UP: strcpy(gestureStrings[gesturesCount], "GESTURE SWIPE UP"); break;
+                        case GESTURE_SWIPE_DOWN: strcpy(gestureStrings[gesturesCount], "GESTURE SWIPE DOWN"); break;
+                        case GESTURE_PINCH_IN: strcpy(gestureStrings[gesturesCount], "GESTURE PINCH IN"); break;
+                        case GESTURE_PINCH_OUT: strcpy(gestureStrings[gesturesCount], "GESTURE PINCH OUT"); break;
+                        default: break;
+                    }
+                    
+                    gesturesCount++;
+                    
+                    // Reset gestures strings
+                    if (gesturesCount >= MAX_GESTURE_STRINGS)
+                    {
+                        for (int i = 0; i < MAX_GESTURE_STRINGS; i++) strcpy(gestureStrings[i], "\0");
+                        
+                        gesturesCount = 0;
+                    }
+                }
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+                
+                DrawRectangleRec(touchArea, GRAY);
+                DrawRectangle(225, 15, screenWidth - 240, screenHeight - 30, RAYWHITE);
+                
+                DrawText("GESTURES TEST AREA", screenWidth - 270, screenHeight - 40, 20, Fade(GRAY, 0.5f));
+                
+                for (int i = 0; i < gesturesCount; i++)
+                {
+                    if (i%2 == 0) DrawRectangle(10, 30 + 20*i, 200, 20, Fade(LIGHTGRAY, 0.5f));
+                    else DrawRectangle(10, 30 + 20*i, 200, 20, Fade(LIGHTGRAY, 0.3f));
+                    
+                    if (i < gesturesCount - 1) DrawText(gestureStrings[i], 35, 36 + 20*i, 10, DARKGRAY);
+                    else DrawText(gestureStrings[i], 35, 36 + 20*i, 10, MAROON);
+                }
+                
+                DrawRectangleLines(10, 29, 200, screenHeight - 50, GRAY);
+                DrawText("DETECTED GESTURES", 50, 15, 10, GRAY);
+                
+                if (currentGesture != GESTURE_NONE) DrawCircleV(touchPosition, 30, MAROON);
+                
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------   
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    }
+
+}

Examples/Examples/core/core_input_gamepad.cs

@@ -0,0 +1,208 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   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)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    // NOTE: Gamepad name ID depends on drivers and OS
+    #if defined(PLATFORM_RPI)
+        private const int XBOX360_NAME_ID = 360; pad"
+        private const int PS3_NAME_ID = 3; Controller"
+    #else
+        private const int XBOX360_NAME_ID = 360; Controller"
+        private const int PS3_NAME_ID = 3; Controller"
+    #endif
+    
+    public static int core_input_gamepad()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        SetConfigFlags(FLAG_MSAA_4X_HINT);  // Set MSAA 4X hint before windows creation  
+        
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - gamepad input");
+        
+        Texture2D texPs3Pad = LoadTexture("resources/ps3.png");
+        Texture2D texXboxPad = LoadTexture("resources/xbox.png");
+    
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            // ...
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+                
+                if (IsGamepadAvailable(GAMEPAD_PLAYER1))
+                {
+                    DrawText(FormatText("GP1: %s", GetGamepadName(GAMEPAD_PLAYER1)), 10, 10, 10, BLACK);
+    
+                    if (IsGamepadName(GAMEPAD_PLAYER1, XBOX360_NAME_ID))
+                    {
+                        DrawTexture(texXboxPad, 0, 0, DARKGRAY);
+                        
+                        // Draw buttons: xbox home
+                        if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_HOME)) DrawCircle(394, 89, 19, RED);
+    
+                        // Draw buttons: basic
+                        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);
+                        if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_Y)) DrawCircle(536, 115, 15, GOLD);
+                        
+                        // Draw buttons: d-pad
+                        DrawRectangle(317, 202, 19, 71, BLACK);
+                        DrawRectangle(293, 228, 69, 19, BLACK);
+                        if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_UP)) DrawRectangle(317, 202, 19, 26, RED);
+                        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);
+                        if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_XBOX_BUTTON_RIGHT)) DrawRectangle(292 + 44, 228, 26, 19, RED);
+                        
+                        // Draw buttons: left-right back
+                        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);
+    
+                        // Draw axis: left joystick
+                        DrawCircle(259, 152, 39, BLACK);
+                        DrawCircle(259, 152, 34, LIGHTGRAY);
+                        DrawCircle(259 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LEFT_X)*20), 
+                                   152 - (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LEFT_Y)*20), 25, BLACK);
+                        
+                        // Draw axis: right joystick
+                        DrawCircle(461, 237, 38, BLACK);
+                        DrawCircle(461, 237, 33, LIGHTGRAY);
+                        DrawCircle(461 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RIGHT_X)*20), 
+                                   237 - (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RIGHT_Y)*20), 25, BLACK);
+    
+                        // Draw axis: left-right triggers
+                        DrawRectangle(170, 30, 15, 70, GRAY);
+                        DrawRectangle(604, 30, 15, 70, GRAY);              
+                        DrawRectangle(170, 30, 15, (((1.0f + GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LT))/2.0f)*70), RED);
+                        DrawRectangle(604, 30, 15, (((1.0f + GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RT))/2.0f)*70), RED);
+                        
+                        //DrawText(FormatText("Xbox axis LT: %02.02f", GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_LT)), 10, 40, 10, BLACK);
+                        //DrawText(FormatText("Xbox axis RT: %02.02f", GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_XBOX_AXIS_RT)), 10, 60, 10, BLACK);
+                    }
+                    else if (IsGamepadName(GAMEPAD_PLAYER1, PS3_NAME_ID))
+                    {
+                        DrawTexture(texPs3Pad, 0, 0, DARKGRAY);
+    
+                        // Draw buttons: ps
+                        if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_PS)) DrawCircle(396, 222, 13, RED);
+                        
+                        // Draw buttons: basic
+                        if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_SELECT)) DrawRectangle(328, 170, 32, 13, RED);
+                        if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_START)) DrawTriangle((Vector2){ 436, 168 }, (Vector2){ 436, 185 }, (Vector2){ 464, 177 }, RED);
+                        if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_TRIANGLE)) DrawCircle(557, 144, 13, LIME);
+                        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);
+                        if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_SQUARE)) DrawCircle(527, 173, 13, PINK);
+    
+                        // Draw buttons: d-pad
+                        DrawRectangle(225, 132, 24, 84, BLACK);
+                        DrawRectangle(195, 161, 84, 25, BLACK);
+                        if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_UP)) DrawRectangle(225, 132, 24, 29, RED);
+                        if (IsGamepadButtonDown(GAMEPAD_PLAYER1, GAMEPAD_PS3_BUTTON_DOWN)) DrawRectangle(225, 132 + 54, 24, 30, RED);
+                        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);
+                        
+                        // Draw buttons: left-right back buttons
+                        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 axis: left joystick
+                        DrawCircle(319, 255, 35, BLACK);
+                        DrawCircle(319, 255, 31, LIGHTGRAY);
+                        DrawCircle(319 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_LEFT_X)*20), 
+                                   255 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_LEFT_Y)*20), 25, BLACK);
+                        
+                        // Draw axis: right joystick
+                        DrawCircle(475, 255, 35, BLACK);
+                        DrawCircle(475, 255, 31, LIGHTGRAY);
+                        DrawCircle(475 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_RIGHT_X)*20), 
+                                   255 + (GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_RIGHT_Y)*20), 25, BLACK);
+    
+                        // Draw axis: left-right triggers
+                        DrawRectangle(169, 48, 15, 70, GRAY);
+                        DrawRectangle(611, 48, 15, 70, GRAY);              
+                        DrawRectangle(169, 48, 15, (((1.0f - GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_L2))/2.0f)*70), RED);
+                        DrawRectangle(611, 48, 15, (((1.0f - GetGamepadAxisMovement(GAMEPAD_PLAYER1, GAMEPAD_PS3_AXIS_R2))/2.0f)*70), RED);
+                    }
+                    else
+                    {
+                        DrawText("- GENERIC GAMEPAD -", 280, 180, 20, GRAY);
+                        
+                        // TODO: Draw generic gamepad
+                    }
+                    
+                    DrawText(FormatText("DETECTED AXIS [%i]:", GetGamepadAxisCount(GAMEPAD_PLAYER1)), 10, 50, 10, MAROON); 
+                    
+                    for (int i = 0; i < GetGamepadAxisCount(GAMEPAD_PLAYER1); i++)
+                    {
+                        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/Examples/core/core_input_keys.cs

@@ -0,0 +1,73 @@
+
+
+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 int core_input_keys()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - keyboard input");
+    
+        Vector2 ballPosition = { (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/Examples/core/core_input_mouse.cs

@@ -0,0 +1,75 @@
+
+
+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 int core_input_mouse()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input");
+    
+        Vector2 ballPosition = { -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/Examples/core/core_mouse_wheel.cs

@@ -0,0 +1,72 @@
+
+
+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 int core_mouse_wheel()
+    {
+        // 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
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+
+}

Examples/Examples/core/core_random_values.cs

@@ -0,0 +1,79 @@
+
+
+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 int core_random_values()
+    {
+        // 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/Examples/core/core_storage_values.cs

@@ -0,0 +1,99 @@
+
+
+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 int core_storage_values()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - storage save/load values");
+        
+        int score = 0;
+        int hiscore = 0;
+        
+        int framesCounter = 0;
+        
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            if (IsKeyPressed(KEY_R))
+            {
+                score = GetRandomValue(1000, 2000);
+                hiscore = GetRandomValue(2000, 4000);
+            }
+            
+            if (IsKeyPressed(KEY_ENTER))
+            {
+                StorageSaveValue(STORAGE_SCORE, score);
+                StorageSaveValue(STORAGE_HISCORE, hiscore);
+            }
+            else if (IsKeyPressed(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/Examples/core/core_vr_simulator.cs

@@ -0,0 +1,100 @@
+
+
+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 int core_vr_simulator()
+    {
+        // 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 = (Vector3){ 5.0f, 2.0f, 5.0f };    // Camera position
+        camera.target = (Vector3){ 0.0f, 2.0f, 0.0f };      // Camera looking at point
+        camera.up = (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(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/Examples/core/core_world_screen.cs

@@ -0,0 +1,93 @@
+
+
+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 int core_world_screen()
+    {
+        // 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 = (Vector3){ 10.0f, 10.0f, 10.0f };
+        camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
+        camera.up = (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((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;
+    }
+
+}

Examples/Examples/models/models_billboard.cs

@@ -0,0 +1,90 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Drawing billboards
+    *
+    *   This example has been created using raylib 1.3 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    public static int models_billboard()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - drawing billboards");
+    
+        // Define the camera to look into our 3d world
+        Camera camera = { 0 };
+        camera.position = (Vector3){ 5.0f, 4.0f, 5.0f };
+        camera.target = (Vector3){ 0.0f, 2.0f, 0.0f };
+        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
+        camera.fovy = 45.0f;
+        camera.type = CAMERA_PERSPECTIVE;
+        
+    
+        Texture2D bill = LoadTexture("resources/billboard.png");     // Our texture billboard
+        Vector3 billPosition = { 0.0f, 2.0f, 0.0f };                 // Position where draw billboard
+        
+        SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
+    
+        SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())            // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            UpdateCamera(&camera);              // Update camera
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+                
+                    DrawBillboard(camera, bill, billPosition, 2.0f, WHITE);
+                    
+                    DrawGrid(10, 1.0f);        // Draw a grid
+    
+                EndMode3D();
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadTexture(bill);        // Unload texture
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+
+}

Examples/Examples/models/models_box_collisions.cs

@@ -0,0 +1,135 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Detect basic 3d collisions (box vs sphere vs box)
+    *
+    *   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 models_box_collisions()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - box collisions");
+    
+        // Define the camera to look into our 3d world
+        Camera camera = {{ 0.0f, 10.0f, 10.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
+        
+        Vector3 playerPosition = { 0.0f, 1.0f, 2.0f };
+        Vector3 playerSize = { 1.0f, 2.0f, 1.0f };
+        Color playerColor = GREEN;
+        
+        Vector3 enemyBoxPos = { -4.0f, 1.0f, 0.0f };
+        Vector3 enemyBoxSize = { 2.0f, 2.0f, 2.0f };
+        
+        Vector3 enemySpherePos = { 4.0f, 0.0f, 0.0f };
+        float enemySphereSize = 1.5f;
+        
+        bool collision = 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
+            //----------------------------------------------------------------------------------
+            
+            // Move player
+            if (IsKeyDown(KEY_RIGHT)) playerPosition.x += 0.2f;
+            else if (IsKeyDown(KEY_LEFT)) playerPosition.x -= 0.2f;
+            else if (IsKeyDown(KEY_DOWN)) playerPosition.z += 0.2f;
+            else if (IsKeyDown(KEY_UP)) playerPosition.z -= 0.2f;
+            
+            collision = false;
+            
+            // Check collisions player vs enemy-box
+            if (CheckCollisionBoxes(
+                (BoundingBox){(Vector3){ playerPosition.x - playerSize.x/2, 
+                                         playerPosition.y - playerSize.y/2, 
+                                         playerPosition.z - playerSize.z/2 }, 
+                              (Vector3){ playerPosition.x + playerSize.x/2,
+                                         playerPosition.y + playerSize.y/2, 
+                                         playerPosition.z + playerSize.z/2 }},
+                (BoundingBox){(Vector3){ enemyBoxPos.x - enemyBoxSize.x/2, 
+                                         enemyBoxPos.y - enemyBoxSize.y/2, 
+                                         enemyBoxPos.z - enemyBoxSize.z/2 }, 
+                              (Vector3){ enemyBoxPos.x + enemyBoxSize.x/2,
+                                         enemyBoxPos.y + enemyBoxSize.y/2, 
+                                         enemyBoxPos.z + enemyBoxSize.z/2 }})) collision = true;
+            
+            // Check collisions player vs enemy-sphere
+            if (CheckCollisionBoxSphere(
+                (BoundingBox){(Vector3){ playerPosition.x - playerSize.x/2, 
+                                         playerPosition.y - playerSize.y/2, 
+                                         playerPosition.z - playerSize.z/2 }, 
+                              (Vector3){ playerPosition.x + playerSize.x/2,
+                                         playerPosition.y + playerSize.y/2, 
+                                         playerPosition.z + playerSize.z/2 }}, 
+                enemySpherePos, enemySphereSize)) collision = true;
+            
+            if (collision) playerColor = RED;
+            else playerColor = GREEN;
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    // Draw enemy-box
+                    DrawCube(enemyBoxPos, enemyBoxSize.x, enemyBoxSize.y, enemyBoxSize.z, GRAY);
+                    DrawCubeWires(enemyBoxPos, enemyBoxSize.x, enemyBoxSize.y, enemyBoxSize.z, DARKGRAY);
+                    
+                    // Draw enemy-sphere
+                    DrawSphere(enemySpherePos, enemySphereSize, GRAY);
+                    DrawSphereWires(enemySpherePos, enemySphereSize, 16, 16, DARKGRAY);
+                    
+                    // Draw player
+                    DrawCubeV(playerPosition, playerSize, playerColor);
+    
+                    DrawGrid(10, 1.0f);        // Draw a grid
+    
+                EndMode3D();
+                
+                DrawText("Move player with cursors to collide", 220, 40, 20, GRAY);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+
+}

Examples/Examples/models/models_cubicmap.cs

@@ -0,0 +1,102 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Cubicmap loading and drawing
+    *
+    *   This example has been created using raylib 1.8 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    public static int models_cubicmap()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - cubesmap loading and drawing");
+    
+        // Define the camera to look into our 3d world
+        Camera camera = {{ 16.0f, 14.0f, 16.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
+    
+        Image image = LoadImage("resources/cubicmap.png");      // Load cubicmap image (RAM)
+        Texture2D cubicmap = LoadTextureFromImage(image);       // Convert image to texture to display (VRAM)
+        
+        Mesh mesh = GenMeshCubicmap(image, (Vector3){ 1.0f, 1.0f, 1.0f });
+        Model model = LoadModelFromMesh(mesh);
+        
+        // NOTE: By default each cube is mapped to one part of texture atlas
+        Texture2D texture = LoadTexture("resources/cubicmap_atlas.png");    // Load map texture
+        model.material.maps[MAP_DIFFUSE].texture = texture;                 // Set map diffuse texture
+        
+        Vector3 mapPosition = { -16.0f, 0.0f, -8.0f };          // Set model position
+    
+        UnloadImage(image);     // Unload cubesmap image from RAM, already uploaded to VRAM
+        
+        SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
+    
+        SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())            // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            UpdateCamera(&camera);              // Update camera
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawModel(model, mapPosition, 1.0f, WHITE);
+    
+                EndMode3D();
+                
+                DrawTextureEx(cubicmap, (Vector2){ screenWidth - cubicmap.width*4 - 20, 20 }, 0.0f, 4.0f, WHITE);
+                DrawRectangleLines(screenWidth - cubicmap.width*4 - 20, 20, cubicmap.width*4, cubicmap.height*4, GREEN);
+                
+                DrawText("cubicmap image used to", 658, 90, 10, GRAY);
+                DrawText("generate map 3d model", 658, 104, 10, GRAY);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadTexture(cubicmap);    // Unload cubicmap texture
+        UnloadTexture(texture);     // Unload map texture
+        UnloadModel(model);         // Unload map model
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+    
+
+}

Examples/Examples/models/models_geometric_shapes.cs

@@ -0,0 +1,94 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Draw some basic geometric shapes (cube, sphere, cylinder...)
+    *
+    *   This example has been created using raylib 1.0 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    public static int models_geometric_shapes()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
+    
+        // Define the camera to look into our 3d world
+        Camera camera = { 0 };
+        camera.position = (Vector3){ 0.0f, 10.0f, 10.0f };
+        camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
+        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
+        camera.fovy = 45.0f;
+        camera.type = CAMERA_PERSPECTIVE;
+    
+        SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            // TODO: Update your variables here
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawCube((Vector3){-4.0f, 0.0f, 2.0f}, 2.0f, 5.0f, 2.0f, RED);
+                    DrawCubeWires((Vector3){-4.0f, 0.0f, 2.0f}, 2.0f, 5.0f, 2.0f, GOLD);
+                    DrawCubeWires((Vector3){-4.0f, 0.0f, -2.0f}, 3.0f, 6.0f, 2.0f, MAROON);
+    
+                    DrawSphere((Vector3){-1.0f, 0.0f, -2.0f}, 1.0f, GREEN);
+                    DrawSphereWires((Vector3){1.0f, 0.0f, 2.0f}, 2.0f, 16, 16, LIME);
+    
+                    DrawCylinder((Vector3){4.0f, 0.0f, -2.0f}, 1.0f, 2.0f, 3.0f, 4, SKYBLUE);
+                    DrawCylinderWires((Vector3){4.0f, 0.0f, -2.0f}, 1.0f, 2.0f, 3.0f, 4, DARKBLUE);
+                    DrawCylinderWires((Vector3){4.5f, -1.0f, 2.0f}, 1.0f, 1.0f, 2.0f, 6, BROWN);
+    
+                    DrawCylinder((Vector3){1.0f, 0.0f, -4.0f}, 0.0f, 1.5f, 3.0f, 8, GOLD);
+                    DrawCylinderWires((Vector3){1.0f, 0.0f, -4.0f}, 0.0f, 1.5f, 3.0f, 8, PINK);
+    
+                    DrawGrid(10, 1.0f);        // Draw a grid
+    
+                EndMode3D();
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+
+}

Examples/Examples/models/models_heightmap.cs

@@ -0,0 +1,96 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Heightmap loading and drawing
+    *
+    *   This example has been created using raylib 1.8 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    public static int models_heightmap()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - heightmap loading and drawing");
+    
+        // Define our custom camera to look into our 3d world
+        Camera camera = {{ 18.0f, 16.0f, 18.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
+    
+        Image image = LoadImage("resources/heightmap.png");             // Load heightmap image (RAM)
+        Texture2D texture = LoadTextureFromImage(image);                // Convert image to texture (VRAM)
+        
+        Mesh mesh = GenMeshHeightmap(image, (Vector3){ 16, 8, 16 });    // Generate heightmap mesh (RAM and VRAM)
+        Model model = LoadModelFromMesh(mesh);                          // Load model from generated mesh
+    
+        model.material.maps[MAP_DIFFUSE].texture = texture;             // Set map diffuse texture
+        Vector3 mapPosition = { -8.0f, 0.0f, -8.0f };                   // Define model position
+    
+        UnloadImage(image);                     // Unload heightmap image from RAM, already uploaded to VRAM
+        
+        SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
+    
+        SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())            // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            UpdateCamera(&camera);              // Update camera
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawModel(model, mapPosition, 1.0f, RED);
+    
+                    DrawGrid(20, 1.0f);
+    
+                EndMode3D();
+                
+                DrawTexture(texture, screenWidth - texture.width - 20, 20, WHITE);
+                DrawRectangleLines(screenWidth - texture.width - 20, 20, texture.width, texture.height, GREEN);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadTexture(texture);     // Unload texture
+        UnloadModel(model);         // Unload model
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+
+}

Examples/Examples/models/models_material_pbr.cs

@@ -0,0 +1,211 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - PBR material
+    *
+    *   This example has been created using raylib 1.8 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    #include "raymath.h"
+    
+    #define RLIGHTS_IMPLEMENTATION
+    #include "rlights.h"
+    
+    private const int CUBEMAP_SIZE = 512;        // Cubemap texture size
+    private const int IRRADIANCE_SIZE = 32;        // Irradiance texture size
+    private const int PREFILTERED_SIZE = 256;        // Prefiltered HDR environment texture size
+    private const int BRDF_SIZE = 512;        // BRDF LUT texture size
+    
+    // PBR material loading
+    static Material LoadMaterialPBR(Color albedo, float metalness, float roughness);
+    
+    public static int models_material_pbr()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        SetConfigFlags(FLAG_MSAA_4X_HINT);  // Enable Multi Sampling Anti Aliasing 4x (if available)
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - pbr material");
+    
+        // Define the camera to look into our 3d world
+        Camera camera = {{ 4.0f, 4.0f, 4.0f }, { 0.0f, 0.5f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
+    
+        // Load model and PBR material
+        Model model = LoadModel("resources/pbr/trooper.obj");
+        MeshTangents(&model.mesh);
+        model.material = LoadMaterialPBR((Color){ 255, 255, 255, 255 }, 1.0f, 1.0f);
+    
+        // Define lights attributes
+        // NOTE: Shader is passed to every light on creation to define shader bindings internally
+        Light lights[MAX_LIGHTS] = { 
+            CreateLight(LIGHT_POINT, (Vector3){ LIGHT_DISTANCE, LIGHT_HEIGHT, 0.0f }, (Vector3){ 0.0f, 0.0f, 0.0f }, (Color){ 255, 0, 0, 255 }, model.material.shader),
+            CreateLight(LIGHT_POINT, (Vector3){ 0.0f, LIGHT_HEIGHT, LIGHT_DISTANCE }, (Vector3){ 0.0f, 0.0f, 0.0f }, (Color){ 0, 255, 0, 255 }, model.material.shader),
+            CreateLight(LIGHT_POINT, (Vector3){ -LIGHT_DISTANCE, LIGHT_HEIGHT, 0.0f }, (Vector3){ 0.0f, 0.0f, 0.0f }, (Color){ 0, 0, 255, 255 }, model.material.shader),
+            CreateLight(LIGHT_DIRECTIONAL, (Vector3){ 0.0f, LIGHT_HEIGHT*2.0f, -LIGHT_DISTANCE }, (Vector3){ 0.0f, 0.0f, 0.0f }, (Color){ 255, 0, 255, 255 }, model.material.shader) 
+        };
+        
+        SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
+    
+        SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())            // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            UpdateCamera(&camera);              // Update camera
+            
+            // Send to material PBR shader camera view position
+            float cameraPos[3] = { camera.position.x, camera.position.y, camera.position.z };
+            SetShaderValue(model.material.shader, model.material.shader.locs[LOC_VECTOR_VIEW], cameraPos, 3);
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawModel(model, Vector3Zero(), 1.0f, WHITE);
+                    
+                    DrawGrid(10, 1.0f);
+    
+                EndMode3D();
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadModel(model);         // Unload skybox model
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+    
+    // Load PBR material (Supports: ALBEDO, NORMAL, METALNESS, ROUGHNESS, AO, EMMISIVE, HEIGHT maps)
+    // NOTE: PBR shader is loaded inside this function
+    static Material LoadMaterialPBR(Color albedo, float metalness, float roughness)
+    {
+        Material mat = { 0 };       // NOTE: All maps textures are set to { 0 }
+        
+        #define     PATH_PBR_VS     "resources/shaders/pbr.vs"      // Path to physically based rendering vertex shader
+        #define     PATH_PBR_FS     "resources/shaders/pbr.fs"      // Path to physically based rendering fragment shader
+       
+        mat.shader = LoadShader(PATH_PBR_VS, PATH_PBR_FS);
+        
+        // Get required locations points for PBR material
+        // NOTE: Those location names must be available and used in the shader code
+        mat.shader.locs[LOC_MAP_ALBEDO] = GetShaderLocation(mat.shader, "albedo.sampler");
+        mat.shader.locs[LOC_MAP_METALNESS] = GetShaderLocation(mat.shader, "metalness.sampler");
+        mat.shader.locs[LOC_MAP_NORMAL] = GetShaderLocation(mat.shader, "normals.sampler");
+        mat.shader.locs[LOC_MAP_ROUGHNESS] = GetShaderLocation(mat.shader, "roughness.sampler");
+        mat.shader.locs[LOC_MAP_OCCLUSION] = GetShaderLocation(mat.shader, "occlusion.sampler");
+        //mat.shader.locs[LOC_MAP_EMISSION] = GetShaderLocation(mat.shader, "emission.sampler");
+        //mat.shader.locs[LOC_MAP_HEIGHT] = GetShaderLocation(mat.shader, "height.sampler");
+        mat.shader.locs[LOC_MAP_IRRADIANCE] = GetShaderLocation(mat.shader, "irradianceMap");
+        mat.shader.locs[LOC_MAP_PREFILTER] = GetShaderLocation(mat.shader, "prefilterMap");
+        mat.shader.locs[LOC_MAP_BRDF] = GetShaderLocation(mat.shader, "brdfLUT");
+    
+        // Set view matrix location
+        mat.shader.locs[LOC_MATRIX_MODEL] = GetShaderLocation(mat.shader, "matModel");
+        mat.shader.locs[LOC_MATRIX_VIEW] = GetShaderLocation(mat.shader, "view");
+        mat.shader.locs[LOC_VECTOR_VIEW] = GetShaderLocation(mat.shader, "viewPos");
+        
+        // Set PBR standard maps
+        mat.maps[MAP_ALBEDO].texture = LoadTexture("resources/pbr/trooper_albedo.png");
+        mat.maps[MAP_NORMAL].texture = LoadTexture("resources/pbr/trooper_normals.png");
+        mat.maps[MAP_METALNESS].texture = LoadTexture("resources/pbr/trooper_metalness.png");
+        mat.maps[MAP_ROUGHNESS].texture = LoadTexture("resources/pbr/trooper_roughness.png");
+        mat.maps[MAP_OCCLUSION].texture = LoadTexture("resources/pbr/trooper_ao.png");
+        
+        // Set environment maps
+        #define     PATH_CUBEMAP_VS         "resources/shaders/cubemap.vs"          // Path to equirectangular to cubemap vertex shader
+        #define     PATH_CUBEMAP_FS         "resources/shaders/cubemap.fs"          // Path to equirectangular to cubemap fragment shader
+        #define     PATH_SKYBOX_VS          "resources/shaders/skybox.vs"           // Path to skybox vertex shader
+        #define     PATH_IRRADIANCE_FS      "resources/shaders/irradiance.fs"       // Path to irradiance (GI) calculation fragment shader
+        #define     PATH_PREFILTER_FS       "resources/shaders/prefilter.fs"        // Path to reflection prefilter calculation fragment shader
+        #define     PATH_BRDF_VS            "resources/shaders/brdf.vs"     // Path to bidirectional reflectance distribution function vertex shader 
+        #define     PATH_BRDF_FS            "resources/shaders/brdf.fs"     // Path to bidirectional reflectance distribution function fragment shader
+        
+        Shader shdrCubemap = LoadShader(PATH_CUBEMAP_VS, PATH_CUBEMAP_FS);
+        Shader shdrIrradiance = LoadShader(PATH_SKYBOX_VS, PATH_IRRADIANCE_FS);
+        Shader shdrPrefilter = LoadShader(PATH_SKYBOX_VS, PATH_PREFILTER_FS);
+        Shader shdrBRDF = LoadShader(PATH_BRDF_VS, PATH_BRDF_FS);
+        
+        // Setup required shader locations
+        SetShaderValuei(shdrCubemap, GetShaderLocation(shdrCubemap, "equirectangularMap"), (int[1]){ 0 }, 1);
+        SetShaderValuei(shdrIrradiance, GetShaderLocation(shdrIrradiance, "environmentMap"), (int[1]){ 0 }, 1);
+        SetShaderValuei(shdrPrefilter, GetShaderLocation(shdrPrefilter, "environmentMap"), (int[1]){ 0 }, 1);
+    
+        Texture2D texHDR = LoadTexture("resources/dresden_square.hdr");
+        Texture2D cubemap = GenTextureCubemap(shdrCubemap, texHDR, CUBEMAP_SIZE);
+        mat.maps[MAP_IRRADIANCE].texture = GenTextureIrradiance(shdrIrradiance, cubemap, IRRADIANCE_SIZE);
+        mat.maps[MAP_PREFILTER].texture = GenTexturePrefilter(shdrPrefilter, cubemap, PREFILTERED_SIZE);
+        mat.maps[MAP_BRDF].texture = GenTextureBRDF(shdrBRDF, cubemap, BRDF_SIZE);
+        UnloadTexture(cubemap);
+        UnloadTexture(texHDR);
+        
+        // Unload already used shaders (to create specific textures)
+        UnloadShader(shdrCubemap);
+        UnloadShader(shdrIrradiance);
+        UnloadShader(shdrPrefilter);
+        UnloadShader(shdrBRDF);
+        
+        // Set textures filtering for better quality
+        SetTextureFilter(mat.maps[MAP_ALBEDO].texture, FILTER_BILINEAR);
+        SetTextureFilter(mat.maps[MAP_NORMAL].texture, FILTER_BILINEAR);
+        SetTextureFilter(mat.maps[MAP_METALNESS].texture, FILTER_BILINEAR);
+        SetTextureFilter(mat.maps[MAP_ROUGHNESS].texture, FILTER_BILINEAR);
+        SetTextureFilter(mat.maps[MAP_OCCLUSION].texture, FILTER_BILINEAR);
+        
+        // Enable sample usage in shader for assigned textures
+        SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "albedo.useSampler"), (int[1]){ 1 }, 1);
+        SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "normals.useSampler"), (int[1]){ 1 }, 1);
+        SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "metalness.useSampler"), (int[1]){ 1 }, 1);
+        SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "roughness.useSampler"), (int[1]){ 1 }, 1);
+        SetShaderValuei(mat.shader, GetShaderLocation(mat.shader, "occlusion.useSampler"), (int[1]){ 1 }, 1);
+        
+        int renderModeLoc = GetShaderLocation(mat.shader, "renderMode");
+        SetShaderValuei(mat.shader, renderModeLoc, (int[1]){ 0 }, 1);
+    
+        // Set up material properties color
+        mat.maps[MAP_ALBEDO].color = albedo;
+        mat.maps[MAP_NORMAL].color = (Color){ 128, 128, 255, 255 };
+        mat.maps[MAP_METALNESS].value = metalness;
+        mat.maps[MAP_ROUGHNESS].value = roughness;
+        mat.maps[MAP_OCCLUSION].value = 1.0f;
+        mat.maps[MAP_EMISSION].value = 0.5f;
+        mat.maps[MAP_HEIGHT].value = 0.5f;
+    
+        return mat;
+    }
+    
+
+}

Examples/Examples/models/models_mesh_generation.cs

@@ -0,0 +1,127 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib example - procedural mesh generation
+    *
+    *   This example has been created using raylib 1.8 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2017 Ramon Santamaria (Ray San)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    private const int NUM_MODELS = 7;      // We generate 7 parametric 3d shapes
+    
+    public static int models_mesh_generation()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - mesh generation");
+        
+        // We generate a checked image for texturing
+        Image checked = GenImageChecked(2, 2, 1, 1, RED, GREEN);
+        Texture2D texture = LoadTextureFromImage(checked);
+        UnloadImage(checked);
+        
+        Model models[NUM_MODELS];
+        
+        models[0] = LoadModelFromMesh(GenMeshPlane(2, 2, 5, 5));
+        models[1] = LoadModelFromMesh(GenMeshCube(2.0f, 1.0f, 2.0f));
+        models[2] = LoadModelFromMesh(GenMeshSphere(2, 32, 32));
+        models[3] = LoadModelFromMesh(GenMeshHemiSphere(2, 16, 16));
+        models[4] = LoadModelFromMesh(GenMeshCylinder(1, 2, 16));
+        models[5] = LoadModelFromMesh(GenMeshTorus(0.25f, 4.0f, 16, 32));
+        models[6] = LoadModelFromMesh(GenMeshKnot(1.0f, 2.0f, 16, 128));
+        
+        // Set checked texture as default diffuse component for all models material
+        for (int i = 0; i < NUM_MODELS; i++) models[i].material.maps[MAP_DIFFUSE].texture = texture;
+    
+        // Define the camera to look into our 3d world
+        Camera camera = {{ 5.0f, 5.0f, 5.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
+    
+        // Model drawing position
+        Vector3 position = { 0.0f, 0.0f, 0.0f };
+        
+        int currentModel = 0;
+        
+        SetCameraMode(camera, CAMERA_ORBITAL);  // Set a orbital camera mode
+    
+        SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            UpdateCamera(&camera);      // Update internal camera and our camera
+            
+            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+            {
+                currentModel = (currentModel + 1)%NUM_MODELS; // Cycle between the textures
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawModel(models[currentModel], position, 1.0f, WHITE);
+    
+                    DrawGrid(10, 1.0);
+    
+                EndMode3D();
+                
+                DrawRectangle(30, 400, 310, 30, Fade(SKYBLUE, 0.5f));
+                DrawRectangleLines(30, 400, 310, 30, Fade(DARKBLUE, 0.5f));
+                DrawText("MOUSE LEFT BUTTON to CYCLE PROCEDURAL MODELS", 40, 410, 10, BLUE);
+                
+                switch(currentModel)
+                {
+                    case 0: DrawText("PLANE", 680, 10, 20, DARKBLUE); break;
+                    case 1: DrawText("CUBE", 680, 10, 20, DARKBLUE); break;
+                    case 2: DrawText("SPHERE", 680, 10, 20, DARKBLUE); break;
+                    case 3: DrawText("HEMISPHERE", 640, 10, 20, DARKBLUE); break;
+                    case 4: DrawText("CYLINDER", 680, 10, 20, DARKBLUE); break;
+                    case 5: DrawText("TORUS", 680, 10, 20, DARKBLUE); break;
+                    case 6: DrawText("KNOT", 680, 10, 20, DARKBLUE); break;
+                    default: break;
+                }
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        
+        // Unload models data (GPU VRAM)
+        for (int i = 0; i < NUM_MODELS; i++) UnloadModel(models[i]);
+        
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+
+}

Examples/Examples/models/models_mesh_picking.cs

@@ -0,0 +1,215 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Mesh picking in 3d mode, ground plane, triangle, mesh
+    *
+    *   This example has been created using raylib 1.7 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+    *   Example contributed by Joel Davis (@joeld42)
+    *
+    ********************************************************************************************/
+    
+    
+    #include "raymath.h"
+    
+    private const int FLT_MAX = 3;.40282347E+38F     // Maximum value of a float, defined in <float.h>
+    
+    public static int models_mesh_picking()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - mesh picking");
+    
+        // Define the camera to look into our 3d world
+        Camera camera;
+        camera.position = (Vector3){ 20.0f, 20.0f, 20.0f };  // Camera position
+        camera.target = (Vector3){ 0.0f, 8.0f, 0.0f };      // Camera looking at point
+        camera.up = (Vector3){ 0.0f, 1.6f, 0.0f };          // Camera up vector (rotation towards target)
+        camera.fovy = 45.0f;                                // Camera field-of-view Y
+        camera.type = CAMERA_PERSPECTIVE;                   // Camera mode type
+    
+        Ray ray;        // Picking ray
+        
+        Model tower = LoadModel("resources/models/turret.obj");                 // Load OBJ model
+        Texture2D texture = LoadTexture("resources/models/turret_diffuse.png"); // Load model texture
+        tower.material.maps[MAP_DIFFUSE].texture = texture;                     // Set model diffuse texture
+        
+        Vector3 towerPos = { 0.0f, 0.0f, 0.0f };                    // Set model position
+        BoundingBox towerBBox = MeshBoundingBox(tower.mesh);        // Get mesh bounding box
+        bool hitMeshBBox = false;
+        bool hitTriangle = false;
+    
+        // Test triangle
+        Vector3 ta = (Vector3){ -25.0, 0.5, 0.0 };    
+        Vector3 tb = (Vector3){ -4.0, 2.5, 1.0 };
+        Vector3 tc = (Vector3){ -8.0, 6.5, 0.0 };
+    
+        Vector3 bary = { 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
+            
+            // Display information about closest hit
+            RayHitInfo nearestHit;
+            char *hitObjectName = "None";
+            nearestHit.distance = FLT_MAX;
+            nearestHit.hit = false;
+            Color cursorColor = WHITE;
+    
+            // Get ray and test against ground, triangle, and mesh
+            ray = GetMouseRay(GetMousePosition(), camera);
+            
+            // Check ray collision aginst ground plane
+            RayHitInfo groundHitInfo = GetCollisionRayGround(ray, 0.0f);
+            
+            if ((groundHitInfo.hit) && (groundHitInfo.distance < nearestHit.distance))
+            {
+                nearestHit = groundHitInfo;
+                cursorColor = GREEN;
+                hitObjectName = "Ground";
+            }
+    
+            // Check ray collision against test triangle
+            RayHitInfo triHitInfo = GetCollisionRayTriangle(ray, ta, tb, tc);
+            
+            if ((triHitInfo.hit) && (triHitInfo.distance < nearestHit.distance)) 
+            {
+                nearestHit = triHitInfo;
+                cursorColor = PURPLE;
+                hitObjectName = "Triangle";
+    
+                bary = Vector3Barycenter(nearestHit.position, ta, tb, tc);
+                hitTriangle = true;
+            } 
+            else hitTriangle = false;
+    
+            RayHitInfo meshHitInfo;
+    
+            // Check ray collision against bounding box first, before trying the full ray-mesh test
+            if (CheckCollisionRayBox(ray, towerBBox)) 
+            {
+                hitMeshBBox = true;
+                
+                // Check ray collision against model
+                // NOTE: It considers model.transform matrix!
+                meshHitInfo = GetCollisionRayModel(ray, &tower);   
+                
+                if ((meshHitInfo.hit) && (meshHitInfo.distance < nearestHit.distance)) 
+                {
+                    nearestHit = meshHitInfo;
+                    cursorColor = ORANGE;
+                    hitObjectName = "Mesh";
+                }
+                
+            } hitMeshBBox = false; 
+            //----------------------------------------------------------------------------------
+            
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    // Draw the tower
+                    // WARNING: If scale is different than 1.0f, 
+                    // not considered by GetCollisionRayModel()
+                    DrawModel(tower, towerPos, 1.0f, WHITE);
+                    
+                    // Draw the test triangle
+                    DrawLine3D(ta, tb, PURPLE);
+                    DrawLine3D(tb, tc, PURPLE);
+                    DrawLine3D(tc, ta, PURPLE);
+    
+                    // Draw the mesh bbox if we hit it
+                    if (hitMeshBBox) DrawBoundingBox(towerBBox, LIME);
+    
+                    // If we hit something, draw the cursor at the hit point
+                    if (nearestHit.hit) 
+                    {
+                        DrawCube(nearestHit.position, 0.3, 0.3, 0.3, cursorColor);
+                        DrawCubeWires(nearestHit.position, 0.3, 0.3, 0.3, RED);
+    
+                        Vector3 normalEnd;
+                        normalEnd.x = nearestHit.position.x + nearestHit.normal.x;
+                        normalEnd.y = nearestHit.position.y + nearestHit.normal.y;
+                        normalEnd.z = nearestHit.position.z + nearestHit.normal.z;
+                        
+                        DrawLine3D(nearestHit.position, normalEnd, RED);
+                    }
+    
+                    DrawRay(ray, MAROON);
+                    
+                    DrawGrid(10, 10.0f);
+    
+                EndMode3D();
+                
+                // Draw some debug GUI text
+                DrawText(FormatText("Hit Object: %s", hitObjectName), 10, 50, 10, BLACK);
+    
+                if (nearestHit.hit) 
+                {
+                    int ypos = 70;
+    
+                    DrawText(FormatText("Distance: %3.2f", nearestHit.distance), 10, ypos, 10, BLACK);
+                    
+                    DrawText(FormatText("Hit Pos: %3.2f %3.2f %3.2f", 
+                                        nearestHit.position.x, 
+                                        nearestHit.position.y, 
+                                        nearestHit.position.z), 10, ypos + 15, 10, BLACK);
+                                        
+                    DrawText(FormatText("Hit Norm: %3.2f %3.2f %3.2f", 
+                                        nearestHit.normal.x, 
+                                        nearestHit.normal.y, 
+                                        nearestHit.normal.z), 10, ypos + 30, 10, BLACK);
+    
+                    if (hitTriangle) DrawText(FormatText("Barycenter: %3.2f %3.2f %3.2f",  bary.x, bary.y, bary.z), 10, ypos + 45, 10, BLACK);
+                }
+    
+                DrawText("Use Mouse to Move Camera", 10, 430, 10, GRAY);
+                
+                DrawText("(c) Turret 3D model by Alberto Cano", screenWidth - 200, screenHeight - 20, 10, GRAY);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadModel(tower);         // Unload model
+        UnloadTexture(texture);     // Unload texture
+        
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+
+}

Examples/Examples/models/models_obj_loading.cs

@@ -0,0 +1,94 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Load and draw a 3d model (OBJ)
+    *
+    *   This example has been created using raylib 1.3 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    public static int models_obj_loading()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - obj model loading");
+    
+        // Define the camera to look into our 3d world
+        Camera camera = { 0 };
+        camera.position = (Vector3){ 8.0f, 8.0f, 8.0f };    // Camera position
+        camera.target = (Vector3){ 0.0f, 2.5f, 0.0f };      // Camera looking at point
+        camera.up = (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
+    
+        Model model = LoadModel("resources/models/castle.obj");                 // Load OBJ model
+        Texture2D texture = LoadTexture("resources/models/castle_diffuse.png"); // Load model texture
+        model.material.maps[MAP_DIFFUSE].texture = texture;                     // Set map diffuse texture
+        Vector3 position = { 0.0f, 0.0f, 0.0f };                                // Set model position
+    
+        SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            //...
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawModel(model, position, 0.2f, WHITE);   // Draw 3d model with texture
+    
+                    DrawGrid(10, 1.0f);         // Draw a grid
+    
+                    DrawGizmo(position);        // Draw gizmo
+    
+                EndMode3D();
+                
+                DrawText("(c) Castle 3D model by Alberto Cano", screenWidth - 200, screenHeight - 20, 10, GRAY);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadTexture(texture);     // Unload texture
+        UnloadModel(model);         // Unload model
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+
+}

Examples/Examples/models/models_orthographic_projection.cs

@@ -0,0 +1,112 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Show the difference between perspective and orthographic projection 
+    *
+    *   This program is heavily based on the geometric objects example
+    *
+    *   This example has been created using raylib 1.9.7 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2018 Max Danielsson & Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    private const int FOVY_PERSPECTIVE = 45;.0f
+    private const int WIDTH_ORTHOGRAPHIC = 10;.0f
+    
+    public static int models_orthographic_projection()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
+    
+        // Define the camera to look into our 3d world
+        Camera camera = {{ 0.0f, 10.0f, 10.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, FOVY_PERSPECTIVE, CAMERA_PERSPECTIVE };
+    
+        SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+        //--------------------------------------------------------------------------------------
+    
+        // Main game loop
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+            if (IsKeyPressed(KEY_SPACE)) 
+            {
+                if (camera.type == CAMERA_PERSPECTIVE) 
+                {
+                    camera.fovy = WIDTH_ORTHOGRAPHIC;
+                    camera.type = CAMERA_ORTHOGRAPHIC;
+                } 
+                else 
+                {
+                    camera.fovy = FOVY_PERSPECTIVE;
+                    camera.type = CAMERA_PERSPECTIVE;
+                }
+            }
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                BeginMode3D(camera);
+    
+                    DrawCube((Vector3){-4.0f, 0.0f, 2.0f}, 2.0f, 5.0f, 2.0f, RED);
+                    DrawCubeWires((Vector3){-4.0f, 0.0f, 2.0f}, 2.0f, 5.0f, 2.0f, GOLD);
+                    DrawCubeWires((Vector3){-4.0f, 0.0f, -2.0f}, 3.0f, 6.0f, 2.0f, MAROON);
+    
+                    DrawSphere((Vector3){-1.0f, 0.0f, -2.0f}, 1.0f, GREEN);
+                    DrawSphereWires((Vector3){1.0f, 0.0f, 2.0f}, 2.0f, 16, 16, LIME);
+    
+                    DrawCylinder((Vector3){4.0f, 0.0f, -2.0f}, 1.0f, 2.0f, 3.0f, 4, SKYBLUE);
+                    DrawCylinderWires((Vector3){4.0f, 0.0f, -2.0f}, 1.0f, 2.0f, 3.0f, 4, DARKBLUE);
+                    DrawCylinderWires((Vector3){4.5f, -1.0f, 2.0f}, 1.0f, 1.0f, 2.0f, 6, BROWN);
+    
+                    DrawCylinder((Vector3){1.0f, 0.0f, -4.0f}, 0.0f, 1.5f, 3.0f, 8, GOLD);
+                    DrawCylinderWires((Vector3){1.0f, 0.0f, -4.0f}, 0.0f, 1.5f, 3.0f, 8, PINK);
+    
+                    DrawGrid(10, 1.0f);        // Draw a grid
+    
+                EndMode3D();
+    
+                DrawText("Press Spacebar to switch camera type", 10, GetScreenHeight() - 30, 20, DARKGRAY);
+    
+                if (camera.type == CAMERA_ORTHOGRAPHIC) DrawText("ORTHOGRAPHIC", 10, 40, 20, BLACK);
+                else if (camera.type == CAMERA_PERSPECTIVE) DrawText("PERSPECTIVE", 10, 40, 20, BLACK);
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+    
+
+}

Examples/Examples/models/models_skybox.cs

@@ -0,0 +1,105 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Skybox loading and drawing
+    *
+    *   This example has been created using raylib 1.8 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    
+    public static int models_skybox()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        int screenWidth = 800;
+        int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - skybox loading and drawing");
+    
+        // Define the camera to look into our 3d world
+        Camera camera = {{ 1.0f, 1.0f, 1.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
+    
+        // Load skybox model   
+        Mesh cube = GenMeshCube(1.0f, 1.0f, 1.0f);
+        Model skybox = LoadModelFromMesh(cube);
+        
+        // Load skybox shader and set required locations
+        // NOTE: Some locations are automatically set at shader loading
+        skybox.material.shader = LoadShader("resources/shaders/skybox.vs", "resources/shaders/skybox.fs");
+        SetShaderValuei(skybox.material.shader, GetShaderLocation(skybox.material.shader, "environmentMap"), (int[1]){ MAP_CUBEMAP }, 1);
+    
+        // Load cubemap shader and setup required shader locations
+        Shader shdrCubemap = LoadShader("resources/shaders/cubemap.vs", "resources/shaders/cubemap.fs");
+        SetShaderValuei(shdrCubemap, GetShaderLocation(shdrCubemap, "equirectangularMap"), (int[1]){ 0 }, 1);
+        
+        // Load HDR panorama (sphere) texture
+        Texture2D texHDR = LoadTexture("resources/dresden_square.hdr");
+        
+        // Generate cubemap (texture with 6 quads-cube-mapping) from panorama HDR texture
+        // NOTE: New texture is generated rendering to texture, shader computes the sphre->cube coordinates mapping
+        skybox.material.maps[MAP_CUBEMAP].texture = GenTextureCubemap(shdrCubemap, texHDR, 512);
+        
+        UnloadTexture(texHDR);      // Texture not required anymore, cubemap already generated
+        UnloadShader(shdrCubemap);  // Unload cubemap generation shader, not required anymore
+        
+        SetCameraMode(camera, 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);
+    
+                    DrawModel(skybox, (Vector3){0, 0, 0}, 1.0f, WHITE);
+                    
+                    DrawGrid(10, 1.0f);
+    
+                EndMode3D();
+    
+                DrawFPS(10, 10);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        UnloadModel(skybox);        // Unload skybox model (and textures)
+    
+        CloseWindow();              // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+    
+
+}

Examples/Examples/models/models_yaw_pitch_roll.cs

@@ -0,0 +1,214 @@
+
+
+using Raylib;
+
+using static Raylib.Raylib;
+
+
+
+public partial class Examples
+
+{
+
+    /*******************************************************************************************
+    *
+    *   raylib [models] example - Plane rotations (yaw, pitch, roll)
+    *
+    *   This example has been created using raylib 1.8 (www.raylib.com)
+    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+    *
+    *   Example based on Berni work on Raspberry Pi:
+    *   http://forum.raylib.com/index.php?p=/discussion/124/line-versus-triangle-drawing-order
+    *
+    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
+    *
+    ********************************************************************************************/
+    
+    
+    #include "raymath.h"
+    
+    // Draw angle gauge controls
+    void DrawAngleGauge(Texture2D angleGauge, int x, int y, float angle, char title[], Color color);
+    
+    //----------------------------------------------------------------------------------
+    // Main entry point
+    //----------------------------------------------------------------------------------
+    public static int models_yaw_pitch_roll()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        const int screenWidth = 800;
+        const int screenHeight = 450;
+    
+        InitWindow(screenWidth, screenHeight, "raylib [models] example - plane rotations (yaw, pitch, roll)");
+    
+        Texture2D texAngleGauge = LoadTexture("resources/angle_gauge.png");
+        Texture2D texBackground = LoadTexture("resources/background.png");
+        Texture2D texPitch = LoadTexture("resources/pitch.png");
+        Texture2D texPlane = LoadTexture("resources/plane.png");
+    
+        RenderTexture2D framebuffer = LoadRenderTexture(192, 192);
+    
+        // Model loading
+        Model model = LoadModel("resources/plane.obj");      // Load OBJ model
+        model.material.maps[MAP_DIFFUSE].texture = LoadTexture("resources/plane_diffuse.png"); // Set map diffuse texture
+    
+        GenTextureMipmaps(&model.material.maps[MAP_DIFFUSE].texture);
+    
+        Camera camera = { 0 };
+        camera.position = (Vector3){ 0.0f, 60.0f, -120.0f };// Camera position perspective
+        camera.target = (Vector3){ 0.0f, 12.0f, 0.0f };     // Camera looking at point
+        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
+        camera.fovy = 30.0f;                                // Camera field-of-view Y
+        camera.type = CAMERA_PERSPECTIVE;                   // Camera type
+    
+        float pitch = 0.0f;
+        float roll = 0.0f;
+        float yaw = 0.0f;
+    
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+    
+    
+        while (!WindowShouldClose())    // Detect window close button or ESC key
+        {
+            // Update
+            //----------------------------------------------------------------------------------
+    
+            // Plane roll (x-axis) controls
+            if (IsKeyDown(KEY_LEFT)) roll += 1.0f;
+            else if (IsKeyDown(KEY_RIGHT)) roll -= 1.0f;
+            else
+            {
+                if (roll > 0.0f) roll -= 0.5f;
+                else if (roll < 0.0f) roll += 0.5f;
+            }
+    
+            // Plane yaw (y-axis) controls
+            if (IsKeyDown(KEY_S)) yaw += 1.0f;
+            else if (IsKeyDown(KEY_A)) yaw -= 1.0f;
+            else
+            {
+                if (yaw > 0.0f) yaw -= 0.5f;
+                else if (yaw < 0.0f) yaw += 0.5f;
+            }
+    
+            // Plane pitch (z-axis) controls
+            if (IsKeyDown(KEY_DOWN)) pitch += 0.6f;
+            else if (IsKeyDown(KEY_UP)) pitch -= 0.6f;
+            else
+            {
+                if (pitch > 0.3f) pitch -= 0.3f;
+                else if (pitch < -0.3f) pitch += 0.3f;
+            }
+    
+            // Wraps the phase of an angle to fit between -180 and +180 degrees
+            int pitchOffset = pitch;
+            while (pitchOffset > 180) pitchOffset -= 360;
+            while (pitchOffset < -180) pitchOffset += 360;
+            pitchOffset *= 10;
+    
+            Matrix transform = MatrixIdentity();
+    
+            transform = MatrixMultiply(transform, MatrixRotateZ(DEG2RAD*roll));
+            transform = MatrixMultiply(transform, MatrixRotateX(DEG2RAD*pitch));
+            transform = MatrixMultiply(transform, MatrixRotateY(DEG2RAD*yaw));
+    
+            model.transform = transform;
+            //----------------------------------------------------------------------------------
+    
+            // Draw
+            //----------------------------------------------------------------------------------
+            BeginDrawing();
+    
+                ClearBackground(RAYWHITE);
+    
+                // Draw framebuffer texture (Ahrs Display)
+                int centerX = framebuffer.texture.width/2;
+                int centerY = framebuffer.texture.height/2;
+                float scaleFactor = 0.5f;
+    
+                BeginTextureMode(framebuffer);
+    
+                    BeginBlendMode(BLEND_ALPHA);
+    
+                    DrawTexturePro(texBackground, (Rectangle){ 0, 0, texBackground.width, texBackground.height },
+                                   (Rectangle){ centerX, centerY, texBackground.width*scaleFactor, texBackground.height*scaleFactor},
+                                   (Vector2){ texBackground.width/2*scaleFactor, texBackground.height/2*scaleFactor + pitchOffset*scaleFactor }, roll, WHITE);
+    
+                    DrawTexturePro(texPitch, (Rectangle){ 0, 0, texPitch.width, texPitch.height },
+                                   (Rectangle){ centerX, centerY, texPitch.width*scaleFactor, texPitch.height*scaleFactor },
+                                   (Vector2){ texPitch.width/2*scaleFactor, texPitch.height/2*scaleFactor + pitchOffset*scaleFactor }, roll, WHITE);
+    
+                    DrawTexturePro(texPlane, (Rectangle){ 0, 0, texPlane.width, texPlane.height },
+                                   (Rectangle){ centerX, centerY, texPlane.width*scaleFactor, texPlane.height*scaleFactor },
+                                   (Vector2){ texPlane.width/2*scaleFactor, texPlane.height/2*scaleFactor }, 0, WHITE);
+    
+                    EndBlendMode();
+    
+                EndTextureMode();
+    
+                // Draw 3D model (recomended to draw 3D always before 2D)
+                BeginMode3D(camera);
+    
+                    DrawModel(model, (Vector3){ 0, 6.0f, 0 }, 1.0f, WHITE);   // Draw 3d model with texture
+                    DrawGrid(10, 10.0f);
+    
+                EndMode3D();
+    
+                // Draw 2D GUI stuff
+                DrawAngleGauge(texAngleGauge, 80, 70, roll, "roll", RED);
+                DrawAngleGauge(texAngleGauge, 190, 70, pitch, "pitch", GREEN);
+                DrawAngleGauge(texAngleGauge, 300, 70, yaw, "yaw", SKYBLUE);
+    
+                DrawRectangle(30, 360, 260, 70, Fade(SKYBLUE, 0.5f));
+                DrawRectangleLines(30, 360, 260, 70, Fade(DARKBLUE, 0.5f));
+                DrawText("Pitch controlled with: KEY_UP / KEY_DOWN", 40, 370, 10, DARKGRAY);
+                DrawText("Roll controlled with: KEY_LEFT / KEY_RIGHT", 40, 390, 10, DARKGRAY);
+                DrawText("Yaw controlled with: KEY_A / KEY_S", 40, 410, 10, DARKGRAY);
+    
+                // Draw framebuffer texture
+                DrawTextureRec(framebuffer.texture, (Rectangle){ 0, 0, framebuffer.texture.width, -framebuffer.texture.height },
+                               (Vector2){ screenWidth - framebuffer.texture.width - 20, 20 }, Fade(WHITE, 0.8f));
+    
+                DrawRectangleLines(screenWidth - framebuffer.texture.width - 20, 20, framebuffer.texture.width, framebuffer.texture.height, DARKGRAY);
+    
+            EndDrawing();
+            //----------------------------------------------------------------------------------
+        }
+    
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+    
+        // Unload all loaded data
+        UnloadModel(model);
+    
+        UnloadRenderTexture(framebuffer);
+    
+        UnloadTexture(texAngleGauge);
+        UnloadTexture(texBackground);
+        UnloadTexture(texPitch);
+        UnloadTexture(texPlane);
+    
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+    
+        return 0;
+    }
+    
+    // Draw angle gauge controls
+    void DrawAngleGauge(Texture2D angleGauge, int x, int y, float angle, char title[], Color color)
+    {
+        Rectangle srcRec = { 0, 0, angleGauge.width, angleGauge.height };
+        Rectangle dstRec = { x, y, angleGauge.width, angleGauge.height };
+        Vector2 origin = { angleGauge.width/2, angleGauge.height/2};
+        int textSize = 20;
+    
+        DrawTexturePro(angleGauge, srcRec, dstRec, origin, angle, color);
+    
+        DrawText(FormatText("%5.1f", angle), x - MeasureText(FormatText("%5.1f", angle), textSize) / 2, y + 10, textSize, DARKGRAY);
+        DrawText(title, x - MeasureText(title, textSize) / 2, y + 60, textSize, DARKGRAY);
+    }
+    
+
+}