Merge remote-tracking branch 'refs/remotes/raysan5/develop' into develop

.gitignore

@@ -49,7 +49,7 @@ ipch/
 # Ignore compiled binaries
 *.o
 *.exe
-!tools/rrem.exe
+!tools/rREM/rrem.exe
 
 # Ignore files build by xcode
 *.mode*v*
@@ -75,4 +75,16 @@ src/libraylib.bc
 !src/external/glfw3/lib/win32/glfw3.dll
 !src/external/openal_soft/lib/win32/OpenAL32.dll
 !src/external/OculusSDK/LibOVR/LibOVRRT32_1.dll
-!src/external/pthread/pthreadGC2.dll
+!src/external/pthread/lib/pthreadGC2.dll
+
+# Visual Studio project
+project/vs2015/*.db
+project/vs2015/*.opendb
+!project/vs2015/raylib.sln
+!project/vs2015/raylib/*.vcxproj
+!project/vs2015/examples/*.vcxproj
+!project/vs2015/external/glfw3/lib/win32/glfw3.dll
+!project/vs2015/external/openal_soft/lib/win32/OpenAL32.dll
+!project/vs2015/external/openal_soft/lib/win64/OpenAL32.dll
+!project/vs2015/external/lua/lib/win32/lua53.dll
+

README.md

@@ -249,6 +249,7 @@ contributing (in some way or another) to make raylib project better. Huge thanks
  - [Chris Hemingway](https://github.com/cHemingway) for improving raylib on OSX build system.
  - [Emanuele Petriglia](https://github.com/LelixSuper) for working on multiple GNU/Linux improvements and developing [TicTacToe](https://github.com/LelixSuper/TicTacToe) raylib game.
  - [Joshua Reisenauer](https://github.com/kd7tck) for adding audio modules support (XM, MOD) and reviewing audio system.
+ - Marcelo Paez (paezao) for his help on OSX to solve High DPI display issue. Thanks Marcelo!
  
 	
 [raysan5]: mailto:raysan5@gmail.com "Ramon Santamaria - Ray San"

examples/Makefile

@@ -77,8 +77,27 @@ endif
 
 #CFLAGSEXTRA = -Wextra -Wmissing-prototypes -Wstrict-prototypes
 
+# define raylib release directory for compiled library
+ifeq ($(PLATFORM),PLATFORM_DESKTOP)
+    ifeq ($(PLATFORM_OS),WINDOWS)
+        RAYLIB_PATH = ../release/win32/mingw32
+    endif
+    ifeq ($(PLATFORM_OS),LINUX)
+        RAYLIB_PATH = ../release/linux
+    endif
+    ifeq ($(PLATFORM_OS),OSX)
+        RAYLIB_PATH = ../release/osx
+    endif
+endif
+ifeq ($(PLATFORM),PLATFORM_WEB)
+    RAYLIB_PATH = ../release/html5
+endif
+ifeq ($(PLATFORM),PLATFORM_RPI)
+    RAYLIB_PATH = ../release/rpi
+endif
+
 # define any directories containing required header files
-INCLUDES = -I. -I../src -I../src/external
+INCLUDES = -I. -I../src -I../src/external -I$(RAYLIB_PATH)
 
 ifeq ($(PLATFORM),PLATFORM_RPI)
     INCLUDES += -I/opt/vc/include -I/opt/vc/include/interface/vcos/pthreads
@@ -97,7 +116,7 @@ ifeq ($(PLATFORM),PLATFORM_DESKTOP)
 endif
 
 # define library paths containing required libs
-LFLAGS = -L. -L../src
+LFLAGS = -L. -L../src -L$(RAYLIB_PATH)
 
 ifeq ($(PLATFORM),PLATFORM_RPI)
     LFLAGS += -L/opt/vc/lib
@@ -120,7 +139,7 @@ ifeq ($(PLATFORM),PLATFORM_DESKTOP)
         # libraries for Debian GNU/Linux desktop compiling
         # requires the following packages:
         # libglfw3-dev libopenal-dev libegl1-mesa-dev
-        LIBS = -lraylib -lglfw3 -lGL -lopenal -lm -pthread -ldl
+        LIBS = -lraylib -lglfw3 -lGL -lopenal -lm -lpthread -ldl
         # on XWindow could require also below libraries, just uncomment
         #LIBS += -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor
     else
@@ -210,6 +229,7 @@ EXAMPLES = \
     audio_sound_loading \
     audio_music_stream \
     audio_module_playing \
+    audio_raw_stream \
     fix_dylib \
 
 
@@ -436,10 +456,14 @@ audio_sound_loading: audio_sound_loading.c
 audio_music_stream: audio_music_stream.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
-# compile [audio] example - module playing (OGG)
+# compile [audio] example - module playing (XM)
 audio_module_playing: audio_module_playing.c
 	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
 
+# compile [audio] example - raw audio streaming
+audio_raw_stream: audio_raw_stream.c
+	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -D$(PLATFORM) $(WINFLAGS)
+
 # fix dylib install path name for each executable (MAC)
 fix_dylib:
 ifeq ($(PLATFORM_OS),OSX)

examples/audio_module_playing.c

@@ -57,9 +57,12 @@ int main()
     // Create a RenderTexture2D to be used for render to texture
     RenderTexture2D target = LoadRenderTexture(screenWidth, screenHeight);
 
-    PlayMusicStream(0, "resources/audio/2t2m_spa.xm");         // Play module stream
+    Music xm = LoadMusicStream("resources/audio/mini1111.xm");
+    
+    PlayMusicStream(xm);
 
     float timePlayed = 0.0f;
+    bool pause = false;
 
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
@@ -69,7 +72,29 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        for (int i = MAX_CIRCLES - 1; i >= 0; i--)
+        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))*2;
+        
+        // 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;
@@ -86,11 +111,6 @@ int main()
                 circles[i].speed = (float)GetRandomValue(1, 100)/20000.0f;
             }
         }
-
-        // Get timePlayed scaled to bar dimensions
-        timePlayed = (GetMusicTimePlayed(0)/GetMusicTimeLength(0)*(screenWidth - 40))*2;
-        
-        UpdateMusicStream(0);        // Update music buffer with new stream data
         //----------------------------------------------------------------------------------
 
         // Draw
@@ -129,6 +149,8 @@ int main()
     UnloadShader(shader);           // Unload shader
     UnloadRenderTexture(target);    // Unload render texture
     
+    UnloadMusicStream(xm);          // Unload music stream buffers from RAM
+    
     CloseAudioDevice();     // Close audio device (music streaming is automatically stopped)
 
     CloseWindow();          // Close window and OpenGL context

examples/audio_module_playing.lua

@@ -0,0 +1,122 @@
+-------------------------------------------------------------------------------------------
+--
+--   raylib [audio] example - Module playing (streaming)
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+MAX_CIRCLES = 64
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [audio] example - module playing (streaming)")
+
+InitAudioDevice()              -- Initialize audio device
+
+local colors = { ORANGE, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK,
+                 YELLOW, GREEN, SKYBLUE, PURPLE, BEIGE }
+
+-- Creates ome circles for visual effect
+local circles = {}
+
+for i = MAX_CIRCLES, 1, -1 do
+    circles[i] = {}
+    circles[i].alpha = 0.0
+    circles[i].radius = GetRandomValue(10, 40)
+    circles[i].position = Vector2(0, 0)
+    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 = GetRandomValue(1, 100)/20000.0
+    circles[i].color = colors[GetRandomValue(1, 14)]
+end
+
+-- Load postprocessing bloom shader
+local shader = LoadShader("resources/shaders/glsl330/base.vs", 
+                          "resources/shaders/glsl330/bloom.fs")
+
+-- Create a RenderTexture2D to be used for render to texture
+local target = LoadRenderTexture(screenWidth, screenHeight)
+
+local xm = LoadMusicStream("resources/audio/mini1111.xm")
+
+PlayMusicStream(xm)
+
+local timePlayed = 0.0
+
+SetTargetFPS(60)               -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do        -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    for i = MAX_CIRCLES, 1, -1 do
+        circles[i].alpha = circles[i].alpha + circles[i].speed
+        circles[i].radius = circles[i].radius + circles[i].speed*10.0
+        
+        if (circles[i].alpha > 1.0) then circles[i].speed = circles[i].speed*-1 end
+        
+        if (circles[i].alpha <= 0.0) then
+            circles[i].alpha = 0.0
+            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(1, 14)]
+            circles[i].speed = GetRandomValue(1, 100)/20000.0
+        end
+    end
+
+    -- Get timePlayed scaled to bar dimensions
+    timePlayed = (GetMusicTimePlayed(xm)/GetMusicTimeLength(xm)*(screenWidth - 40))*2
+    
+    UpdateMusicStream(xm)        -- Update music buffer with new stream data
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(BLACK)
+        
+        BeginTextureMode(target)   -- Enable drawing to texture
+
+            for i = MAX_CIRCLES, 1, -1 do
+                DrawCircleV(circles[i].position, circles[i].radius, Fade(circles[i].color, circles[i].alpha))
+            end
+            
+        EndTextureMode()           -- End drawing to texture (now we have a texture available for next passes)
+        
+        BeginShaderMode(shader)
+
+            -- NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom)
+            DrawTextureRec(target.texture, Rectangle(0, 0, target.texture.width, -target.texture.height), Vector2(0, 0), WHITE)
+            
+        EndShaderMode()
+
+        -- Draw time bar
+        DrawRectangle(20, screenHeight - 20 - 12, screenWidth - 40, 12, LIGHTGRAY)
+        DrawRectangle(20, screenHeight - 20 - 12, timePlayed//1, 12, MAROON)
+        DrawRectangleLines(20, screenHeight - 20 - 12, screenWidth - 40, 12, WHITE)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadShader(shader)           -- Unload shader
+UnloadRenderTexture(target)    -- Unload render texture
+
+UnloadMusicStream(xm)          -- Unload music stream buffers from RAM
+
+CloseAudioDevice()     -- Close audio device (music streaming is automatically stopped)
+
+CloseWindow()          -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/audio_music_stream.c

@@ -24,11 +24,12 @@ int main()
 
     InitAudioDevice();              // Initialize audio device
 
-    PlayMusicStream(0, "resources/audio/guitar_noodling.ogg");         // Play music stream
+    Music music = LoadMusicStream("resources/audio/guitar_noodling.ogg");
+    
+    PlayMusicStream(music);
 
-    int framesCounter = 0;
     float timePlayed = 0.0f;
-    //float volume = 1.0;
+    bool pause = false;
 
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
@@ -38,32 +39,26 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        framesCounter++;
+        UpdateMusicStream(music);        // Update music buffer with new stream data
         
-        // Testing music fading from one file to another
+        // Restart music playing (stop and play)
-/*
+        if (IsKeyPressed(KEY_SPACE)) 
-        if (framesCounter > 600)    // Wait for 10 seconds (600 frames)
         {
-            volume -= 0.01;         // Decrement music volume level
+            StopMusicStream(music);
-
+            PlayMusicStream(music);
-            // When music volume level equal or lower than 0,
-            // restore volume level and init another music file
-            if (volume <= 0)
-            {
-                volume = 1.0;
-                framesCounter = 0;
-                PlayMusicStream(1, "resources/audio/another_file.ogg");
         }
         
-            SetMusicVolume(volume);
+        // Pause/Resume music playing 
+        if (IsKeyPressed(KEY_P))
+        {
+            pause = !pause;
+            
+            if (pause) PauseMusicStream(music);
+            else ResumeMusicStream(music);
         }
-*/
-        if (IsWindowMinimized()) PauseMusicStream(0);
-        else ResumeMusicStream(0);
         
-        timePlayed = GetMusicTimePlayed(0)/GetMusicTimeLength(0)*100*4; // We scale by 4 to fit 400 pixels
+        // Get timePlayed scaled to bar dimensions (400 pixels)
-        
+        timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*100*4;
-        UpdateMusicStream(0);        // Update music buffer with new stream data
         //----------------------------------------------------------------------------------
 
         // Draw
@@ -72,10 +67,14 @@ int main()
 
             ClearBackground(RAYWHITE);
 
-            DrawText("MUSIC SHOULD BE PLAYING!", 255, 200, 20, LIGHTGRAY);
+            DrawText("MUSIC SHOULD BE PLAYING!", 255, 150, 20, LIGHTGRAY);
 
-            DrawRectangle(200, 250, 400, 12, LIGHTGRAY);
+            DrawRectangle(200, 200, 400, 12, LIGHTGRAY);
-            DrawRectangle(200, 250, (int)timePlayed, 12, MAROON);
+            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();
         //----------------------------------------------------------------------------------
@@ -83,6 +82,8 @@ int main()
 
     // 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

examples/audio_music_stream.lua

