Cleanup

engine/lua/lua_actor.cpp

@@ -35,8 +35,7 @@ namespace crown
 static int actor_world_position(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-	stack.push_vector3(actor->world_position());
+	stack.push_vector3(stack.get_actor(1)->world_position());
 	return 1;
 }
 
@@ -44,8 +43,7 @@ static int actor_world_position(lua_State* L)
 static int actor_world_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-	stack.push_quaternion(actor->world_rotation());
+	stack.push_quaternion(stack.get_actor(1)->world_rotation());
 	return 1;
 }
 
@@ -53,8 +51,7 @@ static int actor_world_rotation(lua_State* L)
 static int actor_world_pose(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-	stack.push_matrix4x4(actor->world_pose());
+	stack.push_matrix4x4(stack.get_actor(1)->world_pose());
 	return 1;
 }
 
@@ -62,9 +59,7 @@ static int actor_world_pose(lua_State* L)
 static int actor_teleport_world_position(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-	const Vector3& pos = stack.get_vector3(2);
-	actor->teleport_world_position(pos);
+	stack.get_actor(1)->teleport_world_position(stack.get_vector3(2));
 	return 0;
 }
 
@@ -72,9 +67,7 @@ static int actor_teleport_world_position(lua_State* L)
 static int actor_teleport_world_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-	const Quaternion& rot = stack.get_quaternion(2);
-	actor->teleport_world_rotation(rot);
+	stack.get_actor(1)->teleport_world_rotation(stack.get_quaternion(2));
 	return 0;
 }
 
@@ -82,9 +75,7 @@ static int actor_teleport_world_rotation(lua_State* L)
 static int actor_teleport_world_pose(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-	const Matrix4x4& mat = stack.get_matrix4x4(2);
-	actor->teleport_world_pose(mat);
+	stack.get_actor(1)->teleport_world_pose(stack.get_matrix4x4(2));
 	return 0;
 }
 
@@ -92,8 +83,7 @@ static int actor_teleport_world_pose(lua_State* L)
 static int actor_center_of_mass(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-	stack.push_vector3(actor->center_of_mass());
+	stack.push_vector3(stack.get_actor(1)->center_of_mass());
 	return 1;
 }
 
@@ -101,10 +91,7 @@ static int actor_center_of_mass(lua_State* L)
 static int actor_enable_gravity(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-
-	actor->enable_gravity();
-
+	stack.get_actor(1)->enable_gravity();
 	return 0;
 }
 
@@ -112,9 +99,7 @@ static int actor_enable_gravity(lua_State* L)
 static int actor_disable_gravity(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-
-	actor->disable_gravity();
+	stack.get_actor(1)->disable_gravity();
 	return 0;
 }
 
@@ -122,10 +107,7 @@ static int actor_disable_gravity(lua_State* L)
 static int actor_enable_collision(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-
-	actor->enable_collision();
-
+	stack.get_actor(1)->enable_collision();
 	return 0;
 }
 
@@ -133,10 +115,7 @@ static int actor_enable_collision(lua_State* L)
 static int actor_disable_collision(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-
-	actor->disable_collision();
-
+	stack.get_actor(1)->disable_collision();
 	return 0;
 }
 
@@ -144,8 +123,7 @@ static int actor_disable_collision(lua_State* L)
 static int actor_set_collision_filter(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-	actor->set_collision_filter(stack.get_string(2));
+	stack.get_actor(1)->set_collision_filter(stack.get_string(2));
 	return 0;
 }
 
@@ -153,8 +131,7 @@ static int actor_set_collision_filter(lua_State* L)
 static int actor_set_kinematic(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-	actor->set_kinematic(stack.get_bool(2));
+	stack.get_actor(1)->set_kinematic(stack.get_bool(2));
 	return 0;
 }
 
@@ -162,11 +139,7 @@ static int actor_set_kinematic(lua_State* L)
 static int actor_move(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-	Vector3 pos = stack.get_vector3(2);
-
-	actor->move(pos);
-
+	stack.get_actor(1)->move(stack.get_vector3(2));
 	return 0;
 }
 
@@ -174,10 +147,7 @@ static int actor_move(lua_State* L)
 static int actor_is_static(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-
-	stack.push_bool(actor->is_static());
+	stack.push_bool(stack.get_actor(1)->is_static());
 	return 1;
 }
 
@@ -185,10 +155,7 @@ static int actor_is_static(lua_State* L)
 static int actor_is_dynamic(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-
-	stack.push_bool(actor->is_dynamic());
+	stack.push_bool(stack.get_actor(1)->is_dynamic());
 	return 1;
 }
 
@@ -196,10 +163,7 @@ static int actor_is_dynamic(lua_State* L)
 static int actor_is_kinematic(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-
-	stack.push_bool(actor->is_kinematic());
+	stack.push_bool(stack.get_actor(1)->is_kinematic());
 	return 1;
 }
 
@@ -207,10 +171,7 @@ static int actor_is_kinematic(lua_State* L)
 static int actor_is_nonkinematic(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-
-	stack.push_bool(actor->is_nonkinematic());
+	stack.push_bool(stack.get_actor(1)->is_nonkinematic());
 	return 1;
 }
 
@@ -219,10 +180,7 @@ static int actor_is_nonkinematic(lua_State* L)
 static int actor_linear_damping(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-
-	stack.push_float(actor->linear_damping());
+	stack.push_float(stack.get_actor(1)->linear_damping());
 	return 1;
 }
 
@@ -230,11 +188,7 @@ static int actor_linear_damping(lua_State* L)
 static int actor_set_linear_damping(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-	const float rate = stack.get_float(2);
-
-	actor->set_linear_damping(rate);
+	stack.get_actor(1)->set_linear_damping(stack.get_float(2));
 	return 0;
 }
 
@@ -242,10 +196,7 @@ static int actor_set_linear_damping(lua_State* L)
 static int actor_angular_damping(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-
-	stack.push_float(actor->angular_damping());
+	stack.push_float(stack.get_actor(1)->angular_damping());
 	return 1;
 }
 
@@ -253,11 +204,7 @@ static int actor_angular_damping(lua_State* L)
 static int actor_set_angular_damping(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-	const float rate = stack.get_float(2);
-
-	actor->set_angular_damping(rate);
+	stack.get_actor(1)->set_angular_damping(stack.get_float(2));
 	return 0;
 }
 
@@ -265,10 +212,7 @@ static int actor_set_angular_damping(lua_State* L)
 static int actor_linear_velocity(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-
-	stack.push_vector3(actor->linear_velocity());
+	stack.push_vector3(stack.get_actor(1)->linear_velocity());
 	return 1;
 }
 
@@ -276,11 +220,7 @@ static int actor_linear_velocity(lua_State* L)
 static int actor_set_linear_velocity(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-	const Vector3& vel = stack.get_vector3(2);
-
-	actor->set_linear_velocity(vel);
+	stack.get_actor(1)->set_linear_velocity(stack.get_vector3(2));
 	return 0;
 }
 
@@ -288,10 +228,7 @@ static int actor_set_linear_velocity(lua_State* L)
 static int actor_angular_velocity(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-
-	stack.push_vector3(actor->angular_velocity());
+	stack.push_vector3(stack.get_actor(1)->angular_velocity());
 	return 1;
 }
 
@@ -299,11 +236,7 @@ static int actor_angular_velocity(lua_State* L)
 static int actor_set_angular_velocity(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-	const Vector3& vel = stack.get_vector3(2);
-
-	actor->set_angular_velocity(vel);
+	stack.get_actor(1)->set_angular_velocity(stack.get_vector3(2));
 	return 0;
 }
 
@@ -311,12 +244,7 @@ static int actor_set_angular_velocity(lua_State* L)
 static int actor_add_impulse(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-	const Vector3& impulse = stack.get_vector3(2);
-
-	actor->add_impulse(impulse);
-
+	stack.get_actor(1)->add_impulse(stack.get_vector3(2));
 	return 0;
 }
 
@@ -324,13 +252,7 @@ static int actor_add_impulse(lua_State* L)
 static int actor_add_impulse_at(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-	const Vector3& impulse = stack.get_vector3(2);
-	const Vector3& pos = stack.get_vector3(3);
-
-	actor->add_impulse_at(impulse, pos);
-
+	stack.get_actor(1)->add_impulse_at(stack.get_vector3(2), stack.get_vector3(3));
 	return 0;
 }
 
@@ -338,8 +260,7 @@ static int actor_add_impulse_at(lua_State* L)
 static int actor_add_torque_impulse(lua_State* L)
 {
 	LuaStack stack(L);
-	Actor* actor = stack.get_actor(1);
-	actor->add_torque_impulse(stack.get_vector3(2));
+	stack.get_actor(1)->add_torque_impulse(stack.get_vector3(2));
 	return 0;
 }
 
@@ -347,13 +268,7 @@ static int actor_add_torque_impulse(lua_State* L)
 static int actor_push(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-	const Vector3& vel = stack.get_vector3(2);
-	const float mass = stack.get_float(3);
-
-	actor->push(vel, mass);
-
+	stack.get_actor(1)->push(stack.get_vector3(2), stack.get_float(3));
 	return 0;
 }
 
@@ -361,9 +276,7 @@ static int actor_push(lua_State* L)
 static int actor_push_at(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-	actor->push_at(stack.get_vector3(2), stack.get_float(2), stack.get_vector3(3));
+	stack.get_actor(1)->push_at(stack.get_vector3(2), stack.get_float(2), stack.get_vector3(3));
 	return 0;
 }
 
@@ -371,10 +284,7 @@ static int actor_push_at(lua_State* L)
 static int actor_is_sleeping(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-
-	stack.push_bool(actor->is_sleeping());
+	stack.push_bool(stack.get_actor(1)->is_sleeping());
 	return 1;
 }
 
@@ -382,10 +292,7 @@ static int actor_is_sleeping(lua_State* L)
 static int actor_wake_up(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-
-	actor->wake_up();
+	stack.get_actor(1)->wake_up();
 	return 0;
 }
 
@@ -393,11 +300,7 @@ static int actor_wake_up(lua_State* L)
 static int actor_unit(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Actor* actor = stack.get_actor(1);
-
-	Unit* unit = actor->unit();
-
+	Unit* unit = stack.get_actor(1)->unit();
 	unit == NULL ? stack.push_nil() : stack.push_unit(unit);
 	return 1;
 }
@@ -405,40 +308,40 @@ static int actor_unit(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_actor(LuaEnvironment& env)
 {
-	env.load_module_function("Actor", "world_position", 			actor_world_position);
-	env.load_module_function("Actor", "world_rotation", 			actor_world_rotation);
-	env.load_module_function("Actor", "world_pose", 				actor_world_pose);
-	env.load_module_function("Actor", "teleport_world_position",	actor_teleport_world_position);
-	env.load_module_function("Actor", "teleport_world_rotation",	actor_teleport_world_rotation);
-	env.load_module_function("Actor", "teleport_world_pose",		actor_teleport_world_pose);
-	env.load_module_function("Actor", "center_of_mass",				actor_center_of_mass);
-	env.load_module_function("Actor", "enable_gravity",				actor_enable_gravity);
-	env.load_module_function("Actor", "disable_gravity",			actor_disable_gravity);
-	env.load_module_function("Actor", "enable_collision",			actor_enable_collision);
-	env.load_module_function("Actor", "set_collision_filter",		actor_set_collision_filter);
-	env.load_module_function("Actor", "disable_collision",			actor_disable_collision);
-	env.load_module_function("Actor", "set_kinematic",				actor_set_kinematic);
-	env.load_module_function("Actor", "move",						actor_move);
-	env.load_module_function("Actor", "is_static",					actor_is_static);
-	env.load_module_function("Actor", "is_dynamic",					actor_is_dynamic);
-	env.load_module_function("Actor", "is_kinematic",				actor_is_kinematic);
-	env.load_module_function("Actor", "is_nonkinematic",			actor_is_nonkinematic);
-	env.load_module_function("Actor", "linear_damping",				actor_linear_damping);
-	env.load_module_function("Actor", "set_linear_damping",			actor_set_linear_damping);
-	env.load_module_function("Actor", "angular_damping",			actor_angular_damping);
-	env.load_module_function("Actor", "set_angular_damping",		actor_set_angular_damping);
-	env.load_module_function("Actor", "linear_velocity",			actor_linear_velocity);
-	env.load_module_function("Actor", "set_linear_velocity",		actor_set_linear_velocity);
-	env.load_module_function("Actor", "angular_velocity",			actor_angular_velocity);
-	env.load_module_function("Actor", "set_angular_velocity",		actor_set_angular_velocity);
-	env.load_module_function("Actor", "add_impulse",				actor_add_impulse);
-	env.load_module_function("Actor", "add_impulse_at",				actor_add_impulse_at);
-	env.load_module_function("Actor", "add_torque_impulse",			actor_add_torque_impulse);
-	env.load_module_function("Actor", "push",						actor_push);
-	env.load_module_function("Actor", "push_at",					actor_push_at);
-	env.load_module_function("Actor", "is_sleeping",				actor_is_sleeping);
-	env.load_module_function("Actor", "wake_up",					actor_wake_up);
-	env.load_module_function("Actor", "unit",						actor_unit);
+	env.load_module_function("Actor", "world_position",          actor_world_position);
+	env.load_module_function("Actor", "world_rotation",          actor_world_rotation);
+	env.load_module_function("Actor", "world_pose",              actor_world_pose);
+	env.load_module_function("Actor", "teleport_world_position", actor_teleport_world_position);
+	env.load_module_function("Actor", "teleport_world_rotation", actor_teleport_world_rotation);
+	env.load_module_function("Actor", "teleport_world_pose",     actor_teleport_world_pose);
+	env.load_module_function("Actor", "center_of_mass",          actor_center_of_mass);
+	env.load_module_function("Actor", "enable_gravity",          actor_enable_gravity);
+	env.load_module_function("Actor", "disable_gravity",         actor_disable_gravity);
+	env.load_module_function("Actor", "enable_collision",        actor_enable_collision);
+	env.load_module_function("Actor", "disable_collision",       actor_disable_collision);
+	env.load_module_function("Actor", "set_collision_filter",    actor_set_collision_filter);
+	env.load_module_function("Actor", "set_kinematic",           actor_set_kinematic);
+	env.load_module_function("Actor", "move",                    actor_move);
+	env.load_module_function("Actor", "is_static",               actor_is_static);
+	env.load_module_function("Actor", "is_dynamic",              actor_is_dynamic);
+	env.load_module_function("Actor", "is_kinematic",            actor_is_kinematic);
+	env.load_module_function("Actor", "is_nonkinematic",         actor_is_nonkinematic);
+	env.load_module_function("Actor", "linear_damping",          actor_linear_damping);
+	env.load_module_function("Actor", "set_linear_damping",      actor_set_linear_damping);
+	env.load_module_function("Actor", "angular_damping",         actor_angular_damping);
+	env.load_module_function("Actor", "set_angular_damping",     actor_set_angular_damping);
+	env.load_module_function("Actor", "linear_velocity",         actor_linear_velocity);
+	env.load_module_function("Actor", "set_linear_velocity",     actor_set_linear_velocity);
+	env.load_module_function("Actor", "angular_velocity",        actor_angular_velocity);
+	env.load_module_function("Actor", "set_angular_velocity",    actor_set_angular_velocity);
+	env.load_module_function("Actor", "add_impulse",             actor_add_impulse);
+	env.load_module_function("Actor", "add_impulse_at",          actor_add_impulse_at);
+	env.load_module_function("Actor", "add_torque_impulse",      actor_add_torque_impulse);
+	env.load_module_function("Actor", "push",                    actor_push);
+	env.load_module_function("Actor", "push_at",                 actor_push_at);
+	env.load_module_function("Actor", "is_sleeping",             actor_is_sleeping);
+	env.load_module_function("Actor", "wake_up",                 actor_wake_up);
+	env.load_module_function("Actor", "unit",                    actor_unit);
 }
 
 } // namespace crown

engine/lua/lua_camera.cpp

@@ -38,10 +38,7 @@ namespace crown
 static int camera_local_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-
-	stack.push_vector3(camera->local_position());
+	stack.push_vector3(stack.get_camera(1)->local_position());
 	return 1;
 }
 
@@ -49,10 +46,7 @@ static int camera_local_position(lua_State* L)
 static int camera_local_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-
-	stack.push_quaternion(camera->local_rotation());
+	stack.push_quaternion(stack.get_camera(1)->local_rotation());
 	return 1;
 }
 
@@ -60,10 +54,7 @@ static int camera_local_rotation(lua_State* L)
 static int camera_local_pose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-
-	stack.push_matrix4x4(camera->local_pose());
+	stack.push_matrix4x4(stack.get_camera(1)->local_pose());
 	return 1;
 }
 
@@ -71,10 +62,7 @@ static int camera_local_pose(lua_State* L)
 static int camera_world_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-
-	stack.push_vector3(camera->world_position());
+	stack.push_vector3(stack.get_camera(1)->world_position());
 	return 1;
 }
 
@@ -82,10 +70,7 @@ static int camera_world_position(lua_State* L)
 static int camera_world_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-
-	stack.push_quaternion(camera->world_rotation());
+	stack.push_quaternion(stack.get_camera(1)->world_rotation());
 	return 1;
 }
 
@@ -93,10 +78,7 @@ static int camera_world_rotation(lua_State* L)
 static int camera_world_pose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-
-	stack.push_matrix4x4(camera->world_pose());
+	stack.push_matrix4x4(stack.get_camera(1)->world_pose());
 	return 1;
 }
 
@@ -104,12 +86,7 @@ static int camera_world_pose(lua_State* L)
 static int camera_set_local_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-	Unit* unit = stack.get_unit(2);
-	const Vector3 pos = stack.get_vector3(3);
-
-	camera->set_local_position(unit, pos);
+	stack.get_camera(1)->set_local_position(stack.get_unit(2), stack.get_vector3(3));
 	return 0;
 }
 
@@ -117,12 +94,7 @@ static int camera_set_local_position(lua_State* L)
 static int camera_set_local_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-	Unit* unit = stack.get_unit(2);
-	const Quaternion rot = stack.get_quaternion(3);
-
-	camera->set_local_rotation(unit, rot);
+	stack.get_camera(1)->set_local_rotation(stack.get_unit(2), stack.get_quaternion(3));
 	return 0;
 }
 
@@ -130,12 +102,7 @@ static int camera_set_local_rotation(lua_State* L)
 static int camera_set_local_pose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-	Unit* unit = stack.get_unit(2);
-	const Matrix4x4 pose = stack.get_matrix4x4(3);
-
-	camera->set_local_pose(unit, pose);
+	stack.get_camera(1)->set_local_pose(stack.get_unit(2), stack.get_matrix4x4(3));
 	return 0;
 }
 
