Added initial files.

1 files changed, 2113 insertions, 0 deletions

diff --git a/src/models.c b/src/models.c
new file mode 100644
index 0000000..17683b8
--- /dev/null
+++ b/src/models.c
@@ -0,0 +1,2113 @@
+#include "main.h"
+#include "state.h"
+#include "models.h"
+#include "lua_core.h"
+#include "rmath.h"
+#include "textures.h"
+#include "core.h"
+
+static void checkMeshRealloc( int i ) {
+	if ( i == state->meshCount ) {
+		state->meshCount++;
+	}
+
+	if ( state->meshCount == state->meshAlloc ) {
+		state->meshAlloc += ALLOC_PAGE_SIZE;
+		state->meshes = realloc( state->meshes, state->meshAlloc * sizeof( Mesh* ) );
+
+		for ( i = state->meshCount; i < state->meshAlloc; i++ ) {
+			state->meshes[i] = NULL;
+		}
+	}
+}
+
+static void checkMaterialRealloc( int i ) {
+	if ( i == state->materialCount ) {
+		state->materialCount++;
+	}
+
+	if ( state->materialCount == state->materialAlloc ) {
+		state->materialAlloc += ALLOC_PAGE_SIZE;
+		state->materials = realloc( state->materials, state->materialAlloc * sizeof( Material* ) );
+
+		for ( i = state->materialCount; i < state->materialAlloc; i++ ) {
+			state->materials[i] = NULL;
+		}
+	}
+}
+
+static void checkModelRealloc( int i ) {
+	if ( i == state->modelCount ) {
+		state->modelCount++;
+	}
+
+	if ( state->modelCount == state->modelAlloc ) {
+		state->modelAlloc += ALLOC_PAGE_SIZE;
+		state->models = realloc( state->models, state->modelAlloc * sizeof( Model* ) );
+
+		for ( i = state->modelCount; i < state->modelAlloc; i++ ) {
+			state->models[i] = NULL;
+		}
+	}
+}
+
+static void checkAnimationRealloc( int i ) {
+	if ( i == state->animationCount ) {
+		state->animationCount++;
+	}
+
+	if ( state->animationCount == state->animationAlloc ) {
+		state->animationAlloc += ALLOC_PAGE_SIZE;
+		state->animations = realloc( state->animations, state->animationAlloc * sizeof( ModelAnimations* ) );
+
+		for ( i = state->animationCount; i < state->animationAlloc; i++ ) {
+			state->animations[i] = NULL;
+		}
+	}
+}
+
+static bool validMesh( size_t id ) {
+	if ( id < 0 || state->meshCount < id || state->meshes[ id ] == NULL ) {
+		TraceLog( LOG_WARNING, "%s %d", "Invalid mesh", id );
+		return false;
+	}
+	else {
+		return true;
+	}
+}
+
+static bool validMaterial( size_t id ) {
+	if ( id < 0 || state->materialCount < id || state->materials[ id ] == NULL ) {
+		TraceLog( LOG_WARNING, "%s %d", "Invalid material", id );
+		return false;
+	}
+	else {
+		return true;
+	}
+}
+
+static bool validModel( size_t id ) {
+	if ( id < 0 || state->modelCount < id || state->models[ id ] == NULL ) {
+		TraceLog( LOG_WARNING, "%s %d", "Invalid model", id );
+		return false;
+	}
+	else {
+		return true;
+	}
+}
+
+static bool validAnimation( size_t id ) {
+	if ( id < 0 || state->animationCount < id || state->animations[ id ] == NULL ) {
+		TraceLog( LOG_WARNING, "%s %d", "Invalid animation", id );
+		return false;
+	}
+	else {
+		return true;
+	}
+}
+
+/*
+## Models - Basic
+*/
+
+/*
+> success = RL_DrawLine3D( Vector3 startPos, Vector3 endPos, Color color )
+
+Draw a line in 3D world space
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawLine3D( lua_State *L ) {
+	if ( !lua_istable( L, -3 ) || !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawLine3D( Vector3 startPos, Vector3 endPos, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	Vector3 endPos = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 startPos = uluaGetVector3( L );
+
+	DrawLine3D( startPos, endPos, color);
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawPoint3D( Vector3 position, Color color )
+
+Draw a point in 3D space, actually a small line
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawPoint3D( lua_State *L ) {
+	if ( !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawPoint3D( Vector3 position, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	Vector3 position = uluaGetVector3( L );
+
+	DrawPoint3D( position, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawCircle3D( Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color )
+
+Draw a circle in 3D world space
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawCircle3D( lua_State *L ) {
+	if ( !lua_istable( L, -5 ) || !lua_isnumber( L, -4 ) || !lua_istable( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawCircle3D( Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	float rotationAngle = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 rotationAxis = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	float radius = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 center = uluaGetVector3( L );
+
+	DrawCircle3D( center, radius, rotationAxis, rotationAngle, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawTriangle3D( Vector3 v1, Vector3 v2, Vector3 v3, Color color )
+
+Draw a color-filled triangle ( Vertex in counter-clockwise order! )
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawTriangle3D( lua_State *L ) {
+	if ( !lua_istable( L, -4 ) || !lua_istable( L, -3 ) || !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawTriangle3D( Vector3 v1, Vector3 v2, Vector3 v3, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	Vector3 v3 = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 v2 = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 v1 = uluaGetVector3( L );
+
+	DrawTriangle3D( v1, v2, v3, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawCube( Vector3 position, Vector3 size, Color color )
+
+Draw cube
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawCube( lua_State *L ) {
+	if ( !lua_istable( L, -3 ) || !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawCube( Vector3 position, Vector3 size, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	Vector3 size = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 pos = uluaGetVector3( L );
+
+	DrawCubeV( pos, size, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawCubeWires( Vector3 position, Vector3 size, Color color )
+
+Draw cube wires
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawCubeWires( lua_State *L ) {
+	if ( !lua_istable( L, -3 ) || !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawCubeWires( Vector3 position, Vector3 size, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	Vector3 size = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 pos = uluaGetVector3( L );
+
+	DrawCubeWiresV( pos, size, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawCubeTexture( Texture2D texture, Vector3 position, Vector3 size, Color color )
+
+Draw cube textured
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawCubeTexture( lua_State *L ) {
+	if ( !lua_isnumber( L, -4 ) || !lua_istable( L, -3 ) || !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawCubeTexture( Texture2D texture, Vector3 position, Vector3 size, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	Vector3 size = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 pos = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	size_t texId = lua_tointeger( L, -1 );
+
+	if ( !validSourceTexture( texId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+ 	DrawCubeTexture( *texturesGetSourceTexture( texId ), pos, size.x, size.y, size.z, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawSphere( Vector3 centerPos, float radius, Color color )
+
+Draw sphere
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawSphere( lua_State *L ) {
+	if ( !lua_istable( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawSphere( Vector3 centerPos, float radius, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	float radius = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 centerPos = uluaGetVector3( L );
+
+	DrawSphere( centerPos, radius, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawSphereEx( Vector3 centerPos, float radius, int rings, int slices, Color color )
+
+Draw sphere with extended parameters
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawSphereEx( lua_State *L ) {
+	if ( !lua_istable( L, -5 ) || !lua_isnumber( L, -4 ) || !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawSphereEx( Vector3 centerPos, float radius, int rings, int slices, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	int slices = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	int rings = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	float radius = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 centerPos = uluaGetVector3( L );
+
+	DrawSphereEx( centerPos, radius, rings, slices, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawSphereWires( Vector3 centerPos, float radius, int rings, int slices, Color color )
+
+Draw sphere wires
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawSphereWires( lua_State *L ) {
+	if ( !lua_istable( L, -5 ) || !lua_isnumber( L, -4 ) || !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawSphereWires( Vector3 centerPos, float radius, int rings, int slices, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	int slices = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	int rings = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	float radius = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 centerPos = uluaGetVector3( L );
+
+	DrawSphereWires( centerPos, radius, rings, slices, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawCylinder( Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color )
+
+Draw a cylinder/cone
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawCylinder( lua_State *L ) {
+	if ( !lua_istable( L, -6 ) || !lua_isnumber( L, -5 ) || !lua_isnumber( L, -4 ) || !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawCylinder( Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	int slices = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	float height = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	float radiusBottom = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	float radiusTop = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 position = uluaGetVector3( L );
+
+	DrawCylinder( position, radiusTop, radiusBottom, height, slices, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawCylinderEx( Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color )
+
+Draw a cylinder with base at startPos and top at endPos
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawCylinderEx( lua_State *L ) {
+	if ( !lua_istable( L, -6 ) || !lua_istable( L, -5 ) || !lua_isnumber( L, -4 ) || !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawCylinderEx( Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	int sides = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	float endRadius = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	float startRadius = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 endPos = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 startPos = uluaGetVector3( L );
+
+	DrawCylinderEx( startPos, endPos, startRadius, endRadius, sides, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawCylinderWires( Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color )
+
+Draw a cylinder/cone wires
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawCylinderWires( lua_State *L ) {
+	if ( !lua_istable( L, -6 ) || !lua_isnumber( L, -5 ) || !lua_isnumber( L, -4 ) || !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawCylinderWires( Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	int slices = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	float height = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	float radiusBottom = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	float radiusTop = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 position = uluaGetVector3( L );
+
+	DrawCylinderWires( position, radiusTop, radiusBottom, height, slices, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawCylinderWiresEx( Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color )
+
+Draw a cylinder wires with base at startPos and top at endPos
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawCylinderWiresEx( lua_State *L ) {
+	if ( !lua_istable( L, -6 ) || !lua_istable( L, -5 ) || !lua_isnumber( L, -4 ) || !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawCylinderWiresEx( Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	int sides = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	float endRadius = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	float startRadius = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 endPos = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 startPos = uluaGetVector3( L );
+
+	DrawCylinderWiresEx( startPos, endPos, startRadius, endRadius, sides, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawPlane( Vector3 centerPos, Vector2 size, Color color )
+
+Draw a plane XZ
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawPlane( lua_State *L ) {
+	if ( !lua_istable( L, -3 ) || !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawPlane( Vector3 centerPos, Vector2 size, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	Vector2 size = uluaGetVector2( L );
+	lua_pop( L, 1 );
+	Vector3 centerPos = uluaGetVector3( L );
+
+	DrawPlane( centerPos, size, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawQuad3DTexture( texture, Vector3{} vertices, Vector2{} texCoords, Color color )
+
+Draw 3D quad texture using vertices and texture coordinates. Texture coordinates opengl style 0.0 - 1.0.
+Note! Could be replaced something like "DrawPlaneTextureRec"
+
+- Failure return false
+- Success return true
+*/
+int lmodelDrawQuad3DTexture( lua_State *L ) {
+	if ( !lua_istable( L, -3 ) || !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawQuad3DTexture( texture, Vector3{} vertices, Vector2{} texCoords, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+
+	/* TexCoords. */
+	Vector2 texcoords[4] = { 0 };
+
+	int t = lua_gettop( L ), i = 0;
+    lua_pushnil( L );
+
+	while ( lua_next( L, t ) != 0 ) {
+        if ( lua_istable( L, -1 ) && i < 4 ) {
+			texcoords[i] = uluaGetVector2( L );
+        }
+        i++;
+        lua_pop( L, 1 );
+    }
+	lua_pop( L, 1 );
+
+	/* Vertices. */
+	Vector3 vertices[4] = { 0 };
+
+	t = lua_gettop( L );
+	i = 0;
+    lua_pushnil( L );
+
+	while ( lua_next( L, t ) != 0 ) {
+        if ( lua_istable( L, -1 ) && i < 4 ) {
+			vertices[i] = uluaGetVector3( L );
+        }
+        i++;
+        lua_pop( L, 1 );
+    }
+	lua_pop( L, 1 );
+	size_t texId = lua_tointeger( L, -1 );
+
+	if ( !validSourceTexture( texId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+	// Draw.
+	rlCheckRenderBatchLimit( 4 );
+	rlSetTexture( texturesGetSourceTexture( texId )->id );
+
+	//TODO Normals. maybe something like Vector3Normalize(Vector3CrossProduct(Vector3Subtract(vB, vA), Vector3Subtract(vC, vA)));
+
+	rlBegin( RL_QUADS );
+        rlColor4ub( color.r, color.g, color.b, color.a );
+
+		for ( i = 0; i < 4; ++i ) {
+			rlTexCoord2f( texcoords[i].x, texcoords[i].y );
+			rlVertex3f( vertices[i].x, vertices[i].y, vertices[i].z );
+		}
+	rlEnd();
+	rlSetTexture( 0 );
+
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawRay( Ray ray, Color color )
+
+Draw a ray line
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawRay( lua_State *L ) {
+	if ( !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawRay( Ray ray, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	Ray ray = uluaGetRay( L );
+
+	DrawRay( ray, color );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawGrid( int slices, float spacing )
+
+Draw a grid ( Centered at ( 0, 0, 0 ) )
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawGrid( lua_State *L ) {
+	if ( !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawGrid( int slices, float spacing )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	DrawGrid( lua_tointeger( L, -2 ), lua_tonumber( L, -1 ) );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+## Models - Mesh
+*/
+
+/*
+> mesh = RL_GenMeshPoly( int sides, float radius )
+
+Generate polygonal mesh
+
+- Failure return -1
+- Success return int
+*/
+int lmodelsGenMeshPoly( lua_State *L ) {
+	if ( !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GenMeshPoly( int sides, float radius )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	float radius = lua_tonumber( L, -1 );
+	int sides = lua_tointeger( L, -2 );
+	int i = 0;
+
+	for ( i = 0; i < state->meshCount; i++ ) {
+		if ( state->meshes[i] == NULL ) {
+			break;
+		}
+	}
+	state->meshes[i] = malloc( sizeof( Mesh ) );
+	*state->meshes[i] = GenMeshPoly( sides, radius );
+	lua_pushinteger( L, i );
+	checkMeshRealloc( i );
+
+	return 1;
+}
+
+/*
+> mesh = RL_GenMeshPlane( float width, float length, int resX, int resZ )
+
+Generate plane mesh ( With subdivisions )
+
+- Failure return -1
+- Success return int
+*/
+int lmodelsGenMeshPlane( lua_State *L ) {
+	if ( !lua_isnumber( L, -4 ) || !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GenMeshPlane( float width, float length, int resX, int resZ )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	int resZ = lua_tointeger( L, -1 );
+	int resX = lua_tointeger( L, -2 );
+	float length = lua_tonumber( L, -3 );
+	float width = lua_tonumber( L, -4 );
+	int i = 0;
+
+	for ( i = 0; i < state->meshCount; i++ ) {
+		if ( state->meshes[i] == NULL ) {
+			break;
+		}
+	}
+	state->meshes[i] = malloc( sizeof( Mesh ) );
+	*state->meshes[i] = GenMeshPlane( width, length, resX, resZ );
+	lua_pushinteger( L, i );
+	checkMeshRealloc( i );
+
+	return 1;
+}
+
+/*
+> mesh = RL_GenMeshCube( Vector3 size )
+
+Generate cuboid mesh
+
+- Failure return -1
+- Success return int
+*/
+int lmodelsGenMeshCube( lua_State *L ) {
+	if ( !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GenMeshCube( Vector3 size )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	Vector3 size = uluaGetVector3( L );
+	int i = 0;
+
+	for ( i = 0; i < state->meshCount; i++ ) {
+		if ( state->meshes[i] == NULL ) {
+			break;
+		}
+	}
+	state->meshes[i] = malloc( sizeof( Mesh ) );
+	*state->meshes[i] = GenMeshCube( size.x, size.y, size.z );
+	lua_pushinteger( L, i );
+	checkMeshRealloc( i );
+
+	return 1;
+}
+
+/*
+> mesh = RL_GenMeshSphere( float radius, int rings, int slices )
+
+Generate sphere mesh ( Standard sphere )
+
+- Failure return -1
+- Success return int
+*/
+int lmodelsGenMeshSphere( lua_State *L ) {
+	if ( !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GenMeshSphere( float radius, int rings, int slices )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	int slices = lua_tointeger( L, -1 );
+	int rings = lua_tointeger( L, -2 );
+	float radius = lua_tonumber( L, -3 );
+	int i = 0;
+
+	for ( i = 0; i < state->meshCount; i++ ) {
+		if ( state->meshes[i] == NULL ) {
+			break;
+		}
+	}
+	state->meshes[i] = malloc( sizeof( Mesh ) );
+	*state->meshes[i] = GenMeshSphere( radius, rings, slices );
+	lua_pushinteger( L, i );
+	checkMeshRealloc( i );
+
+	return 1;
+}
+
+/*
+> mesh = RL_GenMeshCylinder( float radius, float height, int slices )
+
+Generate cylinder mesh
+
+- Failure return -1
+- Success return int
+*/
+int lmodelsGenMeshCylinder( lua_State *L ) {
+	if ( !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GenMeshCylinder( float radius, float height, int slices )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	int slices = lua_tointeger( L, -1 );
+	float height = lua_tonumber( L, -2 );
+	float radius = lua_tonumber( L, -3 );
+	int i = 0;
+
+	for ( i = 0; i < state->meshCount; i++ ) {
+		if ( state->meshes[i] == NULL ) {
+			break;
+		}
+	}
+	state->meshes[i] = malloc( sizeof( Mesh ) );
+	*state->meshes[i] = GenMeshCylinder( radius, height, slices);
+	lua_pushinteger( L, i );
+	checkMeshRealloc( i );
+
+	return 1;
+}
+
+/*
+> mesh = RL_GenMeshCone( float radius, float height, int slices )
+
+Generate cone/pyramid mesh
+
+- Failure return -1
+- Success return int
+*/
+int lmodelsGenMeshCone( lua_State *L ) {
+	if ( !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GenMeshCone( float radius, float height, int slices )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	int slices = lua_tointeger( L, -1 );
+	float height = lua_tonumber( L, -2 );
+	float radius = lua_tonumber( L, -3 );
+	int i = 0;
+
+	for ( i = 0; i < state->meshCount; i++ ) {
+		if ( state->meshes[i] == NULL ) {
+			break;
+		}
+	}
+	state->meshes[i] = malloc( sizeof( Mesh ) );
+	*state->meshes[i] = GenMeshCone( radius, height, slices);
+	lua_pushinteger( L, i );
+	checkMeshRealloc( i );
+
+	return 1;
+}
+
+/*
+> mesh = RL_GenMeshTorus( float radius, float size, int radSeg, int sides )
+
+Generate torus mesh
+
+- Failure return -1
+- Success return int
+*/
+int lmodelsGenMeshTorus( lua_State *L ) {
+	if ( !lua_isnumber( L, -4 ) || !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GenMeshTorus( float radius, float size, int radSeg, int sides )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	int sides = lua_tointeger( L, -1 );
+	int radSeg = lua_tointeger( L, -2 );
+	float size = lua_tonumber( L, -3 );
+	float radius = lua_tonumber( L, -4 );
+	int i = 0;
+
+	for ( i = 0; i < state->meshCount; i++ ) {
+		if ( state->meshes[i] == NULL ) {
+			break;
+		}
+	}
+	state->meshes[i] = malloc( sizeof( Mesh ) );
+	*state->meshes[i] = GenMeshTorus( radius, size, radSeg, sides );
+	lua_pushinteger( L, i );
+	checkMeshRealloc( i );
+
+	return 1;
+}
+
+/*
+> mesh = RL_GenMeshKnot( float radius, float size, int radSeg, int sides )
+
+Generate torus mesh
+
+- Failure return -1
+- Success return int
+*/
+int lmodelsGenMeshKnot( lua_State *L ) {
+	if ( !lua_isnumber( L, -4 ) || !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GenMeshKnot( float radius, float size, int radSeg, int sides )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	int sides = lua_tointeger( L, -1 );
+	int radSeg = lua_tointeger( L, -2 );
+	float size = lua_tonumber( L, -3 );
+	float radius = lua_tonumber( L, -4 );
+	int i = 0;
+
+	for ( i = 0; i < state->meshCount; i++ ) {
+		if ( state->meshes[i] == NULL ) {
+			break;
+		}
+	}
+	state->meshes[i] = malloc( sizeof( Mesh ) );
+	*state->meshes[i] = GenMeshKnot( radius, size, radSeg, sides );
+	lua_pushinteger( L, i );
+	checkMeshRealloc( i );
+
+	return 1;
+}
+
+/*
+> mesh = RL_GenMeshHeightmap( Image heightmap, Vector3 size )
+
+Generate heightmap mesh from image data
+
+- Failure return -1
+- Success return int
+*/
+int lmodelsGenMeshHeightmap( lua_State *L ) {
+	if ( !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GenMeshHeightmap( Image heightmap, Vector3 size )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	Vector3 size = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Image *heightmap = state->images[ lua_tointeger( L, -1 ) ];
+	int i = 0;
+
+	for ( i = 0; i < state->meshCount; i++ ) {
+		if ( state->meshes[i] == NULL ) {
+			break;
+		}
+	}
+	state->meshes[i] = malloc( sizeof( Mesh ) );
+	*state->meshes[i] = GenMeshHeightmap( *heightmap, size );
+	lua_pushinteger( L, i );
+	checkMeshRealloc( i );
+
+	return 1;
+}
+
+/*
+> mesh = RL_GenMeshCustom( Vector3{} vertices, Vector2{} texCoords, Vector3{} normals )
+
+Generate custom mesh
+
+- Failure return -1
+- Success return int
+*/
+int lmodelsGenMeshCustom( lua_State *L ) {
+	if ( !lua_istable( L, -3 ) || !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GenMeshCustom( Vector3{} vertices, Vector2{} texCoords, Vector3{} normals )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	Mesh mesh = { 0 };
+	size_t len = uluaGetTableLen( L );
+
+	mesh.vertexCount = len * 3;
+    mesh.triangleCount = len;
+
+	mesh.vertices = (float*)MemAlloc( mesh.vertexCount * 3 * sizeof(float) );
+    mesh.texcoords = (float*)MemAlloc( mesh.vertexCount * 2 * sizeof(float) );
+    mesh.normals = (float*)MemAlloc( mesh.vertexCount * 3 * sizeof(float) );
+	mesh.colors = (unsigned char*)MemAlloc( mesh.vertexCount * 4 * sizeof(unsigned char) );
+
+	/* Normals. */
+
+	int t = lua_gettop( L ), i = 0;
+    lua_pushnil( L );
+
+	while ( lua_next( L, t ) != 0 ) {
+        if ( lua_istable( L, -1 ) ) {
+			Vector3 vec = uluaGetVector3( L );
+			mesh.normals[(i*3)+0] = vec.x;
+			mesh.normals[(i*3)+1] = vec.y;
+			mesh.normals[(i*3)+2] = vec.z;
+        }
+        i++;
+        lua_pop( L, 1 );
+    }
+	lua_pop( L, 1 );
+
+	/* TexCoords. */
+
+	t = lua_gettop( L );
+	i = 0;
+    lua_pushnil( L );
+
+	while ( lua_next( L, t ) != 0 ) {
+        if ( lua_istable( L, -1 ) ) {
+			Vector2 vec = uluaGetVector2( L );
+			mesh.texcoords[(i*2)+0] = vec.x;
+			mesh.texcoords[(i*2)+1] = vec.y;
+        }
+        i++;
+        lua_pop( L, 1 );
+    }
+	lua_pop( L, 1 );
+
+	/* Vertices. */
+
+	t = lua_gettop( L );
+	i = 0;
+    lua_pushnil( L );
+
+	while ( lua_next( L, t ) != 0 ) {
+        if ( lua_istable( L, -1 ) ) {
+			Vector3 vec = uluaGetVector3( L );
+			mesh.vertices[(i*3)+0] = vec.x;
+			mesh.vertices[(i*3)+1] = vec.y;
+			mesh.vertices[(i*3)+2] = vec.z;
+
+			mesh.colors[(i*4)+0] = (unsigned char)255;
+			mesh.colors[(i*4)+1] = (unsigned char)255;
+			mesh.colors[(i*4)+2] = (unsigned char)255;
+			mesh.colors[(i*4)+3] = (unsigned char)255;
+        }
+        i++;
+        lua_pop( L, 1 );
+    }
+	lua_pop( L, 1 );
+
+	UploadMesh( &mesh, false );
+
+	int j = 0;
+
+	for ( j = 0; j < state->meshCount; j++ ) {
+		if ( state->meshes[j] == NULL ) {
+			break;
+		}
+	}
+	state->meshes[j] = malloc( sizeof( Mesh ) );
+	*state->meshes[j] = mesh;
+	lua_pushinteger( L, j );
+	checkMeshRealloc( j );
+
+	return 1;
+}
+
+/*
+> success = RL_UnloadMesh( Mesh mesh )
+
+Unload mesh data from CPU and GPU
+
+- Failure return false
+- Success return true
+*/
+int lmodelsUnloadMesh( lua_State *L ) {
+	if ( !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_UnloadMesh( Mesh mesh )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	size_t id = lua_tointeger( L, -1 );
+
+	if ( !validMesh( id ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	UnloadMesh( *state->meshes[ id ] );
+	state->meshes[ id ] = NULL;
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawMesh( Mesh mesh, Material material, Matrix transform )
+
+Draw a 3d mesh with material and transform
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawMesh( lua_State *L ) {
+	if ( !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawMesh( Mesh mesh, Material material, Matrix transform )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Matrix matrix = uluaGetMatrix( L );
+	lua_pop( L, 1 );
+	size_t materialId = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	size_t meshId = lua_tointeger( L, -1 );
+
+	if ( !validMesh( meshId ) || !validMaterial( materialId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+	DrawMesh( *state->meshes[ meshId ], *state->materials[ materialId ], matrix );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/* TODO Needs shader to work. Test it when we have shaders. */
+/*
+> success = RL_DrawMeshInstanced( Mesh mesh, Material material, Matrix{} transforms, int instances )
+
+Draw multiple mesh instances with material and different transforms
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawMeshInstanced( lua_State *L ) {
+	if ( !lua_isnumber( L, -4 ) || !lua_isnumber( L, -3 ) || !lua_istable( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawMeshInstanced( Mesh mesh, Material material, Matrix{} transforms, int instances )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	int instances = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	Matrix matrises[ instances ];
+
+	int t = lua_gettop( L ), i = 0;
+    lua_pushnil( L );
+
+	while ( lua_next( L, t ) != 0 ) {
+        if ( lua_istable( L, -1 ) ) {
+			matrises[i] = uluaGetMatrix( L );
+        }
+        i++;
+        lua_pop( L, 1 );
+    }
+	lua_pop( L, 1 );
+	size_t materialId = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	size_t meshId = lua_tointeger( L, -1 );
+
+	if ( !validMesh( meshId ) || !validMaterial( materialId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	DrawMeshInstanced( *state->meshes[ meshId ], *state->materials[ materialId ], matrises, instances );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_SetMeshColor( Mesh mesh, Color color )
+
+Updades mesh color vertex attribute buffer
+NOTE: Currently only works on custom mesh
+
+- Failure return false
+- Success return true
+*/
+int lmodelsSetMeshColor( lua_State *L ) {
+	if ( !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_SetMeshColor( Mesh mesh, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	size_t meshId = lua_tointeger( L, -1 );
+
+	if ( !validMesh( meshId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+	Mesh *mesh = state->meshes[ meshId ];
+
+	if ( mesh->colors == NULL ) {
+		TraceLog( LOG_WARNING, "Mesh %d %s", meshId, "Mesh doesn't have vertex colors allocated" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+	for ( int i = 0; i < mesh->vertexCount; ++i ) {
+		mesh->colors[(i*4)+0] = (unsigned char)color.r;
+		mesh->colors[(i*4)+1] = (unsigned char)color.g;
+		mesh->colors[(i*4)+2] = (unsigned char)color.b;
+		mesh->colors[(i*4)+3] = (unsigned char)color.a;
+	}
+	/* Update vertex attribute: color */
+	rlUpdateVertexBuffer( mesh->vboId[3], mesh->colors, mesh->vertexCount * 4 * sizeof( unsigned char ), 0 );
+
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+## Models - Material
+*/
+
+/*
+> material = RL_LoadMaterialDefault()
+
+Load default material
+
+- Success return int
+*/
+int lmodelsLoadMaterialDefault( lua_State *L ) {
+	int i = 0;
+
+	for ( i = 0; i < state->materialCount; i++ ) {
+		if ( state->materials[i] == NULL ) {
+			break;
+		}
+	}
+	state->materials[i] = malloc( sizeof( Material ) );
+	*state->materials[i] = LoadMaterialDefault();
+	lua_pushinteger( L, i );
+	checkMaterialRealloc( i );
+
+	return 1;
+}
+
+/*
+> material = RL_CreateMaterial( material{} )
+
+Load material from table. See material table definition
+
+- Failure return false
+- Success return int
+*/
+int lmodelsCreateMaterial( lua_State *L ) {
+	if ( !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_CreateMaterial( material{} )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	int i = 0;
+
+	for ( i = 0; i < state->materialCount; i++ ) {
+		if ( state->materials[i] == NULL ) {
+			break;
+		}
+	}
+	state->materials[i] = malloc( sizeof( Material ) );
+	*state->materials[i] = LoadMaterialDefault();
+
+	int t = lua_gettop( L );
+	lua_pushnil( L );
+
+	while ( lua_next( L, t ) != 0 ) {
+		if ( strcmp( "maps", (char*)lua_tostring( L, -2 ) ) == 0 && lua_istable( L, -1 ) ) {
+			int t2 = lua_gettop( L );
+			lua_pushnil( L );
+
+			while ( lua_next( L, t2 ) != 0 ) {
+				/* Loop maps. Array where we don't care about the index value. */
+				if ( lua_istable( L, -1 ) ) {
+					int t3 = lua_gettop( L ), j = 0, map = 0;
+					lua_pushnil( L );
+
+					while ( lua_next( L, t3 ) != 0 ) {
+						switch ( j ) {
+							case 0:	/* Map */
+								map = lua_tointeger( L, -1 );
+								break;
+							case 1: /* Parameters */
+							{
+								int t4 = lua_gettop( L );
+								lua_pushnil( L );
+
+								while ( lua_next( L, t4 ) != 0 ) {
+									if ( strcmp( "texture", (char*)lua_tostring( L, -2 ) ) == 0 && lua_isnumber( L, -1 ) ) {
+										state->materials[i]->maps[map].texture = *state->textures[ lua_tointeger( L, -1 ) ];
+									}
+									else if ( strcmp( "color", (char*)lua_tostring( L, -2 ) ) == 0 && lua_istable( L, -1 ) ) {
+										state->materials[i]->maps[map].color = uluaGetColor( L );
+									}
+									else if ( strcmp( "value", (char*)lua_tostring( L, -2 ) ) == 0 && lua_isnumber( L, -1 ) ) {
+										state->materials[i]->maps[map].value = lua_tonumber( L, -1 );
+									}
+									lua_pop( L, 1 );
+								}
+							}
+								break;
+							default:
+								break;
+						}
+					j++;
+					lua_pop( L, 1 );
+					}
+				}
+				lua_pop( L, 1 );
+			}
+		}
+		else if ( strcmp( "params", (char*)lua_tostring( L, -2 ) ) == 0 && lua_istable( L, -1 ) ) {
+			int t2 = lua_gettop( L ), j = 0;
+			lua_pushnil( L );
+
+			while ( lua_next( L, t2 ) != 0 ) {
+				if ( j <= 3 ) {
+					state->materials[i]->params[j] = lua_tonumber( L, -1 );
+				}
+				j++;
+				lua_pop( L, 1 );
+			}
+		}
+		else if ( strcmp( "shader", (char*)lua_tostring( L, -2 ) ) == 0 && lua_isnumber( L, -1 ) ) {
+			/* TODO Shader when implemented. */
+		}
+		lua_pop( L, 1 );
+	}
+	lua_pushinteger( L, i );
+	checkMaterialRealloc( i );
+
+	return 1;
+}
+
+/*
+> success = RL_UnloadMaterial( Material material )
+
+Unload material from GPU memory ( VRAM )
+
+- Failure return false
+- Success return true
+*/
+int lmodelsUnloadMaterial( lua_State *L ) {
+	if ( !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_UnloadMaterial( Material material )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	size_t id = lua_tointeger( L, -1 );
+
+	if ( !validMaterial( id ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	UnloadMaterial( *state->materials[ id ] );
+	state->materials[ id ] = NULL;
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_SetMaterialTexture( Material material, int mapType, Texture2D texture )
+
+Set texture for a material map type ( MATERIAL_MAP_ALBEDO, MATERIAL_MAP_METALNESS... )
+
+- Failure return false
+- Success return true
+*/
+int lmodelsSetMaterialTexture( lua_State *L ) {
+	if ( !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_SetMaterialTexture( Material material, int mapType, Texture2D texture )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	size_t texId = lua_tointeger( L, -1 );
+	size_t materialId = lua_tointeger( L, -3 );
+
+	if ( !validMaterial( materialId ) || !validSourceTexture( texId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+	// SetMaterialTexture( state->materials[ lua_tointeger( L, -3 ) ], lua_tointeger( L, -2 ), *state->textures[ lua_tointeger( L, -1 ) ] );
+	SetMaterialTexture( state->materials[ materialId ], lua_tointeger( L, -2 ), *texturesGetSourceTexture( texId ) );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_SetMaterialColor( Material material, int mapType, Color color )
+
+Set color for a material map type
+
+- Failure return false
+- Success return true
+*/
+int lmodelsSetMaterialColor( lua_State *L ) {
+	if ( !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_SetMaterialColor( Material material, int mapType, Color color )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color color = uluaGetColor( L );
+	lua_pop( L, 1 );
+	size_t mapType = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	size_t materialId = lua_tointeger( L, -1 );
+
+	if ( !validMaterial( materialId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+	state->materials[ materialId ]->maps[ mapType ].color = color;
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_SetMaterialValue( Material material, int mapType, float value )
+
+Set value for a material map type
+
+- Failure return false
+- Success return true
+*/
+int lmodelsSetMaterialValue( lua_State *L ) {
+	if ( !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_SetMaterialValue( Material material, int mapType, float value )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	float value = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	size_t mapType = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	size_t materialId = lua_tointeger( L, -1 );
+
+	if ( !validMaterial( materialId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+	state->materials[ materialId ]->maps[ mapType ].value = value;
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+## Models - Model
+*/
+
+/*
+> model = RL_LoadModel( string fileName )
+
+Load model from files ( Meshes and materials )
+
+- Failure return -1
+- Success return int
+*/
+int lmodelsLoadModel( lua_State *L ) {
+	if ( !lua_isstring( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_LoadModel( string fileName )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	int i = 0;
+
+	for ( i = 0; i < state->modelCount; i++ ) {
+		if ( state->models[i] == NULL ) {
+			break;
+		}
+	}
+	state->models[i] = malloc( sizeof( Model ) );
+	*state->models[i] = LoadModel( lua_tostring( L, -1 ) );
+	lua_pushinteger( L, i );
+	checkModelRealloc( i );
+
+	return 1;
+}
+
+/*
+> model = RL_LoadModelFromMesh( Mesh mesh )
+
+Load model from generated mesh ( Default material )
+
+- Failure return -1
+- Success return int
+*/
+int lmodelsLoadModelFromMesh( lua_State *L ) {
+	if ( !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_LoadModelFromMesh( Mesh mesh )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	size_t meshId = lua_tointeger( L, -1 );
+
+	if ( !validMesh( meshId ) ) {
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	int i = 0;
+
+	for ( i = 0; i < state->modelCount; i++ ) {
+		if ( state->models[i] == NULL ) {
+			break;
+		}
+	}
+	state->models[i] = malloc( sizeof( Model ) );
+	*state->models[i] = LoadModelFromMesh( *state->meshes[ meshId ] );
+	lua_pushinteger( L, i );
+	checkModelRealloc( i );
+
+	return 1;
+}
+
+/*
+> success = RL_UnloadModel( Model model )
+
+Unload model ( Including meshes ) from memory ( RAM and/or VRAM )
+
+- Failure return false
+- Success return true
+*/
+int lmodelsUnloadModel( lua_State *L ) {
+	if ( !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_UnloadModel( Model model )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	size_t modelId = lua_tointeger( L, -1 );
+
+	if ( !validModel( modelId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	UnloadModel( *state->models[ modelId ] );
+	state->models[ modelId ] = NULL;
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawModel( Model model, Vector3 position, float scale, Color tint )
+
+Draw a model ( With texture if set )
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawModel( lua_State *L ) {
+	if ( !lua_isnumber( L, -4 ) || !lua_istable( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawModel( Model model, Vector3 position, float scale, Color tint )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color tint = uluaGetColor( L );
+	lua_pop( L, 1 );
+	float scale = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 position = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	size_t modelId = lua_tointeger( L, -1 );
+
+	if ( !validModel( modelId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+	DrawModel( *state->models[ modelId ], position, scale, tint );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawModelEx( Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint )
+
+Draw a model with extended parameters
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawModelEx( lua_State *L ) {
+	if ( !lua_isnumber( L, -6 ) || !lua_istable( L, -5 ) || !lua_istable( L, -4 )
+	|| !lua_isnumber( L, -3 ) || !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawModelEx( Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color tint = uluaGetColor( L );
+	lua_pop( L, 1 );
+	Vector3 scale = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	float rotationAngle = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 rotationAxis = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 position = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	size_t modelId = lua_tointeger( L, -1 );
+
+	if ( !validModel( modelId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+	DrawModelEx( *state->models[ modelId ], position, rotationAxis, rotationAngle, scale, tint );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_SetModelMaterial( Model model, Material modelMaterial, Material material )
+
+Copies material to model material. ( Model material is the material id in models. Material can be deleted if not used elsewhere )
+
+- Failure return false
+- Success return true
+*/
+int lmodelsSetModelMaterial( lua_State *L ) {
+	if ( !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_SetModelMaterial( Model model, Material modelMaterial, Material material )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	size_t materialId = lua_tointeger( L, -1 );
+	size_t modelId = lua_tointeger( L, -3 );
+
+	if ( !validModel( modelId ) || !validMaterial( materialId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+	Model *model = state->models[ modelId ];
+	int modelMaterialId = lua_tointeger( L, -2 );
+	Material *material = state->materials[ materialId ];
+
+	/* Copy material data instead of using pointer. Pointer would result in double free error. */
+	model->materials[ modelMaterialId ].shader = material->shader;
+	model->materials[ modelMaterialId ].maps[ MATERIAL_MAP_DIFFUSE ] = material->maps[ MATERIAL_MAP_DIFFUSE ];
+	model->materials[ modelMaterialId ].maps[ MATERIAL_MAP_METALNESS ] = material->maps[ MATERIAL_MAP_METALNESS ];
+	model->materials[ modelMaterialId ].maps[ MATERIAL_MAP_NORMAL ] = material->maps[ MATERIAL_MAP_NORMAL ];
+	model->materials[ modelMaterialId ].maps[ MATERIAL_MAP_ROUGHNESS ] = material->maps[ MATERIAL_MAP_ROUGHNESS ];
+	model->materials[ modelMaterialId ].maps[ MATERIAL_MAP_OCCLUSION ] = material->maps[ MATERIAL_MAP_OCCLUSION ];
+	model->materials[ modelMaterialId ].maps[ MATERIAL_MAP_EMISSION ] = material->maps[ MATERIAL_MAP_EMISSION ];
+	model->materials[ modelMaterialId ].maps[ MATERIAL_MAP_HEIGHT ] = material->maps[ MATERIAL_MAP_HEIGHT ];
+	model->materials[ modelMaterialId ].maps[ MATERIAL_MAP_CUBEMAP ] = material->maps[ MATERIAL_MAP_CUBEMAP ];
+	model->materials[ modelMaterialId ].maps[ MATERIAL_MAP_IRRADIANCE ] = material->maps[ MATERIAL_MAP_IRRADIANCE ];
+	model->materials[ modelMaterialId ].maps[ MATERIAL_MAP_PREFILTER ] = material->maps[ MATERIAL_MAP_PREFILTER ];
+	model->materials[ modelMaterialId ].maps[ MATERIAL_MAP_BRDF ] = material->maps[ MATERIAL_MAP_BRDF ];
+
+	for ( int i = 0; i < 4; i++ ) {
+		model->materials[ modelMaterialId ].params[i] = material->params[i];
+	}
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_SetModelMaterial( Model model, Material modelMaterial, Material material )
+
+Set material for a mesh ( Mesh and material on this model )
+
+- Failure return false
+- Success return true
+*/
+int lmodelsSetModelMeshMaterial( lua_State *L ) {
+	if ( !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_SetModelMeshMaterial( Model model, int meshId, int materialId )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	int materialId = lua_tointeger( L, -1 );
+	int meshId = lua_tointeger( L, -2 );
+	size_t modelId = lua_tointeger( L, -3 );
+
+	if ( !validModel( modelId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+	SetModelMeshMaterial( state->models[ modelId ], meshId, materialId );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawBillboard( Camera camera, Texture2D texture, Vector3 position, float size, Color tint )
+
+Draw a billboard texture
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawBillboard( lua_State *L ) {
+	if ( !lua_isnumber( L, -5 ) || !lua_isnumber( L, -4 ) || !lua_istable( L, -3 )
+	|| !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawBillboard( Camera camera, Texture2D texture, Vector3 position, float size, Color tint )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color tint = uluaGetColor( L );
+	lua_pop( L, 1 );
+	float size = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 position = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	size_t texId = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	size_t cameraId = lua_tointeger( L, -1 );
+
+	if ( !validSourceTexture( texId ) || !validCamera3D( cameraId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	DrawBillboard( *state->camera3Ds[ cameraId ], *texturesGetSourceTexture( texId ), position, size, tint );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> success = RL_DrawBillboardRec( Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint )
+
+Draw a billboard texture defined by source
+
+- Failure return false
+- Success return true
+*/
+int lmodelsDrawBillboardRec( lua_State *L ) {
+	if ( !lua_isnumber( L, -6 ) || !lua_isnumber( L, -5 ) || !lua_istable( L, -4 )
+	|| !lua_istable( L, -3 ) || !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_DrawBillboardRec( Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	Color tint = uluaGetColor( L );
+	lua_pop( L, 1 );
+	Vector2 size = uluaGetVector2( L );
+	lua_pop( L, 1 );
+	Vector3 position = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Rectangle source = uluaGetRectangle( L );
+	lua_pop( L, 1 );
+	size_t texId = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	size_t cameraId = lua_tointeger( L, -1 );
+
+	if ( !validSourceTexture( texId ) || !validCamera3D( cameraId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	DrawBillboardRec( *state->camera3Ds[ cameraId ], *texturesGetSourceTexture( texId ), source, position, size, tint );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+## Model - Animations
+*/
+
+/*
+> animations, animationCount = RL_LoadModelAnimations( string fileName )
+
+Load model animations from file
+
+- Failure return -1
+- Success return int, int
+*/
+int lmodelsLoadModelAnimations( lua_State *L ) {
+	if ( !lua_isstring( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_LoadModelAnimations( string fileName )" );
+		lua_pushinteger( L, -1 );
+		return 1;
+	}
+	int i = 0;
+
+	for ( i = 0; i < state->animationCount; i++ ) {
+		if ( state->animations[i] == NULL ) {
+			break;
+		}
+	}
+	state->animations[i] = malloc( sizeof( ModelAnimations ) );
+	state->animations[i]->animations = LoadModelAnimations( lua_tostring( L, -1 ), &state->animations[i]->animCount );
+	checkAnimationRealloc( i );
+
+	lua_pushinteger( L, i );
+	lua_pushinteger( L, state->animations[i]->animCount );
+
+	return 2;
+}
+
+/*
+> success = RL_UpdateModelAnimation( Model model, ModelAnimations animations, int animation, int frame )
+
+Update model animation pose
+
+- Failure return false
+- Success return true
+*/
+int lmodelsUpdateModelAnimation( lua_State *L ) {
+	if ( !lua_isnumber( L, -4 ) || !lua_isnumber( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_UpdateModelAnimation( Model model, ModelAnimations animations, int animation, int frame )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	int frame = imax( 0, lua_tointeger( L, -1 ) );
+	size_t animId = lua_tointeger( L, -3 );
+	size_t modelId = lua_tointeger( L, -4 );
+
+	if ( !validModel( modelId ) || !validAnimation( animId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+
+	UpdateModelAnimation( *state->models[ modelId ], state->animations[ animId ]->animations[ lua_tointeger( L, -2 ) ], frame );
+	lua_pushboolean( L, true );
+
+	return 1;
+}
+
+/*
+> boneCount = RL_GetModelAnimationBoneCount( ModelAnimations animations, int animation )
+
+Return modelAnimation bone count
+
+- Failure return false
+- Success return int
+*/
+int lmodelsGetModelAnimationBoneCount( lua_State *L ) {
+	if ( !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GetModelAnimationBoneCount( ModelAnimations animations, int animation )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	size_t animId = lua_tointeger( L, -2 );
+
+	if ( !validAnimation( animId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	lua_pushinteger( L, state->animations[ animId ]->animations[ lua_tointeger( L, -1 ) ].boneCount );
+
+	return 1;
+}
+
+/*
+> frameCount = RL_GetModelAnimationFrameCount( ModelAnimations animations, int animation )
+
+Return modelAnimation frame count
+
+- Failure return false
+- Success return int
+*/
+int lmodelsGetModelAnimationFrameCount( lua_State *L ) {
+	if ( !lua_isnumber( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GetModelAnimationFrameCount( ModelAnimations animations, int animation )" );
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	size_t animId = lua_tointeger( L, -2 );
+
+	if ( !validAnimation( animId ) ) {
+		lua_pushboolean( L, false );
+		return 1;
+	}
+	lua_pushinteger( L, state->animations[ animId ]->animations[ lua_tointeger( L, -1 ) ].frameCount );
+
+	return 1;
+}
+
+/*
+## Model - Collision
+*/
+
+/*
+> collision = RL_CheckCollisionSpheres( Vector3 center1, float radius1, Vector3 center2, float radius2 )
+
+Check collision between two spheres
+
+- Failure return nil
+- Success return bool
+*/
+int lmodelsCheckCollisionSpheres( lua_State *L ) {
+	if ( !lua_istable( L, -4 ) || !lua_isnumber( L, -3 ) || !lua_istable( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_CheckCollisionSpheres( Vector3 center1, float radius1, Vector3 center2, float radius2 )" );
+		lua_pushnil( L );
+		return 1;
+	}
+	float radius2 = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 center2 = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	float radius1 = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 center1 = uluaGetVector3( L );
+
+	lua_pushboolean( L, CheckCollisionSpheres( center1, radius1, center2, radius2 ) );
+
+	return 1;
+}
+
+/*
+> collision = RL_CheckCollisionBoxes( BoundingBox box1, BoundingBox box2 )
+
+Check collision between two bounding boxes
+
+- Failure return nil
+- Success return bool
+*/
+int lmodelsCheckCollisionBoxes( lua_State *L ) {
+	if ( !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_CheckCollisionBoxes( BoundingBox box1, BoundingBox box2 )" );
+		lua_pushnil( L );
+		return 1;
+	}
+	BoundingBox box2 = uluaGetBoundingBox( L );
+	lua_pop( L, 1 );
+	BoundingBox box1 = uluaGetBoundingBox( L );
+
+	lua_pushboolean( L, CheckCollisionBoxes( box1, box2 ) );
+
+	return 1;
+}
+
+/*
+> collision = RL_CheckCollisionBoxSphere( BoundingBox box, Vector3 center, float radius )
+
+Check collision between box and sphere
+
+- Failure return nil
+- Success return bool
+*/
+int lmodelsCheckCollisionBoxSphere( lua_State *L ) {
+	if ( !lua_istable( L, -3 ) || !lua_istable( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_CheckCollisionBoxSphere( BoundingBox box, Vector3 center, float radius )" );
+		lua_pushnil( L );
+		return 1;
+	}
+	float radius = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 center = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	BoundingBox box = uluaGetBoundingBox( L );
+
+	lua_pushboolean( L, CheckCollisionBoxSphere( box, center, radius ) );
+
+	return 1;
+}
+
+/*
+> rayCollision = RL_GetRayCollisionSphere( Ray ray, Vector3 center, float radius )
+
+Get collision info between ray and sphere. ( RayCollision is Lua table of { hit, distance, point, normal } )
+
+- Failure return nil
+- Success return RayCollision
+*/
+int lmodelsGetRayCollisionSphere( lua_State *L ) {
+	if ( !lua_istable( L, -3 ) || !lua_istable( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GetRayCollisionSphere( Ray ray, Vector3 center, float radius )" );
+		lua_pushnil( L );
+		return 1;
+	}
+	float radius = lua_tonumber( L, -1 );
+	lua_pop( L, 1 );
+	Vector3 center = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Ray ray = uluaGetRay( L );
+
+	uluaPushRayCollision( L, GetRayCollisionSphere( ray, center, radius ) );
+
+	return 1;
+}
+
+/*
+> rayCollision = RL_GetRayCollisionBox( Ray ray, BoundingBox box )
+
+Get collision info between ray and box
+
+- Failure return nil
+- Success return RayCollision
+*/
+int lmodelsGetRayCollisionBox( lua_State *L ) {
+	if ( !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GetRayCollisionBox( Ray ray, BoundingBox box )" );
+		lua_pushnil( L );
+		return 1;
+	}
+	BoundingBox box = uluaGetBoundingBox( L );
+	lua_pop( L, 1 );
+	Ray ray = uluaGetRay( L );
+
+	uluaPushRayCollision( L, GetRayCollisionBox( ray, box ) );
+
+	return 1;
+}
+
+/*
+> rayCollision = RL_GetRayCollisionModel( Ray ray, Model model )
+
+Get collision info between ray and model
+
+- Failure return nil
+- Success return RayCollision
+*/
+int lmodelsGetRayCollisionModel( lua_State *L ) {
+	if ( !lua_istable( L, -2 ) || !lua_isnumber( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GetRayCollisionModel( Ray ray, Model model )" );
+		lua_pushnil( L );
+		return 1;
+	}
+	size_t modelId = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	Ray ray = uluaGetRay( L );
+
+	if ( !validModel( modelId ) ) {
+		lua_pushnil( L );
+		return 1;
+	}
+	uluaPushRayCollision( L, GetRayCollisionModel( ray, *state->models[ modelId ] ) );
+
+	return 1;
+}
+
+/*
+> rayCollision = RL_GetRayCollisionMesh( Ray ray, Mesh mesh, Matrix transform )
+
+Get collision info between ray and mesh
+
+- Failure return nil
+- Success return RayCollision
+*/
+int lmodelsGetRayCollisionMesh( lua_State *L ) {
+	if ( !lua_istable( L, -3 ) || !lua_isnumber( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GetRayCollisionMesh( Ray ray, Mesh mesh, Matrix transform )" );
+		lua_pushnil( L );
+		return 1;
+	}
+	Matrix transform = uluaGetMatrix( L );
+	lua_pop( L, 1 );
+	size_t meshId = lua_tointeger( L, -1 );
+	lua_pop( L, 1 );
+	Ray ray = uluaGetRay( L );
+
+	if ( !validMesh( meshId ) ) {
+		lua_pushnil( L );
+		return 1;
+	}
+	uluaPushRayCollision( L, GetRayCollisionMesh( ray, *state->meshes[ meshId ], transform ) );
+
+	return 1;
+}
+
+/*
+> rayCollision = RL_GetRayCollisionTriangle( Ray ray, Vector3 p1, Vector3 p2, Vector3 p3 )
+
+Get collision info between ray and triangle
+
+- Failure return nil
+- Success return RayCollision
+*/
+int lmodelsGetRayCollisionTriangle( lua_State *L ) {
+	if ( !lua_istable( L, -4 ) || !lua_istable( L, -3 ) || !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GetRayCollisionTriangle( Ray ray, Vector3 p1, Vector3 p2, Vector3 p3 )" );
+		lua_pushnil( L );
+		return 1;
+	}
+	Vector3 p3 = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 p2 = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 p1 = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Ray ray = uluaGetRay( L );
+
+	uluaPushRayCollision( L, GetRayCollisionTriangle( ray, p1, p2, p3 ) );
+
+	return 1;
+}
+
+/*
+> rayCollision = RL_GetRayCollisionQuad( Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4 )
+
+Get collision info between ray and quad
+
+- Failure return nil
+- Success return RayCollision
+*/
+int lmodelsGetRayCollisionQuad( lua_State *L ) {
+	if ( !lua_istable( L, -5 ) || !lua_istable( L, -4 ) || !lua_istable( L, -3 )
+	|| !lua_istable( L, -2 ) || !lua_istable( L, -1 ) ) {
+		TraceLog( LOG_WARNING, "%s", "Bad call of function. RL_GetRayCollisionQuad( Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4 )" );
+		lua_pushnil( L );
+		return 1;
+	}
+	Vector3 p4 = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 p3 = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 p2 = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Vector3 p1 = uluaGetVector3( L );
+	lua_pop( L, 1 );
+	Ray ray = uluaGetRay( L );
+
+	uluaPushRayCollision( L, GetRayCollisionQuad( ray, p1, p2, p3, p4 ) );
+
+	return 1;
+}
+