@@ -0,0 +1,66 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [audio] example - Music playing (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) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [audio] example - music playing (streaming)")
+
+InitAudioDevice()              -- Initialize audio device
+
+local music = LoadMusicStream("resources/audio/guitar_noodling.ogg")
+
+PlayMusicStream(music)
+
+local framesCounter = 0
+local timePlayed = 0.0
+
+SetTargetFPS(60)                -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    framesCounter = framesCounter + 1
+
+    timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*100*4 -- We scale by 4 to fit 400 pixels
+
+    UpdateMusicStream(music)        -- Update music buffer with new stream data
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawText("MUSIC SHOULD BE PLAYING!", 255, 200, 20, LIGHTGRAY)
+
+        DrawRectangle(200, 250, 400, 12, LIGHTGRAY)
+        DrawRectangle(200, 250, timePlayed//1, 12, MAROON)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- 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
+-------------------------------------------------------------------------------------------

examples/audio_raw_stream.c

@@ -0,0 +1,111 @@
+/*******************************************************************************************
+*
+*   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 "raylib.h"
+
+#include <stdlib.h>         // Required for: malloc(), free()
+#include <math.h>           // Required for: sinf()
+
+#define MAX_SAMPLES      20000
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [audio] example - raw audio streaming");
+
+    InitAudioDevice();              // Initialize audio device
+
+    // Init raw audio stream (sample rate: 22050, sample size: 32bit-float, channels: 1-mono)
+    AudioStream stream = InitAudioStream(22050, 32, 1);
+    
+    // Fill audio stream with some samples (sine wave)
+    float *data = (float *)malloc(sizeof(float)*MAX_SAMPLES);
+    
+    for (int i = 0; i < MAX_SAMPLES; i++)
+    {
+        data[i] = sinf(((2*PI*(float)i)/2)*DEG2RAD);
+    }
+    
+    // NOTE: The generated MAX_SAMPLES do not fit to close a perfect loop
+    // for that reason, there is a clip everytime audio stream is looped
+    
+    PlayAudioStream(stream);
+    
+    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
+        if (IsAudioBufferProcessed(stream)) 
+        {
+            int numSamples = 0;
+            if (samplesLeft >= 4096) numSamples = 4096;
+            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)
+            for (int i = 0; i < GetScreenWidth(); i++)
+            {
+                position.x = i;
+                position.y = 250 + 50*data[i];
+                
+                DrawPixelV(position, RED);
+            }
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    free(data);                 // Unload sine wave data
+    
+    CloseAudioStream(stream);   // Close raw audio stream and delete buffers from RAM
+
+    CloseAudioDevice();         // Close audio device (music streaming is automatically stopped)
+
+    CloseWindow();              // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/audio_raw_stream.lua

@@ -0,0 +1,97 @@
+-------------------------------------------------------------------------------------------
+--
+--  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) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+MAX_SAMPLES = 20000
+DEG2RAD = math.pi/180.0
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [audio] example - raw audio streaming")
+
+InitAudioDevice()              -- Initialize audio device
+
+-- Init raw audio stream (sample rate: 22050, sample size: 32bit-float, channels: 1-mono)
+local stream = InitAudioStream(22050, 32, 1)
+
+-- Fill audio stream with some samples (sine wave)
+local data = {}
+
+for i = 1, MAX_SAMPLES do
+    data[i] = math.sin(((2*math.pi*i)/2)*DEG2RAD)
+end
+
+-- NOTE: The generated MAX_SAMPLES do not fit to close a perfect loop
+-- for that reason, there is a clip everytime audio stream is looped
+
+PlayAudioStream(stream)
+
+local totalSamples = MAX_SAMPLES
+local samplesLeft = totalSamples
+
+local position = Vector2(0, 0)
+
+SetTargetFPS(30)               -- Set our game to run at 30 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    
+    -- Refill audio stream if required
+    if (IsAudioBufferProcessed(stream)) then
+        local numSamples = 0
+        
+        if (samplesLeft >= 4096) then numSamples = 4096
+        else numSamples = samplesLeft end
+
+        UpdateAudioStream(stream, data + (totalSamples - samplesLeft), numSamples)
+        
+        samplesLeft = samplesLeft - numSamples
+        
+        -- Reset samples feeding (loop audio)
+        if (samplesLeft <= 0) then samplesLeft = totalSamples end
+    end
+    ---------------------------------------------------------------------------------------
+
+    -- 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)
+        for i = 1, GetScreenWidth() do
+            position.x = (i - 1)
+            position.y = 250 + 50*data[i]
+            
+            DrawPixelV(position, RED)
+        end
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+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
+-------------------------------------------------------------------------------------------

examples/audio_sound_loading.c

@@ -36,7 +36,6 @@ int main()
         // Update
         //----------------------------------------------------------------------------------
         if (IsKeyPressed(KEY_SPACE)) PlaySound(fxWav);      // Play WAV sound
-
         if (IsKeyPressed(KEY_ENTER)) PlaySound(fxOgg);      // Play OGG sound
         //----------------------------------------------------------------------------------
 

examples/audio_sound_loading.lua

@@ -0,0 +1,59 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [audio] example - Sound loading and playing
+--
+--  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) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing")
+
+InitAudioDevice()      -- Initialize audio device
+
+local fxWav = LoadSound("resources/audio/weird.wav")         -- Load WAV audio file
+local fxOgg = LoadSound("resources/audio/tanatana.ogg")      -- Load OGG audio file
+
+SetTargetFPS(60)
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    if (IsKeyPressed(KEY.SPACE)) then PlaySound(fxWav) end      -- Play WAV sound
+    if (IsKeyPressed(KEY.ENTER)) then PlaySound(fxOgg) end      -- 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()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadSound(fxWav)     -- Unload sound data
+UnloadSound(fxOgg)     -- Unload sound data
+
+CloseAudioDevice()     -- Close audio device
+
+CloseWindow()          -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/audio_standalone.c

@@ -39,7 +39,8 @@ int main()
     Sound fxWav = LoadSound("resources/audio/weird.wav");         // Load WAV audio file
     Sound fxOgg = LoadSound("resources/audio/tanatana.ogg");      // Load OGG audio file
     
-    PlayMusicStream(0, "resources/audio/guitar_noodling.ogg");
+    Music music = LoadMusicStream("resources/audio/guitar_noodling.ogg");
+    PlayMusicStream(music);
 
     printf("\nPress s or d to play sounds...\n");
     
@@ -59,12 +60,14 @@ int main()
             key = 0;
         }
         
-        UpdateMusicStream(0);
+        UpdateMusicStream(music);
     }
     
     UnloadSound(fxWav);         // Unload sound data
     UnloadSound(fxOgg);         // Unload sound data
     
+    UnloadMusicStream(music);   // Unload music stream data
+    
     CloseAudioDevice();
     
     printf("\n\nPress ENTER to close...");

examples/core_2d_camera.lua

@@ -0,0 +1,130 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - 2d camera
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+MAX_BUILDINGS = 100
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera")
+
+local player = Rectangle(400, 280, 40, 40)
+local buildings = {}
+local buildColors = {}
+
+local spacing = 0;
+
+for i = 1, MAX_BUILDINGS do
+    buildings[i] = Rectangle(0, 0, 0, 0)
+    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 = spacing + buildings[i].width
+    
+    buildColors[i] = Color(GetRandomValue(200, 240), GetRandomValue(200, 240), GetRandomValue(200, 250), 255)
+end
+
+local camera = Camera2D(Vector2(0, 0), Vector2(0, 0), 0.0, 1.0)
+
+camera.target = Vector2(player.x + 20, player.y + 20)
+camera.offset = Vector2(0, 0)
+camera.rotation = 0.0
+camera.zoom = 1.0
+
+SetTargetFPS(60)
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do                -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    if (IsKeyDown(KEY.RIGHT)) then
+        player.x = player.x + 2                 -- Player movement
+        camera.offset.x = camera.offset.x - 2   -- Camera displacement with player movement
+    elseif (IsKeyDown(KEY.LEFT)) then
+        player.x = player.x - 2                 -- Player movement
+        camera.offset.x = camera.offset.x + 2   -- Camera displacement with player movement
+    end
+    
+    -- Camera target follows player
+    camera.target = Vector2(player.x + 20, player.y + 20)
+    
+    -- Camera rotation controls
+    if (IsKeyDown(KEY.A)) then camera.rotation = camera.rotation - 1
+    elseif (IsKeyDown(KEY.S)) then camera.rotation = camera.rotation + 1
+    end
+    
+    -- Limit camera rotation to 80 degrees (-40 to 40)
+    if (camera.rotation > 40) then camera.rotation = 40
+    elseif (camera.rotation < -40) then camera.rotation = -40
+    end
+
+    -- Camera zoom controls
+    camera.zoom = camera.zoom + (GetMouseWheelMove()*0.05)
+    
+    if (camera.zoom > 3.0) then camera.zoom = 3.0
+    elseif (camera.zoom < 0.1) then camera.zoom = 0.1
+    end
+    
+    -- Camera reset (zoom and rotation)
+    if (IsKeyPressed(KEY.R)) then
+        camera.zoom = 1.0
+        camera.rotation = 0.0
+    end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin2dMode(camera)
+
+            DrawRectangle(-6000, 320, 13000, 8000, DARKGRAY)
+            
+            for i = 1, MAX_BUILDINGS, 1 do DrawRectangleRec(buildings[i], buildColors[i]) end
+            
+            DrawRectangleRec(player, RED)
+
+            DrawRectangle(camera.target.x, -500, 1, screenHeight*4, GREEN)
+            DrawRectangle(-500, camera.target.y, screenWidth*4, 1, GREEN)
+            
+        End2dMode()
+
+        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.5))
+        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();
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()           -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/core_3d_camera_first_person.c

@@ -23,7 +23,7 @@ int main()
     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.0f, 10.0f, 10.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 60.0f };
+    Camera camera = {{ 4.0f, 2.0f, 4.0f }, { 0.0f, 1.8f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 60.0f };
 
     // Generates some random columns
     float heights[MAX_COLUMNS];
@@ -37,10 +37,7 @@ int main()
         colors[i] = (Color){ GetRandomValue(20, 255), GetRandomValue(10, 55), 30, 255 };
     }
     
-    Vector3 playerPosition = { 4.0f, 2.0f, 4.0f };       // Define player position
+    SetCameraMode(camera, CAMERA_FIRST_PERSON); // Set a first person camera mode
-    
-    SetCameraMode(CAMERA_FIRST_PERSON);         // Set a first person camera mode
-    SetCameraFovy(camera.fovy);                 // Set internal camera field-of-view Y
 
     SetTargetFPS(60);                           // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
@@ -50,7 +47,7 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        UpdateCameraPlayer(&camera, &playerPosition); // Update camera and player position
+        UpdateCamera(&camera);                  // Update camera and player position
         //----------------------------------------------------------------------------------
 
         // Draw

examples/core_3d_camera_first_person.lua

@@ -0,0 +1,85 @@
+--------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - 3d camera first person
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+--------------------------------------------------------------------------------------------
+
+MAX_COLUMNS = 20
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local 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)
+local camera = Camera(Vector3(0.0, 10.0, 10.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 60.0)
+
+-- Generates some random columns
+local heights = {}
+local positions = {}
+local colors = {}
+
+for i = 1, MAX_COLUMNS do
+    heights[i] = 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)
+end
+
+local playerPosition = Vector3(4.0, 2.0, 4.0)       -- Define player position
+
+SetCameraMode(CameraMode.FIRST_PERSON)         -- Set a first person camera mode
+SetCameraFovy(camera.fovy)                 -- Set internal camera field-of-view Y
+
+SetTargetFPS(60)                           -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do           -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    camera, playerPosition = UpdateCameraPlayer(camera, playerPosition) -- Update camera and player position
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)
+
+            DrawPlane(Vector3(0.0, 0.0, 0.0), Vector2(32.0, 32.0), LIGHTGRAY) -- Draw ground
+            DrawCube(Vector3(-16.0, 2.5, 0.0), 1.0, 5.0, 32.0, BLUE)     -- Draw a blue wall
+            DrawCube(Vector3(16.0, 2.5, 0.0), 1.0, 5.0, 32.0, LIME)      -- Draw a green wall
+            DrawCube(Vector3(0.0, 2.5, 16.0), 32.0, 5.0, 1.0, GOLD)      -- Draw a yellow wall
+        
+            -- Draw some cubes around
+            for i = 1, MAX_COLUMNS do
+                DrawCube(positions[i], 2.0, heights[i], 2.0, colors[i])
+                DrawCubeWires(positions[i], 2.0, heights[i], 2.0, MAROON)
+            end
+
+        End3dMode()
+        
+        DrawRectangle( 10, 10, 220, 70, Fade(SKYBLUE, 0.5))
+        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()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()           -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/core_3d_camera_free.c

@@ -22,17 +22,14 @@ int main()
 
     // Define the camera to look into our 3d world
     Camera camera;
-    camera.position = (Vector3){ 0.0f, 10.0f, 10.0f };  // Camera position
+    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
     
     Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
     
-    SetCameraMode(CAMERA_FREE);         // Set a free camera mode
+    SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
-    SetCameraPosition(camera.position); // Set internal camera position to match our camera position
-    SetCameraTarget(camera.target);     // Set internal camera target to match our camera target
-    SetCameraFovy(camera.fovy);         // Set internal camera field-of-view Y
 
     SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
@@ -43,6 +40,8 @@ int main()
         // Update
         //----------------------------------------------------------------------------------
         UpdateCamera(&camera);          // Update internal camera and our camera
+        
+        if (IsKeyDown('Z')) camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
         //----------------------------------------------------------------------------------
 
         // Draw

examples/core_3d_camera_free.lua

@@ -0,0 +1,75 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Initialize 3d camera free
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+--------------------------------------------------------------------------------------------
+
+-- Initialization
+----------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free")
+
+-- Define the camera to look into our 3d world
+local camera = {}
+camera.position = Vector3(0.0, 10.0, 10.0)  -- Camera position
+camera.target = Vector3(0.0, 0.0, 0.0)      -- Camera looking at point
+camera.up = Vector3(0.0, 1.0, 0.0)          -- Camera up vector (rotation towards target)
+camera.fovy = 45.0                          -- Camera field-of-view Y
+
+local cubePosition = Vector3(0.0, 0.0, 0.0)
+
+SetCameraMode(CameraMode.FREE)         -- Set a free camera mode
+SetCameraPosition(camera.position) -- Set internal camera position to match our camera position
+SetCameraTarget(camera.target)     -- Set internal camera target to match our camera target
+SetCameraFovy(camera.fovy)         -- Set internal camera field-of-view Y
+
+SetTargetFPS(60)                   -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    camera = UpdateCamera(camera)          -- Update internal camera and our camera
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)
+
+            DrawCube(cubePosition, 2.0, 2.0, 2.0, RED)
+            DrawCubeWires(cubePosition, 2.0, 2.0, 2.0, MAROON)
+
+            DrawGrid(10, 1.0)
+
+        End3dMode()
+        
+        DrawRectangle( 10, 10, 320, 133, Fade(SKYBLUE, 0.5))
+        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()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/core_3d_mode.lua

@@ -0,0 +1,64 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Initialize 3d mode
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d mode")
+
+-- Define the camera to look into our 3d world
+local camera = {}
+camera.position = Vector3(0.0, 10.0, 10.0)   -- Camera position
+camera.target = Vector3(0.0, 0.0, 0.0)       -- Camera looking at point
+camera.up = Vector3(0.0, 1.0, 0.0)           -- Camera up vector (rotation towards target)
+camera.fovy = 45.0                           -- Camera field-of-view Y
+
+local cubePosition = Vector3(0.0, 0.0, 0.0)
+
+SetTargetFPS(60)   -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update your variables here
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)    -- ERROR: Lua Error: attempt to index a number value (?)
+
+            DrawCube(cubePosition, 2.0, 2.0, 2.0, RED)
+            DrawCubeWires(cubePosition, 2.0, 2.0, 2.0, MAROON)
+
+            DrawGrid(10, 1.0)
+
+        End3dMode()
+
+        DrawText("Welcome to the third dimension!", 10, 40, 20, DARKGRAY)
+
+        DrawFPS(10, 10)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()          -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/core_3d_picking.lua

@@ -0,0 +1,98 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Picking in 3d mode
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d picking")
+
+-- Define the camera to look into our 3d world
+local camera = {}
+camera.position = Vector3(0.0, 10.0, 10.0)  -- Camera position
+camera.target = Vector3(0.0, 0.0, 0.0)      -- Camera looking at point
+camera.up = Vector3(0.0, 1.0, 0.0)          -- Camera up vector (rotation towards target)
+camera.fovy = 45.0                          -- Camera field-of-view Y
+
+local cubePosition = Vector3(0.0, 1.0, 0.0)
+local cubeSize = Vector3(2.0, 2.0, 2.0)
+
+local ray = Ray(Vector3(0, 0, 0), Vector3(0, 0, 0)) -- Picking line ray
+
+local collision = false
+
+SetCameraMode(CameraMode.FREE)         -- Set a free camera mode
+SetCameraPosition(camera.position) -- Set internal camera position to match our camera position
+SetCameraFovy(camera.fovy)         -- Set internal camera field-of-view Y
+
+SetTargetFPS(60)                   -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    camera = UpdateCamera(camera)           -- Update internal camera and our camera
+    
+    if (IsMouseButtonPressed(MOUSE.LEFT_BUTTON)) then
+        -- NOTE: This function is NOT WORKING properly!
+        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)))
+
+        --print("collision check:", collision)
+    end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)
+
+            if (collision) then
+                DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, RED)
+                DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, MAROON)
+
+                DrawCubeWires(cubePosition, cubeSize.x + 0.2, cubeSize.y + 0.2, cubeSize.z + 0.2, GREEN)
+            else
+                DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, GRAY)
+                DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, DARKGRAY)
+            end
+            
+            DrawRay(ray, MAROON)
+            
+            DrawGrid(10, 1.0)
+
+        End3dMode()
+        
+        DrawText("Try selecting the box with mouse!", 240, 10, 20, DARKGRAY)
+        
+        if (collision) then 
+            DrawText("BOX SELECTED", (screenWidth - MeasureText("BOX SELECTED", 30))/2, screenHeight*0.1, 30, GREEN)
+        end
+
+        DrawFPS(10, 10)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/core_basic_window.cpp

@@ -0,0 +1,62 @@
+/*******************************************************************************************
+*
+*   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) 2014 Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+int main(int argc, char* argv[])
+{
+	// 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, LIGHTGRAY);
+
+		EndDrawing();
+		//----------------------------------------------------------------------------------
+	}
+
+	// De-Initialization
+	//--------------------------------------------------------------------------------------   
+	CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+	return 0;
+}

examples/core_basic_window.lua

@@ -0,0 +1,44 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Basic window
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window")
+
+SetTargetFPS(60)       -- Set target frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- 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, LIGHTGRAY)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()           -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/core_color_select.lua

@@ -0,0 +1,82 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Color selection by mouse (collision detection)
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+NUM_RECTANGLES = 21
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - color selection (collision detection)")
+
+local colors = { DARKGRAY, MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, DARKBROWN,
+                 GRAY, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK, YELLOW,
+                 GREEN, SKYBLUE, PURPLE, BEIGE }
+
+local colorsRecs = {}               -- Rectangles array
+local selected = {}
+
+-- Fills colorsRecs data (for every rectangle)
+for i = 1, NUM_RECTANGLES do
+    colorsRecs[i] = Rectangle(0, 0, 0, 0)
+    colorsRecs[i].x = 20 + 100*((i-1)%7) + 10*((i-1)%7)
+    colorsRecs[i].y = 60 + 100*((i-1)//7) + 10*((i-1)//7)   -- Using floor division: //
+    colorsRecs[i].width = 100
+    colorsRecs[i].height = 100
+    selected[i] = false
+end
+
+local mousePoint = Vector2(0, 0)
+
+SetTargetFPS(60)               -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    mousePoint = GetMousePosition()
+
+    for i = 1, NUM_RECTANGLES do    -- Iterate along all the rectangles
+        if (CheckCollisionPointRec(mousePoint, colorsRecs[i])) then
+            colors[i].a = 120
+            if (IsMouseButtonPressed(MOUSE.LEFT_BUTTON)) then selected[i] = not selected[i] end
+        else colors[i].a = 255 end
+    end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        for i = 1, NUM_RECTANGLES do    -- Draw all rectangles
+            DrawRectangleRec(colorsRecs[i], colors[i])
+
+            -- Draw four rectangles around selected rectangle
+            if (selected[i]) then
+                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
+            end
+        end
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()                -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/core_drop_files.lua

@@ -0,0 +1,66 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Windows drop files
+--
+--  This example only works on platforms that support drag & drop (Windows, Linux, OSX)
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - drop files")
+
+local count = 0
+local droppedFiles = {}
+
+SetTargetFPS(60)
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    if (IsFileDropped()) then 
+        droppedFiles = GetDroppedFiles() 
+        count = #droppedFiles
+    end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        if (count == 0) then DrawText("Drop your files to this window!", 100, 40, 20, DARKGRAY)
+        else
+            DrawText("Dropped files:", 100, 40, 20, DARKGRAY)
+            
+            for i = 0, count-1 do
+                if (i%2 == 0) then DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.5))
+                else DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.3)) end
+                
+                DrawText(droppedFiles[i+1], 120, 100 + 40*i, 10, GRAY)
+            end
+            
+            DrawText("Drop new files...", 100, 110 + 40*count, 20, DARKGRAY)
+        end
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+ClearDroppedFiles()    -- Clear internal buffers
+
+CloseWindow()          -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/core_gestures_detection.lua

@@ -0,0 +1,102 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Gestures Detection
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+MAX_GESTURE_STRINGS = 20
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - gestures detection")
+
+local touchPosition = Vector2(0, 0)
+local touchArea = Rectangle(220, 10, screenWidth - 230, screenHeight - 20)
+
+local gesturesCount = 0
+local gestureStrings = {}
+
+for i = 1, MAX_GESTURE_STRINGS do gestureStrings[i] = "" end
+
+local currentGesture = Gestures.NONE
+local lastGesture = Gestures.NONE
+
+--SetGesturesEnabled(0b0000000000001001)   -- Enable only some gestures to be detected
+
+SetTargetFPS(60)
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    lastGesture = currentGesture
+    currentGesture = GetGestureDetected()
+    touchPosition = GetTouchPosition(0)
+
+    if (CheckCollisionPointRec(touchPosition, touchArea) and (currentGesture ~= Gestures.NONE)) then
+        if (currentGesture ~= lastGesture) then
+            -- Store gesture string
+            if (currentGesture == Gestures.TAP) then gestureStrings[gesturesCount] = "GESTURE TAP"
+            elseif (currentGesture == Gestures.DOUBLETAP) then gestureStrings[gesturesCount] = "GESTURE DOUBLETAP"
+            elseif (currentGesture == Gestures.HOLD) then gestureStrings[gesturesCount] = "GESTURE HOLD"
+            elseif (currentGesture == Gestures.DRAG) then gestureStrings[gesturesCount] = "GESTURE DRAG"
+            elseif (currentGesture == Gestures.SWIPE_RIGHT) then gestureStrings[gesturesCount] = "GESTURE SWIPE RIGHT"
+            elseif (currentGesture == Gestures.SWIPE_LEFT) then gestureStrings[gesturesCount] = "GESTURE SWIPE LEFT"
+            elseif (currentGesture == Gestures.SWIPE_UP) then gestureStrings[gesturesCount] = "GESTURE SWIPE UP"
+            elseif (currentGesture == Gestures.SWIPE_DOWN) then gestureStrings[gesturesCount] = "GESTURE SWIPE DOWN"
+            elseif (currentGesture == Gestures.PINCH_IN) then gestureStrings[gesturesCount] = "GESTURE PINCH IN"
+            elseif (currentGesture == Gestures.PINCH_OUT) then gestureStrings[gesturesCount] = "GESTURE PINCH OUT"
+            end
+            
+            gesturesCount = gesturesCount + 1
+            
+            -- Reset gestures strings
+            if (gesturesCount >= MAX_GESTURE_STRINGS) then
+                for i = 1, MAX_GESTURE_STRINGS do gestureStrings[i] = "\0" end
+                gesturesCount = 0
+            end
+        end
+    end
+    ---------------------------------------------------------------------------------------
+
+    -- 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.5))
+        
+        for i = 1, gesturesCount do
+            if ((i - 1)%2 == 0) then DrawRectangle(10, 30 + 20*(i - 1), 200, 20, Fade(LIGHTGRAY, 0.5))
+            else DrawRectangle(10, 30 + 20*(i - 1), 200, 20, Fade(LIGHTGRAY, 0.3)) end
+            
+            if (i < gesturesCount) then DrawText(gestureStrings[i], 35, 36 + 20*(i - 1), 10, DARKGRAY)
+            else DrawText(gestureStrings[i], 35, 36 + 20*(i - 1), 10, MAROON) end
+        end
+        
+        DrawRectangleLines(10, 29, 200, screenHeight - 50, GRAY)
+        DrawText("DETECTED GESTURES", 50, 15, 10, GRAY)
+        
+        if (currentGesture ~= GESTURE_NONE) then DrawCircleV(touchPosition, 30, MAROON) end
+        
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/core_input_gamepad.lua

@@ -0,0 +1,63 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Gamepad input
+--
+--  NOTE: This example requires a Gamepad connected to the system
+--        raylib is configured to work with Xbox 360 gamepad, 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) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - gamepad input")
+
+local ballPosition = Vector2(screenWidth/2, screenHeight/2)
+local gamepadMovement = Vector2(0, 0)
+
+SetTargetFPS(60)                   -- Set target frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    if (IsGamepadAvailable(GAMEPAD.PLAYER1)) then
+        gamepadMovement.x = GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_LEFT_X)
+        gamepadMovement.y = GetGamepadAxisMovement(GAMEPAD.PLAYER1, GAMEPAD.XBOX_AXIS_LEFT_Y)
+
+        ballPosition.x = ballPosition.x + gamepadMovement.x
+        ballPosition.y = ballPosition.y - gamepadMovement.y
+
+        if (IsGamepadButtonPressed(GAMEPAD.PLAYER1, GAMEPAD.BUTTON_A)) then
+            ballPosition.x = screenWidth/2
+            ballPosition.y = screenHeight/2
+        end
+    end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawText("move the ball with gamepad", 10, 10, 20, DARKGRAY)
+
+        DrawCircleV(ballPosition, 50, MAROON)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/core_input_keys.lua

@@ -0,0 +1,51 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Keyboard input
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window")
+
+local ballPosition = Vector2(screenWidth/2, screenHeight/2)
+
+SetTargetFPS(60)                -- Set target frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do                -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    if (IsKeyDown(KEY.RIGHT)) then ballPosition.x = ballPosition.x + 0.8 end
+    if (IsKeyDown(KEY.LEFT)) then ballPosition.x = ballPosition.x - 0.8 end
+    if (IsKeyDown(KEY.UP)) then ballPosition.y = ballPosition.y - 0.8 end
+    if (IsKeyDown(KEY.DOWN)) then ballPosition.y = ballPosition.y + 0.8 end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawText("move the ball with arrow keys", 10, 10, 20, DARKGRAY)
+
+        DrawCircleV(ballPosition, 50, MAROON)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()           -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/core_input_mouse.lua

@@ -0,0 +1,54 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Mouse input
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input")
+
+local ballPosition = Vector2(-100.0, -100.0)
+local ballColor = DARKBLUE
+
+SetTargetFPS(60)                    -- Set target frames-per-second
+-----------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ------------------------------------------------------------------------------------
+    ballPosition = GetMousePosition()
+    
+    if (IsMouseButtonPressed(MOUSE.LEFT_BUTTON)) then ballColor = MAROON
+    elseif (IsMouseButtonPressed(MOUSE.MIDDLE_BUTTON)) then ballColor = LIME
+    elseif (IsMouseButtonPressed(MOUSE.RIGHT_BUTTON)) then ballColor = DARKBLUE
+    end
+    ------------------------------------------------------------------------------------
+
+    -- 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()
+    ------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+----------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+----------------------------------------------------------------------------------------

examples/core_mouse_wheel.lua

@@ -0,0 +1,50 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] examples - Mouse wheel
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse wheel")
+
+local boxPositionY = screenHeight/2 - 40
+local scrollSpeed = 4               -- Scrolling speed in pixels
+
+SetTargetFPS(60)                    -- Set target frames-per-second
+----------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ------------------------------------------------------------------------------------
+    boxPositionY = 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(string.format("Box position Y: %03i", boxPositionY), 10, 40, 20, LIGHTGRAY)
+
+    EndDrawing()
+    ------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+----------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+----------------------------------------------------------------------------------------

examples/core_oculus_rift.lua

@@ -0,0 +1,73 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Oculus Rift CV1
+--
+--  NOTE: Example requires linkage with LibOVR
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 1080
+local screenHeight = 600
+
+-- NOTE: screenWidth/screenHeight should match VR device aspect ratio
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - oculus rift")
+
+-- NOTE: If device is not available, it fallbacks to default device (simulator)
+InitVrDevice(VrDevice.OCULUS_RIFT_CV1)      -- Init VR device (Oculus Rift CV1)
+
+-- Define the camera to look into our 3d world
+local camera = {}
+camera.position = Vector3(5.0, 5.0, 5.0)    -- Camera position
+camera.target = Vector3(0.0, 0.0, 0.0)      -- Camera looking at point
+camera.up = Vector3(0.0, 1.0, 0.0)          -- Camera up vector (rotation towards target)
+camera.fovy = 60.0                          -- Camera field-of-view Y
+
+local cubePosition = Vector3(0.0, 0.0, 0.0)
+
+SetTargetFPS(90)                    -- Set our game to run at 90 frames-per-second
+----------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ------------------------------------------------------------------------------------
+    UpdateVrTracking()
+    
+    if (IsKeyPressed(KEY.SPACE)) then ToggleVrMode() end
+    ------------------------------------------------------------------------------------
+
+    -- Draw
+    ------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)
+
+            DrawCube(cubePosition, 2.0, 2.0, 2.0, RED)
+            DrawCubeWires(cubePosition, 2.0, 2.0, 2.0, MAROON)
+
+            DrawGrid(10, 1.0)
+
+        End3dMode()
+
+        DrawFPS(10, 10)
+
+    EndDrawing()
+    ------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+----------------------------------------------------------------------------------------
+CloseVrDevice()        -- Close VR device
+
+CloseWindow()          -- Close window and OpenGL context
+----------------------------------------------------------------------------------------

examples/core_random_values.lua

@@ -0,0 +1,56 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Generate random values
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - generate random values")
+
+local framesCounter = 0  -- Variable used to count frames
+
+local 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 not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ------------------------------------------------------------------------------------
+    framesCounter = framesCounter + 1
+
+    -- Every two seconds (120 frames) a new random value is generated
+    if (((framesCounter/120)%2) == 1) then
+        randValue = GetRandomValue(-8, 5)
+        framesCounter = 0
+    end
+    ------------------------------------------------------------------------------------
+
+    -- Draw
+    ------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawText("Every 2 seconds a new random value is generated:", 130, 100, 20, MAROON)
+
+        DrawText(string.format("%i", randValue), 360, 180, 80, LIGHTGRAY)
+
+    EndDrawing()
+    ------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+----------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+----------------------------------------------------------------------------------------

examples/core_storage_values.lua

@@ -0,0 +1,74 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - Storage save/load values
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- NOTE: Storage positions must start with 0, directly related to file memory layout
+STORAGE_SCORE = 0 
+STORAGE_HISCORE = 1
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - storage save/load values")
+
+local score = 0
+local hiscore = 0
+
+local framesCounter = 0
+
+SetTargetFPS(60)       -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    if (IsKeyPressed(KEY.R)) then
+        score = GetRandomValue(1000, 2000)
+        hiscore = GetRandomValue(2000, 4000)
+    end
+    
+    if (IsKeyPressed(KEY.ENTER)) then
+        StorageSaveValue(STORAGE_SCORE, score)
+        StorageSaveValue(STORAGE_HISCORE, hiscore)
+    elseif (IsKeyPressed(KEY.SPACE)) then
+        -- NOTE: If requested position could not be found, value 0 is returned
+        score = StorageLoadValue(STORAGE_SCORE)
+        hiscore = StorageLoadValue(STORAGE_HISCORE)
+    end
+    
+    framesCounter = framesCounter + 1
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawText(string.format("SCORE: %i", score), 280, 130, 40, MAROON)
+        DrawText(string.format("HI-SCORE: %i", hiscore), 210, 200, 50, BLACK)
+        
+        DrawText(string.format("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()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/core_world_screen.lua

@@ -0,0 +1,69 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [core] example - World to screen
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free")
+
+-- Define the camera to look into our 3d world
+local camera = Camera(Vector3(0.0, 10.0, 10.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
+
+local cubePosition = Vector3(0.0, 0.0, 0.0)
+
+local cubeScreenPosition = Vector2(0, 0)
+
+SetCameraMode(CameraMode.FREE)          -- Set a free camera mode
+SetCameraPosition(camera.position)      -- Set internal camera position to match our camera position
+SetCameraTarget(camera.target)          -- Set internal camera target to match our camera target
+SetCameraFovy(camera.fovy)              -- Set internal camera field-of-view Y
+
+SetTargetFPS(60)                        -- Set our game to run at 60 frames-per-second
+----------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do        -- Detect window close button or ESC key
+    -- Update
+    ------------------------------------------------------------------------------------
+    camera = UpdateCamera(camera)       -- Update internal camera and our camera
+    
+    -- Calculate cube screen space position (with a little offset to be in top)
+    cubeScreenPosition = GetWorldToScreen(Vector3(cubePosition.x, cubePosition.y + 2.5, cubePosition.z), camera)
+    ------------------------------------------------------------------------------------
+
+    -- Draw
+    ------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)
+
+            DrawCube(cubePosition, 2.0, 2.0, 2.0, RED)
+            DrawCubeWires(cubePosition, 2.0, 2.0, 2.0, MAROON)
+
+            DrawGrid(10, 1.0)
+
+        End3dMode()
+        
+        DrawText("Enemy: 100 / 100", cubeScreenPosition.x//1 - MeasureText("Enemy: 100 / 100", 20)//2, cubeScreenPosition.y//1, 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()
+    ------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+----------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+----------------------------------------------------------------------------------------

examples/models_billboard.lua

@@ -0,0 +1,65 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [models] example - Drawing billboards
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [models] example - drawing billboards")
+
+-- Define the camera to look into our 3d world
+local camera = Camera(Vector3(5.0, 4.0, 5.0), Vector3(0.0, 2.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
+
+local bill = LoadTexture("resources/billboard.png")     -- Our texture billboard
+local billPosition = Vector3(0.0, 2.0, 0.0)             -- Position where draw billboard
+
+SetCameraMode(CameraMode.ORBITAL)      -- Set an orbital camera mode
+SetCameraPosition(camera.position) -- Set internal camera position to match our camera position
+SetCameraTarget(camera.target)     -- Set internal camera target to match our camera target
+SetCameraFovy(camera.fovy)         -- Set internal camera field-of-view Y
+
+SetTargetFPS(60)                   -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    camera = UpdateCamera(camera)           -- Update internal camera and our camera
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)
+        
+            DrawBillboard(camera, bill, billPosition, 2.0, WHITE)
+            
+            DrawGrid(10, 1.0)        -- Draw a grid
+
+        End3dMode()
+
+        DrawFPS(10, 10)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(bill)        -- Unload texture
+
+CloseWindow()              -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/models_box_collisions.lua

@@ -0,0 +1,115 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [models] example - Detect basic 3d collisions (box vs sphere vs box)
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [models] example - box collisions")
+
+-- Define the camera to look into our 3d world
+local camera = Camera(Vector3(0.0, 10.0, 10.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
+
+local playerPosition = Vector3(0.0, 1.0, 2.0)
+local playerSize = Vector3(1.0, 2.0, 1.0)
+local playerColor = GREEN
+
+local enemyBoxPos = Vector3(-4.0, 1.0, 0.0)
+local enemyBoxSize = Vector3(2.0, 2.0, 2.0)
+
+local enemySpherePos = Vector3(4.0, 0.0, 0.0)
+local enemySphereSize = 1.5
+
+local collision = false
+
+SetTargetFPS(60)   -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    
+    -- Move player
+    if (IsKeyDown(KEY.RIGHT)) then playerPosition.x = playerPosition.x + 0.2
+    elseif (IsKeyDown(KEY.LEFT)) then playerPosition.x = playerPosition.x - 0.2
+    elseif (IsKeyDown(KEY.DOWN)) then playerPosition.z = playerPosition.z + 0.2
+    elseif (IsKeyDown(KEY.UP)) then playerPosition.z = playerPosition.z - 0.2 end
+    
+    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)))) then collision = true 
+    end
+    
+    -- 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)) then collision = true
+    end
+    
+    if (collision) then playerColor = RED
+    else playerColor = GREEN end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(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.0)        -- Draw a grid
+
+        End3dMode()
+        
+        DrawText("Move player with cursors to collide", 220, 40, 20, GRAY)
+
+        DrawFPS(10, 10)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/models_cubicmap.c

@@ -35,9 +35,7 @@ int main()
 
     UnloadImage(image);     // Unload cubesmap image from RAM, already uploaded to VRAM
     
-    SetCameraMode(CAMERA_ORBITAL);      // Set an orbital camera mode
+    SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
-    SetCameraPosition(camera.position); // Set internal camera position to match our custom camera position
-    SetCameraFovy(camera.fovy);         // Set internal camera field-of-view Y
 
     SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------

examples/models_cubicmap.lua

@@ -0,0 +1,79 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [models] example - Cubicmap loading and drawing
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [models] example - cubesmap loading and drawing")
+
+-- Define the camera to look into our 3d world
+local camera = Camera(Vector3(16.0, 14.0, 16.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
+
+local image = LoadImage("resources/cubicmap.png")      -- Load cubicmap image (RAM)
+local cubicmap = LoadTextureFromImage(image)           -- Convert image to texture to display (VRAM)
+local map = LoadCubicmap(image)                        -- Load cubicmap model (generate model from image)
+
+-- NOTE: By default each cube is mapped to one part of texture atlas
+local texture = LoadTexture("resources/cubicmap_atlas.png")    -- Load map texture
+map.material.texDiffuse = texture                      -- Set map diffuse texture
+
+local mapPosition = Vector3(-16.0, 0.0, -8.0)          -- Set model position
+
+UnloadImage(image)     -- Unload cubesmap image from RAM, already uploaded to VRAM
+
+SetCameraMode(CameraMode.ORBITAL)      -- Set an orbital camera mode
+SetCameraPosition(camera.position)     -- Set internal camera position to match our custom camera position
+SetCameraFovy(camera.fovy)             -- Set internal camera field-of-view Y
+
+SetTargetFPS(60)                       -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    camera = UpdateCamera(camera)           -- Update internal camera and our camera
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)
+
+            DrawModel(map, mapPosition, 1.0, WHITE)
+
+        End3dMode()
+        
+        DrawTextureEx(cubicmap, (Vector2)(screenWidth - cubicmap.width*4 - 20, 20), 0.0, 4.0, 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()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(cubicmap)    -- Unload cubicmap texture
+UnloadTexture(texture)     -- Unload map texture
+UnloadModel(map)           -- Unload map model
+
+CloseWindow()              -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/models_geometric_shapes.lua

@@ -0,0 +1,67 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [models] example - Draw some basic geometric shapes (cube, sphere, cylinder...)
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes")
+
+-- Define the camera to look into our 3d world
+local camera = Camera(Vector3(0.0, 10.0, 10.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
+
+SetTargetFPS(60)   -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update your variables here
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)  -- ERROR: Lua Error: attempt to index a number value
+
+            DrawCube(Vector3(-4.0, 0.0, 2.0), 2.0, 5.0, 2.0, RED)
+            DrawCubeWires(Vector3(-4.0, 0.0, 2.0), 2.0, 5.0, 2.0, GOLD)
+            DrawCubeWires(Vector3(-4.0, 0.0, -2.0), 3.0, 6.0, 2.0, MAROON)
+
+            DrawSphere(Vector3(-1.0, 0.0, -2.0), 1.0, GREEN)
+            DrawSphereWires(Vector3(1.0, 0.0, 2.0), 2.0, 16, 16, LIME)
+
+            DrawCylinder(Vector3(4.0, 0.0, -2.0), 1.0, 2.0, 3.0, 4, SKYBLUE)
+            DrawCylinderWires(Vector3(4.0, 0.0, -2.0), 1.0, 2.0, 3.0, 4, DARKBLUE)
+            DrawCylinderWires(Vector3(4.5, -1.0, 2.0), 1.0, 1.0, 2.0, 6, BROWN)
+
+            DrawCylinder(Vector3(1.0, 0.0, -4.0), 0.0, 1.5, 3.0, 8, GOLD)
+            DrawCylinderWires(Vector3(1.0, 0.0, -4.0), 0.0, 1.5, 3.0, 8, PINK)
+
+            DrawGrid(10, 1.0)        -- Draw a grid
+
+        End3dMode()
+
+        DrawFPS(10, 10)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/models_heightmap.lua

@@ -0,0 +1,73 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [models] example - Heightmap loading and drawing
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [models] example - heightmap loading and drawing")
+
+-- Define our custom camera to look into our 3d world
+local camera = Camera(Vector3(18.0, 16.0, 18.0), Vector3(0.0, 0.0, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
+
+local image = LoadImage("resources/heightmap.png")      -- Load heightmap image (RAM)
+local texture = LoadTextureFromImage(image)             -- Convert image to texture (VRAM)
+local map = LoadHeightmap(image, Vector3(16, 8, 16))    -- Load heightmap model with defined size
+map.material.texDiffuse = texture                       -- Set map diffuse texture
+local mapPosition = Vector3(-8.0, 0.0, -8.0)            -- Set model position (depends on model scaling!)
+
+UnloadImage(image)                 -- Unload heightmap image from RAM, already uploaded to VRAM
+
+SetCameraMode(CameraMode.ORBITAL)      -- Set an orbital camera mode
+SetCameraPosition(camera.position) -- Set internal camera position to match our custom camera position
+
+SetTargetFPS(60)                   -- Set our game to run at 60 frames-per-second
+----------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    camera = UpdateCamera(camera)           -- Update internal camera and our camera
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)
+
+            -- NOTE: Model is scaled to 1/4 of its original size (128x128 units)
+            DrawModel(map, mapPosition, 1.0, RED)
+
+            DrawGrid(20, 1.0)
+
+        End3dMode()
+        
+        DrawTexture(texture, screenWidth - texture.width - 20, 20, WHITE)
+        DrawRectangleLines(screenWidth - texture.width - 20, 20, texture.width, texture.height, GREEN)
+
+        DrawFPS(10, 10)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(texture)     -- Unload texture
+UnloadModel(map)           -- Unload model
+
+CloseWindow()              -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/models_obj_loading.lua

@@ -0,0 +1,67 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [models] example - Load and draw a 3d model (OBJ)
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [models] example - obj model loading")
+
+-- Define the camera to look into our 3d world
+local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
+
+local dwarf = LoadModel("resources/model/dwarf.obj")                -- Load OBJ model
+local texture = LoadTexture("resources/model/dwarf_diffuse.png")    -- Load model texture
+dwarf.material.texDiffuse = texture                                 -- Set dwarf model diffuse texture
+local position = Vector3(0.0, 0.0, 0.0)                             -- Set model position
+
+SetTargetFPS(60)        -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- ...
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)
+
+            DrawModel(dwarf, position, 2.0, WHITE)   -- Draw 3d model with texture
+
+            DrawGrid(10, 1.0)         -- Draw a grid
+
+            DrawGizmo(position)        -- Draw gizmo
+
+        End3dMode()
+        
+        DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY)
+
+        DrawFPS(10, 10)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(texture)     -- Unload texture
+UnloadModel(dwarf)         -- Unload model
+
+CloseWindow()              -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/physics_basic_rigidbody.c

@@ -5,9 +5,16 @@
 *   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)
 *
+*   NOTE:
+*   Physac requires multi-threading, when InitPhysics() a second thread is created to manage
+*   physics calculations. To accomplish that, physac uses pthread Win32 library that can be
+*   found inside raylib/src/external/pthread directory. 
 *
-*   Compile example using:
+*   Add pthread library when compiling physac example:
-*   cmd /c IF NOT EXIST pthreadGC2.dll copy C:\raylib\raylib\src\external\pthread\pthreadGC2.dll $(CURRENT_DIRECTORY) /Y
+*   gcc -o $(NAME_PART).exe $(FILE_NAME) $(RAYLIB_DIR)\raylib_icon -L../src/external/pthread/lib \
+*   -I../src -I../src/external/pthread/include -lraylib -lglfw3 -lopengl32 -lgdi32 -lpthreadGC2 -std=c99 -Wall
+*
+*   Note that pthreadGC2.dll must be also copied to project directory!
 *
 *   Copyright (c) 2016 Victor Fisac and Ramon Santamaria (@raysan5)
 *

examples/physics_forces.c

@@ -5,10 +5,16 @@
 *   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)
 *
-*   NOTE: This example requires raylib module [rlgl]
+*   NOTE:
+*   Physac requires multi-threading, when InitPhysics() a second thread is created to manage
+*   physics calculations. To accomplish that, physac uses pthread Win32 library that can be
+*   found inside raylib/src/external/pthread directory. 
 *
-*   Compile example using:
+*   Add pthread library when compiling physac example:
-*   cmd /c IF NOT EXIST pthreadGC2.dll copy C:\raylib\raylib\src\external\pthread\pthreadGC2.dll $(CURRENT_DIRECTORY) /Y
+*   gcc -o $(NAME_PART).exe $(FILE_NAME) $(RAYLIB_DIR)\raylib_icon -L../src/external/pthread/lib \
+*   -I../src -I../src/external/pthread/include -lraylib -lglfw3 -lopengl32 -lgdi32 -lpthreadGC2 -std=c99 -Wall
+*
+*   Note that pthreadGC2.dll must be also copied to project directory!
 *
 *   Copyright (c) 2016 Victor Fisac and Ramon Santamaria (@raysan5)
 *

examples/resources/shaders/glsl100/bloom.fs

@@ -8,30 +8,32 @@ varying vec4 fragColor;
 
 // Input uniform values
 uniform sampler2D texture0;
-uniform vec4 fragTintColor;
+uniform vec4 colDiffuse;
 
 // NOTE: Add here your custom variables
 
+const vec2 size = vec2(800, 450);   // render size
+const float samples = 5.0;          // pixels per axis; higher = bigger glow, worse performance
+const float quality = 2.5; 	        // lower = smaller glow, better quality
+
 void main()
 {
     vec4 sum = vec4(0);
-    vec4 tc = vec4(0);
+    vec2 sizeFactor = vec2(1)/size*quality;
-
-    for (int i = -4; i < 4; i++)
-    {
-        for (int j = -3; j < 3; j++)
-        {
-            sum += texture2D(texture0, fragTexCoord + vec2(j, i)*0.004) * 0.25;
-        }
-    }
 
     // Texel color fetching from texture sampler
-    vec4 texelColor = texture2D(texture0, fragTexCoord);
+    vec4 source = texture2D(texture0, fragTexCoord);
+
+    const int range = 2;            // should be = (samples - 1)/2;
+
+    for (int x = -range; x <= range; x++)
+    {
+        for (int y = -range; y <= range; y++)
+        {
+            sum += texture2D(texture0, fragTexCoord + vec2(x, y)*sizeFactor);
+        }
+    }
 
     // Calculate final fragment color
-    if (texelColor.r < 0.3) tc = sum*sum*0.012 + texelColor;
+    gl_FragColor = ((sum/(samples*samples)) + source)*colDiffuse;
-    else if (texelColor.r < 0.5) tc = sum*sum*0.009 + texelColor;
-    else tc = sum*sum*0.0075 + texelColor;
-    
-    gl_FragColor = tc;
 }

examples/resources/shaders/glsl100/standard.fs

@@ -0,0 +1,161 @@
+#version 100
+
+precision mediump float;
+
+varying vec3 fragPosition;
+varying vec2 fragTexCoord;
+varying vec4 fragColor;
+varying vec3 fragNormal;
+
+uniform sampler2D texture0;
+uniform sampler2D texture1;
+uniform sampler2D texture2;
+
+uniform vec4 colAmbient;
+uniform vec4 colDiffuse;
+uniform vec4 colSpecular;
+uniform float glossiness;
+
+uniform int useNormal;
+uniform int useSpecular;
+
+uniform mat4 modelMatrix;
+uniform vec3 viewDir;
+
+struct Light {
+    int enabled;
+    int type;
+    vec3 position;
+    vec3 direction;
+    vec4 diffuse;
+    float intensity;
+    float radius;
+    float coneAngle;
+};
+
+const int maxLights = 8;
+uniform Light lights[maxLights];
+
+vec3 ComputeLightPoint(Light l, vec3 n, vec3 v, float s)
+{
+/*
+    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1.0));
+    vec3 surfaceToLight = l.position - surfacePos;
+    
+    // Diffuse shading
+    float brightness = clamp(float(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n))), 0.0, 1.0);
+    float diff = 1.0/dot(surfaceToLight/l.radius, surfaceToLight/l.radius)*brightness*l.intensity;
+    
+    // Specular shading
+    float spec = 0.0;
+    if (diff > 0.0)
+    {
+        vec3 h = normalize(-l.direction + v);
+        spec = pow(dot(n, h), 3.0 + glossiness)*s;
+    }
+    
+    return (diff*l.diffuse.rgb + spec*colSpecular.rgb);
+*/
+    return vec3(0.5);
+}
+
+vec3 ComputeLightDirectional(Light l, vec3 n, vec3 v, float s)
+{
+/*
+    vec3 lightDir = normalize(-l.direction);
+    
+    // Diffuse shading
+    float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
+    
+    // Specular shading
+    float spec = 0.0;
+    if (diff > 0.0)
+    {
+        vec3 h = normalize(lightDir + v);
+        spec = pow(dot(n, h), 3.0 + glossiness)*s;
+    }
+    
+    // Combine results
+    return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);
+*/
+    return vec3(0.5);
+}
+
+vec3 ComputeLightSpot(Light l, vec3 n, vec3 v, float s)
+{
+/*
+    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
+    vec3 lightToSurface = normalize(surfacePos - l.position);
+    vec3 lightDir = normalize(-l.direction);
+    
+    // Diffuse shading
+    float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
+    
+    // Spot attenuation
+    float attenuation = clamp(float(dot(n, lightToSurface)), 0.0, 1.0);
+    attenuation = dot(lightToSurface, -lightDir);
+    
+    float lightToSurfaceAngle = degrees(acos(attenuation));
+    if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;
+    
+    float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;
+    
+    // Combine diffuse and attenuation
+    float diffAttenuation = diff*attenuation;
+    
+    // Specular shading
+    float spec = 0.0;
+    if (diffAttenuation > 0.0)
+    {
+        vec3 h = normalize(lightDir + v);
+        spec = pow(dot(n, h), 3.0 + glossiness)*s;
+    }
+    
+    return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
+*/
+    return vec3(0.5);
+}
+
+void main()
+{
+    // Calculate fragment normal in screen space
+    // NOTE: important to multiply model matrix by fragment normal to apply model transformation (rotation and scale)
+    mat3 normalMatrix = mat3(modelMatrix);
+    vec3 normal = normalize(normalMatrix*fragNormal);
+
+    // Normalize normal and view direction vectors
+    vec3 n = normalize(normal);
+    vec3 v = normalize(viewDir);
+
+    // Calculate diffuse texture color fetching
+    vec4 texelColor = texture2D(texture0, fragTexCoord);
+    vec3 lighting = colAmbient.rgb;
+    
+    // Calculate normal texture color fetching or set to maximum normal value by default
+    if (useNormal == 1)
+    {
+        n *= texture2D(texture1, fragTexCoord).rgb;
+        n = normalize(n);
+    }
+    
+    // Calculate specular texture color fetching or set to maximum specular value by default
+    float spec = 1.0;
+    if (useSpecular == 1) spec *= normalize(texture2D(texture2, fragTexCoord).r);
+    
+    for (int i = 0; i < maxLights; i++)
+    {
+        // Check if light is enabled
+        if (lights[i].enabled == 1)
+        {
+            // Calculate lighting based on light type
+            if(lights[i].type == 0) lighting += ComputeLightPoint(lights[i], n, v, spec);
+            else if(lights[i].type == 1) lighting += ComputeLightDirectional(lights[i], n, v, spec);
+            else if(lights[i].type == 2) lighting += ComputeLightSpot(lights[i], n, v, spec);
+            
+            // NOTE: It seems that too many ComputeLight*() operations inside for loop breaks the shader on RPI
+        }
+    }
+    
+    // Calculate final fragment color
+    gl_FragColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a);
+}