@@ -143,11 +110,7 @@ static int camera_set_local_pose(lua_State* L)
 static int camera_set_projection_type(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-	ProjectionType::Enum proj_type = (ProjectionType::Enum) stack.get_int(2);
-
-	camera->set_projection_type(proj_type);
+	stack.get_camera(1)->set_projection_type((ProjectionType::Enum) stack.get_int(2));
 	return 0;
 }
 
@@ -155,10 +118,7 @@ static int camera_set_projection_type(lua_State* L)
 static int camera_projection_type(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-
-	stack.push_uint32(camera->projection_type());
+	stack.push_uint32(stack.get_camera(1)->projection_type());
 	return 1;
 }
 
@@ -166,10 +126,7 @@ static int camera_projection_type(lua_State* L)
 static int camera_fov(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-
-	stack.push_float(camera->fov());
+	stack.push_float(stack.get_camera(1)->fov());
 	return 1;
 }
 
@@ -177,11 +134,7 @@ static int camera_fov(lua_State* L)
 static int camera_set_fov(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-	const float fov = stack.get_float(2);
-
-	camera->set_fov(fov);
+	stack.get_camera(1)->set_fov(stack.get_float(2));
 	return 0;
 }
 
@@ -189,10 +142,7 @@ static int camera_set_fov(lua_State* L)
 static int camera_aspect(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-
-	stack.push_float(camera->aspect());
+	stack.push_float(stack.get_camera(1)->aspect());
 	return 1;
 }
 
@@ -200,11 +150,7 @@ static int camera_aspect(lua_State* L)
 static int camera_set_aspect(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-	const float aspect = stack.get_float(2);
-
-	camera->set_aspect(aspect);
+	stack.get_camera(1)->set_aspect(stack.get_float(2));
 	return 0;
 }
 
@@ -212,10 +158,7 @@ static int camera_set_aspect(lua_State* L)
 static int camera_near_clip_distance(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-
-	stack.push_float(camera->near_clip_distance());
+	stack.push_float(stack.get_camera(1)->near_clip_distance());
 	return 1;
 }
 
@@ -223,11 +166,7 @@ static int camera_near_clip_distance(lua_State* L)
 static int camera_set_near_clip_distance(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-	const float near = stack.get_float(2);
-
-	camera->set_near_clip_distance(near);
+	stack.get_camera(1)->set_near_clip_distance(stack.get_float(2));
 	return 0;
 }
 
@@ -235,10 +174,7 @@ static int camera_set_near_clip_distance(lua_State* L)
 static int camera_far_clip_distance(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-
-	stack.push_float(camera->far_clip_distance());
+	stack.push_float(stack.get_camera(1)->far_clip_distance());
 	return 1;
 }
 
@@ -246,11 +182,7 @@ static int camera_far_clip_distance(lua_State* L)
 static int camera_set_far_clip_distance(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-	const float far = stack.get_float(2);
-
-	camera->set_far_clip_distance(far);
+	stack.get_camera(1)->set_far_clip_distance(stack.get_float(2));
 	return 0;
 }
 
@@ -258,14 +190,8 @@ static int camera_set_far_clip_distance(lua_State* L)
 static int camera_set_orthographic_metrics(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-	const float left = stack.get_float(2);
-	const float right = stack.get_float(3);
-	const float bottom = stack.get_float(4);
-	const float top = stack.get_float(5);
-
-	camera->set_orthographic_metrics(left, right, bottom, top);
+	stack.get_camera(1)->set_orthographic_metrics(stack.get_float(2), stack.get_float(3),
+		stack.get_float(4), stack.get_float(5));
 	return 0;
 }
 
@@ -273,14 +199,8 @@ static int camera_set_orthographic_metrics(lua_State* L)
 static int camera_set_viewport_metrics(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-	const int16_t x = stack.get_int(2);
-	const int16_t y = stack.get_int(3);
-	const int16_t width = stack.get_int(4);
-	const int16_t height = stack.get_int(5);
-
-	camera->set_viewport_metrics(x, y, width, height);
+	stack.get_camera(1)->set_viewport_metrics(stack.get_int(2), stack.get_int(3),
+		stack.get_int(4), stack.get_int(5));
 	return 0;
 }
 
@@ -288,11 +208,7 @@ static int camera_set_viewport_metrics(lua_State* L)
 static int camera_screen_to_world(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-	const Vector3 pos = stack.get_vector3(2);
-
-	stack.push_vector3(camera->screen_to_world(pos));
+	stack.push_vector3(stack.get_camera(1)->screen_to_world(stack.get_vector3(2)));
 	return 1;
 }
 
@@ -300,43 +216,39 @@ static int camera_screen_to_world(lua_State* L)
 static int camera_world_to_screen(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Camera* camera = stack.get_camera(1);
-	const Vector3 pos = stack.get_vector3(2);
-
-	stack.push_vector3(camera->world_to_screen(pos));
+	stack.push_vector3(stack.get_camera(1)->world_to_screen(stack.get_vector3(2)));
 	return 1;
 }
 
 //-----------------------------------------------------------------------------
 void load_camera(LuaEnvironment& env)
 {
-	env.load_module_function("Camera", "local_position",            camera_local_position);
-	env.load_module_function("Camera", "local_rotation",            camera_local_rotation);
-	env.load_module_function("Camera", "local_pose",                camera_local_pose);
-	env.load_module_function("Camera", "world_position",            camera_world_position);
-	env.load_module_function("Camera", "world_rotation",            camera_world_rotation);
-	env.load_module_function("Camera", "world_pose",                camera_world_pose);
-	env.load_module_function("Camera", "set_local_position",        camera_set_local_position);
-	env.load_module_function("Camera", "set_local_rotation",        camera_set_local_rotation);
-	env.load_module_function("Camera", "set_local_pose",            camera_set_local_pose);
-	env.load_module_function("Camera", "set_projection_type",       camera_set_projection_type);
-	env.load_module_function("Camera", "projection_type",           camera_projection_type);
-	env.load_module_function("Camera", "fov",                       camera_fov);
-	env.load_module_function("Camera", "set_fov",                   camera_set_fov);
-	env.load_module_function("Camera", "aspect",                    camera_aspect);
-	env.load_module_function("Camera", "set_aspect",                camera_set_aspect);
-	env.load_module_function("Camera", "near_clip_distance",        camera_near_clip_distance);
-	env.load_module_function("Camera", "set_near_clip_distance",    camera_set_near_clip_distance);
-	env.load_module_function("Camera", "far_clip_distance",         camera_far_clip_distance);
-	env.load_module_function("Camera", "set_far_clip_distance",     camera_set_far_clip_distance);
-	env.load_module_function("Camera", "set_orthographic_metrics",  camera_set_orthographic_metrics);
-	env.load_module_function("Camera", "set_viewport_metrics",      camera_set_viewport_metrics);
-	env.load_module_function("Camera", "screen_to_world",  			camera_screen_to_world);
-	env.load_module_function("Camera", "world_to_screen",  			camera_world_to_screen);
-
+	env.load_module_function("Camera", "local_position",           camera_local_position);
+	env.load_module_function("Camera", "local_rotation",           camera_local_rotation);
+	env.load_module_function("Camera", "local_pose",               camera_local_pose);
+	env.load_module_function("Camera", "world_position",           camera_world_position);
+	env.load_module_function("Camera", "world_rotation",           camera_world_rotation);
+	env.load_module_function("Camera", "world_pose",               camera_world_pose);
+	env.load_module_function("Camera", "set_local_position",       camera_set_local_position);
+	env.load_module_function("Camera", "set_local_rotation",       camera_set_local_rotation);
+	env.load_module_function("Camera", "set_local_pose",           camera_set_local_pose);
+	env.load_module_function("Camera", "set_projection_type",      camera_set_projection_type);
+	env.load_module_function("Camera", "projection_type",          camera_projection_type);
+	env.load_module_function("Camera", "fov",                      camera_fov);
+	env.load_module_function("Camera", "set_fov",                  camera_set_fov);
+	env.load_module_function("Camera", "aspect",                   camera_aspect);
+	env.load_module_function("Camera", "set_aspect",               camera_set_aspect);
+	env.load_module_function("Camera", "near_clip_distance",       camera_near_clip_distance);
+	env.load_module_function("Camera", "set_near_clip_distance",   camera_set_near_clip_distance);
+	env.load_module_function("Camera", "far_clip_distance",        camera_far_clip_distance);
+	env.load_module_function("Camera", "set_far_clip_distance",    camera_set_far_clip_distance);
+	env.load_module_function("Camera", "set_orthographic_metrics", camera_set_orthographic_metrics);
+	env.load_module_function("Camera", "set_viewport_metrics",     camera_set_viewport_metrics);
+	env.load_module_function("Camera", "screen_to_world",          camera_screen_to_world);
+	env.load_module_function("Camera", "world_to_screen",          camera_world_to_screen);
+	
 	env.load_module_enum("Camera", "ORTHOGRAPHIC", ProjectionType::ORTHOGRAPHIC);
-	env.load_module_enum("Camera", "PERSPECTIVE", ProjectionType::PERSPECTIVE);
+	env.load_module_enum("Camera", "PERSPECTIVE",  ProjectionType::PERSPECTIVE);
 }
 
 } // namespace crown

engine/lua/lua_color4.cpp

@@ -35,13 +35,10 @@ namespace crown
 static int color4_new(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const float r = stack.get_float(1);
-	const float g = stack.get_float(2);
-	const float b = stack.get_float(3);
-	const float a = stack.get_float(4);
-
-	stack.push_quaternion(Quaternion(r, g, b, a));
+	stack.push_quaternion(Quaternion(stack.get_float(1),
+							stack.get_float(2),
+							stack.get_float(3),
+							stack.get_float(4)));
 	return 1;
 }
 
@@ -57,7 +54,7 @@ static int color4_ctor(lua_State* L)
 void load_color4(LuaEnvironment& env)
 {
 	env.load_module_function("Color4", "new", color4_new);
-	env.load_module_constructor("Color4", color4_ctor);
+	env.load_module_constructor("Color4",     color4_ctor);
 }
 
 } // namespace crown

engine/lua/lua_controller.cpp

@@ -36,11 +36,7 @@ namespace crown
 static int controller_move(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Controller* controller = stack.get_controller(1);
-	const Vector3& pos = stack.get_vector3(2);
-
-	controller->move(pos);
+	stack.get_controller(1)->move(stack.get_vector3(2));
 	return 0;
 }
 
@@ -48,10 +44,7 @@ static int controller_move(lua_State* L)
 static int controller_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Controller* controller = stack.get_controller(1);
-
-	stack.push_vector3(controller->position());
+	stack.push_vector3(stack.get_controller(1)->position());
 	return 1;
 }
 
@@ -59,10 +52,7 @@ static int controller_position(lua_State* L)
 static int controller_collides_up(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Controller* controller = stack.get_controller(1);
-
-	stack.push_bool(controller->collides_up());
+	stack.push_bool(stack.get_controller(1)->collides_up());
 	return 1;
 }
 
@@ -70,10 +60,7 @@ static int controller_collides_up(lua_State* L)
 static int controller_collides_down(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Controller* controller = stack.get_controller(1);
-
-	stack.push_bool(controller->collides_down());
+	stack.push_bool(stack.get_controller(1)->collides_down());
 	return 1;
 }
 
@@ -81,10 +68,7 @@ static int controller_collides_down(lua_State* L)
 static int controller_collides_sides(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Controller* controller = stack.get_controller(1);
-
-	stack.push_bool(controller->collides_sides());
+	stack.push_bool(stack.get_controller(1)->collides_sides());
 	return 1;
 }
 

engine/lua/lua_debug_line.cpp

@@ -37,12 +37,7 @@ namespace crown
 static int debug_line_add_line(lua_State* L)
 {
 	LuaStack stack(L);
-
-	DebugLine* line = stack.get_debug_line(1);
-	const Vector3& start = stack.get_vector3(2);
-	const Vector3& end = stack.get_vector3(3);
-
-	line->add_line(Color4::RED, start, end);
+	stack.get_debug_line(1)->add_line(Color4::RED, stack.get_vector3(2), stack.get_vector3(3));
 	return 0;
 }
 
@@ -50,12 +45,7 @@ static int debug_line_add_line(lua_State* L)
 static int debug_line_add_sphere(lua_State* L)
 {
 	LuaStack stack(L);
-
-	DebugLine* line = stack.get_debug_line(1);
-	const Vector3& center = stack.get_vector3(2);
-	const float radius = stack.get_float(3);
-
-	line->add_sphere(Color4::RED, center, radius);
+	stack.get_debug_line(1)->add_sphere(Color4::RED, stack.get_vector3(2), stack.get_float(3));
 	return 0;
 }
 
@@ -63,9 +53,7 @@ static int debug_line_add_sphere(lua_State* L)
 static int debug_line_clear(lua_State* L)
 {
 	LuaStack stack(L);
-
-	DebugLine* line = stack.get_debug_line(1);
-	line->clear();
+	stack.get_debug_line(1)->clear();
 	return 0;
 }
 
@@ -73,9 +61,7 @@ static int debug_line_clear(lua_State* L)
 static int debug_line_commit(lua_State* L)
 {
 	LuaStack stack(L);
-
-	DebugLine* line = stack.get_debug_line(1);
-	line->commit();
+	stack.get_debug_line(1)->commit();
 	return 0;
 }
 
@@ -83,20 +69,19 @@ static int debug_line_commit(lua_State* L)
 static int debug_line_tostring(lua_State* L)
 {
 	LuaStack stack(L);
-	DebugLine* dl = stack.get_debug_line(1);
-	stack.push_fstring("DebugLine (%p)", dl);
+	stack.push_fstring("DebugLine (%p)", stack.get_debug_line(1));
 	return 1;
 }
 
 //-----------------------------------------------------------------------------
 void load_debug_line(LuaEnvironment& env)
 {
-	env.load_module_function("DebugLine", "add_line",    debug_line_add_line);
-	env.load_module_function("DebugLine", "add_sphere",  debug_line_add_sphere);
-	env.load_module_function("DebugLine", "clear",       debug_line_clear);
-	env.load_module_function("DebugLine", "commit",      debug_line_commit);
-	env.load_module_function("DebugLine", "__index",	 "DebugLine");
-	env.load_module_function("DebugLine", "__tostring",  debug_line_tostring);
+	env.load_module_function("DebugLine", "add_line",   debug_line_add_line);
+	env.load_module_function("DebugLine", "add_sphere", debug_line_add_sphere);
+	env.load_module_function("DebugLine", "clear",      debug_line_clear);
+	env.load_module_function("DebugLine", "commit",     debug_line_commit);
+	env.load_module_function("DebugLine", "__index",    "DebugLine");
+	env.load_module_function("DebugLine", "__tostring", debug_line_tostring);
 }
 
 } // namespace crown

engine/lua/lua_device.cpp

@@ -64,11 +64,7 @@ static int device_version(lua_State* L)
 static int device_last_delta_time(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float delta = device()->last_delta_time();
-
-	stack.push_float(delta);
-
+	stack.push_float(device()->last_delta_time());
 	return 1;
 }
 
@@ -111,11 +107,7 @@ static int device_destroy_world(lua_State* L)
 static int device_render_world(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-	Camera* camera = stack.get_camera(2);
-
-	device()->render_world(world, camera);
+	device()->render_world(stack.get_world(1), stack.get_camera(2));
 	return 0;
 }
 
@@ -123,10 +115,7 @@ static int device_render_world(lua_State* L)
 static int device_create_resource_package(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const char* package = stack.get_string(1);
-	stack.push_resource_package(device()->create_resource_package(package));
-
+	stack.push_resource_package(device()->create_resource_package(stack.get_string(1)));
 	return 1;
 }
 
@@ -134,10 +123,7 @@ static int device_create_resource_package(lua_State* L)
 static int device_destroy_resource_package(lua_State* L)
 {
 	LuaStack stack(L);
-
-	ResourcePackage* package = stack.get_resource_package(1);
-	device()->destroy_resource_package(package);
-
+	device()->destroy_resource_package(stack.get_resource_package(1));
 	return 0;
 }
 

engine/lua/lua_float_setting.cpp

@@ -136,11 +136,11 @@ static int float_setting_update(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_float_setting(LuaEnvironment& env)
 {
-	env.load_module_function("FloatSetting", "value",		float_setting_value);
-	env.load_module_function("FloatSetting", "synopsis",	float_setting_synopsis);
-	env.load_module_function("FloatSetting", "min",			float_setting_min);
-	env.load_module_function("FloatSetting", "max",			float_setting_max);
-	env.load_module_function("FloatSetting", "update",		float_setting_update);
+	env.load_module_function("FloatSetting", "value",    float_setting_value);
+	env.load_module_function("FloatSetting", "synopsis", float_setting_synopsis);
+	env.load_module_function("FloatSetting", "min",      float_setting_min);
+	env.load_module_function("FloatSetting", "max",      float_setting_max);
+	env.load_module_function("FloatSetting", "update",   float_setting_update);
 }
 
 } // namespace crown

engine/lua/lua_gui.cpp

@@ -41,13 +41,9 @@ namespace crown
 static int gui_resolution(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Gui* gui = stack.get_gui(1);
-	const Vector2 resolution = gui->resolution();
-
+	const Vector2 resolution = stack.get_gui(1)->resolution();
 	stack.push_int32((uint32_t)resolution.x);
 	stack.push_int32((uint32_t)resolution.y);
-
 	return 2;
 }
 
@@ -55,9 +51,7 @@ static int gui_resolution(lua_State* L)
 static int gui_move(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Gui* gui = stack.get_gui(1);
-	gui->move(stack.get_vector2(2));
+	stack.get_gui(1)->move(stack.get_vector2(2));
 	return 0;
 }
 
@@ -65,9 +59,7 @@ static int gui_move(lua_State* L)
 static int gui_screen_to_gui(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Gui* gui = stack.get_gui(1);
-	stack.push_vector2(gui->screen_to_gui(stack.get_vector2(2)));
+	stack.push_vector2(stack.get_gui(1)->screen_to_gui(stack.get_vector2(2)));
 	return 1;
 }
 
@@ -75,9 +67,8 @@ static int gui_screen_to_gui(lua_State* L)
 static int gui_draw_rectangle(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Gui* gui = stack.get_gui(1);
-	gui->draw_rectangle(stack.get_vector3(2), stack.get_vector2(3), stack.get_color4(4));
+	stack.get_gui(1)->draw_rectangle(stack.get_vector3(2), stack.get_vector2(3),
+		stack.get_color4(4));
 	return 0;
 }
 
