Merge branch 'develop' of https://github.com/raysan5/raylib into develop

21 files changed, 2320 insertions, 2322 deletions

diff --git a/examples/audio_module_playing.lua b/examples/audio_module_playing.lua
index 38cf9afe..3c5ad641 100644
--- a/examples/audio_module_playing.lua
+++ b/examples/audio_module_playing.lua
@@ -11,16 +11,6 @@
 
 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
@@ -78,7 +68,7 @@ while not WindowShouldClose() do        -- Detect window close button or ESC key
             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].color = colors[GetRandomValue(1, 14)]
             circles[i].speed = GetRandomValue(1, 100)/20000.0
         end
     end
@@ -112,7 +102,7 @@ while not WindowShouldClose() do        -- Detect window close button or ESC key
 
         -- Draw time bar
         DrawRectangle(20, screenHeight - 20 - 12, screenWidth - 40, 12, LIGHTGRAY)
-        DrawRectangle(20, screenHeight - 20 - 12, timePlayed, 12, MAROON)
+        DrawRectangle(20, screenHeight - 20 - 12, timePlayed//1, 12, MAROON)
         DrawRectangleLines(20, screenHeight - 20 - 12, screenWidth - 40, 12, WHITE)
 
     EndDrawing()
diff --git a/examples/core_2d_camera.lua b/examples/core_2d_camera.lua
index a7c0515a..95302c26 100644
--- a/examples/core_2d_camera.lua
+++ b/examples/core_2d_camera.lua
@@ -91,7 +91,7 @@ while not WindowShouldClose() do                -- Detect window close button or
 
         ClearBackground(RAYWHITE)
 
-        Begin2dMode(camera)    -- ERROR: Lua Error: attempt to index a number value (?)
+        Begin2dMode(camera)
 
             DrawRectangle(-6000, 320, 13000, 8000, DARKGRAY)
             
diff --git a/examples/core_3d_picking.lua b/examples/core_3d_picking.lua
index 2e1dc7c4..1adee67c 100644
--- a/examples/core_3d_picking.lua
+++ b/examples/core_3d_picking.lua
@@ -41,7 +41,7 @@ SetTargetFPS(60)                   -- Set our game to run at 60 frames-per-secon
 while not WindowShouldClose() do            -- Detect window close button or ESC key
     -- Update
     ---------------------------------------------------------------------------------------
-    UpdateCamera(camera)           -- Update internal camera and our camera
+    camera = UpdateCamera(camera)           -- Update internal camera and our camera
     
     if (IsMouseButtonPressed(MOUSE.LEFT_BUTTON)) then
         -- NOTE: This function is NOT WORKING properly!
@@ -49,8 +49,10 @@ while not WindowShouldClose() do            -- Detect window close button or ESC
         
         -- 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)))
+                        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
     ---------------------------------------------------------------------------------------
 
diff --git a/examples/core_world_screen.lua b/examples/core_world_screen.lua
index ebad41f8..51f2cdbf 100644
--- a/examples/core_world_screen.lua
+++ b/examples/core_world_screen.lua
@@ -56,7 +56,7 @@ while not WindowShouldClose() do        -- Detect window close button or ESC key
 
         End3dMode()
         
-        DrawText("Enemy: 100 / 100", cubeScreenPosition.x - MeasureText("Enemy: 100 / 100", 20)//2, cubeScreenPosition.y, 20, BLACK)
+        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()
diff --git a/examples/models_billboard.lua b/examples/models_billboard.lua
index 25b00510..457198e6 100644
--- a/examples/models_billboard.lua
+++ b/examples/models_billboard.lua
@@ -34,7 +34,7 @@ SetTargetFPS(60)                   -- Set our game to run at 60 frames-per-secon
 while not WindowShouldClose() do            -- Detect window close button or ESC key
     -- Update
     ---------------------------------------------------------------------------------------
-    UpdateCamera(camera)          -- Update internal camera and our camera
+    camera = UpdateCamera(camera)           -- Update internal camera and our camera
     ---------------------------------------------------------------------------------------
 
     -- Draw
diff --git a/examples/models_box_collisions.lua b/examples/models_box_collisions.lua
index d8b2e4b5..4a3107b9 100644
--- a/examples/models_box_collisions.lua
+++ b/examples/models_box_collisions.lua
@@ -60,7 +60,7 @@ while not WindowShouldClose() do            -- Detect window close button or ESC
                             enemyBoxPos.z - enemyBoxSize.z/2), 
                     Vector3(enemyBoxPos.x + enemyBoxSize.x/2,
                             enemyBoxPos.y + enemyBoxSize.y/2, 
-                            enemyBoxPos.z + enemyBoxSize.z/2))) then collision = true 
+                            enemyBoxPos.z + enemyBoxSize.z/2)))) then collision = true 
     end
     
     -- Check collisions player vs enemy-sphere
diff --git a/examples/models_cubicmap.lua b/examples/models_cubicmap.lua
index 53cb2c12..bae3bac2 100644
--- a/examples/models_cubicmap.lua
+++ b/examples/models_cubicmap.lua
@@ -32,17 +32,17 @@ 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
+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
+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
+    camera = UpdateCamera(camera)           -- Update internal camera and our camera
     ---------------------------------------------------------------------------------------
 
     -- Draw
diff --git a/examples/models_heightmap.lua b/examples/models_heightmap.lua
index 6d7f6f3f..4240f8b7 100644
--- a/examples/models_heightmap.lua
+++ b/examples/models_heightmap.lua
@@ -37,7 +37,7 @@ SetTargetFPS(60)                   -- Set our game to run at 60 frames-per-secon
 while not WindowShouldClose() do            -- Detect window close button or ESC key
     -- Update
     ---------------------------------------------------------------------------------------
-    UpdateCamera(camera)          -- Update internal camera and our camera
+    camera = UpdateCamera(camera)           -- Update internal camera and our camera
     ---------------------------------------------------------------------------------------
 
     -- Draw
diff --git a/examples/rlua_execute_file.c b/examples/rlua_execute_file.c
index 5c2d8654..6050cf14 100644
--- a/examples/rlua_execute_file.c
+++ b/examples/rlua_execute_file.c
@@ -29,8 +29,8 @@ int main()
     //--------------------------------------------------------------------------------------
 
     // ExecuteLuaFile("core_basic_window.lua");                 // OK!
-		// ExecuteLuaFile("core_input_keys.lua");                   // OK!
-		// ExecuteLuaFile("core_input_mouse.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!
@@ -38,13 +38,13 @@ int main()
     // ExecuteLuaFile("core_drop_files.lua");                   // ERROR: GetDroppedFiles()
     // ExecuteLuaFile("core_storage_values.lua");               // OK!
     // ExecuteLuaFile("core_gestures_detection.lua");           // OK!
-    // ExecuteLuaFile("core_3d_mode.lua");                      // ERROR: Lua Error: attempt to index a number value - Begin3dMode()
-    // ExecuteLuaFile("core_3d_picking.lua");                   // ERROR: Lua Error: attempt to index a number value
-    // ExecuteLuaFile("core_3d_camera_free.lua");               // ERROR: Lua Error: attempt to index a number value
-    // ExecuteLuaFile("core_3d_camera_first_person.lua");       // ERROR: Lua Error: attempt to index a number value
-    // ExecuteLuaFile("core_2d_camera.lua");                    // ERROR: Lua Error: attempt to index a number value - Begin2dMode()
-    // ExecuteLuaFile("core_world_screen.lua");                 // ERROR: Lua Error: attempt to index a number value
-    // ExecuteLuaFile("core_oculus_rift.lua");                  // ERROR: Lua Error: attempt to index a number value
+    // ExecuteLuaFile("core_3d_mode.lua");                      // OK!
+    // ExecuteLuaFile("core_3d_picking.lua");                   // ISSUE: CheckCollisionRayBox() returns false despite touching box
+    // 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!
@@ -54,31 +54,31 @@ int main()
     // ExecuteLuaFile("textures_rectangle.lua");                // OK!
     // ExecuteLuaFile("textures_srcrec_dstrec.lua");            // OK!
     // ExecuteLuaFile("textures_to_image.lua");                 // OK!
-    // ExecuteLuaFile("textures_raw_data.lua");                 // ERROR: Lua Error: attempt to index a number value
-		// ExecuteLuaFile("textures_formats_loading.lua");          // ISSUE: texture.id not exposed to be checked
-		// ExecuteLuaFile("textures_particles_trail_blending.lua"); // ERROR: Using struct
-		// 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");                   // ERROR: Lua Error: attempt to index a nil value
-		// 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");                 // ERROR: SubText()
-		// ExecuteLuaFile("models_geometric_shapes.lua");           // ERROR: Lua Error: attempt to index a number value - Begin3dMode(camera)
-		// ExecuteLuaFile("models_box_collisions.lua");             //
-		// ExecuteLuaFile("models_billboard.lua");                  //
-		// ExecuteLuaFile("models_obj_loading.lua");                //
-		// ExecuteLuaFile("models_heightmap.lua");                  //
-    // ExecuteLuaFile("models_cubicmap.lua");                   //
-		// ExecuteLuaFile("shaders_model_shader.lua");              //
-		// ExecuteLuaFile("shaders_shapes_textures.lua");           //
-    // ExecuteLuaFile("shaders_custom_uniform.lua");            //
-    // ExecuteLuaFile("shaders_postprocessing.lua");            //
-    // ExecuteLuaFile("shaders_standard_lighting.lua");         //
+    // ExecuteLuaFile("textures_raw_data.lua");                 // ERROR: bad argument #2 to 'LoadImageEx' (number expected, got no value)
+    // ExecuteLuaFile("textures_formats_loading.lua");          // ISSUE: texture.id not exposed to be checked (not really an issue...)
+    // 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");            // ISSUE: SetShaderValue()
+    // ExecuteLuaFile("shaders_postprocessing.lua");            // OK!
+    // ExecuteLuaFile("shaders_standard_lighting.lua");         // ERROR: CreateLight() returns an opaque pointer (fields can not be accessed)
     // ExecuteLuaFile("audio_sound_loading.lua");               // OK!
     // ExecuteLuaFile("audio_music_stream.lua");                // OK!
-    ExecuteLuaFile("audio_module_playing.lua");              // ERROR: Using struct
+    // ExecuteLuaFile("audio_module_playing.lua");              // OK!
     ExecuteLuaFile("audio_raw_stream.lua");                  // ERROR: UpdateAudioStream()
 
     // De-Initialization
@@ -86,5 +86,5 @@ int main()
     CloseLuaDevice();        // Close Lua device and free resources
     //--------------------------------------------------------------------------------------
 
-	return 0;
+    return 0;
 }
\ No newline at end of file
diff --git a/examples/shaders_custom_uniform.lua b/examples/shaders_custom_uniform.lua
index b4e4d483..fb93adc1 100644
--- a/examples/shaders_custom_uniform.lua
+++ b/examples/shaders_custom_uniform.lua
@@ -66,7 +66,7 @@ while not WindowShouldClose() do       -- Detect window close button or ESC key
     -- Send new value to the shader to be used on drawing
     SetShaderValue(shader, swirlCenterLoc, swirlCenter, 2)
     
-    UpdateCamera(camera)              -- Update internal camera and our camera
+    camera = UpdateCamera(camera)      -- Update internal camera and our camera
     ---------------------------------------------------------------------------------------
 
     -- Draw
diff --git a/examples/shaders_model_shader.lua b/examples/shaders_model_shader.lua
index b31c8609..d1436a7e 100644
--- a/examples/shaders_model_shader.lua
+++ b/examples/shaders_model_shader.lua
@@ -50,7 +50,7 @@ SetTargetFPS(60)                          -- Set our game to run at 60 frames-pe
 while not WindowShouldClose() do          -- Detect window close button or ESC key
     -- Update
     ---------------------------------------------------------------------------------------
-    UpdateCamera(camera)                 -- Update internal camera and our camera
+    camera = UpdateCamera(camera)         -- Update internal camera and our camera
     ---------------------------------------------------------------------------------------
 
     -- Draw
diff --git a/examples/shaders_postprocessing.lua b/examples/shaders_postprocessing.lua
index 0913fbbd..f20f31ec 100644
--- a/examples/shaders_postprocessing.lua
+++ b/examples/shaders_postprocessing.lua
@@ -52,7 +52,7 @@ SetTargetFPS(60)                       -- Set our game to run at 60 frames-per-s
 while not WindowShouldClose() do       -- Detect window close button or ESC key
     -- Update
     ---------------------------------------------------------------------------------------
-    UpdateCamera(camera)              -- Update internal camera and our camera
+    camera = UpdateCamera(camera)      -- Update internal camera and our camera
     ---------------------------------------------------------------------------------------
 
     -- Draw
diff --git a/examples/shaders_standard_lighting.lua b/examples/shaders_standard_lighting.lua
index 7c354d54..2f3700ff 100644
--- a/examples/shaders_standard_lighting.lua
+++ b/examples/shaders_standard_lighting.lua
@@ -27,9 +27,9 @@ 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 position = Vector3(0.0, 0.0, 0.0)   -- Set model position
 
 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()
 
@@ -37,30 +37,30 @@ material.texDiffuse = LoadTexture("resources/model/dwarf_diffuse.png")   -- Load
 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.colAmbient = Color(0, 0, 10, 255)
 material.colSpecular = WHITE
 material.glossiness = 50.0
 
 dwarf.material = material      -- Apply material to model
 
-local spotLight = CreateLight(LIGHT_SPOT, (Vector3)(3.0, 5.0, 2.0), (Color)(255, 255, 255, 255))
-spotLight.target = (Vector3)(0.0, 0.0, 0.0)
+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.diffuse = Color(255, 100, 100, 255)
 spotLight.coneAngle = 60.0
 
-local dirLight = CreateLight(LIGHT_DIRECTIONAL, (Vector3)(0.0, -3.0, -3.0), (Color)(255, 255, 255, 255))
-dirLight.target = (Vector3)(1.0, -2.0, -2.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)
+dirLight.diffuse = Color(100, 255, 100, 255)
 
-local pointLight = CreateLight(LIGHT_POINT, (Vector3)(0.0, 4.0, 5.0), (Color)(255, 255, 255, 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.diffuse = Color(100, 100, 255, 255)
 pointLight.radius = 3.0
 
 -- Setup orbital camera
-SetCameraMode(CameraMode.ORBITAL)          -- Set an orbital camera mode
+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
 
@@ -71,7 +71,7 @@ SetTargetFPS(60)                       -- Set our game to run at 60 frames-per-s
 while not WindowShouldClose() do       -- Detect window close button or ESC key
     -- Update
     ---------------------------------------------------------------------------------------
-    UpdateCamera(camera)              -- Update internal camera and our camera
+    camera = UpdateCamera(camera)      -- Update internal camera and our camera
     ---------------------------------------------------------------------------------------
 
     -- Draw
diff --git a/examples/text_rbmf_fonts.lua b/examples/text_rbmf_fonts.lua
index 0e0e4142..31a733f1 100644
--- a/examples/text_rbmf_fonts.lua
+++ b/examples/text_rbmf_fonts.lua
@@ -47,7 +47,7 @@ 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 + 50*i
+    positions[i].y = 60 + fonts[i].size + 45*(i - 1)
 end
 
 local colors = { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD, BLACK }
diff --git a/examples/text_writing_anim.lua b/examples/text_writing_anim.lua
index 05195dc4..f4af9f58 100644
--- a/examples/text_writing_anim.lua
+++ b/examples/text_writing_anim.lua
@@ -38,7 +38,7 @@ while not WindowShouldClose() do            -- Detect window close button or ESC
 
         ClearBackground(RAYWHITE)
 
-        DrawText(string.sub(message, 0, framesCounter/10), 210, 160, 20, MAROON)
+        DrawText(string.sub(message, 0, framesCounter//10), 210, 160, 20, MAROON)
         
         DrawText("PRESS [ENTER] to RESTART!", 240, 280, 20, LIGHTGRAY)
 
diff --git a/examples/textures_particles_trail_blending.lua b/examples/textures_particles_trail_blending.lua
index 38036bcf..d2c2518e 100644
--- a/examples/textures_particles_trail_blending.lua
+++ b/examples/textures_particles_trail_blending.lua
@@ -11,7 +11,6 @@
 
 MAX_PARTICLES = 200
 
--- Particle structure with basic data
 -- Initialization
 -------------------------------------------------------------------------------------------
 local screenWidth = 800
@@ -56,7 +55,7 @@ while not WindowShouldClose() do            -- Detect window close button or ESC
             mouseTail[i].active = true
             mouseTail[i].alpha = 1.0
             mouseTail[i].position = GetMousePosition()
-            i = MAX_PARTICLES
+            break
         end
     end
 
@@ -90,7 +89,7 @@ while not WindowShouldClose() do            -- Detect window close button or ESC
                 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, smoke.height*mouseTail[i].size),
+                                  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
diff --git a/examples/textures_raw_data.lua b/examples/textures_raw_data.lua
index 16c1c0ad..8a955adf 100644
--- a/examples/textures_raw_data.lua
+++ b/examples/textures_raw_data.lua
@@ -36,7 +36,7 @@ local pixels = {}
 
 for y = 1, height do
     for x = 1, width do
-        if (((x/32+y/32)/1)%2 == 0) then pixels[y*height + x] = DARKBLUE
+        if ((((x - 1)/32+(y - 1)//32)//1)%2 == 0) then pixels[y*height + x] = DARKBLUE
         else pixels[y*height + x] = SKYBLUE end
     end
 end
diff --git a/src/audio.c b/src/audio.c
index 0896e4ca..32911865 100644
--- a/src/audio.c
+++ b/src/audio.c
@@ -183,6 +183,8 @@ void CloseAudioDevice(void)
     alcMakeContextCurrent(NULL);
     alcDestroyContext(context);
     alcCloseDevice(device);
+    
+    TraceLog(INFO, "Audio device closed successfully");
 }
 
 // Check if device has been initialized successfully
diff --git a/src/raylib.h b/src/raylib.h
index 1489546a..bbf83ccd 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -909,10 +909,8 @@ void DestroyLight(Light light);                                     // Destroy a
 //------------------------------------------------------------------------------------
 void InitVrDevice(int vdDevice);            // Init VR device
 void CloseVrDevice(void);                   // Close VR device
-void UpdateVrTracking(void);                // Update VR tracking (position and orientation)
-void BeginVrDrawing(void);                  // Begin VR drawing configuration
-void EndVrDrawing(void);                    // End VR drawing process (and desktop mirror)
 bool IsVrDeviceReady(void);                 // Detect if VR device (or simulator) is ready
+void UpdateVrTracking(void);                // Update VR tracking (position and orientation)
 void ToggleVrMode(void);                    // Enable/Disable VR experience (device or simulator)
 
 //------------------------------------------------------------------------------------
diff --git a/src/rlgl.h b/src/rlgl.h
index 425871a9..bcb7c24f 100644
--- a/src/rlgl.h
+++ b/src/rlgl.h
@@ -332,6 +332,10 @@ Vector3 rlglUnproject(Vector3 source, Matrix proj, Matrix view);    // Get world
 unsigned char *rlglReadScreenPixels(int width, int height);         // Read screen pixel data (color buffer)
 void *rlglReadTexturePixels(Texture2D texture);                     // Read texture pixel data
 
+// VR functions exposed to core module but not to raylib users
+void BeginVrDrawing(void);                  // Begin VR drawing configuration
+void EndVrDrawing(void);                    // End VR drawing process (and desktop mirror)
+
 // NOTE: There is a set of shader related functions that are available to end user,
 // to avoid creating function wrappers through core module, they have been directly declared in raylib.h
 
@@ -368,10 +372,8 @@ float *MatrixToFloat(Matrix mat);
 
 void InitVrDevice(int vrDevice);            // Init VR device
 void CloseVrDevice(void);                   // Close VR device
-void UpdateVrTracking(void);                // Update VR tracking (position and orientation)
-void BeginVrDrawing(void);                  // Begin VR drawing configuration
-void EndVrDrawing(void);                    // End VR drawing process (and desktop mirror)
 bool IsVrDeviceReady(void);                 // Detect if VR device (or simulator) is ready
+void UpdateVrTracking(void);                // Update VR tracking (position and orientation)
 void ToggleVrMode(void);                    // Enable/Disable VR experience (device or simulator)
 
 // Oculus Rift API for direct access the device (no simulator)
diff --git a/src/rlua.h b/src/rlua.h
index 77a51ed5..08ffbca0 100644
--- a/src/rlua.h
+++ b/src/rlua.h
@@ -188,47 +188,47 @@ static Model LuaGetArgument_Model(lua_State* L, int index);
 //----------------------------------------------------------------------------------
 static void LuaStartEnum(void)
 {
-	lua_newtable(L);
+    lua_newtable(L);
 }
 
 static void LuaSetEnum(const char *name, int value)
 {
-	lua_pushinteger(L, value);
-	lua_setfield(L, -2, name);
+    lua_pushinteger(L, value);
+    lua_setfield(L, -2, name);
 }
 
 static void LuaSetEnumColor(const char *name, Color color)
 {
-	LuaPush_Color(L, color);
-	lua_setfield(L, -2, name);
+    LuaPush_Color(L, color);
+    lua_setfield(L, -2, name);
 }
 
 static void LuaEndEnum(const char *name)
 {
-	lua_setglobal(L, name);
+    lua_setglobal(L, name);
 }
 
 static void LuaPushOpaque(lua_State* L, void *ptr, size_t size)
 {
-	void *ud = lua_newuserdata(L, size);
-	memcpy(ud, ptr, size);
+    void *ud = lua_newuserdata(L, size);
+    memcpy(ud, ptr, size);
 }
 
 static void LuaPushOpaqueWithMetatable(lua_State* L, void *ptr, size_t size, const char *metatable_name)
 {
-	void *ud = lua_newuserdata(L, size);
-	memcpy(ud, ptr, size);
-	luaL_setmetatable(L, metatable_name);
+    void *ud = lua_newuserdata(L, size);
+    memcpy(ud, ptr, size);
+    luaL_setmetatable(L, metatable_name);
 }
 
 static void* LuaGetArgumentOpaqueType(lua_State* L, int index)
 {
-	return lua_touserdata(L, index);
+    return lua_touserdata(L, index);
 }
 
 static void* LuaGetArgumentOpaqueTypeWithMetatable(lua_State* L, int index, const char *metatable_name)
 {
-	return luaL_checkudata(L, index, metatable_name);
+    return luaL_checkudata(L, index, metatable_name);
 }
 
 //----------------------------------------------------------------------------------
@@ -236,87 +236,87 @@ static void* LuaGetArgumentOpaqueTypeWithMetatable(lua_State* L, int index, cons
 //----------------------------------------------------------------------------------
 static int LuaIndexImage(lua_State* L)
 {
-	Image img = LuaGetArgument_Image(L, 1);
-	const char *key = luaL_checkstring(L, 2);
-	if (!strcmp(key, "width"))
-		lua_pushinteger(L, img.width);
-	else if (!strcmp(key, "height"))
-		lua_pushinteger(L, img.height);
-	else if (!strcmp(key, "mipmaps"))
-		lua_pushinteger(L, img.mipmaps);
-	else if (!strcmp(key, "format"))
-		lua_pushinteger(L, img.format);
-	else
-		return 0;
-	return 1;
+    Image img = LuaGetArgument_Image(L, 1);
+    const char *key = luaL_checkstring(L, 2);
+    if (!strcmp(key, "width"))
+        lua_pushinteger(L, img.width);
+    else if (!strcmp(key, "height"))
+        lua_pushinteger(L, img.height);
+    else if (!strcmp(key, "mipmaps"))
+        lua_pushinteger(L, img.mipmaps);
+    else if (!strcmp(key, "format"))
+        lua_pushinteger(L, img.format);
+    else
+        return 0;
+    return 1;
 }
 
 static int LuaIndexTexture2D(lua_State* L)
 {
-	Texture2D img = LuaGetArgument_Texture2D(L, 1);
-	const char *key = luaL_checkstring(L, 2);
-	if (!strcmp(key, "width"))
-		lua_pushinteger(L, img.width);
-	else if (!strcmp(key, "height"))
-		lua_pushinteger(L, img.height);
-	else if (!strcmp(key, "mipmaps"))
-		lua_pushinteger(L, img.mipmaps);
-	else if (!strcmp(key, "format"))
-		lua_pushinteger(L, img.format);
-	else
-		return 0;
-	return 1;
+    Texture2D img = LuaGetArgument_Texture2D(L, 1);
+    const char *key = luaL_checkstring(L, 2);
+    if (!strcmp(key, "width"))
+        lua_pushinteger(L, img.width);
+    else if (!strcmp(key, "height"))
+        lua_pushinteger(L, img.height);
+    else if (!strcmp(key, "mipmaps"))
+        lua_pushinteger(L, img.mipmaps);
+    else if (!strcmp(key, "format"))
+        lua_pushinteger(L, img.format);
+    else
+        return 0;
+    return 1;
 }
 
 static int LuaIndexRenderTexture2D(lua_State* L)
 {
-	RenderTexture2D img = LuaGetArgument_RenderTexture2D(L, 1);
-	const char *key = luaL_checkstring(L, 2);
-	if (!strcmp(key, "texture"))
-		LuaPush_Texture2D(L, img.texture);
-	else if (!strcmp(key, "depth"))
-		LuaPush_Texture2D(L, img.depth);
-	else
-		return 0;
-	return 1;
+    RenderTexture2D img = LuaGetArgument_RenderTexture2D(L, 1);
+    const char *key = luaL_checkstring(L, 2);
+    if (!strcmp(key, "texture"))
+        LuaPush_Texture2D(L, img.texture);
+    else if (!strcmp(key, "depth"))
+        LuaPush_Texture2D(L, img.depth);
+    else
+        return 0;
+    return 1;
 }
 
 static int LuaIndexSpriteFont(lua_State* L)
 {
-	SpriteFont img = LuaGetArgument_SpriteFont(L, 1);
-	const char *key = luaL_checkstring(L, 2);
-	if (!strcmp(key, "size"))
-		lua_pushinteger(L, img.size);
-	else if (!strcmp(key, "texture"))
-		LuaPush_Texture2D(L, img.texture);
-	else if (!strcmp(key, "numChars"))
-		lua_pushinteger(L, img.numChars);
-	else
-		return 0;
-	return 1;
+    SpriteFont img = LuaGetArgument_SpriteFont(L, 1);
+    const char *key = luaL_checkstring(L, 2);
+    if (!strcmp(key, "size"))
+        lua_pushinteger(L, img.size);
+    else if (!strcmp(key, "texture"))
+        LuaPush_Texture2D(L, img.texture);
+    else if (!strcmp(key, "numChars"))
+        lua_pushinteger(L, img.numChars);
+    else
+        return 0;
+    return 1;
 }
 
 static void LuaBuildOpaqueMetatables(void)
 {
-	luaL_newmetatable(L, "Image");
-	lua_pushcfunction(L, &LuaIndexImage);
-	lua_setfield(L, -2, "__index");
-	lua_pop(L, 1);
+    luaL_newmetatable(L, "Image");
+    lua_pushcfunction(L, &LuaIndexImage);
+    lua_setfield(L, -2, "__index");
+    lua_pop(L, 1);
 
-	luaL_newmetatable(L, "Texture2D");
-	lua_pushcfunction(L, &LuaIndexTexture2D);
-	lua_setfield(L, -2, "__index");
-	lua_pop(L, 1);
+    luaL_newmetatable(L, "Texture2D");
+    lua_pushcfunction(L, &LuaIndexTexture2D);
+    lua_setfield(L, -2, "__index");
+    lua_pop(L, 1);
     
     luaL_newmetatable(L, "RenderTexture2D");
-	lua_pushcfunction(L, &LuaIndexRenderTexture2D);
-	lua_setfield(L, -2, "__index");
-	lua_pop(L, 1);
+    lua_pushcfunction(L, &LuaIndexRenderTexture2D);
+    lua_setfield(L, -2, "__index");
+    lua_pop(L, 1);
 
-	luaL_newmetatable(L, "SpriteFont");
-	lua_pushcfunction(L, &LuaIndexSpriteFont);
-	lua_setfield(L, -2, "__index");
-	lua_pop(L, 1);
+    luaL_newmetatable(L, "SpriteFont");
+    lua_pushcfunction(L, &LuaIndexSpriteFont);
+    lua_setfield(L, -2, "__index");
+    lua_pop(L, 1);
 }
 
 //----------------------------------------------------------------------------------
@@ -325,180 +325,180 @@ static void LuaBuildOpaqueMetatables(void)
 
 static Vector2 LuaGetArgument_Vector2(lua_State* L, int index)
 {
-	index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
-	luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Vector2");
-	float x = (float)lua_tonumber(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Vector2");
-	float y = (float)lua_tonumber(L, -1);
-	lua_pop(L, 2);
-	return (Vector2) { x, y };
+    index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
+    luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Vector2");
+    float x = (float)lua_tonumber(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Vector2");
+    float y = (float)lua_tonumber(L, -1);
+    lua_pop(L, 2);
+    return (Vector2) { x, y };
 }
 
 static Vector3 LuaGetArgument_Vector3(lua_State* L, int index)
 {
-	index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
-	luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Vector3");
-	float x = (float)lua_tonumber(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Vector3");
-	float y = (float)lua_tonumber(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "z") == LUA_TNUMBER, index, "Expected Vector3");
-	float z = (float)lua_tonumber(L, -1);
-	lua_pop(L, 3);
-	return (Vector3) { x, y, z };
+    index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
+    luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Vector3");
+    float x = (float)lua_tonumber(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Vector3");
+    float y = (float)lua_tonumber(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "z") == LUA_TNUMBER, index, "Expected Vector3");
+    float z = (float)lua_tonumber(L, -1);
+    lua_pop(L, 3);
+    return (Vector3) { x, y, z };
 }
 
 static Quaternion LuaGetArgument_Quaternion(lua_State* L, int index)
 {
-	index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
-	luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Quaternion");
-	float x = (float)lua_tonumber(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Quaternion");
-	float y = (float)lua_tonumber(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "z") == LUA_TNUMBER, index, "Expected Quaternion");
-	float z = (float)lua_tonumber(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "w") == LUA_TNUMBER, index, "Expected Quaternion");
-	float w = (float)lua_tonumber(L, -1);
-	lua_pop(L, 4);
-	return (Quaternion) { x, y, z, w };
+    index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
+    luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Quaternion");
+    float x = (float)lua_tonumber(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Quaternion");
+    float y = (float)lua_tonumber(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "z") == LUA_TNUMBER, index, "Expected Quaternion");
+    float z = (float)lua_tonumber(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "w") == LUA_TNUMBER, index, "Expected Quaternion");
+    float w = (float)lua_tonumber(L, -1);
+    lua_pop(L, 4);
+    return (Quaternion) { x, y, z, w };
 }
 
 static Color LuaGetArgument_Color(lua_State* L, int index)
 {
-	index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
-	luaL_argcheck(L, lua_getfield(L, index, "r") == LUA_TNUMBER, index, "Expected Color");
-	unsigned char r = (unsigned char)lua_tointeger(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "g") == LUA_TNUMBER, index, "Expected Color");
-	unsigned char g = (unsigned char)lua_tointeger(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "b") == LUA_TNUMBER, index, "Expected Color");
-	unsigned char b = (unsigned char)lua_tointeger(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "a") == LUA_TNUMBER, index, "Expected Color");
-	unsigned char a = (unsigned char)lua_tointeger(L, -1);
-	lua_pop(L, 4);
-	return (Color) { r, g, b, a };
+    index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
+    luaL_argcheck(L, lua_getfield(L, index, "r") == LUA_TNUMBER, index, "Expected Color");
+    unsigned char r = (unsigned char)lua_tointeger(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "g") == LUA_TNUMBER, index, "Expected Color");
+    unsigned char g = (unsigned char)lua_tointeger(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "b") == LUA_TNUMBER, index, "Expected Color");
+    unsigned char b = (unsigned char)lua_tointeger(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "a") == LUA_TNUMBER, index, "Expected Color");
+    unsigned char a = (unsigned char)lua_tointeger(L, -1);
+    lua_pop(L, 4);
+    return (Color) { r, g, b, a };
 }
 
 static Rectangle LuaGetArgument_Rectangle(lua_State* L, int index)
 {
-	index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
-	luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Rectangle");
-	int x = (int)lua_tointeger(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Rectangle");
-	int y = (int)lua_tointeger(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "width") == LUA_TNUMBER, index, "Expected Rectangle");
-	int w = (int)lua_tointeger(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "height") == LUA_TNUMBER, index, "Expected Rectangle");
-	int h = (int)lua_tointeger(L, -1);
-	lua_pop(L, 4);
-	return (Rectangle) { x, y, w, h };
+    index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
+    luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Rectangle");
+    int x = (int)lua_tointeger(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Rectangle");
+    int y = (int)lua_tointeger(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "width") == LUA_TNUMBER, index, "Expected Rectangle");
+    int w = (int)lua_tointeger(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "height") == LUA_TNUMBER, index, "Expected Rectangle");
+    int h = (int)lua_tointeger(L, -1);
+    lua_pop(L, 4);
+    return (Rectangle) { x, y, w, h };
 }
 
 static Camera LuaGetArgument_Camera(lua_State* L, int index)
 {
-	Camera result;
-	index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
-	luaL_argcheck(L, lua_getfield(L, index, "position") == LUA_TTABLE, index, "Expected Camera");
-	result.position = LuaGetArgument_Vector3(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "target") == LUA_TTABLE, index, "Expected Camera");
-	result.target = LuaGetArgument_Vector3(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "up") == LUA_TTABLE, index, "Expected Camera");
-	result.up = LuaGetArgument_Vector3(L, -1);
+    Camera result;
+    index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
+    luaL_argcheck(L, lua_getfield(L, index, "position") == LUA_TTABLE, index, "Expected Camera");
+    result.position = LuaGetArgument_Vector3(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "target") == LUA_TTABLE, index, "Expected Camera");
+    result.target = LuaGetArgument_Vector3(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "up") == LUA_TTABLE, index, "Expected Camera");
+    result.up = LuaGetArgument_Vector3(L, -1);
   luaL_argcheck(L, lua_getfield(L, index, "fovy") == LUA_TNUMBER, index, "Expected Camera");