examples/resources/shaders/glsl100/standard.vs

@@ -0,0 +1,23 @@
+#version 100
+
+attribute vec3 vertexPosition;
+attribute vec3 vertexNormal;
+attribute vec2 vertexTexCoord;
+attribute vec4 vertexColor;
+
+varying vec3 fragPosition;
+varying vec2 fragTexCoord;
+varying vec4 fragColor;
+varying vec3 fragNormal;
+
+uniform mat4 mvpMatrix;
+
+void main()
+{
+    fragPosition = vertexPosition;
+    fragTexCoord = vertexTexCoord;
+    fragColor = vertexColor;
+    fragNormal = vertexNormal;
+
+    gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
+}

examples/resources/shaders/glsl330/bloom.fs

@@ -6,33 +6,35 @@ in vec4 fragColor;
 
 // Input uniform values
 uniform sampler2D texture0;
-uniform vec4 fragTintColor;
+uniform vec4 colDiffuse;
 
 // Output fragment color
 out vec4 finalColor;
 
 // NOTE: Add here your custom variables
 
+const vec2 size = vec2(800, 450);   // render size
+const float samples = 5.0;          // pixels per axis; higher = bigger glow, worse performance
+const float quality = 2.5; 	        // lower = smaller glow, better quality
+
 void main()
 {
     vec4 sum = vec4(0);
-    vec4 tc = vec4(0);
+    vec2 sizeFactor = vec2(1)/size*quality;
-
-    for (int i = -4; i < 4; i++)
-    {
-        for (int j = -3; j < 3; j++)
-        {
-            sum += texture(texture0, fragTexCoord + vec2(j, i)*0.004)*0.25;
-        }
-    }
 
     // Texel color fetching from texture sampler
-    vec4 texelColor = texture(texture0, fragTexCoord);
+    vec4 source = texture(texture0, fragTexCoord);
+
+    const int range = 2;            // should be = (samples - 1)/2;
+
+    for (int x = -range; x <= range; x++)
+    {
+        for (int y = -range; y <= range; y++)
+        {
+            sum += texture(texture0, fragTexCoord + vec2(x, y)*sizeFactor);
+        }
+    }
 
     // Calculate final fragment color
-    if (texelColor.r < 0.3) tc = sum*sum*0.012 + texelColor;
+    finalColor = ((sum/(samples*samples)) + source)*colDiffuse;
-    else if (texelColor.r < 0.5) tc = sum*sum*0.009 + texelColor;
-    else tc = sum*sum*0.0075 + texelColor;
-
-    finalColor = tc;
 }

examples/resources/shaders/glsl330/standard.fs

@@ -0,0 +1,150 @@
+#version 330
+
+in vec3 fragPosition;
+in vec2 fragTexCoord;
+in vec4 fragColor;
+in vec3 fragNormal;
+
+out vec4 finalColor;
+
+uniform sampler2D texture0;
+uniform sampler2D texture1;
+uniform sampler2D texture2;
+
+uniform vec4 colAmbient;
+uniform vec4 colDiffuse;
+uniform vec4 colSpecular;
+uniform float glossiness;
+
+uniform int useNormal;
+uniform int useSpecular;
+
+uniform mat4 modelMatrix;
+uniform vec3 viewDir;
+
+struct Light {
+    int enabled;
+    int type;
+    vec3 position;
+    vec3 direction;
+    vec4 diffuse;
+    float intensity;
+    float radius;
+    float coneAngle;
+};
+
+const int maxLights = 8;
+uniform Light lights[maxLights];
+
+vec3 ComputeLightPoint(Light l, vec3 n, vec3 v, float s)
+{
+    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
+    vec3 surfaceToLight = l.position - surfacePos;
+    
+    // Diffuse shading
+    float brightness = clamp(float(dot(n, surfaceToLight)/(length(surfaceToLight)*length(n))), 0.0, 1.0);
+    float diff = 1.0/dot(surfaceToLight/l.radius, surfaceToLight/l.radius)*brightness*l.intensity;
+    
+    // Specular shading
+    float spec = 0.0;
+    if (diff > 0.0)
+    {
+        vec3 h = normalize(-l.direction + v);
+        spec = pow(dot(n, h), 3.0 + glossiness)*s;
+    }
+    
+    return (diff*l.diffuse.rgb + spec*colSpecular.rgb);
+}
+
+vec3 ComputeLightDirectional(Light l, vec3 n, vec3 v, float s)
+{
+    vec3 lightDir = normalize(-l.direction);
+    
+    // Diffuse shading
+    float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
+    
+    // Specular shading
+    float spec = 0.0;
+    if (diff > 0.0)
+    {
+        vec3 h = normalize(lightDir + v);
+        spec = pow(dot(n, h), 3.0 + glossiness)*s;
+    }
+    
+    // Combine results
+    return (diff*l.intensity*l.diffuse.rgb + spec*colSpecular.rgb);
+}
+
+vec3 ComputeLightSpot(Light l, vec3 n, vec3 v, float s)
+{
+    vec3 surfacePos = vec3(modelMatrix*vec4(fragPosition, 1));
+    vec3 lightToSurface = normalize(surfacePos - l.position);
+    vec3 lightDir = normalize(-l.direction);
+    
+    // Diffuse shading
+    float diff = clamp(float(dot(n, lightDir)), 0.0, 1.0)*l.intensity;
+    
+    // Spot attenuation
+    float attenuation = clamp(float(dot(n, lightToSurface)), 0.0, 1.0);
+    attenuation = dot(lightToSurface, -lightDir);
+    
+    float lightToSurfaceAngle = degrees(acos(attenuation));
+    if (lightToSurfaceAngle > l.coneAngle) attenuation = 0.0;
+    
+    float falloff = (l.coneAngle - lightToSurfaceAngle)/l.coneAngle;
+    
+    // Combine diffuse and attenuation
+    float diffAttenuation = diff*attenuation;
+    
+    // Specular shading
+    float spec = 0.0;
+    if (diffAttenuation > 0.0)
+    {
+        vec3 h = normalize(lightDir + v);
+        spec = pow(dot(n, h), 3.0 + glossiness)*s;
+    }
+    
+    return (falloff*(diffAttenuation*l.diffuse.rgb + spec*colSpecular.rgb));
+}
+
+void main()
+{
+    // Calculate fragment normal in screen space
+    // NOTE: important to multiply model matrix by fragment normal to apply model transformation (rotation and scale)
+    mat3 normalMatrix = mat3(modelMatrix);
+    vec3 normal = normalize(normalMatrix*fragNormal);
+
+    // Normalize normal and view direction vectors
+    vec3 n = normalize(normal);
+    vec3 v = normalize(viewDir);
+
+    // Calculate diffuse texture color fetching
+    vec4 texelColor = texture(texture0, fragTexCoord);
+    vec3 lighting = colAmbient.rgb;
+    
+    // Calculate normal texture color fetching or set to maximum normal value by default
+    if (useNormal == 1)
+    {
+        n *= texture(texture1, fragTexCoord).rgb;
+        n = normalize(n);
+    }
+    
+    // Calculate specular texture color fetching or set to maximum specular value by default
+    float spec = 1.0;
+    if (useSpecular == 1) spec *= normalize(texture(texture2, fragTexCoord).r);
+    
+    for (int i = 0; i < maxLights; i++)
+    {
+        // Check if light is enabled
+        if (lights[i].enabled == 1)
+        {
+            // Calculate lighting based on light type
+            if (lights[i].type == 0) lighting += ComputeLightPoint(lights[i], n, v, spec);
+            else if (lights[i].type == 1) lighting += ComputeLightDirectional(lights[i], n, v, spec);
+            else if (lights[i].type == 2) lighting += ComputeLightSpot(lights[i], n, v, spec);
+        }
+    }
+    
+    // Calculate final fragment color
+    finalColor = vec4(texelColor.rgb*lighting*colDiffuse.rgb, texelColor.a*colDiffuse.a);
+}

examples/resources/shaders/glsl330/standard.vs

@@ -0,0 +1,23 @@
+#version 330 
+
+in vec3 vertexPosition;
+in vec3 vertexNormal;
+in vec2 vertexTexCoord;
+in vec4 vertexColor;
+
+out vec3 fragPosition;
+out vec2 fragTexCoord;
+out vec4 fragColor;
+out vec3 fragNormal;
+
+uniform mat4 mvpMatrix;
+
+void main()
+{
+    fragPosition = vertexPosition;
+    fragTexCoord = vertexTexCoord;
+    fragColor = vertexColor;
+    fragNormal = vertexNormal;
+
+    gl_Position = mvpMatrix*vec4(vertexPosition, 1.0);
+}

examples/rlua_execute_file.c