@@ -85,9 +76,8 @@ static int gui_draw_rectangle(lua_State* L)
 static int gui_draw_image(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Gui* gui = stack.get_gui(1);
-	gui->draw_image(stack.get_string(2), stack.get_vector3(3), stack.get_vector2(4), stack.get_color4(5));
+	stack.get_gui(1)->draw_image(stack.get_string(2), stack.get_vector3(3),
+		stack.get_vector2(4), stack.get_color4(5));
 	return 0;
 }
 
@@ -95,9 +85,8 @@ static int gui_draw_image(lua_State* L)
 static int gui_draw_image_uv(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Gui* gui = stack.get_gui(1);
-	gui->draw_image_uv(stack.get_string(2), stack.get_vector3(3), stack.get_vector2(4), stack.get_vector2(5), stack.get_vector2(6), stack.get_color4(7));
+	stack.get_gui(1)->draw_image_uv(stack.get_string(2), stack.get_vector3(3),
+		stack.get_vector2(4), stack.get_vector2(5), stack.get_vector2(6), stack.get_color4(7));
 	return 0;
 }
 
@@ -105,23 +94,21 @@ static int gui_draw_image_uv(lua_State* L)
 static int gui_draw_text(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Gui* gui = stack.get_gui(1);
-	gui->draw_text(stack.get_string(2), stack.get_string(3), stack.get_int(4), stack.get_vector3(5), stack.get_color4(6));
+	stack.get_gui(1)->draw_text(stack.get_string(2), stack.get_string(3), stack.get_int(4),
+		stack.get_vector3(5), stack.get_color4(6));
 	return 0;
 }
 
 //-----------------------------------------------------------------------------
 void load_gui(LuaEnvironment& env)
 {
-	env.load_module_function("Gui", "resolution",		gui_resolution);
-	env.load_module_function("Gui", "move",				gui_move);
-	env.load_module_function("Gui", "screen_to_gui",	gui_screen_to_gui);
-
-	env.load_module_function("Gui", "draw_rectangle",	gui_draw_rectangle);
-	env.load_module_function("Gui", "draw_image",		gui_draw_image);
-	env.load_module_function("Gui", "draw_image_uv",	gui_draw_image_uv);
-	env.load_module_function("Gui", "draw_text",		gui_draw_text);
+	env.load_module_function("Gui", "resolution",     gui_resolution);
+	env.load_module_function("Gui", "move",           gui_move);
+	env.load_module_function("Gui", "screen_to_gui",  gui_screen_to_gui);
+	env.load_module_function("Gui", "draw_rectangle", gui_draw_rectangle);
+	env.load_module_function("Gui", "draw_image",     gui_draw_image);
+	env.load_module_function("Gui", "draw_image_uv",  gui_draw_image_uv);
+	env.load_module_function("Gui", "draw_text",      gui_draw_text);
 }
 
 } // namespace crown

engine/lua/lua_int_setting.cpp

@@ -136,11 +136,11 @@ static int int_setting_update(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_int_setting(LuaEnvironment& env)
 {
-	env.load_module_function("IntSetting", "value",		int_setting_query_value);
-	env.load_module_function("IntSetting", "synopsis",	int_setting_query_synopsis);
-	env.load_module_function("IntSetting", "min",		int_setting_query_min);
-	env.load_module_function("IntSetting", "max",		int_setting_query_max);
-	env.load_module_function("IntSetting", "update",	int_setting_update);
+	env.load_module_function("IntSetting", "value",    int_setting_query_value);
+	env.load_module_function("IntSetting", "synopsis", int_setting_query_synopsis);
+	env.load_module_function("IntSetting", "min",      int_setting_query_min);
+	env.load_module_function("IntSetting", "max",      int_setting_query_max);
+	env.load_module_function("IntSetting", "update",   int_setting_update);
 }
 
 } // namespace crown

engine/lua/lua_keyboard.cpp

@@ -77,103 +77,91 @@ static int keyboard_any_released(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_keyboard(LuaEnvironment& env)
 {
-	env.load_module_function("Keyboard", "modifier_pressed",	keyboard_modifier_pressed);
-	env.load_module_function("Keyboard", "button_pressed",		keyboard_button_pressed);
-	env.load_module_function("Keyboard", "button_released",		keyboard_button_released);
-	env.load_module_function("Keyboard", "any_pressed",			keyboard_any_pressed);
-	env.load_module_function("Keyboard", "any_released",		keyboard_any_released);
-
-	env.load_module_enum("Keyboard", "TAB",			KeyboardButton::TAB);
-	env.load_module_enum("Keyboard", "ENTER",		KeyboardButton::ENTER);
-	env.load_module_enum("Keyboard", "ESCAPE",		KeyboardButton::ESCAPE);
-	env.load_module_enum("Keyboard", "SPACE",		KeyboardButton::SPACE);
-	env.load_module_enum("Keyboard", "BACKSPACE",	KeyboardButton::BACKSPACE);
-
-	/* KeyPad */
-	env.load_module_enum("Keyboard", "KP_0",		KeyboardButton::KP_0);
-	env.load_module_enum("Keyboard", "KP_1",		KeyboardButton::KP_1);
-	env.load_module_enum("Keyboard", "KP_2",		KeyboardButton::KP_2);
-	env.load_module_enum("Keyboard", "KP_3",		KeyboardButton::KP_3);
-	env.load_module_enum("Keyboard", "KP_4",		KeyboardButton::KP_4);
-	env.load_module_enum("Keyboard", "KP_5",		KeyboardButton::KP_5);
-	env.load_module_enum("Keyboard", "KP_6",		KeyboardButton::KP_6);
-	env.load_module_enum("Keyboard", "KP_7",		KeyboardButton::KP_7);
-	env.load_module_enum("Keyboard", "KP_8",		KeyboardButton::KP_8);
-	env.load_module_enum("Keyboard", "KP_9",		KeyboardButton::KP_9);
-
-	/* Function keys */
-	env.load_module_enum("Keyboard", "F1",			KeyboardButton::F1);
-	env.load_module_enum("Keyboard", "F2",			KeyboardButton::F2);
-	env.load_module_enum("Keyboard", "F3",			KeyboardButton::F3);
-	env.load_module_enum("Keyboard", "F4",			KeyboardButton::F4);
-	env.load_module_enum("Keyboard", "F5",			KeyboardButton::F5);
-	env.load_module_enum("Keyboard", "F6",			KeyboardButton::F6);
-	env.load_module_enum("Keyboard", "F7",			KeyboardButton::F7);
-	env.load_module_enum("Keyboard", "F8",			KeyboardButton::F8);
-	env.load_module_enum("Keyboard", "F9",			KeyboardButton::F9);
-	env.load_module_enum("Keyboard", "F10",			KeyboardButton::F10);
-	env.load_module_enum("Keyboard", "F11",			KeyboardButton::F11);
-	env.load_module_enum("Keyboard", "F12",			KeyboardButton::F12);
-
-	/* Other keys */
-	env.load_module_enum("Keyboard", "HOME",		KeyboardButton::HOME);
-	env.load_module_enum("Keyboard", "LEFT",		KeyboardButton::LEFT);
-	env.load_module_enum("Keyboard", "UP",			KeyboardButton::UP);
-	env.load_module_enum("Keyboard", "RIGHT",		KeyboardButton::RIGHT);
-	env.load_module_enum("Keyboard", "DOWN",		KeyboardButton::DOWN);
-	env.load_module_enum("Keyboard", "PAGE_UP",		KeyboardButton::PAGE_UP);
-	env.load_module_enum("Keyboard", "PAGE_DOWN",	KeyboardButton::PAGE_DOWN);
-
-	/* Modifier keys */
-	env.load_module_enum("Keyboard", "LCONTROL",	KeyboardButton::LCONTROL);
-	env.load_module_enum("Keyboard", "RCONTROL",	KeyboardButton::RCONTROL);
-	env.load_module_enum("Keyboard", "LSHIFT",		KeyboardButton::LSHIFT);
-	env.load_module_enum("Keyboard", "RSHIFT",		KeyboardButton::RSHIFT);
-	env.load_module_enum("Keyboard", "CAPS_LOCK",	KeyboardButton::CAPS_LOCK);
-	env.load_module_enum("Keyboard", "LALT",		KeyboardButton::LALT);
-	env.load_module_enum("Keyboard", "RALT",		KeyboardButton::RALT);
-	env.load_module_enum("Keyboard", "LSUPER",		KeyboardButton::LSUPER);
-	env.load_module_enum("Keyboard", "RSUPER",		KeyboardButton::RSUPER);
-
-	/* [0x30, 0x39] reserved for ASCII digits */
-	env.load_module_enum("Keyboard", "NUM_0",		KeyboardButton::NUM_0);
-	env.load_module_enum("Keyboard", "NUM_1",		KeyboardButton::NUM_1);
-	env.load_module_enum("Keyboard", "NUM_2",		KeyboardButton::NUM_2);
-	env.load_module_enum("Keyboard", "NUM_3",		KeyboardButton::NUM_3);
-	env.load_module_enum("Keyboard", "NUM_4",		KeyboardButton::NUM_4);
-	env.load_module_enum("Keyboard", "NUM_5",		KeyboardButton::NUM_5);
-	env.load_module_enum("Keyboard", "NUM_6",		KeyboardButton::NUM_6);
-	env.load_module_enum("Keyboard", "NUM_7",		KeyboardButton::NUM_7);
-	env.load_module_enum("Keyboard", "NUM_8",		KeyboardButton::NUM_8);
-	env.load_module_enum("Keyboard", "NUM_9",		KeyboardButton::NUM_9);
-
-	/* [0x41, 0x5A] reserved for ASCII alph,abet */
-	env.load_module_enum("Keyboard", "A",			KeyboardButton::A);
-	env.load_module_enum("Keyboard", "B",			KeyboardButton::B);
-	env.load_module_enum("Keyboard", "C",			KeyboardButton::C);
-	env.load_module_enum("Keyboard", "D",			KeyboardButton::D);
-	env.load_module_enum("Keyboard", "E",			KeyboardButton::E);
-	env.load_module_enum("Keyboard", "F",			KeyboardButton::F);
-	env.load_module_enum("Keyboard", "G",			KeyboardButton::G);
-	env.load_module_enum("Keyboard", "H",			KeyboardButton::H);
-	env.load_module_enum("Keyboard", "I",			KeyboardButton::I);
-	env.load_module_enum("Keyboard", "J",			KeyboardButton::J);
-	env.load_module_enum("Keyboard", "K",			KeyboardButton::K);
-	env.load_module_enum("Keyboard", "L",			KeyboardButton::L);
-	env.load_module_enum("Keyboard", "M",			KeyboardButton::M);
-	env.load_module_enum("Keyboard", "N",			KeyboardButton::N);
-	env.load_module_enum("Keyboard", "O",			KeyboardButton::O);
-	env.load_module_enum("Keyboard", "P",			KeyboardButton::P);
-	env.load_module_enum("Keyboard", "Q",			KeyboardButton::Q);
-	env.load_module_enum("Keyboard", "R",			KeyboardButton::R);
-	env.load_module_enum("Keyboard", "S",			KeyboardButton::S);
-	env.load_module_enum("Keyboard", "T",			KeyboardButton::T);
-	env.load_module_enum("Keyboard", "U",			KeyboardButton::U);
-	env.load_module_enum("Keyboard", "V",			KeyboardButton::V);
-	env.load_module_enum("Keyboard", "W",			KeyboardButton::W);
-	env.load_module_enum("Keyboard", "X",			KeyboardButton::X);
-	env.load_module_enum("Keyboard", "Y",			KeyboardButton::Y);
-	env.load_module_enum("Keyboard", "Z",			KeyboardButton::Z);
+	env.load_module_function("Keyboard", "modifier_pressed", keyboard_modifier_pressed);
+	env.load_module_function("Keyboard", "button_pressed",   keyboard_button_pressed);
+	env.load_module_function("Keyboard", "button_released",  keyboard_button_released);
+	env.load_module_function("Keyboard", "any_pressed",      keyboard_any_pressed);
+	env.load_module_function("Keyboard", "any_released",     keyboard_any_released);
+	
+	env.load_module_enum("Keyboard", "TAB",       KeyboardButton::TAB);
+	env.load_module_enum("Keyboard", "ENTER",     KeyboardButton::ENTER);
+	env.load_module_enum("Keyboard", "ESCAPE",    KeyboardButton::ESCAPE);
+	env.load_module_enum("Keyboard", "SPACE",     KeyboardButton::SPACE);
+	env.load_module_enum("Keyboard", "BACKSPACE", KeyboardButton::BACKSPACE);
+	env.load_module_enum("Keyboard", "KP_0",      KeyboardButton::KP_0);
+	env.load_module_enum("Keyboard", "KP_1",      KeyboardButton::KP_1);
+	env.load_module_enum("Keyboard", "KP_2",      KeyboardButton::KP_2);
+	env.load_module_enum("Keyboard", "KP_3",      KeyboardButton::KP_3);
+	env.load_module_enum("Keyboard", "KP_4",      KeyboardButton::KP_4);
+	env.load_module_enum("Keyboard", "KP_5",      KeyboardButton::KP_5);
+	env.load_module_enum("Keyboard", "KP_6",      KeyboardButton::KP_6);
+	env.load_module_enum("Keyboard", "KP_7",      KeyboardButton::KP_7);
+	env.load_module_enum("Keyboard", "KP_8",      KeyboardButton::KP_8);
+	env.load_module_enum("Keyboard", "KP_9",      KeyboardButton::KP_9);
+	env.load_module_enum("Keyboard", "F1",        KeyboardButton::F1);
+	env.load_module_enum("Keyboard", "F2",        KeyboardButton::F2);
+	env.load_module_enum("Keyboard", "F3",        KeyboardButton::F3);
+	env.load_module_enum("Keyboard", "F4",        KeyboardButton::F4);
+	env.load_module_enum("Keyboard", "F5",        KeyboardButton::F5);
+	env.load_module_enum("Keyboard", "F6",        KeyboardButton::F6);
+	env.load_module_enum("Keyboard", "F7",        KeyboardButton::F7);
+	env.load_module_enum("Keyboard", "F8",        KeyboardButton::F8);
+	env.load_module_enum("Keyboard", "F9",        KeyboardButton::F9);
+	env.load_module_enum("Keyboard", "F10",       KeyboardButton::F10);
+	env.load_module_enum("Keyboard", "F11",       KeyboardButton::F11);
+	env.load_module_enum("Keyboard", "F12",       KeyboardButton::F12);
+	env.load_module_enum("Keyboard", "HOME",      KeyboardButton::HOME);
+	env.load_module_enum("Keyboard", "LEFT",      KeyboardButton::LEFT);
+	env.load_module_enum("Keyboard", "UP",        KeyboardButton::UP);
+	env.load_module_enum("Keyboard", "RIGHT",     KeyboardButton::RIGHT);
+	env.load_module_enum("Keyboard", "DOWN",      KeyboardButton::DOWN);
+	env.load_module_enum("Keyboard", "PAGE_UP",   KeyboardButton::PAGE_UP);
+	env.load_module_enum("Keyboard", "PAGE_DOWN", KeyboardButton::PAGE_DOWN);
+	env.load_module_enum("Keyboard", "LCONTROL",  KeyboardButton::LCONTROL);
+	env.load_module_enum("Keyboard", "RCONTROL",  KeyboardButton::RCONTROL);
+	env.load_module_enum("Keyboard", "LSHIFT",    KeyboardButton::LSHIFT);
+	env.load_module_enum("Keyboard", "RSHIFT",    KeyboardButton::RSHIFT);
+	env.load_module_enum("Keyboard", "CAPS_LOCK", KeyboardButton::CAPS_LOCK);
+	env.load_module_enum("Keyboard", "LALT",      KeyboardButton::LALT);
+	env.load_module_enum("Keyboard", "RALT",      KeyboardButton::RALT);
+	env.load_module_enum("Keyboard", "LSUPER",    KeyboardButton::LSUPER);
+	env.load_module_enum("Keyboard", "RSUPER",    KeyboardButton::RSUPER);
+	env.load_module_enum("Keyboard", "NUM_0",     KeyboardButton::NUM_0);
+	env.load_module_enum("Keyboard", "NUM_1",     KeyboardButton::NUM_1);
+	env.load_module_enum("Keyboard", "NUM_2",     KeyboardButton::NUM_2);
+	env.load_module_enum("Keyboard", "NUM_3",     KeyboardButton::NUM_3);
+	env.load_module_enum("Keyboard", "NUM_4",     KeyboardButton::NUM_4);
+	env.load_module_enum("Keyboard", "NUM_5",     KeyboardButton::NUM_5);
+	env.load_module_enum("Keyboard", "NUM_6",     KeyboardButton::NUM_6);
+	env.load_module_enum("Keyboard", "NUM_7",     KeyboardButton::NUM_7);
+	env.load_module_enum("Keyboard", "NUM_8",     KeyboardButton::NUM_8);
+	env.load_module_enum("Keyboard", "NUM_9",     KeyboardButton::NUM_9);
+	env.load_module_enum("Keyboard", "A",         KeyboardButton::A);
+	env.load_module_enum("Keyboard", "B",         KeyboardButton::B);
+	env.load_module_enum("Keyboard", "C",         KeyboardButton::C);
+	env.load_module_enum("Keyboard", "D",         KeyboardButton::D);
+	env.load_module_enum("Keyboard", "E",         KeyboardButton::E);
+	env.load_module_enum("Keyboard", "F",         KeyboardButton::F);
+	env.load_module_enum("Keyboard", "G",         KeyboardButton::G);
+	env.load_module_enum("Keyboard", "H",         KeyboardButton::H);
+	env.load_module_enum("Keyboard", "I",         KeyboardButton::I);
+	env.load_module_enum("Keyboard", "J",         KeyboardButton::J);
+	env.load_module_enum("Keyboard", "K",         KeyboardButton::K);
+	env.load_module_enum("Keyboard", "L",         KeyboardButton::L);
+	env.load_module_enum("Keyboard", "M",         KeyboardButton::M);
+	env.load_module_enum("Keyboard", "N",         KeyboardButton::N);
+	env.load_module_enum("Keyboard", "O",         KeyboardButton::O);
+	env.load_module_enum("Keyboard", "P",         KeyboardButton::P);
+	env.load_module_enum("Keyboard", "Q",         KeyboardButton::Q);
+	env.load_module_enum("Keyboard", "R",         KeyboardButton::R);
+	env.load_module_enum("Keyboard", "S",         KeyboardButton::S);
+	env.load_module_enum("Keyboard", "T",         KeyboardButton::T);
+	env.load_module_enum("Keyboard", "U",         KeyboardButton::U);
+	env.load_module_enum("Keyboard", "V",         KeyboardButton::V);
+	env.load_module_enum("Keyboard", "W",         KeyboardButton::W);
+	env.load_module_enum("Keyboard", "X",         KeyboardButton::X);
+	env.load_module_enum("Keyboard", "Y",         KeyboardButton::Y);
+	env.load_module_enum("Keyboard", "Z",         KeyboardButton::Z);
 }
 
 } // namespace crown