-	result.fovy = LuaGetArgument_float(L, -1);
-	lua_pop(L, 4);
-	return result;
+    result.fovy = LuaGetArgument_float(L, -1);
+    lua_pop(L, 4);
+    return result;
 }
 
 static Camera2D LuaGetArgument_Camera2D(lua_State* L, int index)
 {
-	Camera2D result;
-	index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
-	luaL_argcheck(L, lua_getfield(L, index, "offset") == LUA_TTABLE, index, "Expected Camera2D");
-	result.offset = LuaGetArgument_Vector2(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "target") == LUA_TTABLE, index, "Expected Camera2D");
-	result.target = LuaGetArgument_Vector2(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "rotation") == LUA_TNUMBER, index, "Expected Camera2D");
-	result.rotation = LuaGetArgument_float(L, -1);
+    Camera2D result;
+    index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
+    luaL_argcheck(L, lua_getfield(L, index, "offset") == LUA_TTABLE, index, "Expected Camera2D");
+    result.offset = LuaGetArgument_Vector2(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "target") == LUA_TTABLE, index, "Expected Camera2D");
+    result.target = LuaGetArgument_Vector2(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "rotation") == LUA_TNUMBER, index, "Expected Camera2D");
+    result.rotation = LuaGetArgument_float(L, -1);
   luaL_argcheck(L, lua_getfield(L, index, "zoom") == LUA_TNUMBER, index, "Expected Camera2D");
-	result.zoom = LuaGetArgument_float(L, -1);
-	lua_pop(L, 4);
-	return result;
+    result.zoom = LuaGetArgument_float(L, -1);
+    lua_pop(L, 4);
+    return result;
 }
 
 static BoundingBox LuaGetArgument_BoundingBox(lua_State* L, int index)
 {
-	BoundingBox result;
-	index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
-	luaL_argcheck(L, lua_getfield(L, index, "min") == LUA_TTABLE, index, "Expected BoundingBox");
-	result.min = LuaGetArgument_Vector3(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "max") == LUA_TTABLE, index, "Expected BoundingBox");
-	result.max = LuaGetArgument_Vector3(L, -1);
-	lua_pop(L, 2);
-	return result;
+    BoundingBox result;
+    index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
+    luaL_argcheck(L, lua_getfield(L, index, "min") == LUA_TTABLE, index, "Expected BoundingBox");
+    result.min = LuaGetArgument_Vector3(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "max") == LUA_TTABLE, index, "Expected BoundingBox");
+    result.max = LuaGetArgument_Vector3(L, -1);
+    lua_pop(L, 2);
+    return result;
 }
 
 static Ray LuaGetArgument_Ray(lua_State* L, int index)
 {
-	Ray result;
-	index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
-	luaL_argcheck(L, lua_getfield(L, index, "position") == LUA_TTABLE, index, "Expected Ray");
-	result.position = LuaGetArgument_Vector3(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "direction") == LUA_TTABLE, index, "Expected Ray");
-	result.direction = LuaGetArgument_Vector3(L, -1);
-	lua_pop(L, 2);
-	return result;
+    Ray result;
+    index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
+    luaL_argcheck(L, lua_getfield(L, index, "position") == LUA_TTABLE, index, "Expected Ray");
+    result.position = LuaGetArgument_Vector3(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "direction") == LUA_TTABLE, index, "Expected Ray");
+    result.direction = LuaGetArgument_Vector3(L, -1);
+    lua_pop(L, 2);
+    return result;
 }
 
 static Matrix LuaGetArgument_Matrix(lua_State* L, int index)
 {
-	Matrix result = { 0 };
-	float* ptr = &result.m0;
-	index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
+    Matrix result = { 0 };
+    float* ptr = &result.m0;
+    index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
 
-	for (int i = 0; i < 16; i++)
-	{
-		lua_geti(L, index, i+1);
-		ptr[i] = luaL_checknumber(L, -1);
-	}
-	lua_pop(L, 16);
-	return result;
+    for (int i = 0; i < 16; i++)
+    {
+        lua_geti(L, index, i+1);
+        ptr[i] = luaL_checknumber(L, -1);
+    }
+    lua_pop(L, 16);
+    return result;
 }
 
 static Material LuaGetArgument_Material(lua_State* L, int index)
 {
     Material result;
-		index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
+        index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
     luaL_argcheck(L, lua_getfield(L, index, "shader") == LUA_TUSERDATA, index, "Expected Material");
-	result.shader = LuaGetArgument_Shader(L, -1);
+    result.shader = LuaGetArgument_Shader(L, -1);
     luaL_argcheck(L, lua_getfield(L, index, "texDiffuse") == LUA_TUSERDATA, index, "Expected Material");
-	result.texDiffuse = LuaGetArgument_Texture2D(L, -1);
+    result.texDiffuse = LuaGetArgument_Texture2D(L, -1);
     luaL_argcheck(L, lua_getfield(L, index, "texNormal") == LUA_TUSERDATA, index, "Expected Material");
-	result.texNormal = LuaGetArgument_Texture2D(L, -1);
+    result.texNormal = LuaGetArgument_Texture2D(L, -1);
     luaL_argcheck(L, lua_getfield(L, index, "texSpecular") == LUA_TUSERDATA, index, "Expected Material");
-	result.texSpecular = LuaGetArgument_Texture2D(L, -1);
+    result.texSpecular = LuaGetArgument_Texture2D(L, -1);
     luaL_argcheck(L, lua_getfield(L, index, "colDiffuse") == LUA_TTABLE, index, "Expected Material");
-	result.colDiffuse = LuaGetArgument_Color(L, -1);
+    result.colDiffuse = LuaGetArgument_Color(L, -1);
     luaL_argcheck(L, lua_getfield(L, index, "colAmbient") == LUA_TTABLE, index, "Expected Material");
-	result.colAmbient = LuaGetArgument_Color(L, -1);
+    result.colAmbient = LuaGetArgument_Color(L, -1);
     luaL_argcheck(L, lua_getfield(L, index, "colSpecular") == LUA_TTABLE, index, "Expected Material");
-	result.colSpecular = LuaGetArgument_Color(L, -1);
+    result.colSpecular = LuaGetArgument_Color(L, -1);
     luaL_argcheck(L, lua_getfield(L, index, "glossiness") == LUA_TNUMBER, index, "Expected Material");
-	result.glossiness = LuaGetArgument_float(L, -1);
+    result.glossiness = LuaGetArgument_float(L, -1);
     lua_pop(L, 8);
     return result;
 }
 
 static Model LuaGetArgument_Model(lua_State* L, int index)
 {
-	Model result;
-	index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
-	luaL_argcheck(L, lua_getfield(L, index, "mesh") == LUA_TUSERDATA, index, "Expected Model");
-	result.mesh = LuaGetArgument_Mesh(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "transform") == LUA_TTABLE, index, "Expected Model");
-	result.transform = LuaGetArgument_Matrix(L, -1);
-	luaL_argcheck(L, lua_getfield(L, index, "material") == LUA_TTABLE, index, "Expected Model");
-	result.material = LuaGetArgument_Material(L, -1);
-	lua_pop(L, 3);
-	return result;
+    Model result;
+    index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values
+    luaL_argcheck(L, lua_getfield(L, index, "mesh") == LUA_TUSERDATA, index, "Expected Model");
+    result.mesh = LuaGetArgument_Mesh(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "transform") == LUA_TTABLE, index, "Expected Model");
+    result.transform = LuaGetArgument_Matrix(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "material") == LUA_TTABLE, index, "Expected Model");
+    result.material = LuaGetArgument_Material(L, -1);
+    lua_pop(L, 3);
+    return result;
 }
 
 //----------------------------------------------------------------------------------
@@ -506,149 +506,149 @@ static Model LuaGetArgument_Model(lua_State* L, int index)
 //----------------------------------------------------------------------------------
 static void LuaPush_Color(lua_State* L, Color color)
 {
-	lua_createtable(L, 0, 4);
-	lua_pushinteger(L, color.r);
-	lua_setfield(L, -2, "r");
-	lua_pushinteger(L, color.g);
-	lua_setfield(L, -2, "g");
-	lua_pushinteger(L, color.b);
-	lua_setfield(L, -2, "b");
-	lua_pushinteger(L, color.a);
-	lua_setfield(L, -2, "a");
+    lua_createtable(L, 0, 4);
+    lua_pushinteger(L, color.r);
+    lua_setfield(L, -2, "r");
+    lua_pushinteger(L, color.g);
+    lua_setfield(L, -2, "g");
+    lua_pushinteger(L, color.b);
+    lua_setfield(L, -2, "b");
+    lua_pushinteger(L, color.a);
+    lua_setfield(L, -2, "a");
 }
 
 static void LuaPush_Vector2(lua_State* L, Vector2 vec)
 {
-	lua_createtable(L, 0, 2);
-	lua_pushnumber(L, vec.x);
-	lua_setfield(L, -2, "x");
-	lua_pushnumber(L, vec.y);
-	lua_setfield(L, -2, "y");
+    lua_createtable(L, 0, 2);
+    lua_pushnumber(L, vec.x);
+    lua_setfield(L, -2, "x");
+    lua_pushnumber(L, vec.y);
+    lua_setfield(L, -2, "y");
 }
 
 static void LuaPush_Vector3(lua_State* L, Vector3 vec)
 {
-	lua_createtable(L, 0, 3);
-	lua_pushnumber(L, vec.x);
-	lua_setfield(L, -2, "x");
-	lua_pushnumber(L, vec.y);
-	lua_setfield(L, -2, "y");
-	lua_pushnumber(L, vec.z);
-	lua_setfield(L, -2, "z");
+    lua_createtable(L, 0, 3);
+    lua_pushnumber(L, vec.x);
+    lua_setfield(L, -2, "x");
+    lua_pushnumber(L, vec.y);
+    lua_setfield(L, -2, "y");
+    lua_pushnumber(L, vec.z);
+    lua_setfield(L, -2, "z");
 }
 
 static void LuaPush_Quaternion(lua_State* L, Quaternion vec)
 {
-	lua_createtable(L, 0, 4);
-	lua_pushnumber(L, vec.x);
-	lua_setfield(L, -2, "x");
-	lua_pushnumber(L, vec.y);
-	lua_setfield(L, -2, "y");
-	lua_pushnumber(L, vec.z);
-	lua_setfield(L, -2, "z");
-	lua_pushnumber(L, vec.w);
-	lua_setfield(L, -2, "w");
+    lua_createtable(L, 0, 4);
+    lua_pushnumber(L, vec.x);
+    lua_setfield(L, -2, "x");
+    lua_pushnumber(L, vec.y);
+    lua_setfield(L, -2, "y");
+    lua_pushnumber(L, vec.z);
+    lua_setfield(L, -2, "z");
+    lua_pushnumber(L, vec.w);
+    lua_setfield(L, -2, "w");
 }
 
 static void LuaPush_Matrix(lua_State* L, Matrix *matrix)
 {
-	int i;
-	lua_createtable(L, 16, 0);
-	float* num = (&matrix->m0);
-	for (i = 0; i < 16; i++)
-	{
-		lua_pushnumber(L, num[i]);
-		lua_rawseti(L, -2, i + 1);
-	}
+    int i;
+    lua_createtable(L, 16, 0);
+    float* num = (&matrix->m0);
+    for (i = 0; i < 16; i++)
+    {
+        lua_pushnumber(L, num[i]);
+        lua_rawseti(L, -2, i + 1);
+    }
 }
 
 static void LuaPush_Rectangle(lua_State* L, Rectangle rect)
 {
-	lua_createtable(L, 0, 4);
-	lua_pushinteger(L, rect.x);
-	lua_setfield(L, -2, "x");
-	lua_pushinteger(L, rect.y);
-	lua_setfield(L, -2, "y");
-	lua_pushinteger(L, rect.width);
-	lua_setfield(L, -2, "width");
-	lua_pushinteger(L, rect.height);
-	lua_setfield(L, -2, "height");
+    lua_createtable(L, 0, 4);
+    lua_pushinteger(L, rect.x);
+    lua_setfield(L, -2, "x");
+    lua_pushinteger(L, rect.y);
+    lua_setfield(L, -2, "y");
+    lua_pushinteger(L, rect.width);
+    lua_setfield(L, -2, "width");
+    lua_pushinteger(L, rect.height);
+    lua_setfield(L, -2, "height");
 }
 
 static void LuaPush_Ray(lua_State* L, Ray ray)
 {
-	lua_createtable(L, 0, 2);
-	LuaPush_Vector3(L, ray.position);
-	lua_setfield(L, -2, "position");
-	LuaPush_Vector3(L, ray.direction);
-	lua_setfield(L, -2, "direction");
+    lua_createtable(L, 0, 2);
+    LuaPush_Vector3(L, ray.position);
+    lua_setfield(L, -2, "position");
+    LuaPush_Vector3(L, ray.direction);
+    lua_setfield(L, -2, "direction");
 }
 
 static void LuaPush_BoundingBox(lua_State* L, BoundingBox bb)
 {
-	lua_createtable(L, 0, 2);
-	LuaPush_Vector3(L, bb.min);
-	lua_setfield(L, -2, "min");
-	LuaPush_Vector3(L, bb.max);
-	lua_setfield(L, -2, "max");
+    lua_createtable(L, 0, 2);
+    LuaPush_Vector3(L, bb.min);
+    lua_setfield(L, -2, "min");
+    LuaPush_Vector3(L, bb.max);
+    lua_setfield(L, -2, "max");
 }
 
 static void LuaPush_Camera(lua_State* L, Camera cam)
 {
-	lua_createtable(L, 0, 4);
-	LuaPush_Vector3(L, cam.position);
-	lua_setfield(L, -2, "position");
-	LuaPush_Vector3(L, cam.target);
-	lua_setfield(L, -2, "target");
-	LuaPush_Vector3(L, cam.up);
-	lua_setfield(L, -2, "up");
+    lua_createtable(L, 0, 4);
+    LuaPush_Vector3(L, cam.position);
+    lua_setfield(L, -2, "position");
+    LuaPush_Vector3(L, cam.target);
+    lua_setfield(L, -2, "target");
+    LuaPush_Vector3(L, cam.up);
+    lua_setfield(L, -2, "up");
     lua_pushnumber(L, cam.fovy);
-	lua_setfield(L, -2, "fovy");
+    lua_setfield(L, -2, "fovy");
 }
 
 static void LuaPush_Camera2D(lua_State* L, Camera2D cam)
 {
-	lua_createtable(L, 0, 4);
-	LuaPush_Vector2(L, cam.offset);
-	lua_setfield(L, -2, "offset");
-	LuaPush_Vector2(L, cam.target);
-	lua_setfield(L, -2, "target");
-	lua_pushnumber(L, cam.rotation);
-	lua_setfield(L, -2, "rotation");
+    lua_createtable(L, 0, 4);
+    LuaPush_Vector2(L, cam.offset);
+    lua_setfield(L, -2, "offset");
+    LuaPush_Vector2(L, cam.target);
+    lua_setfield(L, -2, "target");
+    lua_pushnumber(L, cam.rotation);
+    lua_setfield(L, -2, "rotation");
     lua_pushnumber(L, cam.zoom);
-	lua_setfield(L, -2, "zoom");
+    lua_setfield(L, -2, "zoom");
 }
 
 static void LuaPush_Material(lua_State* L, Material mat)
 {
-	lua_createtable(L, 0, 8);
-	LuaPush_Shader(L, mat.shader);
-	lua_setfield(L, -2, "shader");
-	LuaPush_Texture2D(L, mat.texDiffuse);
-	lua_setfield(L, -2, "texDiffuse");
-	LuaPush_Texture2D(L, mat.texNormal);
-	lua_setfield(L, -2, "texNormal");
+    lua_createtable(L, 0, 8);
+    LuaPush_Shader(L, mat.shader);
+    lua_setfield(L, -2, "shader");
+    LuaPush_Texture2D(L, mat.texDiffuse);
+    lua_setfield(L, -2, "texDiffuse");
+    LuaPush_Texture2D(L, mat.texNormal);
+    lua_setfield(L, -2, "texNormal");
     LuaPush_Texture2D(L, mat.texSpecular);
-	lua_setfield(L, -2, "texSpecular");
+    lua_setfield(L, -2, "texSpecular");
     LuaPush_Color(L, mat.colDiffuse);
-	lua_setfield(L, -2, "colDiffuse");
+    lua_setfield(L, -2, "colDiffuse");
     LuaPush_Color(L, mat.colAmbient);
-	lua_setfield(L, -2, "colAmbient");
+    lua_setfield(L, -2, "colAmbient");
     LuaPush_Color(L, mat.colSpecular);
-	lua_setfield(L, -2, "colSpecular");
+    lua_setfield(L, -2, "colSpecular");
     lua_pushnumber(L, mat.glossiness);
-	lua_setfield(L, -2, "glossiness");
+    lua_setfield(L, -2, "glossiness");
 }
 
 static void LuaPush_Model(lua_State* L, Model mdl)
 {
-	lua_createtable(L, 0, 4);
-	LuaPush_Mesh(L, mdl.mesh);
-	lua_setfield(L, -2, "mesh");
-	LuaPush_Matrix(L, &mdl.transform);
-	lua_setfield(L, -2, "transform");
-	LuaPush_Material(L, mdl.material);
-	lua_setfield(L, -2, "material");
+    lua_createtable(L, 0, 4);
+    LuaPush_Mesh(L, mdl.mesh);
+    lua_setfield(L, -2, "mesh");
+    LuaPush_Matrix(L, &mdl.transform);
+    lua_setfield(L, -2, "transform");
+    LuaPush_Material(L, mdl.material);
+    lua_setfield(L, -2, "material");
 }
 
 //----------------------------------------------------------------------------------
