Add raylib lua examples

examples/audio_module_playing.lua

@@ -0,0 +1,131 @@
+-------------------------------------------------------------------------------------------
+--
+--   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
+
+typedef struct {        -- TODO: Find a Lua alternative: TABLES?
+    Vector2 position
+    float radius
+    float alpha
+    float speed
+    Color color
+} CircleWave
+
+-- 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].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].speed = (float)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].speed
+        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(0, 13)]
+            circles[i].speed = (float)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, (int)timePlayed, 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
+-------------------------------------------------------------------------------------------
+
+return 0
+}

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.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.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/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)    -- ERROR: Lua Error: attempt to index a number value (?)
+
+            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.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.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,96 @@
+-------------------------------------------------------------------------------------------
+--
+--  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
+    ---------------------------------------------------------------------------------------
+    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 }})
+    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.lua

@@ -1,28 +1,33 @@
+-------------------------------------------------------------------------------------------
+--
+--  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 [rlua] example - basic window")
+InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window")
-
-InitAudioDevice()
-
---local pause = false
---local texture = LoadTexture("resources/texture.png")
 
 SetTargetFPS(60)       -- Set target frames-per-second
-----------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------
 
-while not WindowShouldClose() do
+-- Main game loop
+while not WindowShouldClose() do            -- Detect window close button or ESC key
     -- Update
-    ------------------------------------------------------------------------------------
+    ---------------------------------------------------------------------------------------
-    --if (IsKeyPressed(KEY.SPACE)) then
+    -- TODO: Update your variables here
-    --  pause = not pause
+    ---------------------------------------------------------------------------------------
-    --end
-    ------------------------------------------------------------------------------------
 
     -- Draw
-    ------------------------------------------------------------------------------------
+    ---------------------------------------------------------------------------------------
     BeginDrawing()
 
         ClearBackground(RAYWHITE)
@@ -30,12 +35,10 @@ while not WindowShouldClose() do
         DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY)
 
     EndDrawing()
-    ------------------------------------------------------------------------------------
+    ---------------------------------------------------------------------------------------
 end
 
 -- De-Initialization
-------------------------------------------------------------------------------------
+-------------------------------------------------------------------------------------------
-CloseAudioDevice()      -- Close audio device
-
 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,63 @@
+-------------------------------------------------------------------------------------------
+--
+--  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
+--char **droppedFiles     -- ???
+
+SetTargetFPS(60)
+-------------------------------------------------------------------------------------------
+
+-- Main game loop
+while not WindowShouldClose() do    -- Detect window close button or ESC key
+    -- Update
+    ---------------------------------------------------------------------------------------
+    if (IsFileDropped()) then droppedFiles = GetDroppedFiles(count) 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 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], 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
+-------------------------------------------------------------------------------------------