[rlua] new module: raylib Lua binding

1 files changed, 3631 insertions, 0 deletions

diff --git a/src/rlua.h b/src/rlua.h
new file mode 100644
index 00000000..6a909c43
--- /dev/null
+++ b/src/rlua.h
@@ -0,0 +1,3631 @@
+/**********************************************************************************************
+*
+*   rlua - raylib Lua bindings
+*
+*   NOTE 01:
+*   The following types:
+*       Color, Vector2, Vector3, Rectangle, Ray, Camera
+*   are treated as objects with named fields, same as in C.
+*   
+*   Lua defines utility functions for creating those objects.
+*   Usage:
+*       local cl = Color(255,255,255,255)
+*       local rec = Rectangle(10, 10, 100, 100)
+*       local ray = Ray(Vector3(20, 20, 20), Vector3(50, 50, 50))
+*       local x2 = rec.x + rec.width
+*
+*   The following types:
+*       Image, Texture2D, SpriteFont
+*   are immutable, and you can only read their non-pointer arguments (e.g. sprfnt.size).
+*
+*   All other object types are opaque, that is, you cannot access or
+*   change their fields directly.
+*
+*   Remember that ALL raylib types have REFERENCE SEMANTICS in Lua.
+*   There is currently no way to create a copy of an opaque object.
+*
+*   NOTE 02:
+*   Some raylib functions take a pointer to an array, and the size of that array.
+*   The equivalent Lua functions take only an array table of the specified type UNLESS
+*   it's a pointer to a large char array (e.g. for images), then it takes (and potentially returns) 
+*   a Lua string (without the size argument, as Lua strings are sized by default).
+*
+*   NOTE 03:
+*   Some raylib functions take pointers to objects to modify (e.g. ImageToPOT, etc.)
+*   In Lua, these functions take values and return a new changed value, instead.
+*   So, in C:
+*       ImageToPOT(&img, BLACK);
+*   In Lua becomes:
+*       img = ImageToPOT(img, BLACK)
+*
+*   Remember that functions can return multiple values, so:
+*       UpdateCameraPlayer(&cam, &playerPos);
+*       Vector3 vec = ResolveCollisionCubicmap(img, mapPos, &playerPos, 5.0);
+*   becomes:
+*       cam, playerPos = UpdateCameraPlayer(cam, playerPos)
+*       vec, playerPos = ResolveCollisionCubicmap(img, mapPos, playerPos, 5)
+*
+*   This is to preserve value semantics of raylib objects.
+*
+*
+*   This Lua binding for raylib was originally created by Ghassan Al-Mashareqa (ghassan@ghassan.pl)
+*   for raylib 1.3 and later on reviewed and updated to raylib 1.6 by Ramon Santamaria.
+*
+*   Copyright (c) 2015-2016 Ghassan Al-Mashareqa and Ramon Santamaria (@raysan5)
+*
+*   This software is provided "as-is", without any express or implied warranty. In no event
+*   will the authors be held liable for any damages arising from the use of this software.
+*
+*   Permission is granted to anyone to use this software for any purpose, including commercial
+*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
+*
+*     1. The origin of this software must not be misrepresented; you must not claim that you
+*     wrote the original software. If you use this software in a product, an acknowledgment
+*     in the product documentation would be appreciated but is not required.
+*
+*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
+*     as being the original software.
+*
+*     3. This notice may not be removed or altered from any source distribution.
+*
+**********************************************************************************************/
+
+#pragma once
+
+#include "raylib.h"
+
+#define RLUA_STATIC
+#ifdef RLUA_STATIC
+    #define RLUADEF static            // Functions just visible to module including this file
+#else
+    #ifdef __cplusplus
+        #define RLUADEF extern "C"    // Functions visible from other files (no name mangling of functions in C++)
+    #else
+        #define RLUADEF extern        // Functions visible from other files
+    #endif
+#endif
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+// ...
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+RLUADEF void InitLuaDevice(void);                   // Initialize Lua system
+RLUADEF void ExecuteLuaCode(const char *code);      // Execute raylib Lua code
+RLUADEF void ExecuteLuaFile(const char *filename);  // Execute raylib Lua script
+RLUADEF void CloseLuaDevice(void);                  // De-initialize Lua system
+
+/***********************************************************************************
+*
+*   RLUA IMPLEMENTATION
+*
+************************************************************************************/
+
+#if defined(RLUA_IMPLEMENTATION)
+
+#include "raylib.h"
+#include "utils.h"
+#include "raymath.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+
+//----------------------------------------------------------------------------------
+// Defines and Macros
+//----------------------------------------------------------------------------------
+#define LuaPush_Image(L, img) LuaPushOpaqueTypeWithMetatable(L, img, Image)
+#define LuaPush_Texture2D(L, tex) LuaPushOpaqueTypeWithMetatable(L, tex, Texture2D)
+#define LuaPush_RenderTexture2D(L, tex) LuaPushOpaqueTypeWithMetatable(L, tex, RenderTexture2D)
+#define LuaPush_SpriteFont(L, sf) LuaPushOpaqueTypeWithMetatable(L, sf, SpriteFont)
+#define LuaPush_Mesh(L, vd) LuaPushOpaqueType(L, vd)
+#define LuaPush_Shader(L, s) LuaPushOpaqueType(L, s)
+#define LuaPush_Sound(L, snd) LuaPushOpaqueType(L, snd)
+#define LuaPush_Wave(L, wav) LuaPushOpaqueType(L, wav)
+#define LuaPush_Music(L, mus) LuaPushOpaqueType(L, mus)
+
+#define LuaGetArgument_string luaL_checkstring
+#define LuaGetArgument_int (int)luaL_checkinteger
+#define LuaGetArgument_unsigned (unsigned)luaL_checkinteger
+#define LuaGetArgument_char (char)luaL_checkinteger
+#define LuaGetArgument_float (float)luaL_checknumber
+#define LuaGetArgument_double luaL_checknumber
+#define LuaGetArgument_Image(L, img) *(Image*)LuaGetArgumentOpaqueTypeWithMetatable(L, img, "Image")
+#define LuaGetArgument_Texture2D(L, tex) *(Texture2D*)LuaGetArgumentOpaqueTypeWithMetatable(L, tex, "Texture2D")
+#define LuaGetArgument_RenderTexture2D(L, rtex) *(RenderTexture2D*)LuaGetArgumentOpaqueTypeWithMetatable(L, rtex, "RenderTexture2D")
+#define LuaGetArgument_SpriteFont(L, sf) *(SpriteFont*)LuaGetArgumentOpaqueTypeWithMetatable(L, sf, "SpriteFont")
+#define LuaGetArgument_Mesh(L, vd) *(Mesh*)LuaGetArgumentOpaqueType(L, vd)
+#define LuaGetArgument_Shader(L, s) *(Shader*)LuaGetArgumentOpaqueType(L, s)
+#define LuaGetArgument_Sound(L, snd) *(Sound*)LuaGetArgumentOpaqueType(L, snd)
+#define LuaGetArgument_Wave(L, wav) *(Wave*)LuaGetArgumentOpaqueType(L, wav)
+#define LuaGetArgument_Music(L, mus) *(Music*)LuaGetArgumentOpaqueType(L, mus)
+
+#define LuaPushOpaqueType(L, str) LuaPushOpaque(L, &str, sizeof(str))
+#define LuaPushOpaqueTypeWithMetatable(L, str, meta) LuaPushOpaqueWithMetatable(L, &str, sizeof(str), #meta)
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+static lua_State* mainLuaState = 0;
+static lua_State* L = 0;
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Declaration
+//----------------------------------------------------------------------------------
+static void LuaPush_Color(lua_State* L, Color color);
+static void LuaPush_Vector2(lua_State* L, Vector2 vec);
+static void LuaPush_Vector3(lua_State* L, Vector3 vec);
+static void LuaPush_Quaternion(lua_State* L, Quaternion vec);
+static void LuaPush_Matrix(lua_State* L, Matrix *matrix);
+static void LuaPush_Rectangle(lua_State* L, Rectangle rect);
+static void LuaPush_Model(lua_State* L, Model mdl);
+static void LuaPush_Ray(lua_State* L, Ray ray);
+static void LuaPush_Camera(lua_State* L, Camera cam);
+
+static Vector2 LuaGetArgument_Vector2(lua_State* L, int index);
+static Vector3 LuaGetArgument_Vector3(lua_State* L, int index);
+static Quaternion LuaGetArgument_Quaternion(lua_State* L, int index);
+static Color LuaGetArgument_Color(lua_State* L, int index);
+static Rectangle LuaGetArgument_Rectangle(lua_State* L, int index);
+static Camera LuaGetArgument_Camera(lua_State* L, int index);
+static Ray LuaGetArgument_Ray(lua_State* L, int index);
+static Matrix LuaGetArgument_Matrix(lua_State* L, int index);
+static Model LuaGetArgument_Model(lua_State* L, int index);
+
+//----------------------------------------------------------------------------------
+// rlua Helper Functions
+//----------------------------------------------------------------------------------
+static void LuaStartEnum(void)
+{
+	lua_newtable(L);
+}
+
+static void LuaSetEnum(const char *name, int value)
+{
+	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);
+}
+
+static void LuaEndEnum(const char *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);
+}
+
+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);
+}
+
+static void* LuaGetArgumentOpaqueType(lua_State* L, int 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);
+}
+
+//----------------------------------------------------------------------------------
+// LuaIndex* functions
+//----------------------------------------------------------------------------------
+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;
+}
+
+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;
+}
+
+// TODO: RenderTexture2D?
+
+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;
+}
+
+static void LuaBuildOpaqueMetatables(void)
+{
+	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);
+    
+    // TODO?
+    /*
+    luaL_newmetatable(L, "RenderTexture2D");
+	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);
+}
+
+//----------------------------------------------------------------------------------
+// LuaGetArgument functions
+//----------------------------------------------------------------------------------
+
+static Vector2 LuaGetArgument_Vector2(lua_State* L, int index)
+{
+	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)
+{
+	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)
+{
+	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)
+{
+	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)
+{
+	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;
+	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_TTABLE, index, "Expected Camera");
+	result.fovy = LuaGetArgument_float(L, -1);
+	lua_pop(L, 4);
+	return result;
+}
+
+static Camera2D LuaGetArgument_Camera2D(lua_State* L, int index)
+{
+	Camera2D result;
+	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_TTABLE, index, "Expected Camera2D");
+	result.rotation = LuaGetArgument_float(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "zoom") == LUA_TTABLE, index, "Expected Camera2D");
+	result.zoom = LuaGetArgument_float(L, -1);
+	lua_pop(L, 4);
+	return result;
+}
+
+// TODO:
+//BoundingBox
+//LightData, *Light
+//MusicData *Music;
+//AudioStream
+
+// TODO: Review Mesh, Shader
+
+static BoundingBox LuaGetArgument_BoundingBox(lua_State* L, int index)
+{
+	BoundingBox result;
+	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;
+	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;
+	for (int i = 0; i < 16; i++)
+	{
+		lua_geti(L, -1, i+1);
+		ptr[i] = luaL_checkinteger(L, -1);
+	}
+	lua_pop(L, 16);
+	return result;
+}
+
+static Material LuaGetArgument_Material(lua_State* L, int index)
+{
+    Material result;
+    luaL_argcheck(L, lua_getfield(L, index, "shader") == LUA_TUSERDATA, index, "Expected Material");
+	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);
+    luaL_argcheck(L, lua_getfield(L, index, "texNormal") == LUA_TUSERDATA, index, "Expected Material");
+	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);
+    luaL_argcheck(L, lua_getfield(L, index, "colDiffuse") == LUA_TUSERDATA, index, "Expected Material");
+	result.colDiffuse = LuaGetArgument_Color(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "colAmbient") == LUA_TUSERDATA, index, "Expected Material");
+	result.colAmbient = LuaGetArgument_Color(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "colSpecular") == LUA_TUSERDATA, index, "Expected Material");
+	result.colSpecular = LuaGetArgument_Color(L, -1);
+    luaL_argcheck(L, lua_getfield(L, index, "glossiness") == LUA_TUSERDATA, index, "Expected Material");
+	result.glossiness = LuaGetArgument_float(L, -1);
+    lua_pop(L, 8);
+    return result;
+}
+
+static Model LuaGetArgument_Model(lua_State* L, int index)
+{
+	Model result;
+	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;
+}
+
+//----------------------------------------------------------------------------------
+// LuaPush functions
+//----------------------------------------------------------------------------------
+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");
+}
+
+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");
+}
+
+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");
+}
+
+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");
+}
+
+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);
+	}
+}
+
+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");
+}
+
+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");
+}
+
+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");
+}
+
+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_pushnumber(L, cam.fovy);
+	lua_setfield(L, -2, "fovy");
+}
+
+static void LuaPush_Camera2D(lua_State* L, Camera2D cam)
+{
+	lua_createtable(L, 0, 3);
+	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");
+}
+
+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");
+    LuaPush_Texture2D(L, mat.texSpecular);
+	lua_setfield(L, -2, "texSpecular");
+    LuaPush_Color(L, mat.colDiffuse);
+	lua_setfield(L, -2, "colDiffuse");
+    LuaPush_Color(L, mat.colAmbient);
+	lua_setfield(L, -2, "colAmbient");
+    LuaPush_Color(L, mat.colSpecular);
+	lua_setfield(L, -2, "colSpecular");
+    lua_pushnumber(L, mat.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");
+}
+
+//----------------------------------------------------------------------------------
+// raylib Lua Structure constructors
+//----------------------------------------------------------------------------------
+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;
+}
+
+static int lua_Vector2(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+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;
+}
+
+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);
+    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 }, fovy });
+	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);
+    float zoom = LuaGetArgument_float(L, 4);
+	LuaPush_Camera2D(L, (Camera2D) { { off.x, off.y }, { tar.x, tar.y }, rot, zoom });
+	return 1;
+}
+
+
+/*************************************************************************************
+*  raylib Lua Functions Bindings
+**************************************************************************************/
+
+//------------------------------------------------------------------------------------
+// raylib [core] module functions - Window and Graphics Device
+//------------------------------------------------------------------------------------
+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 lua_CloseWindow(lua_State* L)
+{
+	CloseWindow();
+	return 0;
+}
+
+int lua_WindowShouldClose(lua_State* L)
+{
+	bool result = WindowShouldClose();
+	lua_pushboolean(L, result);
+	return 1;
+}
+
+int lua_IsWindowMinimized(lua_State* L)
+{
+	bool result = IsWindowMinimized();
+	lua_pushboolean(L, result);
+	return 1;
+}
+
+int lua_ToggleFullscreen(lua_State* L)
+{
+	ToggleFullscreen();
+	return 0;
+}
+
+int lua_GetScreenWidth(lua_State* L)
+{
+	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 lua_ShowCursor(lua_State* L)
+{
+	ShowCursor();
+	return 0;
+}
+
+int lua_HideCursor(lua_State* L)
+{
+	HideCursor();
+	return 0;
+}
+
+int lua_IsCursorHidden(lua_State* L)
+{
+	bool result = IsCursorHidden();
+	lua_pushboolean(L, result);
+	return 1;
+}
+
+// TODO:
+/*
+void EnableCursor(void);                                    // Enables cursor
+void DisableCursor(void);                                   // Disables cursor
+*/
+
+int lua_ClearBackground(lua_State* L)
+{
+	Color arg1 = LuaGetArgument_Color(L, 1);
+	ClearBackground(arg1);
+	return 0;
+}
+
+int lua_BeginDrawing(lua_State* L)
+{
+	BeginDrawing();
+	return 0;
+}
+
+int lua_EndDrawing(lua_State* L)
+{
+	EndDrawing();
+	return 0;
+}
+
+// TODO:
+//void Begin2dMode(Camera2D camera);                          // Initialize 2D mode with custom camera
+//void End2dMode(void);                                       // Ends 2D mode custom camera usage
+
+int lua_Begin3dMode(lua_State* L)
+{
+	Camera arg1 = LuaGetArgument_Camera(L, 1);
+	Begin3dMode(arg1);
+	return 0;
+}
+
+int lua_End3dMode(lua_State* L)
+{
+	End3dMode();
+	return 0;
+}
+
+// TODO:
+//void BeginTextureMode(RenderTexture2D target);              // Initializes render texture for drawing
+//void EndTextureMode(void);                                  // Ends drawing to render texture
+
+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;
+}
+
+// TODO: 
+//Vector2 GetWorldToScreen(Vector3 position, Camera camera);  // Returns the screen space position from a 3d world space position
+//Matrix GetCameraMatrix(Camera camera);                      // Returns camera transform matrix (view matrix)
+
+#if defined(PLATFORM_WEB)
+
+static int LuaDrawLoopFunc;
+
+static void LuaDrawLoop()
+{
+	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;
+}
+
+#else
+
+int lua_SetTargetFPS(lua_State* L)
+{
+	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;
+}
+
+int lua_GetFrameTime(lua_State* L)
+{
+	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 lua_GetHexValue(lua_State* L)
+{
+	Color arg1 = LuaGetArgument_Color(L, 1);
+	int result = GetHexValue(arg1);
+	lua_pushinteger(L, result);
+	return 1;
+}
+
+// TODO:
+/*
+float *ColorToFloat(Color color);                           // Converts Color to float array and normalizes
+float *VectorToFloat(Vector3 vec);                          // Converts Vector3 to float array
+float *MatrixToFloat(Matrix mat);                           // Converts Matrix to float array
+*/
+
+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 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;
+}
+
+int lua_SetConfigFlags(lua_State* L)
+{
+	char arg1 = LuaGetArgument_char(L, 1);
+	SetConfigFlags(arg1);
+	return 0;
+}
+
+int lua_ShowLogo(lua_State* L)
+{
+	ShowLogo();
+	return 0;
+}
+
+int lua_IsFileDropped(lua_State* L)
+{
+	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 lua_ClearDroppedFiles(lua_State* L)
+{
+	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 lua_StorageLoadValue(lua_State* L)
+{
+    int arg1 = LuaGetArgument_int(L, 1);
+	int result = StorageLoadValue(arg1);
+	lua_pushinteger(L, result);
+	return 1;
+}
+
+//------------------------------------------------------------------------------------
+// raylib [core] module functions - Input Handling
+//------------------------------------------------------------------------------------
+#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 lua_IsKeyDown(lua_State* L)
+{
+	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 lua_IsKeyUp(lua_State* L)
+{
+	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 lua_SetExitKey(lua_State* L)
+{
+	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;
+}
+
+// TODO: Review
+// float GetGamepadAxisMovement(int gamepad, int axis);    // Return axis movement value for a gamepad axis
+/*
+int lua_GetGamepadMovement(lua_State* L)
+{
+	int arg1 = LuaGetArgument_int(L, 1);
+	Vector2 result = GetGamepadMovement(arg1);
+	LuaPush_Vector2(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 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 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 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;
+}
+#endif
+
+int lua_IsMouseButtonPressed(lua_State* L)
+{
+	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 lua_IsMouseButtonReleased(lua_State* L)
+{
+	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 lua_GetMouseX(lua_State* L)
+{
+	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 lua_GetMousePosition(lua_State* L)
+{
+	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;
+}
+
+int lua_GetMouseWheelMove(lua_State* L)
+{
+	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 lua_GetTouchY(lua_State* L)
+{
+	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;
+}
+
+// TODO:
+/*
+#if defined(PLATFORM_ANDROID)
+bool IsButtonPressed(int button);                       // Detect if an android physic button has been pressed
+bool IsButtonDown(int button);                          // Detect if an android physic button is being pressed
+bool IsButtonReleased(int button);                      // Detect if an android physic button has been released
+#endif
+*/
+
+//------------------------------------------------------------------------------------
+// raylib [gestures] module functions - Gestures and Touch Handling
+//------------------------------------------------------------------------------------
+int lua_SetGesturesEnabled(lua_State* L)
+{
+	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;
+}
+
+// TODO:
+///void ProcessGestureEvent(GestureEvent event);           // Process gesture event and translate it into gestures
+
+int lua_UpdateGestures(lua_State* L)
+{
+	UpdateGestures();
+	return 0;
+}
+
+int lua_GetTouchPointsCount(lua_State* L)
+{
+	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 lua_GetGestureHoldDuration(lua_State* L)
+{
+	int result = GetGestureHoldDuration();
+	lua_pushinteger(L, result);
+	return 1;
+}
+
+int lua_GetGestureDragVector(lua_State* L)
+{
+	Vector2 result = GetGestureDragVector();
+	LuaPush_Vector2(L, result);
+	return 1;
+}
+
+int lua_GetGestureDragAngle(lua_State* L)
+{
+	float result = GetGestureDragAngle();
+	lua_pushnumber(L, result);
+	return 1;
+}
+
+int lua_GetGesturePinchVector(lua_State* L)
+{
+	Vector2 result = GetGesturePinchVector();
+	LuaPush_Vector2(L, result);
+	return 1;
+}
+
+int lua_GetGesturePinchAngle(lua_State* L)
+{
+	float result = GetGesturePinchAngle();
+	lua_pushnumber(L, result);
+	return 1;
+}
+
+//------------------------------------------------------------------------------------
+// raylib [camera] module functions - Camera System
+//------------------------------------------------------------------------------------
+int lua_SetCameraMode(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+int lua_SetCameraPosition(lua_State* L)
+{
+	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;
+}
+
+int lua_SetCameraFovy(lua_State* L)
+{
+	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 lua_SetCameraAltControl(lua_State* L)
+{
+	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 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 lua_SetCameraMouseSensitivity(lua_State* L)
+{
+	float arg1 = LuaGetArgument_float(L, 1);
+	SetCameraMouseSensitivity(arg1);
+	return 0;
+}
+
+//------------------------------------------------------------------------------------
+// raylib [shapes] module functions - Basic Shapes Drawing
+//------------------------------------------------------------------------------------
+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 lua_DrawPixelV(lua_State* L)
+{
+	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 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;
+}
+
+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 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 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;
+}
+
+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 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 lua_DrawRectangleRec(lua_State* L)
+{
+	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 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;
+}
+
+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 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;
+}
+
+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;
+}
+
+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;
+}
+
+#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; \
+	}
+
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+//------------------------------------------------------------------------------------
+// raylib [textures] module functions - Texture Loading and Drawing
+//------------------------------------------------------------------------------------
+int lua_LoadImage(lua_State* L)
+{
+	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);
+
+	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;
+}
+
+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;
+}
+
+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;
+}
+
+int lua_LoadTexture(lua_State* L)
+{
+	const char * arg1 = LuaGetArgument_string(L, 1);
+	Texture2D result = LoadTexture(arg1);
+	LuaPush_Texture2D(L, result);
+	return 1;
+}
+
+// TODO: Texture2D LoadTextureEx(void *data, int width, int height, int textureFormat);
+int lua_LoadTextureEx(lua_State* L)
+{
+	void * arg1 = LuaGetArgument_string(L, 1);  // TODO: How to get a void * ?
+    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 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;
+}
+
+int lua_LoadTextureFromImage(lua_State* L)
+{
+	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 lua_UnloadImage(lua_State* L)
+{
+	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;
+}
+
+int lua_UnloadRenderTexture(lua_State* L)
+{
+	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;
+}
+
+int lua_GetTextureData(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+// TODO:
+/*
+void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp);                            // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
+Image ImageCopy(Image image);                                                                      // Create an image duplicate (useful for transformations)
+void ImageCrop(Image *image, Rectangle crop);                                                      // Crop an image to a defined rectangle
+void ImageResize(Image *image, int newWidth, int newHeight);                                       // Resize and image (bilinear filtering)
+void ImageResizeNN(Image *image,int newWidth,int newHeight);                                       // Resize and image (Nearest-Neighbor scaling algorithm)
+Image ImageText(const char *text, int fontSize, Color color);                                      // Create an image from text (default font)
+Image ImageTextEx(SpriteFont font, const char *text, int fontSize, int spacing, Color tint);       // Create an image from text (custom sprite font)
+void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec);                         // Draw a source image within a destination image
+void ImageDrawText(Image *dst, Vector2 position, const char *text, int fontSize, Color color);     // Draw text (default font) within an image (destination)
+void ImageDrawTextEx(Image *dst, Vector2 position, SpriteFont font, const char *text, int fontSize, int spacing, Color color); // Draw text (custom sprite font) within an image (destination)
+void ImageFlipVertical(Image *image);                                                              // Flip image vertically
+void ImageFlipHorizontal(Image *image);                                                            // Flip image horizontally
+void ImageColorTint(Image *image, Color color);                                                    // Modify image color: tint
+void ImageColorInvert(Image *image);                                                               // Modify image color: invert
+void ImageColorGrayscale(Image *image);                                                            // Modify image color: grayscale
+void ImageColorContrast(Image *image, float contrast);                                             // Modify image color: contrast (-100 to 100)
+void ImageColorBrightness(Image *image, int brightness);                                           // Modify image color: brightness (-255 to 255)
+*/
+
+int lua_GenTextureMipmaps(lua_State* L)
+{
+	Texture2D arg1 = LuaGetArgument_Texture2D(L, 1);
+	GenTextureMipmaps(arg1);
+	return 0;
+}
+
+// TODO: void UpdateTexture(Texture2D texture, void *pixels);                                               // Update GPU texture with new data
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+//------------------------------------------------------------------------------------
+// raylib [text] module functions - Font Loading and Text Drawing
+//------------------------------------------------------------------------------------
+int lua_GetDefaultFont(lua_State* L)
+{
+	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;
+}
+
+int lua_UnloadSpriteFont(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+int lua_DrawFPS(lua_State* L)
+{
+	int arg1 = LuaGetArgument_int(L, 1);
+	int arg2 = LuaGetArgument_int(L, 2);
+	DrawFPS(arg1, arg2);
+	return 0;
+}
+
+// TODO:
+/*
+const char *FormatText(const char *text, ...);                                                     // Formatting of text with variables to 'embed'
+const char *SubText(const char *text, int position, int length);                                   // Get a piece of a text string
+*/
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+int lua_DrawRay(lua_State* L)
+{
+	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 lua_DrawGizmo(lua_State* L)
+{
+	Vector3 arg1 = LuaGetArgument_Vector3(L, 1);
+	DrawGizmo(arg1);
+	return 0;
+}
+
+// TODO:
+/*
+void DrawLight(Light light);                                                                       // Draw light in 3D world
+void Draw3DLine(Vector3 startPos, Vector3 endPos, Color color);                                    // Draw a line in 3D world space
+void Draw3DCircle(Vector3 center, float radius, float rotationAngle, Vector3 rotation, Color color);    // Draw a circle in 3D world space
+*/
+
+//------------------------------------------------------------------------------------
+// raylib [models] module functions
+//------------------------------------------------------------------------------------
+int lua_LoadModel(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+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;
+}
+
+int lua_LoadCubicmap(lua_State* L)
+{
+	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;
+}
+
+// TODO: GenMesh*()
+
+int lua_LoadMaterial(lua_State* L)
+{
+	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;
+}
+
+int lua_LoadStandardMaterial(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+int lua_DrawModelEx(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+int lua_DrawModelWiresEx(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+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;
+}
+
+int lua_CalculateBoundingBox(lua_State* L)
+{
+	Mesh arg1 = LuaGetArgument_Mesh(L, 1);
+    BoundingBox result = CalculateBoundingBox(arg1);
+	LuaPush_BoundingBox(L, result);
+	return 0;
+}
+
+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;
+}
+
+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;
+}
+
+int lua_CheckCollisionBoxSphere(lua_State* L)
+{
+	BoundingBox arg1 = LuaGetArgument_BoundingBox(L, 1);
+	Vector3 arg2 = LuaGetArgument_Vector3(L, 2);
+	float arg3 = LuaGetArgument_float(L, 4);
+	bool result = CheckCollisionBoxSphere(arg1, arg2, arg3);
+	lua_pushboolean(L, result);
+	return 1;
+}
+
+// TODO:
+/*
+bool CheckCollisionRaySphere(Ray ray, Vector3 spherePosition, float sphereRadius);                              // Detect collision between ray and sphere
+bool CheckCollisionRaySphereEx(Ray ray, Vector3 spherePosition, float sphereRadius, Vector3 *collisionPoint);   // Detect collision between ray and sphere with extended parameters and collision point detection
+bool CheckCollisionRayBox(Ray ray, BoundingBox box);                                                            // Detect collision between ray and box
+Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *playerPosition, float radius);   // Detect collision of player radius with cubicmap
+*/
+
+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;
+}
+
+//------------------------------------------------------------------------------------
+// raylib [raymath] module functions - Shaders
+//------------------------------------------------------------------------------------
+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;
+}
+
+int lua_UnloadShader(lua_State* L)
+{
+	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;
+}
+
+int lua_GetStandardShader(lua_State* L)
+{
+	Shader result = GetStandardShader();
+	LuaPush_Shader(L, result);
+	return 1;
+}
+
+int lua_GetDefaultTexture(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+int lua_SetMatrixProjection(lua_State* L)
+{
+	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;
+}
+
+int lua_BeginShaderMode(lua_State* L)
+{
+	Shader arg1 = LuaGetArgument_Shader(L, 1);
+	BeginShaderMode(arg1);
+	return 0;
+}
+
+int lua_EndShaderMode(lua_State* L)
+{
+	EndShaderMode();
+	return 0;
+}
+
+int lua_BeginBlendMode(lua_State* L)
+{
+	int arg1 = LuaGetArgument_int(L, 1);
+	BeginBlendMode(arg1);
+	return 0;
+}
+
+int lua_EndBlendMode(lua_State* L)
+{
+	EndBlendMode();
+	return 0;
+}
+
+// TODO:
+//Light CreateLight(int type, Vector3 position, Color diffuse);       // Create a new light, initialize it and add to pool
+//void DestroyLight(Light light);                                     // Destroy a light and take it out of the list
+
+// TODO:
+/*
+//------------------------------------------------------------------------------------
+// raylib [rlgl] module functions - VR experience
+//------------------------------------------------------------------------------------
+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 ToggleVrMode(void);                    // Enable/Disable VR experience (device or simulator)
+*/
+
+//------------------------------------------------------------------------------------
+// raylib [audio] module functions
+//------------------------------------------------------------------------------------
+int lua_InitAudioDevice(lua_State* L)
+{
+	InitAudioDevice();
+	return 0;
+}
+
+int lua_CloseAudioDevice(lua_State* L)
+{
+	CloseAudioDevice();
+	return 0;
+}
+
+int lua_IsAudioDeviceReady(lua_State* L)
+{
+	bool result = IsAudioDeviceReady();
+    lua_pushboolean(L, result);
+	return 0;
+}
+
+int lua_LoadSound(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+int lua_UnloadSound(lua_State* L)
+{
+	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;
+}
+
+int lua_PauseSound(lua_State* L)
+{
+	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;
+}
+
+int lua_StopSound(lua_State* L)
+{
+	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;
+}
+
+int lua_SetSoundVolume(lua_State* L)
+{
+	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;
+}
+
+int lua_LoadMusicStream(lua_State* L)
+{
+	const char * arg1 = LuaGetArgument_string(L, 1);
+    Music result = LoadMusicStream((char *)arg1);
+	LuaPush_Music(L, result);
+	return 0;
+}
+
+int lua_UnloadMusicStream(lua_State* L)
+{
+	Music arg1 = LuaGetArgument_Music(L, 1);
+	UnloadMusicStream(arg1);
+	return 0;
+}
+
+int lua_PlayMusicStream(lua_State* L)
+{
+	Music arg1 = LuaGetArgument_Music(L, 1);
+	PlayMusicStream(arg1);
+	return 0;
+}
+
+int lua_UpdateMusicStream(lua_State* L)
+{
+    Music arg1 = LuaGetArgument_Music(L, 1);
+	UpdateMusicStream(arg1);
+	return 0;
+}
+
+int lua_StopMusicStream(lua_State* L)
+{
+    Music arg1 = LuaGetArgument_Music(L, 1);
+	StopMusicStream(arg1);
+	return 0;
+}
+
+int lua_PauseMusicStream(lua_State* L)
+{
+    Music arg1 = LuaGetArgument_Music(L, 1);
+	PauseMusicStream(arg1);
+	return 0;
+}
+
+int lua_ResumeMusicStream(lua_State* L)
+{
+    Music arg1 = LuaGetArgument_Music(L, 1);
+	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;
+}
+
+int lua_SetMusicVolume(lua_State* L)
+{
+    Music arg1 = LuaGetArgument_Music(L, 1);
+	float arg2 = LuaGetArgument_float(L, 2);
+	SetMusicVolume(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;
+}
+
+int lua_GetMusicTimePlayed(lua_State* L)
+{
+    Music arg1 = LuaGetArgument_Music(L, 1);
+	float result = GetMusicTimePlayed(arg1);
+	lua_pushnumber(L, result);
+	return 1;
+}
+
+// TODO:
+/*
+AudioStream InitAudioStream(unsigned int sampleRate, 
+                            unsigned int sampleSize, 
+                            unsigned int channels);             // Init audio stream (to stream audio pcm data)
+void UpdateAudioStream(AudioStream stream, void *data, int numSamples); // Update audio stream buffers with data
+void CloseAudioStream(AudioStream stream);                      // Close audio stream and free memory
+bool IsAudioBufferProcessed(AudioStream stream);                // Check if any audio stream buffers requires refill
+void PlayAudioStream(AudioStream stream);                       // Play audio stream
+void PauseAudioStream(AudioStream stream);                      // Pause audio stream
+void ResumeAudioStream(AudioStream stream);                     // Resume audio stream
+void StopAudioStream(AudioStream stream);                       // Stop audio stream
+*/
+
+//----------------------------------------------------------------------------------
+// raylib [utils] module functions
+//----------------------------------------------------------------------------------
+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;
+}
+
+#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;
+}
+
+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;
+}
+#endif
+
+int lua_TraceLog(lua_State* L)
+{
+	int num_args = lua_gettop(L) - 1;
+	int arg1 = LuaGetArgument_int(L, 1);
+
+	/// type, 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;
+}
+
+int lua_GetExtension(lua_State* L)
+{
+	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;
+}
+
+//----------------------------------------------------------------------------------
+// raylib [raymath] module functions - Vector3 math
+//----------------------------------------------------------------------------------
+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;
+}
+
+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;
+}
+
+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;
+}
+
+int lua_VectorPerpendicular(lua_State* L)
+{
+	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;
+}
+
+int lua_VectorLength(lua_State* L)
+{
+	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;
+}
+
+int lua_VectorNegate(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+int lua_VectorZero(lua_State* L)
+{
+	Vector3 result = VectorZero();
+	LuaPush_Vector3(L, result);
+	return 1;
+}
+
+//----------------------------------------------------------------------------------
+// raylib [raymath] module functions - Matrix math
+//----------------------------------------------------------------------------------
+int lua_MatrixDeterminant(lua_State* L)
+{
+	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;
+}
+
+int lua_MatrixTranspose(lua_State* L)
+{
+	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;
+}
+
+int lua_MatrixNormalize(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+int lua_MatrixRotateX(lua_State* L)
+{
+	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;
+}
+
+int lua_MatrixRotateZ(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+//----------------------------------------------------------------------------------
+// raylib [raymath] module functions - Quaternion math
+//----------------------------------------------------------------------------------
+int lua_QuaternionLength(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+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;
+}
+
+int lua_QuaternionFromMatrix(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+int lua_QuaternionToAxisAngle(lua_State* L)
+{
+	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;
+}
+
+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;
+}
+
+
+//----------------------------------------------------------------------------------
+// Functions Registering
+//----------------------------------------------------------------------------------
+#define REG(name) { #name, lua_##name },
+
+// raylib Functions (and data types) list
+static luaL_Reg raylib_functions[] = {
+	REG(Color)
+	REG(Vector2)
+	REG(Vector3)
+	REG(Rectangle)
+	REG(Ray)
+	REG(Camera)
+    // TODO: Additional structs
+
+    // TODO: Review registered functions
+	REG(InitWindow)
+	REG(CloseWindow)
+	REG(WindowShouldClose)
+	REG(IsWindowMinimized)
+	REG(ToggleFullscreen)
+
+	REG(GetScreenWidth)
+	REG(GetScreenHeight)
+	REG(ClearBackground)
+	REG(BeginDrawing)
+	REG(EndDrawing)
+	REG(Begin3dMode)
+	REG(End3dMode)
+	REG(GetMouseRay)
+#if defined(PLATFORM_WEB)
+	REG(SetDrawingLoop)
+#else
+	REG(SetTargetFPS)
+#endif
+	REG(GetFPS)
+	REG(GetFrameTime)
+	REG(GetColor)
+	REG(GetHexValue)
+	REG(GetRandomValue)
+	REG(Fade)
+	REG(SetConfigFlags)
+	REG(ShowLogo)
+	REG(IsFileDropped)
+	//REG(*GetDroppedFiles)
+	REG(ClearDroppedFiles)
+#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB)
+	REG(IsKeyPressed)
+	REG(IsKeyDown)
+	REG(IsKeyReleased)
+	REG(IsKeyUp)
+	REG(GetKeyPressed)
+	REG(IsMouseButtonPressed)
+	REG(IsMouseButtonDown)
+	REG(IsMouseButtonReleased)
+	REG(IsMouseButtonUp)
+	REG(GetMouseX)
+	REG(GetMouseY)
+	REG(GetMousePosition)
+	REG(SetMousePosition)
+	REG(GetMouseWheelMove)
+	REG(ShowCursor)
+	REG(HideCursor)
+	REG(IsCursorHidden)
+#endif
+
+#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
+	REG(IsGamepadAvailable)
+    
+	REG(IsGamepadButtonPressed)
+	REG(IsGamepadButtonDown)
+	REG(IsGamepadButtonReleased)
+	REG(IsGamepadButtonUp)
+#endif
+
+#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB)
+	REG(GetTouchX)
+	REG(GetTouchY)
+	REG(GetTouchPosition)
+#if defined(PLATFORM_WEB)
+	REG(InitGesturesSystem)
+#elif defined(PLATFORM_ANDROID)
+	//REG(InitGesturesSystem)
+#endif
+	REG(UpdateGestures)
+	REG(IsGestureDetected)
+	REG(GetGestureType)
+	REG(SetGesturesEnabled)
+	REG(GetGestureDragIntensity)
+	REG(GetGestureDragAngle)
+	REG(GetGestureDragVector)
+	REG(GetGestureHoldDuration)
+	REG(GetGesturePinchDelta)
+	REG(GetGesturePinchAngle)
+#endif
+	REG(SetCameraMode)
+	REG(UpdateCamera)
+	REG(UpdateCameraPlayer)
+	REG(SetCameraPosition)
+	REG(SetCameraTarget)
+	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(CheckCollisionRecs)
+	REG(CheckCollisionCircles)
+	REG(CheckCollisionCircleRec)
+	REG(GetCollisionRec)
+	REG(CheckCollisionPointRec)
+	REG(CheckCollisionPointCircle)
+	REG(CheckCollisionPointTriangle)
+	REG(LoadImage)
+	REG(LoadImageEx)
+	REG(LoadImageRaw)
+	REG(LoadImageFromRES)
+	REG(LoadTexture)
+	REG(LoadTextureFromRES)
+	REG(LoadTextureFromImage)
+	REG(UnloadImage)
+	REG(UnloadTexture)
+	REG(GetImageData)
+	REG(GetTextureData)
+	REG(ImageToPOT)
+	REG(ImageFormat)
+	REG(GenTextureMipmaps)
+	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(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(LoadHeightmap)
+	REG(LoadCubicmap)
+	REG(UnloadModel)
+	REG(DrawModel)
+	REG(DrawModelEx)
+	REG(DrawModelWires)
+	REG(DrawBillboard)
+	REG(DrawBillboardRec)
+	REG(CheckCollisionSpheres)
+	REG(CheckCollisionBoxes)
+	REG(CheckCollisionBoxSphere)
+	REG(ResolveCollisionCubicmap)
+	REG(LoadShader)
+	REG(UnloadShader)
+	REG(GetShaderLocation)
+	REG(SetShaderValue)
+	REG(SetShaderValuei)
+
+	REG(BeginBlendMode)
+	REG(EndBlendMode)
+	REG(InitAudioDevice)
+	REG(CloseAudioDevice)
+	REG(LoadSound)
+	REG(LoadSoundFromWave)
+	REG(LoadSoundFromRES)
+	REG(UnloadSound)
+	REG(PlaySound)
+	REG(PauseSound)
+	REG(StopSound)
+	REG(IsSoundPlaying)
+	REG(SetSoundVolume)
+	REG(SetSoundPitch)
+	REG(PlayMusicStream)
+	REG(UpdateMusicStream)
+	REG(StopMusicStream)
+	REG(PauseMusicStream)
+	REG(ResumeMusicStream)
+	REG(IsMusicPlaying)
+	REG(SetMusicVolume)
+	REG(GetMusicTimeLength)
+	REG(GetMusicTimePlayed)
+
+	/// Math and util
+	REG(DecompressData)
+#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI)
+	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}
+};
+
+// 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);
+
+	luaL_setfuncs(L, raylib_functions, 0);
+}
+
+//----------------------------------------------------------------------------------
+// raylib Lua API
+//----------------------------------------------------------------------------------
+
+// Initialize Lua system
+RLUADEF void InitLuaDevice(void)
+{
+	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);
+	LuaEndEnum("GAMEPAD");
+    
+	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);
+	LuaEndEnum("GAMEPAD");
+    
+    // TODO: XBOX controller buttons enum
+
+	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");
+    
+    LuaStartEnum();
+    LuaSetEnum("HMD_DEFAULT_DEVICE", HMD_DEFAULT_DEVICE);
+    LuaSetEnum("HMD_OCULUS_RIFT_DK2", HMD_OCULUS_RIFT_DK2);
+    LuaSetEnum("HMD_OCULUS_RIFT_CV1", HMD_OCULUS_RIFT_CV1);
+    LuaSetEnum("HMD_VALVE_HTC_VIVE", HMD_VALVE_HTC_VIVE);
+    LuaSetEnum("HMD_SAMSUNG_GEAR_VR", HMD_SAMSUNG_GEAR_VR);
+    LuaSetEnum("HMD_GOOGLE_CARDBOARD", HMD_GOOGLE_CARDBOARD);
+    LuaSetEnum("HMD_SONY_PLAYSTATION_VR", HMD_SONY_PLAYSTATION_VR);
+    LuaSetEnum("HMD_RAZER_OSVR", HMD_RAZER_OSVR);
+    LuaSetEnum("HMD_FOVE_VR", HMD_FOVE_VR);
+	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_pushboolean(L, true);
+#if defined(PLATFORM_DESKTOP)
+	lua_setglobal(L, "PLATFORM_DESKTOP");
+#elif defined(PLATFORM_ANDROID) 
+	lua_setglobal(L, "PLATFORM_ANDROID");
+#elif defined(PLATFORM_RPI) 
+	lua_setglobal(L, "PLATFORM_RPI");
+#elif defined(PLATFORM_WEB)
+	lua_setglobal(L, "PLATFORM_WEB");
+#endif
+
+	luaL_openlibs(L);
+	LuaBuildOpaqueMetatables();
+    
+	LuaRegisterRayLib(0);
+}
+
+// De-initialize Lua system
+RLUADEF void CloseLuaDevice(void)
+{
+	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;
+	}
+
+	int result = luaL_dostring(L, code);
+    
+	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;
+	}
+
+	int result = luaL_dofile(L, filename);
+    
+	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