@@ -656,95 +656,95 @@ static void LuaPush_Model(lua_State* L, Model mdl)
 //----------------------------------------------------------------------------------
 static int lua_Color(lua_State* L)
 {
-	LuaPush_Color(L, (Color) { (unsigned char)luaL_checkinteger(L, 1), (unsigned char)luaL_checkinteger(L, 2), (unsigned char)luaL_checkinteger(L, 3), (unsigned char)luaL_checkinteger(L, 4) });
-	return 1;
+    LuaPush_Color(L, (Color) { (unsigned char)luaL_checkinteger(L, 1), (unsigned char)luaL_checkinteger(L, 2), (unsigned char)luaL_checkinteger(L, 3), (unsigned char)luaL_checkinteger(L, 4) });
+    return 1;
 }
 
 static int lua_Vector2(lua_State* L)
 {
-	LuaPush_Vector2(L, (Vector2) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2) });
-	return 1;
+    LuaPush_Vector2(L, (Vector2) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2) });
+    return 1;
 }
 
 static int lua_Vector3(lua_State* L)
 {
-	LuaPush_Vector3(L, (Vector3) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3) });
-	return 1;
+    LuaPush_Vector3(L, (Vector3) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3) });
+    return 1;
 }
 
 static int lua_Quaternion(lua_State* L)
 {
-	LuaPush_Quaternion(L, (Quaternion) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3), (float)luaL_checknumber(L, 4) });
-	return 1;
+    LuaPush_Quaternion(L, (Quaternion) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3), (float)luaL_checknumber(L, 4) });
+    return 1;
 }
 
 /*
 static int lua_Matrix(lua_State* L)
 {
-	LuaPush_Matrix(L, (Matrix) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3), (float)luaL_checknumber(L, 4),
+    LuaPush_Matrix(L, (Matrix) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3), (float)luaL_checknumber(L, 4),
                                  (float)luaL_checknumber(L, 5), (float)luaL_checknumber(L, 6), (float)luaL_checknumber(L, 7), (float)luaL_checknumber(L, 8),
                                  (float)luaL_checknumber(L, 9), (float)luaL_checknumber(L, 10), (float)luaL_checknumber(L, 11), (float)luaL_checknumber(L, 12),
                                  (float)luaL_checknumber(L, 13), (float)luaL_checknumber(L, 14), (float)luaL_checknumber(L, 15), (float)luaL_checknumber(L, 16) });
-	return 1;
+    return 1;
 }
 */
 
 static int lua_Rectangle(lua_State* L)
 {
-	LuaPush_Rectangle(L, (Rectangle) { (int)luaL_checkinteger(L, 1), (int)luaL_checkinteger(L, 2), (int)luaL_checkinteger(L, 3), (int)luaL_checkinteger(L, 4) });
-	return 1;
+    LuaPush_Rectangle(L, (Rectangle) { (int)luaL_checkinteger(L, 1), (int)luaL_checkinteger(L, 2), (int)luaL_checkinteger(L, 3), (int)luaL_checkinteger(L, 4) });
+    return 1;
 }
 
 static int lua_Ray(lua_State* L)
 {
-	Vector2 pos = LuaGetArgument_Vector2(L, 1);
-	Vector2 dir = LuaGetArgument_Vector2(L, 2);
-	LuaPush_Ray(L, (Ray) { { pos.x, pos.y }, { dir.x, dir.y } });
-	return 1;
+    Vector2 pos = LuaGetArgument_Vector2(L, 1);
+    Vector2 dir = LuaGetArgument_Vector2(L, 2);
+    LuaPush_Ray(L, (Ray) { { pos.x, pos.y }, { dir.x, dir.y } });
+    return 1;
 }
 
 static int lua_BoundingBox(lua_State* L)
 {
-	Vector3 min = LuaGetArgument_Vector3(L, 1);
-	Vector3 max = LuaGetArgument_Vector3(L, 2);
-	LuaPush_BoundingBox(L, (BoundingBox) { { min.x, min.y }, { max.x, max.y } });
-	return 1;
+    Vector3 min = LuaGetArgument_Vector3(L, 1);
+    Vector3 max = LuaGetArgument_Vector3(L, 2);
+    LuaPush_BoundingBox(L, (BoundingBox) { { min.x, min.y }, { max.x, max.y } });
+    return 1;
 }
 
 static int lua_Camera(lua_State* L)
 {
-	Vector3 pos = LuaGetArgument_Vector3(L, 1);
-	Vector3 tar = LuaGetArgument_Vector3(L, 2);
-	Vector3 up = LuaGetArgument_Vector3(L, 3);
+    Vector3 pos = LuaGetArgument_Vector3(L, 1);
+    Vector3 tar = LuaGetArgument_Vector3(L, 2);
+    Vector3 up = LuaGetArgument_Vector3(L, 3);
     //float fovy = LuaGetArgument_float(L, 4);      // ???
-	LuaPush_Camera(L, (Camera) { { pos.x, pos.y, pos.z }, { tar.x, tar.y, tar.z }, { up.x, up.y, up.z }, (float)luaL_checknumber(L, 4) });
-	return 1;
+    LuaPush_Camera(L, (Camera) { { pos.x, pos.y, pos.z }, { tar.x, tar.y, tar.z }, { up.x, up.y, up.z }, (float)luaL_checknumber(L, 4) });
+    return 1;
 }
 
 static int lua_Camera2D(lua_State* L)
 {
-	Vector2 off = LuaGetArgument_Vector2(L, 1);
-	Vector2 tar = LuaGetArgument_Vector2(L, 2);
-	float rot = LuaGetArgument_float(L, 3);
+    Vector2 off = LuaGetArgument_Vector2(L, 1);
+    Vector2 tar = LuaGetArgument_Vector2(L, 2);
+    float rot = LuaGetArgument_float(L, 3);
     float zoom = LuaGetArgument_float(L, 4);
-	LuaPush_Camera2D(L, (Camera2D) { { off.x, off.y }, { tar.x, tar.y }, rot, zoom });
-	return 1;
+    LuaPush_Camera2D(L, (Camera2D) { { off.x, off.y }, { tar.x, tar.y }, rot, zoom });
+    return 1;
 }
 
 /*
 // NOTE: does it make sense to have this constructor? Probably not...
 static int lua_Material(lua_State* L)
 {
-	Shader sdr = LuaGetArgument_Shader(L, 1);
-	Texture2D td = LuaGetArgument_Texture2D(L, 2);
-	Texture2D tn = LuaGetArgument_Texture2D(L, 3);
-	Texture2D ts = LuaGetArgument_Texture2D(L, 4);
-	Color cd = LuaGetArgument_Color(L, 5);
-	Color ca = LuaGetArgument_Color(L, 6);
-	Color cs = LuaGetArgument_Color(L, 7);
+    Shader sdr = LuaGetArgument_Shader(L, 1);
+    Texture2D td = LuaGetArgument_Texture2D(L, 2);
+    Texture2D tn = LuaGetArgument_Texture2D(L, 3);
+    Texture2D ts = LuaGetArgument_Texture2D(L, 4);
+    Color cd = LuaGetArgument_Color(L, 5);
+    Color ca = LuaGetArgument_Color(L, 6);
+    Color cs = LuaGetArgument_Color(L, 7);
     float gloss = LuaGetArgument_float(L, 8);
-	LuaPush_Material(L, (Material) { sdr, td, tn, ts cd, ca, cs, gloss });
-	return 1;
+    LuaPush_Material(L, (Material) { sdr, td, tn, ts cd, ca, cs, gloss });
+    return 1;
 }
 */
 