@@ -0,0 +1,90 @@
+/*******************************************************************************************
+*
+*   raylib [rlua] example - Lua file execution
+*
+*   NOTE: This example requires Lua library (http://luabinaries.sourceforge.net/download.html)
+*
+*   Compile example using:
+*   gcc -o $(NAME_PART).exe $(FILE_NAME) $(RAYLIB_DIR)\raylib_icon          /
+*       -I../src -I../src/external/lua/include -L../src/external/lua/lib    /
+*       -lraylib -lglfw3 -lopengl32 -lopenal32 -llua53 -lgdi32 -std=c99
+*
+*   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)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+
+#define RLUA_IMPLEMENTATION
+#include "rlua.h"
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    InitLuaDevice();
+    //--------------------------------------------------------------------------------------
+
+    // ExecuteLuaFile("core_basic_window.lua");                 // OK!
+    // ExecuteLuaFile("core_input_keys.lua");                   // OK!
+    // ExecuteLuaFile("core_input_mouse.lua");                  // OK!
+    // ExecuteLuaFile("core_mouse_wheel.lua");                  // OK!
+    // ExecuteLuaFile("core_input_gamepad.lua");                // OK!
+    // ExecuteLuaFile("core_random_values.lua");                // OK!
+    // ExecuteLuaFile("core_color_select.lua");                 // OK!
+    // ExecuteLuaFile("core_drop_files.lua");                   // OK!
+    // ExecuteLuaFile("core_storage_values.lua");               // OK!
+    // ExecuteLuaFile("core_gestures_detection.lua");           // OK!
+    // ExecuteLuaFile("core_3d_mode.lua");                      // OK!
+    // ExecuteLuaFile("core_3d_picking.lua");                   // OK!
+    // ExecuteLuaFile("core_3d_camera_free.lua");               // OK!
+    // ExecuteLuaFile("core_3d_camera_first_person.lua");       // OK!
+    // ExecuteLuaFile("core_2d_camera.lua");                    // OK!
+    // ExecuteLuaFile("core_world_screen.lua");                 // OK!
+    // ExecuteLuaFile("core_oculus_rift.lua");                  // OK!
+    // ExecuteLuaFile("shapes_logo_raylib.lua");                // OK!
+    // ExecuteLuaFile("shapes_basic_shapes.lua");               // OK!
+    // ExecuteLuaFile("shapes_colors_palette.lua");             // OK!
+    // ExecuteLuaFile("shapes_logo_raylib_anim.lua");           // OK! NOTE: Use lua string.sub() instead of raylib SubText()
+    // ExecuteLuaFile("textures_logo_raylib.lua");              // OK!
+    // ExecuteLuaFile("textures_image_loading.lua");            // OK!
+    // ExecuteLuaFile("textures_rectangle.lua");                // OK!
+    // ExecuteLuaFile("textures_srcrec_dstrec.lua");            // OK!
+    // ExecuteLuaFile("textures_to_image.lua");                 // OK!
+    // ExecuteLuaFile("textures_raw_data.lua");                 // ERROR: LoadImageEx()
+    // ExecuteLuaFile("textures_formats_loading.lua");          // OK!
+    // ExecuteLuaFile("textures_particles_trail_blending.lua"); // OK!
+    // ExecuteLuaFile("textures_image_processing.lua");         // ERROR: GetImageData() --> UpdateTexture()
+    // ExecuteLuaFile("textures_image_drawing.lua");            // OK!
+    // ExecuteLuaFile("text_sprite_fonts.lua");                 // OK!
+    // ExecuteLuaFile("text_bmfont_ttf.lua");                   // OK!
+    // ExecuteLuaFile("text_rbmf_fonts.lua");                   // OK!
+    // ExecuteLuaFile("text_format_text.lua");                  // OK! NOTE: Use lua string.format() instead of raylib FormatText()
+    // ExecuteLuaFile("text_font_select.lua");                  // OK!
+    // ExecuteLuaFile("text_writing_anim.lua");                 // OK!
+    // ExecuteLuaFile("models_geometric_shapes.lua");           // OK!
+    // ExecuteLuaFile("models_box_collisions.lua");             // OK!
+    // ExecuteLuaFile("models_billboard.lua");                  // OK!
+    // ExecuteLuaFile("models_obj_loading.lua");                // OK!
+    // ExecuteLuaFile("models_heightmap.lua");                  // OK!
+    // ExecuteLuaFile("models_cubicmap.lua");                   // OK!
+    // ExecuteLuaFile("shaders_model_shader.lua");              // OK!
+    // ExecuteLuaFile("shaders_shapes_textures.lua");           // OK!
+    // ExecuteLuaFile("shaders_custom_uniform.lua");            // OK!
+    // ExecuteLuaFile("shaders_postprocessing.lua");            // OK!
+    // ExecuteLuaFile("shaders_standard_lighting.lua");         // OK!
+    // ExecuteLuaFile("audio_sound_loading.lua");               // OK!
+    // ExecuteLuaFile("audio_music_stream.lua");                // OK!
+    // ExecuteLuaFile("audio_module_playing.lua");              // OK!
+    // ExecuteLuaFile("audio_raw_stream.lua");                  // ERROR: UpdateAudioStream()
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    CloseLuaDevice();        // Close Lua device and free resources
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}

examples/shaders_custom_uniform.lua

@@ -0,0 +1,115 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [shaders] example - Apply a postprocessing shader and connect a custom uniform variable
+--
+--  NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
+--        OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
+--
+--  NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
+--        on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
+--        raylib comes with shaders ready for both versions, check raylib/shaders install folder
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+SetConfigFlags(FLAG.MSAA_4X_HINT)      -- Enable Multi Sampling Anti Aliasing 4x (if available)
+
+InitWindow(screenWidth, screenHeight, "raylib [shaders] example - custom uniform variable")
+
+-- Define the camera to look into our 3d world
+local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
+
+local dwarf = LoadModel("resources/model/dwarf.obj")                   -- Load OBJ model
+local texture = LoadTexture("resources/model/dwarf_diffuse.png")       -- Load model texture (diffuse map)
+dwarf.material.texDiffuse = texture                                    -- Set dwarf model diffuse texture
+
+local position = Vector3(0.0, 0.0, 0.0)                                -- Set model position
+
+local shader = LoadShader("resources/shaders/glsl330/base.vs", 
+                          "resources/shaders/glsl330/swirl.fs")        -- Load postpro shader
+
+-- Get variable (uniform) location on the shader to connect with the program
+-- NOTE: If uniform variable could not be found in the shader, function returns -1
+local swirlCenterLoc = GetShaderLocation(shader, "center")
+
+local swirlCenter = { screenWidth/2, screenHeight/2 }
+
+-- Create a RenderTexture2D to be used for render to texture
+local target = LoadRenderTexture(screenWidth, screenHeight)
+
+-- Setup orbital camera
+SetCameraMode(CameraMode.ORBITAL)          -- Set an orbital camera mode
+SetCameraPosition(camera.position)     -- Set internal camera position to match our camera position
+SetCameraTarget(camera.target)         -- Set internal camera target to match our camera target
+
+SetTargetFPS(60)                       -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do       -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    local mousePosition = GetMousePosition()
+
+    swirlCenter[1] = mousePosition.x
+    swirlCenter[2] = screenHeight - mousePosition.y
+
+    -- Send new value to the shader to be used on drawing
+    SetShaderValue(shader, swirlCenterLoc, swirlCenter)
+    
+    camera = UpdateCamera(camera)      -- Update internal camera and our camera
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+        
+        BeginTextureMode(target)       -- Enable drawing to texture
+
+            Begin3dMode(camera)
+
+                DrawModel(dwarf, position, 2.0, WHITE)   -- Draw 3d model with texture
+
+                DrawGrid(10, 1.0)     -- Draw a grid
+
+            End3dMode()
+            
+            DrawText("TEXT DRAWN IN RENDER TEXTURE", 200, 10, 30, RED)
+        
+        EndTextureMode()           -- End drawing to texture (now we have a texture available for next passes)
+        
+        BeginShaderMode(shader)
+        
+            -- NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom)
+            DrawTextureRec(target.texture, Rectangle(0, 0, target.texture.width, -target.texture.height), Vector2(0, 0), WHITE)
+        
+        EndShaderMode()
+        
+        DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY)
+
+        DrawFPS(10, 10)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadShader(shader)           -- Unload shader
+UnloadTexture(texture)         -- Unload texture
+UnloadModel(dwarf)             -- Unload model
+UnloadRenderTexture(target)    -- Unload render texture
+
+CloseWindow()                  -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/shaders_model_shader.c

@@ -42,10 +42,7 @@ int main()
     
     Vector3 position = { 0.0f, 0.0f, 0.0f };    // Set model position
     
-    // Setup orbital camera
+    SetCameraMode(camera, CAMERA_ORBITAL);      // Set an orbital camera mode
-    SetCameraMode(CAMERA_ORBITAL);          // Set an orbital camera mode
-    SetCameraPosition(camera.position);     // Set internal camera position to match our camera position
-    SetCameraTarget(camera.target);         // Set internal camera target to match our camera target
 
     SetTargetFPS(60);                           // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------

examples/shaders_model_shader.lua

@@ -0,0 +1,85 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [shaders] example - Apply a shader to a 3d model
+--
+--  NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
+--        OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
+--
+--  NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
+--        on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
+--        raylib comes with shaders ready for both versions, check raylib/shaders install folder
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+SetConfigFlags(FLAG.MSAA_4X_HINT)      -- Enable Multi Sampling Anti Aliasing 4x (if available)
+
+InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader")
+
+-- Define the camera to look into our 3d world
+local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
+
+local dwarf = LoadModel("resources/model/dwarf.obj")                   -- Load OBJ model
+local texture = LoadTexture("resources/model/dwarf_diffuse.png")       -- Load model texture
+local shader = LoadShader("resources/shaders/glsl330/base.vs", 
+                          "resources/shaders/glsl330/grayscale.fs")    -- Load model shader
+
+dwarf.material.shader = shader            -- Set shader effect to 3d model
+dwarf.material.texDiffuse = texture       -- Bind texture to model
+
+local position = Vector3(0.0, 0.0, 0.0)   -- Set model position
+
+-- Setup orbital camera
+SetCameraMode(CameraMode.ORBITAL)             -- Set an orbital camera mode
+SetCameraPosition(camera.position)        -- Set internal camera position to match our camera position
+SetCameraTarget(camera.target)            -- Set internal camera target to match our camera target
+
+SetTargetFPS(60)                          -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do          -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    camera = UpdateCamera(camera)         -- Update internal camera and our camera
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)
+
+            DrawModel(dwarf, position, 2.0, WHITE)   -- Draw 3d model with texture
+
+            DrawGrid(10, 1.0)     -- Draw a grid
+
+        End3dMode()
+        
+        DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY)
+
+        DrawFPS(10, 10)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadShader(shader)       -- Unload shader
+UnloadTexture(texture)     -- Unload texture
+UnloadModel(dwarf)         -- Unload model
+
+CloseWindow()              -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/shaders_postprocessing.lua

@@ -0,0 +1,101 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [shaders] example - Apply a postprocessing shader to a scene
+--
+--  NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
+--        OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
+--
+--  NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
+--        on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
+--        raylib comes with shaders ready for both versions, check raylib/shaders install folder
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+SetConfigFlags(FLAG.MSAA_4X_HINT)      -- Enable Multi Sampling Anti Aliasing 4x (if available)
+
+InitWindow(screenWidth, screenHeight, "raylib [shaders] example - postprocessing shader")
+
+-- Define the camera to look into our 3d world
+local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
+
+local dwarf = LoadModel("resources/model/dwarf.obj")                   -- Load OBJ model
+local texture = LoadTexture("resources/model/dwarf_diffuse.png")       -- Load model texture (diffuse map)
+dwarf.material.texDiffuse = texture                                    -- Set dwarf model diffuse texture
+
+local position = Vector3(0.0, 0.0, 0.0)                                -- Set model position
+
+local shader = LoadShader("resources/shaders/glsl330/base.vs", 
+                          "resources/shaders/glsl330/bloom.fs")        -- Load postpro shader
+
+-- Create a RenderTexture2D to be used for render to texture
+local target = LoadRenderTexture(screenWidth, screenHeight)
+
+-- Setup orbital camera
+SetCameraMode(CameraMode.ORBITAL)          -- Set an orbital camera mode
+SetCameraPosition(camera.position)     -- Set internal camera position to match our camera position
+SetCameraTarget(camera.target)         -- Set internal camera target to match our camera target
+
+SetTargetFPS(60)                       -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do       -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    camera = UpdateCamera(camera)      -- Update internal camera and our camera
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        BeginTextureMode(target)       -- Enable drawing to texture
+
+            Begin3dMode(camera)
+
+                DrawModel(dwarf, position, 2.0, WHITE)   -- Draw 3d model with texture
+
+                DrawGrid(10, 1.0)      -- Draw a grid
+
+            End3dMode()
+      
+            DrawText("HELLO POSTPROCESSING!", 70, 190, 50, RED)
+            
+        EndTextureMode()           -- End drawing to texture (now we have a texture available for next passes)
+        
+        BeginShaderMode(shader)
+        
+            -- NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom)
+            DrawTextureRec(target.texture, Rectangle(0, 0, target.texture.width, -target.texture.height), Vector2(0, 0), WHITE)
+            
+        EndShaderMode()
+        
+        DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, DARKGRAY)
+
+        DrawFPS(10, 10)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadShader(shader)           -- Unload shader
+UnloadTexture(texture)         -- Unload texture
+UnloadModel(dwarf)             -- Unload model
+UnloadRenderTexture(target)    -- Unload render texture
+
+CloseWindow()                  -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/shaders_shapes_textures.lua

@@ -0,0 +1,101 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [shaders] example - Apply a shader to some shape or texture
+--
+--  NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
+--        OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
+--
+--  NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
+--        on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
+--        raylib comes with shaders ready for both versions, check raylib/shaders install folder
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shapes and texture shaders")
+
+local sonic = LoadTexture("resources/texture_formats/sonic.png")
+
+-- NOTE: Using GLSL 330 shader version, on OpenGL ES 2.0 use GLSL 100 shader version 
+local shader = LoadShader("resources/shaders/glsl330/base.vs", 
+                          "resources/shaders/glsl330/grayscale.fs")
+                           
+-- Shader usage is also different than models/postprocessing, shader is just activated when required
+
+SetTargetFPS(60)                        -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do        -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update your variables here
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+        
+        -- Start drawing with default shader
+
+        DrawText("USING DEFAULT SHADER", 20, 40, 10, RED)
+        
+        DrawCircle(80, 120, 35, DARKBLUE)
+        DrawCircleGradient(80, 220, 60, GREEN, SKYBLUE)
+        DrawCircleLines(80, 340, 80, DARKBLUE)
+
+        
+        -- Activate our custom shader to be applied on next shapes/textures drawings
+        BeginShaderMode(shader)
+        
+            DrawText("USING CUSTOM SHADER", 190, 40, 10, RED)
+
+            DrawRectangle(250 - 60, 90, 120, 60, RED)
+            DrawRectangleGradient(250 - 90, 170, 180, 130, MAROON, GOLD)
+            DrawRectangleLines(250 - 40, 320, 80, 60, ORANGE)
+
+        -- Activate our default shader for next drawings
+        EndShaderMode()
+        
+        DrawText("USING DEFAULT SHADER", 370, 40, 10, RED)
+        
+        DrawTriangle(Vector2(430, 80),
+                     Vector2(430 - 60, 150),
+                     Vector2(430 + 60, 150), VIOLET)
+                     
+        DrawTriangleLines(Vector2(430, 160),
+                          Vector2(430 - 20, 230),
+                          Vector2(430 + 20, 230), DARKBLUE)
+
+        DrawPoly(Vector2(430, 320), 6, 80, 0, BROWN)
+        
+        -- Activate our custom shader to be applied on next shapes/textures drawings
+        BeginShaderMode(shader)
+
+            DrawTexture(sonic, 380, -10, WHITE)    -- Using custom shader
+        
+        -- Activate our default shader for next drawings
+        EndShaderMode()
+        
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadShader(shader)   -- Unload shader
+UnloadTexture(sonic)   -- Unload texture
+
+CloseWindow()          -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/shaders_standard_lighting.lua

@@ -0,0 +1,114 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [shaders] example - Standard lighting (materials and lights)
+--
+--  NOTE: This example requires raylib OpenGL 3.3 or ES2 versions for shaders support,
+--        OpenGL 1.1 does not support shaders, recompile raylib to OpenGL 3.3 version.
+--
+--  NOTE: Shaders used in this example are #version 330 (OpenGL 3.3), to test this example
+--        on OpenGL ES 2.0 platforms (Android, Raspberry Pi, HTML5), use #version 100 shaders
+--        raylib comes with shaders ready for both versions, check raylib/shaders install folder
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+SetConfigFlags(FLAG.MSAA_4X_HINT)      -- Enable Multi Sampling Anti Aliasing 4x (if available)
+
+InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader")
+
+-- Define the camera to look into our 3d world
+local camera = Camera(Vector3(4.0, 4.0, 4.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)
+
+local dwarf = LoadModel("resources/model/dwarf.obj")                     -- Load OBJ model
+local position = Vector3(0.0, 0.0, 0.0)                                  -- Set model position
+
+local material = LoadStandardMaterial()
+
+material.texDiffuse = LoadTexture("resources/model/dwarf_diffuse.png")   -- Load model diffuse texture
+material.texNormal = LoadTexture("resources/model/dwarf_normal.png")     -- Load model normal texture
+material.texSpecular = LoadTexture("resources/model/dwarf_specular.png") -- Load model specular texture
+material.colDiffuse = WHITE
+material.colAmbient = Color(0, 0, 10, 255)
+material.colSpecular = WHITE
+material.glossiness = 50.0
+
+dwarf.material = material      -- Apply material to model
+
+local spotLight = CreateLight(LightType.SPOT, Vector3(3.0, 5.0, 2.0), Color(255, 255, 255, 255))
+spotLight.target = Vector3(0.0, 0.0, 0.0)
+spotLight.intensity = 2.0
+spotLight.diffuse = Color(255, 100, 100, 255)
+spotLight.coneAngle = 60.0
+
+local dirLight = CreateLight(LightType.DIRECTIONAL, Vector3(0.0, -3.0, -3.0), Color(255, 255, 255, 255))
+dirLight.target = Vector3(1.0, -2.0, -2.0)
+dirLight.intensity = 2.0
+dirLight.diffuse = Color(100, 255, 100, 255)
+
+local pointLight = CreateLight(LightType.POINT, Vector3(0.0, 4.0, 5.0), Color(255, 255, 255, 255))
+pointLight.intensity = 2.0
+pointLight.diffuse = Color(100, 100, 255, 255)
+pointLight.radius = 3.0
+
+-- Setup orbital camera
+SetCameraMode(CameraMode.ORBITAL)      -- Set an orbital camera mode
+SetCameraPosition(camera.position)     -- Set internal camera position to match our camera position
+SetCameraTarget(camera.target)         -- Set internal camera target to match our camera target
+
+SetTargetFPS(60)                       -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do       -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    camera = UpdateCamera(camera)      -- Update internal camera and our camera
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        Begin3dMode(camera)
+            
+            DrawModel(dwarf, position, 2.0, WHITE)   -- Draw 3d model with texture
+            
+            DrawLight(spotLight)       -- Draw spot light
+            DrawLight(dirLight)        -- Draw directional light
+            DrawLight(pointLight)      -- Draw point light
+
+            DrawGrid(10, 1.0)          -- Draw a grid
+
+        End3dMode()
+        
+        DrawText("(c) Dwarf 3D model by David Moreno", screenWidth - 200, screenHeight - 20, 10, GRAY)
+        
+        DrawFPS(10, 10)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadMaterial(material)   -- Unload material and assigned textures
+UnloadModel(dwarf)         -- Unload model
+
+-- Destroy all created lights
+DestroyLight(pointLight)
+DestroyLight(dirLight)
+DestroyLight(spotLight)
+
+CloseWindow()              -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/shapes_basic_shapes.lua

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

examples/shapes_colors_palette.lua

@@ -0,0 +1,89 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [shapes] example - Draw raylib custom color palette
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib color palette")
+
+SetTargetFPS(60)       -- Set target frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update your variables here
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawText("raylib color palette", 28, 42, 20, BLACK)
+
+        DrawRectangle(26, 80, 100, 100, DARKGRAY)
+        DrawRectangle(26, 188, 100, 100, GRAY)
+        DrawRectangle(26, 296, 100, 100, LIGHTGRAY)
+        DrawRectangle(134, 80, 100, 100, MAROON)
+        DrawRectangle(134, 188, 100, 100, RED)
+        DrawRectangle(134, 296, 100, 100, PINK)
+        DrawRectangle(242, 80, 100, 100, ORANGE)
+        DrawRectangle(242, 188, 100, 100, GOLD)
+        DrawRectangle(242, 296, 100, 100, YELLOW)
+        DrawRectangle(350, 80, 100, 100, DARKGREEN)
+        DrawRectangle(350, 188, 100, 100, LIME)
+        DrawRectangle(350, 296, 100, 100, GREEN)
+        DrawRectangle(458, 80, 100, 100, DARKBLUE)
+        DrawRectangle(458, 188, 100, 100, BLUE)
+        DrawRectangle(458, 296, 100, 100, SKYBLUE)
+        DrawRectangle(566, 80, 100, 100, DARKPURPLE)
+        DrawRectangle(566, 188, 100, 100, VIOLET)
+        DrawRectangle(566, 296, 100, 100, PURPLE)
+        DrawRectangle(674, 80, 100, 100, DARKBROWN)
+        DrawRectangle(674, 188, 100, 100, BROWN)
+        DrawRectangle(674, 296, 100, 100, BEIGE)
+
+
+        DrawText("DARKGRAY", 65, 166, 10, BLACK)
+        DrawText("GRAY", 93, 274, 10, BLACK)
+        DrawText("LIGHTGRAY", 61, 382, 10, BLACK)
+        DrawText("MAROON", 186, 166, 10, BLACK)
+        DrawText("RED", 208, 274, 10, BLACK)
+        DrawText("PINK", 204, 382, 10, BLACK)
+        DrawText("ORANGE", 295, 166, 10, BLACK)
+        DrawText("GOLD", 310, 274, 10, BLACK)
+        DrawText("YELLOW", 300, 382, 10, BLACK)
+        DrawText("DARKGREEN", 382, 166, 10, BLACK)
+        DrawText("LIME", 420, 274, 10, BLACK)
+        DrawText("GREEN", 410, 382, 10, BLACK)
+        DrawText("DARKBLUE", 498, 166, 10, BLACK)
+        DrawText("BLUE", 526, 274, 10, BLACK)
+        DrawText("SKYBLUE", 505, 382, 10, BLACK)
+        DrawText("DARKPURPLE", 592, 166, 10, BLACK)
+        DrawText("VIOLET", 621, 274, 10, BLACK)
+        DrawText("PURPLE", 620, 382, 10, BLACK)
+        DrawText("DARKBROWN", 705, 166, 10, BLACK)
+        DrawText("BROWN", 733, 274, 10, BLACK)
+        DrawText("BEIGE", 737, 382, 10, BLACK)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/shapes_logo_raylib.lua

@@ -0,0 +1,48 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [shapes] example - Draw raylib logo using basic shapes
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo using shapes")
+
+SetTargetFPS(60)       -- Set target frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update your variables here
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawRectangle(screenWidth/2 - 128, screenHeight/2 - 128, 256, 256, BLACK)
+        DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, RAYWHITE)
+        DrawText("raylib", screenWidth/2 - 44, screenHeight/2 + 48, 50, BLACK)
+
+        DrawText("this is NOT a texture!", 350, 370, 10, GRAY)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/shapes_logo_raylib_anim.lua

@@ -0,0 +1,127 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [shapes] example - raylib logo animation
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo animation")
+
+local logoPositionX = screenWidth/2 - 128
+local logoPositionY = screenHeight/2 - 128
+
+local framesCounter = 0
+local lettersCount = 0
+
+local topSideRecWidth = 16
+local leftSideRecHeight = 16
+
+local bottomSideRecWidth = 16
+local rightSideRecHeight = 16
+
+local state = 0                -- Tracking animation states (State Machine)
+local alpha = 1.0              -- Useful for fading
+
+SetTargetFPS(60)               -- Set target frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    if (state == 0) then                    -- State 0: Small box blinking
+        framesCounter = framesCounter + 1
+
+        if (framesCounter == 120) then
+            state = 1
+            framesCounter = 0               -- Reset counter... will be used later...
+        end
+    elseif (state == 1) then                -- State 1: Top and left bars growing
+        topSideRecWidth = topSideRecWidth + 4
+        leftSideRecHeight = leftSideRecHeight + 4
+
+        if (topSideRecWidth == 256) then state = 2 end
+    elseif (state == 2) then                -- State 2: Bottom and right bars growing
+        bottomSideRecWidth = bottomSideRecWidth + 4
+        rightSideRecHeight = rightSideRecHeight + 4
+
+        if (bottomSideRecWidth == 256) then state = 3 end
+    elseif (state == 3) then                -- State 3: Letters appearing (one by one)
+        framesCounter = framesCounter + 1
+
+        if (framesCounter//12 == 1) then    -- Every 12 frames, one more letter!
+            lettersCount = lettersCount + 1
+            framesCounter = 0
+        end
+
+        if (lettersCount >= 10) then        -- When all letters have appeared, just fade out everything
+            alpha = alpha - 0.02
+
+            if (alpha <= 0.0) then
+                alpha = 0.0
+                state = 4
+            end
+        end
+    elseif (state == 4) then                -- State 4: Reset and Replay
+        if (IsKeyPressed(KEY.R)) then
+            framesCounter = 0
+            lettersCount = 0
+
+            topSideRecWidth = 16
+            leftSideRecHeight = 16
+
+            bottomSideRecWidth = 16
+            rightSideRecHeight = 16
+
+            alpha = 1.0
+            state = 0                       -- Return to State 0
+        end
+    end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        if (state == 0) then
+            if ((framesCounter//15)%2 == 1) then DrawRectangle(logoPositionX, logoPositionY, 16, 16, BLACK) end
+        elseif (state == 1) then
+            DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, BLACK)
+            DrawRectangle(logoPositionX, logoPositionY, 16, leftSideRecHeight, BLACK)
+        elseif (state == 2) then
+            DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, BLACK)
+            DrawRectangle(logoPositionX, logoPositionY, 16, leftSideRecHeight, BLACK)
+
+            DrawRectangle(logoPositionX + 240, logoPositionY, 16, rightSideRecHeight, BLACK)
+            DrawRectangle(logoPositionX, logoPositionY + 240, bottomSideRecWidth, 16, BLACK)
+        elseif (state == 3) then
+            DrawRectangle(logoPositionX, logoPositionY, topSideRecWidth, 16, Fade(BLACK, alpha))
+            DrawRectangle(logoPositionX, logoPositionY + 16, 16, leftSideRecHeight - 32, Fade(BLACK, alpha))
+
+            DrawRectangle(logoPositionX + 240, logoPositionY + 16, 16, rightSideRecHeight - 32, Fade(BLACK, alpha))
+            DrawRectangle(logoPositionX, logoPositionY + 240, bottomSideRecWidth, 16, Fade(BLACK, alpha))
+
+            DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, Fade(RAYWHITE, alpha))
+
+            DrawText(string.sub("raylib", 0, lettersCount), screenWidth/2 - 44, screenHeight/2 + 48, 50, Fade(BLACK, alpha))
+        elseif (state == 4) then DrawText("[R] REPLAY", 340, 200, 20, GRAY) end
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/text_bmfont_ttf.lua

@@ -0,0 +1,59 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [text] example - BMFont and TTF SpriteFonts loading
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [text] example - bmfont and ttf sprite fonts loading")
+
+local msgBm = "THIS IS AN AngelCode SPRITE FONT"
+local msgTtf = "THIS FONT has been GENERATED from TTF"
+
+-- NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required)
+local fontBm = LoadSpriteFont("resources/fonts/bmfont.fnt")       -- BMFont (AngelCode)
+local fontTtf = LoadSpriteFont("resources/fonts/pixantiqua.ttf")  -- TTF font
+
+local fontPosition = Vector2(0, 0)
+fontPosition.x = screenWidth/2 - MeasureTextEx(fontBm, msgBm, fontBm.size, 0).x/2
+fontPosition.y = screenHeight/2 - fontBm.size/2 - 80
+
+SetTargetFPS(60)            -- Set target frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update variables here...
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawTextEx(fontBm, msgBm, fontPosition, fontBm.size, 0, MAROON)
+        DrawTextEx(fontTtf, msgTtf, Vector2(60.0, 240.0), fontTtf.size, 2, LIME)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadSpriteFont(fontBm)     -- AngelCode SpriteFont unloading
+UnloadSpriteFont(fontTtf)    -- TTF SpriteFont unloading
+
+CloseWindow()                -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/text_font_select.lua

@@ -0,0 +1,143 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [text] example - Font selector
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [text] example - font selector")
+
+-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+local fonts = {}        -- SpriteFont array
+
+fonts[1] = LoadSpriteFont("resources/fonts/alagard.rbmf")       -- SpriteFont loading
+fonts[2] = LoadSpriteFont("resources/fonts/pixelplay.rbmf")     -- SpriteFont loading
+fonts[3] = LoadSpriteFont("resources/fonts/mecha.rbmf")         -- SpriteFont loading
+fonts[4] = LoadSpriteFont("resources/fonts/setback.rbmf")       -- SpriteFont loading
+fonts[5] = LoadSpriteFont("resources/fonts/romulus.rbmf")       -- SpriteFont loading
+fonts[6] = LoadSpriteFont("resources/fonts/pixantiqua.rbmf")    -- SpriteFont loading
+fonts[7] = LoadSpriteFont("resources/fonts/alpha_beta.rbmf")    -- SpriteFont loading
+fonts[8] = LoadSpriteFont("resources/fonts/jupiter_crash.rbmf") -- SpriteFont loading
+
+local currentFont = 1        -- Selected font
+
+local colors = { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD, RED }
+
+local fontNames = { "[1] Alagard", "[2] PixelPlay", "[3] MECHA", "[4] Setback",
+                    "[5] Romulus", "[6] PixAntiqua", "[7] Alpha Beta", "[8] Jupiter Crash" }
+
+local text = "THIS is THE FONT you SELECTED!"     -- Main text
+
+local textSize = MeasureTextEx(fonts[currentFont], text, fonts[currentFont].size*3, 1)
+
+local mousePoint
+
+local btnNextOutColor = DARKBLUE       -- Button color (outside line)
+local btnNextInColor = SKYBLUE         -- Button color (inside)
+
+local framesCounter = 0      -- Useful to count frames button is 'active' = clicked
+
+local positionY = 180        -- Text selector and button Y position
+
+local btnNextRec = Rectangle(673, positionY, 109, 44)    -- Button rectangle (useful for collision)
+
+SetTargetFPS(60)           -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+
+    -- Keyboard-based font selection (easy)
+    if (IsKeyPressed(KEY.RIGHT)) then
+        if (currentFont < 8) then currentFont = currentFont + 1 end
+    end
+
+    if (IsKeyPressed(KEY.LEFT)) then
+        if (currentFont > 1) then currentFont = currentFont - 1 end
+    end
+    
+    if (IsKeyPressed(KEY.ZERO)) then currentFont = 0
+    elseif (IsKeyPressed(KEY.ONE)) then currentFont = 1
+    elseif (IsKeyPressed(KEY.TWO)) then currentFont = 2
+    elseif (IsKeyPressed(KEY.THREE)) then currentFont = 3
+    elseif (IsKeyPressed(KEY.FOUR)) then currentFont = 4
+    elseif (IsKeyPressed(KEY.FIVE)) then currentFont = 5
+    elseif (IsKeyPressed(KEY.SIX)) then currentFont = 6
+    elseif (IsKeyPressed(KEY.SEVEN)) then currentFont = 7
+    end
+
+    -- Mouse-based font selection (NEXT button logic)
+    mousePoint = GetMousePosition()
+
+    if (CheckCollisionPointRec(mousePoint, btnNextRec)) then
+        -- Mouse hover button logic
+        if (framesCounter == 0) then
+            btnNextOutColor = DARKPURPLE
+            btnNextInColor = PURPLE
+        end
+
+        if (IsMouseButtonDown(MOUSE.LEFT_BUTTON)) then
+            framesCounter = 20         -- Frames button is 'active'
+            btnNextOutColor = MAROON
+            btnNextInColor = RED
+        end
+    else
+        -- Mouse not hover button
+        btnNextOutColor = DARKBLUE
+        btnNextInColor = SKYBLUE
+    end
+    
+    if (framesCounter > 0) then framesCounter = framesCounter - 1 end
+
+    if (framesCounter == 1) then     -- We change font on frame 1
+        currentFont = currentFont + 1
+        if (currentFont > 7) then currentFont = 0 end
+    end
+
+    -- Text measurement for better positioning on screen
+    textSize = MeasureTextEx(fonts[currentFont], text, fonts[currentFont].size*3, 1)
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+        
+        DrawText("font selector - use arroys, button or numbers", 160, 80, 20, DARKGRAY)
+        DrawLine(120, 120, 680, 120, DARKGRAY)
+
+        DrawRectangle(18, positionY, 644, 44, DARKGRAY)
+        DrawRectangle(20, positionY + 2, 640, 40, LIGHTGRAY)
+        DrawText(fontNames[currentFont], 30, positionY + 13, 20, BLACK)
+        DrawText("< >", 610, positionY + 8, 30, BLACK)
+
+        DrawRectangleRec(btnNextRec, btnNextOutColor)
+        DrawRectangle(675, positionY + 2, 105, 40, btnNextInColor)
+        DrawText("NEXT", 700, positionY + 13, 20, btnNextOutColor)
+
+        DrawTextEx(fonts[currentFont], text, Vector2(screenWidth/2 - textSize.x/2,
+                   260 + (70 - textSize.y)/2), fonts[currentFont].size*3,
+                   1, colors[currentFont])
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+for i = 1, 8 do UnloadSpriteFont(fonts[i]) end       -- SpriteFont(s) unloading
+
+CloseWindow()                -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/text_format_text.lua

@@ -0,0 +1,54 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [text] example - Text formatting
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [text] example - text formatting")
+
+local score = 100020
+local hiscore = 200450
+local lives = 5
+
+SetTargetFPS(60)        -- Set target frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update your variables here
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawText(string.format("Score: %08i", score), 200, 80, 20, RED)
+
+        DrawText(string.format("HiScore: %08i", hiscore), 200, 120, 20, GREEN)
+
+        DrawText(string.format("Lives: %02i", lives), 200, 160, 40, BLUE)
+
+        DrawText(string.format("Elapsed Time: %02.02f ms", GetFrameTime()*1000), 200, 220, 20, BLACK)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/text_rbmf_fonts.lua

@@ -0,0 +1,87 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [text] example - raylib bitmap font (rbmf) loading and usage
+--
+--  NOTE: raylib is distributed with some free to use fonts (even for commercial pourposes!)
+--        To view details and credits for those fonts, check raylib license file
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [text] example - rBMF fonts")
+
+-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+local fonts = {}
+
+fonts[1] = LoadSpriteFont("resources/fonts/alagard.rbmf")       -- rBMF font loading
+fonts[2] = LoadSpriteFont("resources/fonts/pixelplay.rbmf")     -- rBMF font loading
+fonts[3] = LoadSpriteFont("resources/fonts/mecha.rbmf")         -- rBMF font loading
+fonts[4] = LoadSpriteFont("resources/fonts/setback.rbmf")       -- rBMF font loading
+fonts[5] = LoadSpriteFont("resources/fonts/romulus.rbmf")       -- rBMF font loading
+fonts[6] = LoadSpriteFont("resources/fonts/pixantiqua.rbmf")    -- rBMF font loading
+fonts[7] = LoadSpriteFont("resources/fonts/alpha_beta.rbmf")    -- rBMF font loading
+fonts[8] = LoadSpriteFont("resources/fonts/jupiter_crash.rbmf") -- rBMF font loading
+
+local messages = { "ALAGARD FONT designed by Hewett Tsoi", 
+                   "PIXELPLAY FONT designed by Aleksander Shevchuk",
+                   "MECHA FONT designed by Captain Falcon",  
+                   "SETBACK FONT designed by Brian Kent (AEnigma)", 
+                   "ROMULUS FONT designed by Hewett Tsoi", 
+                   "PIXANTIQUA FONT designed by Gerhard Grossmann",
+                   "ALPHA_BETA FONT designed by Brian Kent (AEnigma)",
+                   "JUPITER_CRASH FONT designed by Brian Kent (AEnigma)" }
+                            
+local spacings = { 2, 4, 8, 4, 3, 4, 4, 1 }
+
+local positions = {}
+
+for i = 1, 8 do
+    positions[i] = Vector2(0, 0)
+    positions[i].x = screenWidth/2 - MeasureTextEx(fonts[i], messages[i], fonts[i].size*2, spacings[i]).x/2
+    positions[i].y = 60 + fonts[i].size + 45*(i - 1)
+end
+
+local colors = { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD, BLACK }
+
+SetTargetFPS(60)            -- Set target frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update your variables here
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+        
+        DrawText("free fonts included with raylib", 250, 20, 20, DARKGRAY)
+        DrawLine(220, 50, 590, 50, DARKGRAY)
+        
+        for i = 1, 8 do
+            DrawTextEx(fonts[i], messages[i], positions[i], fonts[i].size*2, spacings[i], colors[i])
+        end
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+for i = 1, 8 do UnloadSpriteFont(fonts[i]) end       -- SpriteFont unloading
+
+CloseWindow()                 -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/text_sprite_fonts.lua

@@ -0,0 +1,72 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [text] example - SpriteFont loading and usage
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [text] example - sprite fonts usage")
+
+local msg1 = "THIS IS A custom SPRITE FONT..."
+local msg2 = "...and this is ANOTHER CUSTOM font..."
+local msg3 = "...and a THIRD one! GREAT! :D"
+
+-- NOTE: Textures/Fonts MUST be loaded after Window initialization (OpenGL context is required)
+local font1 = LoadSpriteFont("resources/fonts/custom_mecha.png")          -- SpriteFont loading
+local font2 = LoadSpriteFont("resources/fonts/custom_alagard.png")        -- SpriteFont loading
+local font3 = LoadSpriteFont("resources/fonts/custom_jupiter_crash.png")  -- SpriteFont loading
+
+local fontPosition1 = Vector2(0, 0)
+local fontPosition2 = Vector2(0, 0)
+local fontPosition3 = Vector2(0, 0)
+
+fontPosition1.x = screenWidth/2 - MeasureTextEx(font1, msg1, font1.size, -3).x/2
+fontPosition1.y = screenHeight/2 - font1.size/2 - 80
+
+fontPosition2.x = screenWidth/2 - MeasureTextEx(font2, msg2, font2.size, -2).x/2
+fontPosition2.y = screenHeight/2 - font2.size/2 - 10
+
+fontPosition3.x = screenWidth/2 - MeasureTextEx(font3, msg3, font3.size, 2).x/2
+fontPosition3.y = screenHeight/2 - font3.size/2 + 50
+
+SetTargetFPS(60)            -- Set target frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update variables here...
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawTextEx(font1, msg1, fontPosition1, font1.size, -3, WHITE)
+        DrawTextEx(font2, msg2, fontPosition2, font2.size, -2, WHITE)
+        DrawTextEx(font3, msg3, fontPosition3, font3.size, 2, WHITE)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadSpriteFont(font1)      -- SpriteFont unloading
+UnloadSpriteFont(font2)      -- SpriteFont unloading
+UnloadSpriteFont(font3)      -- SpriteFont unloading
+
+CloseWindow()                -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/text_writing_anim.lua

@@ -0,0 +1,52 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [text] example - Text Writing Animation
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [text] example - text writing anim")
+
+local message = "This sample illustrates a text writing\nanimation effect! Check it out! )"
+
+local framesCounter = 0
+
+SetTargetFPS(60)            -- Set target frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    framesCounter = framesCounter + 1
+    
+    if (IsKeyPressed(KEY.ENTER)) then framesCounter = 0 end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawText(string.sub(message, 0, framesCounter//10), 210, 160, 20, MAROON)
+        
+        DrawText("PRESS [ENTER] to RESTART!", 240, 280, 20, LIGHTGRAY)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------   
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/textures_formats_loading.lua

@@ -0,0 +1,217 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [textures] example - texture formats loading (compressed and uncompressed)
+--
+--  NOTE: This example requires raylib OpenGL 3.3+ or ES2 versions for compressed textures,
+--        OpenGL 1.1 does not support compressed textures, only uncompressed ones.
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+NUM_TEXTURES = 24
+
+PNG_R8G8B8A8 = 1
+PVR_GRAYSCALE = 2
+PVR_GRAY_ALPHA = 3
+PVR_R5G6B5 = 4 
+PVR_R5G5B5A1 = 5
+PVR_R4G4B4A4 = 6
+DDS_R5G6B5 = 7
+DDS_R5G5B5A1 = 8
+DDS_R4G4B4A4 = 9
+DDS_R8G8B8A8 = 10
+DDS_DXT1_RGB = 11
+DDS_DXT1_RGBA = 12
+DDS_DXT3_RGBA = 13
+DDS_DXT5_RGBA = 14
+PKM_ETC1_RGB = 15
+PKM_ETC2_RGB = 16
+PKM_ETC2_EAC_RGBA = 17
+KTX_ETC1_RGB = 18
+KTX_ETC2_RGB = 19
+KTX_ETC2_EAC_RGBA = 20
+ASTC_4x4_LDR = 21
+ASTC_8x8_LDR = 22
+PVR_PVRT_RGB = 23
+PVR_PVRT_RGBA = 24
+
+local formatText = {
+    "PNG_R8G8B8A8",
+    "PVR_GRAYSCALE",
+    "PVR_GRAY_ALPHA",
+    "PVR_R5G6B5",
+    "PVR_R5G5B5A1",
+    "PVR_R4G4B4A4",
+    "DDS_R5G6B5",
+    "DDS_R5G5B5A1",
+    "DDS_R4G4B4A4",
+    "DDS_R8G8B8A8",
+    "DDS_DXT1_RGB",
+    "DDS_DXT1_RGBA",
+    "DDS_DXT3_RGBA",
+    "DDS_DXT5_RGBA",
+    "PKM_ETC1_RGB",
+    "PKM_ETC2_RGB",
+    "PKM_ETC2_EAC_RGBA",
+    "KTX_ETC1_RGB",
+    "KTX_ETC2_RGB",
+    "KTX_ETC2_EAC_RGBA",
+    "ASTC_4x4_LDR",
+    "ASTC_8x8_LDR",
+    "PVR_PVRT_RGB",
+    "PVR_PVRT_RGBA"
+}
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture formats loading")
+
+-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+
+local sonic = {}
+
+sonic[PNG_R8G8B8A8] = LoadTexture("resources/texture_formats/sonic.png")
+
+-- Load UNCOMPRESSED PVR texture data
+sonic[PVR_GRAYSCALE] = LoadTexture("resources/texture_formats/sonic_GRAYSCALE.pvr")
+sonic[PVR_GRAY_ALPHA] = LoadTexture("resources/texture_formats/sonic_L8A8.pvr")
+sonic[PVR_R5G6B5] = LoadTexture("resources/texture_formats/sonic_R5G6B5.pvr")
+sonic[PVR_R5G5B5A1] = LoadTexture("resources/texture_formats/sonic_R5G5B5A1.pvr")
+sonic[PVR_R4G4B4A4] = LoadTexture("resources/texture_formats/sonic_R4G4B4A4.pvr")
+
+-- Load UNCOMPRESSED DDS texture data
+sonic[DDS_R5G6B5] = LoadTexture("resources/texture_formats/sonic_R5G6B5.dds")
+sonic[DDS_R5G5B5A1] = LoadTexture("resources/texture_formats/sonic_A1R5G5B5.dds")
+sonic[DDS_R4G4B4A4] = LoadTexture("resources/texture_formats/sonic_A4R4G4B4.dds")
+sonic[DDS_R8G8B8A8] = LoadTexture("resources/texture_formats/sonic_A8R8G8B8.dds")
+
+-- Load COMPRESSED DXT DDS texture data (if supported)
+sonic[DDS_DXT1_RGB] = LoadTexture("resources/texture_formats/sonic_DXT1_RGB.dds")
+sonic[DDS_DXT1_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT1_RGBA.dds")
+sonic[DDS_DXT3_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT3_RGBA.dds")
+sonic[DDS_DXT5_RGBA] = LoadTexture("resources/texture_formats/sonic_DXT5_RGBA.dds")
+
+-- Load COMPRESSED ETC texture data (if supported)
+sonic[PKM_ETC1_RGB] = LoadTexture("resources/texture_formats/sonic_ETC1_RGB.pkm")
+sonic[PKM_ETC2_RGB] = LoadTexture("resources/texture_formats/sonic_ETC2_RGB.pkm")
+sonic[PKM_ETC2_EAC_RGBA] = LoadTexture("resources/texture_formats/sonic_ETC2_EAC_RGBA.pkm")
+
+sonic[KTX_ETC1_RGB] = LoadTexture("resources/texture_formats/sonic_ETC1_RGB.ktx")
+sonic[KTX_ETC2_RGB] = LoadTexture("resources/texture_formats/sonic_ETC2_RGB.ktx")
+sonic[KTX_ETC2_EAC_RGBA] = LoadTexture("resources/texture_formats/sonic_ETC2_EAC_RGBA.ktx")
+
+-- Load COMPRESSED ASTC texture data (if supported)
+sonic[ASTC_4x4_LDR] = LoadTexture("resources/texture_formats/sonic_ASTC_4x4_ldr.astc")
+sonic[ASTC_8x8_LDR] = LoadTexture("resources/texture_formats/sonic_ASTC_8x8_ldr.astc")
+
+-- Load COMPRESSED PVR texture data (if supported)
+sonic[PVR_PVRT_RGB] = LoadTexture("resources/texture_formats/sonic_PVRT_RGB.pvr")
+sonic[PVR_PVRT_RGBA] = LoadTexture("resources/texture_formats/sonic_PVRT_RGBA.pvr")
+
+local selectedFormat = PNG_R8G8B8A8
+
+local selectRecs = {}
+
+for i = 1, NUM_TEXTURES do
+    if ((i - 1) < NUM_TEXTURES//2) then selectRecs[i] = Rectangle(40, 30 + 32*(i - 1), 150, 30)
+    else selectRecs[i] = Rectangle(40 + 152, 30 + 32*((i - 1) - NUM_TEXTURES//2), 150, 30) end
+end
+
+-- Texture sizes in KB
+local textureSizes = { 
+    512*512*32/8/1024,      --PNG_R8G8B8A8 (32 bpp)
+    512*512*8/8/1024,       --PVR_GRAYSCALE (8 bpp)
+    512*512*16/8/1024,      --PVR_GRAY_ALPHA (16 bpp) 
+    512*512*16/8/1024,      --PVR_R5G6B5 (16 bpp)
+    512*512*16/8/1024,      --PVR_R5G5B5A1 (16 bpp) 
+    512*512*16/8/1024,      --PVR_R4G4B4A4 (16 bpp)
+    512*512*16/8/1024,      --DDS_R5G6B5 (16 bpp)
+    512*512*16/8/1024,      --DDS_R5G5B5A1 (16 bpp)
+    512*512*16/8/1024,      --DDS_R4G4B4A4 (16 bpp)
+    512*512*32/8/1024,      --DDS_R8G8B8A8 (32 bpp)
+    512*512*4/8/1024,       --DDS_DXT1_RGB (4 bpp) -Compressed-
+    512*512*4/8/1024,       --DDS_DXT1_RGBA (4 bpp) -Compressed-
+    512*512*8/8/1024,       --DDS_DXT3_RGBA (8 bpp) -Compressed-
+    512*512*8/8/1024,       --DDS_DXT5_RGBA (8 bpp) -Compressed-
+    512*512*4/8/1024,       --PKM_ETC1_RGB (4 bpp) -Compressed-
+    512*512*4/8/1024,       --PKM_ETC2_RGB (4 bpp) -Compressed-
+    512*512*8/8/1024,       --PKM_ETC2_EAC_RGBA (8 bpp) -Compressed-
+    512*512*4/8/1024,       --KTX_ETC1_RGB (4 bpp) -Compressed-
+    512*512*4/8/1024,       --KTX_ETC2_RGB (4 bpp) -Compressed-
+    512*512*8/8/1024,       --KTX_ETC2_EAC_RGBA (8 bpp) -Compressed-
+    512*512*8/8/1024,       --ASTC_4x4_LDR (8 bpp) -Compressed-
+    512*512*2/8/1024,       --ASTC_8x8_LDR (2 bpp) -Compressed-
+    512*512*4/8/1024,       --PVR_PVRT_RGB (4 bpp) -Compressed-
+    512*512*4/8/1024,       --PVR_PVRT_RGBA (4 bpp) -Compressed-
+}
+
+SetTargetFPS(60)   -- Set our game to run at 60 frames-per-second
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    if (IsKeyPressed(KEY.DOWN)) then
+        selectedFormat = selectedFormat + 1
+        if (selectedFormat > NUM_TEXTURES) then selectedFormat = 1 end
+    elseif (IsKeyPressed(KEY.UP)) then
+        selectedFormat = selectedFormat - 1
+        if (selectedFormat < 1) then selectedFormat = NUM_TEXTURES end
+    elseif (IsKeyPressed(KEY.RIGHT)) then
+        if (selectedFormat < NUM_TEXTURES//2) then selectedFormat = selectedFormat + NUM_TEXTURES//2 end
+    elseif (IsKeyPressed(KEY.LEFT)) then
+        if (selectedFormat > NUM_TEXTURES//2) then selectedFormat = selectedFormat - NUM_TEXTURES//2 end
+    end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+        
+        -- Draw rectangles
+        for i = 1, NUM_TEXTURES do
+            if (i == selectedFormat) then
+                DrawRectangleRec(selectRecs[i], SKYBLUE)
+                DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, BLUE)
+                DrawText(formatText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(formatText[i], 10)//2, selectRecs[i].y + 11, 10, DARKBLUE)
+            else
+                DrawRectangleRec(selectRecs[i], LIGHTGRAY)
+                DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, GRAY)
+                DrawText(formatText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(formatText[i], 10)//2, selectRecs[i].y + 11, 10, DARKGRAY)
+            end
+        end
+        
+        -- Draw selected texture
+        if (sonic[selectedFormat].id ~= 0) then DrawTexture(sonic[selectedFormat], 350, -10, WHITE)
+        else
+            DrawRectangleLines(488, 165, 200, 110, DARKGRAY)
+            DrawText("FORMAT", 550, 180, 20, MAROON)
+            DrawText("NOT SUPPORTED", 500, 210, 20, MAROON)
+            DrawText("ON YOUR GPU", 520, 240, 20, MAROON)
+        end
+        
+        DrawText("Select texture format (use cursor keys):", 40, 10, 10, DARKGRAY)
+        DrawText("Required GPU memory size (VRAM):", 40, 427, 10, DARKGRAY)
+        DrawText(string.format("%4.0f KB", textureSizes[selectedFormat]), 240, 420, 20, DARKBLUE)
+        
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+for i = 1, NUM_TEXTURES do UnloadTexture(sonic[i]) end
+
+CloseWindow()                  -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/textures_image_drawing.lua

@@ -0,0 +1,70 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [textures] example - Image loading and drawing on it
+--
+--  NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM)
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [textures] example - image drawing")
+
+-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+
+local cat = LoadImage("resources/cat.png")             -- Load image in CPU memory (RAM)
+cat = ImageCrop(cat, Rectangle(100, 10, 280, 380))     -- Crop an image piece
+cat = ImageFlipHorizontal(cat)                         -- Flip cropped image horizontally
+cat = ImageResize(cat, 150, 200)                       -- Resize flipped-cropped image
+
+local parrots = LoadImage("resources/parrots.png")     -- Load image in CPU memory (RAM)
+
+-- Draw one image over the other with a scaling of 1.5f
+parrots = ImageDraw(parrots, cat, Rectangle(0, 0, cat.width, cat.height), Rectangle(30, 40, cat.width*1.5, cat.height*1.5))
+parrots = ImageCrop(parrots, Rectangle(0, 50, parrots.width, parrots.height - 100)) -- Crop resulting image
+
+UnloadImage(cat)       -- Unload image from RAM
+
+local texture = LoadTextureFromImage(parrots)      -- Image converted to texture, uploaded to GPU memory (VRAM)
+UnloadImage(parrots)   -- Once image has been converted to texture and uploaded to VRAM, it can be unloaded from RAM
+
+SetTargetFPS(60)
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update your variables here
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2 - 40, WHITE)
+        DrawRectangleLines(screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2 - 40, texture.width, texture.height, DARKGRAY)
+
+        DrawText("We are drawing only one texture from various images composed!", 240, 350, 10, DARKGRAY)
+        DrawText("Source images have been cropped, scaled, flipped and copied one over the other.", 190, 370, 10, DARKGRAY)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(texture)       -- Texture unloading
+
+CloseWindow()                -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/textures_image_loading.lua

@@ -0,0 +1,55 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [textures] example - Image loading and texture creation
+--
+--  NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM)
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [textures] example - image loading")
+
+-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+
+local image = LoadImage("resources/raylib_logo.png")  -- Loaded in CPU memory (RAM)
+local texture = LoadTextureFromImage(image)           -- Image converted to texture, GPU memory (VRAM)
+
+UnloadImage(image)   -- Once image has been converted to texture and uploaded to VRAM, it can be unloaded from RAM
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update your variables here
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE)
+
+        DrawText("this IS a texture loaded from an image!", 300, 370, 10, GRAY)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(texture)       -- Texture unloading
+
+CloseWindow()                -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/textures_image_processing.lua

@@ -0,0 +1,134 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [textures] example - Image processing
+--
+--  NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM)
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+--#include <stdlib.h>     -- Required for: free()
+
+NUM_PROCESSES = 8
+
+-- enum ImageProcess
+local COLOR_NONE = 1
+local COLOR_GRAYSCALE = 2
+local COLOR_TINT = 3
+local COLOR_INVERT = 4
+local COLOR_CONTRAST = 5
+local COLOR_BRIGHTNESS = 6
+local FLIP_VERTICAL = 7
+local FLIP_HORIZONTAL = 8
+
+local processText = {
+    "NO PROCESSING",
+    "COLOR GRAYSCALE",
+    "COLOR TINT",
+    "COLOR INVERT",
+    "COLOR CONTRAST",
+    "COLOR BRIGHTNESS",
+    "FLIP VERTICAL",
+    "FLIP HORIZONTAL"
+}
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [textures] example - image processing")
+
+-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+
+local image = LoadImage("resources/parrots.png")   -- Loaded in CPU memory (RAM)
+image = ImageFormat(image, TextureFormat.UNCOMPRESSED_R8G8B8A8)         -- Format image to RGBA 32bit (required for texture update)
+local texture = LoadTextureFromImage(image)        -- Image converted to texture, GPU memory (VRAM)
+
+local currentProcess = COLOR_NONE
+local textureReload = false
+
+local selectRecs = {}
+
+for i = 1, NUM_PROCESSES do selectRecs[i] = Rectangle(40, 50 + 32*i, 150, 30) end
+
+SetTargetFPS(60)
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    if (IsKeyPressed(KEY.DOWN)) then
+        currentProcess = currentProcess + 1
+        if (currentProcess > NUM_PROCESSES) then currentProcess = 1 end
+        textureReload = true
+    elseif (IsKeyPressed(KEY.UP)) then
+        currentProcess = currentProcess - 1
+        if (currentProcess < 1) then currentProcess = NUM_PROCESSES end
+        textureReload = true
+    end
+    
+    if (textureReload) then
+        UnloadImage(image)                         -- Unload current image data
+        image = LoadImage("resources/parrots.png") -- Re-load image data
+
+        -- NOTE: Image processing is a costly CPU process to be done every frame, 
+        -- If image processing is required in a frame-basis, it should be done 
+        -- with a texture and by shaders
+        if (currentProcess == COLOR_GRAYSCALE) then image = ImageColorGrayscale(image)
+        elseif (currentProcess == COLOR_TINT) then image = ImageColorTint(image, GREEN)
+        elseif (currentProcess == COLOR_INVERT) then image = ImageColorInvert(image)
+        elseif (currentProcess == COLOR_CONTRAST) then image = ImageColorContrast(image, -40)
+        elseif (currentProcess == COLOR_BRIGHTNESS) then image = ImageColorBrightness(image, -80)
+        elseif (currentProcess == FLIP_VERTICAL) then image = ImageFlipVertical(image)
+        elseif (currentProcess == FLIP_HORIZONTAL) then image = ImageFlipHorizontal(image)
+        end
+        
+        local pixels = {}
+        pixels = GetImageData(image)                -- Get pixel data from image (RGBA 32bit)
+        texture = UpdateTexture(texture, pixels)    -- Update texture with new image data
+
+        textureReload = false
+    end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+        
+        DrawText("IMAGE PROCESSING:", 40, 30, 10, DARKGRAY)
+        
+        -- Draw rectangles
+        for i = 1, NUM_PROCESSES do
+            if (i == currentProcess) then
+                DrawRectangleRec(selectRecs[i], SKYBLUE)
+                DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, BLUE)
+                DrawText(processText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(processText[i], 10)//2, selectRecs[i].y + 11, 10, DARKBLUE)
+            else
+                DrawRectangleRec(selectRecs[i], LIGHTGRAY)
+                DrawRectangleLines(selectRecs[i].x, selectRecs[i].y, selectRecs[i].width, selectRecs[i].height, GRAY)
+                DrawText(processText[i], selectRecs[i].x + selectRecs[i].width/2 - MeasureText(processText[i], 10)//2, selectRecs[i].y + 11, 10, DARKGRAY)
+            end
+        end
+
+        DrawTexture(texture, screenWidth - texture.width - 60, screenHeight/2 - texture.height/2, WHITE)
+        DrawRectangleLines(screenWidth - texture.width - 60, screenHeight/2 - texture.height/2, texture.width, texture.height, BLACK)
+        
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(texture)       -- Unload texture from VRAM
+UnloadImage(image)           -- Unload image from RAM
+
+CloseWindow()                -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/textures_logo_raylib.lua

@@ -0,0 +1,49 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [textures] example - Texture loading and drawing
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture loading and drawing")
+
+-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+local texture = LoadTexture("resources/raylib_logo.png")        -- Texture loading
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update your variables here
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE)
+
+        DrawText("this IS a texture!", 360, 370, 10, GRAY)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(texture)       -- Texture unloading
+
+CloseWindow()                -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/textures_particles_trail_blending.lua

@@ -0,0 +1,113 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib example - particles trail blending
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+MAX_PARTICLES = 200
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [textures] example - particles trail blending")
+
+-- Particles pool, reuse them!
+local mouseTail = {}
+
+-- Initialize particles
+for i = 1, MAX_PARTICLES do
+    mouseTail[i] = {}
+    mouseTail[i].position = Vector2(0, 0)
+    mouseTail[i].color = Color(GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255)
+    mouseTail[i].alpha = 1.0
+    mouseTail[i].size = GetRandomValue(1, 30)/20.0
+    mouseTail[i].rotation = GetRandomValue(0, 360)
+    mouseTail[i].active = false
+end
+
+local gravity = 3.0
+
+local smoke = LoadTexture("resources/smoke.png")
+
+local blending = BlendMode.ALPHA
+
+SetTargetFPS(60)
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    
+    -- Activate one particle every frame and Update active particles
+    -- NOTE: Particles initial position should be mouse position when activated
+    -- NOTE: Particles fall down with gravity and rotation... and disappear after 2 seconds (alpha = 0)
+    -- NOTE: When a particle disappears, active = false and it can be reused.
+    for i = 1, MAX_PARTICLES do
+        if (not mouseTail[i].active) then
+            mouseTail[i].active = true
+            mouseTail[i].alpha = 1.0
+            mouseTail[i].position = GetMousePosition()
+            break
+        end
+    end
+
+    for i = 1, MAX_PARTICLES do
+        if (mouseTail[i].active) then
+            mouseTail[i].position.y = mouseTail[i].position.y + gravity
+            mouseTail[i].alpha = mouseTail[i].alpha - 0.01
+            
+            if (mouseTail[i].alpha <= 0.0) then mouseTail[i].active = false end
+            
+            mouseTail[i].rotation = mouseTail[i].rotation + 5.0
+        end
+    end
+    
+    if (IsKeyPressed(KEY.SPACE)) then
+        if (blending == BlendMode.ALPHA) then blending = BlendMode.ADDITIVE
+        else blending = BlendMode.ALPHA end
+    end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(DARKGRAY)
+        
+        BeginBlendMode(blending)
+
+            -- Draw active particles
+            for i = 1, MAX_PARTICLES do
+                if (mouseTail[i].active) then 
+                    DrawTexturePro(smoke, Rectangle(0, 0, smoke.width, smoke.height), 
+                        Rectangle(mouseTail[i].position.x, mouseTail[i].position.y, 
+                                  smoke.width*mouseTail[i].size//1, smoke.height*mouseTail[i].size//1),
+                        Vector2(smoke.width*mouseTail[i].size/2, smoke.height*mouseTail[i].size/2), 
+                        mouseTail[i].rotation, Fade(mouseTail[i].color, mouseTail[i].alpha)) end
+            end
+        
+        EndBlendMode()
+        
+        DrawText("PRESS SPACE to CHANGE BLENDING MODE", 180, 20, 20, BLACK)
+        
+        if (blending == BlendMode.ALPHA) then DrawText("ALPHA BLENDING", 290, screenHeight - 40, 20, BLACK)
+        else DrawText("ADDITIVE BLENDING", 280, screenHeight - 40, 20, RAYWHITE) end
+        
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(smoke)
+
+CloseWindow()        -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/textures_raw_data.lua

@@ -0,0 +1,83 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [textures] example - Load textures from raw data
+--
+--  NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM)
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+--#include <stdlib.h>     -- Required for malloc() and free()
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture from raw data")
+
+-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+
+-- Load RAW image data (512x512, 32bit RGBA, no file header)
+local sonicRaw = LoadImageRaw("resources/texture_formats/sonic_R8G8B8A8.raw", 512, 512, TextureFormat.UNCOMPRESSED_R8G8B8A8, 0)
+local sonic = LoadTextureFromImage(sonicRaw)   -- Upload CPU (RAM) image to GPU (VRAM)
+UnloadImage(sonicRaw)                              -- Unload CPU (RAM) image data
+
+-- Generate a checked texture by code (1024x1024 pixels)
+local width = 1024
+local height = 1024
+
+-- Dynamic memory allocation to store pixels data (Color type)
+local pixels = {}
+
+for y = 1, height do
+    for x = 1, width do
+        if ((((x - 1)/32+(y - 1)//32)//1)%2 == 0) then pixels[(y - 1)*height + x] = DARKBLUE
+        else pixels[(y - 1)*height + x] = SKYBLUE end
+    end
+end
+
+-- Load pixels data into an image structure and create texture
+local checkedIm = LoadImageEx(pixels, width, height)
+local checked = LoadTextureFromImage(checkedIm)
+UnloadImage(checkedIm)     -- Unload CPU (RAM) image data
+
+-- Dynamic memory must be freed after using it
+--free(pixels)               -- Unload CPU (RAM) pixels data
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update your variables here
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawTexture(checked, screenWidth/2 - checked.width/2, screenHeight/2 - checked.height/2, Fade(WHITE, 0.3))
+        DrawTexture(sonic, 330, -20, WHITE)
+
+        DrawText("CHECKED TEXTURE ", 84, 100, 30, DARKBLUE)
+        DrawText("GENERATED by CODE", 72, 164, 30, DARKBLUE)
+        DrawText("and RAW IMAGE LOADING", 46, 226, 30, DARKBLUE)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(sonic)       -- Texture unloading
+UnloadTexture(checked)     -- Texture unloading
+
+CloseWindow()              -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/textures_rectangle.lua

@@ -0,0 +1,69 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [textures] example - Texture loading and drawing a part defined by a rectangle
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [texture] example - texture rectangle")
+
+-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+local guybrush = LoadTexture("resources/guybrush.png")        -- Texture loading
+
+local position = Vector2(350.0, 240.0)
+local frameRec = Rectangle(0, 0, guybrush.width/7, guybrush.height)
+local currentFrame = 0
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    if (IsKeyPressed(KEY.RIGHT)) then
+        currentFrame = currentFrame + 1
+        
+        if (currentFrame > 6) then currentFrame = 0 end
+        
+        frameRec.x = currentFrame*guybrush.width/7
+    end
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawTexture(guybrush, 35, 40, WHITE)
+        DrawRectangleLines(35, 40, guybrush.width, guybrush.height, LIME)
+        
+        DrawTextureRec(guybrush, frameRec, position, WHITE)  -- Draw part of the texture
+        
+        DrawRectangleLines(35 + frameRec.x, 40 + frameRec.y, frameRec.width, frameRec.height, RED)
+        
+        DrawText("PRESS RIGHT KEY to", 540, 310, 10, GRAY)
+        DrawText("CHANGE DRAWING RECTANGLE", 520, 330, 10, GRAY)
+        
+        DrawText("Guybrush Ulysses Threepwood,", 100, 300, 10, GRAY)
+        DrawText("main character of the Monkey Island series", 80, 320, 10, GRAY)
+        DrawText("of computer adventure games by LucasArts.", 80, 340, 10, GRAY)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(guybrush)       -- Texture unloading
+
+CloseWindow()                 -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/textures_srcrec_dstrec.lua

@@ -0,0 +1,71 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [textures] example - Texture source and destination rectangles
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [textures] examples - texture source and destination rectangles")
+
+-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+local guybrush = LoadTexture("resources/guybrush.png")        -- Texture loading
+
+local frameWidth = guybrush.width/7
+local frameHeight = guybrush.height
+
+-- NOTE: Source rectangle (part of the texture to use for drawing)
+local sourceRec = Rectangle(0, 0, frameWidth, frameHeight)
+
+-- NOTE: Destination rectangle (screen rectangle where drawing part of texture)
+local destRec = Rectangle(screenWidth/2, screenHeight/2, frameWidth*2, frameHeight*2)
+
+-- NOTE: Origin of the texture (rotation/scale point), it's relative to destination rectangle size
+local origin = Vector2(frameWidth, frameHeight)
+
+local rotation = 0
+
+SetTargetFPS(60)
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    rotation = rotation + 1
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        -- NOTE: Using DrawTexturePro() we can easily rotate and scale the part of the texture we draw
+        -- sourceRec defines the part of the texture we use for drawing
+        -- destRec defines the rectangle where our texture part will fit (scaling it to fit)
+        -- origin defines the point of the texture used as reference for rotation and scaling
+        -- rotation defines the texture rotation (using origin as rotation point)
+        DrawTexturePro(guybrush, sourceRec, destRec, origin, rotation, WHITE)
+
+        DrawLine(destRec.x, 0, destRec.x, screenHeight, GRAY)
+        DrawLine(0, destRec.y, screenWidth, destRec.y, GRAY)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(guybrush)       -- Texture unloading
+
+CloseWindow()                -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

examples/textures_to_image.lua

@@ -0,0 +1,60 @@
+-------------------------------------------------------------------------------------------
+--
+--  raylib [textures] example - Retrieve image data from texture: GetTextureData() 
+--
+--  NOTE: Images are loaded in CPU memory (RAM) textures are loaded in GPU memory (VRAM)
+--
+--  This example has been created using raylib 1.6 (www.raylib.com)
+--  raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+--
+--  Copyright (c) 2014-2016 Ramon Santamaria (@raysan5)
+--
+-------------------------------------------------------------------------------------------
+
+-- Initialization
+-------------------------------------------------------------------------------------------
+local screenWidth = 800
+local screenHeight = 450
+
+InitWindow(screenWidth, screenHeight, "raylib [textures] example - texture to image")
+
+-- NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required)
+
+local image = LoadImage("resources/raylib_logo.png")  -- Load image data into CPU memory (RAM)
+local texture = LoadTextureFromImage(image)           -- Image converted to texture, GPU memory (RAM -> VRAM)
+UnloadImage(image)                                    -- Unload image data from CPU memory (RAM)
+
+image = GetTextureData(texture)                       -- Retrieve image data from GPU memory (VRAM -> RAM)
+UnloadTexture(texture)                                -- Unload texture from GPU memory (VRAM)
+
+texture = LoadTextureFromImage(image)                 -- Recreate texture from retrieved image data (RAM -> VRAM)
+UnloadImage(image)                                    -- Unload retrieved image data from CPU memory (RAM)
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    -- TODO: Update your variables here
+    ---------------------------------------------------------------------------------------
+
+    -- Draw
+    ---------------------------------------------------------------------------------------
+    BeginDrawing()
+
+        ClearBackground(RAYWHITE)
+
+        DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE)
+
+        DrawText("this IS a texture loaded from an image!", 300, 370, 10, GRAY)
+
+    EndDrawing()
+    ---------------------------------------------------------------------------------------
+end
+
+-- De-Initialization
+-------------------------------------------------------------------------------------------
+UnloadTexture(texture)       -- Texture unloading
+
+CloseWindow()                -- Close window and OpenGL context
+-------------------------------------------------------------------------------------------

games/arkanoid.lua

@@ -0,0 +1,297 @@
+--[[
+
+   raylib - sample game: arkanoid
+
+   Sample game Marc Palau and Ramon Santamaria
+
+   This game has been created using raylib v1.3 (www.raylib.com)
+   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+
+   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+   
+   Translated to Lua by Ghassan Al-Mashareqa (ghassan@ghassan.pl)
+
+--]]
+
+------------------------------------------------------------------------------------
+-- Some Defines
+------------------------------------------------------------------------------------
+PLAYER_MAX_LIFE = 5
+LINES_OF_BRICKS = 5
+BRICKS_PER_LINE = 20
+
+------------------------------------------------------------------------------------
+-- Types and Structures Definition
+------------------------------------------------------------------------------------
+
+GameScreen = { LOGO = 0, TITLE = 1, GAMEPLAY = 2, ENDING = 3 }
+
+function Player()
+	return { position = Vector2(0,0), size = Vector2(0,0), life = 0 }
+end
+
+function Ball()
+	return { position = Vector2(0,0), speed = Vector2(0,0), radius = 0, active = false }
+end
+
+function Brick()
+	return { position = Vector2(0,0), active = false }
+end
+
+--------------------------------------------------------------------------------------
+-- Global Variables Declaration
+--------------------------------------------------------------------------------------
+screenWidth = 800;
+screenHeight = 450;
+
+framesCounter = 0;
+gameOver = false;
+pause = false;
+
+player = Player()
+ball = Ball()
+brick = {}--[LINES_OF_BRICKS][BRICKS_PER_LINE];
+for i = 0, LINES_OF_BRICKS-1 do
+	brick[i] = {}
+	for j = 0, BRICKS_PER_LINE-1 do
+		brick[i][j] = Brick()
+	end
+end
+brickSize = Vector2(0,0)
+
+
+--------------------------------------------------------------------------------------
+-- Module Functions Definitions (local)
+--------------------------------------------------------------------------------------
+
+-- Initialize game variables
+function InitGame()
+
+    brickSize = Vector2(GetScreenWidth()/BRICKS_PER_LINE, 40)
+
+    -- Initialize player
+    player.position = Vector2(screenWidth/2, screenHeight*7/8)
+    player.size = Vector2(screenWidth/10, 20)
+    player.life = PLAYER_MAX_LIFE;
+    
+    -- Initialize ball
+    ball.position = Vector2(screenWidth/2, screenHeight*7/8 - 30)
+    ball.speed = Vector2(0, 0)
+    ball.radius = 7;
+    ball.active = false;
+    
+    -- Initialize bricks
+    local initialDownPosition = 50;
+
+    for i = 0, LINES_OF_BRICKS-1 do
+        for j = 0, BRICKS_PER_LINE-1 do
+            brick[i][j].position = Vector2(j*brickSize.x + brickSize.x/2, i*brickSize.y + initialDownPosition)
+            brick[i][j].active = true;
+        end
+    end
+end
+
+-- Update game (one frame)
+function UpdateGame()
+
+    if (not gameOver) then
+        if (IsKeyPressed(KEY.P)) then pause = not pause; end
+
+        if (not pause) then
+            -- Player movement
+            if (IsKeyDown(KEY.LEFT)) then player.position.x = player.position.x - 5; end
+            if ((player.position.x - player.size.x/2) <= 0) then player.position.x = player.size.x/2; end
+            if (IsKeyDown(KEY.RIGHT)) then player.position.x = player.position.x + 5; end
+            if ((player.position.x + player.size.x/2) >= screenWidth) then player.position.x = screenWidth - player.size.x/2; end
+
+            -- Launch ball
+            if (not ball.active) then
+                if (IsKeyPressed(KEY.SPACE)) then
+                    ball.active = true;
+                    ball.speed = Vector2(0, -5)
+                end
+            end
+            
+            UpdateBall();
+
+            -- Game over logic
+            if (player.life <= 0) then
+							gameOver = true;
+            else
+                gameOver = true;
+                
+                for i = 0, LINES_OF_BRICKS-1 do
+                    for j = 0, BRICKS_PER_LINE-1 do
+                        if (brick[i][j].active) then gameOver = false; end
+                    end
+                end
+            end
+        end
+    else
+        if (IsKeyPressed(KEY.ENTER)) then
+            InitGame();
+            gameOver = false;
+        end
+    end
+
+end
+
+-- Draw game (one frame)
+function DrawGame()
+
+    BeginDrawing();
+
+        ClearBackground(RAYWHITE);
+
+        if (not gameOver) then
+            -- Draw player bar
+            DrawRectangle(player.position.x - player.size.x/2, player.position.y - player.size.y/2, player.size.x, player.size.y, BLACK);
+
+            -- Draw player lives
+            for i = 0, player.life-1 do
+							DrawRectangle(20 + 40*i, screenHeight - 30, 35, 10, LIGHTGRAY);
+						end
+            
+            -- Draw ball
+            DrawCircleV(ball.position, ball.radius, MAROON);
+            
+            -- Draw bricks
+            for i = 0, LINES_OF_BRICKS-1 do
+                for j = 0, BRICKS_PER_LINE-1 do
+                    if (brick[i][j].active) then
+                        if ((i + j) % 2 == 0) then
+													DrawRectangle(brick[i][j].position.x - brickSize.x/2, brick[i][j].position.y - brickSize.y/2, brickSize.x, brickSize.y, GRAY);
+                        else 
+													DrawRectangle(brick[i][j].position.x - brickSize.x/2, brick[i][j].position.y - brickSize.y/2, brickSize.x, brickSize.y, DARKGRAY);
+												end
+                    end
+                end
+            end
+            
+            if (pause) then
+							DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY);
+						end
+        else 
+					DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY);
+				end
+
+    EndDrawing();
+end
+
+-- Unload game variables
+function UnloadGame()
+    -- TODO: Unload all dynamic loaded data (textures, sounds, models...)
+end
+
+-- Update and Draw (one frame)
+function UpdateDrawFrame()
+    UpdateGame();
+    DrawGame();
+end
+
+----------------------------------------------------------------------------------------
+-- Additional module functions
+----------------------------------------------------------------------------------------
+function UpdateBall()
+    -- Update position
+    if (ball.active) then
+        ball.position.x = ball.position.x + ball.speed.x;
+        ball.position.y = ball.position.y + ball.speed.y;
+    else
+        ball.position = Vector2(player.position.x, screenHeight*7/8 - 30);
+    end
+
+    -- Bounce in x
+    if (((ball.position.x + ball.radius) >= screenWidth) or ((ball.position.x - ball.radius) <= 0)) 
+    then
+			ball.speed.x = ball.speed.x * -1;
+		end
+
+    -- Bounce in y
+    if ((ball.position.y - ball.radius) <= 0) then
+			ball.speed.y = ball.speed.y * -1;
+		end
+
+    -- Ball reaches bottom of the screen
+    if ((ball.position.y + ball.radius) >= screenHeight) then
+        ball.speed = Vector2(0, 0);
+        ball.active = false;
+
+        player.life = player.life - 1;
+    end
+
+    -- Collision logic: ball vs player
+    if CheckCollisionCircleRec(ball.position, ball.radius, 
+				Rectangle(
+					player.position.x - player.size.x/2, 
+					player.position.y - player.size.y/2, 
+					player.size.x, 
+					player.size.y)) then
+        if (ball.speed.y > 0) then
+            ball.speed.y = ball.speed.y * -1;
+            ball.speed.x = (ball.position.x - player.position.x)/(player.size.x/2)*5;
+        end
+    end
+
+    -- Collision logic: ball vs bricks
+    for i = 0,LINES_OF_BRICKS-1 do
+        for j = 0,BRICKS_PER_LINE-1 do
+            if (brick[i][j].active) then
+                -- Hit below
+                if (((ball.position.y - ball.radius) <= (brick[i][j].position.y + brickSize.y/2)) and
+                    ((ball.position.y - ball.radius) > (brick[i][j].position.y + brickSize.y/2 + ball.speed.y)) and
+                    ((math.abs(ball.position.x - brick[i][j].position.x)) < (brickSize.x/2 + ball.radius*2/3)) and (ball.speed.y < 0))
+                then
+                    brick[i][j].active = false;
+                    ball.speed.y = ball.speed.y * -1;
+                -- Hit above
+                elseif (((ball.position.y + ball.radius) >= (brick[i][j].position.y - brickSize.y/2)) and
+                        ((ball.position.y + ball.radius) < (brick[i][j].position.y - brickSize.y/2 + ball.speed.y)) and
+                        ((math.abs(ball.position.x - brick[i][j].position.x)) < (brickSize.x/2 + ball.radius*2/3)) and (ball.speed.y > 0))
+                then
+                    brick[i][j].active = false;
+                    ball.speed.y = ball.speed.y * -1;
+                -- Hit left
+                elseif (((ball.position.x + ball.radius) >= (brick[i][j].position.x - brickSize.x/2)) and
+                        ((ball.position.x + ball.radius) < (brick[i][j].position.x - brickSize.x/2 + ball.speed.x)) and
+                        ((math.abs(ball.position.y - brick[i][j].position.y)) < (brickSize.y/2 + ball.radius*2/3)) and (ball.speed.x > 0))
+                then
+                    brick[i][j].active = false;
+                    ball.speed.x = ball.speed.x * -1;
+                -- Hit right
+                elseif (((ball.position.x - ball.radius) <= (brick[i][j].position.x + brickSize.x/2)) and
+                        ((ball.position.x - ball.radius) > (brick[i][j].position.x + brickSize.x/2 + ball.speed.x)) and
+                        ((math.abs(ball.position.y - brick[i][j].position.y)) < (brickSize.y/2 + ball.radius*2/3)) and (ball.speed.x < 0))
+                then
+                    brick[i][j].active = false;
+                    ball.speed.x = ball.speed.x * -1;
+                end
+            end
+        end
+    end
+end
+
+InitWindow(screenWidth, screenHeight, "sample game: arkanoid");
+
+InitGame();
+
+SetTargetFPS(60);
+----------------------------------------------------------------------------------------
+
+-- Main game loop
+while (not WindowShouldClose())    -- Detect window close button or ESC key
+do
+		-- Update
+		------------------------------------------------------------------------------------
+		UpdateGame();
+		------------------------------------------------------------------------------------
+
+		-- Draw
+		------------------------------------------------------------------------------------
+		DrawGame();
+		------------------------------------------------------------------------------------
+end
+
+UnloadGame();         -- Unload loaded data (textures, sounds, models...)
+
+CloseWindow();        -- Close window and OpenGL context

games/drturtle/05_drturtle_audio.c

@@ -12,7 +12,7 @@
 *
 *   Enjoy using raylib. :)
 *
-*   This game has been created using raylib 1.1 (www.raylib.com)
+*   This game has been created using raylib 1.6 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
 *   Copyright (c) 2014 Ramon Santamaria (Ray San - raysan@raysanweb.com)
@@ -59,8 +59,9 @@ int main()
     Sound die = LoadSound("resources/die.wav");
     Sound growl = LoadSound("resources/gamera.wav");
     
-    // Start playing streaming music
+    // Load music stream and start playing music
-    PlayMusicStream("resources/speeding.ogg");
+    Music music = LoadMusicStream("resources/speeding.ogg");
+    PlayMusicStream(music);
 
     // Define scrolling variables
     int backScrolling = 0;
@@ -118,6 +119,8 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
+        UpdateMusicStream(music);   // Refill music stream buffers (if required)
+        
         framesCounter++;
 
         // Game screens management
@@ -458,7 +461,7 @@ int main()
     UnloadSound(die);
     UnloadSound(growl);
     
-    StopMusicStream();      // Stop music
+    UnloadMusicStream(music);   // Unload music
     CloseAudioDevice();         // Close audio device
     
     CloseWindow();              // Close window and OpenGL context

games/drturtle/06_drturtle_final.c

@@ -12,7 +12,7 @@
 *
 *   Enjoy using raylib. :)
 *
-*   This game has been created using raylib 1.1 (www.raylib.com)
+*   This game has been created using raylib 1.6 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
 *   Copyright (c) 2014 Ramon Santamaria (Ray San - raysan@raysanweb.com)
@@ -62,8 +62,9 @@ int main()
     Sound die = LoadSound("resources/die.wav");
     Sound growl = LoadSound("resources/gamera.wav");
     
-    // Start playing streaming music
+    // Load music stream and start playing music
-    PlayMusicStream("resources/speeding.ogg");
+    Music music = LoadMusicStream("resources/speeding.ogg");
+    PlayMusicStream(music);
 
     // Define scrolling variables
     int backScrolling = 0;
@@ -127,6 +128,8 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
+        UpdateMusicStream(music);   // Refill music stream buffers (if required)
+        
         framesCounter++;
         
         // Sea color tint effect
@@ -483,7 +486,7 @@ int main()
     UnloadSound(die);
     UnloadSound(growl);
     
-    StopMusicStream();      // Stop music
+    UnloadMusicStream(music);   // Unload music
     CloseAudioDevice();         // Close audio device
     
     CloseWindow();              // Close window and OpenGL context

games/drturtle/drturtle_final_web.c

@@ -12,7 +12,7 @@
 *
 *   Enjoy using raylib. :)
 *
-*   This game has been created using raylib 1.1 (www.raylib.com)
+*   This game has been created using raylib 1.6 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
 *   Copyright (c) 2014 Ramon Santamaria (Ray San - raysan@raysanweb.com)
@@ -54,6 +54,8 @@ Sound eat;
 Sound die;
 Sound growl;
 
+Music music;
+
 // Define scrolling variables
 int backScrolling = 0;
 int seaScrolling = 0;
@@ -124,8 +126,9 @@ int main()
     die = LoadSound("resources/die.wav");
     growl = LoadSound("resources/gamera.wav");
     
-    // Start playing streaming music
+    // Load music stream and start playing music
-    PlayMusicStream("resources/speeding.ogg");
+    music = LoadMusicStream("resources/speeding.ogg");
+    PlayMusicStream(music);
     
     playerBounds = (Rectangle){ 30 + 14, playerRail*120 + 90 + 14, 100, 100 };
     
@@ -190,7 +193,7 @@ int main()
     UnloadSound(die);
     UnloadSound(growl);
     
-    StopMusicStream();      // Stop music
+    UnloadMusicStream(music);   // Unload music
     CloseAudioDevice();         // Close audio device
     
     CloseWindow();              // Close window and OpenGL context
@@ -206,7 +209,7 @@ void UpdateDrawFrame(void)
 {
     // Update
     //----------------------------------------------------------------------------------
-    UpdateMusicStream();
+    UpdateMusicStream(music);   // Refill music stream buffers (if required)
         
     framesCounter++;
     

games/just_do/just_do.c

@@ -6,7 +6,7 @@
 *
 *   Developed by: Ramon Santamaria (Ray San)
 *
-*   This game has been created using raylib (www.raylib.com)
+*   This game has been created using raylib 1.6 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
 *   raylib - Copyright (c) 2015 Ramon Santamaria (Ray San - raysan@raysanweb.com)
@@ -35,6 +35,7 @@ int transToScreen = -1;
 int framesCounter = 0;
 
 //static Sound levelWin;
+Music music;
 
 //----------------------------------------------------------------------------------
 // Local Functions Declaration
@@ -57,10 +58,11 @@ int main(void)
     //SetupFlags(FLAG_FULLSCREEN_MODE);
     InitWindow(screenWidth, screenHeight, windowTitle);
 
-    // TODO: Load global data here (assets that must be available in all screens, i.e. fonts)
+    // Load global data here (assets that must be available in all screens, i.e. fonts)
     InitAudioDevice();
     
     levelWin = LoadSound("resources/win.wav");
+    music = LoadMusicStream("resources/ambient.ogg");
     
     // Setup and Init first screen
     currentScreen = LOGO;
@@ -85,8 +87,9 @@ int main(void)
     // De-Initialization
     //--------------------------------------------------------------------------------------
     
-    // TODO: Unload all global loaded data (i.e. fonts) here!
+    // Unload all global loaded data (i.e. fonts) here!
     UnloadSound(levelWin);
+    UnloadMusicStream(music);
     
     CloseAudioDevice();
     
@@ -197,6 +200,8 @@ void UpdateDrawFrame(void)
             InitLevel08Screen();
         }
         
+        UpdateMusicStream(music);
+        
         switch(currentScreen) 
         {
             case LOGO: 
@@ -209,8 +214,8 @@ void UpdateDrawFrame(void)
                     TransitionToScreen(LEVEL00);
                     InitLevel00Screen();
                     
-                    PlayMusicStream("resources/ambient.ogg");
+                    PlayMusicStream(music);
-                    SetMusicVolume(0.6f);
+                    SetMusicVolume(music, 0.6f);
                 }
             } break;
             case LEVEL00: 

games/light_my_ritual/light_my_ritual.c

@@ -36,6 +36,8 @@ bool transFadeOut = false;
 int transFromScreen = -1;
 int transToScreen = -1;
 
+static Music music;
+    
 //----------------------------------------------------------------------------------
 // Local Functions Declaration
 //----------------------------------------------------------------------------------
@@ -66,12 +68,14 @@ int main(void)
     
     UnloadImage(image);                         // Unload image from CPU memory (RAM)
     
-    //PlayMusicStream("resources/audio/come_play_with_me.ogg");
-    
     font = LoadSpriteFont("resources/font_arcadian.png");
 	//doors = LoadTexture("resources/textures/doors.png");
     //sndDoor = LoadSound("resources/audio/door.ogg");
     
+    music = LoadMusicStream("resources/audio/ambient.ogg");
+    PlayMusicStream(music);
+    SetMusicVolume(music, 1.0f);
+
     // Setup and Init first screen
     currentScreen = LOGO_RL;
     //InitTitleScreen();
@@ -105,6 +109,8 @@ int main(void)
     UnloadSpriteFont(font);
     //UnloadSound(sndDoor);
     
+    UnloadMusicStream(music);
+    
     free(lightsMap);
     
     CloseAudioDevice();
@@ -224,7 +230,11 @@ void UpdateDrawFrame(void)
             {
                 UpdateTitleScreen();
                 
-                if (FinishTitleScreen() == 1) TransitionToScreen(GAMEPLAY);
+                if (FinishTitleScreen() == 1)
+                {
+                    StopMusicStream(music);
+                    TransitionToScreen(GAMEPLAY);
+                }
 
             } break;
             case GAMEPLAY:
@@ -244,7 +254,7 @@ void UpdateDrawFrame(void)
         UpdateTransition();
     }
     
-    UpdateMusicStream();
+    if (currentScreen != GAMEPLAY) UpdateMusicStream(music);
     //----------------------------------------------------------------------------------
     
     // Draw

games/light_my_ritual/screens/screen_gameplay.c

@@ -64,7 +64,7 @@ typedef struct Enemy {
     Color color;
 } Enemy;
 
-typedef struct Light {
+typedef struct LightSpot {
     Vector2 position;
     int radius;
     int requiredEnergy;
@@ -74,7 +74,7 @@ typedef struct Light {
     int framesCounter;
     int currentFrame;
     Rectangle frameRec;
-} Light;
+} LightSpot;
 
 typedef enum { LEVEL_I, LEVEL_II, LEVEL_III, LEVEL_FINISHED } LightedLevel;
 
@@ -92,9 +92,9 @@ static bool pause;
 
 static Player player;
 
-static Light lightsI[MAX_LIGHTS_I];
+static LightSpot lightsI[MAX_LIGHTS_I];
-static Light lightsII[MAX_LIGHTS_II];
+static LightSpot lightsII[MAX_LIGHTS_II];
-static Light lightsIII[MAX_LIGHTS_III];
+static LightSpot lightsIII[MAX_LIGHTS_III];
 
 static Enemy enemies[MAX_ENEMIES];
 
@@ -133,6 +133,8 @@ static Rectangle lightOff, lightOn;
 
 static Sound fxLightOn, fxLightOff;
 
+static Music music;
+
 // Debug variables
 static bool enemiesStopped;
 
@@ -286,7 +288,8 @@ void InitGameplayScreen(void)
     
     enemiesStopped = false;
     
-    PlayMusicStream("resources/audio/ritual.ogg");
+    music = LoadMusicStream("resources/audio/ritual.ogg");
+    PlayMusicStream(music);
 }
 
 // Gameplay Screen Update logic
@@ -549,10 +552,12 @@ void UpdateGameplayScreen(void)
     {
         alphaRitual += 0.02f;
         
-        SetMusicVolume(1.0f - alphaRitual);  
+        SetMusicVolume(music, 1.0f - alphaRitual);  
         
         if (alphaRitual > 1.0f) finishScreen = 1;
     }
+    
+    UpdateMusicStream(music);
 }
 
 // Gameplay Screen Draw logic
@@ -757,6 +762,8 @@ void UnloadGameplayScreen(void)
     // Unload sounds
     UnloadSound(fxLightOn);
     UnloadSound(fxLightOff);
+    
+    UnloadMusicStream(music);
 }
 
 // Gameplay Screen should finish?

games/light_my_ritual/screens/screen_logo_raylib.c

@@ -75,9 +75,6 @@ void rlInitLogoScreen(void)
     
     state = 0;
     alpha = 1.0f;
-    
-    PlayMusicStream("resources/audio/ambient.ogg");
-    SetMusicVolume(1.0f);
 }
 
 // Logo Screen Update logic
@@ -204,7 +201,7 @@ void rlDrawLogoScreen(void)
 // Logo Screen Unload logic
 void rlUnloadLogoScreen(void)
 {
-    // TODO: Unload LOGO screen variables here!
+    // Unload LOGO screen variables here!
 }
 
 // Logo Screen should finish?

games/makefile

@@ -86,8 +86,6 @@ else
 # external libraries headers
 # GLFW3
     INCLUDES += -I../external/glfw3/include
-# GLEW - Not required any more, replaced by GLAD
-    #INCLUDES += -I../external/glew/include
 # OpenAL Soft
     INCLUDES += -I../external/openal_soft/include
 endif
@@ -103,8 +101,6 @@ else
     ifneq ($(PLATFORM_OS),OSX)
     # OpenAL Soft
     	LFLAGS += -L../external/openal_soft/lib/$(LIBPATH)
-    # GLEW: Not used, replaced by GLAD
-        #LFLAGS += -L../../external/glew/lib/$(LIBPATH)
     endif
 endif
 
@@ -115,9 +111,9 @@ ifeq ($(PLATFORM),PLATFORM_DESKTOP)
         # libraries for Debian GNU/Linux desktop compiling
         # requires the following packages:
         # libglfw3-dev libopenal-dev libglew-dev libegl1-mesa-dev
-        LIBS = -lraylib -lglfw3 -lGLEW -lGL -lopenal -lm -pthread
+        LIBS = -lraylib -lglfw3 -lGLEW -lGL -lopenal -lm -lpthread -ldl
-	# on XWindow could require also below libraries, just uncomment
+        # on XWindow could require also below libraries:
-	#LIBS += -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor
+        LIBS += -lX11 -lXrandr -lXinerama -lXi -lXxf86vm -lXcursor
     else
     ifeq ($(PLATFORM_OS),OSX)
         # libraries for OS X 10.9 desktop compiling

games/raylib_demo/raylib_demo.c

@@ -123,6 +123,8 @@ Model cat;
 Sound fxWav;
 Sound fxOgg;
 
+Music music;
+
 Vector2 soundBallsPosition[MAX_BALLS];
 Color soundBallsColor[MAX_BALLS];
 bool soundBallsActive[MAX_BALLS];
@@ -203,11 +205,13 @@ int main()
 
     catTexture = LoadTexture("resources/catsham.png");   // Load model texture
     cat = LoadModel("resources/cat.obj");                // Load OBJ model
-    cat.material.texDiffuse = texture;                   // Set cat model diffuse texture
+    cat.material.texDiffuse = catTexture;                // Set cat model diffuse texture
     
     fxWav = LoadSound("resources/audio/weird.wav");         // Load WAV audio file
     fxOgg = LoadSound("resources/audio/tanatana.ogg");      // Load OGG audio file
     
+    music = LoadMusicStream("resources/audio/guitar_noodling.ogg");     // Load music
+    
     for (int i = 0; i < MAX_BALLS; i++)
     {
         soundBallsPosition[i] = (Vector2){ 650 + 560/2 + GetRandomValue(-280, 280), 220 + 200 + GetRandomValue(-200, 200) };
@@ -268,6 +272,8 @@ int main()
     UnloadSound(fxWav);
     UnloadSound(fxOgg);
     
+    UnloadMusicStream(music);
+
     CloseAudioDevice();
     
     CloseWindow();        // Close window and OpenGL context
@@ -464,11 +470,11 @@ void UpdateDrawOneFrame(void)
 
                 if (selectedModule == AUDIO)
                 {
-                    if (IsKeyPressed(KEY_SPACE) && !MusicIsPlaying()) PlayMusicStream("resources/audio/guitar_noodling.ogg");         // Play music stream
+                    if (IsKeyPressed(KEY_SPACE) && !IsMusicPlaying(music)) PlayMusicStream(music);         // Play music stream
 
                     if (IsKeyPressed('S'))
                     {
-                        StopMusicStream();
+                        StopMusicStream(music);
                         timePlayed = 0.0f;
 
                         for (int i = 0; i < MAX_BALLS; i++)
@@ -482,9 +488,11 @@ void UpdateDrawOneFrame(void)
                         }
                     }
 
-                    if (MusicIsPlaying())
+                    if (IsMusicPlaying(music))
                     {
-                        timePlayed = GetMusicTimePlayed() / GetMusicTimeLength() * 100 * 4;
+                        UpdateMusicStream(music);
+                        
+                        timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*100*4;
 
                         if ((framesCounter%10) == 0)
                         {
@@ -842,7 +850,7 @@ void UpdateDrawOneFrame(void)
                         DrawRectangle(150, 390, 400, 12, LIGHTGRAY);
                         DrawRectangle(150, 390, (int)timePlayed, 12, MAROON);
 
-                        if (MusicIsPlaying())
+                        if (IsMusicPlaying(music))
                         {
                             DrawText("PRESS 'S' to STOP PLAYING MUSIC", 165, 425, 20, GRAY);
 

games/skully_escape/skully_escape.c

@@ -2,7 +2,7 @@
 *
 *   SKULLY ESCAPE [KING GAME JAM 2015]
 *
-*   This game has been created using raylib (www.raylib.com)
+*   This game has been created using raylib 1.6 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
 *   Copyright (c) 2014 Ramon Santamaria (Ray San - raysan@raysanweb.com)
@@ -33,6 +33,8 @@ int transToScreen = -1;
 
 static int framesCounter = 0;
 
+Music music;
+    
 //----------------------------------------------------------------------------------
 // Local Functions Declaration
 //----------------------------------------------------------------------------------
@@ -57,7 +59,8 @@ int main(void)
     // Global data loading (assets that must be available in all screens, i.e. fonts)
     InitAudioDevice();
     
-    PlayMusicStream("resources/audio/come_play_with_me.ogg");
+    music = LoadMusicStream("resources/audio/come_play_with_me.ogg");
+    PlayMusicStream(music);
     
     font = LoadSpriteFont("resources/textures/alagard.png");
 	doors = LoadTexture("resources/textures/doors.png");
@@ -93,6 +96,8 @@ int main(void)
     UnloadSound(sndDoor);
     UnloadSound(sndScream);
     
+    UnloadMusicStream(music);
+    
     CloseAudioDevice();
     
     CloseWindow();        // Close window and OpenGL context
@@ -368,7 +373,7 @@ void UpdateDrawFrame(void)
         UpdateTransition();
     }
     
-    UpdateMusicStream();
+    UpdateMusicStream(music);
     //----------------------------------------------------------------------------------
     
     // Draw

project/vs2015/examples/core_basic_window.vcxproj

@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{0981CA98-E4A5-4DF1-987F-A41D09131EFC}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>core_basic_window</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+    <ProjectName>core_basic_window</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;PLATFORM_DESKTOP;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>CompileAsC</CompileAs>
+      <AdditionalIncludeDirectories>$(SolutionDir)..\..\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalLibraryDirectories>$(SolutionDir)external\glfw3\lib\win32;$(SolutionDir)external\openal_soft\lib\win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;glfw3.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\examples\core_basic_window.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\raylib\raylib.vcxproj">
+      <Project>{e89d61ac-55de-4482-afd4-df7242ebc859}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

project/vs2015/examples/core_basic_window_cpp.vcxproj

@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{B655E850-3322-42F7-941D-6AC18FD66CA1}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>raylib_example_cpp</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+    <ProjectName>core_basic_window_cpp</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(SolutionDir)..\..\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <CompileAs>CompileAsCpp</CompileAs>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;glfw3.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>$(SolutionDir)external\glfw3\lib\win32;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\raylib\raylib.vcxproj">
+      <Project>{e89d61ac-55de-4482-afd4-df7242ebc859}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\examples\core_basic_window.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

project/vs2015/external/glfw3/COPYING.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2002-2006 Marcus Geelnard
+Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would
+   be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not
+   be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+   distribution.
+

project/vs2015/external/glfw3/include/GLFW/glfw3native.h

@@ -0,0 +1,456 @@
+/*************************************************************************
+ * GLFW 3.2 - www.glfw.org
+ * A library for OpenGL, window and input
+ *------------------------------------------------------------------------
+ * Copyright (c) 2002-2006 Marcus Geelnard
+ * Copyright (c) 2006-2016 Camilla Berglund <elmindreda@glfw.org>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would
+ *    be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and must not
+ *    be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ *    distribution.
+ *
+ *************************************************************************/
+
+#ifndef _glfw3_native_h_
+#define _glfw3_native_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*************************************************************************
+ * Doxygen documentation
+ *************************************************************************/
+
+/*! @file glfw3native.h
+ *  @brief The header of the native access functions.
+ *
+ *  This is the header file of the native access functions.  See @ref native for
+ *  more information.
+ */
+/*! @defgroup native Native access
+ *
+ *  **By using the native access functions you assert that you know what you're
+ *  doing and how to fix problems caused by using them.  If you don't, you
+ *  shouldn't be using them.**
+ *
+ *  Before the inclusion of @ref glfw3native.h, you may define exactly one
+ *  window system API macro and zero or more context creation API macros.
+ *
+ *  The chosen backends must match those the library was compiled for.  Failure
+ *  to do this will cause a link-time error.
+ *
+ *  The available window API macros are:
+ *  * `GLFW_EXPOSE_NATIVE_WIN32`
+ *  * `GLFW_EXPOSE_NATIVE_COCOA`
+ *  * `GLFW_EXPOSE_NATIVE_X11`
+ *  * `GLFW_EXPOSE_NATIVE_WAYLAND`
+ *  * `GLFW_EXPOSE_NATIVE_MIR`
+ *
+ *  The available context API macros are:
+ *  * `GLFW_EXPOSE_NATIVE_WGL`
+ *  * `GLFW_EXPOSE_NATIVE_NSGL`
+ *  * `GLFW_EXPOSE_NATIVE_GLX`
+ *  * `GLFW_EXPOSE_NATIVE_EGL`
+ *
+ *  These macros select which of the native access functions that are declared
+ *  and which platform-specific headers to include.  It is then up your (by
+ *  definition platform-specific) code to handle which of these should be
+ *  defined.
+ */
+
+
+/*************************************************************************
+ * System headers and types
+ *************************************************************************/
+
+#if defined(GLFW_EXPOSE_NATIVE_WIN32)
+ // This is a workaround for the fact that glfw3.h needs to export APIENTRY (for
+ // example to allow applications to correctly declare a GL_ARB_debug_output
+ // callback) but windows.h assumes no one will define APIENTRY before it does
+ #undef APIENTRY
+ #include <windows.h>
+#elif defined(GLFW_EXPOSE_NATIVE_COCOA)
+ #include <ApplicationServices/ApplicationServices.h>
+ #if defined(__OBJC__)
+  #import <Cocoa/Cocoa.h>
+ #else
+  typedef void* id;
+ #endif
+#elif defined(GLFW_EXPOSE_NATIVE_X11)
+ #include <X11/Xlib.h>
+ #include <X11/extensions/Xrandr.h>
+#elif defined(GLFW_EXPOSE_NATIVE_WAYLAND)
+ #include <wayland-client.h>
+#elif defined(GLFW_EXPOSE_NATIVE_MIR)
+ #include <mir_toolkit/mir_client_library.h>
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_WGL)
+ /* WGL is declared by windows.h */
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_NSGL)
+ /* NSGL is declared by Cocoa.h */
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_GLX)
+ #include <GL/glx.h>
+#endif
+#if defined(GLFW_EXPOSE_NATIVE_EGL)
+ #include <EGL/egl.h>
+#endif
+
+
+/*************************************************************************
+ * Functions
+ *************************************************************************/
+
+#if defined(GLFW_EXPOSE_NATIVE_WIN32)
+/*! @brief Returns the adapter device name of the specified monitor.
+ *
+ *  @return The UTF-8 encoded adapter device name (for example `\\.\DISPLAY1`)
+ *  of the specified monitor, or `NULL` if an [error](@ref error_handling)
+ *  occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI const char* glfwGetWin32Adapter(GLFWmonitor* monitor);
+
+/*! @brief Returns the display device name of the specified monitor.
+ *
+ *  @return The UTF-8 encoded display device name (for example
+ *  `\\.\DISPLAY1\Monitor0`) of the specified monitor, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI const char* glfwGetWin32Monitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the `HWND` of the specified window.
+ *
+ *  @return The `HWND` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI HWND glfwGetWin32Window(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_WGL)
+/*! @brief Returns the `HGLRC` of the specified window.
+ *
+ *  @return The `HGLRC` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_COCOA)
+/*! @brief Returns the `CGDirectDisplayID` of the specified monitor.
+ *
+ *  @return The `CGDirectDisplayID` of the specified monitor, or
+ *  `kCGNullDirectDisplay` if an [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI CGDirectDisplayID glfwGetCocoaMonitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the `NSWindow` of the specified window.
+ *
+ *  @return The `NSWindow` of the specified window, or `nil` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI id glfwGetCocoaWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_NSGL)
+/*! @brief Returns the `NSOpenGLContext` of the specified window.
+ *
+ *  @return The `NSOpenGLContext` of the specified window, or `nil` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI id glfwGetNSGLContext(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_X11)
+/*! @brief Returns the `Display` used by GLFW.
+ *
+ *  @return The `Display` used by GLFW, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI Display* glfwGetX11Display(void);
+
+/*! @brief Returns the `RRCrtc` of the specified monitor.
+ *
+ *  @return The `RRCrtc` of the specified monitor, or `None` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI RRCrtc glfwGetX11Adapter(GLFWmonitor* monitor);
+
+/*! @brief Returns the `RROutput` of the specified monitor.
+ *
+ *  @return The `RROutput` of the specified monitor, or `None` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.1.
+ *
+ *  @ingroup native
+ */
+GLFWAPI RROutput glfwGetX11Monitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the `Window` of the specified window.
+ *
+ *  @return The `Window` of the specified window, or `None` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI Window glfwGetX11Window(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_GLX)
+/*! @brief Returns the `GLXContext` of the specified window.
+ *
+ *  @return The `GLXContext` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* window);
+
+/*! @brief Returns the `GLXWindow` of the specified window.
+ *
+ *  @return The `GLXWindow` of the specified window, or `None` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_WAYLAND)
+/*! @brief Returns the `struct wl_display*` used by GLFW.
+ *
+ *  @return The `struct wl_display*` used by GLFW, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI struct wl_display* glfwGetWaylandDisplay(void);
+
+/*! @brief Returns the `struct wl_output*` of the specified monitor.
+ *
+ *  @return The `struct wl_output*` of the specified monitor, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI struct wl_output* glfwGetWaylandMonitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the main `struct wl_surface*` of the specified window.
+ *
+ *  @return The main `struct wl_surface*` of the specified window, or `NULL` if
+ *  an [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI struct wl_surface* glfwGetWaylandWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_MIR)
+/*! @brief Returns the `MirConnection*` used by GLFW.
+ *
+ *  @return The `MirConnection*` used by GLFW, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI MirConnection* glfwGetMirDisplay(void);
+
+/*! @brief Returns the Mir output ID of the specified monitor.
+ *
+ *  @return The Mir output ID of the specified monitor, or zero if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI int glfwGetMirMonitor(GLFWmonitor* monitor);
+
+/*! @brief Returns the `MirSurface*` of the specified window.
+ *
+ *  @return The `MirSurface*` of the specified window, or `NULL` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.2.
+ *
+ *  @ingroup native
+ */
+GLFWAPI MirSurface* glfwGetMirWindow(GLFWwindow* window);
+#endif
+
+#if defined(GLFW_EXPOSE_NATIVE_EGL)
+/*! @brief Returns the `EGLDisplay` used by GLFW.
+ *
+ *  @return The `EGLDisplay` used by GLFW, or `EGL_NO_DISPLAY` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI EGLDisplay glfwGetEGLDisplay(void);
+
+/*! @brief Returns the `EGLContext` of the specified window.
+ *
+ *  @return The `EGLContext` of the specified window, or `EGL_NO_CONTEXT` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI EGLContext glfwGetEGLContext(GLFWwindow* window);
+
+/*! @brief Returns the `EGLSurface` of the specified window.
+ *
+ *  @return The `EGLSurface` of the specified window, or `EGL_NO_SURFACE` if an
+ *  [error](@ref error_handling) occurred.
+ *
+ *  @thread_safety This function may be called from any thread.  Access is not
+ *  synchronized.
+ *
+ *  @since Added in version 3.0.
+ *
+ *  @ingroup native
+ */
+GLFWAPI EGLSurface glfwGetEGLSurface(GLFWwindow* window);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _glfw3_native_h_ */
+