engine/lua/lua_material.cpp

@@ -58,7 +58,7 @@ static int material_set_vector3(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_material(LuaEnvironment& env)
 {
-	env.load_module_function("Material", "set_float", material_set_float);
+	env.load_module_function("Material", "set_float",   material_set_float);
 	env.load_module_function("Material", "set_vector2", material_set_vector2);
 	env.load_module_function("Material", "set_vector3", material_set_vector3);
 }

engine/lua/lua_math.cpp

@@ -35,11 +35,7 @@ namespace crown
 static int math_deg_to_rad(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float deg = stack.get_float(1);
-
-	stack.push_float(math::deg_to_rad(deg));
-
+	stack.push_float(math::deg_to_rad(stack.get_float(1)));
 	return 1;
 }
 
@@ -47,11 +43,7 @@ static int math_deg_to_rad(lua_State* L)
 static int math_rad_to_deg(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float rad = stack.get_float(1);
-
-	stack.push_float(math::rad_to_deg(rad));
-
+	stack.push_float(math::rad_to_deg(stack.get_float(1)));
 	return 1;
 }
 
@@ -59,11 +51,7 @@ static int math_rad_to_deg(lua_State* L)
 static int math_next_pow_2(lua_State* L)
 {
 	LuaStack stack(L);
-
-	uint32_t x = stack.get_int(1);
-
-	stack.push_uint32(math::next_pow_2(x));
-
+	stack.push_uint32(math::next_pow_2(stack.get_int(1)));
 	return 1;
 }
 
@@ -71,11 +59,7 @@ static int math_next_pow_2(lua_State* L)
 static int math_is_pow_2(lua_State* L)
 {
 	LuaStack stack(L);
-
-	uint32_t x = stack.get_int(1);
-
-	stack.push_bool(math::is_pow_2(x));
-
+	stack.push_bool(math::is_pow_2(stack.get_int(1)));
 	return 1;
 }
 
@@ -83,11 +67,7 @@ static int math_is_pow_2(lua_State* L)
 static int math_ceil(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-
-	stack.push_float(math::ceil(x));
-
+	stack.push_float(math::ceil(stack.get_float(1)));
 	return 1;
 }
 
@@ -95,11 +75,7 @@ static int math_ceil(lua_State* L)
 static int math_floor(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-
-	stack.push_float(math::floor(x));
-
+	stack.push_float(math::floor(stack.get_float(1)));
 	return 1;
 }
 
@@ -107,11 +83,7 @@ static int math_floor(lua_State* L)
 static int math_sqrt(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-
-	stack.push_float(math::sqrt(x));
-
+	stack.push_float(math::sqrt(stack.get_float(1)));
 	return 1;
 }
 
@@ -119,11 +91,7 @@ static int math_sqrt(lua_State* L)
 static int math_inv_sqrt(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-
-	stack.push_float(math::inv_sqrt(x));
-
+	stack.push_float(math::inv_sqrt(stack.get_float(1)));
 	return 1;
 }
 
@@ -131,11 +99,7 @@ static int math_inv_sqrt(lua_State* L)
 static int math_sin(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-
-	stack.push_float(math::sin(x));
-
+	stack.push_float(math::sin(stack.get_float(1)));
 	return 1;
 }
 
@@ -143,11 +107,7 @@ static int math_sin(lua_State* L)
 static int math_cos(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-
-	stack.push_float(math::cos(x));
-
+	stack.push_float(math::cos(stack.get_float(1)));
 	return 1;
 }
 
@@ -155,11 +115,7 @@ static int math_cos(lua_State* L)
 static int math_asin(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-
-	stack.push_float(math::asin(x));
-
+	stack.push_float(math::asin(stack.get_float(1)));
 	return 1;
 }
 
@@ -167,11 +123,7 @@ static int math_asin(lua_State* L)
 static int math_acos(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-
-	stack.push_float(math::acos(x));
-
+	stack.push_float(math::acos(stack.get_float(1)));
 	return 1;
 }
 
@@ -179,11 +131,7 @@ static int math_acos(lua_State* L)
 static int math_tan(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-
-	stack.push_float(math::tan(x));
-
+	stack.push_float(math::tan(stack.get_float(1)));
 	return 1;
 }
 
@@ -191,12 +139,7 @@ static int math_tan(lua_State* L)
 static int math_atan2(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-	float y = stack.get_float(2);
-
-	stack.push_float(math::atan2(x, y));
-
+	stack.push_float(math::atan2(stack.get_float(1), stack.get_float(2)));
 	return 1;
 }
 
@@ -204,11 +147,7 @@ static int math_atan2(lua_State* L)
 static int math_abs(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-
-	stack.push_float(math::abs(x));
-
+	stack.push_float(math::abs(stack.get_float(1)));
 	return 1;
 }
 
@@ -216,34 +155,29 @@ static int math_abs(lua_State* L)
 static int math_fmod(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-	float y = stack.get_float(2);
-
-	stack.push_float(math::fmod(x, y));
-
+	stack.push_float(math::fmod(stack.get_float(1), stack.get_float(2)));
 	return 1;
 }
 
 //-----------------------------------------------------------------------------
 void load_math(LuaEnvironment& env)
 {
-	env.load_module_function("Math", "deg_to_rad", 	math_deg_to_rad);
-	env.load_module_function("Math", "rad_to_deg", 	math_rad_to_deg);
-	env.load_module_function("Math", "next_pow_2", 	math_next_pow_2);
-	env.load_module_function("Math", "is_pow_2", 	math_is_pow_2);
-	env.load_module_function("Math", "ceil", 		math_ceil);
-	env.load_module_function("Math", "floor", 		math_floor);
-	env.load_module_function("Math", "sqrt", 		math_sqrt);
-	env.load_module_function("Math", "inv_sqrt", 	math_inv_sqrt);
-	env.load_module_function("Math", "sin", 		math_sin);
-	env.load_module_function("Math", "cos", 		math_cos);
-	env.load_module_function("Math", "asin",	 	math_asin);
-	env.load_module_function("Math", "acos", 		math_acos);
-	env.load_module_function("Math", "tan", 		math_tan);
-	env.load_module_function("Math", "atan2", 		math_atan2);
-	env.load_module_function("Math", "abs", 		math_abs);
-	env.load_module_function("Math", "fmod", 		math_fmod);
+	env.load_module_function("Math", "deg_to_rad", math_deg_to_rad);
+	env.load_module_function("Math", "rad_to_deg", math_rad_to_deg);
+	env.load_module_function("Math", "next_pow_2", math_next_pow_2);
+	env.load_module_function("Math", "is_pow_2",   math_is_pow_2);
+	env.load_module_function("Math", "ceil",       math_ceil);
+	env.load_module_function("Math", "floor",      math_floor);
+	env.load_module_function("Math", "sqrt",       math_sqrt);
+	env.load_module_function("Math", "inv_sqrt",   math_inv_sqrt);
+	env.load_module_function("Math", "sin",        math_sin);
+	env.load_module_function("Math", "cos",        math_cos);
+	env.load_module_function("Math", "asin",       math_asin);
+	env.load_module_function("Math", "acos",       math_acos);
+	env.load_module_function("Math", "tan",        math_tan);
+	env.load_module_function("Math", "atan2",      math_atan2);
+	env.load_module_function("Math", "abs",        math_abs);
+	env.load_module_function("Math", "fmod",       math_fmod);
 }
 
 } // namespace crown

engine/lua/lua_matrix4x4.cpp

@@ -38,7 +38,6 @@ using namespace matrix4x4;
 static int matrix4x4_new(lua_State* L)
 {
 	LuaStack stack(L);
-
 	float m0 = stack.get_float(1);
 	float m1 = stack.get_float(2);
 	float m2 = stack.get_float(3);
@@ -55,9 +54,7 @@ static int matrix4x4_new(lua_State* L)
 	float m13 = stack.get_float(14);
 	float m14 = stack.get_float(15);
 	float m15 = stack.get_float(16);
-
 	stack.push_matrix4x4(Matrix4x4(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15));
-
 	return 1;
 }
 
@@ -73,8 +70,7 @@ static int matrix4x4_ctor(lua_State* L)
 static int matrix4x4_from_quaternion(lua_State* L)
 {
 	LuaStack stack(L);
-	const Quaternion& q = stack.get_quaternion(1);
-	stack.push_matrix4x4(Matrix4x4(q, Vector3(0, 0, 0)));
+	stack.push_matrix4x4(Matrix4x4(stack.get_quaternion(1), Vector3(0, 0, 0)));
 	return 1;
 }
 
@@ -82,8 +78,7 @@ static int matrix4x4_from_quaternion(lua_State* L)
 static int matrix4x4_from_translation(lua_State* L)
 {
 	LuaStack stack(L);
-	const Vector3& t = stack.get_vector3(1);
-	stack.push_matrix4x4(Matrix4x4(quaternion::IDENTITY, t));
+	stack.push_matrix4x4(Matrix4x4(quaternion::IDENTITY, stack.get_vector3(1)));
 	return 1;
 }
 
@@ -107,12 +102,7 @@ static int matrix4x4_from_axes(lua_State* L)
 static int matrix4x4_add(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-	Matrix4x4& b = stack.get_matrix4x4(2);
-
-	stack.push_matrix4x4(a + b);
-
+	stack.push_matrix4x4(stack.get_matrix4x4(1) + stack.get_matrix4x4(2));
 	return 1;
 }
 
@@ -120,12 +110,7 @@ static int matrix4x4_add(lua_State* L)
 static int matrix4x4_subtract(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-	Matrix4x4& b = stack.get_matrix4x4(2);
-
-	stack.push_matrix4x4(a - b);
-
+	stack.push_matrix4x4(stack.get_matrix4x4(1) - stack.get_matrix4x4(2));
 	return 1;
 }
 
@@ -133,12 +118,7 @@ static int matrix4x4_subtract(lua_State* L)
 static int matrix4x4_multiply(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-	Matrix4x4& b = stack.get_matrix4x4(2);
-
-	stack.push_matrix4x4(a * b);
-
+	stack.push_matrix4x4(stack.get_matrix4x4(1) * stack.get_matrix4x4(2));
 	return 1;
 }
 
@@ -146,11 +126,7 @@ static int matrix4x4_multiply(lua_State* L)
 static int matrix4x4_transpose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-
-	stack.push_matrix4x4(transpose(a));
-
+	stack.push_matrix4x4(transpose(stack.get_matrix4x4(1)));
 	return 1;
 }
 
@@ -158,11 +134,7 @@ static int matrix4x4_transpose(lua_State* L)
 static int matrix4x4_determinant(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-
-	stack.push_float(determinant(a));
-
+	stack.push_float(determinant(stack.get_matrix4x4(1)));
 	return 1;
 }
 
@@ -170,11 +142,7 @@ static int matrix4x4_determinant(lua_State* L)
 static int matrix4x4_invert(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-
-	stack.push_matrix4x4(invert(a));
-
+	stack.push_matrix4x4(invert(stack.get_matrix4x4(1)));
 	return 1;
 }
 
@@ -182,11 +150,7 @@ static int matrix4x4_invert(lua_State* L)
 static int matrix4x4_x(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-
-	stack.push_vector3(x(a));
-
+	stack.push_vector3(x(stack.get_matrix4x4(1)));
 	return 1;
 }
 
@@ -194,11 +158,7 @@ static int matrix4x4_x(lua_State* L)
 static int matrix4x4_y(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-
-	stack.push_vector3(y(a));
-
+	stack.push_vector3(y(stack.get_matrix4x4(1)));
 	return 1;
 }
 
@@ -206,11 +166,7 @@ static int matrix4x4_y(lua_State* L)
 static int matrix4x4_z(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-
-	stack.push_vector3(z(a));
-
+	stack.push_vector3(z(stack.get_matrix4x4(1)));
 	return 1;
 }
 
@@ -218,12 +174,7 @@ static int matrix4x4_z(lua_State* L)
 static int matrix4x4_set_x(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-	Vector3& x = stack.get_vector3(2);
-
-	set_x(a, x);
-
+	set_x(stack.get_matrix4x4(1), stack.get_vector3(2));
 	return 0;
 }
 
@@ -231,12 +182,7 @@ static int matrix4x4_set_x(lua_State* L)
 static int matrix4x4_set_y(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-	Vector3& y = stack.get_vector3(2);
-
-	set_y(a, y);
-
+	set_y(stack.get_matrix4x4(1), stack.get_vector3(2));
 	return 0;
 }
 
@@ -244,12 +190,7 @@ static int matrix4x4_set_y(lua_State* L)
 static int matrix4x4_set_z(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-	Vector3& z = stack.get_vector3(2);
-
-	set_z(a, z);
-
+	set_z(stack.get_matrix4x4(1), stack.get_vector3(2));
 	return 0;
 }
 
@@ -257,11 +198,7 @@ static int matrix4x4_set_z(lua_State* L)
 static int matrix4x4_translation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-
-	stack.push_vector3(translation(a));
-
+	stack.push_vector3(translation(stack.get_matrix4x4(1)));
 	return 1;
 }
 
@@ -269,12 +206,7 @@ static int matrix4x4_translation(lua_State* L)
 static int matrix4x4_set_translation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& a = stack.get_matrix4x4(1);
-	Vector3& trans = stack.get_vector3(2);
-
-	set_translation(a, trans);
-
+	set_translation(stack.get_matrix4x4(1), stack.get_vector3(2));
 	return 0;
 }
 
@@ -282,9 +214,7 @@ static int matrix4x4_set_translation(lua_State* L)
 static int matrix4x4_identity(lua_State* L)
 {
 	LuaStack stack(L);
-
 	stack.push_matrix4x4(matrix4x4::IDENTITY);
-
 	return 1;
 }
 
@@ -292,41 +222,38 @@ static int matrix4x4_identity(lua_State* L)
 static int matrix4x4_to_string(lua_State* L)
 {
 	LuaStack stack(L);
-
 	Matrix4x4& a = stack.get_matrix4x4(1);
-
 	stack.push_fstring("%.1f, %.1f, %.1f, %.1f\n%.1f, %.1f, %.1f, %.1f\n%.1f, %.1f, %.1f, %.1f\n%.1f, %.1f, %.1f, %.1f\n",
 						a[0], a[4], a[8], a[12], a[1], a[5], a[9], a[13], a[2], a[6], a[10], a[14], a[3], a[7], a[11], a[15]);
-
 	return 1;
 }
 
 //-----------------------------------------------------------------------------
 void load_matrix4x4(LuaEnvironment& env)
 {
-	env.load_module_function("Matrix4x4", "new", 							matrix4x4_new);
-	env.load_module_function("Matrix4x4", "from_quaternion",				matrix4x4_from_quaternion);
-	env.load_module_function("Matrix4x4", "from_translation",				matrix4x4_from_translation);
-	env.load_module_function("Matrix4x4", "from_quaternion_translation",	matrix4x4_from_quaternion_translation);
-	env.load_module_function("Matrix4x4", "from_axes",						matrix4x4_from_axes);
-	env.load_module_function("Matrix4x4", "add", 							matrix4x4_add);
-	env.load_module_function("Matrix4x4", "subtract", 						matrix4x4_subtract);
-	env.load_module_function("Matrix4x4", "multiply", 						matrix4x4_multiply);
-	env.load_module_function("Matrix4x4", "transpose", 						matrix4x4_transpose);
-	env.load_module_function("Matrix4x4", "determinant", 					matrix4x4_determinant);
-	env.load_module_function("Matrix4x4", "invert", 						matrix4x4_invert);
-	env.load_module_function("Matrix4x4", "x",								matrix4x4_x);
-	env.load_module_function("Matrix4x4", "y",								matrix4x4_y);
-	env.load_module_function("Matrix4x4", "z",								matrix4x4_z);
-	env.load_module_function("Matrix4x4", "set_x",							matrix4x4_set_x);
-	env.load_module_function("Matrix4x4", "set_y",							matrix4x4_set_y);
-	env.load_module_function("Matrix4x4", "set_z",							matrix4x4_set_z);
-	env.load_module_function("Matrix4x4", "translation", 					matrix4x4_translation);
-	env.load_module_function("Matrix4x4", "set_translation", 				matrix4x4_set_translation);
-	env.load_module_function("Matrix4x4", "identity", 						matrix4x4_identity);
-	env.load_module_function("Matrix4x4", "to_string",						matrix4x4_to_string);
-
-	env.load_module_constructor("Matrix4x4",								matrix4x4_ctor);
+	env.load_module_function("Matrix4x4", "new",                         matrix4x4_new);
+	env.load_module_function("Matrix4x4", "from_quaternion",             matrix4x4_from_quaternion);
+	env.load_module_function("Matrix4x4", "from_translation",            matrix4x4_from_translation);
+	env.load_module_function("Matrix4x4", "from_quaternion_translation", matrix4x4_from_quaternion_translation);
+	env.load_module_function("Matrix4x4", "from_axes",                   matrix4x4_from_axes);
+	env.load_module_function("Matrix4x4", "add",                         matrix4x4_add);
+	env.load_module_function("Matrix4x4", "subtract",                    matrix4x4_subtract);
+	env.load_module_function("Matrix4x4", "multiply",                    matrix4x4_multiply);
+	env.load_module_function("Matrix4x4", "transpose",                   matrix4x4_transpose);
+	env.load_module_function("Matrix4x4", "determinant",                 matrix4x4_determinant);
+	env.load_module_function("Matrix4x4", "invert",                      matrix4x4_invert);
+	env.load_module_function("Matrix4x4", "x",                           matrix4x4_x);
+	env.load_module_function("Matrix4x4", "y",                           matrix4x4_y);
+	env.load_module_function("Matrix4x4", "z",                           matrix4x4_z);
+	env.load_module_function("Matrix4x4", "set_x",                       matrix4x4_set_x);
+	env.load_module_function("Matrix4x4", "set_y",                       matrix4x4_set_y);
+	env.load_module_function("Matrix4x4", "set_z",                       matrix4x4_set_z);
+	env.load_module_function("Matrix4x4", "translation",                 matrix4x4_translation);
+	env.load_module_function("Matrix4x4", "set_translation",             matrix4x4_set_translation);
+	env.load_module_function("Matrix4x4", "identity",                    matrix4x4_identity);
+	env.load_module_function("Matrix4x4", "to_string",                   matrix4x4_to_string);
+	
+	env.load_module_constructor("Matrix4x4", matrix4x4_ctor);
 }
 
 } //namespace crown