@@ -757,166 +757,166 @@ static int lua_Material(lua_State* L)
 //------------------------------------------------------------------------------------
 int lua_InitWindow(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	const char * arg3 = LuaGetArgument_string(L, 3);
-	InitWindow(arg1, arg2, arg3);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    const char * arg3 = LuaGetArgument_string(L, 3);
+    InitWindow(arg1, arg2, arg3);
+    return 0;
 }
 
 int lua_CloseWindow(lua_State* L)
 {
-	CloseWindow();
-	return 0;
+    CloseWindow();
+    return 0;
 }
 
 int lua_WindowShouldClose(lua_State* L)
 {
-	bool result = WindowShouldClose();
-	lua_pushboolean(L, result);
-	return 1;
+    bool result = WindowShouldClose();
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_IsWindowMinimized(lua_State* L)
 {
-	bool result = IsWindowMinimized();
-	lua_pushboolean(L, result);
-	return 1;
+    bool result = IsWindowMinimized();
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_ToggleFullscreen(lua_State* L)
 {
-	ToggleFullscreen();
-	return 0;
+    ToggleFullscreen();
+    return 0;
 }
 
 int lua_GetScreenWidth(lua_State* L)
 {
-	int result = GetScreenWidth();
-	lua_pushinteger(L, result);
-	return 1;
+    int result = GetScreenWidth();
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_GetScreenHeight(lua_State* L)
 {
-	int result = GetScreenHeight();
-	lua_pushinteger(L, result);
-	return 1;
+    int result = GetScreenHeight();
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_ShowCursor(lua_State* L)
 {
-	ShowCursor();
-	return 0;
+    ShowCursor();
+    return 0;
 }
 
 int lua_HideCursor(lua_State* L)
 {
-	HideCursor();
-	return 0;
+    HideCursor();
+    return 0;
 }
 
 int lua_IsCursorHidden(lua_State* L)
 {
-	bool result = IsCursorHidden();
-	lua_pushboolean(L, result);
-	return 1;
+    bool result = IsCursorHidden();
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_EnableCursor(lua_State* L)
 {
-	EnableCursor();
-	return 0;
+    EnableCursor();
+    return 0;
 }
 
 int lua_DisableCursor(lua_State* L)
 {
-	DisableCursor();
-	return 0;
+    DisableCursor();
+    return 0;
 }
 
 int lua_ClearBackground(lua_State* L)
 {
-	Color arg1 = LuaGetArgument_Color(L, 1);
-	ClearBackground(arg1);
-	return 0;
+    Color arg1 = LuaGetArgument_Color(L, 1);
+    ClearBackground(arg1);
+    return 0;
 }
 
 int lua_BeginDrawing(lua_State* L)
 {
-	BeginDrawing();
-	return 0;
+    BeginDrawing();
+    return 0;
 }
 
 int lua_EndDrawing(lua_State* L)
 {
-	EndDrawing();
-	return 0;
+    EndDrawing();
+    return 0;
 }
 
 int lua_Begin2dMode(lua_State* L)
 {
-	Camera2D arg1 = LuaGetArgument_Camera2D(L, 1);
-	Begin2dMode(arg1);
-	return 0;
+    Camera2D arg1 = LuaGetArgument_Camera2D(L, 1);
+    Begin2dMode(arg1);
+    return 0;
 }
 
 int lua_End2dMode(lua_State* L)
 {
-	End2dMode();
-	return 0;
+    End2dMode();
+    return 0;
 }
 
 int lua_Begin3dMode(lua_State* L)
 {
-	Camera arg1 = LuaGetArgument_Camera(L, 1);
-	Begin3dMode(arg1);
-	return 0;
+    Camera arg1 = LuaGetArgument_Camera(L, 1);
+    Begin3dMode(arg1);
+    return 0;
 }
 
 int lua_End3dMode(lua_State* L)
 {
-	End3dMode();
-	return 0;
+    End3dMode();
+    return 0;
 }
 
 int lua_BeginTextureMode(lua_State* L)
 {
-	RenderTexture2D arg1 = LuaGetArgument_RenderTexture2D(L, 1);
-	BeginTextureMode(arg1);
-	return 0;
+    RenderTexture2D arg1 = LuaGetArgument_RenderTexture2D(L, 1);
+    BeginTextureMode(arg1);
+    return 0;
 }
 
 int lua_EndTextureMode(lua_State* L)
 {
-	EndTextureMode();
-	return 0;
+    EndTextureMode();
+    return 0;
 }
 
 int lua_GetMouseRay(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	Camera arg2 = LuaGetArgument_Camera(L, 2);
-	Ray result = GetMouseRay(arg1, arg2);
-	LuaPush_Ray(L, result);
-	return 1;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    Camera arg2 = LuaGetArgument_Camera(L, 2);
+    Ray result = GetMouseRay(arg1, arg2);
+    LuaPush_Ray(L, result);
+    return 1;
 }
 
 int lua_GetWorldToScreen(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Camera arg2 = LuaGetArgument_Camera(L, 2);
-	Vector2 result = GetWorldToScreen(arg1, arg2);
-	LuaPush_Vector2(L, result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Camera arg2 = LuaGetArgument_Camera(L, 2);
+    Vector2 result = GetWorldToScreen(arg1, arg2);
+    LuaPush_Vector2(L, result);
+    return 1;
 }
 
 int lua_GetCameraMatrix(lua_State* L)
 {
-	Camera arg1 = LuaGetArgument_Camera(L, 1);
-	Matrix result = GetCameraMatrix(arg1);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    Camera arg1 = LuaGetArgument_Camera(L, 1);
+    Matrix result = GetCameraMatrix(arg1);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 #if defined(PLATFORM_WEB)
@@ -925,167 +925,167 @@ static int LuaDrawLoopFunc;
 
 static void LuaDrawLoop()
 {
-	lua_rawgeti(L, LUA_REGISTRYINDEX, LuaDrawLoopFunc);
-	lua_call(L, 0, 0);
+    lua_rawgeti(L, LUA_REGISTRYINDEX, LuaDrawLoopFunc);
+    lua_call(L, 0, 0);
 }
 
 int lua_SetDrawingLoop(lua_State* L)
 {
-	luaL_argcheck(L, lua_isfunction(L, 1), 1, "Loop function expected");
-	lua_pushvalue(L, 1);
-	LuaDrawLoopFunc = luaL_ref(L, LUA_REGISTRYINDEX);
-	SetDrawingLoop(&LuaDrawLoop);
-	return 0;
+    luaL_argcheck(L, lua_isfunction(L, 1), 1, "Loop function expected");
+    lua_pushvalue(L, 1);
+    LuaDrawLoopFunc = luaL_ref(L, LUA_REGISTRYINDEX);
+    SetDrawingLoop(&LuaDrawLoop);
+    return 0;
 }
 
 #else
 
 int lua_SetTargetFPS(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	SetTargetFPS(arg1);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    SetTargetFPS(arg1);
+    return 0;
 }
 #endif
 
 int lua_GetFPS(lua_State* L)
 {
-	float result = GetFPS();
-	lua_pushnumber(L, result);
-	return 1;
+    float result = GetFPS();
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 int lua_GetFrameTime(lua_State* L)
 {
-	float result = GetFrameTime();
-	lua_pushnumber(L, result);
-	return 1;
+    float result = GetFrameTime();
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 int lua_GetColor(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	Color result = GetColor(arg1);
-	LuaPush_Color(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    Color result = GetColor(arg1);
+    LuaPush_Color(L, result);
+    return 1;
 }
 
 int lua_GetHexValue(lua_State* L)
 {
-	Color arg1 = LuaGetArgument_Color(L, 1);
-	int result = GetHexValue(arg1);
-	lua_pushinteger(L, result);
-	return 1;
+    Color arg1 = LuaGetArgument_Color(L, 1);
+    int result = GetHexValue(arg1);
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_ColorToFloat(lua_State* L)
 {
-	Color arg1 = LuaGetArgument_Color(L, 1);
-	float * result = ColorToFloat(arg1);
-	lua_createtable(L, 4, 0);
-	for (int i = 0; i < 4; i++)
-	{
-		lua_pushnumber(L, result[i]);
-		lua_rawseti(L, -2, i + 1);
-	}
-	free(result);
-	return 1;
+    Color arg1 = LuaGetArgument_Color(L, 1);
+    float * result = ColorToFloat(arg1);
+    lua_createtable(L, 4, 0);
+    for (int i = 0; i < 4; i++)
+    {
+        lua_pushnumber(L, result[i]);
+        lua_rawseti(L, -2, i + 1);
+    }
+    free(result);
+    return 1;
 }
 
 int lua_VectorToFloat(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float * result = VectorToFloat(arg1);
-	lua_createtable(L, 3, 0);
-	for (int i = 0; i < 3; i++)
-	{
-		lua_pushnumber(L, result[i]);
-		lua_rawseti(L, -2, i + 1);
-	}
-	free(result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float * result = VectorToFloat(arg1);
+    lua_createtable(L, 3, 0);
+    for (int i = 0; i < 3; i++)
+    {
+        lua_pushnumber(L, result[i]);
+        lua_rawseti(L, -2, i + 1);
+    }
+    free(result);
+    return 1;
 }
 
 int lua_MatrixToFloat(lua_State* L)
 {
-	Matrix arg1 = LuaGetArgument_Matrix(L, 1);
-	float * result = MatrixToFloat(arg1);
-	lua_createtable(L, 16, 0);
-	for (int i = 0; i < 16; i++)
-	{
-		lua_pushnumber(L, result[i]);
-		lua_rawseti(L, -2, i + 1);
-	}
-	free(result);
-	return 1;
+    Matrix arg1 = LuaGetArgument_Matrix(L, 1);
+    float * result = MatrixToFloat(arg1);
+    lua_createtable(L, 16, 0);
+    for (int i = 0; i < 16; i++)
+    {
+        lua_pushnumber(L, result[i]);
+        lua_rawseti(L, -2, i + 1);
+    }
+    free(result);
+    return 1;
 }
 
 int lua_GetRandomValue(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int result = GetRandomValue(arg1, arg2);
-	lua_pushinteger(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int result = GetRandomValue(arg1, arg2);
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_Fade(lua_State* L)
 {
-	Color arg1 = LuaGetArgument_Color(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	Color result = Fade(arg1, arg2);
-	LuaPush_Color(L, result);
-	return 1;
+    Color arg1 = LuaGetArgument_Color(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    Color result = Fade(arg1, arg2);
+    LuaPush_Color(L, result);
+    return 1;
 }
 
 int lua_SetConfigFlags(lua_State* L)
 {
-	char arg1 = LuaGetArgument_char(L, 1);
-	SetConfigFlags(arg1);
-	return 0;
+    char arg1 = LuaGetArgument_char(L, 1);
+    SetConfigFlags(arg1);
+    return 0;
 }
 
 int lua_ShowLogo(lua_State* L)
 {
-	ShowLogo();
-	return 0;
+    ShowLogo();
+    return 0;
 }
 
 int lua_IsFileDropped(lua_State* L)
 {
-	bool result = IsFileDropped();
-	lua_pushboolean(L, result);
-	return 1;
+    bool result = IsFileDropped();
+    lua_pushboolean(L, result);
+    return 1;
 }
 /*
 int lua_*GetDroppedFiles(lua_State* L)
 {
-	int * arg1 = LuaGetArgument_int *(L, 1);
-	//char * result = *GetDroppedFiles(arg1);
-	LuaPush_//char *(L, result);
-		return 1;
+    int * arg1 = LuaGetArgument_int *(L, 1);
+    //char * result = *GetDroppedFiles(arg1);
+    LuaPush_//char *(L, result);
+        return 1;
 }
 */
 int lua_ClearDroppedFiles(lua_State* L)
 {
-	ClearDroppedFiles();
-	return 0;
+    ClearDroppedFiles();
+    return 0;
 }
 
 int lua_StorageSaveValue(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	StorageSaveValue(arg1, arg2);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    StorageSaveValue(arg1, arg2);
+    return 0;
 }
 
 int lua_StorageLoadValue(lua_State* L)
 {
     int arg1 = LuaGetArgument_int(L, 1);
-	int result = StorageLoadValue(arg1);
-	lua_pushinteger(L, result);
-	return 1;
+    int result = StorageLoadValue(arg1);
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 //------------------------------------------------------------------------------------
@@ -1094,217 +1094,217 @@ int lua_StorageLoadValue(lua_State* L)
 #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB)
 int lua_IsKeyPressed(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsKeyPressed(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    bool result = IsKeyPressed(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_IsKeyDown(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsKeyDown(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    bool result = IsKeyDown(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_IsKeyReleased(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsKeyReleased(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    bool result = IsKeyReleased(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_IsKeyUp(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsKeyUp(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    bool result = IsKeyUp(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_GetKeyPressed(lua_State* L)
 {
-	int result = GetKeyPressed();
-	lua_pushinteger(L, result);
-	return 1;
+    int result = GetKeyPressed();
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_SetExitKey(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	SetExitKey(arg1);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    SetExitKey(arg1);
+    return 0;
 }
 
 int lua_IsGamepadAvailable(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsGamepadAvailable(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    bool result = IsGamepadAvailable(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_GetGamepadAxisMovement(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	float result = GetGamepadAxisMovement(arg1, arg2);
-	lua_pushnumber(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    float result = GetGamepadAxisMovement(arg1, arg2);
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 int lua_IsGamepadButtonPressed(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	bool result = IsGamepadButtonPressed(arg1, arg2);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    bool result = IsGamepadButtonPressed(arg1, arg2);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_IsGamepadButtonDown(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	bool result = IsGamepadButtonDown(arg1, arg2);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    bool result = IsGamepadButtonDown(arg1, arg2);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_IsGamepadButtonReleased(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	bool result = IsGamepadButtonReleased(arg1, arg2);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    bool result = IsGamepadButtonReleased(arg1, arg2);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_IsGamepadButtonUp(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	bool result = IsGamepadButtonUp(arg1, arg2);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    bool result = IsGamepadButtonUp(arg1, arg2);
+    lua_pushboolean(L, result);
+    return 1;
 }
 #endif
 
 int lua_IsMouseButtonPressed(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsMouseButtonPressed(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    bool result = IsMouseButtonPressed(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_IsMouseButtonDown(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsMouseButtonDown(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    bool result = IsMouseButtonDown(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_IsMouseButtonReleased(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsMouseButtonReleased(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    bool result = IsMouseButtonReleased(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_IsMouseButtonUp(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsMouseButtonUp(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    bool result = IsMouseButtonUp(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_GetMouseX(lua_State* L)
 {
-	int result = GetMouseX();
-	lua_pushinteger(L, result);
-	return 1;
+    int result = GetMouseX();
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_GetMouseY(lua_State* L)
 {
-	int result = GetMouseY();
-	lua_pushinteger(L, result);
-	return 1;
+    int result = GetMouseY();
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_GetMousePosition(lua_State* L)
 {
-	Vector2 result = GetMousePosition();
-	LuaPush_Vector2(L, result);
-	return 1;
+    Vector2 result = GetMousePosition();
+    LuaPush_Vector2(L, result);
+    return 1;
 }
 
 int lua_SetMousePosition(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	SetMousePosition(arg1);
-	return 0;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    SetMousePosition(arg1);
+    return 0;
 }
 
 int lua_GetMouseWheelMove(lua_State* L)
 {
-	int result = GetMouseWheelMove();
-	lua_pushinteger(L, result);
-	return 1;
+    int result = GetMouseWheelMove();
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_GetTouchX(lua_State* L)
 {
-	int result = GetTouchX();
-	lua_pushinteger(L, result);
-	return 1;
+    int result = GetTouchX();
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_GetTouchY(lua_State* L)
 {
-	int result = GetTouchY();
-	lua_pushinteger(L, result);
-	return 1;
+    int result = GetTouchY();
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_GetTouchPosition(lua_State* L)
 {
     int arg1 = LuaGetArgument_int(L, 1);
-	Vector2 result = GetTouchPosition(arg1);
-	LuaPush_Vector2(L, result);
-	return 1;
+    Vector2 result = GetTouchPosition(arg1);
+    LuaPush_Vector2(L, result);
+    return 1;
 }
 
 
 #if defined(PLATFORM_ANDROID)
 int lua_IsButtonPressed(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsButtonPressed(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    bool result = IsButtonPressed(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_IsButtonDown(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsButtonDown(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    bool result = IsButtonDown(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_IsButtonReleased(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsButtonReleased(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    bool result = IsButtonReleased(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 #endif
 
@@ -1313,66 +1313,66 @@ int lua_IsButtonReleased(lua_State* L)
 //------------------------------------------------------------------------------------
 int lua_SetGesturesEnabled(lua_State* L)
 {
-	unsigned arg1 = LuaGetArgument_unsigned(L, 1);
-	SetGesturesEnabled(arg1);
-	return 0;
+    unsigned arg1 = LuaGetArgument_unsigned(L, 1);
+    SetGesturesEnabled(arg1);
+    return 0;
 }
 
 int lua_IsGestureDetected(lua_State* L)
 {
     int arg1 = LuaGetArgument_int(L, 1);
-	bool result = IsGestureDetected(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    bool result = IsGestureDetected(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_GetTouchPointsCount(lua_State* L)
 {
-	int result = GetTouchPointsCount();
-	lua_pushinteger(L, result);
-	return 1;
+    int result = GetTouchPointsCount();
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_GetGestureDetected(lua_State* L)
 {
-	int result = GetGestureDetected();
-	lua_pushinteger(L, result);
-	return 1;
+    int result = GetGestureDetected();
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_GetGestureHoldDuration(lua_State* L)
 {
-	int result = GetGestureHoldDuration();
-	lua_pushinteger(L, result);
-	return 1;
+    int result = GetGestureHoldDuration();
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_GetGestureDragVector(lua_State* L)
 {
-	Vector2 result = GetGestureDragVector();
-	LuaPush_Vector2(L, result);
-	return 1;
+    Vector2 result = GetGestureDragVector();
+    LuaPush_Vector2(L, result);
+    return 1;
 }
 
 int lua_GetGestureDragAngle(lua_State* L)
 {
-	float result = GetGestureDragAngle();
-	lua_pushnumber(L, result);
-	return 1;
+    float result = GetGestureDragAngle();
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 int lua_GetGesturePinchVector(lua_State* L)
 {
-	Vector2 result = GetGesturePinchVector();
-	LuaPush_Vector2(L, result);
-	return 1;
+    Vector2 result = GetGesturePinchVector();
+    LuaPush_Vector2(L, result);
+    return 1;
 }
 
 int lua_GetGesturePinchAngle(lua_State* L)
 {
-	float result = GetGesturePinchAngle();
-	lua_pushnumber(L, result);
-	return 1;
+    float result = GetGesturePinchAngle();
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 //------------------------------------------------------------------------------------
@@ -1380,88 +1380,88 @@ int lua_GetGesturePinchAngle(lua_State* L)
 //------------------------------------------------------------------------------------
 int lua_SetCameraMode(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	SetCameraMode(arg1);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    SetCameraMode(arg1);
+    return 0;
 }
 
 int lua_UpdateCamera(lua_State* L)
 {
-	Camera arg1 = LuaGetArgument_Camera(L, 1);
-	UpdateCamera(&arg1);
-	LuaPush_Camera(L, arg1);
-	return 1;
+    Camera arg1 = LuaGetArgument_Camera(L, 1);
+    UpdateCamera(&arg1);
+    LuaPush_Camera(L, arg1);
+    return 1;
 }
 
 int lua_UpdateCameraPlayer(lua_State* L)
 {
-	Camera arg1 = LuaGetArgument_Camera(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	UpdateCameraPlayer(&arg1, &arg2);
-	LuaPush_Camera(L, arg1);
-	LuaPush_Vector3(L, arg2);
-	return 2;
+    Camera arg1 = LuaGetArgument_Camera(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    UpdateCameraPlayer(&arg1, &arg2);
+    LuaPush_Camera(L, arg1);
+    LuaPush_Vector3(L, arg2);
+    return 2;
 }
 
 int lua_SetCameraPosition(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	SetCameraPosition(arg1);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    SetCameraPosition(arg1);
+    return 0;
 }
 
 int lua_SetCameraTarget(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	SetCameraTarget(arg1);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    SetCameraTarget(arg1);
+    return 0;
 }
 
 int lua_SetCameraFovy(lua_State* L)
 {
-	float arg1 = LuaGetArgument_float(L, 1);
-	SetCameraFovy(arg1);
-	return 0;
+    float arg1 = LuaGetArgument_float(L, 1);
+    SetCameraFovy(arg1);
+    return 0;
 }
 
 int lua_SetCameraPanControl(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	SetCameraPanControl(arg1);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    SetCameraPanControl(arg1);
+    return 0;
 }
 
 int lua_SetCameraAltControl(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	SetCameraAltControl(arg1);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    SetCameraAltControl(arg1);
+    return 0;
 }
 
 int lua_SetCameraSmoothZoomControl(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	SetCameraSmoothZoomControl(arg1);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    SetCameraSmoothZoomControl(arg1);
+    return 0;
 }
 
 int lua_SetCameraMoveControls(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	int arg5 = LuaGetArgument_int(L, 5);
-	int arg6 = LuaGetArgument_int(L, 6);
-	SetCameraMoveControls(arg1, arg2, arg3, arg4, arg5, arg6);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    int arg5 = LuaGetArgument_int(L, 5);
+    int arg6 = LuaGetArgument_int(L, 6);
+    SetCameraMoveControls(arg1, arg2, arg3, arg4, arg5, arg6);
+    return 0;
 }
 
 int lua_SetCameraMouseSensitivity(lua_State* L)
 {
-	float arg1 = LuaGetArgument_float(L, 1);
-	SetCameraMouseSensitivity(arg1);
-	return 0;
+    float arg1 = LuaGetArgument_float(L, 1);
+    SetCameraMouseSensitivity(arg1);
+    return 0;
 }
 
 //------------------------------------------------------------------------------------
@@ -1469,274 +1469,274 @@ int lua_SetCameraMouseSensitivity(lua_State* L)
 //------------------------------------------------------------------------------------
 int lua_DrawPixel(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	Color arg3 = LuaGetArgument_Color(L, 3);
-	DrawPixel(arg1, arg2, arg3);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    Color arg3 = LuaGetArgument_Color(L, 3);
+    DrawPixel(arg1, arg2, arg3);
+    return 0;
 }
 
 int lua_DrawPixelV(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	Color arg2 = LuaGetArgument_Color(L, 2);
-	DrawPixelV(arg1, arg2);
-	return 0;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    Color arg2 = LuaGetArgument_Color(L, 2);
+    DrawPixelV(arg1, arg2);
+    return 0;
 }
 
 int lua_DrawLine(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	DrawLine(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    DrawLine(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 int lua_DrawLineV(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
-	Color arg3 = LuaGetArgument_Color(L, 3);
-	DrawLineV(arg1, arg2, arg3);
-	return 0;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
+    Color arg3 = LuaGetArgument_Color(L, 3);
+    DrawLineV(arg1, arg2, arg3);
+    return 0;
 }
 
 int lua_DrawCircle(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	Color arg4 = LuaGetArgument_Color(L, 4);
-	DrawCircle(arg1, arg2, arg3, arg4);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    Color arg4 = LuaGetArgument_Color(L, 4);
+    DrawCircle(arg1, arg2, arg3, arg4);
+    return 0;
 }
 
 int lua_DrawCircleGradient(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	Color arg4 = LuaGetArgument_Color(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	DrawCircleGradient(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    Color arg4 = LuaGetArgument_Color(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    DrawCircleGradient(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 int lua_DrawCircleV(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	Color arg3 = LuaGetArgument_Color(L, 3);
-	DrawCircleV(arg1, arg2, arg3);
-	return 0;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    Color arg3 = LuaGetArgument_Color(L, 3);
+    DrawCircleV(arg1, arg2, arg3);
+    return 0;
 }
 
 int lua_DrawCircleLines(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	Color arg4 = LuaGetArgument_Color(L, 4);
-	DrawCircleLines(arg1, arg2, arg3, arg4);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    Color arg4 = LuaGetArgument_Color(L, 4);
+    DrawCircleLines(arg1, arg2, arg3, arg4);
+    return 0;
 }
 
 int lua_DrawRectangle(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	DrawRectangle(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    DrawRectangle(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 int lua_DrawRectangleRec(lua_State* L)
 {
-	Rectangle arg1 = LuaGetArgument_Rectangle(L, 1);
-	Color arg2 = LuaGetArgument_Color(L, 2);
-	DrawRectangleRec(arg1, arg2);
-	return 0;
+    Rectangle arg1 = LuaGetArgument_Rectangle(L, 1);
+    Color arg2 = LuaGetArgument_Color(L, 2);
+    DrawRectangleRec(arg1, arg2);
+    return 0;
 }
 
 int lua_DrawRectangleGradient(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	Color arg6 = LuaGetArgument_Color(L, 6);
-	DrawRectangleGradient(arg1, arg2, arg3, arg4, arg5, arg6);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    Color arg6 = LuaGetArgument_Color(L, 6);
+    DrawRectangleGradient(arg1, arg2, arg3, arg4, arg5, arg6);
+    return 0;
 }
 
 int lua_DrawRectangleV(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
-	Color arg3 = LuaGetArgument_Color(L, 3);
-	DrawRectangleV(arg1, arg2, arg3);
-	return 0;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
+    Color arg3 = LuaGetArgument_Color(L, 3);
+    DrawRectangleV(arg1, arg2, arg3);
+    return 0;
 }
 
 int lua_DrawRectangleLines(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	DrawRectangleLines(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    DrawRectangleLines(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 int lua_DrawTriangle(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
-	Vector2 arg3 = LuaGetArgument_Vector2(L, 3);
-	Color arg4 = LuaGetArgument_Color(L, 4);
-	DrawTriangle(arg1, arg2, arg3, arg4);
-	return 0;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
+    Vector2 arg3 = LuaGetArgument_Vector2(L, 3);
+    Color arg4 = LuaGetArgument_Color(L, 4);
+    DrawTriangle(arg1, arg2, arg3, arg4);
+    return 0;
 }
 
 int lua_DrawTriangleLines(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
-	Vector2 arg3 = LuaGetArgument_Vector2(L, 3);
-	Color arg4 = LuaGetArgument_Color(L, 4);
-	DrawTriangleLines(arg1, arg2, arg3, arg4);
-	return 0;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
+    Vector2 arg3 = LuaGetArgument_Vector2(L, 3);
+    Color arg4 = LuaGetArgument_Color(L, 4);
+    DrawTriangleLines(arg1, arg2, arg3, arg4);
+    return 0;
 }
 
 int lua_DrawPoly(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	DrawPoly(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    float arg4 = LuaGetArgument_float(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    DrawPoly(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 #define GET_TABLE(type, name, index) \
-	type* name = 0; \
-	size_t name##_size = 0; \
-	{ \
-		size_t sz = 0; \
-		luaL_checktype(L, index, LUA_TTABLE); \
-		lua_pushnil(L); \
-		while (lua_next(L, index)) { \
-			LuaGetArgument_##type(L, -1); \
-			sz++; \
-			lua_pop(L, 1); \
-		} \
-		lua_pop(L, 1); \
-		name = calloc(sz, sizeof(type)); \
-		sz = 0; \
-		lua_pushnil(L); \
-		while (lua_next(L, index)) { \
-			name[sz] = LuaGetArgument_##type(L, -1); \
-			sz++; \
-			lua_pop(L, 1); \
-		} \
-		lua_pop(L, 1); \
-		name##_size = sz; \
-	}
+    type* name = 0; \
+    size_t name##_size = 0; \
+    { \
+        size_t sz = 0; \
+        luaL_checktype(L, index, LUA_TTABLE); \
+        lua_pushnil(L); \
+        while (lua_next(L, index)) { \
+            LuaGetArgument_##type(L, -1); \
+            sz++; \
+            lua_pop(L, 1); \
+        } \
+        lua_pop(L, 1); \
+        name = calloc(sz, sizeof(type)); \
+        sz = 0; \
+        lua_pushnil(L); \
+        while (lua_next(L, index)) { \
+            name[sz] = LuaGetArgument_##type(L, -1); \
+            sz++; \
+            lua_pop(L, 1); \
+        } \
+        lua_pop(L, 1); \
+        name##_size = sz; \
+    }
 
 
 int lua_DrawPolyEx(lua_State* L)
 {
-	GET_TABLE(Vector2, arg1, 1);
-	Color arg2 = LuaGetArgument_Color(L, 2);
-	DrawPolyEx(arg1, arg1_size, arg2);
-	free(arg1);
-	return 0;
+    GET_TABLE(Vector2, arg1, 1);
+    Color arg2 = LuaGetArgument_Color(L, 2);
+    DrawPolyEx(arg1, arg1_size, arg2);
+    free(arg1);
+    return 0;
 }
 
 int lua_DrawPolyExLines(lua_State* L)
 {
-	GET_TABLE(Vector2, arg1, 1);
-	Color arg2 = LuaGetArgument_Color(L, 2);
-	DrawPolyExLines(arg1, arg1_size, arg2);
-	free(arg1);
-	return 0;
+    GET_TABLE(Vector2, arg1, 1);
+    Color arg2 = LuaGetArgument_Color(L, 2);
+    DrawPolyExLines(arg1, arg1_size, arg2);
+    free(arg1);
+    return 0;
 }
 
 int lua_CheckCollisionRecs(lua_State* L)
 {
-	Rectangle arg1 = LuaGetArgument_Rectangle(L, 1);
-	Rectangle arg2 = LuaGetArgument_Rectangle(L, 2);
-	bool result = CheckCollisionRecs(arg1, arg2);
-	lua_pushboolean(L, result);
-	return 1;
+    Rectangle arg1 = LuaGetArgument_Rectangle(L, 1);
+    Rectangle arg2 = LuaGetArgument_Rectangle(L, 2);
+    bool result = CheckCollisionRecs(arg1, arg2);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_CheckCollisionCircles(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	Vector2 arg3 = LuaGetArgument_Vector2(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	bool result = CheckCollisionCircles(arg1, arg2, arg3, arg4);
-	lua_pushboolean(L, result);
-	return 1;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    Vector2 arg3 = LuaGetArgument_Vector2(L, 3);
+    float arg4 = LuaGetArgument_float(L, 4);
+    bool result = CheckCollisionCircles(arg1, arg2, arg3, arg4);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_CheckCollisionCircleRec(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	Rectangle arg3 = LuaGetArgument_Rectangle(L, 3);
-	bool result = CheckCollisionCircleRec(arg1, arg2, arg3);
-	lua_pushboolean(L, result);
-	return 1;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    Rectangle arg3 = LuaGetArgument_Rectangle(L, 3);
+    bool result = CheckCollisionCircleRec(arg1, arg2, arg3);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_GetCollisionRec(lua_State* L)
 {
-	Rectangle arg1 = LuaGetArgument_Rectangle(L, 1);
-	Rectangle arg2 = LuaGetArgument_Rectangle(L, 2);
-	Rectangle result = GetCollisionRec(arg1, arg2);
-	LuaPush_Rectangle(L, result);
-	return 1;
+    Rectangle arg1 = LuaGetArgument_Rectangle(L, 1);
+    Rectangle arg2 = LuaGetArgument_Rectangle(L, 2);
+    Rectangle result = GetCollisionRec(arg1, arg2);
+    LuaPush_Rectangle(L, result);
+    return 1;
 }
 
 int lua_CheckCollisionPointRec(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	Rectangle arg2 = LuaGetArgument_Rectangle(L, 2);
-	bool result = CheckCollisionPointRec(arg1, arg2);
-	lua_pushboolean(L, result);
-	return 1;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    Rectangle arg2 = LuaGetArgument_Rectangle(L, 2);
+    bool result = CheckCollisionPointRec(arg1, arg2);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_CheckCollisionPointCircle(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	bool result = CheckCollisionPointCircle(arg1, arg2, arg3);
-	lua_pushboolean(L, result);
-	return 1;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    bool result = CheckCollisionPointCircle(arg1, arg2, arg3);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_CheckCollisionPointTriangle(lua_State* L)
 {
-	Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
-	Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
-	Vector2 arg3 = LuaGetArgument_Vector2(L, 3);
-	Vector2 arg4 = LuaGetArgument_Vector2(L, 4);
-	bool result = CheckCollisionPointTriangle(arg1, arg2, arg3, arg4);
-	lua_pushboolean(L, result);
-	return 1;
+    Vector2 arg1 = LuaGetArgument_Vector2(L, 1);
+    Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
+    Vector2 arg3 = LuaGetArgument_Vector2(L, 3);
+    Vector2 arg4 = LuaGetArgument_Vector2(L, 4);
+    bool result = CheckCollisionPointTriangle(arg1, arg2, arg3, arg4);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 //------------------------------------------------------------------------------------
@@ -1744,385 +1744,385 @@ int lua_CheckCollisionPointTriangle(lua_State* L)
 //------------------------------------------------------------------------------------
 int lua_LoadImage(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	Image result = LoadImage(arg1);
-	LuaPush_Image(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    Image result = LoadImage(arg1);
+    LuaPush_Image(L, result);
+    return 1;
 }
 
 int lua_LoadImageEx(lua_State* L)
 {
-	//Color * arg1 = LuaGetArgument_Color *(L, 1);
-	GET_TABLE(Color, arg1, 1);
+    //Color * arg1 = LuaGetArgument_Color *(L, 1);
+    GET_TABLE(Color, arg1, 1);
 
-	int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	Image result = LoadImageEx(arg1, arg2, arg3);
-	LuaPush_Image(L, result);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    Image result = LoadImageEx(arg1, arg2, arg3);
+    LuaPush_Image(L, result);
 
-	free(arg1);
-	return 1;
+    free(arg1);
+    return 1;
 }
 
 int lua_LoadImageRaw(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	int arg5 = LuaGetArgument_int(L, 5);
-	Image result = LoadImageRaw(arg1, arg2, arg3, arg4, arg5);
-	LuaPush_Image(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    int arg5 = LuaGetArgument_int(L, 5);
+    Image result = LoadImageRaw(arg1, arg2, arg3, arg4, arg5);
+    LuaPush_Image(L, result);
+    return 1;
 }
 
 int lua_LoadImageFromRES(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	Image result = LoadImageFromRES(arg1, arg2);
-	LuaPush_Image(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    Image result = LoadImageFromRES(arg1, arg2);
+    LuaPush_Image(L, result);
+    return 1;
 }
 
 int lua_LoadTexture(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	Texture2D result = LoadTexture(arg1);
-	LuaPush_Texture2D(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    Texture2D result = LoadTexture(arg1);
+    LuaPush_Texture2D(L, result);
+    return 1;
 }
 
 int lua_LoadTextureEx(lua_State* L)
 {
-	void * arg1 = (char *)LuaGetArgument_string(L, 1);  // NOTE: getting argument as string
+    void * arg1 = (char *)LuaGetArgument_string(L, 1);  // NOTE: getting argument as string
     int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	Texture2D result = LoadTextureEx(arg1, arg2, arg3, arg4);
-	LuaPush_Texture2D(L, result);
-	return 1;
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    Texture2D result = LoadTextureEx(arg1, arg2, arg3, arg4);
+    LuaPush_Texture2D(L, result);
+    return 1;
 }
 
 int lua_LoadTextureFromRES(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	Texture2D result = LoadTextureFromRES(arg1, arg2);
-	LuaPush_Texture2D(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    Texture2D result = LoadTextureFromRES(arg1, arg2);
+    LuaPush_Texture2D(L, result);
+    return 1;
 }
 
 int lua_LoadTextureFromImage(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	Texture2D result = LoadTextureFromImage(arg1);
-	LuaPush_Texture2D(L, result);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    Texture2D result = LoadTextureFromImage(arg1);
+    LuaPush_Texture2D(L, result);
+    return 1;
 }
 
 int lua_LoadRenderTexture(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	RenderTexture2D result = LoadRenderTexture(arg1, arg2);
-	LuaPush_RenderTexture2D(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    RenderTexture2D result = LoadRenderTexture(arg1, arg2);
+    LuaPush_RenderTexture2D(L, result);
+    return 1;
 }
 
 int lua_UnloadImage(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	UnloadImage(arg1);
-	return 0;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    UnloadImage(arg1);
+    return 0;
 }
 
 int lua_UnloadTexture(lua_State* L)
 {
-	Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
-	UnloadTexture(arg1);
-	return 0;
+    Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
+    UnloadTexture(arg1);
+    return 0;
 }
 
 int lua_UnloadRenderTexture(lua_State* L)
 {
-	RenderTexture2D arg1 = LuaGetArgument_RenderTexture2D(L, 1);
-	UnloadRenderTexture(arg1);
-	return 0;
+    RenderTexture2D arg1 = LuaGetArgument_RenderTexture2D(L, 1);
+    UnloadRenderTexture(arg1);
+    return 0;
 }
 
 int lua_GetImageData(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	Color * result = GetImageData(arg1);
-	lua_createtable(L, arg1.width*arg1.height, 0);
-	for (int i = 0; i < arg1.width*arg1.height; i++)
-	{
-		LuaPush_Color(L, result[i]);
-		lua_rawseti(L, -2, i + 1);
-	}
-	free(result);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    Color * result = GetImageData(arg1);
+    lua_createtable(L, arg1.width*arg1.height, 0);
+    for (int i = 0; i < arg1.width*arg1.height; i++)
+    {
+        LuaPush_Color(L, result[i]);
+        lua_rawseti(L, -2, i + 1);
+    }
+    free(result);
+    return 1;
 }
 
 int lua_GetTextureData(lua_State* L)
 {
-	Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
-	Image result = GetTextureData(arg1);
-	LuaPush_Image(L, result);
-	return 1;
+    Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
+    Image result = GetTextureData(arg1);
+    LuaPush_Image(L, result);
+    return 1;
 }
 
 int lua_ImageToPOT(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	Color arg2 = LuaGetArgument_Color(L, 2);
-	ImageToPOT(&arg1, arg2);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    Color arg2 = LuaGetArgument_Color(L, 2);
+    ImageToPOT(&arg1, arg2);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageFormat(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	ImageFormat(&arg1, arg2);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    ImageFormat(&arg1, arg2);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageDither(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
+    Image arg1 = LuaGetArgument_Image(L, 1);
     int arg2 = LuaGetArgument_int(L, 2);
     int arg3 = LuaGetArgument_int(L, 3);
     int arg4 = LuaGetArgument_int(L, 4);
     int arg5 = LuaGetArgument_int(L, 5);
-	ImageDither(&arg1, arg2, arg3, arg4, arg5);
-	LuaPush_Image(L, arg1);
-	return 1;
+    ImageDither(&arg1, arg2, arg3, arg4, arg5);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageCopy(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	Image result = ImageCopy(arg1);
-	LuaPush_Image(L, result);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    Image result = ImageCopy(arg1);
+    LuaPush_Image(L, result);
+    return 1;
 }
 
 int lua_ImageCrop(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	Rectangle arg2 = LuaGetArgument_Rectangle(L, 2);
-	ImageCrop(&arg1, arg2);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    Rectangle arg2 = LuaGetArgument_Rectangle(L, 2);
+    ImageCrop(&arg1, arg2);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageResize(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	ImageResize(&arg1, arg2, arg3);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    ImageResize(&arg1, arg2, arg3);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageResizeNN(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	ImageResizeNN(&arg1, arg2, arg3);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    ImageResizeNN(&arg1, arg2, arg3);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageText(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	Color arg3 = LuaGetArgument_Color(L, 3);
-	Image result = ImageText(arg1, arg2, arg3);
-	LuaPush_Image(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    Color arg3 = LuaGetArgument_Color(L, 3);
+    Image result = ImageText(arg1, arg2, arg3);
+    LuaPush_Image(L, result);
+    return 1;
 }
 
 int lua_ImageTextEx(lua_State* L)
 {
     SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1);
-	const char * arg2 = LuaGetArgument_string(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	Image result = ImageTextEx(arg1, arg2, arg3, arg4, arg5);
-	LuaPush_Image(L, result);
-	return 1;
+    const char * arg2 = LuaGetArgument_string(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    Image result = ImageTextEx(arg1, arg2, arg3, arg4, arg5);
+    LuaPush_Image(L, result);
+    return 1;
 }
 
 int lua_ImageDraw(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	Image arg2 = LuaGetArgument_Image(L, 2);
-	Rectangle arg3 = LuaGetArgument_Rectangle(L, 3);
-	Rectangle arg4 = LuaGetArgument_Rectangle(L, 4);
-	ImageDraw(&arg1, arg2, arg3, arg4);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    Image arg2 = LuaGetArgument_Image(L, 2);
+    Rectangle arg3 = LuaGetArgument_Rectangle(L, 3);
+    Rectangle arg4 = LuaGetArgument_Rectangle(L, 4);
+    ImageDraw(&arg1, arg2, arg3, arg4);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageDrawText(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
-	const char * arg3 = LuaGetArgument_string(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	ImageDrawText(&arg1, arg2, arg3, arg4, arg5);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
+    const char * arg3 = LuaGetArgument_string(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    ImageDrawText(&arg1, arg2, arg3, arg4, arg5);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageDrawTextEx(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
-	SpriteFont arg3 = LuaGetArgument_SpriteFont(L, 3);
-	const char * arg4 = LuaGetArgument_string(L, 4);
-	int arg5 = LuaGetArgument_int(L, 5);
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
+    SpriteFont arg3 = LuaGetArgument_SpriteFont(L, 3);
+    const char * arg4 = LuaGetArgument_string(L, 4);
+    int arg5 = LuaGetArgument_int(L, 5);
     int arg6 = LuaGetArgument_int(L, 6);
-	Color arg7 = LuaGetArgument_Color(L, 7);
-	ImageDrawTextEx(&arg1, arg2, arg3, arg4, arg5, arg6, arg7);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Color arg7 = LuaGetArgument_Color(L, 7);
+    ImageDrawTextEx(&arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageFlipVertical(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	ImageFlipVertical(&arg1);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    ImageFlipVertical(&arg1);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageFlipHorizontal(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	ImageFlipHorizontal(&arg1);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    ImageFlipHorizontal(&arg1);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageColorTint(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	Color arg2 = LuaGetArgument_Color(L, 2);
-	ImageColorTint(&arg1, arg2);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    Color arg2 = LuaGetArgument_Color(L, 2);
+    ImageColorTint(&arg1, arg2);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageColorInvert(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	ImageColorInvert(&arg1);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    ImageColorInvert(&arg1);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageColorGrayscale(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	ImageColorGrayscale(&arg1);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    ImageColorGrayscale(&arg1);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageColorContrast(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	ImageColorContrast(&arg1, arg2);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    ImageColorContrast(&arg1, arg2);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_ImageColorBrightness(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	ImageColorBrightness(&arg1, arg2);
-	LuaPush_Image(L, arg1);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    ImageColorBrightness(&arg1, arg2);
+    LuaPush_Image(L, arg1);
+    return 1;
 }
 
 int lua_GenTextureMipmaps(lua_State* L)
 {
-	Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
-	GenTextureMipmaps(arg1);
-	return 0;
+    Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
+    GenTextureMipmaps(arg1);
+    return 0;
 }
 
 int lua_UpdateTexture(lua_State* L)
 {
-	Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
+    Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
     void * arg2 = (char *)LuaGetArgument_string(L, 2);  // NOTE: Getting (void *) as string?
-	UpdateTexture(arg1, arg2);
-	return 0;
+    UpdateTexture(arg1, arg2);
+    return 0;
 }
 
 int lua_DrawTexture(lua_State* L)
 {
-	Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	Color arg4 = LuaGetArgument_Color(L, 4);
-	DrawTexture(arg1, arg2, arg3, arg4);
-	return 0;
+    Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    Color arg4 = LuaGetArgument_Color(L, 4);
+    DrawTexture(arg1, arg2, arg3, arg4);
+    return 0;
 }
 
 int lua_DrawTextureV(lua_State* L)
 {
-	Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
-	Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
-	Color arg3 = LuaGetArgument_Color(L, 3);
-	DrawTextureV(arg1, arg2, arg3);
-	return 0;
+    Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
+    Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
+    Color arg3 = LuaGetArgument_Color(L, 3);
+    DrawTextureV(arg1, arg2, arg3);
+    return 0;
 }
 
 int lua_DrawTextureEx(lua_State* L)
 {
-	Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
-	Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	DrawTextureEx(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
+    Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    float arg4 = LuaGetArgument_float(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    DrawTextureEx(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 int lua_DrawTextureRec(lua_State* L)
 {
-	Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
-	Rectangle arg2 = LuaGetArgument_Rectangle(L, 2);
-	Vector2 arg3 = LuaGetArgument_Vector2(L, 3);
-	Color arg4 = LuaGetArgument_Color(L, 4);
-	DrawTextureRec(arg1, arg2, arg3, arg4);
-	return 0;
+    Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
+    Rectangle arg2 = LuaGetArgument_Rectangle(L, 2);
+    Vector2 arg3 = LuaGetArgument_Vector2(L, 3);
+    Color arg4 = LuaGetArgument_Color(L, 4);
+    DrawTextureRec(arg1, arg2, arg3, arg4);
+    return 0;
 }
 
 int lua_DrawTexturePro(lua_State* L)
 {
-	Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
-	Rectangle arg2 = LuaGetArgument_Rectangle(L, 2);
-	Rectangle arg3 = LuaGetArgument_Rectangle(L, 3);
-	Vector2 arg4 = LuaGetArgument_Vector2(L, 4);
-	float arg5 = LuaGetArgument_float(L, 5);
-	Color arg6 = LuaGetArgument_Color(L, 6);
-	DrawTexturePro(arg1, arg2, arg3, arg4, arg5, arg6);
-	return 0;
+    Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
+    Rectangle arg2 = LuaGetArgument_Rectangle(L, 2);
+    Rectangle arg3 = LuaGetArgument_Rectangle(L, 3);
+    Vector2 arg4 = LuaGetArgument_Vector2(L, 4);
+    float arg5 = LuaGetArgument_float(L, 5);
+    Color arg6 = LuaGetArgument_Color(L, 6);
+    DrawTexturePro(arg1, arg2, arg3, arg4, arg5, arg6);
+    return 0;
 }
 
 //------------------------------------------------------------------------------------
@@ -2130,230 +2130,230 @@ int lua_DrawTexturePro(lua_State* L)
 //------------------------------------------------------------------------------------
 int lua_GetDefaultFont(lua_State* L)
 {
-	SpriteFont result = GetDefaultFont();
-	LuaPush_SpriteFont(L, result);
-	return 1;
+    SpriteFont result = GetDefaultFont();
+    LuaPush_SpriteFont(L, result);
+    return 1;
 }
 
 int lua_LoadSpriteFont(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	SpriteFont result = LoadSpriteFont(arg1);
-	LuaPush_SpriteFont(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    SpriteFont result = LoadSpriteFont(arg1);
+    LuaPush_SpriteFont(L, result);
+    return 1;
 }
 
 int lua_UnloadSpriteFont(lua_State* L)
 {
-	SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1);
-	UnloadSpriteFont(arg1);
-	return 0;
+    SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1);
+    UnloadSpriteFont(arg1);
+    return 0;
 }
 
 int lua_DrawText(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	DrawText(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    DrawText(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 int lua_DrawTextEx(lua_State* L)
 {
-	SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1);
-	const char * arg2 = LuaGetArgument_string(L, 2);
-	Vector2 arg3 = LuaGetArgument_Vector2(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	int arg5 = LuaGetArgument_int(L, 5);
-	Color arg6 = LuaGetArgument_Color(L, 6);
-	DrawTextEx(arg1, arg2, arg3, arg4, arg5, arg6);
-	return 0;
+    SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1);
+    const char * arg2 = LuaGetArgument_string(L, 2);
+    Vector2 arg3 = LuaGetArgument_Vector2(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    int arg5 = LuaGetArgument_int(L, 5);
+    Color arg6 = LuaGetArgument_Color(L, 6);
+    DrawTextEx(arg1, arg2, arg3, arg4, arg5, arg6);
+    return 0;
 }
 
 int lua_MeasureText(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int result = MeasureText(arg1, arg2);
-	lua_pushinteger(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int result = MeasureText(arg1, arg2);
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_MeasureTextEx(lua_State* L)
 {
-	SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1);
-	const char * arg2 = LuaGetArgument_string(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	Vector2 result = MeasureTextEx(arg1, arg2, arg3, arg4);
-	LuaPush_Vector2(L, result);
-	return 1;
+    SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1);
+    const char * arg2 = LuaGetArgument_string(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    Vector2 result = MeasureTextEx(arg1, arg2, arg3, arg4);
+    LuaPush_Vector2(L, result);
+    return 1;
 }
 
 int lua_DrawFPS(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	DrawFPS(arg1, arg2);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    DrawFPS(arg1, arg2);
+    return 0;
 }
 
-// TODO: const char *FormatText(const char *text, ...);
-// TODO: const char *SubText(const char *text, int position, int length);
+// NOTE: FormatText() can be replaced by Lua function: string.format()
+// NOTE: SubText() can be replaced by Lua function: string.sub()
 
 int lua_DrawCube(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	DrawCube(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    float arg4 = LuaGetArgument_float(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    DrawCube(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 int lua_DrawCubeV(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	Color arg3 = LuaGetArgument_Color(L, 3);
-	DrawCubeV(arg1, arg2, arg3);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    Color arg3 = LuaGetArgument_Color(L, 3);
+    DrawCubeV(arg1, arg2, arg3);
+    return 0;
 }
 
 int lua_DrawCubeWires(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	DrawCubeWires(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    float arg4 = LuaGetArgument_float(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    DrawCubeWires(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 int lua_DrawCubeTexture(lua_State* L)
 {
-	Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	float arg5 = LuaGetArgument_float(L, 5);
-	Color arg6 = LuaGetArgument_Color(L, 6);
-	DrawCubeTexture(arg1, arg2, arg3, arg4, arg5, arg6);
-	return 0;
+    Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    float arg4 = LuaGetArgument_float(L, 4);
+    float arg5 = LuaGetArgument_float(L, 5);
+    Color arg6 = LuaGetArgument_Color(L, 6);
+    DrawCubeTexture(arg1, arg2, arg3, arg4, arg5, arg6);
+    return 0;
 }
 
 int lua_DrawSphere(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	Color arg3 = LuaGetArgument_Color(L, 3);
-	DrawSphere(arg1, arg2, arg3);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    Color arg3 = LuaGetArgument_Color(L, 3);
+    DrawSphere(arg1, arg2, arg3);
+    return 0;
 }
 
 int lua_DrawSphereEx(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	DrawSphereEx(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    DrawSphereEx(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 int lua_DrawSphereWires(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	DrawSphereWires(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    DrawSphereWires(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 int lua_DrawCylinder(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	int arg5 = LuaGetArgument_int(L, 5);
-	Color arg6 = LuaGetArgument_Color(L, 6);
-	DrawCylinder(arg1, arg2, arg3, arg4, arg5, arg6);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    float arg4 = LuaGetArgument_float(L, 4);
+    int arg5 = LuaGetArgument_int(L, 5);
+    Color arg6 = LuaGetArgument_Color(L, 6);
+    DrawCylinder(arg1, arg2, arg3, arg4, arg5, arg6);
+    return 0;
 }
 
 int lua_DrawCylinderWires(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	int arg5 = LuaGetArgument_int(L, 5);
-	Color arg6 = LuaGetArgument_Color(L, 6);
-	DrawCylinderWires(arg1, arg2, arg3, arg4, arg5, arg6);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    float arg4 = LuaGetArgument_float(L, 4);
+    int arg5 = LuaGetArgument_int(L, 5);
+    Color arg6 = LuaGetArgument_Color(L, 6);
+    DrawCylinderWires(arg1, arg2, arg3, arg4, arg5, arg6);
+    return 0;
 }
 
 int lua_DrawPlane(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
-	Color arg3 = LuaGetArgument_Color(L, 3);
-	DrawPlane(arg1, arg2, arg3);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector2 arg2 = LuaGetArgument_Vector2(L, 2);
+    Color arg3 = LuaGetArgument_Color(L, 3);
+    DrawPlane(arg1, arg2, arg3);
+    return 0;
 }
 
 int lua_DrawRay(lua_State* L)
 {
-	Ray arg1 = LuaGetArgument_Ray(L, 1);
-	Color arg2 = LuaGetArgument_Color(L, 2);
-	DrawRay(arg1, arg2);
-	return 0;
+    Ray arg1 = LuaGetArgument_Ray(L, 1);
+    Color arg2 = LuaGetArgument_Color(L, 2);
+    DrawRay(arg1, arg2);
+    return 0;
 }
 
 int lua_DrawGrid(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	DrawGrid(arg1, arg2);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    DrawGrid(arg1, arg2);
+    return 0;
 }
 
 int lua_DrawGizmo(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	DrawGizmo(arg1);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    DrawGizmo(arg1);
+    return 0;
 }
 
 // TODO: DrawLight(Light light);
 
 int lua_Draw3DLine(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	Color arg3 = LuaGetArgument_Color(L, 3);
-	Draw3DLine(arg1, arg2, arg3);
-	return 0;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    Color arg3 = LuaGetArgument_Color(L, 3);
+    Draw3DLine(arg1, arg2, arg3);
+    return 0;
 }
 
 int lua_Draw3DCircle(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
     float arg2 = LuaGetArgument_float(L, 2);
     float arg3 = LuaGetArgument_float(L, 3);
-	Vector3 arg4 = LuaGetArgument_Vector3(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	Draw3DCircle(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    Vector3 arg4 = LuaGetArgument_Vector3(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    Draw3DCircle(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 //------------------------------------------------------------------------------------
@@ -2361,231 +2361,231 @@ int lua_Draw3DCircle(lua_State* L)
 //------------------------------------------------------------------------------------
 int lua_LoadModel(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	Model result = LoadModel(arg1);
-	LuaPush_Model(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    Model result = LoadModel(arg1);
+    LuaPush_Model(L, result);
+    return 1;
 }
 
 int lua_LoadModelEx(lua_State* L)
 {
-	Mesh arg1 = LuaGetArgument_Mesh(L, 1);
-	bool arg2 = LuaGetArgument_int(L, 2);
-	Model result = LoadModelEx(arg1, arg2);
-	LuaPush_Model(L, result);
-	return 1;
+    Mesh arg1 = LuaGetArgument_Mesh(L, 1);
+    bool arg2 = LuaGetArgument_int(L, 2);
+    Model result = LoadModelEx(arg1, arg2);
+    LuaPush_Model(L, result);
+    return 1;
 }
 
 int lua_LoadModelFromRES(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	Model result = LoadModelFromRES(arg1, arg2);
-	LuaPush_Model(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    Model result = LoadModelFromRES(arg1, arg2);
+    LuaPush_Model(L, result);
+    return 1;
 }
 
 int lua_LoadHeightmap(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	Model result = LoadHeightmap(arg1, arg2);
-	LuaPush_Model(L, result);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    Model result = LoadHeightmap(arg1, arg2);
+    LuaPush_Model(L, result);
+    return 1;
 }
 
 int lua_LoadCubicmap(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	Model result = LoadCubicmap(arg1);
-	LuaPush_Model(L, result);
-	return 1;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    Model result = LoadCubicmap(arg1);
+    LuaPush_Model(L, result);
+    return 1;
 }
 
 int lua_UnloadModel(lua_State* L)
 {
-	Model arg1 = LuaGetArgument_Model(L, 1);
-	UnloadModel(arg1);
-	return 0;
+    Model arg1 = LuaGetArgument_Model(L, 1);
+    UnloadModel(arg1);
+    return 0;
 }
 
 // TODO: GenMesh*() functionality (not ready yet on raylib 1.6)
 
 int lua_LoadMaterial(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	Material result = LoadMaterial(arg1);
-	LuaPush_Material(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    Material result = LoadMaterial(arg1);
+    LuaPush_Material(L, result);
+    return 1;
 }
 
 int lua_LoadDefaultMaterial(lua_State* L)
 {
-	Material result = LoadDefaultMaterial();
-	LuaPush_Material(L, result);
-	return 1;
+    Material result = LoadDefaultMaterial();
+    LuaPush_Material(L, result);
+    return 1;
 }
 
 int lua_LoadStandardMaterial(lua_State* L)
 {
-	Material result = LoadStandardMaterial();
-	LuaPush_Material(L, result);
-	return 1;
+    Material result = LoadStandardMaterial();
+    LuaPush_Material(L, result);
+    return 1;
 }
 
 int lua_UnloadMaterial(lua_State* L)
 {
-	Material arg1 = LuaGetArgument_Material(L, 1);
-	UnloadMaterial(arg1);
-	return 0;
+    Material arg1 = LuaGetArgument_Material(L, 1);
+    UnloadMaterial(arg1);
+    return 0;
 }
 
 int lua_DrawModel(lua_State* L)
 {
-	Model arg1 = LuaGetArgument_Model(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	Color arg4 = LuaGetArgument_Color(L, 4);
-	DrawModel(arg1, arg2, arg3, arg4);
-	return 0;
+    Model arg1 = LuaGetArgument_Model(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    Color arg4 = LuaGetArgument_Color(L, 4);
+    DrawModel(arg1, arg2, arg3, arg4);
+    return 0;
 }
 
 int lua_DrawModelEx(lua_State* L)
 {
-	Model arg1 = LuaGetArgument_Model(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    Model arg1 = LuaGetArgument_Model(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
     Vector3 arg3 = LuaGetArgument_Vector3(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	Vector3 arg5 = LuaGetArgument_Vector3(L, 5);
-	Color arg6 = LuaGetArgument_Color(L, 6);
-	DrawModelEx(arg1, arg2, arg3, arg4, arg5, arg6);
-	return 0;
+    float arg4 = LuaGetArgument_float(L, 4);
+    Vector3 arg5 = LuaGetArgument_Vector3(L, 5);
+    Color arg6 = LuaGetArgument_Color(L, 6);
+    DrawModelEx(arg1, arg2, arg3, arg4, arg5, arg6);
+    return 0;
 }
 
 int lua_DrawModelWires(lua_State* L)
 {
-	Model arg1 = LuaGetArgument_Model(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	Color arg4 = LuaGetArgument_Color(L, 4);
-	DrawModelWires(arg1, arg2, arg3, arg4);
-	return 0;
+    Model arg1 = LuaGetArgument_Model(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    Color arg4 = LuaGetArgument_Color(L, 4);
+    DrawModelWires(arg1, arg2, arg3, arg4);
+    return 0;
 }
 
 int lua_DrawModelWiresEx(lua_State* L)
 {
-	Model arg1 = LuaGetArgument_Model(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    Model arg1 = LuaGetArgument_Model(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
     Vector3 arg3 = LuaGetArgument_Vector3(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	Vector3 arg5 = LuaGetArgument_Vector3(L, 5);
-	Color arg6 = LuaGetArgument_Color(L, 6);
-	DrawModelWiresEx(arg1, arg2, arg3, arg4, arg5, arg6);
-	return 0;
+    float arg4 = LuaGetArgument_float(L, 4);
+    Vector3 arg5 = LuaGetArgument_Vector3(L, 5);
+    Color arg6 = LuaGetArgument_Color(L, 6);
+    DrawModelWiresEx(arg1, arg2, arg3, arg4, arg5, arg6);
+    return 0;
 }
 
 int lua_DrawBillboard(lua_State* L)
 {
-	Camera arg1 = LuaGetArgument_Camera(L, 1);
-	Texture2D arg2 = LuaGetArgument_Texture2D(L, 2);
-	Vector3 arg3 = LuaGetArgument_Vector3(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	Color arg5 = LuaGetArgument_Color(L, 5);
-	DrawBillboard(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    Camera arg1 = LuaGetArgument_Camera(L, 1);
+    Texture2D arg2 = LuaGetArgument_Texture2D(L, 2);
+    Vector3 arg3 = LuaGetArgument_Vector3(L, 3);
+    float arg4 = LuaGetArgument_float(L, 4);
+    Color arg5 = LuaGetArgument_Color(L, 5);
+    DrawBillboard(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 
 int lua_DrawBillboardRec(lua_State* L)
 {
-	Camera arg1 = LuaGetArgument_Camera(L, 1);
-	Texture2D arg2 = LuaGetArgument_Texture2D(L, 2);
-	Rectangle arg3 = LuaGetArgument_Rectangle(L, 3);
-	Vector3 arg4 = LuaGetArgument_Vector3(L, 4);
-	float arg5 = LuaGetArgument_float(L, 5);
-	Color arg6 = LuaGetArgument_Color(L, 6);
-	DrawBillboardRec(arg1, arg2, arg3, arg4, arg5, arg6);
-	return 0;
+    Camera arg1 = LuaGetArgument_Camera(L, 1);
+    Texture2D arg2 = LuaGetArgument_Texture2D(L, 2);
+    Rectangle arg3 = LuaGetArgument_Rectangle(L, 3);
+    Vector3 arg4 = LuaGetArgument_Vector3(L, 4);
+    float arg5 = LuaGetArgument_float(L, 5);
+    Color arg6 = LuaGetArgument_Color(L, 6);
+    DrawBillboardRec(arg1, arg2, arg3, arg4, arg5, arg6);
+    return 0;
 }
 
 int lua_CalculateBoundingBox(lua_State* L)
 {
-	Mesh arg1 = LuaGetArgument_Mesh(L, 1);
+    Mesh arg1 = LuaGetArgument_Mesh(L, 1);
     BoundingBox result = CalculateBoundingBox(arg1);
-	LuaPush_BoundingBox(L, result);
-	return 1;
+    LuaPush_BoundingBox(L, result);
+    return 1;
 }
 
 int lua_CheckCollisionSpheres(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	Vector3 arg3 = LuaGetArgument_Vector3(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	bool result = CheckCollisionSpheres(arg1, arg2, arg3, arg4);
-	lua_pushboolean(L, result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    Vector3 arg3 = LuaGetArgument_Vector3(L, 3);
+    float arg4 = LuaGetArgument_float(L, 4);
+    bool result = CheckCollisionSpheres(arg1, arg2, arg3, arg4);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_CheckCollisionBoxes(lua_State* L)
 {
-	BoundingBox arg1 = LuaGetArgument_BoundingBox(L, 1);
-	BoundingBox arg2 = LuaGetArgument_BoundingBox(L, 2);
-	bool result = CheckCollisionBoxes(arg1, arg2);
-	lua_pushboolean(L, result);
-	return 1;
+    BoundingBox arg1 = LuaGetArgument_BoundingBox(L, 1);
+    BoundingBox arg2 = LuaGetArgument_BoundingBox(L, 2);
+    bool result = CheckCollisionBoxes(arg1, arg2);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_CheckCollisionBoxSphere(lua_State* L)
 {
-	BoundingBox arg1 = LuaGetArgument_BoundingBox(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	bool result = CheckCollisionBoxSphere(arg1, arg2, arg3);
-	lua_pushboolean(L, result);
-	return 1;
+    BoundingBox arg1 = LuaGetArgument_BoundingBox(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    bool result = CheckCollisionBoxSphere(arg1, arg2, arg3);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_CheckCollisionRaySphere(lua_State* L)
 {
-	Ray arg1 = LuaGetArgument_Ray(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	bool result = CheckCollisionRaySphere(arg1, arg2, arg3);
-	lua_pushboolean(L, result);
-	return 1;
+    Ray arg1 = LuaGetArgument_Ray(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    bool result = CheckCollisionRaySphere(arg1, arg2, arg3);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_CheckCollisionRaySphereEx(lua_State* L)
 {
-	Ray arg1 = LuaGetArgument_Ray(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
+    Ray arg1 = LuaGetArgument_Ray(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
     Vector3 arg4 = LuaGetArgument_Vector3(L, 4);
-	bool result = CheckCollisionRaySphereEx(arg1, arg2, arg3, &arg4);
-	lua_pushboolean(L, result);
+    bool result = CheckCollisionRaySphereEx(arg1, arg2, arg3, &arg4);
+    lua_pushboolean(L, result);
     LuaPush_Vector3(L, arg4);
-	return 2;
+    return 2;
 }
 
 int lua_CheckCollisionRayBox(lua_State* L)
 {
-	Ray arg1 = LuaGetArgument_Ray(L, 1);
-	BoundingBox arg2 = LuaGetArgument_BoundingBox(L, 2);
-	bool result = CheckCollisionRayBox(arg1, arg2);
-	lua_pushboolean(L, result);
-	return 1;
+    Ray arg1 = LuaGetArgument_Ray(L, 1);
+    BoundingBox arg2 = LuaGetArgument_BoundingBox(L, 2);
+    bool result = CheckCollisionRayBox(arg1, arg2);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_ResolveCollisionCubicmap(lua_State* L)
 {
-	Image arg1 = LuaGetArgument_Image(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	Vector3 arg3 = LuaGetArgument_Vector3(L, 3);
-	float arg4 = LuaGetArgument_float(L, 4);
-	Vector3 result = ResolveCollisionCubicmap(arg1, arg2, &arg3, arg4);
-	LuaPush_Vector3(L, result);
-	LuaPush_Vector3(L, arg3);
-	return 2;
+    Image arg1 = LuaGetArgument_Image(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    Vector3 arg3 = LuaGetArgument_Vector3(L, 3);
+    float arg4 = LuaGetArgument_float(L, 4);
+    Vector3 result = ResolveCollisionCubicmap(arg1, arg2, &arg3, arg4);
+    LuaPush_Vector3(L, result);
+    LuaPush_Vector3(L, arg3);
+    return 2;
 }
 
 //------------------------------------------------------------------------------------
@@ -2593,167 +2593,170 @@ int lua_ResolveCollisionCubicmap(lua_State* L)
 //------------------------------------------------------------------------------------
 int lua_LoadShader(lua_State* L)
 {
-	char * arg1 = (char *)LuaGetArgument_string(L, 1);
-	char * arg2 = (char *)LuaGetArgument_string(L, 2);
-	Shader result = LoadShader(arg1, arg2);
-	LuaPush_Shader(L, result);
-	return 1;
+    char * arg1 = (char *)LuaGetArgument_string(L, 1);
+    char * arg2 = (char *)LuaGetArgument_string(L, 2);
+    Shader result = LoadShader(arg1, arg2);
+    LuaPush_Shader(L, result);
+    return 1;
 }
 
 int lua_UnloadShader(lua_State* L)
 {
-	Shader arg1 = LuaGetArgument_Shader(L, 1);
-	UnloadShader(arg1);
-	return 0;
+    Shader arg1 = LuaGetArgument_Shader(L, 1);
+    UnloadShader(arg1);
+    return 0;
 }
 
 int lua_GetDefaultShader(lua_State* L)
 {
-	Shader result = GetDefaultShader();
-	LuaPush_Shader(L, result);
-	return 1;
+    Shader result = GetDefaultShader();
+    LuaPush_Shader(L, result);
+    return 1;
 }
 
 int lua_GetStandardShader(lua_State* L)
 {
-	Shader result = GetStandardShader();
-	LuaPush_Shader(L, result);
-	return 1;
+    Shader result = GetStandardShader();
+    LuaPush_Shader(L, result);
+    return 1;
 }
 
 int lua_GetDefaultTexture(lua_State* L)
 {
-	Texture2D result = GetDefaultTexture();
-	LuaPush_Texture2D(L, result);
-	return 1;
+    Texture2D result = GetDefaultTexture();
+    LuaPush_Texture2D(L, result);
+    return 1;
 }
 
 int lua_GetShaderLocation(lua_State* L)
 {
-	Shader arg1 = LuaGetArgument_Shader(L, 1);
-	const char * arg2 = LuaGetArgument_string(L, 2);
-	int result = GetShaderLocation(arg1, arg2);
-	lua_pushinteger(L, result);
-	return 1;
+    Shader arg1 = LuaGetArgument_Shader(L, 1);
+    const char * arg2 = LuaGetArgument_string(L, 2);
+    int result = GetShaderLocation(arg1, arg2);
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 int lua_SetShaderValue(lua_State* L)
 {
-	Shader arg1 = LuaGetArgument_Shader(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	GET_TABLE(float, arg3, 3);
-	SetShaderValue(arg1, arg2, arg3, arg3_size);
-	free(arg3);
-	return 0;
+    Shader arg1 = LuaGetArgument_Shader(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    GET_TABLE(float, arg3, 3);
+    SetShaderValue(arg1, arg2, arg3, arg3_size);
+    free(arg3);
+    return 0;
 }
 
 int lua_SetShaderValuei(lua_State* L)
 {
-	Shader arg1 = LuaGetArgument_Shader(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	GET_TABLE(int, arg3, 3);
-	SetShaderValuei(arg1, arg2, arg3, arg3_size);
-	free(arg3);
-	return 0;
+    Shader arg1 = LuaGetArgument_Shader(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    GET_TABLE(int, arg3, 3);
+    SetShaderValuei(arg1, arg2, arg3, arg3_size);
+    free(arg3);
+    return 0;
 }
 
 int lua_SetShaderValueMatrix(lua_State* L)
 {
-	Shader arg1 = LuaGetArgument_Shader(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	Matrix arg3 = LuaGetArgument_Matrix(L, 3);
-	SetShaderValueMatrix(arg1, arg2, arg3);
-	return 0;
+    Shader arg1 = LuaGetArgument_Shader(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    Matrix arg3 = LuaGetArgument_Matrix(L, 3);
+    SetShaderValueMatrix(arg1, arg2, arg3);
+    return 0;
 }
 
 int lua_SetMatrixProjection(lua_State* L)
 {
-	Matrix arg1 = LuaGetArgument_Matrix(L, 1);
-	SetMatrixProjection(arg1);
-	return 0;
+    Matrix arg1 = LuaGetArgument_Matrix(L, 1);
+    SetMatrixProjection(arg1);
+    return 0;
 }
 
 int lua_SetMatrixModelview(lua_State* L)
 {
-	Matrix arg1 = LuaGetArgument_Matrix(L, 1);
-	SetMatrixModelview(arg1);
-	return 0;
+    Matrix arg1 = LuaGetArgument_Matrix(L, 1);
+    SetMatrixModelview(arg1);
+    return 0;
 }
 
 int lua_BeginShaderMode(lua_State* L)
 {
-	Shader arg1 = LuaGetArgument_Shader(L, 1);
-	BeginShaderMode(arg1);
-	return 0;
+    Shader arg1 = LuaGetArgument_Shader(L, 1);
+    BeginShaderMode(arg1);
+    return 0;
 }
 
 int lua_EndShaderMode(lua_State* L)
 {
-	EndShaderMode();
-	return 0;
+    EndShaderMode();
+    return 0;
 }
 
 int lua_BeginBlendMode(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	BeginBlendMode(arg1);
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    BeginBlendMode(arg1);
+    return 0;
 }
 
 int lua_EndBlendMode(lua_State* L)
 {
-	EndBlendMode();
-	return 0;
+    EndBlendMode();
+    return 0;
 }
 
-// TODO: Light CreateLight(int type, Vector3 position, Color diffuse);
-// TODO: void DestroyLight(Light light);
-
-//------------------------------------------------------------------------------------
-// raylib [rlgl] module functions - VR experience
-//------------------------------------------------------------------------------------
-int lua_InitVrDevice(lua_State* L)
+int lua_CreateLight(lua_State* L)
 {
     int arg1 = LuaGetArgument_int(L, 1);
-	InitVrDevice(arg1);
-	return 0;
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    Color arg3 = LuaGetArgument_Color(L, 3);
+    Light result = CreateLight(arg1, arg2, arg3);
+    LuaPush_Light(L, result);
+    return 1;
 }
 
-int lua_CloseVrDevice(lua_State* L)
+int lua_DestroyLight(lua_State* L)
 {
-	CloseVrDevice();
-	return 0;
+    Light arg1 = LuaGetArgument_Light(L, 1);
+    DestroyLight(arg1);
+    return 0;
 }
 
-int lua_UpdateVrTracking(lua_State* L)
+
+//------------------------------------------------------------------------------------
+// raylib [rlgl] module functions - VR experience
+//------------------------------------------------------------------------------------
+int lua_InitVrDevice(lua_State* L)
 {
-	UpdateVrTracking();
-	return 0;
+    int arg1 = LuaGetArgument_int(L, 1);
+    InitVrDevice(arg1);
+    return 0;
 }
 
-int lua_BeginVrDrawing(lua_State* L)
+int lua_CloseVrDevice(lua_State* L)
 {
-	BeginVrDrawing();
-	return 0;
+    CloseVrDevice();
+    return 0;
 }
 
-int lua_EndVrDrawing(lua_State* L)
+int lua_IsVrDeviceReady(lua_State* L)
 {
-	EndVrDrawing();
-	return 0;
+    bool result = IsVrDeviceReady();
+    lua_pushboolean(L, result);
+    return 1;
 }
 
-int lua_IsVrDeviceReady(lua_State* L)
+int lua_UpdateVrTracking(lua_State* L)
 {
-	bool result = IsVrDeviceReady();
-	lua_pushboolean(L, result);
-	return 1;
+    UpdateVrTracking();
+    return 0;
 }
 
 int lua_ToggleVrMode(lua_State* L)
 {
-	ToggleVrMode();
-	return 0;
+    ToggleVrMode();
+    return 0;
 }
 
 //------------------------------------------------------------------------------------
@@ -2761,213 +2764,213 @@ int lua_ToggleVrMode(lua_State* L)
 //------------------------------------------------------------------------------------
 int lua_InitAudioDevice(lua_State* L)
 {
-	InitAudioDevice();
-	return 0;
+    InitAudioDevice();
+    return 0;
 }
 
 int lua_CloseAudioDevice(lua_State* L)
 {
-	CloseAudioDevice();
-	return 0;
+    CloseAudioDevice();
+    return 0;
 }
 
 int lua_IsAudioDeviceReady(lua_State* L)
 {
-	bool result = IsAudioDeviceReady();
+    bool result = IsAudioDeviceReady();
     lua_pushboolean(L, result);
-	return 1;
+    return 1;
 }
 
 int lua_LoadSound(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	Sound result = LoadSound((char*)arg1);
-	LuaPush_Sound(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    Sound result = LoadSound((char*)arg1);
+    LuaPush_Sound(L, result);
+    return 1;
 }
 
 int lua_LoadSoundFromWave(lua_State* L)
 {
-	Wave arg1 = LuaGetArgument_Wave(L, 1);
-	Sound result = LoadSoundFromWave(arg1);
-	LuaPush_Sound(L, result);
-	return 1;
+    Wave arg1 = LuaGetArgument_Wave(L, 1);
+    Sound result = LoadSoundFromWave(arg1);
+    LuaPush_Sound(L, result);
+    return 1;
 }
 
 int lua_LoadSoundFromRES(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	Sound result = LoadSoundFromRES(arg1, arg2);
-	LuaPush_Sound(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    Sound result = LoadSoundFromRES(arg1, arg2);
+    LuaPush_Sound(L, result);
+    return 1;
 }
 
 int lua_UnloadSound(lua_State* L)
 {
-	Sound arg1 = LuaGetArgument_Sound(L, 1);
-	UnloadSound(arg1);
-	return 0;
+    Sound arg1 = LuaGetArgument_Sound(L, 1);
+    UnloadSound(arg1);
+    return 0;
 }
 
 int lua_PlaySound(lua_State* L)
 {
-	Sound arg1 = LuaGetArgument_Sound(L, 1);
-	PlaySound(arg1);
-	return 0;
+    Sound arg1 = LuaGetArgument_Sound(L, 1);
+    PlaySound(arg1);
+    return 0;
 }
 
 int lua_PauseSound(lua_State* L)
 {
-	Sound arg1 = LuaGetArgument_Sound(L, 1);
-	PauseSound(arg1);
-	return 0;
+    Sound arg1 = LuaGetArgument_Sound(L, 1);
+    PauseSound(arg1);
+    return 0;
 }
 
 int lua_ResumeSound(lua_State* L)
 {
-	Sound arg1 = LuaGetArgument_Sound(L, 1);
-	ResumeSound(arg1);
-	return 0;
+    Sound arg1 = LuaGetArgument_Sound(L, 1);
+    ResumeSound(arg1);
+    return 0;
 }
 
 int lua_StopSound(lua_State* L)
 {
-	Sound arg1 = LuaGetArgument_Sound(L, 1);
-	StopSound(arg1);
-	return 0;
+    Sound arg1 = LuaGetArgument_Sound(L, 1);
+    StopSound(arg1);
+    return 0;
 }
 
 int lua_IsSoundPlaying(lua_State* L)
 {
-	Sound arg1 = LuaGetArgument_Sound(L, 1);
-	bool result = IsSoundPlaying(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    Sound arg1 = LuaGetArgument_Sound(L, 1);
+    bool result = IsSoundPlaying(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_SetSoundVolume(lua_State* L)
 {
-	Sound arg1 = LuaGetArgument_Sound(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	SetSoundVolume(arg1, arg2);
-	return 0;
+    Sound arg1 = LuaGetArgument_Sound(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    SetSoundVolume(arg1, arg2);
+    return 0;
 }
 
 int lua_SetSoundPitch(lua_State* L)
 {
-	Sound arg1 = LuaGetArgument_Sound(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	SetSoundPitch(arg1, arg2);
-	return 0;
+    Sound arg1 = LuaGetArgument_Sound(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    SetSoundPitch(arg1, arg2);
+    return 0;
 }
 
 int lua_LoadMusicStream(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
+    const char * arg1 = LuaGetArgument_string(L, 1);
     Music result = LoadMusicStream((char *)arg1);
-	LuaPush_Music(L, result);
-	return 1;
+    LuaPush_Music(L, result);
+    return 1;
 }
 
 int lua_UnloadMusicStream(lua_State* L)
 {
-	Music arg1 = LuaGetArgument_Music(L, 1);
-	UnloadMusicStream(arg1);
-	return 0;
+    Music arg1 = LuaGetArgument_Music(L, 1);
+    UnloadMusicStream(arg1);
+    return 0;
 }
 
 int lua_UpdateMusicStream(lua_State* L)
 {
     Music arg1 = LuaGetArgument_Music(L, 1);
-	UpdateMusicStream(arg1);
-	return 0;
+    UpdateMusicStream(arg1);
+    return 0;
 }
 
 int lua_PlayMusicStream(lua_State* L)
 {
-	Music arg1 = LuaGetArgument_Music(L, 1);
-	PlayMusicStream(arg1);
-	return 0;
+    Music arg1 = LuaGetArgument_Music(L, 1);
+    PlayMusicStream(arg1);
+    return 0;
 }
 
 
 int lua_StopMusicStream(lua_State* L)
 {
     Music arg1 = LuaGetArgument_Music(L, 1);
-	StopMusicStream(arg1);
-	return 0;
+    StopMusicStream(arg1);
+    return 0;
 }
 
 int lua_PauseMusicStream(lua_State* L)
 {
     Music arg1 = LuaGetArgument_Music(L, 1);
-	PauseMusicStream(arg1);
-	return 0;
+    PauseMusicStream(arg1);
+    return 0;
 }
 
 int lua_ResumeMusicStream(lua_State* L)
 {
     Music arg1 = LuaGetArgument_Music(L, 1);
-	ResumeMusicStream(arg1);
-	return 0;
+    ResumeMusicStream(arg1);
+    return 0;
 }
 
 int lua_IsMusicPlaying(lua_State* L)
 {
     Music arg1 = LuaGetArgument_Music(L, 1);
-	bool result = IsMusicPlaying(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    bool result = IsMusicPlaying(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_SetMusicVolume(lua_State* L)
 {
     Music arg1 = LuaGetArgument_Music(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	SetMusicVolume(arg1, arg2);
-	return 0;
+    float arg2 = LuaGetArgument_float(L, 2);
+    SetMusicVolume(arg1, arg2);
+    return 0;
 }
 
 int lua_SetMusicPitch(lua_State* L)
 {
     Music arg1 = LuaGetArgument_Music(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	SetMusicPitch(arg1, arg2);
-	return 0;
+    float arg2 = LuaGetArgument_float(L, 2);
+    SetMusicPitch(arg1, arg2);
+    return 0;
 }
 
 int lua_GetMusicTimeLength(lua_State* L)
 {
     Music arg1 = LuaGetArgument_Music(L, 1);
-	float result = GetMusicTimeLength(arg1);
-	lua_pushnumber(L, result);
-	return 1;
+    float result = GetMusicTimeLength(arg1);
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 int lua_GetMusicTimePlayed(lua_State* L)
 {
     Music arg1 = LuaGetArgument_Music(L, 1);
-	float result = GetMusicTimePlayed(arg1);
-	lua_pushnumber(L, result);
-	return 1;
+    float result = GetMusicTimePlayed(arg1);
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 int lua_InitAudioStream(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int arg2 = LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
+    int arg1 = LuaGetArgument_int(L, 1);
+    int arg2 = LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
     AudioStream result = InitAudioStream(arg1, arg2, arg3);
-	LuaPush_AudioStream(L, result);
-	return 1;
+    LuaPush_AudioStream(L, result);
+    return 1;
 }
 
 int lua_CloseAudioStream(lua_State* L)
 {
-	AudioStream arg1 = LuaGetArgument_AudioStream(L, 1);
-	CloseAudioStream(arg1);
-	return 0;
+    AudioStream arg1 = LuaGetArgument_AudioStream(L, 1);
+    CloseAudioStream(arg1);
+    return 0;
 }
 
 int lua_UpdateAudioStream(lua_State* L)
@@ -2975,45 +2978,45 @@ int lua_UpdateAudioStream(lua_State* L)
     AudioStream arg1 = LuaGetArgument_AudioStream(L, 1);
     void * arg2 = (char *)LuaGetArgument_string(L, 2);
     int arg3 = LuaGetArgument_int(L, 3);
-	UpdateAudioStream(arg1, arg2, arg3);
-	return 0;
+    UpdateAudioStream(arg1, arg2, arg3);
+    return 0;
 }
 
 int lua_IsAudioBufferProcessed(lua_State* L)
 {
     AudioStream arg1 = LuaGetArgument_AudioStream(L, 1);
-	bool result = IsAudioBufferProcessed(arg1);
-	lua_pushboolean(L, result);
-	return 1;
+    bool result = IsAudioBufferProcessed(arg1);
+    lua_pushboolean(L, result);
+    return 1;
 }
 
 int lua_PlayAudioStream(lua_State* L)
 {
-	AudioStream arg1 = LuaGetArgument_AudioStream(L, 1);
-	PlayAudioStream(arg1);
-	return 0;
+    AudioStream arg1 = LuaGetArgument_AudioStream(L, 1);
+    PlayAudioStream(arg1);
+    return 0;
 }
 
 
 int lua_StopAudioStream(lua_State* L)
 {
     AudioStream arg1 = LuaGetArgument_AudioStream(L, 1);
-	StopAudioStream(arg1);
-	return 0;
+    StopAudioStream(arg1);
+    return 0;
 }
 
 int lua_PauseAudioStream(lua_State* L)
 {
     AudioStream arg1 = LuaGetArgument_AudioStream(L, 1);
-	PauseAudioStream(arg1);
-	return 0;
+    PauseAudioStream(arg1);
+    return 0;
 }
 
 int lua_ResumeAudioStream(lua_State* L)
 {
     AudioStream arg1 = LuaGetArgument_AudioStream(L, 1);
-	ResumeAudioStream(arg1);
-	return 0;
+    ResumeAudioStream(arg1);
+    return 0;
 }
 
 //----------------------------------------------------------------------------------
@@ -3021,70 +3024,70 @@ int lua_ResumeAudioStream(lua_State* L)
 //----------------------------------------------------------------------------------
 int lua_DecompressData(lua_State* L)
 {
-	unsigned char *arg1 = (unsigned char *)LuaGetArgument_string(L, 1);
-	unsigned arg2 = (unsigned)LuaGetArgument_int(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	unsigned char *result = DecompressData(arg1, arg2, arg3);
-	lua_pushlstring(L, (const char *)result, arg3);
-	return 1;
+    unsigned char *arg1 = (unsigned char *)LuaGetArgument_string(L, 1);
+    unsigned arg2 = (unsigned)LuaGetArgument_int(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    unsigned char *result = DecompressData(arg1, arg2, arg3);
+    lua_pushlstring(L, (const char *)result, arg3);
+    return 1;
 }
 
 #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI)
 int lua_WriteBitmap(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	unsigned char* arg2 = (unsigned char*)LuaGetArgument_string(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	WriteBitmap(arg1, arg2, arg3, arg4);
-	return 0;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    unsigned char* arg2 = (unsigned char*)LuaGetArgument_string(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    WriteBitmap(arg1, arg2, arg3, arg4);
+    return 0;
 }
 
 int lua_WritePNG(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	unsigned char* arg2 = (unsigned char*)LuaGetArgument_string(L, 2);
-	int arg3 = LuaGetArgument_int(L, 3);
-	int arg4 = LuaGetArgument_int(L, 4);
-	int arg5 = LuaGetArgument_int(L, 5);
-	WritePNG(arg1, arg2, arg3, arg4, arg5);
-	return 0;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    unsigned char* arg2 = (unsigned char*)LuaGetArgument_string(L, 2);
+    int arg3 = LuaGetArgument_int(L, 3);
+    int arg4 = LuaGetArgument_int(L, 4);
+    int arg5 = LuaGetArgument_int(L, 5);
+    WritePNG(arg1, arg2, arg3, arg4, arg5);
+    return 0;
 }
 #endif
 
 int lua_TraceLog(lua_State* L)
 {
-	int num_args = lua_gettop(L) - 1;
-	int arg1 = LuaGetArgument_int(L, 1);
+    int num_args = lua_gettop(L) - 1;
+    int arg1 = LuaGetArgument_int(L, 1);
 
-	/// type, fmt, args...
+    /// type, fmt, args...
 
-	lua_rotate(L, 1, -1); /// fmt, args..., type
-	lua_pop(L, 1); /// fmt, args...
+    lua_rotate(L, 1, -1); /// fmt, args..., type
+    lua_pop(L, 1); /// fmt, args...
 
-	lua_getglobal(L, "string"); /// fmt, args..., [string]
-	lua_getfield(L, 1, "format"); /// fmt, args..., [string], format()
-	lua_rotate(L, 1, 2); /// [string], format(), fmt, args...
-	lua_call(L, num_args, 1); /// [string], formatted_string
-	
-	TraceLog(arg1, "%s", luaL_checkstring(L,-1));
-	return 0;
+    lua_getglobal(L, "string"); /// fmt, args..., [string]
+    lua_getfield(L, 1, "format"); /// fmt, args..., [string], format()
+    lua_rotate(L, 1, 2); /// [string], format(), fmt, args...
+    lua_call(L, num_args, 1); /// [string], formatted_string
+    
+    TraceLog(arg1, "%s", luaL_checkstring(L,-1));
+    return 0;
 }
 
 int lua_GetExtension(lua_State* L)
 {
-	const char * arg1 = LuaGetArgument_string(L, 1);
-	const char* result = GetExtension(arg1);
-	lua_pushstring(L, result);
-	return 1;
+    const char * arg1 = LuaGetArgument_string(L, 1);
+    const char* result = GetExtension(arg1);
+    lua_pushstring(L, result);
+    return 1;
 }
 
 int lua_GetNextPOT(lua_State* L)
 {
-	int arg1 = LuaGetArgument_int(L, 1);
-	int result = GetNextPOT(arg1);
-	lua_pushinteger(L, result);
-	return 1;
+    int arg1 = LuaGetArgument_int(L, 1);
+    int result = GetNextPOT(arg1);
+    lua_pushinteger(L, result);
+    return 1;
 }
 
 //----------------------------------------------------------------------------------
@@ -3092,123 +3095,123 @@ int lua_GetNextPOT(lua_State* L)
 //----------------------------------------------------------------------------------
 int lua_VectorAdd(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	Vector3 result = VectorAdd(arg1, arg2);
-	LuaPush_Vector3(L, result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    Vector3 result = VectorAdd(arg1, arg2);
+    LuaPush_Vector3(L, result);
+    return 1;
 }
 
 int lua_VectorSubtract(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	Vector3 result = VectorSubtract(arg1, arg2);
-	LuaPush_Vector3(L, result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    Vector3 result = VectorSubtract(arg1, arg2);
+    LuaPush_Vector3(L, result);
+    return 1;
 }
 
 int lua_VectorCrossProduct(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	Vector3 result = VectorCrossProduct(arg1, arg2);
-	LuaPush_Vector3(L, result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    Vector3 result = VectorCrossProduct(arg1, arg2);
+    LuaPush_Vector3(L, result);
+    return 1;
 }
 
 int lua_VectorPerpendicular(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Vector3 result = VectorPerpendicular(arg1);
-	LuaPush_Vector3(L, result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector3 result = VectorPerpendicular(arg1);
+    LuaPush_Vector3(L, result);
+    return 1;
 }
 
 int lua_VectorDotProduct(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	float result = VectorDotProduct(arg1, arg2);
-	lua_pushnumber(L, result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    float result = VectorDotProduct(arg1, arg2);
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 int lua_VectorLength(lua_State* L)
 {
-	const Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float result = VectorLength(arg1);
-	lua_pushnumber(L, result);
-	return 1;
+    const Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float result = VectorLength(arg1);
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 int lua_VectorScale(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	VectorScale(&arg1, arg2);
-	LuaPush_Vector3(L, arg1);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    VectorScale(&arg1, arg2);
+    LuaPush_Vector3(L, arg1);
+    return 1;
 }
 
 int lua_VectorNegate(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	VectorNegate(&arg1);
-	LuaPush_Vector3(L, arg1);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    VectorNegate(&arg1);
+    LuaPush_Vector3(L, arg1);
+    return 1;
 }
 
 int lua_VectorNormalize(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	VectorNormalize(&arg1);
-	LuaPush_Vector3(L, arg1);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    VectorNormalize(&arg1);
+    LuaPush_Vector3(L, arg1);
+    return 1;
 }
 
 int lua_VectorDistance(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	float result = VectorDistance(arg1, arg2);
-	lua_pushnumber(L, result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    float result = VectorDistance(arg1, arg2);
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 int lua_VectorLerp(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	Vector3 result = VectorLerp(arg1, arg2, arg3);
-	LuaPush_Vector3(L, result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    Vector3 result = VectorLerp(arg1, arg2, arg3);
+    LuaPush_Vector3(L, result);
+    return 1;
 }
 
 int lua_VectorReflect(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	Vector3 result = VectorReflect(arg1, arg2);
-	LuaPush_Vector3(L, result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    Vector3 result = VectorReflect(arg1, arg2);
+    LuaPush_Vector3(L, result);
+    return 1;
 }
 
 int lua_VectorTransform(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Matrix arg2 = LuaGetArgument_Matrix(L, 2);
-	VectorTransform(&arg1, arg2);
-	LuaPush_Vector3(L, arg1);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Matrix arg2 = LuaGetArgument_Matrix(L, 2);
+    VectorTransform(&arg1, arg2);
+    LuaPush_Vector3(L, arg1);
+    return 1;
 }
 
 int lua_VectorZero(lua_State* L)
 {
-	Vector3 result = VectorZero();
-	LuaPush_Vector3(L, result);
-	return 1;
+    Vector3 result = VectorZero();
+    LuaPush_Vector3(L, result);
+    return 1;
 }
 
 //----------------------------------------------------------------------------------
@@ -3216,176 +3219,176 @@ int lua_VectorZero(lua_State* L)
 //----------------------------------------------------------------------------------
 int lua_MatrixDeterminant(lua_State* L)
 {
-	Matrix arg1 = LuaGetArgument_Matrix(L, 1);
-	float result = MatrixDeterminant(arg1);
-	lua_pushnumber(L, result);
-	return 1;
+    Matrix arg1 = LuaGetArgument_Matrix(L, 1);
+    float result = MatrixDeterminant(arg1);
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 int lua_MatrixTrace(lua_State* L)
 {
-	Matrix arg1 = LuaGetArgument_Matrix(L, 1);
-	float result = MatrixTrace(arg1);
-	lua_pushnumber(L, result);
-	return 1;
+    Matrix arg1 = LuaGetArgument_Matrix(L, 1);
+    float result = MatrixTrace(arg1);
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 int lua_MatrixTranspose(lua_State* L)
 {
-	Matrix arg1 = LuaGetArgument_Matrix(L, 1);
-	MatrixTranspose(&arg1);
-	LuaPush_Matrix(L, &arg1);
-	return 1;
+    Matrix arg1 = LuaGetArgument_Matrix(L, 1);
+    MatrixTranspose(&arg1);
+    LuaPush_Matrix(L, &arg1);
+    return 1;
 }
 
 int lua_MatrixInvert(lua_State* L)
 {
-	Matrix arg1 = LuaGetArgument_Matrix(L, 1);
-	MatrixInvert(&arg1);
-	LuaPush_Matrix(L, &arg1);
-	return 1;
+    Matrix arg1 = LuaGetArgument_Matrix(L, 1);
+    MatrixInvert(&arg1);
+    LuaPush_Matrix(L, &arg1);
+    return 1;
 }
 
 int lua_MatrixNormalize(lua_State* L)
 {
-	Matrix arg1 = LuaGetArgument_Matrix(L, 1);
-	MatrixNormalize(&arg1);
-	LuaPush_Matrix(L, &arg1);
-	return 1;
+    Matrix arg1 = LuaGetArgument_Matrix(L, 1);
+    MatrixNormalize(&arg1);
+    LuaPush_Matrix(L, &arg1);
+    return 1;
 }
 
 int lua_MatrixIdentity(lua_State* L)
 {
-	Matrix result = MatrixIdentity();
-	LuaPush_Matrix(L, &result);
-	return 1;
+    Matrix result = MatrixIdentity();
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixAdd(lua_State* L)
 {
-	Matrix arg1 = LuaGetArgument_Matrix(L, 1);
-	Matrix arg2 = LuaGetArgument_Matrix(L, 2);
-	Matrix result = MatrixAdd(arg1, arg2);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    Matrix arg1 = LuaGetArgument_Matrix(L, 1);
+    Matrix arg2 = LuaGetArgument_Matrix(L, 2);
+    Matrix result = MatrixAdd(arg1, arg2);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixSubstract(lua_State* L)
 {
-	Matrix arg1 = LuaGetArgument_Matrix(L, 1);
-	Matrix arg2 = LuaGetArgument_Matrix(L, 2);
-	Matrix result = MatrixSubstract(arg1, arg2);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    Matrix arg1 = LuaGetArgument_Matrix(L, 1);
+    Matrix arg2 = LuaGetArgument_Matrix(L, 2);
+    Matrix result = MatrixSubstract(arg1, arg2);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixTranslate(lua_State* L)
 {
-	float arg1 = LuaGetArgument_float(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	Matrix result = MatrixTranslate(arg1, arg2, arg3);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    float arg1 = LuaGetArgument_float(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    Matrix result = MatrixTranslate(arg1, arg2, arg3);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixRotate(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	Matrix result = MatrixRotate(arg1, arg2);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    Matrix result = MatrixRotate(arg1, arg2);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixRotateX(lua_State* L)
 {
-	float arg1 = LuaGetArgument_float(L, 1);
-	Matrix result = MatrixRotateX(arg1);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    float arg1 = LuaGetArgument_float(L, 1);
+    Matrix result = MatrixRotateX(arg1);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixRotateY(lua_State* L)
 {
-	float arg1 = LuaGetArgument_float(L, 1);
-	Matrix result = MatrixRotateY(arg1);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    float arg1 = LuaGetArgument_float(L, 1);
+    Matrix result = MatrixRotateY(arg1);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixRotateZ(lua_State* L)
 {
-	float arg1 = LuaGetArgument_float(L, 1);
-	Matrix result = MatrixRotateZ(arg1);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    float arg1 = LuaGetArgument_float(L, 1);
+    Matrix result = MatrixRotateZ(arg1);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixScale(lua_State* L)
 {
-	float arg1 = LuaGetArgument_float(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	Matrix result = MatrixScale(arg1, arg2, arg3);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    float arg1 = LuaGetArgument_float(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    Matrix result = MatrixScale(arg1, arg2, arg3);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixMultiply(lua_State* L)
 {
-	Matrix arg1 = LuaGetArgument_Matrix(L, 1);
-	Matrix arg2 = LuaGetArgument_Matrix(L, 2);
-	Matrix result = MatrixMultiply(arg1, arg2);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    Matrix arg1 = LuaGetArgument_Matrix(L, 1);
+    Matrix arg2 = LuaGetArgument_Matrix(L, 2);
+    Matrix result = MatrixMultiply(arg1, arg2);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixFrustum(lua_State* L)
 {
-	double arg1 = LuaGetArgument_double(L, 1);
-	double arg2 = LuaGetArgument_double(L, 2);
-	double arg3 = LuaGetArgument_double(L, 3);
-	double arg4 = LuaGetArgument_double(L, 4);
-	double arg5 = LuaGetArgument_double(L, 5);
-	double arg6 = LuaGetArgument_double(L, 6);
-	Matrix result = MatrixFrustum(arg1, arg2, arg3, arg4, arg5, arg6);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    double arg1 = LuaGetArgument_double(L, 1);
+    double arg2 = LuaGetArgument_double(L, 2);
+    double arg3 = LuaGetArgument_double(L, 3);
+    double arg4 = LuaGetArgument_double(L, 4);
+    double arg5 = LuaGetArgument_double(L, 5);
+    double arg6 = LuaGetArgument_double(L, 6);
+    Matrix result = MatrixFrustum(arg1, arg2, arg3, arg4, arg5, arg6);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixPerspective(lua_State* L)
 {
-	double arg1 = LuaGetArgument_double(L, 1);
-	double arg2 = LuaGetArgument_double(L, 2);
-	double arg3 = LuaGetArgument_double(L, 3);
-	double arg4 = LuaGetArgument_double(L, 4);
-	Matrix result = MatrixPerspective(arg1, arg2, arg3, arg4);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    double arg1 = LuaGetArgument_double(L, 1);
+    double arg2 = LuaGetArgument_double(L, 2);
+    double arg3 = LuaGetArgument_double(L, 3);
+    double arg4 = LuaGetArgument_double(L, 4);
+    Matrix result = MatrixPerspective(arg1, arg2, arg3, arg4);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixOrtho(lua_State* L)
 {
-	double arg1 = LuaGetArgument_double(L, 1);
-	double arg2 = LuaGetArgument_double(L, 2);
-	double arg3 = LuaGetArgument_double(L, 3);
-	double arg4 = LuaGetArgument_double(L, 4);
-	double arg5 = LuaGetArgument_double(L, 5);
-	double arg6 = LuaGetArgument_double(L, 6);
-	Matrix result = MatrixOrtho(arg1, arg2, arg3, arg4, arg5, arg6);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    double arg1 = LuaGetArgument_double(L, 1);
+    double arg2 = LuaGetArgument_double(L, 2);
+    double arg3 = LuaGetArgument_double(L, 3);
+    double arg4 = LuaGetArgument_double(L, 4);
+    double arg5 = LuaGetArgument_double(L, 5);
+    double arg6 = LuaGetArgument_double(L, 6);
+    Matrix result = MatrixOrtho(arg1, arg2, arg3, arg4, arg5, arg6);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_MatrixLookAt(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
-	Vector3 arg3 = LuaGetArgument_Vector3(L, 3);
-	Matrix result = MatrixLookAt(arg1, arg2, arg3);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+    Vector3 arg3 = LuaGetArgument_Vector3(L, 3);
+    Matrix result = MatrixLookAt(arg1, arg2, arg3);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 //----------------------------------------------------------------------------------
@@ -3393,82 +3396,82 @@ int lua_MatrixLookAt(lua_State* L)
 //----------------------------------------------------------------------------------
 int lua_QuaternionLength(lua_State* L)
 {
-	Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
-	float result = QuaternionLength(arg1);
-	lua_pushnumber(L, result);
-	return 1;
+    Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
+    float result = QuaternionLength(arg1);
+    lua_pushnumber(L, result);
+    return 1;
 }
 
 int lua_QuaternionNormalize(lua_State* L)
 {
-	Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
-	QuaternionNormalize(&arg1);
-	LuaPush_Quaternion(L, arg1);
-	return 1;
+    Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
+    QuaternionNormalize(&arg1);
+    LuaPush_Quaternion(L, arg1);
+    return 1;
 }
 
 int lua_QuaternionMultiply(lua_State* L)
 {
-	Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
-	Quaternion arg2 = LuaGetArgument_Quaternion(L, 2);
-	Quaternion result = QuaternionMultiply(arg1, arg2);
-	LuaPush_Quaternion(L, result);
-	return 1;
+    Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
+    Quaternion arg2 = LuaGetArgument_Quaternion(L, 2);
+    Quaternion result = QuaternionMultiply(arg1, arg2);
+    LuaPush_Quaternion(L, result);
+    return 1;
 }
 
 int lua_QuaternionSlerp(lua_State* L)
 {
-	Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
-	Quaternion arg2 = LuaGetArgument_Quaternion(L, 2);
-	float arg3 = LuaGetArgument_float(L, 3);
-	Quaternion result = QuaternionSlerp(arg1, arg2, arg3);
-	LuaPush_Quaternion(L, result);
-	return 1;
+    Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
+    Quaternion arg2 = LuaGetArgument_Quaternion(L, 2);
+    float arg3 = LuaGetArgument_float(L, 3);
+    Quaternion result = QuaternionSlerp(arg1, arg2, arg3);
+    LuaPush_Quaternion(L, result);
+    return 1;
 }
 
 int lua_QuaternionFromMatrix(lua_State* L)
 {
-	Matrix arg1 = LuaGetArgument_Matrix(L, 1);
-	Quaternion result = QuaternionFromMatrix(arg1);
-	LuaPush_Quaternion(L, result);
-	return 1;
+    Matrix arg1 = LuaGetArgument_Matrix(L, 1);
+    Quaternion result = QuaternionFromMatrix(arg1);
+    LuaPush_Quaternion(L, result);
+    return 1;
 }
 
 int lua_QuaternionToMatrix(lua_State* L)
 {
-	Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
-	Matrix result = QuaternionToMatrix(arg1);
-	LuaPush_Matrix(L, &result);
-	return 1;
+    Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
+    Matrix result = QuaternionToMatrix(arg1);
+    LuaPush_Matrix(L, &result);
+    return 1;
 }
 
 int lua_QuaternionFromAxisAngle(lua_State* L)
 {
-	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
-	float arg2 = LuaGetArgument_float(L, 2);
-	Quaternion result = QuaternionFromAxisAngle(arg1, arg2);
-	LuaPush_Quaternion(L, result);
-	return 1;
+    Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+    float arg2 = LuaGetArgument_float(L, 2);
+    Quaternion result = QuaternionFromAxisAngle(arg1, arg2);
+    LuaPush_Quaternion(L, result);
+    return 1;
 }
 
 int lua_QuaternionToAxisAngle(lua_State* L)
 {
-	Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
+    Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
     Vector3 arg2;
-	float arg3 = 0;
-	QuaternionToAxisAngle(arg1, &arg2, &arg3);
-	LuaPush_Vector3(L, arg2);
-	lua_pushnumber(L, arg3);
-	return 2;
+    float arg3 = 0;
+    QuaternionToAxisAngle(arg1, &arg2, &arg3);
+    LuaPush_Vector3(L, arg2);
+    lua_pushnumber(L, arg3);
+    return 2;
 }
 
 int lua_QuaternionTransform(lua_State* L)
 {
-	Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
-	Matrix arg2 = LuaGetArgument_Matrix(L, 2);
-	QuaternionTransform(&arg1, arg2);
-	LuaPush_Quaternion(L, arg1);
-	return 1;
+    Quaternion arg1 = LuaGetArgument_Quaternion(L, 1);
+    Matrix arg2 = LuaGetArgument_Matrix(L, 2);
+    QuaternionTransform(&arg1, arg2);
+    LuaPush_Quaternion(L, arg1);
+    return 1;
 }
 
 
@@ -3479,174 +3482,174 @@ int lua_QuaternionTransform(lua_State* L)
 
 // raylib Functions (and data types) list
 static luaL_Reg raylib_functions[] = {
-	
+    
     // Register non-opaque data types
     REG(Color)
-	REG(Vector2)
-	REG(Vector3)
+    REG(Vector2)
+    REG(Vector3)
     //REG(Matrix)
     REG(Quaternion)
-	REG(Rectangle)
-	REG(Ray)
-	REG(Camera)
-	REG(Camera2D)
+    REG(Rectangle)
+    REG(Ray)
+    REG(Camera)
+    REG(Camera2D)
     REG(BoundingBox)
     //REG(Material)
 
     // Register functions
-	REG(InitWindow)
-	REG(CloseWindow)
-	REG(WindowShouldClose)
-	REG(IsWindowMinimized)
-	REG(ToggleFullscreen)
-	REG(GetScreenWidth)
-	REG(GetScreenHeight)
+    REG(InitWindow)
+    REG(CloseWindow)
+    REG(WindowShouldClose)
+    REG(IsWindowMinimized)
+    REG(ToggleFullscreen)
+    REG(GetScreenWidth)
+    REG(GetScreenHeight)
     
-	REG(ShowCursor)
-	REG(HideCursor)
-	REG(IsCursorHidden)
-	REG(EnableCursor)
-	REG(DisableCursor)
-
-	REG(ClearBackground)
-	REG(BeginDrawing)
-	REG(EndDrawing)
+    REG(ShowCursor)
+    REG(HideCursor)
+    REG(IsCursorHidden)
+    REG(EnableCursor)
+    REG(DisableCursor)
+
+    REG(ClearBackground)
+    REG(BeginDrawing)
+    REG(EndDrawing)
     REG(Begin2dMode)
-	REG(End2dMode)
-	REG(Begin3dMode)
-	REG(End3dMode)
+    REG(End2dMode)
+    REG(Begin3dMode)
+    REG(End3dMode)
     REG(BeginTextureMode)
-	REG(EndTextureMode)
+    REG(EndTextureMode)
     
-	REG(GetMouseRay)
-	REG(GetWorldToScreen)
-	REG(GetCameraMatrix)
+    REG(GetMouseRay)
+    REG(GetWorldToScreen)
+    REG(GetCameraMatrix)
     
 #if defined(PLATFORM_WEB)
-	REG(SetDrawingLoop)
+    REG(SetDrawingLoop)
 #else
-	REG(SetTargetFPS)
+    REG(SetTargetFPS)
 #endif
-	REG(GetFPS)
-	REG(GetFrameTime)
+    REG(GetFPS)
+    REG(GetFrameTime)
     
-	REG(GetColor)
-	REG(GetHexValue)
-	REG(ColorToFloat)
-	REG(VectorToFloat)
-	REG(MatrixToFloat)
-	REG(GetRandomValue)
-	REG(Fade)
-	REG(SetConfigFlags)
-	REG(ShowLogo)
+    REG(GetColor)
+    REG(GetHexValue)
+    REG(ColorToFloat)
+    REG(VectorToFloat)
+    REG(MatrixToFloat)
+    REG(GetRandomValue)
+    REG(Fade)
+    REG(SetConfigFlags)
+    REG(ShowLogo)
     
-	REG(IsFileDropped)
-	//REG(*GetDroppedFiles)
-	REG(ClearDroppedFiles)
-	REG(StorageSaveValue)
-	REG(StorageLoadValue)
+    REG(IsFileDropped)
+    //REG(*GetDroppedFiles)
+    REG(ClearDroppedFiles)
+    REG(StorageSaveValue)
+    REG(StorageLoadValue)
     
 #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB)
-	REG(IsKeyPressed)
-	REG(IsKeyDown)
-	REG(IsKeyReleased)
-	REG(IsKeyUp)
-	REG(GetKeyPressed)
+    REG(IsKeyPressed)
+    REG(IsKeyDown)
+    REG(IsKeyReleased)
+    REG(IsKeyUp)
+    REG(GetKeyPressed)
     REG(SetExitKey)
     
-	REG(IsGamepadAvailable)
+    REG(IsGamepadAvailable)
     REG(GetGamepadAxisMovement)
-	REG(IsGamepadButtonPressed)
-	REG(IsGamepadButtonDown)
-	REG(IsGamepadButtonReleased)
-	REG(IsGamepadButtonUp)
+    REG(IsGamepadButtonPressed)
+    REG(IsGamepadButtonDown)
+    REG(IsGamepadButtonReleased)
+    REG(IsGamepadButtonUp)
 #endif
 
-	REG(IsMouseButtonPressed)
-	REG(IsMouseButtonDown)
-	REG(IsMouseButtonReleased)
-	REG(IsMouseButtonUp)
-	REG(GetMouseX)
-	REG(GetMouseY)
-	REG(GetMousePosition)
-	REG(SetMousePosition)
-	REG(GetMouseWheelMove)
-	REG(GetTouchX)
-	REG(GetTouchY)
-	REG(GetTouchPosition)
+    REG(IsMouseButtonPressed)
+    REG(IsMouseButtonDown)
+    REG(IsMouseButtonReleased)
+    REG(IsMouseButtonUp)
+    REG(GetMouseX)
+    REG(GetMouseY)
+    REG(GetMousePosition)
+    REG(SetMousePosition)
+    REG(GetMouseWheelMove)
+    REG(GetTouchX)
+    REG(GetTouchY)
+    REG(GetTouchPosition)
 
 #if defined(PLATFORM_ANDROID)
-	REG(IsButtonPressed)
-	REG(IsButtonDown)
-	REG(IsButtonReleased)
+    REG(IsButtonPressed)
+    REG(IsButtonDown)
+    REG(IsButtonReleased)
 #endif
 
-	REG(SetGesturesEnabled)
-	REG(IsGestureDetected)
-	REG(GetGestureDetected)
+    REG(SetGesturesEnabled)
+    REG(IsGestureDetected)
+    REG(GetGestureDetected)
     REG(GetTouchPointsCount)
-	REG(GetGestureHoldDuration)
-	REG(GetGestureDragVector)
-	REG(GetGestureDragAngle)
-	REG(GetGesturePinchVector)
-	REG(GetGesturePinchAngle)
-
-	REG(SetCameraMode)
-	REG(UpdateCamera)
-	REG(UpdateCameraPlayer)
-	REG(SetCameraPosition)
-	REG(SetCameraTarget)
+    REG(GetGestureHoldDuration)
+    REG(GetGestureDragVector)
+    REG(GetGestureDragAngle)
+    REG(GetGesturePinchVector)
+    REG(GetGesturePinchAngle)
+
+    REG(SetCameraMode)
+    REG(UpdateCamera)
+    REG(UpdateCameraPlayer)
+    REG(SetCameraPosition)
+    REG(SetCameraTarget)
     REG(SetCameraFovy)
     
-	REG(SetCameraPanControl)
-	REG(SetCameraAltControl)
-	REG(SetCameraSmoothZoomControl)
-	REG(SetCameraMoveControls)
-	REG(SetCameraMouseSensitivity)
+    REG(SetCameraPanControl)
+    REG(SetCameraAltControl)
+    REG(SetCameraSmoothZoomControl)
+    REG(SetCameraMoveControls)
+    REG(SetCameraMouseSensitivity)
     
-	REG(DrawPixel)
-	REG(DrawPixelV)
-	REG(DrawLine)
-	REG(DrawLineV)
-	REG(DrawCircle)
-	REG(DrawCircleGradient)
-	REG(DrawCircleV)
-	REG(DrawCircleLines)
-	REG(DrawRectangle)
-	REG(DrawRectangleRec)
-	REG(DrawRectangleGradient)
-	REG(DrawRectangleV)
-	REG(DrawRectangleLines)
-	REG(DrawTriangle)
-	REG(DrawTriangleLines)
-	REG(DrawPoly)
-	REG(DrawPolyEx)
-	REG(DrawPolyExLines)
+    REG(DrawPixel)
+    REG(DrawPixelV)
+    REG(DrawLine)
+    REG(DrawLineV)
+    REG(DrawCircle)
+    REG(DrawCircleGradient)
+    REG(DrawCircleV)
+    REG(DrawCircleLines)
+    REG(DrawRectangle)
+    REG(DrawRectangleRec)
+    REG(DrawRectangleGradient)
+    REG(DrawRectangleV)
+    REG(DrawRectangleLines)
+    REG(DrawTriangle)
+    REG(DrawTriangleLines)
+    REG(DrawPoly)
+    REG(DrawPolyEx)
+    REG(DrawPolyExLines)
     
-	REG(CheckCollisionRecs)
-	REG(CheckCollisionCircles)
-	REG(CheckCollisionCircleRec)
-	REG(GetCollisionRec)
-	REG(CheckCollisionPointRec)
-	REG(CheckCollisionPointCircle)
-	REG(CheckCollisionPointTriangle)
+    REG(CheckCollisionRecs)
+    REG(CheckCollisionCircles)
+    REG(CheckCollisionCircleRec)
+    REG(GetCollisionRec)
+    REG(CheckCollisionPointRec)
+    REG(CheckCollisionPointCircle)
+    REG(CheckCollisionPointTriangle)
     
-	REG(LoadImage)
-	REG(LoadImageEx)
-	REG(LoadImageRaw)
-	REG(LoadImageFromRES)
-	REG(LoadTexture)
-	REG(LoadTextureEx)
-	REG(LoadTextureFromRES)
-	REG(LoadTextureFromImage)
+    REG(LoadImage)
+    REG(LoadImageEx)
+    REG(LoadImageRaw)
+    REG(LoadImageFromRES)
+    REG(LoadTexture)
+    REG(LoadTextureEx)
+    REG(LoadTextureFromRES)
+    REG(LoadTextureFromImage)
     REG(LoadRenderTexture)
-	REG(UnloadImage)
-	REG(UnloadTexture)
-	REG(UnloadRenderTexture)
-	REG(GetImageData)
-	REG(GetTextureData)
-	REG(ImageToPOT)
-	REG(ImageFormat)
+    REG(UnloadImage)
+    REG(UnloadTexture)
+    REG(UnloadRenderTexture)
+    REG(GetImageData)
+    REG(GetTextureData)
+    REG(ImageToPOT)
+    REG(ImageFormat)
     REG(ImageDither)
     REG(ImageCopy)
     REG(ImageCrop)
@@ -3664,192 +3667,188 @@ static luaL_Reg raylib_functions[] = {
     REG(ImageColorGrayscale)
     REG(ImageColorContrast)
     REG(ImageColorBrightness)
-	REG(GenTextureMipmaps)
+    REG(GenTextureMipmaps)
     REG(UpdateTexture)
     
-	REG(DrawTexture)
-	REG(DrawTextureV)
-	REG(DrawTextureEx)
-	REG(DrawTextureRec)
-	REG(DrawTexturePro)
+    REG(DrawTexture)
+    REG(DrawTextureV)
+    REG(DrawTextureEx)
+    REG(DrawTextureRec)
+    REG(DrawTexturePro)
     
-	REG(GetDefaultFont)
-	REG(LoadSpriteFont)
-	REG(UnloadSpriteFont)
-	REG(DrawText)
-	REG(DrawTextEx)
-	REG(MeasureText)
-	REG(MeasureTextEx)
-	REG(DrawFPS)
-    //REG(FormatText)
-    //REG(SubText)
+    REG(GetDefaultFont)
+    REG(LoadSpriteFont)
+    REG(UnloadSpriteFont)
+    REG(DrawText)
+    REG(DrawTextEx)
+    REG(MeasureText)
+    REG(MeasureTextEx)
+    REG(DrawFPS)
     
-	REG(DrawCube)
-	REG(DrawCubeV)
-	REG(DrawCubeWires)
-	REG(DrawCubeTexture)
-	REG(DrawSphere)
-	REG(DrawSphereEx)
-	REG(DrawSphereWires)
-	REG(DrawCylinder)
-	REG(DrawCylinderWires)
-	REG(DrawPlane)
-	REG(DrawRay)
-	REG(DrawGrid)
-	REG(DrawGizmo)
+    REG(DrawCube)
+    REG(DrawCubeV)
+    REG(DrawCubeWires)
+    REG(DrawCubeTexture)
+    REG(DrawSphere)
+    REG(DrawSphereEx)
+    REG(DrawSphereWires)
+    REG(DrawCylinder)
+    REG(DrawCylinderWires)
+    REG(DrawPlane)
+    REG(DrawRay)
+    REG(DrawGrid)
+    REG(DrawGizmo)
     
-	REG(LoadModel)
-	REG(LoadModelEx)
+    REG(LoadModel)
+    REG(LoadModelEx)
     REG(LoadModelFromRES)
-	REG(LoadHeightmap)
-	REG(LoadCubicmap)
-	REG(UnloadModel)
-		REG(LoadMaterial)
-		REG(LoadDefaultMaterial)
-		REG(LoadStandardMaterial)
-		REG(UnloadMaterial)
+    REG(LoadHeightmap)
+    REG(LoadCubicmap)
+    REG(UnloadModel)
+        REG(LoadMaterial)
+        REG(LoadDefaultMaterial)
+        REG(LoadStandardMaterial)
+        REG(UnloadMaterial)
     //REG(GenMesh*)     // Not ready yet...
     
-	REG(DrawModel)
-	REG(DrawModelEx)
-	REG(DrawModelWires)
-	REG(DrawModelWiresEx)
-	REG(DrawBillboard)
-	REG(DrawBillboardRec)
+    REG(DrawModel)
+    REG(DrawModelEx)
+    REG(DrawModelWires)
+    REG(DrawModelWiresEx)
+    REG(DrawBillboard)
+    REG(DrawBillboardRec)
     REG(CalculateBoundingBox)
-	REG(CheckCollisionSpheres)
-	REG(CheckCollisionBoxes)
-	REG(CheckCollisionBoxSphere)
+    REG(CheckCollisionSpheres)
+    REG(CheckCollisionBoxes)
+    REG(CheckCollisionBoxSphere)
     REG(CheckCollisionRaySphere)
     REG(CheckCollisionRaySphereEx)
     REG(CheckCollisionRayBox)
-	REG(ResolveCollisionCubicmap)
+    REG(ResolveCollisionCubicmap)
     
-	REG(LoadShader)
-	REG(UnloadShader)
+    REG(LoadShader)
+    REG(UnloadShader)
     REG(GetDefaultShader)
     REG(GetStandardShader)
     REG(GetDefaultTexture)
-	REG(GetShaderLocation)
-	REG(SetShaderValue)
-	REG(SetShaderValuei)
-	REG(SetShaderValueMatrix)
-	REG(SetMatrixProjection)
-	REG(SetMatrixModelview)
-	REG(BeginShaderMode)
-	REG(EndShaderMode)
-	REG(BeginBlendMode)
-	REG(EndBlendMode)
-    //REG(CreateLight)
-    //REG(DestroyLight)
+    REG(GetShaderLocation)
+    REG(SetShaderValue)
+    REG(SetShaderValuei)
+    REG(SetShaderValueMatrix)
+    REG(SetMatrixProjection)
+    REG(SetMatrixModelview)
+    REG(BeginShaderMode)
+    REG(EndShaderMode)
+    REG(BeginBlendMode)
+    REG(EndBlendMode)
+    REG(CreateLight)
+    REG(DestroyLight)
     
-	REG(InitVrDevice)
-	REG(CloseVrDevice)
-	REG(UpdateVrTracking)
-	REG(BeginVrDrawing)
-	REG(EndVrDrawing)
-	REG(IsVrDeviceReady)
-	REG(ToggleVrMode)
+    REG(InitVrDevice)
+    REG(CloseVrDevice)
+    REG(IsVrDeviceReady)
+    REG(UpdateVrTracking)
+    REG(ToggleVrMode)
     
-	REG(InitAudioDevice)
-	REG(CloseAudioDevice)
+    REG(InitAudioDevice)
+    REG(CloseAudioDevice)
     REG(IsAudioDeviceReady)
-	REG(LoadSound)
-	REG(LoadSoundFromWave)
-	REG(LoadSoundFromRES)
-	REG(UnloadSound)
-	REG(PlaySound)
-	REG(PauseSound)
-	REG(ResumeSound)
-	REG(StopSound)
-	REG(IsSoundPlaying)
-	REG(SetSoundVolume)
-	REG(SetSoundPitch)
+    REG(LoadSound)
+    REG(LoadSoundFromWave)
+    REG(LoadSoundFromRES)
+    REG(UnloadSound)
+    REG(PlaySound)
+    REG(PauseSound)
+    REG(ResumeSound)
+    REG(StopSound)
+    REG(IsSoundPlaying)
+    REG(SetSoundVolume)
+    REG(SetSoundPitch)
     
-	REG(LoadMusicStream)
-	REG(UnloadMusicStream)
-	REG(UpdateMusicStream)
+    REG(LoadMusicStream)
+    REG(UnloadMusicStream)
+    REG(UpdateMusicStream)
     REG(PlayMusicStream)
-	REG(StopMusicStream)
-	REG(PauseMusicStream)
-	REG(ResumeMusicStream)
-	REG(IsMusicPlaying)
-	REG(SetMusicVolume)
-	REG(SetMusicPitch)
-	REG(GetMusicTimeLength)
-	REG(GetMusicTimePlayed)
+    REG(StopMusicStream)
+    REG(PauseMusicStream)
+    REG(ResumeMusicStream)
+    REG(IsMusicPlaying)
+    REG(SetMusicVolume)
+    REG(SetMusicPitch)
+    REG(GetMusicTimeLength)
+    REG(GetMusicTimePlayed)
     
-	REG(InitAudioStream)
-	REG(UpdateAudioStream)
-	REG(CloseAudioStream)
-	REG(IsAudioBufferProcessed)
-	REG(PlayAudioStream)
-	REG(PauseAudioStream)
-	REG(ResumeAudioStream)
-	REG(StopAudioStream)
-
-	/// Math and util
-	REG(DecompressData)
+    REG(InitAudioStream)
+    REG(UpdateAudioStream)
+    REG(CloseAudioStream)
+    REG(IsAudioBufferProcessed)
+    REG(PlayAudioStream)
+    REG(PauseAudioStream)
+    REG(ResumeAudioStream)
+    REG(StopAudioStream)
+
+    /// Math and util
+    REG(DecompressData)
 #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI)
-	REG(WriteBitmap)
-	REG(WritePNG)
+    REG(WriteBitmap)
+    REG(WritePNG)
 #endif
-	REG(TraceLog)
-	REG(GetExtension)
-	REG(GetNextPOT)
-	REG(VectorAdd)
-	REG(VectorSubtract)
-	REG(VectorCrossProduct)
-	REG(VectorPerpendicular)
-	REG(VectorDotProduct)
-	REG(VectorLength)
-	REG(VectorScale)
-	REG(VectorNegate)
-	REG(VectorNormalize)
-	REG(VectorDistance)
-	REG(VectorLerp)
-	REG(VectorReflect)
-	REG(VectorTransform)
-	REG(VectorZero)
-	REG(MatrixDeterminant)
-	REG(MatrixTrace)
-	REG(MatrixTranspose)
-	REG(MatrixInvert)
-	REG(MatrixNormalize)
-	REG(MatrixIdentity)
-	REG(MatrixAdd)
-	REG(MatrixSubstract)
-	REG(MatrixTranslate)
-	REG(MatrixRotate)
-	REG(MatrixRotateX)
-	REG(MatrixRotateY)
-	REG(MatrixRotateZ)
-	REG(MatrixScale)
-	REG(MatrixMultiply)
-	REG(MatrixFrustum)
-	REG(MatrixPerspective)
-	REG(MatrixOrtho)
-	REG(MatrixLookAt)
-	REG(QuaternionLength)
-	REG(QuaternionNormalize)
-	REG(QuaternionMultiply)
-	REG(QuaternionSlerp)
-	REG(QuaternionFromMatrix)
-	REG(QuaternionToMatrix)
-	REG(QuaternionFromAxisAngle)
-	REG(QuaternionToAxisAngle)
-	REG(QuaternionTransform)
-
-	{0,0}
+    REG(TraceLog)
+    REG(GetExtension)
+    REG(GetNextPOT)
+    REG(VectorAdd)
+    REG(VectorSubtract)
+    REG(VectorCrossProduct)
+    REG(VectorPerpendicular)
+    REG(VectorDotProduct)
+    REG(VectorLength)
+    REG(VectorScale)
+    REG(VectorNegate)
+    REG(VectorNormalize)
+    REG(VectorDistance)
+    REG(VectorLerp)
+    REG(VectorReflect)
+    REG(VectorTransform)
+    REG(VectorZero)
+    REG(MatrixDeterminant)
+    REG(MatrixTrace)
+    REG(MatrixTranspose)
+    REG(MatrixInvert)
+    REG(MatrixNormalize)
+    REG(MatrixIdentity)
+    REG(MatrixAdd)
+    REG(MatrixSubstract)
+    REG(MatrixTranslate)
+    REG(MatrixRotate)
+    REG(MatrixRotateX)
+    REG(MatrixRotateY)
+    REG(MatrixRotateZ)
+    REG(MatrixScale)
+    REG(MatrixMultiply)
+    REG(MatrixFrustum)
+    REG(MatrixPerspective)
+    REG(MatrixOrtho)
+    REG(MatrixLookAt)
+    REG(QuaternionLength)
+    REG(QuaternionNormalize)
+    REG(QuaternionMultiply)
+    REG(QuaternionSlerp)
+    REG(QuaternionFromMatrix)
+    REG(QuaternionToMatrix)
+    REG(QuaternionFromAxisAngle)
+    REG(QuaternionToAxisAngle)
+    REG(QuaternionTransform)
+
+    {0,0}
 };
 
 // Register raylib functionality
 static void LuaRegisterRayLib(const char *opt_table)
 {
-	if (opt_table) lua_createtable(L, 0, sizeof(raylib_functions)/sizeof(raylib_functions[0]));
-	else lua_pushglobaltable(L);
+    if (opt_table) lua_createtable(L, 0, sizeof(raylib_functions)/sizeof(raylib_functions[0]));
+    else lua_pushglobaltable(L);
 
-	luaL_setfuncs(L, raylib_functions, 0);
+    luaL_setfuncs(L, raylib_functions, 0);
 }
 
 //----------------------------------------------------------------------------------
@@ -3859,210 +3858,216 @@ static void LuaRegisterRayLib(const char *opt_table)
 // Initialize Lua system
 RLUADEF void InitLuaDevice(void)
 {
-	mainLuaState = luaL_newstate();
-	L = mainLuaState;
+    mainLuaState = luaL_newstate();
+    L = mainLuaState;
     
-	LuaStartEnum();
-	LuaSetEnum("FULLSCREEN_MODE", 1);
-	LuaSetEnum("SHOW_LOGO", 2);
-	LuaSetEnum("SHOW_MOUSE_CURSOR", 4);
-	LuaSetEnum("CENTERED_MODE", 8);
-	LuaSetEnum("MSAA_4X_HINT", 16);
-	LuaSetEnum("VSYNC_HINT", 32);
-	LuaEndEnum("FLAG");
-
-	LuaStartEnum();
-	LuaSetEnum("SPACE", 32);
-	LuaSetEnum("ESCAPE", 256);
-	LuaSetEnum("ENTER", 257);
-	LuaSetEnum("BACKSPACE", 259);
-	LuaSetEnum("RIGHT", 262);
-	LuaSetEnum("LEFT", 263);
-	LuaSetEnum("DOWN", 264);
-	LuaSetEnum("UP", 265);
-	LuaSetEnum("F1", 290);
-	LuaSetEnum("F2", 291);
-	LuaSetEnum("F3", 292);
-	LuaSetEnum("F4", 293);
-	LuaSetEnum("F5", 294);
-	LuaSetEnum("F6", 295);
-	LuaSetEnum("F7", 296);
-	LuaSetEnum("F8", 297);
-	LuaSetEnum("F9", 298);
-	LuaSetEnum("F10", 299);
-	LuaSetEnum("LEFT_SHIFT", 340);
-	LuaSetEnum("LEFT_CONTROL", 341);
-	LuaSetEnum("LEFT_ALT", 342);
-	LuaSetEnum("RIGHT_SHIFT", 344);
-	LuaSetEnum("RIGHT_CONTROL", 345);
-	LuaSetEnum("RIGHT_ALT", 346);
-	LuaSetEnum("ZERO", 48);
-	LuaSetEnum("ONE", 49);
-	LuaSetEnum("TWO", 50);
-	LuaSetEnum("THREE", 51);
-	LuaSetEnum("FOUR", 52);
-	LuaSetEnum("FIVE", 53);
-	LuaSetEnum("SIX", 54);
-	LuaSetEnum("SEVEN", 55);
-	LuaSetEnum("EIGHT", 56);
-	LuaSetEnum("NINE", 57);
-	LuaSetEnum("A", 65);
-	LuaSetEnum("B", 66);
-	LuaSetEnum("C", 67);
-	LuaSetEnum("D", 68);
-	LuaSetEnum("E", 69);
-	LuaSetEnum("F", 70);
-	LuaSetEnum("G", 71);
-	LuaSetEnum("H", 72);
-	LuaSetEnum("I", 73);
-	LuaSetEnum("J", 74);
-	LuaSetEnum("K", 75);
-	LuaSetEnum("L", 76);
-	LuaSetEnum("M", 77);
-	LuaSetEnum("N", 78);
-	LuaSetEnum("O", 79);
-	LuaSetEnum("P", 80);
-	LuaSetEnum("Q", 81);
-	LuaSetEnum("R", 82);
-	LuaSetEnum("S", 83);
-	LuaSetEnum("T", 84);
-	LuaSetEnum("U", 85);
-	LuaSetEnum("V", 86);
-	LuaSetEnum("W", 87);
-	LuaSetEnum("X", 88);
-	LuaSetEnum("Y", 89);
-	LuaSetEnum("Z", 90);
-	LuaEndEnum("KEY");
-
-	LuaStartEnum();
-	LuaSetEnum("LEFT_BUTTON", 0);
-	LuaSetEnum("RIGHT_BUTTON", 1);
-	LuaSetEnum("MIDDLE_BUTTON", 2);
-	LuaEndEnum("MOUSE");
-
-	LuaStartEnum();
-	LuaSetEnum("PLAYER1", 0);
-	LuaSetEnum("PLAYER2", 1);
-	LuaSetEnum("PLAYER3", 2);
-	LuaSetEnum("PLAYER4", 3);
-
-	LuaSetEnum("BUTTON_A", 2);
-	LuaSetEnum("BUTTON_B", 1);
-	LuaSetEnum("BUTTON_X", 3);
-	LuaSetEnum("BUTTON_Y", 4);
-	LuaSetEnum("BUTTON_R1", 7);
-	LuaSetEnum("BUTTON_R2", 5);
-	LuaSetEnum("BUTTON_L1", 6);
-	LuaSetEnum("BUTTON_L2", 8);
-	LuaSetEnum("BUTTON_SELECT", 9);
-	LuaSetEnum("BUTTON_START", 10);
+    LuaStartEnum();
+    LuaSetEnum("FULLSCREEN_MODE", 1);
+    LuaSetEnum("SHOW_LOGO", 2);
+    LuaSetEnum("SHOW_MOUSE_CURSOR", 4);
+    LuaSetEnum("CENTERED_MODE", 8);
+    LuaSetEnum("MSAA_4X_HINT", 16);
+    LuaSetEnum("VSYNC_HINT", 32);
+    LuaEndEnum("FLAG");
+
+    LuaStartEnum();
+    LuaSetEnum("SPACE", 32);
+    LuaSetEnum("ESCAPE", 256);
+    LuaSetEnum("ENTER", 257);
+    LuaSetEnum("BACKSPACE", 259);
+    LuaSetEnum("RIGHT", 262);
+    LuaSetEnum("LEFT", 263);
+    LuaSetEnum("DOWN", 264);
+    LuaSetEnum("UP", 265);
+    LuaSetEnum("F1", 290);
+    LuaSetEnum("F2", 291);
+    LuaSetEnum("F3", 292);
+    LuaSetEnum("F4", 293);
+    LuaSetEnum("F5", 294);
+    LuaSetEnum("F6", 295);
+    LuaSetEnum("F7", 296);
+    LuaSetEnum("F8", 297);
+    LuaSetEnum("F9", 298);
+    LuaSetEnum("F10", 299);
+    LuaSetEnum("LEFT_SHIFT", 340);
+    LuaSetEnum("LEFT_CONTROL", 341);
+    LuaSetEnum("LEFT_ALT", 342);
+    LuaSetEnum("RIGHT_SHIFT", 344);
+    LuaSetEnum("RIGHT_CONTROL", 345);
+    LuaSetEnum("RIGHT_ALT", 346);
+    LuaSetEnum("ZERO", 48);
+    LuaSetEnum("ONE", 49);
+    LuaSetEnum("TWO", 50);
+    LuaSetEnum("THREE", 51);
+    LuaSetEnum("FOUR", 52);
+    LuaSetEnum("FIVE", 53);
+    LuaSetEnum("SIX", 54);
+    LuaSetEnum("SEVEN", 55);
+    LuaSetEnum("EIGHT", 56);
+    LuaSetEnum("NINE", 57);
+    LuaSetEnum("A", 65);
+    LuaSetEnum("B", 66);
+    LuaSetEnum("C", 67);
+    LuaSetEnum("D", 68);
+    LuaSetEnum("E", 69);
+    LuaSetEnum("F", 70);
+    LuaSetEnum("G", 71);
+    LuaSetEnum("H", 72);
+    LuaSetEnum("I", 73);
+    LuaSetEnum("J", 74);
+    LuaSetEnum("K", 75);
+    LuaSetEnum("L", 76);
+    LuaSetEnum("M", 77);
+    LuaSetEnum("N", 78);
+    LuaSetEnum("O", 79);
+    LuaSetEnum("P", 80);
+    LuaSetEnum("Q", 81);
+    LuaSetEnum("R", 82);
+    LuaSetEnum("S", 83);
+    LuaSetEnum("T", 84);
+    LuaSetEnum("U", 85);
+    LuaSetEnum("V", 86);
+    LuaSetEnum("W", 87);
+    LuaSetEnum("X", 88);
+    LuaSetEnum("Y", 89);
+    LuaSetEnum("Z", 90);
+    LuaEndEnum("KEY");
+
+    LuaStartEnum();
+    LuaSetEnum("LEFT_BUTTON", 0);
+    LuaSetEnum("RIGHT_BUTTON", 1);
+    LuaSetEnum("MIDDLE_BUTTON", 2);
+    LuaEndEnum("MOUSE");
+
+    LuaStartEnum();
+    LuaSetEnum("PLAYER1", 0);
+    LuaSetEnum("PLAYER2", 1);
+    LuaSetEnum("PLAYER3", 2);
+    LuaSetEnum("PLAYER4", 3);
+
+    LuaSetEnum("BUTTON_A", 2);
+    LuaSetEnum("BUTTON_B", 1);
+    LuaSetEnum("BUTTON_X", 3);
+    LuaSetEnum("BUTTON_Y", 4);
+    LuaSetEnum("BUTTON_R1", 7);
+    LuaSetEnum("BUTTON_R2", 5);
+    LuaSetEnum("BUTTON_L1", 6);
+    LuaSetEnum("BUTTON_L2", 8);
+    LuaSetEnum("BUTTON_SELECT", 9);
+    LuaSetEnum("BUTTON_START", 10);
     
-	LuaSetEnum("XBOX_BUTTON_A", 0);
-	LuaSetEnum("XBOX_BUTTON_B", 1);
-	LuaSetEnum("XBOX_BUTTON_X", 2);
-	LuaSetEnum("XBOX_BUTTON_Y", 3);
-	LuaSetEnum("XBOX_BUTTON_LB", 4);
-	LuaSetEnum("XBOX_BUTTON_RB", 5);
-	LuaSetEnum("XBOX_BUTTON_SELECT", 6);
-	LuaSetEnum("XBOX_BUTTON_START", 7);
+    LuaSetEnum("XBOX_BUTTON_A", 0);
+    LuaSetEnum("XBOX_BUTTON_B", 1);
+    LuaSetEnum("XBOX_BUTTON_X", 2);
+    LuaSetEnum("XBOX_BUTTON_Y", 3);
+    LuaSetEnum("XBOX_BUTTON_LB", 4);
+    LuaSetEnum("XBOX_BUTTON_RB", 5);
+    LuaSetEnum("XBOX_BUTTON_SELECT", 6);
+    LuaSetEnum("XBOX_BUTTON_START", 7);
 
 #if defined(PLATFORM_RPI)
-	LuaSetEnum("XBOX_AXIS_DPAD_X", 7);
-	LuaSetEnum("XBOX_AXIS_DPAD_Y", 6);
- 	LuaSetEnum("XBOX_AXIS_RIGHT_X", 3);
-	LuaSetEnum("XBOX_AXIS_RIGHT_Y", 4);
-	LuaSetEnum("XBOX_AXIS_LT", 2);
-	LuaSetEnum("XBOX_AXIS_RT", 5);
+    LuaSetEnum("XBOX_AXIS_DPAD_X", 7);
+    LuaSetEnum("XBOX_AXIS_DPAD_Y", 6);
+     LuaSetEnum("XBOX_AXIS_RIGHT_X", 3);
+    LuaSetEnum("XBOX_AXIS_RIGHT_Y", 4);
+    LuaSetEnum("XBOX_AXIS_LT", 2);
+    LuaSetEnum("XBOX_AXIS_RT", 5);
 #else
-	LuaSetEnum("XBOX_BUTTON_UP", 10);
-	LuaSetEnum("XBOX_BUTTON_DOWN", 12);
-	LuaSetEnum("XBOX_BUTTON_LEFT", 13);
-	LuaSetEnum("XBOX_BUTTON_RIGHT", 11);
-	LuaSetEnum("XBOX_AXIS_RIGHT_X", 4);
-	LuaSetEnum("XBOX_AXIS_RIGHT_Y", 3);
-	LuaSetEnum("XBOX_AXIS_LT_RT", 2);
+    LuaSetEnum("XBOX_BUTTON_UP", 10);
+    LuaSetEnum("XBOX_BUTTON_DOWN", 12);
+    LuaSetEnum("XBOX_BUTTON_LEFT", 13);
+    LuaSetEnum("XBOX_BUTTON_RIGHT", 11);
+    LuaSetEnum("XBOX_AXIS_RIGHT_X", 4);
+    LuaSetEnum("XBOX_AXIS_RIGHT_Y", 3);
+    LuaSetEnum("XBOX_AXIS_LT_RT", 2);
 #endif
-	LuaSetEnum("XBOX_AXIS_LEFT_X", 0);
-	LuaSetEnum("XBOX_AXIS_LEFT_Y", 1);
-	LuaEndEnum("GAMEPAD");
-
-	lua_pushglobaltable(L);
-	LuaSetEnumColor("LIGHTGRAY", LIGHTGRAY);
-	LuaSetEnumColor("GRAY", GRAY);
-	LuaSetEnumColor("DARKGRAY", DARKGRAY);
-	LuaSetEnumColor("YELLOW", YELLOW);
-	LuaSetEnumColor("GOLD", GOLD);
-	LuaSetEnumColor("ORANGE", ORANGE);
-	LuaSetEnumColor("PINK", PINK);
-	LuaSetEnumColor("RED", RED);
-	LuaSetEnumColor("MAROON", MAROON);
-	LuaSetEnumColor("GREEN", GREEN);
-	LuaSetEnumColor("LIME", LIME);
-	LuaSetEnumColor("DARKGREEN", DARKGREEN);
-	LuaSetEnumColor("SKYBLUE", SKYBLUE);
-	LuaSetEnumColor("BLUE", BLUE);
-	LuaSetEnumColor("DARKBLUE", DARKBLUE);
-	LuaSetEnumColor("PURPLE", PURPLE);
-	LuaSetEnumColor("VIOLET", VIOLET);
-	LuaSetEnumColor("DARKPURPLE", DARKPURPLE);
-	LuaSetEnumColor("BEIGE", BEIGE);
-	LuaSetEnumColor("BROWN", BROWN);
-	LuaSetEnumColor("DARKBROWN", DARKBROWN);
-	LuaSetEnumColor("WHITE", WHITE);
-	LuaSetEnumColor("BLACK", BLACK);
-	LuaSetEnumColor("BLANK", BLANK);
-	LuaSetEnumColor("MAGENTA", MAGENTA);
-	LuaSetEnumColor("RAYWHITE", RAYWHITE);
-	lua_pop(L, 1);
-
-	LuaStartEnum();
-	LuaSetEnum("UNCOMPRESSED_GRAYSCALE", UNCOMPRESSED_GRAYSCALE);
-	LuaSetEnum("UNCOMPRESSED_GRAY_ALPHA", UNCOMPRESSED_GRAY_ALPHA);
-	LuaSetEnum("UNCOMPRESSED_R5G6B5", UNCOMPRESSED_R5G6B5);
-	LuaSetEnum("UNCOMPRESSED_R8G8B8", UNCOMPRESSED_R8G8B8);
-	LuaSetEnum("UNCOMPRESSED_R5G5B5A1", UNCOMPRESSED_R5G5B5A1);
-	LuaSetEnum("UNCOMPRESSED_R4G4B4A4", UNCOMPRESSED_R4G4B4A4);
-	LuaSetEnum("UNCOMPRESSED_R8G8B8A8", UNCOMPRESSED_R8G8B8A8);
-	LuaSetEnum("COMPRESSED_DXT1_RGB", COMPRESSED_DXT1_RGB);
-	LuaSetEnum("COMPRESSED_DXT1_RGBA", COMPRESSED_DXT1_RGBA);
-	LuaSetEnum("COMPRESSED_DXT3_RGBA", COMPRESSED_DXT3_RGBA);
-	LuaSetEnum("COMPRESSED_DXT5_RGBA", COMPRESSED_DXT5_RGBA);
-	LuaSetEnum("COMPRESSED_ETC1_RGB", COMPRESSED_ETC1_RGB);
-	LuaSetEnum("COMPRESSED_ETC2_RGB", COMPRESSED_ETC2_RGB);
-	LuaSetEnum("COMPRESSED_ETC2_EAC_RGBA", COMPRESSED_ETC2_EAC_RGBA);
-	LuaSetEnum("COMPRESSED_PVRT_RGB", COMPRESSED_PVRT_RGB);
-	LuaSetEnum("COMPRESSED_PVRT_RGBA", COMPRESSED_PVRT_RGBA);
-	LuaSetEnum("COMPRESSED_ASTC_4x4_RGBA", COMPRESSED_ASTC_4x4_RGBA);
-	LuaSetEnum("COMPRESSED_ASTC_8x8_RGBA", COMPRESSED_ASTC_8x8_RGBA);
-	LuaEndEnum("TextureFormat");
-
-	LuaStartEnum();
-	LuaSetEnum("ALPHA", BLEND_ALPHA);
-	LuaSetEnum("ADDITIVE", BLEND_ADDITIVE);
-	LuaSetEnum("MULTIPLIED", BLEND_MULTIPLIED);
-	LuaEndEnum("BlendMode");
-
-	LuaStartEnum();
-	LuaSetEnum("NONE", GESTURE_NONE);
-	LuaSetEnum("TAP", GESTURE_TAP);
-	LuaSetEnum("DOUBLETAP", GESTURE_DOUBLETAP);
-	LuaSetEnum("HOLD", GESTURE_HOLD);
-	LuaSetEnum("DRAG", GESTURE_DRAG);
-	LuaSetEnum("SWIPE_RIGHT", GESTURE_SWIPE_RIGHT);
-	LuaSetEnum("SWIPE_LEFT", GESTURE_SWIPE_LEFT);
-	LuaSetEnum("SWIPE_UP", GESTURE_SWIPE_UP);
-	LuaSetEnum("SWIPE_DOWN", GESTURE_SWIPE_DOWN);
-	LuaSetEnum("PINCH_IN", GESTURE_PINCH_IN);
-	LuaSetEnum("PINCH_OUT", GESTURE_PINCH_OUT);
-	LuaEndEnum("Gestures");
-
-	LuaStartEnum();
-	LuaSetEnum("CUSTOM", CAMERA_CUSTOM);
-	LuaSetEnum("FREE", CAMERA_FREE);
-	LuaSetEnum("ORBITAL", CAMERA_ORBITAL);
-	LuaSetEnum("FIRST_PERSON", CAMERA_FIRST_PERSON);
-	LuaSetEnum("THIRD_PERSON", CAMERA_THIRD_PERSON);
-	LuaEndEnum("CameraMode");
+    LuaSetEnum("XBOX_AXIS_LEFT_X", 0);
+    LuaSetEnum("XBOX_AXIS_LEFT_Y", 1);
+    LuaEndEnum("GAMEPAD");
+
+    lua_pushglobaltable(L);
+    LuaSetEnumColor("LIGHTGRAY", LIGHTGRAY);
+    LuaSetEnumColor("GRAY", GRAY);
+    LuaSetEnumColor("DARKGRAY", DARKGRAY);
+    LuaSetEnumColor("YELLOW", YELLOW);
+    LuaSetEnumColor("GOLD", GOLD);
+    LuaSetEnumColor("ORANGE", ORANGE);
+    LuaSetEnumColor("PINK", PINK);
+    LuaSetEnumColor("RED", RED);
+    LuaSetEnumColor("MAROON", MAROON);
+    LuaSetEnumColor("GREEN", GREEN);
+    LuaSetEnumColor("LIME", LIME);
+    LuaSetEnumColor("DARKGREEN", DARKGREEN);
+    LuaSetEnumColor("SKYBLUE", SKYBLUE);
+    LuaSetEnumColor("BLUE", BLUE);
+    LuaSetEnumColor("DARKBLUE", DARKBLUE);
+    LuaSetEnumColor("PURPLE", PURPLE);
+    LuaSetEnumColor("VIOLET", VIOLET);
+    LuaSetEnumColor("DARKPURPLE", DARKPURPLE);
+    LuaSetEnumColor("BEIGE", BEIGE);
+    LuaSetEnumColor("BROWN", BROWN);
+    LuaSetEnumColor("DARKBROWN", DARKBROWN);
+    LuaSetEnumColor("WHITE", WHITE);
+    LuaSetEnumColor("BLACK", BLACK);
+    LuaSetEnumColor("BLANK", BLANK);
+    LuaSetEnumColor("MAGENTA", MAGENTA);
+    LuaSetEnumColor("RAYWHITE", RAYWHITE);
+    lua_pop(L, 1);
+
+    LuaStartEnum();
+    LuaSetEnum("UNCOMPRESSED_GRAYSCALE", UNCOMPRESSED_GRAYSCALE);
+    LuaSetEnum("UNCOMPRESSED_GRAY_ALPHA", UNCOMPRESSED_GRAY_ALPHA);
+    LuaSetEnum("UNCOMPRESSED_R5G6B5", UNCOMPRESSED_R5G6B5);
+    LuaSetEnum("UNCOMPRESSED_R8G8B8", UNCOMPRESSED_R8G8B8);
+    LuaSetEnum("UNCOMPRESSED_R5G5B5A1", UNCOMPRESSED_R5G5B5A1);
+    LuaSetEnum("UNCOMPRESSED_R4G4B4A4", UNCOMPRESSED_R4G4B4A4);
+    LuaSetEnum("UNCOMPRESSED_R8G8B8A8", UNCOMPRESSED_R8G8B8A8);
+    LuaSetEnum("COMPRESSED_DXT1_RGB", COMPRESSED_DXT1_RGB);
+    LuaSetEnum("COMPRESSED_DXT1_RGBA", COMPRESSED_DXT1_RGBA);
+    LuaSetEnum("COMPRESSED_DXT3_RGBA", COMPRESSED_DXT3_RGBA);
+    LuaSetEnum("COMPRESSED_DXT5_RGBA", COMPRESSED_DXT5_RGBA);
+    LuaSetEnum("COMPRESSED_ETC1_RGB", COMPRESSED_ETC1_RGB);
+    LuaSetEnum("COMPRESSED_ETC2_RGB", COMPRESSED_ETC2_RGB);
+    LuaSetEnum("COMPRESSED_ETC2_EAC_RGBA", COMPRESSED_ETC2_EAC_RGBA);
+    LuaSetEnum("COMPRESSED_PVRT_RGB", COMPRESSED_PVRT_RGB);
+    LuaSetEnum("COMPRESSED_PVRT_RGBA", COMPRESSED_PVRT_RGBA);
+    LuaSetEnum("COMPRESSED_ASTC_4x4_RGBA", COMPRESSED_ASTC_4x4_RGBA);
+    LuaSetEnum("COMPRESSED_ASTC_8x8_RGBA", COMPRESSED_ASTC_8x8_RGBA);
+    LuaEndEnum("TextureFormat");
+
+    LuaStartEnum();
+    LuaSetEnum("ALPHA", BLEND_ALPHA);
+    LuaSetEnum("ADDITIVE", BLEND_ADDITIVE);
+    LuaSetEnum("MULTIPLIED", BLEND_MULTIPLIED);
+    LuaEndEnum("BlendMode");
+    
+    LuaStartEnum();
+    LuaSetEnum("POINT", LIGHT_POINT); 
+    LuaSetEnum("DIRECTIONAL", LIGHT_DIRECTIONAL);
+    LuaSetEnum("SPOT", LIGHT_SPOT);
+    LuaEndEnum("LightType");
+
+    LuaStartEnum();
+    LuaSetEnum("NONE", GESTURE_NONE);
+    LuaSetEnum("TAP", GESTURE_TAP);
+    LuaSetEnum("DOUBLETAP", GESTURE_DOUBLETAP);
+    LuaSetEnum("HOLD", GESTURE_HOLD);
+    LuaSetEnum("DRAG", GESTURE_DRAG);
+    LuaSetEnum("SWIPE_RIGHT", GESTURE_SWIPE_RIGHT);
+    LuaSetEnum("SWIPE_LEFT", GESTURE_SWIPE_LEFT);
+    LuaSetEnum("SWIPE_UP", GESTURE_SWIPE_UP);
+    LuaSetEnum("SWIPE_DOWN", GESTURE_SWIPE_DOWN);
+    LuaSetEnum("PINCH_IN", GESTURE_PINCH_IN);
+    LuaSetEnum("PINCH_OUT", GESTURE_PINCH_OUT);
+    LuaEndEnum("Gestures");
+
+    LuaStartEnum();
+    LuaSetEnum("CUSTOM", CAMERA_CUSTOM);
+    LuaSetEnum("FREE", CAMERA_FREE);
+    LuaSetEnum("ORBITAL", CAMERA_ORBITAL);
+    LuaSetEnum("FIRST_PERSON", CAMERA_FIRST_PERSON);
+    LuaSetEnum("THIRD_PERSON", CAMERA_THIRD_PERSON);
+    LuaEndEnum("CameraMode");
     
     LuaStartEnum();
     LuaSetEnum("DEFAULT_DEVICE", HMD_DEFAULT_DEVICE);
@@ -4074,82 +4079,82 @@ RLUADEF void InitLuaDevice(void)
     LuaSetEnum("SONY_PLAYSTATION_VR", HMD_SONY_PLAYSTATION_VR);
     LuaSetEnum("RAZER_OSVR", HMD_RAZER_OSVR);
     LuaSetEnum("FOVE_VR", HMD_FOVE_VR);
-	LuaEndEnum("VrDevice");
+    LuaEndEnum("VrDevice");
 
-	lua_pushglobaltable(L);
-	LuaSetEnum("INFO", INFO);
-	LuaSetEnum("ERROR", ERROR);
-	LuaSetEnum("WARNING", WARNING);
-	LuaSetEnum("DEBUG", DEBUG);
-	LuaSetEnum("OTHER", OTHER);
-	lua_pop(L, 1);
+    lua_pushglobaltable(L);
+    LuaSetEnum("INFO", INFO);
+    LuaSetEnum("ERROR", ERROR);
+    LuaSetEnum("WARNING", WARNING);
+    LuaSetEnum("DEBUG", DEBUG);
+    LuaSetEnum("OTHER", OTHER);
+    lua_pop(L, 1);
 
-	lua_pushboolean(L, true);
+    lua_pushboolean(L, true);
 #if defined(PLATFORM_DESKTOP)
-	lua_setglobal(L, "PLATFORM_DESKTOP");
+    lua_setglobal(L, "PLATFORM_DESKTOP");
 #elif defined(PLATFORM_ANDROID) 
-	lua_setglobal(L, "PLATFORM_ANDROID");
+    lua_setglobal(L, "PLATFORM_ANDROID");
 #elif defined(PLATFORM_RPI) 
-	lua_setglobal(L, "PLATFORM_RPI");
+    lua_setglobal(L, "PLATFORM_RPI");
 #elif defined(PLATFORM_WEB)
-	lua_setglobal(L, "PLATFORM_WEB");
+    lua_setglobal(L, "PLATFORM_WEB");
 #endif
 
-	luaL_openlibs(L);
-	LuaBuildOpaqueMetatables();
+    luaL_openlibs(L);
+    LuaBuildOpaqueMetatables();
     
-	LuaRegisterRayLib(0);
+    LuaRegisterRayLib(0);
 }
 
 // De-initialize Lua system
 RLUADEF void CloseLuaDevice(void)
 {
-	if (mainLuaState)
-	{
-		lua_close(mainLuaState);
-		mainLuaState = 0;
-		L = 0;
-	}
+    if (mainLuaState)
+    {
+        lua_close(mainLuaState);
+        mainLuaState = 0;
+        L = 0;
+    }
 }
 
 // Execute raylib Lua code
 RLUADEF void ExecuteLuaCode(const char *code)
 {
-	if (!mainLuaState)
-	{
-		TraceLog(WARNING, "Lua device not initialized");
-		return;
-	}
+    if (!mainLuaState)
+    {
+        TraceLog(WARNING, "Lua device not initialized");
+        return;
+    }
 
-	int result = luaL_dostring(L, code);
+    int result = luaL_dostring(L, code);
     
-	switch (result)
-	{
+    switch (result)
+    {
         case LUA_OK: break;
         case LUA_ERRRUN: TraceLog(ERROR, "Lua Runtime Error: %s", lua_tostring(L, -1)); break;
         case LUA_ERRMEM: TraceLog(ERROR, "Lua Memory Error: %s", lua_tostring(L, -1)); break;
         default: TraceLog(ERROR, "Lua Error: %s", lua_tostring(L, -1)); break;
-	}
+    }
 }
 
 // Execute raylib Lua script
 RLUADEF void ExecuteLuaFile(const char *filename)
 {
-	if (!mainLuaState)
-	{
-		TraceLog(WARNING, "Lua device not initialized");
-		return;
-	}
+    if (!mainLuaState)
+    {
+        TraceLog(WARNING, "Lua device not initialized");
+        return;
+    }
 
-	int result = luaL_dofile(L, filename);
+    int result = luaL_dofile(L, filename);
     
-	switch (result)
-	{
+    switch (result)
+    {
         case LUA_OK: break;
         case LUA_ERRRUN: TraceLog(ERROR, "Lua Runtime Error: %s", lua_tostring(L, -1));
         case LUA_ERRMEM: TraceLog(ERROR, "Lua Memory Error: %s", lua_tostring(L, -1));
         default: TraceLog(ERROR, "Lua Error: %s", lua_tostring(L, -1));
-	}
+    }
 }
 
 #endif // RLUA_IMPLEMENTATION