Merge branch 'master' into world

CMakeLists.txt

@@ -4,7 +4,7 @@ project(crown)
 
 set (CROWN_VERSION_MAJOR 0)
 set (CROWN_VERSION_MINOR 1)
-set (CROWN_VERSION_MICRO 8)
+set (CROWN_VERSION_MICRO 9)
 
 option (CROWN_BUILD_SAMPLES "Whether to build the samples" ON)
 option (CROWN_BUILD_TOOLS "Whether to build the tools" ON)

engine/Android.mk

@@ -39,7 +39,6 @@ LOCAL_SRC_FILES :=\
 	core/math/Mat4.cpp\
 	core/math/Plane.cpp\
 	core/math/Quat.cpp\
-	core/math/Shape.cpp\
 	core/math/Vec2.cpp\
 	core/math/Vec3.cpp\
 	core/math/Vec4.cpp\

engine/CMakeLists.txt

@@ -70,7 +70,6 @@ set (HEADERS
 	Config.h
 	Crown.h
 	Device.h
-	Glyph.h
 	ConsoleServer.h
 	FPSSystem.h
 )
@@ -121,7 +120,6 @@ set (MATH_SRC
 	core/math/Plane.cpp
 	core/math/Point2.cpp
 	core/math/Quat.cpp
-	core/math/Shape.cpp
 	core/math/Vec2.cpp
 	core/math/Vec3.cpp
 	core/math/Vec4.cpp
@@ -139,7 +137,6 @@ set (MATH_HEADERS
 	core/math/Quat.h
 	core/math/Random.h
 	core/math/Ray.h
-	core/math/Shape.h
 	core/math/Triangle.h
 	core/math/Vec2.h
 	core/math/Vec3.h

engine/Crown.h

@@ -44,7 +44,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "Quat.h"
 #include "Random.h"
 #include "Ray.h"
-#include "Shape.h"
 #include "Triangle.h"
 #include "Vec2.h"
 #include "Vec3.h"
@@ -100,16 +99,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 // Engine
 #include "Camera.h"
 #include "Device.h"
-#include "Glyph.h"
-#include "Bundle.h"
-#include "ArchiveBundle.h"
-#include "FileBundle.h"
-#include "ResourceManager.h"
-#include "TextureResource.h"
-#include "MeshResource.h"
-#include "SoundResource.h"
-#include "MaterialResource.h"
-#include "FontResource.h"
 
 // Engine/Input
 #include "EventDispatcher.h"
@@ -141,3 +130,14 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "DebugRenderer.h"
 #include "PixelFormat.h"
 #include "VertexFormat.h"
+
+// Engine/Resource
+#include "Bundle.h"
+#include "ArchiveBundle.h"
+#include "FileBundle.h"
+#include "ResourceManager.h"
+#include "TextureResource.h"
+#include "MeshResource.h"
+#include "SoundResource.h"
+#include "MaterialResource.h"
+#include "FontResource.h"

engine/Glyph.h

@@ -1,117 +0,0 @@
-/*
-Copyright (c) 2013 Daniele Bartolini, Michele Rossi
-Copyright (c) 2012 Daniele Bartolini, Simone Boscaratto
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#pragma once
-
-#include "Types.h"
-
-namespace crown
-{
-
-class Glyph
-{
-public:
-
-	/// Constructor
-	Glyph() :
-		m_code_point(0),
-		m_left(0),
-		m_right(0),
-		m_bottom(0),
-		m_top(0),
-		m_width(0),
-		m_height(0),
-		m_advance(0),
-		m_baseline(0)
-	{
-	}
-
-	/// Constructor
-	Glyph(uint32_t code, float left, float right, float bottom, float top, float width, float height, float advance, float baseline) :
-		m_code_point(code),
-		m_left(left),
-		m_right(right),
-		m_bottom(bottom),
-		m_top(top),
-		m_width(width),
-		m_height(height),
-		m_advance(advance),
-		m_baseline(baseline)
-	{
-	}
-
-	/// Destructor
-	~Glyph()
-	{
-	}
-
-	/// Returns the glyph's metrics
-	void metrics(float& left, float& right, float& bottom, float& top, float& width, float& height, float& advance, float& baseline) const
-	{
-		left = m_left;
-		right = m_right;
-		bottom = m_bottom;
-		top = m_top;
-		width = m_width;
-		height = m_height;
-		advance = m_advance;
-		baseline = m_baseline;
-	}
-
-	/// Sets the glyph's metrics
-	void set_metrics(float left, float right, float bottom, float top, float width, float height, float advance, float baseline)
-	{
-		m_left = left;
-		m_right = right;
-		m_bottom = bottom;
-		m_top = top;
-		m_width = width;
-		m_height = height;
-		m_advance = advance;
-		m_baseline = baseline;
-	}
-
-	/// Returns the glyph's code point
-	uint32_t code_point() const
-	{
-		return m_code_point;
-	}
-
-private:
-
-	uint32_t m_code_point;
-	float m_left;
-	float m_right;
-	float m_bottom;
-	float m_top;
-	float m_width;
-	float m_height;
-	float m_advance;
-	float m_baseline;
-};
-
-} // namespace crown
-

engine/core/math/Shape.cpp

@@ -1,49 +0,0 @@
-/*
-Copyright (c) 2013 Daniele Bartolini, Michele Rossi
-Copyright (c) 2012 Daniele Bartolini, Simone Boscaratto
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#include "Shape.h"
-
-namespace crown
-{
-
-//-----------------------------------------------------------------------------
-Shape::Shape(ShapeType type):
-	m_type(type)
-{
-}
-
-//-----------------------------------------------------------------------------
-Shape::~Shape()
-{
-}
-
-//-----------------------------------------------------------------------------
-ShapeType Shape::type()
-{
-	return m_type;
-}
-
-}

engine/core/math/Shape.h

@@ -1,65 +0,0 @@
-/*
-Copyright (c) 2013 Daniele Bartolini, Michele Rossi
-Copyright (c) 2012 Daniele Bartolini, Simone Boscaratto
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#pragma once
-
-#include "Plane.h"
-#include "Sphere.h"
-#include "Box.h"
-#include "Ray.h"
-
-namespace crown
-{
-
-enum ShapeType
-{
-	ST_PLANE				= BIT(0),
-	ST_SPHERE				= BIT(1),
-	ST_BOX					= BIT(2),
-	ST_RAY					= BIT(3),
-	ST_CONVEX				= BIT(4)
-//	ST_RECT					= BIT(4),
-//	ST_CIRCLE				= BIT(5),
-//	ST_ORIENTED_RECTANGLE	= BIT(6),
-//	ST_RAY_2D				= BIT(7),
-//	ST_SEGMENT				= BIT(8)
-};
-
-class Shape
-{
-public:
-					Shape(ShapeType type);
-					~Shape();
-
-	ShapeType		type();
-
-private:
-
-	ShapeType		m_type;
-	void*			m_shape;
-};
-
-} // namespace crown

engine/lua/LuaAccelerometer.cpp

@@ -33,7 +33,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t accelerometer_orientation(lua_State* L)
+CE_EXPORT int accelerometer_orientation(lua_State* L)
 {
 	LuaStack stack(L);
 

engine/lua/LuaCamera.cpp

@@ -33,128 +33,128 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera(lua_State* L)
+CE_EXPORT int camera(lua_State* L)
 {
 	LuaStack stack(L);	
 
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_position(lua_State* L)
+CE_EXPORT int camera_position(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_set_position(lua_State* L)
+CE_EXPORT int camera_set_position(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_look_at(lua_State* L)
+CE_EXPORT int camera_look_at(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_set_look_at(lua_State* L)
+CE_EXPORT int camera_set_look_at(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_set_rotation(lua_State* L)
+CE_EXPORT int camera_set_rotation(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_up(lua_State* L)
+CE_EXPORT int camera_up(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_fov(lua_State* L)
+CE_EXPORT int camera_fov(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_set_fov(lua_State* L)
+CE_EXPORT int camera_set_fov(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_aspect(lua_State* L)
+CE_EXPORT int camera_aspect(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_set_aspect(lua_State* L)
+CE_EXPORT int camera_set_aspect(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_near_clip_distance(lua_State* L)
+CE_EXPORT int camera_near_clip_distance(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_set_near_clip_distance(lua_State* L)
+CE_EXPORT int camera_set_near_clip_distance(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_far_clip_distance(lua_State* L)
+CE_EXPORT int camera_far_clip_distance(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_set_far_clip_distance(lua_State* L)
+CE_EXPORT int camera_set_far_clip_distance(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_projection_matrix(lua_State* L)
+CE_EXPORT int camera_projection_matrix(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_view_matrix(lua_State* L)
+CE_EXPORT int camera_view_matrix(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_move_forward(lua_State* L)
+CE_EXPORT int camera_move_forward(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_move_backward(lua_State* L)
+CE_EXPORT int camera_move_backward(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_strafe_left(lua_State* L)
+CE_EXPORT int camera_strafe_left(lua_State* L)
 {
 	LuaStack stack(L);	
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t camera_strafe_right(lua_State* L)
+CE_EXPORT int camera_strafe_right(lua_State* L)
 {
 	LuaStack stack(L);	
 }

engine/lua/LuaDevice.cpp

@@ -32,7 +32,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t device_frame_count(lua_State* L)
+CE_EXPORT int device_frame_count(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -44,7 +44,7 @@ CE_EXPORT int32_t device_frame_count(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t device_last_delta_time(lua_State* L)
+CE_EXPORT int device_last_delta_time(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -56,7 +56,7 @@ CE_EXPORT int32_t device_last_delta_time(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t device_start(lua_State* /*L*/)
+CE_EXPORT int device_start(lua_State* /*L*/)
 {
 	device()->start();
 
@@ -64,7 +64,7 @@ CE_EXPORT int32_t device_start(lua_State* /*L*/)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t device_stop(lua_State* /*L*/)
+CE_EXPORT int device_stop(lua_State* /*L*/)
 {
 	device()->stop();
 

engine/lua/LuaFloatSetting.cpp

@@ -33,7 +33,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t float_setting_value(lua_State* L)
+CE_EXPORT int float_setting_value(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -54,7 +54,7 @@ CE_EXPORT int32_t float_setting_value(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t float_setting_synopsis(lua_State* L)
+CE_EXPORT int float_setting_synopsis(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -75,7 +75,7 @@ CE_EXPORT int32_t float_setting_synopsis(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t float_setting_min(lua_State* L)
+CE_EXPORT int float_setting_min(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -96,7 +96,7 @@ CE_EXPORT int32_t float_setting_min(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t float_setting_max(lua_State* L)
+CE_EXPORT int float_setting_max(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -117,7 +117,7 @@ CE_EXPORT int32_t float_setting_max(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t float_setting_update(lua_State* L)
+CE_EXPORT int float_setting_update(lua_State* L)
 {
 	LuaStack stack(L);
 

engine/lua/LuaIntSetting.cpp

@@ -33,7 +33,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t int_setting_query_value(lua_State* L)
+CE_EXPORT int int_setting_query_value(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -54,7 +54,7 @@ CE_EXPORT int32_t int_setting_query_value(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t int_setting_query_synopsis(lua_State* L)
+CE_EXPORT int int_setting_query_synopsis(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -75,7 +75,7 @@ CE_EXPORT int32_t int_setting_query_synopsis(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t int_setting_query_min(lua_State* L)
+CE_EXPORT int int_setting_query_min(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -96,7 +96,7 @@ CE_EXPORT int32_t int_setting_query_min(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t int_setting_query_max(lua_State* L)
+CE_EXPORT int int_setting_query_max(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -117,7 +117,7 @@ CE_EXPORT int32_t int_setting_query_max(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t int_setting_update(lua_State* L)
+CE_EXPORT int int_setting_update(lua_State* L)
 {
 	LuaStack stack(L);
 

engine/lua/LuaKeyboard.cpp

@@ -33,7 +33,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t keyboard_modifier_pressed(lua_State* L)
+CE_EXPORT int keyboard_modifier_pressed(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -45,7 +45,7 @@ CE_EXPORT int32_t keyboard_modifier_pressed(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t keyboard_key_pressed(lua_State* L)
+CE_EXPORT int keyboard_key_pressed(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -57,7 +57,7 @@ CE_EXPORT int32_t keyboard_key_pressed(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t keyboard_key_released(lua_State* L)
+CE_EXPORT int keyboard_key_released(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -69,7 +69,7 @@ CE_EXPORT int32_t keyboard_key_released(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t keyboard_any_pressed(lua_State* L)
+CE_EXPORT int keyboard_any_pressed(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -79,7 +79,7 @@ CE_EXPORT int32_t keyboard_any_pressed(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t keyboard_any_released(lua_State* L)
+CE_EXPORT int keyboard_any_released(lua_State* L)
 {
 	LuaStack stack(L);
 

engine/lua/LuaMat4.cpp

@@ -34,7 +34,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4(lua_State* L)
+CE_EXPORT int mat4(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -61,7 +61,7 @@ CE_EXPORT int32_t mat4(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------					
-CE_EXPORT int32_t mat4_add(lua_State* L)
+CE_EXPORT int mat4_add(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -74,7 +74,7 @@ CE_EXPORT int32_t mat4_add(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_subtract(lua_State* L)
+CE_EXPORT int mat4_subtract(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -87,7 +87,7 @@ CE_EXPORT int32_t mat4_subtract(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_multiply(lua_State* L)
+CE_EXPORT int mat4_multiply(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -100,7 +100,7 @@ CE_EXPORT int32_t mat4_multiply(lua_State* L)
 }	
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_multiply_by_scalar(lua_State* L)
+CE_EXPORT int mat4_multiply_by_scalar(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -113,7 +113,7 @@ CE_EXPORT int32_t mat4_multiply_by_scalar(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_divide_by_scalar(lua_State* L)
+CE_EXPORT int mat4_divide_by_scalar(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -126,7 +126,7 @@ CE_EXPORT int32_t mat4_divide_by_scalar(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_rotation_x(lua_State* L)
+CE_EXPORT int mat4_build_rotation_x(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -139,7 +139,7 @@ CE_EXPORT int32_t mat4_build_rotation_x(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_rotation_y(lua_State* L)
+CE_EXPORT int mat4_build_rotation_y(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -152,7 +152,7 @@ CE_EXPORT int32_t mat4_build_rotation_y(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_rotation_z(lua_State* L)
+CE_EXPORT int mat4_build_rotation_z(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -165,7 +165,7 @@ CE_EXPORT int32_t mat4_build_rotation_z(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_rotation(lua_State* L)
+CE_EXPORT int mat4_build_rotation(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -179,7 +179,7 @@ CE_EXPORT int32_t mat4_build_rotation(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_projection_perspective_rh(lua_State* L)
+CE_EXPORT int mat4_build_projection_perspective_rh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -195,7 +195,7 @@ CE_EXPORT int32_t mat4_build_projection_perspective_rh(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_projection_perspective_lh(lua_State* L)
+CE_EXPORT int mat4_build_projection_perspective_lh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -211,7 +211,7 @@ CE_EXPORT int32_t mat4_build_projection_perspective_lh(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_projection_ortho_rh(lua_State* L)
+CE_EXPORT int mat4_build_projection_ortho_rh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -227,7 +227,7 @@ CE_EXPORT int32_t mat4_build_projection_ortho_rh(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_projection_ortho_lh(lua_State* L)
+CE_EXPORT int mat4_build_projection_ortho_lh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -243,7 +243,7 @@ CE_EXPORT int32_t mat4_build_projection_ortho_lh(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_projection_ortho_2d_rh(lua_State* L)
+CE_EXPORT int mat4_build_projection_ortho_2d_rh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -259,7 +259,7 @@ CE_EXPORT int32_t mat4_build_projection_ortho_2d_rh(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_look_at_rh(lua_State* L)
+CE_EXPORT int mat4_build_look_at_rh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -274,7 +274,7 @@ CE_EXPORT int32_t mat4_build_look_at_rh(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_look_at_lh(lua_State* L)
+CE_EXPORT int mat4_build_look_at_lh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -289,7 +289,7 @@ CE_EXPORT int32_t mat4_build_look_at_lh(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_viewpoint_billboard(lua_State* L)
+CE_EXPORT int mat4_build_viewpoint_billboard(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -304,7 +304,7 @@ CE_EXPORT int32_t mat4_build_viewpoint_billboard(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_build_axis_billboard(lua_State* L)
+CE_EXPORT int mat4_build_axis_billboard(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -319,7 +319,7 @@ CE_EXPORT int32_t mat4_build_axis_billboard(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_transpose(lua_State* L)
+CE_EXPORT int mat4_transpose(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -331,7 +331,7 @@ CE_EXPORT int32_t mat4_transpose(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_determinant(lua_State* L)
+CE_EXPORT int mat4_determinant(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -343,7 +343,7 @@ CE_EXPORT int32_t mat4_determinant(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_invert(lua_State* L)
+CE_EXPORT int mat4_invert(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -355,7 +355,7 @@ CE_EXPORT int32_t mat4_invert(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_load_identity(lua_State* L)
+CE_EXPORT int mat4_load_identity(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -367,7 +367,7 @@ CE_EXPORT int32_t mat4_load_identity(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_x(lua_State* L)
+CE_EXPORT int mat4_x(lua_State* L)
 {	
 	LuaStack stack(L);
 
@@ -379,7 +379,7 @@ CE_EXPORT int32_t mat4_x(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_y(lua_State* L)
+CE_EXPORT int mat4_y(lua_State* L)
 {	
 	LuaStack stack(L);
 
@@ -391,7 +391,7 @@ CE_EXPORT int32_t mat4_y(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_z(lua_State* L)
+CE_EXPORT int mat4_z(lua_State* L)
 {	
 	LuaStack stack(L);
 
@@ -403,7 +403,7 @@ CE_EXPORT int32_t mat4_z(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_set_x(lua_State* L)
+CE_EXPORT int mat4_set_x(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -416,7 +416,7 @@ CE_EXPORT int32_t mat4_set_x(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_set_y(lua_State* L)
+CE_EXPORT int mat4_set_y(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -429,7 +429,7 @@ CE_EXPORT int32_t mat4_set_y(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_set_z(lua_State* L)
+CE_EXPORT int mat4_set_z(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -442,7 +442,7 @@ CE_EXPORT int32_t mat4_set_z(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_translation(lua_State* L)
+CE_EXPORT int mat4_translation(lua_State* L)
 {	
 	LuaStack stack(L);
 
@@ -454,7 +454,7 @@ CE_EXPORT int32_t mat4_translation(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_set_translation(lua_State* L)
+CE_EXPORT int mat4_set_translation(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -467,7 +467,7 @@ CE_EXPORT int32_t mat4_set_translation(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_get_scale(lua_State* L)
+CE_EXPORT int mat4_get_scale(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -479,7 +479,7 @@ CE_EXPORT int32_t mat4_get_scale(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_set_scale(lua_State* L)
+CE_EXPORT int mat4_set_scale(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -492,7 +492,7 @@ CE_EXPORT int32_t mat4_set_scale(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mat4_print(lua_State* L)
+CE_EXPORT int mat4_print(lua_State* L)
 {
 	LuaStack stack(L);
 

engine/lua/LuaMath.cpp

@@ -32,7 +32,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_deg_to_rad(lua_State* L)
+CE_EXPORT int math_deg_to_rad(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -44,7 +44,7 @@ CE_EXPORT int32_t math_deg_to_rad(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_rad_to_deg(lua_State* L)
+CE_EXPORT int math_rad_to_deg(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -56,7 +56,7 @@ CE_EXPORT int32_t math_rad_to_deg(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_next_pow_2(lua_State* L)
+CE_EXPORT int math_next_pow_2(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -68,7 +68,7 @@ CE_EXPORT int32_t math_next_pow_2(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_is_pow_2(lua_State* L)
+CE_EXPORT int math_is_pow_2(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -80,7 +80,7 @@ CE_EXPORT int32_t math_is_pow_2(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_ceil(lua_State* L)
+CE_EXPORT int math_ceil(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -92,7 +92,7 @@ CE_EXPORT int32_t math_ceil(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_floor(lua_State* L)
+CE_EXPORT int math_floor(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -104,7 +104,7 @@ CE_EXPORT int32_t math_floor(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_sqrt(lua_State* L)
+CE_EXPORT int math_sqrt(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -116,7 +116,7 @@ CE_EXPORT int32_t math_sqrt(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_inv_sqrt(lua_State* L)
+CE_EXPORT int math_inv_sqrt(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -128,7 +128,7 @@ CE_EXPORT int32_t math_inv_sqrt(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_sin(lua_State* L)
+CE_EXPORT int math_sin(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -140,7 +140,7 @@ CE_EXPORT int32_t math_sin(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_cos(lua_State* L)
+CE_EXPORT int math_cos(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -152,7 +152,7 @@ CE_EXPORT int32_t math_cos(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_asin(lua_State* L)
+CE_EXPORT int math_asin(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -164,7 +164,7 @@ CE_EXPORT int32_t math_asin(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_acos(lua_State* L)
+CE_EXPORT int math_acos(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -176,7 +176,7 @@ CE_EXPORT int32_t math_acos(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_tan(lua_State* L)
+CE_EXPORT int math_tan(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -188,7 +188,7 @@ CE_EXPORT int32_t math_tan(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_atan2(lua_State* L)
+CE_EXPORT int math_atan2(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -201,7 +201,7 @@ CE_EXPORT int32_t math_atan2(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_abs(lua_State* L)
+CE_EXPORT int math_abs(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -213,7 +213,7 @@ CE_EXPORT int32_t math_abs(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t math_fmod(lua_State* L)
+CE_EXPORT int math_fmod(lua_State* L)
 {
 	LuaStack stack(L);
 

engine/lua/LuaMouse.cpp

@@ -34,7 +34,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mouse_button_pressed(lua_State* L)
+CE_EXPORT int mouse_button_pressed(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -46,7 +46,7 @@ CE_EXPORT int32_t mouse_button_pressed(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mouse_button_released(lua_State* L)
+CE_EXPORT int mouse_button_released(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -58,7 +58,7 @@ CE_EXPORT int32_t mouse_button_released(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mouse_any_pressed(lua_State* L)
+CE_EXPORT int mouse_any_pressed(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -68,7 +68,7 @@ CE_EXPORT int32_t mouse_any_pressed(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mouse_any_released(lua_State* L)
+CE_EXPORT int mouse_any_released(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -78,7 +78,7 @@ CE_EXPORT int32_t mouse_any_released(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mouse_cursor_xy(lua_State* L)
+CE_EXPORT int mouse_cursor_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -88,7 +88,7 @@ CE_EXPORT int32_t mouse_cursor_xy(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mouse_set_cursor_xy(lua_State* L)
+CE_EXPORT int mouse_set_cursor_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -100,7 +100,7 @@ CE_EXPORT int32_t mouse_set_cursor_xy(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mouse_cursor_relative_xy(lua_State* L)
+CE_EXPORT int mouse_cursor_relative_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -110,7 +110,7 @@ CE_EXPORT int32_t mouse_cursor_relative_xy(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t mouse_set_cursor_relative_xy(lua_State* L)
+CE_EXPORT int mouse_set_cursor_relative_xy(lua_State* L)
 {
 	LuaStack stack(L);
 

engine/lua/LuaQuat.cpp

@@ -34,7 +34,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t quat(lua_State* L)
+CE_EXPORT int quat(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -47,7 +47,7 @@ CE_EXPORT int32_t quat(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t quat_negate(lua_State* L)
+CE_EXPORT int quat_negate(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -59,7 +59,7 @@ CE_EXPORT int32_t quat_negate(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t quat_load_identity(lua_State* L)
+CE_EXPORT int quat_load_identity(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -71,7 +71,7 @@ CE_EXPORT int32_t quat_load_identity(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t quat_length(lua_State* L)
+CE_EXPORT int quat_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -83,7 +83,7 @@ CE_EXPORT int32_t quat_length(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t quat_conjugate(lua_State* L)
+CE_EXPORT int quat_conjugate(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -95,7 +95,7 @@ CE_EXPORT int32_t quat_conjugate(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t quat_inverse(lua_State* L)
+CE_EXPORT int quat_inverse(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -107,7 +107,7 @@ CE_EXPORT int32_t quat_inverse(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t quat_cross(lua_State* L)
+CE_EXPORT int quat_cross(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -120,7 +120,7 @@ CE_EXPORT int32_t quat_cross(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t quat_multiply(lua_State* L)
+CE_EXPORT int quat_multiply(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -133,7 +133,7 @@ CE_EXPORT int32_t quat_multiply(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t quat_power(lua_State* L)
+CE_EXPORT int quat_power(lua_State* L)
 {
 	LuaStack stack(L);
 

engine/lua/LuaStack.cpp

@@ -206,71 +206,59 @@ const char* LuaStack::get_string(int32_t index)
 //-----------------------------------------------------------------------------
 void* LuaStack::get_lightdata(int32_t index)
 {
-	CE_ASSERT(lua_islightuserdata(m_state, index), "Not a lightuserdata object");
-
-	void* data = lua_touserdata(m_state, index);
-
-	return data;	
+	return lua_touserdata(m_state, index);	
 }
 
 //-----------------------------------------------------------------------------
 Vec2& LuaStack::get_vec2(int32_t index)
 {
-	CE_ASSERT(lua_islightuserdata(m_state, index), "Not a lightuserdata object");
-
-	Vec2* v = (Vec2*)lua_touserdata(m_state, index);
+	void* v = lua_touserdata(m_state, index);
 
 	if (v < &vec2_buffer[0] || v > &vec2_buffer[LUA_VEC2_BUFFER_SIZE-1])
 	{
 		luaL_typerror(m_state, index, "Vec2");
 	}
 
-	return *v;
+	return *(Vec2*)v;
 }
 
 //-----------------------------------------------------------------------------
 Vec3& LuaStack::get_vec3(int32_t index)
 {
-	CE_ASSERT(lua_islightuserdata(m_state, index), "Not a lightuserdata object");
-
-	Vec3* v = (Vec3*)lua_touserdata(m_state, index);
+	void* v = lua_touserdata(m_state, index);
 
 	if (v < &vec3_buffer[0] || v > &vec3_buffer[LUA_VEC3_BUFFER_SIZE-1])
 	{
 		luaL_typerror(m_state, index, "Vec3");
 	}
 
-	return *v;
+	return *(Vec3*)v;
 }
 
 //-----------------------------------------------------------------------------
 Mat4& LuaStack::get_mat4(int32_t index)
 {
-	CE_ASSERT(lua_islightuserdata(m_state, index), "Not a lightuserdata object");
-
-	Mat4* m = (Mat4*)lua_touserdata(m_state, index);
+	void* m = lua_touserdata(m_state, index);
 
 	if (m < &mat4_buffer[0] || m > &mat4_buffer[LUA_MAT4_BUFFER_SIZE-1])
 	{
 		luaL_typerror(m_state, index, "Mat4");
 	}
 
-	return *m;
+	return *(Mat4*)m;
 }
 
 //-----------------------------------------------------------------------------
 Quat& LuaStack::get_quat(int32_t index)
 {
-	CE_ASSERT(lua_islightuserdata(m_state, index), "Not a lightuserdata object");
-
-	Quat* q = (Quat*)lua_touserdata(m_state, index);
+	void* q = lua_touserdata(m_state, index);
 
 	if (q < &quat_buffer[0] || q > &quat_buffer[LUA_QUAT_BUFFER_SIZE-1])
 	{
 		luaL_typerror(m_state, index, "Quat");
 	}
 
-	return *q;
+	return *(Quat*)q;
 }
 
 //-----------------------------------------------------------------------------

engine/lua/LuaStringSetting.cpp

@@ -33,7 +33,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t string_setting_value(lua_State* L)
+CE_EXPORT int string_setting_value(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -54,7 +54,7 @@ CE_EXPORT int32_t string_setting_value(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t string_setting_synopsis(lua_State* L)
+CE_EXPORT int string_setting_synopsis(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -75,7 +75,7 @@ CE_EXPORT int32_t string_setting_synopsis(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t string_setting_update(lua_State* L)
+CE_EXPORT int string_setting_update(lua_State* L)
 {
 	LuaStack stack(L);
 

engine/lua/LuaVec2.cpp

@@ -32,7 +32,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2(lua_State* L)
+CE_EXPORT int vec2(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -45,7 +45,7 @@ CE_EXPORT int32_t vec2(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_values(lua_State* L)
+CE_EXPORT int vec2_values(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -58,7 +58,7 @@ CE_EXPORT int32_t vec2_values(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_add(lua_State* L)
+CE_EXPORT int vec2_add(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -71,7 +71,7 @@ CE_EXPORT int32_t vec2_add(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_subtract(lua_State* L)
+CE_EXPORT int vec2_subtract(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -84,7 +84,7 @@ CE_EXPORT int32_t vec2_subtract(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_multiply(lua_State* L)
+CE_EXPORT int vec2_multiply(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -97,7 +97,7 @@ CE_EXPORT int32_t vec2_multiply(lua_State* L)
 }			
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_divide(lua_State* L)
+CE_EXPORT int vec2_divide(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -110,7 +110,7 @@ CE_EXPORT int32_t vec2_divide(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_dot(lua_State* L)
+CE_EXPORT int vec2_dot(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -123,7 +123,7 @@ CE_EXPORT int32_t vec2_dot(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_equals(lua_State* L)
+CE_EXPORT int vec2_equals(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -136,7 +136,7 @@ CE_EXPORT int32_t vec2_equals(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_lower(lua_State* L)
+CE_EXPORT int vec2_lower(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -149,7 +149,7 @@ CE_EXPORT int32_t vec2_lower(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_greater(lua_State* L)
+CE_EXPORT int vec2_greater(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -162,7 +162,7 @@ CE_EXPORT int32_t vec2_greater(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_length(lua_State* L)
+CE_EXPORT int vec2_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -174,7 +174,7 @@ CE_EXPORT int32_t vec2_length(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_squared_length(lua_State* L)
+CE_EXPORT int vec2_squared_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -186,7 +186,7 @@ CE_EXPORT int32_t vec2_squared_length(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_set_length(lua_State* L)
+CE_EXPORT int vec2_set_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -199,7 +199,7 @@ CE_EXPORT int32_t vec2_set_length(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_normalize(lua_State* L)
+CE_EXPORT int vec2_normalize(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -211,7 +211,7 @@ CE_EXPORT int32_t vec2_normalize(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_negate(lua_State* L)
+CE_EXPORT int vec2_negate(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -223,7 +223,7 @@ CE_EXPORT int32_t vec2_negate(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_get_distance_to(lua_State* L)
+CE_EXPORT int vec2_get_distance_to(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -236,7 +236,7 @@ CE_EXPORT int32_t vec2_get_distance_to(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_get_angle_between(lua_State* L)
+CE_EXPORT int vec2_get_angle_between(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -249,7 +249,7 @@ CE_EXPORT int32_t vec2_get_angle_between(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec2_zero(lua_State* L)
+CE_EXPORT int vec2_zero(lua_State* L)
 {
 	LuaStack stack(L);
 

engine/lua/LuaVec3.cpp

@@ -32,7 +32,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3(lua_State* L)
+CE_EXPORT int vec3(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -46,7 +46,7 @@ CE_EXPORT int32_t vec3(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_values(lua_State* L)
+CE_EXPORT int vec3_values(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -60,7 +60,7 @@ CE_EXPORT int32_t vec3_values(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_add(lua_State* L)
+CE_EXPORT int vec3_add(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -73,7 +73,7 @@ CE_EXPORT int32_t vec3_add(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_subtract(lua_State* L)
+CE_EXPORT int vec3_subtract(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -86,7 +86,7 @@ CE_EXPORT int32_t vec3_subtract(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_multiply(lua_State* L)
+CE_EXPORT int vec3_multiply(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -99,7 +99,7 @@ CE_EXPORT int32_t vec3_multiply(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_divide(lua_State* L)
+CE_EXPORT int vec3_divide(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -112,7 +112,7 @@ CE_EXPORT int32_t vec3_divide(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_dot(lua_State* L)
+CE_EXPORT int vec3_dot(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -125,7 +125,7 @@ CE_EXPORT int32_t vec3_dot(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_cross(lua_State* L)
+CE_EXPORT int vec3_cross(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -138,7 +138,7 @@ CE_EXPORT int32_t vec3_cross(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_equals(lua_State* L)
+CE_EXPORT int vec3_equals(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -151,7 +151,7 @@ CE_EXPORT int32_t vec3_equals(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_lower(lua_State* L)
+CE_EXPORT int vec3_lower(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -164,7 +164,7 @@ CE_EXPORT int32_t vec3_lower(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_greater(lua_State* L)
+CE_EXPORT int vec3_greater(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -177,7 +177,7 @@ CE_EXPORT int32_t vec3_greater(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_length(lua_State* L)
+CE_EXPORT int vec3_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -189,7 +189,7 @@ CE_EXPORT int32_t vec3_length(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_squared_length(lua_State* L)
+CE_EXPORT int vec3_squared_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -201,7 +201,7 @@ CE_EXPORT int32_t vec3_squared_length(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_set_length(lua_State* L)
+CE_EXPORT int vec3_set_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -214,7 +214,7 @@ CE_EXPORT int32_t vec3_set_length(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_normalize(lua_State* L)
+CE_EXPORT int vec3_normalize(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -226,7 +226,7 @@ CE_EXPORT int32_t vec3_normalize(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_negate(lua_State* L)
+CE_EXPORT int vec3_negate(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -238,7 +238,7 @@ CE_EXPORT int32_t vec3_negate(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_get_distance_to(lua_State* L)
+CE_EXPORT int vec3_get_distance_to(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -251,7 +251,7 @@ CE_EXPORT int32_t vec3_get_distance_to(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_get_angle_between(lua_State* L)
+CE_EXPORT int vec3_get_angle_between(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -264,7 +264,7 @@ CE_EXPORT int32_t vec3_get_angle_between(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t vec3_zero(lua_State* L)
+CE_EXPORT int vec3_zero(lua_State* L)
 {
 	LuaStack stack(L);
 

engine/lua/LuaWindow.cpp

@@ -34,7 +34,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t window_show(lua_State* L)
+CE_EXPORT int window_show(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -44,7 +44,7 @@ CE_EXPORT int32_t window_show(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t window_hide(lua_State* L)
+CE_EXPORT int window_hide(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -54,7 +54,7 @@ CE_EXPORT int32_t window_hide(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t window_get_size(lua_State* L)
+CE_EXPORT int window_get_size(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -69,7 +69,7 @@ CE_EXPORT int32_t window_get_size(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t window_get_position(lua_State* L)
+CE_EXPORT int window_get_position(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -84,7 +84,7 @@ CE_EXPORT int32_t window_get_position(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t window_resize(lua_State* L)
+CE_EXPORT int window_resize(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -97,7 +97,7 @@ CE_EXPORT int32_t window_resize(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t window_move(lua_State* L)
+CE_EXPORT int window_move(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -110,7 +110,7 @@ CE_EXPORT int32_t window_move(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t window_show_cursor(lua_State* L)
+CE_EXPORT int window_show_cursor(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -120,7 +120,7 @@ CE_EXPORT int32_t window_show_cursor(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t window_hide_cursor(lua_State* L)
+CE_EXPORT int window_hide_cursor(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -130,7 +130,7 @@ CE_EXPORT int32_t window_hide_cursor(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t window_get_cursor_xy(lua_State* L)
+CE_EXPORT int window_get_cursor_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -145,7 +145,7 @@ CE_EXPORT int32_t window_get_cursor_xy(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t window_set_cursor_xy(lua_State* L)
+CE_EXPORT int window_set_cursor_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -158,7 +158,7 @@ CE_EXPORT int32_t window_set_cursor_xy(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t window_title(lua_State* L)
+CE_EXPORT int window_title(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -170,7 +170,7 @@ CE_EXPORT int32_t window_title(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-CE_EXPORT int32_t window_set_title(lua_State* L)
+CE_EXPORT int window_set_title(lua_State* L)
 {
 	LuaStack stack(L);
 

engine/resource/FontResource.h

@@ -27,7 +27,6 @@ OTHER DEALINGS IN THE SOFTWARE.
 #pragma once
 
 #include "Types.h"
-#include "Glyph.h"
 #include "Resource.h"
 
 namespace crown