engine/lua/lua_matrix4x4_box.cpp

@@ -37,10 +37,7 @@ namespace crown
 static int matrix4x4box_new(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Matrix4x4& tm = stack.get_matrix4x4(1);
-
-	stack.push_matrix4x4box(tm);
+	stack.push_matrix4x4box(stack.get_matrix4x4(1));
 	return 1;
 }
 
@@ -56,11 +53,7 @@ static int matrix4x4box_ctor(lua_State* L)
 static int matrix4x4box_store(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& m = stack.get_matrix4x4box(1);
-	const Matrix4x4 tm = stack.get_matrix4x4(2);
-
-	m = tm;
+	stack.get_matrix4x4box(1) = stack.get_matrix4x4(2);
 	return 0;
 }
 
@@ -68,10 +61,7 @@ static int matrix4x4box_store(lua_State* L)
 static int matrix4x4box_unbox(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Matrix4x4& m = stack.get_matrix4x4box(1);
-
-	stack.push_matrix4x4(m);
+	stack.push_matrix4x4(stack.get_matrix4x4box(1));
 	return 1;
 }
 
@@ -87,12 +77,12 @@ static int matrix4x4box_tostring(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_matrix4x4box(LuaEnvironment& env)
 {
-	env.load_module_function("Matrix4x4Box", "new",			matrix4x4box_new);
-	env.load_module_function("Matrix4x4Box", "store",		matrix4x4box_store);
-	env.load_module_function("Matrix4x4Box", "unbox",		matrix4x4box_unbox);
-	env.load_module_function("Matrix4x4Box", "__tostring",	matrix4x4box_tostring);
-
-	env.load_module_constructor("Matrix4x4Box",				matrix4x4box_ctor);
+	env.load_module_function("Matrix4x4Box", "new",        matrix4x4box_new);
+	env.load_module_function("Matrix4x4Box", "store",      matrix4x4box_store);
+	env.load_module_function("Matrix4x4Box", "unbox",      matrix4x4box_unbox);
+	env.load_module_function("Matrix4x4Box", "__tostring", matrix4x4box_tostring);
+	
+	env.load_module_constructor("Matrix4x4Box", matrix4x4box_ctor);
 }
 
 } // namespace crown

engine/lua/lua_mesh.cpp

@@ -36,10 +36,7 @@ namespace crown
 static int mesh_local_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Mesh* mesh = stack.get_mesh(1);
-
-	stack.push_vector3(mesh->local_position());
+	stack.push_vector3(stack.get_mesh(1)->local_position());
 	return 1;
 }
 
@@ -47,10 +44,7 @@ static int mesh_local_position(lua_State* L)
 static int mesh_local_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Mesh* mesh = stack.get_mesh(1);
-
-	stack.push_quaternion(mesh->local_rotation());
+	stack.push_quaternion(stack.get_mesh(1)->local_rotation());
 	return 1;
 }
 
@@ -58,10 +52,7 @@ static int mesh_local_rotation(lua_State* L)
 static int mesh_local_pose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Mesh* mesh = stack.get_mesh(1);
-
-	stack.push_matrix4x4(mesh->local_pose());
+	stack.push_matrix4x4(stack.get_mesh(1)->local_pose());
 	return 1;
 }
 
@@ -69,10 +60,7 @@ static int mesh_local_pose(lua_State* L)
 static int mesh_world_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Mesh* mesh = stack.get_mesh(1);
-
-	stack.push_vector3(mesh->world_position());
+	stack.push_vector3(stack.get_mesh(1)->world_position());
 	return 1;
 }
 
@@ -80,10 +68,7 @@ static int mesh_world_position(lua_State* L)
 static int mesh_world_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Mesh* mesh = stack.get_mesh(1);
-
-	stack.push_quaternion(mesh->world_rotation());
+	stack.push_quaternion(stack.get_mesh(1)->world_rotation());
 	return 1;
 }
 
@@ -91,10 +76,7 @@ static int mesh_world_rotation(lua_State* L)
 static int mesh_world_pose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Mesh* mesh = stack.get_mesh(1);
-
-	stack.push_matrix4x4(mesh->world_pose());
+	stack.push_matrix4x4(stack.get_mesh(1)->world_pose());
 	return 1;
 }
 
@@ -102,12 +84,7 @@ static int mesh_world_pose(lua_State* L)
 static int mesh_set_local_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Mesh* mesh = stack.get_mesh(1);
-	Unit* unit = stack.get_unit(2);
-	const Vector3 pos = stack.get_vector3(3);
-
-	mesh->set_local_position(unit, pos);
+	stack.get_mesh(1)->set_local_position(stack.get_unit(2), stack.get_vector3(3));
 	return 0;
 }
 
@@ -115,12 +92,7 @@ static int mesh_set_local_position(lua_State* L)
 static int mesh_set_local_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Mesh* mesh = stack.get_mesh(1);
-	Unit* unit = stack.get_unit(2);
-	const Quaternion rot = stack.get_quaternion(3);
-
-	mesh->set_local_rotation(unit, rot);
+	stack.get_mesh(1)->set_local_rotation(stack.get_unit(2), stack.get_quaternion(3));
 	return 0;
 }
 
@@ -128,27 +100,22 @@ static int mesh_set_local_rotation(lua_State* L)
 static int mesh_set_local_pose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Mesh* mesh = stack.get_mesh(1);
-	Unit* unit = stack.get_unit(2);
-	const Matrix4x4 pose = stack.get_matrix4x4(3);
-
-	mesh->set_local_pose(unit, pose);
+	stack.get_mesh(1)->set_local_pose(stack.get_unit(2), stack.get_matrix4x4(3));
 	return 0;
 }
 
 //-----------------------------------------------------------------------------
 void load_mesh(LuaEnvironment& env)
 {
-	env.load_module_function("Mesh", "local_position",         mesh_local_position);
-	env.load_module_function("Mesh", "local_rotation",         mesh_local_rotation);
-	env.load_module_function("Mesh", "local_pose",             mesh_local_pose);
-	env.load_module_function("Mesh", "world_position",         mesh_world_position);
-	env.load_module_function("Mesh", "world_rotation",         mesh_world_rotation);
-	env.load_module_function("Mesh", "world_pose",             mesh_world_pose);
-	env.load_module_function("Mesh", "set_local_position",     mesh_set_local_position);
-	env.load_module_function("Mesh", "set_local_rotation",     mesh_set_local_rotation);
-	env.load_module_function("Mesh", "set_local_pose",         mesh_set_local_pose);
+	env.load_module_function("Mesh", "local_position",     mesh_local_position);
+	env.load_module_function("Mesh", "local_rotation",     mesh_local_rotation);
+	env.load_module_function("Mesh", "local_pose",         mesh_local_pose);
+	env.load_module_function("Mesh", "world_position",     mesh_world_position);
+	env.load_module_function("Mesh", "world_rotation",     mesh_world_rotation);
+	env.load_module_function("Mesh", "world_pose",         mesh_world_pose);
+	env.load_module_function("Mesh", "set_local_position", mesh_set_local_position);
+	env.load_module_function("Mesh", "set_local_rotation", mesh_set_local_rotation);
+	env.load_module_function("Mesh", "set_local_pose",     mesh_set_local_pose);
 }
 
 } // namespace crown

engine/lua/lua_mouse.cpp

@@ -100,18 +100,18 @@ static int mouse_set_cursor_relative_xy(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_mouse(LuaEnvironment& env)
 {
-	env.load_module_function("Mouse", "button_pressed",			mouse_button_pressed);
-	env.load_module_function("Mouse", "button_released",		mouse_button_released);
-	env.load_module_function("Mouse", "any_pressed",			mouse_any_pressed);
-	env.load_module_function("Mouse", "any_released",			mouse_any_released);
-	env.load_module_function("Mouse", "cursor_xy",				mouse_cursor_xy);
-	env.load_module_function("Mouse", "set_cursor_xy",			mouse_set_cursor_xy);
-	env.load_module_function("Mouse", "cursor_relative_xy",		mouse_cursor_relative_xy);
-	env.load_module_function("Mouse", "set_cursor_relative_xy",	mouse_set_cursor_relative_xy);
-
-	env.load_module_enum("Mouse", "LEFT",						MouseButton::LEFT);
-	env.load_module_enum("Mouse", "MIDDLE",						MouseButton::MIDDLE);
-	env.load_module_enum("Mouse", "RIGHT", 						MouseButton::RIGHT);
+	env.load_module_function("Mouse", "button_pressed",         mouse_button_pressed);
+	env.load_module_function("Mouse", "button_released",        mouse_button_released);
+	env.load_module_function("Mouse", "any_pressed",            mouse_any_pressed);
+	env.load_module_function("Mouse", "any_released",           mouse_any_released);
+	env.load_module_function("Mouse", "cursor_xy",              mouse_cursor_xy);
+	env.load_module_function("Mouse", "set_cursor_xy",          mouse_set_cursor_xy);
+	env.load_module_function("Mouse", "cursor_relative_xy",     mouse_cursor_relative_xy);
+	env.load_module_function("Mouse", "set_cursor_relative_xy", mouse_set_cursor_relative_xy);
+	
+	env.load_module_enum("Mouse", "LEFT",   MouseButton::LEFT);
+	env.load_module_enum("Mouse", "MIDDLE", MouseButton::MIDDLE);
+	env.load_module_enum("Mouse", "RIGHT",  MouseButton::RIGHT);
 }
 
 } // namespace crown

engine/lua/lua_physics_world.cpp

@@ -37,10 +37,7 @@ namespace crown
 static int physics_world_gravity(lua_State* L)
 {
 	LuaStack stack(L);
-
-	PhysicsWorld* world = stack.get_physics_world(1);
-
-	stack.push_vector3(world->gravity());
+	stack.push_vector3(stack.get_physics_world(1)->gravity());
 	return 1;
 }
 
@@ -48,11 +45,7 @@ static int physics_world_gravity(lua_State* L)
 static int physics_world_set_gravity(lua_State* L)
 {
 	LuaStack stack(L);
-
-	PhysicsWorld* world = stack.get_physics_world(1);
-	const Vector3& gravity = stack.get_vector3(2);
-
-	world->set_gravity(gravity);
+	stack.get_physics_world(1)->set_gravity(stack.get_vector3(2));
 	return 0;
 }
 
@@ -112,34 +105,30 @@ static int physics_world_tostring(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_physics_world(LuaEnvironment& env)
 {
-	env.load_module_function("PhysicsWorld", "gravity",				physics_world_gravity);
-	env.load_module_function("PhysicsWorld", "set_gravity",			physics_world_set_gravity);
-	env.load_module_function("PhysicsWorld", "make_raycast",		physics_world_make_raycast);
-	env.load_module_function("PhysicsWorld", "overlap_test",		physics_world_overlap_test);
-	env.load_module_function("PhysicsWorld", "__index",				"PhysicsWorld");
-	env.load_module_function("PhysicsWorld", "__tostring",			physics_world_tostring);
-
-	// Actor types
-	env.load_module_enum("ActorType", "STATIC",						ActorType::STATIC);
-	env.load_module_enum("ActorType", "DYNAMIC_PHYSICAL",			ActorType::DYNAMIC_PHYSICAL);
-	env.load_module_enum("ActorType", "DYNAMIC_KINEMATIC",			ActorType::DYNAMIC_KINEMATIC);
-
-	// Shape types
-	env.load_module_enum("ShapeType", "SPHERE",						ShapeType::SPHERE);
-	env.load_module_enum("ShapeType", "CAPSULE",					ShapeType::CAPSULE);
-	env.load_module_enum("ShapeType", "BOX",						ShapeType::BOX);
-	env.load_module_enum("ShapeType", "PLANE",						ShapeType::PLANE);
-	env.load_module_enum("ShapeType", "CONVEX_MESH",				ShapeType::CONVEX_MESH);
-
-	// SceneQuery modes
-	env.load_module_enum("CollisionMode", "CLOSEST",				CollisionMode::CLOSEST);
-	env.load_module_enum("CollisionMode", "ANY",					CollisionMode::ANY);
-	env.load_module_enum("CollisionMode", "ALL",					CollisionMode::ALL);
-
-	// SceneQuery filters
-	env.load_module_enum("CollisionType", "STATIC",					CollisionType::STATIC);
-	env.load_module_enum("CollisionType", "DYNAMIC",				CollisionType::DYNAMIC);
-	env.load_module_enum("CollisionType", "BOTH",					CollisionType::BOTH);
+	env.load_module_function("PhysicsWorld", "gravity",      physics_world_gravity);
+	env.load_module_function("PhysicsWorld", "set_gravity",  physics_world_set_gravity);
+	env.load_module_function("PhysicsWorld", "make_raycast", physics_world_make_raycast);
+	env.load_module_function("PhysicsWorld", "overlap_test", physics_world_overlap_test);
+	env.load_module_function("PhysicsWorld", "__index",      "PhysicsWorld");
+	env.load_module_function("PhysicsWorld", "__tostring",   physics_world_tostring);
+	
+	env.load_module_enum("ActorType", "STATIC",            ActorType::STATIC);
+	env.load_module_enum("ActorType", "DYNAMIC_PHYSICAL",  ActorType::DYNAMIC_PHYSICAL);
+	env.load_module_enum("ActorType", "DYNAMIC_KINEMATIC", ActorType::DYNAMIC_KINEMATIC);
+
+	env.load_module_enum("ShapeType", "SPHERE",      ShapeType::SPHERE);
+	env.load_module_enum("ShapeType", "CAPSULE",     ShapeType::CAPSULE);
+	env.load_module_enum("ShapeType", "BOX",         ShapeType::BOX);
+	env.load_module_enum("ShapeType", "PLANE",       ShapeType::PLANE);
+	env.load_module_enum("ShapeType", "CONVEX_MESH", ShapeType::CONVEX_MESH);
+	
+	env.load_module_enum("CollisionMode", "CLOSEST", CollisionMode::CLOSEST);
+	env.load_module_enum("CollisionMode", "ANY",     CollisionMode::ANY);
+	env.load_module_enum("CollisionMode", "ALL",     CollisionMode::ALL);
+	
+	env.load_module_enum("CollisionType", "STATIC",  CollisionType::STATIC);
+	env.load_module_enum("CollisionType", "DYNAMIC", CollisionType::DYNAMIC);
+	env.load_module_enum("CollisionType", "BOTH",    CollisionType::BOTH);
 }
 
 } // namespace crown

engine/lua/lua_quaternion.cpp

@@ -37,12 +37,7 @@ namespace crown
 static int quaternion_new(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Vector3& v = stack.get_vector3(1);
-	const float w = stack.get_float(2);
-
-	stack.push_quaternion(Quaternion(v, w));
-
+	stack.push_quaternion(Quaternion(stack.get_vector3(1), stack.get_float(2)));
 	return 1;
 }
 
@@ -58,11 +53,7 @@ static int quaternion_ctor(lua_State* L)
 static int quaternion_negate(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Quaternion& q = stack.get_quaternion(1);
-
-	stack.push_quaternion(-q);
-
+	stack.push_quaternion(-stack.get_quaternion(1));
 	return 1;
 }
 
@@ -70,7 +61,6 @@ static int quaternion_negate(lua_State* L)
 static int quaternion_identity(lua_State* L)
 {
 	LuaStack stack(L);
-
 	stack.push_quaternion(quaternion::IDENTITY);
 	return 1;
 }
@@ -79,11 +69,7 @@ static int quaternion_identity(lua_State* L)
 static int quaternion_length(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Quaternion& q = stack.get_quaternion(1);
-
-	stack.push_float(quaternion::length(q));
-
+	stack.push_float(quaternion::length(stack.get_quaternion(1)));
 	return 1;
 }
 
@@ -91,11 +77,7 @@ static int quaternion_length(lua_State* L)
 static int quaternion_conjugate(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Quaternion& q = stack.get_quaternion(1);
-
-	stack.push_quaternion(quaternion::conjugate(q));
-
+	stack.push_quaternion(quaternion::conjugate(stack.get_quaternion(1)));
 	return 1;
 }
 
@@ -103,11 +85,7 @@ static int quaternion_conjugate(lua_State* L)
 static int quaternion_inverse(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Quaternion& q = stack.get_quaternion(1);
-
-	stack.push_quaternion(quaternion::inverse(q));
-
+	stack.push_quaternion(quaternion::inverse(stack.get_quaternion(1)));
 	return 1;
 }
 
@@ -115,12 +93,7 @@ static int quaternion_inverse(lua_State* L)
 static int quaternion_multiply(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Quaternion& q1 = stack.get_quaternion(1);
-	const Quaternion& q2 = stack.get_quaternion(2);
-
-	stack.push_quaternion(q1 * q2);
-
+	stack.push_quaternion(stack.get_quaternion(1) * stack.get_quaternion(2));
 	return 1;
 }
 
@@ -128,12 +101,7 @@ static int quaternion_multiply(lua_State* L)
 static int quaternion_multiply_by_scalar(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Quaternion& q = stack.get_quaternion(1);
-	const float k = stack.get_float(2);
-
-	stack.push_quaternion(q * k);
-
+	stack.push_quaternion(stack.get_quaternion(1) * stack.get_float(2));
 	return 1;
 }
 
@@ -141,12 +109,7 @@ static int quaternion_multiply_by_scalar(lua_State* L)
 static int quaternion_power(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Quaternion& q = stack.get_quaternion(1);
-	const float k = stack.get_float(2);
-
-	stack.push_quaternion(quaternion::power(q, k));
-
+	stack.push_quaternion(quaternion::power(stack.get_quaternion(1), stack.get_float(2)));
 	return 1;
 }
 