project/vs2015/external/lua/include/lauxlib.h

@@ -0,0 +1,256 @@
+/*
+** $Id: lauxlib.h,v 1.129 2015/11/23 11:29:43 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+
+
+/* extra error code for 'luaL_load' */
+#define LUA_ERRFILE     (LUA_ERRERR+1)
+
+
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+
+
+#define LUAL_NUMSIZES	(sizeof(lua_Integer)*16 + sizeof(lua_Number))
+
+LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
+#define luaL_checkversion(L)  \
+	  luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
+
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
+LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,
+                                                          size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,
+                                          const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
+                                          lua_Integer def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
+
+LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def,
+                                   const char *const lst[]);
+
+LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
+LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
+
+/* predefined references */
+#define LUA_NOREF       (-2)
+#define LUA_REFNIL      (-1)
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
+                                               const char *mode);
+
+#define luaL_loadfile(L,f)	luaL_loadfilex(L,f,NULL)
+
+LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
+                                   const char *name, const char *mode);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate) (void);
+
+LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);
+
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
+                                                  const char *r);
+
+LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
+
+LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
+
+LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
+                                  const char *msg, int level);
+
+LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
+                                 lua_CFunction openf, int glb);
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+
+#define luaL_newlibtable(L,l)	\
+  lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
+
+#define luaL_newlib(L,l)  \
+  (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+
+#define luaL_argcheck(L, cond,arg,extramsg)	\
+		((void)((cond) || luaL_argerror(L, (arg), (extramsg))))
+#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
+
+#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+#define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)
+
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+typedef struct luaL_Buffer {
+  char *b;  /* buffer address */
+  size_t size;  /* buffer size */
+  size_t n;  /* number of characters in buffer */
+  lua_State *L;
+  char initb[LUAL_BUFFERSIZE];  /* initial buffer */
+} luaL_Buffer;
+
+
+#define luaL_addchar(B,c) \
+  ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
+   ((B)->b[(B)->n++] = (c)))
+
+#define luaL_addsize(B,s)	((B)->n += (s))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
+
+#define luaL_prepbuffer(B)	luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+
+/* }====================================================== */
+
+
+
+/*
+** {======================================================
+** File handles for IO library
+** =======================================================
+*/
+
+/*
+** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
+** initial structure 'luaL_Stream' (it may contain other fields
+** after that initial structure).
+*/
+
+#define LUA_FILEHANDLE          "FILE*"
+
+
+typedef struct luaL_Stream {
+  FILE *f;  /* stream (NULL for incompletely created streams) */
+  lua_CFunction closef;  /* to close stream (NULL for closed streams) */
+} luaL_Stream;
+
+/* }====================================================== */
+
+
+
+/* compatibility with old module system */
+#if defined(LUA_COMPAT_MODULE)
+
+LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
+                                   int sizehint);
+LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
+                                const luaL_Reg *l, int nup);
+
+#define luaL_register(L,n,l)	(luaL_openlib(L,(n),(l),0))
+
+#endif
+
+
+/*
+** {==================================================================
+** "Abstraction Layer" for basic report of messages and errors
+** ===================================================================
+*/
+
+/* print a string */
+#if !defined(lua_writestring)
+#define lua_writestring(s,l)   fwrite((s), sizeof(char), (l), stdout)
+#endif
+
+/* print a newline and flush the output */
+#if !defined(lua_writeline)
+#define lua_writeline()        (lua_writestring("\n", 1), fflush(stdout))
+#endif
+
+/* print an error message */
+#if !defined(lua_writestringerror)
+#define lua_writestringerror(s,p) \
+        (fprintf(stderr, (s), (p)), fflush(stderr))
+#endif
+
+/* }================================================================== */
+
+
+/*
+** {============================================================
+** Compatibility with deprecated conversions
+** =============================================================
+*/
+#if defined(LUA_COMPAT_APIINTCASTS)
+
+#define luaL_checkunsigned(L,a)	((lua_Unsigned)luaL_checkinteger(L,a))
+#define luaL_optunsigned(L,a,d)	\
+	((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
+
+#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
+
+#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
+
+#endif
+/* }============================================================ */
+
+
+
+#endif
+
+

project/vs2015/external/lua/include/lua.h

@@ -0,0 +1,486 @@
+/*
+** $Id: lua.h,v 1.331 2016/05/30 15:53:28 roberto Exp $
+** Lua - A Scripting Language
+** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
+** See Copyright Notice at the end of this file
+*/
+
+
+#ifndef lua_h
+#define lua_h
+
+#include <stdarg.h>
+#include <stddef.h>
+
+
+#include "luaconf.h"
+
+
+#define LUA_VERSION_MAJOR	"5"
+#define LUA_VERSION_MINOR	"3"
+#define LUA_VERSION_NUM		503
+#define LUA_VERSION_RELEASE	"3"
+
+#define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
+#define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
+#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2016 Lua.org, PUC-Rio"
+#define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
+
+
+/* mark for precompiled code ('<esc>Lua') */
+#define LUA_SIGNATURE	"\x1bLua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+#define LUA_MULTRET	(-1)
+
+
+/*
+** Pseudo-indices
+** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty
+** space after that to help overflow detection)
+*/
+#define LUA_REGISTRYINDEX	(-LUAI_MAXSTACK - 1000)
+#define lua_upvalueindex(i)	(LUA_REGISTRYINDEX - (i))
+
+
+/* thread status */
+#define LUA_OK		0
+#define LUA_YIELD	1
+#define LUA_ERRRUN	2
+#define LUA_ERRSYNTAX	3
+#define LUA_ERRMEM	4
+#define LUA_ERRGCMM	5
+#define LUA_ERRERR	6
+
+
+typedef struct lua_State lua_State;
+
+
+/*
+** basic types
+*/
+#define LUA_TNONE		(-1)
+
+#define LUA_TNIL		0
+#define LUA_TBOOLEAN		1
+#define LUA_TLIGHTUSERDATA	2
+#define LUA_TNUMBER		3
+#define LUA_TSTRING		4
+#define LUA_TTABLE		5
+#define LUA_TFUNCTION		6
+#define LUA_TUSERDATA		7
+#define LUA_TTHREAD		8
+
+#define LUA_NUMTAGS		9
+
+
+
+/* minimum Lua stack available to a C function */
+#define LUA_MINSTACK	20
+
+
+/* predefined values in the registry */
+#define LUA_RIDX_MAINTHREAD	1
+#define LUA_RIDX_GLOBALS	2
+#define LUA_RIDX_LAST		LUA_RIDX_GLOBALS
+
+
+/* type of numbers in Lua */
+typedef LUA_NUMBER lua_Number;
+
+
+/* type for integer functions */
+typedef LUA_INTEGER lua_Integer;
+
+/* unsigned integer type */
+typedef LUA_UNSIGNED lua_Unsigned;
+
+/* type for continuation-function contexts */
+typedef LUA_KCONTEXT lua_KContext;
+
+
+/*
+** Type for C functions registered with Lua
+*/
+typedef int (*lua_CFunction) (lua_State *L);
+
+/*
+** Type for continuation functions
+*/
+typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);
+
+
+/*
+** Type for functions that read/write blocks when loading/dumping Lua chunks
+*/
+typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
+
+typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud);
+
+
+/*
+** Type for memory-allocation functions
+*/
+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
+
+
+
+/*
+** generic extra include file
+*/
+#if defined(LUA_USER_H)
+#include LUA_USER_H
+#endif
+
+
+/*
+** RCS ident string
+*/
+extern const char lua_ident[];
+
+
+/*
+** state manipulation
+*/
+LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
+LUA_API void       (lua_close) (lua_State *L);
+LUA_API lua_State *(lua_newthread) (lua_State *L);
+
+LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
+
+
+LUA_API const lua_Number *(lua_version) (lua_State *L);
+
+
+/*
+** basic stack manipulation
+*/
+LUA_API int   (lua_absindex) (lua_State *L, int idx);
+LUA_API int   (lua_gettop) (lua_State *L);
+LUA_API void  (lua_settop) (lua_State *L, int idx);
+LUA_API void  (lua_pushvalue) (lua_State *L, int idx);
+LUA_API void  (lua_rotate) (lua_State *L, int idx, int n);
+LUA_API void  (lua_copy) (lua_State *L, int fromidx, int toidx);
+LUA_API int   (lua_checkstack) (lua_State *L, int n);
+
+LUA_API void  (lua_xmove) (lua_State *from, lua_State *to, int n);
+
+
+/*
+** access functions (stack -> C)
+*/
+
+LUA_API int             (lua_isnumber) (lua_State *L, int idx);
+LUA_API int             (lua_isstring) (lua_State *L, int idx);
+LUA_API int             (lua_iscfunction) (lua_State *L, int idx);
+LUA_API int             (lua_isinteger) (lua_State *L, int idx);
+LUA_API int             (lua_isuserdata) (lua_State *L, int idx);
+LUA_API int             (lua_type) (lua_State *L, int idx);
+LUA_API const char     *(lua_typename) (lua_State *L, int tp);
+
+LUA_API lua_Number      (lua_tonumberx) (lua_State *L, int idx, int *isnum);
+LUA_API lua_Integer     (lua_tointegerx) (lua_State *L, int idx, int *isnum);
+LUA_API int             (lua_toboolean) (lua_State *L, int idx);
+LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
+LUA_API size_t          (lua_rawlen) (lua_State *L, int idx);
+LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
+LUA_API void	       *(lua_touserdata) (lua_State *L, int idx);
+LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
+LUA_API const void     *(lua_topointer) (lua_State *L, int idx);
+
+
+/*
+** Comparison and arithmetic functions
+*/
+
+#define LUA_OPADD	0	/* ORDER TM, ORDER OP */
+#define LUA_OPSUB	1
+#define LUA_OPMUL	2
+#define LUA_OPMOD	3
+#define LUA_OPPOW	4
+#define LUA_OPDIV	5
+#define LUA_OPIDIV	6
+#define LUA_OPBAND	7
+#define LUA_OPBOR	8
+#define LUA_OPBXOR	9
+#define LUA_OPSHL	10
+#define LUA_OPSHR	11
+#define LUA_OPUNM	12
+#define LUA_OPBNOT	13
+
+LUA_API void  (lua_arith) (lua_State *L, int op);
+
+#define LUA_OPEQ	0
+#define LUA_OPLT	1
+#define LUA_OPLE	2
+
+LUA_API int   (lua_rawequal) (lua_State *L, int idx1, int idx2);
+LUA_API int   (lua_compare) (lua_State *L, int idx1, int idx2, int op);
+
+
+/*
+** push functions (C -> stack)
+*/
+LUA_API void        (lua_pushnil) (lua_State *L);
+LUA_API void        (lua_pushnumber) (lua_State *L, lua_Number n);
+LUA_API void        (lua_pushinteger) (lua_State *L, lua_Integer n);
+LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len);
+LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);
+LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
+                                                      va_list argp);
+LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
+LUA_API void  (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
+LUA_API void  (lua_pushboolean) (lua_State *L, int b);
+LUA_API void  (lua_pushlightuserdata) (lua_State *L, void *p);
+LUA_API int   (lua_pushthread) (lua_State *L);
+
+
+/*
+** get functions (Lua -> stack)
+*/
+LUA_API int (lua_getglobal) (lua_State *L, const char *name);
+LUA_API int (lua_gettable) (lua_State *L, int idx);
+LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n);
+LUA_API int (lua_rawget) (lua_State *L, int idx);
+LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
+LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);
+
+LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
+LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
+LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
+LUA_API int  (lua_getuservalue) (lua_State *L, int idx);
+
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void  (lua_setglobal) (lua_State *L, const char *name);
+LUA_API void  (lua_settable) (lua_State *L, int idx);
+LUA_API void  (lua_setfield) (lua_State *L, int idx, const char *k);
+LUA_API void  (lua_seti) (lua_State *L, int idx, lua_Integer n);
+LUA_API void  (lua_rawset) (lua_State *L, int idx);
+LUA_API void  (lua_rawseti) (lua_State *L, int idx, lua_Integer n);
+LUA_API void  (lua_rawsetp) (lua_State *L, int idx, const void *p);
+LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
+LUA_API void  (lua_setuservalue) (lua_State *L, int idx);
+
+
+/*
+** 'load' and 'call' functions (load and run Lua code)
+*/
+LUA_API void  (lua_callk) (lua_State *L, int nargs, int nresults,
+                           lua_KContext ctx, lua_KFunction k);
+#define lua_call(L,n,r)		lua_callk(L, (n), (r), 0, NULL)
+
+LUA_API int   (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
+                            lua_KContext ctx, lua_KFunction k);
+#define lua_pcall(L,n,r,f)	lua_pcallk(L, (n), (r), (f), 0, NULL)
+
+LUA_API int   (lua_load) (lua_State *L, lua_Reader reader, void *dt,
+                          const char *chunkname, const char *mode);
+
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
+
+
+/*
+** coroutine functions
+*/
+LUA_API int  (lua_yieldk)     (lua_State *L, int nresults, lua_KContext ctx,
+                               lua_KFunction k);
+LUA_API int  (lua_resume)     (lua_State *L, lua_State *from, int narg);
+LUA_API int  (lua_status)     (lua_State *L);
+LUA_API int (lua_isyieldable) (lua_State *L);
+
+#define lua_yield(L,n)		lua_yieldk(L, (n), 0, NULL)
+
+
+/*
+** garbage-collection function and options
+*/
+
+#define LUA_GCSTOP		0
+#define LUA_GCRESTART		1
+#define LUA_GCCOLLECT		2
+#define LUA_GCCOUNT		3
+#define LUA_GCCOUNTB		4
+#define LUA_GCSTEP		5
+#define LUA_GCSETPAUSE		6
+#define LUA_GCSETSTEPMUL	7
+#define LUA_GCISRUNNING		9
+
+LUA_API int (lua_gc) (lua_State *L, int what, int data);
+
+
+/*
+** miscellaneous functions
+*/
+
+LUA_API int   (lua_error) (lua_State *L);
+
+LUA_API int   (lua_next) (lua_State *L, int idx);
+
+LUA_API void  (lua_concat) (lua_State *L, int n);
+LUA_API void  (lua_len)    (lua_State *L, int idx);
+
+LUA_API size_t   (lua_stringtonumber) (lua_State *L, const char *s);
+
+LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
+
+
+
+/*
+** {==============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define lua_getextraspace(L)	((void *)((char *)(L) - LUA_EXTRASPACE))
+
+#define lua_tonumber(L,i)	lua_tonumberx(L,(i),NULL)
+#define lua_tointeger(L,i)	lua_tointegerx(L,(i),NULL)
+
+#define lua_pop(L,n)		lua_settop(L, -(n)-1)
+
+#define lua_newtable(L)		lua_createtable(L, 0, 0)
+
+#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+
+#define lua_pushcfunction(L,f)	lua_pushcclosure(L, (f), 0)
+
+#define lua_isfunction(L,n)	(lua_type(L, (n)) == LUA_TFUNCTION)
+#define lua_istable(L,n)	(lua_type(L, (n)) == LUA_TTABLE)
+#define lua_islightuserdata(L,n)	(lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
+#define lua_isnil(L,n)		(lua_type(L, (n)) == LUA_TNIL)
+#define lua_isboolean(L,n)	(lua_type(L, (n)) == LUA_TBOOLEAN)
+#define lua_isthread(L,n)	(lua_type(L, (n)) == LUA_TTHREAD)
+#define lua_isnone(L,n)		(lua_type(L, (n)) == LUA_TNONE)
+#define lua_isnoneornil(L, n)	(lua_type(L, (n)) <= 0)
+
+#define lua_pushliteral(L, s)	lua_pushstring(L, "" s)
+
+#define lua_pushglobaltable(L)  \
+	((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS))
+
+#define lua_tostring(L,i)	lua_tolstring(L, (i), NULL)
+
+
+#define lua_insert(L,idx)	lua_rotate(L, (idx), 1)
+
+#define lua_remove(L,idx)	(lua_rotate(L, (idx), -1), lua_pop(L, 1))
+
+#define lua_replace(L,idx)	(lua_copy(L, -1, (idx)), lua_pop(L, 1))
+
+/* }============================================================== */
+
+
+/*
+** {==============================================================
+** compatibility macros for unsigned conversions
+** ===============================================================
+*/
+#if defined(LUA_COMPAT_APIINTCASTS)
+
+#define lua_pushunsigned(L,n)	lua_pushinteger(L, (lua_Integer)(n))
+#define lua_tounsignedx(L,i,is)	((lua_Unsigned)lua_tointegerx(L,i,is))
+#define lua_tounsigned(L,i)	lua_tounsignedx(L,(i),NULL)
+
+#endif
+/* }============================================================== */
+
+/*
+** {======================================================================
+** Debug API
+** =======================================================================
+*/
+
+
+/*
+** Event codes
+*/
+#define LUA_HOOKCALL	0
+#define LUA_HOOKRET	1
+#define LUA_HOOKLINE	2
+#define LUA_HOOKCOUNT	3
+#define LUA_HOOKTAILCALL 4
+
+
+/*
+** Event masks
+*/
+#define LUA_MASKCALL	(1 << LUA_HOOKCALL)
+#define LUA_MASKRET	(1 << LUA_HOOKRET)
+#define LUA_MASKLINE	(1 << LUA_HOOKLINE)
+#define LUA_MASKCOUNT	(1 << LUA_HOOKCOUNT)
+
+typedef struct lua_Debug lua_Debug;  /* activation record */
+
+
+/* Functions to be called by the debugger in specific events */
+typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
+
+
+LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);
+LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);
+LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);
+LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);
+
+LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);
+LUA_API void  (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
+                                               int fidx2, int n2);
+
+LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API lua_Hook (lua_gethook) (lua_State *L);
+LUA_API int (lua_gethookmask) (lua_State *L);
+LUA_API int (lua_gethookcount) (lua_State *L);
+
+
+struct lua_Debug {
+  int event;
+  const char *name;	/* (n) */
+  const char *namewhat;	/* (n) 'global', 'local', 'field', 'method' */
+  const char *what;	/* (S) 'Lua', 'C', 'main', 'tail' */
+  const char *source;	/* (S) */
+  int currentline;	/* (l) */
+  int linedefined;	/* (S) */
+  int lastlinedefined;	/* (S) */
+  unsigned char nups;	/* (u) number of upvalues */
+  unsigned char nparams;/* (u) number of parameters */
+  char isvararg;        /* (u) */
+  char istailcall;	/* (t) */
+  char short_src[LUA_IDSIZE]; /* (S) */
+  /* private part */
+  struct CallInfo *i_ci;  /* active function */
+};
+
+/* }====================================================================== */
+
+
+/******************************************************************************
+* Copyright (C) 1994-2016 Lua.org, PUC-Rio.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+******************************************************************************/
+
+
+#endif