@@ -155,7 +118,6 @@ static int quaternion_elements(lua_State* L)
 {
 	LuaStack stack(L);
 	const Quaternion& q = stack.get_quaternion(1);
-
 	stack.push_float(q.x);
 	stack.push_float(q.y);
 	stack.push_float(q.z);
@@ -166,18 +128,18 @@ static int quaternion_elements(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_quaternion(LuaEnvironment& env)
 {
-	env.load_module_function("Quaternion", "new",					quaternion_new);
-	env.load_module_function("Quaternion", "negate",				quaternion_negate);
-	env.load_module_function("Quaternion", "identity",				quaternion_identity);
-	env.load_module_function("Quaternion", "multiply",				quaternion_multiply);
-	env.load_module_function("Quaternion", "multiply_by_scalar",	quaternion_multiply_by_scalar);
-	env.load_module_function("Quaternion", "length",				quaternion_length);
-	env.load_module_function("Quaternion", "conjugate",				quaternion_conjugate);
-	env.load_module_function("Quaternion", "inverse",				quaternion_inverse);
-	env.load_module_function("Quaternion", "power",					quaternion_power);
-	env.load_module_function("Quaternion", "elements",				quaternion_elements);
-
-	env.load_module_constructor("Quaternion",						quaternion_ctor);
+	env.load_module_function("Quaternion", "new",                quaternion_new);
+	env.load_module_function("Quaternion", "negate",             quaternion_negate);
+	env.load_module_function("Quaternion", "identity",           quaternion_identity);
+	env.load_module_function("Quaternion", "multiply",           quaternion_multiply);
+	env.load_module_function("Quaternion", "multiply_by_scalar", quaternion_multiply_by_scalar);
+	env.load_module_function("Quaternion", "length",             quaternion_length);
+	env.load_module_function("Quaternion", "conjugate",          quaternion_conjugate);
+	env.load_module_function("Quaternion", "inverse",            quaternion_inverse);
+	env.load_module_function("Quaternion", "power",              quaternion_power);
+	env.load_module_function("Quaternion", "elements",           quaternion_elements);
+	
+	env.load_module_constructor("Quaternion", quaternion_ctor);
 }
 
 } //namespace crown

engine/lua/lua_quaternion_box.cpp

@@ -117,7 +117,7 @@ void load_quaternionbox(LuaEnvironment& env)
 	env.load_module_function("QuaternionBox", "unbox",      quaternionbox_unbox);
 	env.load_module_function("QuaternionBox", "__tostring", quaternionbox_tostring);
 
-	env.load_module_constructor("QuaternionBox",			quaternionbox_ctor);
+	env.load_module_constructor("QuaternionBox", quaternionbox_ctor);
 }
 
 } // namespace crown

engine/lua/lua_raycast.cpp

@@ -94,7 +94,7 @@ static int raycast_cast(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_raycast(LuaEnvironment& env)
 {
-	env.load_module_function("Raycast", "cast",	raycast_cast);
+	env.load_module_function("Raycast", "cast", raycast_cast);
 }
 
 } // namespace crown

engine/lua/lua_resource_package.cpp

@@ -35,10 +35,7 @@ namespace crown
 static int resource_package_load(lua_State* L)
 {
 	LuaStack stack(L);
-
-	ResourcePackage* package = stack.get_resource_package(1);
-	package->load();
-
+	stack.get_resource_package(1)->load();
 	return 0;
 }
 
@@ -46,10 +43,7 @@ static int resource_package_load(lua_State* L)
 static int resource_package_unload(lua_State* L)
 {
 	LuaStack stack(L);
-
-	ResourcePackage* package = stack.get_resource_package(1);
-	package->unload();
-
+	stack.get_resource_package(1)->unload();
 	return 0;
 }
 
@@ -57,10 +51,7 @@ static int resource_package_unload(lua_State* L)
 static int resource_package_flush(lua_State* L)
 {
 	LuaStack stack(L);
-
-	ResourcePackage* package = stack.get_resource_package(1);
-	package->flush();
-
+	stack.get_resource_package(1)->flush();
 	return 0;
 }
 
@@ -68,10 +59,7 @@ static int resource_package_flush(lua_State* L)
 static int resource_package_has_loaded(lua_State* L)
 {
 	LuaStack stack(L);
-
-	ResourcePackage* package = stack.get_resource_package(1);
-	stack.push_bool(package->has_loaded());
-
+	stack.push_bool(stack.get_resource_package(1)->has_loaded());
 	return 1;
 }
 

engine/lua/lua_sound_world.cpp

@@ -35,9 +35,7 @@ namespace crown
 static int sound_world_stop_all(lua_State* L)
 {
 	LuaStack stack(L);
-
-	SoundWorld* sw = stack.get_sound_world(1);
-	sw->stop_all();
+	stack.get_sound_world(1)->stop_all();
 	return 0;
 }
 
@@ -45,9 +43,7 @@ static int sound_world_stop_all(lua_State* L)
 static int sound_world_pause_all(lua_State* L)
 {
 	LuaStack stack(L);
-
-	SoundWorld* sw = stack.get_sound_world(1);
-	sw->pause_all();
+	stack.get_sound_world(1)->pause_all();
 	return 0;
 }
 
@@ -55,9 +51,7 @@ static int sound_world_pause_all(lua_State* L)
 static int sound_world_resume_all(lua_State* L)
 {
 	LuaStack stack(L);
-
-	SoundWorld* sw = stack.get_sound_world(1);
-	sw->resume_all();
+	stack.get_sound_world(1)->resume_all();
 	return 0;
 }
 
@@ -65,10 +59,7 @@ static int sound_world_resume_all(lua_State* L)
 static int sound_world_is_playing(lua_State* L)
 {
 	LuaStack stack(L);
-
-	SoundWorld* sw = stack.get_sound_world(1);
-	SoundInstanceId id = stack.get_sound_instance_id(2);
-	stack.push_bool(sw->is_playing(id));
+	stack.push_bool(stack.get_sound_world(1)->is_playing(stack.get_sound_instance_id(2)));
 	return 1;
 }
 
@@ -84,12 +75,12 @@ static int sound_world_tostring(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_sound_world(LuaEnvironment& env)
 {
-	env.load_module_function("SoundWorld", "stop_all",    sound_world_stop_all);
-	env.load_module_function("SoundWorld", "pause_all",   sound_world_pause_all);
-	env.load_module_function("SoundWorld", "resume_all",  sound_world_resume_all);
-	env.load_module_function("SoundWorld", "is_playing",  sound_world_is_playing);
-	env.load_module_function("SoundWorld", "__index",	  "SoundWorld");
-	env.load_module_function("SoundWorld", "__tostring",  sound_world_tostring);
+	env.load_module_function("SoundWorld", "stop_all",   sound_world_stop_all);
+	env.load_module_function("SoundWorld", "pause_all",  sound_world_pause_all);
+	env.load_module_function("SoundWorld", "resume_all", sound_world_resume_all);
+	env.load_module_function("SoundWorld", "is_playing", sound_world_is_playing);
+	env.load_module_function("SoundWorld", "__index",    "SoundWorld");
+	env.load_module_function("SoundWorld", "__tostring", sound_world_tostring);
 }
 
 } // namespace crown

engine/lua/lua_sprite.cpp

@@ -36,11 +36,7 @@ namespace crown
 static int sprite_local_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Sprite* sprite = stack.get_sprite(1);
-
-	stack.push_vector3(sprite->local_position());
-
+	stack.push_vector3(stack.get_sprite(1)->local_position());
 	return 1;
 }
 
@@ -48,11 +44,7 @@ static int sprite_local_position(lua_State* L)
 static int sprite_local_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Sprite* sprite = stack.get_sprite(1);
-
-	stack.push_quaternion(sprite->local_rotation());
-
+	stack.push_quaternion(stack.get_sprite(1)->local_rotation());
 	return 1;
 }
 
@@ -60,11 +52,7 @@ static int sprite_local_rotation(lua_State* L)
 static int sprite_local_pose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Sprite* sprite = stack.get_sprite(1);
-
-	stack.push_matrix4x4(sprite->local_pose());
-
+	stack.push_matrix4x4(stack.get_sprite(1)->local_pose());
 	return 1;
 }
 
@@ -72,13 +60,7 @@ static int sprite_local_pose(lua_State* L)
 static int sprite_set_local_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Sprite* sprite = stack.get_sprite(1);
-	Unit* unit = stack.get_unit(2);
-	Vector3 pos = stack.get_vector3(3);
-
-	sprite->set_local_position(unit, pos);
-
+	stack.get_sprite(1)->set_local_position(stack.get_unit(2), stack.get_vector3(3));
 	return 0;
 }
 
@@ -86,13 +68,7 @@ static int sprite_set_local_position(lua_State* L)
 static int sprite_set_local_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Sprite* sprite = stack.get_sprite(1);
-	Unit* unit = stack.get_unit(2);
-	Quaternion rot = stack.get_quaternion(3);
-
-	sprite->set_local_rotation(unit, rot);
-
+	stack.get_sprite(1)->set_local_rotation(stack.get_unit(2), stack.get_quaternion(3));
 	return 0;
 }
 
@@ -100,13 +76,7 @@ static int sprite_set_local_rotation(lua_State* L)
 static int sprite_set_local_pose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Sprite* sprite = stack.get_sprite(1);
-	Unit* unit = stack.get_unit(2);
-	Matrix4x4 pose = stack.get_matrix4x4(3);
-
-	sprite->set_local_pose(unit, pose);
-
+	stack.get_sprite(1)->set_local_pose(stack.get_unit(2), stack.get_matrix4x4(3));
 	return 0;
 }
 
@@ -114,22 +84,20 @@ static int sprite_set_local_pose(lua_State* L)
 static int sprite_set_frame(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Sprite* sprite = stack.get_sprite(1);
-	sprite->set_frame(stack.get_int(2));
+	stack.get_sprite(1)->set_frame(stack.get_int(2));
 	return 0;
 }
 
 //-----------------------------------------------------------------------------
 void load_sprite(LuaEnvironment& env)
 {
-	env.load_module_function("Sprite", "local_position", 		sprite_local_position);
-	env.load_module_function("Sprite", "local_rotation", 		sprite_local_rotation);
-	env.load_module_function("Sprite", "local_pose", 			sprite_local_pose);
-	env.load_module_function("Sprite", "set_local_position", 	sprite_set_local_position);
-	env.load_module_function("Sprite", "set_local_rotation", 	sprite_set_local_rotation);
-	env.load_module_function("Sprite", "set_local_pose", 		sprite_set_local_pose);
-	env.load_module_function("Sprite", "set_frame",				sprite_set_frame);
+	env.load_module_function("Sprite", "local_position",     sprite_local_position);
+	env.load_module_function("Sprite", "local_rotation",     sprite_local_rotation);
+	env.load_module_function("Sprite", "local_pose",         sprite_local_pose);
+	env.load_module_function("Sprite", "set_local_position", sprite_set_local_position);
+	env.load_module_function("Sprite", "set_local_rotation", sprite_set_local_rotation);
+	env.load_module_function("Sprite", "set_local_pose",     sprite_set_local_pose);
+	env.load_module_function("Sprite", "set_frame",          sprite_set_frame);
 }
 
 } // namespace crown

engine/lua/lua_string_setting.cpp

@@ -94,9 +94,9 @@ static int string_setting_update(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_string_setting(LuaEnvironment& env)
 {
-	env.load_module_function("StringSetting", "value",		string_setting_value);
-	env.load_module_function("StringSetting", "synopsis",	string_setting_synopsis);
-	env.load_module_function("StringSetting", "update",		string_setting_update);
+	env.load_module_function("StringSetting", "value",    string_setting_value);
+	env.load_module_function("StringSetting", "synopsis", string_setting_synopsis);
+	env.load_module_function("StringSetting", "update",   string_setting_update);
 }
 
 } // namespace crown

engine/lua/lua_touch.cpp

@@ -76,11 +76,11 @@ static int touch_pointer_xy(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_touch(LuaEnvironment& env)
 {
-	env.load_module_function("Touch", "pointer_down",	touch_pointer_down);
-	env.load_module_function("Touch", "pointer_up",		touch_pointer_up);
-	env.load_module_function("Touch", "any_down",		touch_any_down);
-	env.load_module_function("Touch", "any_up",			touch_any_up);
-	env.load_module_function("Touch", "pointer_xy",		touch_pointer_xy);
+	env.load_module_function("Touch", "pointer_down", touch_pointer_down);
+	env.load_module_function("Touch", "pointer_up",   touch_pointer_up);
+	env.load_module_function("Touch", "any_down",     touch_any_down);
+	env.load_module_function("Touch", "any_up",       touch_any_up);
+	env.load_module_function("Touch", "pointer_xy",   touch_pointer_xy);
 }
 
 } // namespace crown

engine/lua/lua_unit.cpp

@@ -35,11 +35,7 @@ namespace crown
 static int unit_node(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const char* name = stack.get_string(2);
-
-	stack.push_int32(unit->node(name));
+	stack.push_int32(stack.get_unit(1)->node(stack.get_string(2)));
 	return 1;
 }
 
@@ -47,11 +43,7 @@ static int unit_node(lua_State* L)
 static int unit_has_node(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const char* name = stack.get_string(2);
-
-	stack.push_bool(unit->has_node(name));
+	stack.push_bool(stack.get_unit(1)->has_node(stack.get_string(2)));
 	return 1;
 }
 
@@ -59,10 +51,7 @@ static int unit_has_node(lua_State* L)
 static int unit_num_nodes(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-
-	stack.push_int32(unit->num_nodes());
+	stack.push_int32(stack.get_unit(1)->num_nodes());
 	return 1;
 }
 
@@ -70,11 +59,7 @@ static int unit_num_nodes(lua_State* L)
 static int unit_local_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const int32_t node = stack.get_int(2);
-
-	stack.push_vector3(unit->local_position(node));
+	stack.push_vector3(stack.get_unit(1)->local_position(stack.get_int(2)));
 	return 1;
 }
 
@@ -82,11 +67,7 @@ static int unit_local_position(lua_State* L)
 static int unit_local_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const int32_t node = stack.get_int(2);
-
-	stack.push_quaternion(unit->local_rotation(node));
+	stack.push_quaternion(stack.get_unit(1)->local_rotation(stack.get_int(2)));
 	return 1;
 }
 
@@ -94,11 +75,7 @@ static int unit_local_rotation(lua_State* L)
 static int unit_local_pose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const int32_t node = stack.get_int(2);
-
-	stack.push_matrix4x4(unit->local_pose(node));
+	stack.push_matrix4x4(stack.get_unit(1)->local_pose(stack.get_int(2)));
 	return 1;
 }
 
@@ -106,11 +83,7 @@ static int unit_local_pose(lua_State* L)
 static int unit_world_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const int32_t node = stack.get_int(2);
-
-	stack.push_vector3(unit->world_position(node));
+	stack.push_vector3(stack.get_unit(1)->world_position(stack.get_int(2)));
 	return 1;
 }
 
@@ -118,11 +91,7 @@ static int unit_world_position(lua_State* L)
 static int unit_world_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const int32_t node = stack.get_int(2);
-
-	stack.push_quaternion(unit->world_rotation(node));
+	stack.push_quaternion(stack.get_unit(1)->world_rotation(stack.get_int(2)));
 	return 1;
 }
 
@@ -130,11 +99,7 @@ static int unit_world_rotation(lua_State* L)
 static int unit_world_pose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const int32_t node = stack.get_int(2);
-
-	stack.push_matrix4x4(unit->world_pose(node));
+	stack.push_matrix4x4(stack.get_unit(1)->world_pose(stack.get_int(2)));
 	return 1;
 }
 
@@ -142,12 +107,7 @@ static int unit_world_pose(lua_State* L)
 static int unit_set_local_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const int32_t node = stack.get_int(2);
-	Vector3& pos = stack.get_vector3(3);
-
-	unit->set_local_position(node, pos);
+	stack.get_unit(1)->set_local_position(stack.get_int(2), stack.get_vector3(3));
 	return 0;
 }
 
@@ -155,12 +115,7 @@ static int unit_set_local_position(lua_State* L)
 static int unit_set_local_rotation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const int32_t node = stack.get_int(2);
-	Quaternion& rot = stack.get_quaternion(3);
-
-	unit->set_local_rotation(node, rot);
+	stack.get_unit(1)->set_local_rotation(stack.get_int(2), stack.get_quaternion(3));
 	return 0;
 }
 
@@ -168,12 +123,7 @@ static int unit_set_local_rotation(lua_State* L)
 static int unit_set_local_pose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const int32_t node = stack.get_int(2);
-	Matrix4x4& pose = stack.get_matrix4x4(3);
-
-	unit->set_local_pose(node, pose);
+	stack.get_unit(1)->set_local_pose(stack.get_int(2), stack.get_matrix4x4(3));
 	return 0;
 }
 
@@ -181,12 +131,7 @@ static int unit_set_local_pose(lua_State* L)
 static int unit_link_node(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const int32_t child = stack.get_int(2);
-	const int32_t parent = stack.get_int(3);
-
-	unit->link_node(child, parent);
+	stack.get_unit(1)->link_node(stack.get_int(2), stack.get_int(3));
 	return 0;
 }
 
@@ -194,11 +139,7 @@ static int unit_link_node(lua_State* L)
 static int unit_unlink_node(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const int32_t child = stack.get_int(2);
-
-	unit->unlink_node(child);
+	stack.get_unit(1)->unlink_node(stack.get_int(2));
 	return 0;
 }
 
@@ -291,11 +232,8 @@ static int unit_actor(lua_State* L)
 static int unit_controller(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-
-	Controller* controller = unit->controller();
-	controller ? stack.push_controller(controller) : stack.push_nil();
+	Controller* ctl = stack.get_unit(1)->controller();
+	ctl ? stack.push_controller(ctl) : stack.push_nil();
 	return 1;
 }
 
@@ -303,11 +241,7 @@ static int unit_controller(lua_State* L)
 static int unit_is_a(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const char* name = stack.get_string(2);
-
-	stack.push_bool(unit->is_a(name));
+	stack.push_bool(stack.get_unit(1)->is_a(stack.get_string(2)));
 	return 1;
 }
 
@@ -315,10 +249,7 @@ static int unit_is_a(lua_State* L)
 static int unit_play_sprite_animation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	const char* anim = stack.get_string(2);
-	unit->play_sprite_animation(anim, stack.get_bool(3));
+	stack.get_unit(1)->play_sprite_animation(stack.get_string(2), stack.get_bool(3));
 	return 0;
 }
 
@@ -326,9 +257,7 @@ static int unit_play_sprite_animation(lua_State* L)
 static int unit_stop_sprite_animation(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	unit->stop_sprite_animation();
+	stack.get_unit(1)->stop_sprite_animation();
 	return 0;
 }
 
@@ -336,9 +265,7 @@ static int unit_stop_sprite_animation(lua_State* L)
 static int unit_has_key(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Unit* unit = stack.get_unit(1);
-	stack.push_bool(unit->has_key(stack.get_string(2)));
+	stack.push_bool(stack.get_unit(1)->has_key(stack.get_string(2)));
 	return 1;
 }
 
@@ -409,37 +336,32 @@ static int unit_set_key(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_unit(LuaEnvironment& env)
 {
-	env.load_module_function("Unit", "node",					unit_node);
-	env.load_module_function("Unit", "has_node",				unit_has_node);
-	env.load_module_function("Unit", "num_nodes",				unit_num_nodes);
-
-	env.load_module_function("Unit", "local_position",			unit_local_position);
-	env.load_module_function("Unit", "local_rotation",			unit_local_rotation);
-	env.load_module_function("Unit", "local_pose",				unit_local_pose);
-	env.load_module_function("Unit", "world_position",			unit_world_position);
-	env.load_module_function("Unit", "world_rotation",			unit_world_rotation);
-	env.load_module_function("Unit", "world_pose",				unit_world_pose);
-	env.load_module_function("Unit", "set_local_position",		unit_set_local_position);
-	env.load_module_function("Unit", "set_local_rotation",		unit_set_local_rotation);
-	env.load_module_function("Unit", "set_local_pose",			unit_set_local_pose);
-	env.load_module_function("Unit", "link_node",				unit_link_node);
-	env.load_module_function("Unit", "unlink_node",				unit_unlink_node);
-
-	env.load_module_function("Unit", "camera",					unit_camera);
-	env.load_module_function("Unit", "material",				unit_material);
-	env.load_module_function("Unit", "mesh",					unit_mesh);
-	env.load_module_function("Unit", "sprite",					unit_sprite);
-	env.load_module_function("Unit", "actor",					unit_actor);
-	env.load_module_function("Unit", "controller",				unit_controller);
-
-	env.load_module_function("Unit", "is_a",					unit_is_a);
-
-	env.load_module_function("Unit", "play_sprite_animation",	unit_play_sprite_animation);
-	env.load_module_function("Unit", "stop_sprite_animation",	unit_stop_sprite_animation);
-
-	env.load_module_function("Unit", "has_key",					unit_has_key);
-	env.load_module_function("Unit", "get_key",					unit_get_key);
-	env.load_module_function("Unit", "set_key",					unit_set_key);
+	env.load_module_function("Unit", "node",                  unit_node);
+	env.load_module_function("Unit", "has_node",              unit_has_node);
+	env.load_module_function("Unit", "num_nodes",             unit_num_nodes);
+	env.load_module_function("Unit", "local_position",        unit_local_position);
+	env.load_module_function("Unit", "local_rotation",        unit_local_rotation);
+	env.load_module_function("Unit", "local_pose",            unit_local_pose);
+	env.load_module_function("Unit", "world_position",        unit_world_position);
+	env.load_module_function("Unit", "world_rotation",        unit_world_rotation);
+	env.load_module_function("Unit", "world_pose",            unit_world_pose);
+	env.load_module_function("Unit", "set_local_position",    unit_set_local_position);
+	env.load_module_function("Unit", "set_local_rotation",    unit_set_local_rotation);
+	env.load_module_function("Unit", "set_local_pose",        unit_set_local_pose);
+	env.load_module_function("Unit", "link_node",             unit_link_node);
+	env.load_module_function("Unit", "unlink_node",           unit_unlink_node);
+	env.load_module_function("Unit", "camera",                unit_camera);
+	env.load_module_function("Unit", "material",              unit_material);
+	env.load_module_function("Unit", "mesh",                  unit_mesh);
+	env.load_module_function("Unit", "sprite",                unit_sprite);
+	env.load_module_function("Unit", "actor",                 unit_actor);
+	env.load_module_function("Unit", "controller",            unit_controller);
+	env.load_module_function("Unit", "is_a",                  unit_is_a);
+	env.load_module_function("Unit", "play_sprite_animation", unit_play_sprite_animation);
+	env.load_module_function("Unit", "stop_sprite_animation", unit_stop_sprite_animation);
+	env.load_module_function("Unit", "has_key",               unit_has_key);
+	env.load_module_function("Unit", "get_key",               unit_get_key);
+	env.load_module_function("Unit", "set_key",               unit_set_key);
 }
 
 } // namespace crown

engine/lua/lua_vector2.cpp

@@ -35,12 +35,7 @@ namespace crown
 static int vector2_new(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-	float y = stack.get_float(2);
-
-	stack.push_vector2(Vector2(x, y));
-
+	stack.push_vector2(Vector2(stack.get_float(1), stack.get_float(2)));
 	return 1;
 }
 
@@ -56,10 +51,7 @@ static int vector2_ctor(lua_State* L)
 static int vector2_x(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Vector2& a = stack.get_vector2(1);
-
-	stack.push_float(a.x);
+	stack.push_float(stack.get_vector2(1).x);
 	return 1;
 }
 
@@ -67,10 +59,7 @@ static int vector2_x(lua_State* L)
 static int vector2_y(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Vector2& a = stack.get_vector2(1);
-
-	stack.push_float(a.y);
+	stack.push_float(stack.get_vector2(1).y);
 	return 1;
 }
 
@@ -78,11 +67,7 @@ static int vector2_y(lua_State* L)
 static int vector2_set_x(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-	const float val = stack.get_float(2);
-
-	a.x = val;
+	stack.get_vector2(1).x = stack.get_float(2);
 	return 0;
 }
 
@@ -90,11 +75,7 @@ static int vector2_set_x(lua_State* L)
 static int vector2_set_y(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-	const float val = stack.get_float(2);
-
-	a.y = val;
+	stack.get_vector2(1).y = stack.get_float(2);
 	return 0;
 }
 
@@ -102,12 +83,9 @@ static int vector2_set_y(lua_State* L)
 static int vector2_values(lua_State* L)
 {
 	LuaStack stack(L);
-
 	Vector2& a = stack.get_vector2(1);
-
 	stack.push_float(a.x);
 	stack.push_float(a.y);
-
 	return 2;
 }
 
@@ -115,12 +93,7 @@ static int vector2_values(lua_State* L)
 static int vector2_add(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-	Vector2& b = stack.get_vector2(2);
-
-	stack.push_vector2(a + b);
-
+	stack.push_vector2(stack.get_vector2(1) + stack.get_vector2(2));
 	return 1;
 }
 
@@ -128,12 +101,7 @@ static int vector2_add(lua_State* L)
 static int vector2_subtract(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-	Vector2& b = stack.get_vector2(2);
-
-	stack.push_vector2(a - b);
-
+	stack.push_vector2(stack.get_vector2(1) - stack.get_vector2(2));
 	return 1;
 }
 
@@ -141,12 +109,7 @@ static int vector2_subtract(lua_State* L)
 static int vector2_multiply(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-	float k = stack.get_float(2);
-
-	stack.push_vector2(a * k);
-
+	stack.push_vector2(stack.get_vector2(1) * stack.get_float(2));
 	return 1;
 }
 
@@ -154,12 +117,7 @@ static int vector2_multiply(lua_State* L)
 static int vector2_divide(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-	float k = stack.get_float(2);
-
-	stack.push_vector2(a / k);
-
+	stack.push_vector2(stack.get_vector2(1) / stack.get_float(2));
 	return 1;
 }
 
@@ -167,12 +125,7 @@ static int vector2_divide(lua_State* L)
 static int vector2_dot(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-	Vector2& b = stack.get_vector2(2);
-
-	stack.push_float(vector2::dot(a, b));
-
+	stack.push_float(vector2::dot(stack.get_vector2(1), stack.get_vector2(2)));
 	return 1;
 }
 
@@ -180,12 +133,7 @@ static int vector2_dot(lua_State* L)
 static int vector2_equal(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-	Vector2& b = stack.get_vector2(2);
-
-	stack.push_bool(a == b);
-
+	stack.push_bool(stack.get_vector2(1) == stack.get_vector2(2));
 	return 1;
 }
 
@@ -193,11 +141,7 @@ static int vector2_equal(lua_State* L)
 static int vector2_length(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-
-	stack.push_float(vector2::length(a));
-
+	stack.push_float(vector2::length(stack.get_vector2(1)));
 	return 1;
 }
 
@@ -205,11 +149,7 @@ static int vector2_length(lua_State* L)
 static int vector2_squared_length(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-
-	stack.push_float(vector2::squared_length(a));
-
+	stack.push_float(vector2::squared_length(stack.get_vector2(1)));
 	return 1;
 }
 
@@ -217,12 +157,7 @@ static int vector2_squared_length(lua_State* L)
 static int vector2_set_length(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-	float len = stack.get_float(2);
-
-	vector2::set_length(a, len);
-
+	vector2::set_length(stack.get_vector2(1), stack.get_float(2));
 	return 0;
 }
 
@@ -230,11 +165,7 @@ static int vector2_set_length(lua_State* L)
 static int vector2_normalize(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-
-	stack.push_vector2(vector2::normalize(a));
-
+	stack.push_vector2(vector2::normalize(stack.get_vector2(1)));
 	return 1;
 }
 
@@ -242,12 +173,7 @@ static int vector2_normalize(lua_State* L)
 static int vector2_distance(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-	Vector2& b = stack.get_vector2(2);
-
-	stack.push_float(vector2::distance(a, b));
-
+	stack.push_float(vector2::distance(stack.get_vector2(1), stack.get_vector2(2)));
 	return 1;
 }
 
@@ -255,38 +181,33 @@ static int vector2_distance(lua_State* L)
 static int vector2_angle(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector2& a = stack.get_vector2(1);
-	Vector2& b = stack.get_vector2(2);
-
-	stack.push_float(vector2::angle(a, b));
-
+	stack.push_float(vector2::angle(stack.get_vector2(1), stack.get_vector2(2)));
 	return 1;
 }
 
 //-----------------------------------------------------------------------------
 void load_vector2(LuaEnvironment& env)
 {
-	env.load_module_function("Vector2", "new",					vector2_new);
-	env.load_module_function("Vector2", "x", 					vector2_x);
-	env.load_module_function("Vector2", "y", 					vector2_y);
-	env.load_module_function("Vector2", "set_x", 				vector2_set_x);
-	env.load_module_function("Vector2", "set_y", 				vector2_set_y);
-	env.load_module_function("Vector2", "values",				vector2_values);
-	env.load_module_function("Vector2", "add",					vector2_add);
-	env.load_module_function("Vector2", "subtract",				vector2_subtract);
-	env.load_module_function("Vector2", "multiply",				vector2_multiply);
-	env.load_module_function("Vector2", "divide",				vector2_divide);
-	env.load_module_function("Vector2", "dot",					vector2_dot);
-	env.load_module_function("Vector2", "equal",				vector2_equal);
-	env.load_module_function("Vector2", "length",				vector2_length);
-	env.load_module_function("Vector2", "squared_length",		vector2_squared_length);
-	env.load_module_function("Vector2", "set_length",			vector2_set_length);
-	env.load_module_function("Vector2", "normalize",			vector2_normalize);
-	env.load_module_function("Vector2", "distance",				vector2_distance);
-	env.load_module_function("Vector2", "angle",				vector2_angle);
-
-	env.load_module_constructor("Vector2",						vector2_ctor);
+	env.load_module_function("Vector2", "new",            vector2_new);
+	env.load_module_function("Vector2", "x",              vector2_x);
+	env.load_module_function("Vector2", "y",              vector2_y);
+	env.load_module_function("Vector2", "set_x",          vector2_set_x);
+	env.load_module_function("Vector2", "set_y",          vector2_set_y);
+	env.load_module_function("Vector2", "values",         vector2_values);
+	env.load_module_function("Vector2", "add",            vector2_add);
+	env.load_module_function("Vector2", "subtract",       vector2_subtract);
+	env.load_module_function("Vector2", "multiply",       vector2_multiply);
+	env.load_module_function("Vector2", "divide",         vector2_divide);
+	env.load_module_function("Vector2", "dot",            vector2_dot);
+	env.load_module_function("Vector2", "equal",          vector2_equal);
+	env.load_module_function("Vector2", "length",         vector2_length);
+	env.load_module_function("Vector2", "squared_length", vector2_squared_length);
+	env.load_module_function("Vector2", "set_length",     vector2_set_length);
+	env.load_module_function("Vector2", "normalize",      vector2_normalize);
+	env.load_module_function("Vector2", "distance",       vector2_distance);
+	env.load_module_function("Vector2", "angle",          vector2_angle);
+
+	env.load_module_constructor("Vector2", vector2_ctor);
 }
 
 } // namespace crown

engine/lua/lua_vector2_box.cpp

@@ -149,14 +149,14 @@ static int vector2box_tostring(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_vector2box(LuaEnvironment& env)
 {
-	env.load_module_function("Vector2Box", "new",			vector2box_new);
-	env.load_module_function("Vector2Box", "store",			vector2box_store);
-	env.load_module_function("Vector2Box", "unbox",			vector2box_unbox);
-	env.load_module_function("Vector2Box", "__index",		vector2box_get_value);
-	env.load_module_function("Vector2Box", "__newindex",	vector2box_set_value);
-	env.load_module_function("Vector2Box", "__tostring",	vector2box_tostring);
-
-	env.load_module_constructor("Vector2Box",				vector2box_ctor);
+	env.load_module_function("Vector2Box", "new",        vector2box_new);
+	env.load_module_function("Vector2Box", "store",      vector2box_store);
+	env.load_module_function("Vector2Box", "unbox",      vector2box_unbox);
+	env.load_module_function("Vector2Box", "__index",    vector2box_get_value);
+	env.load_module_function("Vector2Box", "__newindex", vector2box_set_value);
+	env.load_module_function("Vector2Box", "__tostring", vector2box_tostring);
+	
+	env.load_module_constructor("Vector2Box", vector2box_ctor);
 }
 
 } // namespace crown

engine/lua/lua_vector3.cpp

@@ -35,13 +35,7 @@ namespace crown
 static int vector3_new(lua_State* L)
 {
 	LuaStack stack(L);
-
-	float x = stack.get_float(1);
-	float y = stack.get_float(2);
-	float z = stack.get_float(3);
-
-	stack.push_vector3(Vector3(x, y, z));
-
+	stack.push_vector3(Vector3(stack.get_float(1), stack.get_float(2), stack.get_float(3)));
 	return 1;
 }
 
@@ -57,10 +51,7 @@ static int vector3_ctor(lua_State* L)
 static int vector3_x(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Vector3& a = stack.get_vector3(1);
-
-	stack.push_float(a.x);
+	stack.push_float(stack.get_vector3(1).x);
 	return 1;
 }
 
@@ -68,10 +59,7 @@ static int vector3_x(lua_State* L)
 static int vector3_y(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Vector3& a = stack.get_vector3(1);
-
-	stack.push_float(a.y);
+	stack.push_float(stack.get_vector3(1).y);
 	return 1;
 }
 
@@ -79,10 +67,7 @@ static int vector3_y(lua_State* L)
 static int vector3_z(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const Vector3& a = stack.get_vector3(1);
-
-	stack.push_float(a.z);
+	stack.push_float(stack.get_vector3(1).z);
 	return 1;
 }
 
@@ -90,11 +75,7 @@ static int vector3_z(lua_State* L)
 static int vector3_set_x(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	const float val = stack.get_float(2);
-
-	a.x = val;
+	stack.get_vector3(1).x = stack.get_float(2);
 	return 0;
 }
 
@@ -102,11 +83,7 @@ static int vector3_set_x(lua_State* L)
 static int vector3_set_y(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	const float val = stack.get_float(2);
-
-	a.y = val;
+	stack.get_vector3(1).y = stack.get_float(2);
 	return 0;
 }
 
@@ -114,11 +91,7 @@ static int vector3_set_y(lua_State* L)
 static int vector3_set_z(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	const float val = stack.get_float(2);
-
-	a.z = val;
+	stack.get_vector3(1).z = stack.get_float(2);
 	return 0;
 }
 
@@ -126,13 +99,10 @@ static int vector3_set_z(lua_State* L)
 static int vector3_values(lua_State* L)
 {
 	LuaStack stack(L);
-
 	Vector3& a = stack.get_vector3(1);
-
 	stack.push_float(a.x);
 	stack.push_float(a.y);
 	stack.push_float(a.z);
-
 	return 3;
 }
 
@@ -140,12 +110,7 @@ static int vector3_values(lua_State* L)
 static int vector3_add(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	Vector3& b = stack.get_vector3(2);
-
-	stack.push_vector3(a + b);
-
+	stack.push_vector3(stack.get_vector3(1) + stack.get_vector3(2));
 	return 1;
 }
 
@@ -153,12 +118,7 @@ static int vector3_add(lua_State* L)
 static int vector3_subtract(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	Vector3& b = stack.get_vector3(2);
-
-	stack.push_vector3(a - b);
-
+	stack.push_vector3(stack.get_vector3(1) - stack.get_vector3(2));
 	return 1;
 }
 
@@ -166,12 +126,7 @@ static int vector3_subtract(lua_State* L)
 static int vector3_multiply(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	float b = stack.get_float(2);
-
-	stack.push_vector3(a * b);
-
+	stack.push_vector3(stack.get_vector3(1) * stack.get_float(2));
 	return 1;
 }
 
@@ -179,12 +134,7 @@ static int vector3_multiply(lua_State* L)
 static int vector3_divide(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	float b = stack.get_float(2);
-
-	stack.push_vector3(a / b);
-
+	stack.push_vector3(stack.get_vector3(1) / stack.get_float(2));
 	return 1;
 }
 
@@ -192,12 +142,7 @@ static int vector3_divide(lua_State* L)
 static int vector3_dot(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	Vector3& b = stack.get_vector3(2);
-
-	stack.push_float(vector3::dot(a, b));
-
+	stack.push_float(vector3::dot(stack.get_vector3(1), stack.get_vector3(2)));
 	return 1;
 }
 
@@ -205,12 +150,7 @@ static int vector3_dot(lua_State* L)
 static int vector3_cross(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	Vector3& b = stack.get_vector3(2);
-
-	stack.push_vector3(vector3::cross(a, b));
-
+	stack.push_vector3(vector3::cross(stack.get_vector3(1), stack.get_vector3(2)));
 	return 1;
 }
 
@@ -218,12 +158,7 @@ static int vector3_cross(lua_State* L)
 static int vector3_equal(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	Vector3& b = stack.get_vector3(2);
-
-	stack.push_bool(a == b);
-
+	stack.push_bool(stack.get_vector3(1) == stack.get_vector3(2));
 	return 1;
 }
 
@@ -231,11 +166,7 @@ static int vector3_equal(lua_State* L)
 static int vector3_length(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-
-	stack.push_float(vector3::length(a));
-
+	stack.push_float(vector3::length(stack.get_vector3(1)));
 	return 1;
 }
 
@@ -243,11 +174,7 @@ static int vector3_length(lua_State* L)
 static int vector3_squared_length(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-
-	stack.push_float(vector3::squared_length(a));
-
+	stack.push_float(vector3::squared_length(stack.get_vector3(1)));
 	return 1;
 }
 
@@ -255,12 +182,7 @@ static int vector3_squared_length(lua_State* L)
 static int vector3_set_length(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	float len = stack.get_float(2);
-
-	vector3::set_length(a, len);
-
+	vector3::set_length(stack.get_vector3(1), stack.get_float(2));
 	return 0;
 }
 
@@ -268,11 +190,7 @@ static int vector3_set_length(lua_State* L)
 static int vector3_normalize(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-
-	stack.push_vector3(vector3::normalize(a));
-
+	stack.push_vector3(vector3::normalize(stack.get_vector3(1)));
 	return 1;
 }
 
@@ -280,12 +198,7 @@ static int vector3_normalize(lua_State* L)
 static int vector3_distance(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	Vector3& b = stack.get_vector3(2);
-
-	stack.push_float(vector3::distance(a, b));
-
+	stack.push_float(vector3::distance(stack.get_vector3(1), stack.get_vector3(2)));
 	return 1;
 }
 
@@ -293,41 +206,36 @@ static int vector3_distance(lua_State* L)
 static int vector3_angle(lua_State* L)
 {
 	LuaStack stack(L);
-
-	Vector3& a = stack.get_vector3(1);
-	Vector3& b = stack.get_vector3(2);
-
-	stack.push_float(vector3::angle(a, b));
-
+	stack.push_float(vector3::angle(stack.get_vector3(1), stack.get_vector3(2)));
 	return 1;
 }
 
 //-----------------------------------------------------------------------------
 void load_vector3(LuaEnvironment& env)
 {
-	env.load_module_function("Vector3", "new", 				vector3_new);
-	env.load_module_function("Vector3", "x", 				vector3_x);
-	env.load_module_function("Vector3", "y", 				vector3_y);
-	env.load_module_function("Vector3", "z", 				vector3_z);
-	env.load_module_function("Vector3", "set_x", 			vector3_set_x);
-	env.load_module_function("Vector3", "set_y", 			vector3_set_y);
-	env.load_module_function("Vector3", "set_z", 			vector3_set_z);
-	env.load_module_function("Vector3", "values", 			vector3_values);
-	env.load_module_function("Vector3", "add", 				vector3_add);
-	env.load_module_function("Vector3", "subtract", 		vector3_subtract);
-	env.load_module_function("Vector3", "multiply", 		vector3_multiply);
-	env.load_module_function("Vector3", "divide", 			vector3_divide);
-	env.load_module_function("Vector3", "dot", 				vector3_dot);
-	env.load_module_function("Vector3", "cross", 			vector3_cross);
-	env.load_module_function("Vector3", "equal", 			vector3_equal);
-	env.load_module_function("Vector3", "length", 			vector3_length);
-	env.load_module_function("Vector3", "squared_length", 	vector3_squared_length);
-	env.load_module_function("Vector3", "set_length", 		vector3_set_length);
-	env.load_module_function("Vector3", "normalize", 		vector3_normalize);
-	env.load_module_function("Vector3", "distance", 		vector3_distance);
-	env.load_module_function("Vector3", "angle",			vector3_angle);
-
-	env.load_module_constructor("Vector3",					vector3_ctor);
+	env.load_module_function("Vector3", "new",            vector3_new);
+	env.load_module_function("Vector3", "x",              vector3_x);
+	env.load_module_function("Vector3", "y",              vector3_y);
+	env.load_module_function("Vector3", "z",              vector3_z);
+	env.load_module_function("Vector3", "set_x",          vector3_set_x);
+	env.load_module_function("Vector3", "set_y",          vector3_set_y);
+	env.load_module_function("Vector3", "set_z",          vector3_set_z);
+	env.load_module_function("Vector3", "values",         vector3_values);
+	env.load_module_function("Vector3", "add",            vector3_add);
+	env.load_module_function("Vector3", "subtract",       vector3_subtract);
+	env.load_module_function("Vector3", "multiply",       vector3_multiply);
+	env.load_module_function("Vector3", "divide",         vector3_divide);
+	env.load_module_function("Vector3", "dot",            vector3_dot);
+	env.load_module_function("Vector3", "cross",          vector3_cross);
+	env.load_module_function("Vector3", "equal",          vector3_equal);
+	env.load_module_function("Vector3", "length",         vector3_length);
+	env.load_module_function("Vector3", "squared_length", vector3_squared_length);
+	env.load_module_function("Vector3", "set_length",     vector3_set_length);
+	env.load_module_function("Vector3", "normalize",      vector3_normalize);
+	env.load_module_function("Vector3", "distance",       vector3_distance);
+	env.load_module_function("Vector3", "angle",          vector3_angle);
+
+	env.load_module_constructor("Vector3", vector3_ctor);
 }
 
 } // namespace crown

engine/lua/lua_vector3_box.cpp

@@ -160,14 +160,14 @@ static int vector3box_tostring(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_vector3box(LuaEnvironment& env)
 {
-	env.load_module_function("Vector3Box", "new",			vector3box_new);
-	env.load_module_function("Vector3Box", "store",			vector3box_store);
-	env.load_module_function("Vector3Box", "unbox",			vector3box_unbox);
-	env.load_module_function("Vector3Box", "__index",		vector3box_get_value);
-	env.load_module_function("Vector3Box", "__newindex",	vector3box_set_value);
-	env.load_module_function("Vector3Box", "__tostring",	vector3box_tostring);
-
-	env.load_module_constructor("Vector3Box",				vector3box_ctor);
+	env.load_module_function("Vector3Box", "new",        vector3box_new);
+	env.load_module_function("Vector3Box", "store",      vector3box_store);
+	env.load_module_function("Vector3Box", "unbox",      vector3box_unbox);
+	env.load_module_function("Vector3Box", "__index",    vector3box_get_value);
+	env.load_module_function("Vector3Box", "__newindex", vector3box_set_value);
+	env.load_module_function("Vector3Box", "__tostring", vector3box_tostring);
+	
+	env.load_module_constructor("Vector3Box", vector3box_ctor);
 }
 
 } // namespace crown

engine/lua/lua_window.cpp

@@ -46,9 +46,7 @@ namespace crown
 static int window_show(lua_State* L)
 {
 	LuaStack stack(L);
-
 	// window()->show();
-
 	return 0;
 }
 
@@ -56,9 +54,7 @@ static int window_show(lua_State* L)
 static int window_hide(lua_State* L)
 {
 	LuaStack stack(L);
-
 	// window()->hide();
-
 	return 0;
 }
 
@@ -66,12 +62,7 @@ static int window_hide(lua_State* L)
 static int window_resize(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const int32_t w = stack.get_int(1);
-	const int32_t h = stack.get_int(2);
-
-	// window()->resize(w, h);
-
+	// window()->resize(stack.get_int(1), stack.get_int(2));
 	return 0;
 }
 
@@ -79,12 +70,7 @@ static int window_resize(lua_State* L)
 static int window_move(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const int32_t x = stack.get_int(1);
-	const int32_t y = stack.get_int(2);
-
-	// window()->move(x, y);
-
+	// window()->move(stack.get_int(1), stack.get_int(2));
 	return 0;
 }
 
@@ -106,9 +92,7 @@ static int window_restore(lua_State* /*L*/)
 static int window_is_resizable(lua_State* L)
 {
 	LuaStack stack(L);
-
 	stack.push_bool(/*window()->is_resizable()*/ false);
-
 	return 1;
 }
 
@@ -116,9 +100,7 @@ static int window_is_resizable(lua_State* L)
 static int window_set_resizable(lua_State* L)
 {
 	LuaStack stack(L);
-
 	// window()->set_resizable(stack.get_bool(1));
-
 	return 0;
 }
 
@@ -126,11 +108,8 @@ static int window_set_resizable(lua_State* L)
 static int window_title(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const char* title = ""; // window()->title();
-
-	stack.push_string(title);
-
+	// stack.push_string(window()->title());
+	stack.push_string("");
 	return 1;
 }
 
@@ -138,27 +117,23 @@ static int window_title(lua_State* L)
 static int window_set_title(lua_State* L)
 {
 	LuaStack stack(L);
-
-	const char* title = stack.get_string(1);
-
-	// window()->set_title(title);
-
+	// window()->set_title(stack.get_string(1));
 	return 0;
 }
 
 //-----------------------------------------------------------------------------
 void load_window(LuaEnvironment& env)
 {
-	env.load_module_function("Window", "show",			window_show);
-	env.load_module_function("Window", "hide",			window_hide);
-	env.load_module_function("Window", "resize",		window_resize);
-	env.load_module_function("Window", "move",			window_move);
-	env.load_module_function("Window", "minimize",		window_minimize);
-	env.load_module_function("Window", "restore",		window_restore);
-	env.load_module_function("Window", "is_resizable",	window_is_resizable);
-	env.load_module_function("Window", "set_resizable",	window_set_resizable);
-	env.load_module_function("Window", "title",			window_title);
-	env.load_module_function("Window", "set_title",		window_set_title);
+	env.load_module_function("Window", "show",          window_show);
+	env.load_module_function("Window", "hide",          window_hide);
+	env.load_module_function("Window", "resize",        window_resize);
+	env.load_module_function("Window", "move",          window_move);
+	env.load_module_function("Window", "minimize",      window_minimize);
+	env.load_module_function("Window", "restore",       window_restore);
+	env.load_module_function("Window", "is_resizable",  window_is_resizable);
+	env.load_module_function("Window", "set_resizable", window_set_resizable);
+	env.load_module_function("Window", "title",         window_title);
+	env.load_module_function("Window", "set_title",     window_set_title);
 }
 
 } // namespace crown

engine/lua/lua_world.cpp

@@ -55,11 +55,7 @@ static int world_spawn_unit(lua_State* L)
 static int world_destroy_unit(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-	Unit* unit = stack.get_unit(2);
-
-	world->destroy_unit(unit->id());
+	stack.get_world(1)->destroy_unit(stack.get_unit(2)->id());
 	return 0;
 }
 
@@ -67,10 +63,7 @@ static int world_destroy_unit(lua_State* L)
 static int world_num_units(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-
-	stack.push_uint32(world->num_units());
+	stack.push_uint32(stack.get_world(1)->num_units());
 	return 1;
 }
 
@@ -80,10 +73,8 @@ static int world_units(lua_State* L)
 	LuaStack stack(L);
 
 	World* world = stack.get_world(1);
-
 	TempAllocator1024 alloc;
 	Array<UnitId> all_units(alloc);
-
 	world->units(all_units);
 
 	stack.push_table();
@@ -128,15 +119,14 @@ static int world_play_sound(lua_State* L)
 
 	World* world = stack.get_world(1);
 	const char* name = stack.get_string(2);
+	int32_t nargs = stack.num_args();
 
-	const bool loop = stack.num_args() > 2 ? stack.get_bool(3) : false;
-	const float volume = stack.num_args() > 3 ? stack.get_float(4) : 1.0f;
-	const Vector3& pos = stack.num_args() > 4 ? stack.get_vector3(5) : vector3::ZERO;
-	const float range = stack.num_args() > 5 ? stack.get_float(6) : 1000.0f;
+	const bool loop = nargs > 2 ? stack.get_bool(3) : false;
+	const float volume = nargs > 3 ? stack.get_float(4) : 1.0f;
+	const Vector3& pos = nargs > 4 ? stack.get_vector3(5) : vector3::ZERO;
+	const float range = nargs > 5 ? stack.get_float(6) : 1000.0f;
 
-	SoundInstanceId id = world->play_sound(name, loop, volume, pos, range);
-
-	stack.push_sound_instance_id(id);
+	stack.push_sound_instance_id(world->play_sound(name, loop, volume, pos, range));
 	return 1;
 }
 
@@ -144,11 +134,7 @@ static int world_play_sound(lua_State* L)
 static int world_stop_sound(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-	const SoundInstanceId id = stack.get_sound_instance_id(2);
-
-	world->stop_sound(id);
+	stack.get_world(1)->stop_sound(stack.get_sound_instance_id(2));
 	return 0;
 }
 
@@ -156,13 +142,9 @@ static int world_stop_sound(lua_State* L)
 static int world_link_sound(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-	const SoundInstanceId id = stack.get_sound_instance_id(2);
-	Unit* unit = stack.get_unit(3);
-	const int32_t node = stack.get_int(4);
-
-	world->link_sound(id, unit, node);
+	stack.get_world(1)->link_sound(stack.get_sound_instance_id(2),
+		stack.get_unit(3),
+		stack.get_int(4));
 	return 0;
 }
 
@@ -170,10 +152,7 @@ static int world_link_sound(lua_State* L)
 static int world_set_listener_pose(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-
-	world->set_listener_pose(stack.get_matrix4x4(2));
+	stack.get_world(1)->set_listener_pose(stack.get_matrix4x4(2));
 	return 0;
 }
 
@@ -181,12 +160,8 @@ static int world_set_listener_pose(lua_State* L)
 static int world_set_sound_position(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-	const SoundInstanceId id = stack.get_sound_instance_id(2);
-	const Vector3& pos = stack.get_vector3(3);
-
-	world->set_sound_position(id, pos);
+	stack.get_world(1)->set_sound_position(stack.get_sound_instance_id(2),
+		stack.get_vector3(3));
 	return 0;
 }
 
@@ -194,12 +169,8 @@ static int world_set_sound_position(lua_State* L)
 static int world_set_sound_range(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-	const SoundInstanceId id = stack.get_sound_instance_id(2);
-	float range = stack.get_float(3);
-
-	world->set_sound_range(id, range);
+	stack.get_world(1)->set_sound_range(stack.get_sound_instance_id(2),
+		stack.get_float(3));
 	return 0;
 }
 
@@ -207,12 +178,8 @@ static int world_set_sound_range(lua_State* L)
 static int world_set_sound_volume(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-	const SoundInstanceId id = stack.get_sound_instance_id(2);
-	float vol = stack.get_float(3);
-
-	world->set_sound_volume(id, vol);
+	stack.get_world(1)->set_sound_volume(stack.get_sound_instance_id(2),
+		stack.get_float(3));
 	return 0;
 }
 
@@ -220,10 +187,8 @@ static int world_set_sound_volume(lua_State* L)
 static int world_create_window_gui(lua_State* L)
 {
 	LuaStack stack(L);
-
 	World* world = stack.get_world(1);
 	GuiId id = world->create_window_gui(stack.get_int(2), stack.get_int(3), stack.get_string(4));
-
 	stack.push_gui(world->get_gui(id));
 	return 1;
 }
@@ -232,69 +197,48 @@ static int world_create_window_gui(lua_State* L)
 static int world_destroy_gui(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-	Gui* gui = stack.get_gui(2);
-
-	world->destroy_gui(gui->id());
-
+	stack.get_world(1)->destroy_gui(stack.get_gui(2)->id());
 	return 0;
 }
 
 //-----------------------------------------------------------------------------
-static int world_physics_world(lua_State* L)
+static int world_create_debug_line(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-
-	stack.push_physics_world(world->physics_world());
+	stack.push_debug_line(stack.get_world(1)->create_debug_line(stack.get_bool(2)));
 	return 1;
 }
 
 //-----------------------------------------------------------------------------
-static int world_sound_world(lua_State* L)
+static int world_destroy_debug_line(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-
-	stack.push_sound_world(world->sound_world());
-	return 1;
+	stack.get_world(1)->destroy_debug_line(stack.get_debug_line(2));
+	return 0;
 }
 
 //-----------------------------------------------------------------------------
-static int world_create_debug_line(lua_State* L)
+static int world_load_level(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-	const bool depth_test = stack.get_bool(2);
-
-	stack.push_debug_line(world->create_debug_line(depth_test));
-	return 1;
+	stack.get_world(1)->load_level(stack.get_string(2));
+	return 0;
 }
 
 //-----------------------------------------------------------------------------
-static int world_destroy_debug_line(lua_State* L)
+static int world_physics_world(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-	DebugLine* line = stack.get_debug_line(2);
-
-	world->destroy_debug_line(line);
-	return 0;
+	stack.push_physics_world(stack.get_world(1)->physics_world());
+	return 1;
 }
 
 //-----------------------------------------------------------------------------
-static int world_load_level(lua_State* L)
+static int world_sound_world(lua_State* L)
 {
 	LuaStack stack(L);
-
-	World* world = stack.get_world(1);
-	world->load_level(stack.get_string(2));
-	return 0;
+	stack.push_sound_world(stack.get_world(1)->sound_world());
+	return 1;
 }
 
 //-----------------------------------------------------------------------------
@@ -309,36 +253,29 @@ static int world_tostring(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_world(LuaEnvironment& env)
 {
-	env.load_module_function("World", "spawn_unit",			world_spawn_unit);
+	env.load_module_function("World", "spawn_unit",         world_spawn_unit);
 	env.load_module_function("World", "destroy_unit",       world_destroy_unit);
 	env.load_module_function("World", "num_units",          world_num_units);
 	env.load_module_function("World", "units",              world_units);
-
 	env.load_module_function("World", "update_animations",  world_update_animations);
 	env.load_module_function("World", "update_scene",       world_update_scene);
 	env.load_module_function("World", "update",             world_update);
-
-	env.load_module_function("World", "play_sound",			world_play_sound);
-	env.load_module_function("World", "stop_sound", 		world_stop_sound);
-	env.load_module_function("World", "link_sound",			world_link_sound);
-	env.load_module_function("World", "set_listener_pose", 	world_set_listener_pose);
+	env.load_module_function("World", "play_sound",         world_play_sound);
+	env.load_module_function("World", "stop_sound",         world_stop_sound);
+	env.load_module_function("World", "link_sound",         world_link_sound);
+	env.load_module_function("World", "set_listener_pose",  world_set_listener_pose);
 	env.load_module_function("World", "set_sound_position", world_set_sound_position);
-	env.load_module_function("World", "set_sound_range", 	world_set_sound_range);
-	env.load_module_function("World", "set_sound_volume", 	world_set_sound_volume);
-
-	env.load_module_function("World", "create_window_gui",	world_create_window_gui);
-	env.load_module_function("World", "destroy_gui",		world_destroy_gui);
-
-	env.load_module_function("World", "physics_world",		world_physics_world);
-	env.load_module_function("World", "sound_world",        world_sound_world);
-
+	env.load_module_function("World", "set_sound_range",    world_set_sound_range);
+	env.load_module_function("World", "set_sound_volume",   world_set_sound_volume);
+	env.load_module_function("World", "create_window_gui",  world_create_window_gui);
+	env.load_module_function("World", "destroy_gui",        world_destroy_gui);
 	env.load_module_function("World", "create_debug_line",  world_create_debug_line);
 	env.load_module_function("World", "destroy_debug_line", world_destroy_debug_line);
-
-	env.load_module_function("World", "load_level",			world_load_level);
-
-	env.load_module_function("World", "__index",			"World");
-	env.load_module_function("World", "__tostring",			world_tostring);
+	env.load_module_function("World", "load_level",         world_load_level);
+	env.load_module_function("World", "physics_world",      world_physics_world);
+	env.load_module_function("World", "sound_world",        world_sound_world);
+	env.load_module_function("World", "__index",            "World");
+	env.load_module_function("World", "__tostring",         world_tostring);
 }
 
 } // namespace crown