Math binds re-implemented without ffi

lua/CMakeLists.txt

@@ -8,6 +8,7 @@ set(LUA_SRC
 	Vec2Binds.cpp
 	Vec3Binds.cpp
 	Mat4Binds.cpp
+	MathBinds.cpp
 
 	MouseBinds.cpp
 	KeyboardBinds.cpp

lua/MathBinds.cpp

@@ -1,183 +1,211 @@
 #include "MathUtils.h"
-#include "Types.h"
 #include "LuaStack.h"
-#include "OS.h"
+#include "LuaEnvironment.h"
 
 namespace crown
 {
 
 extern "C"
 {
-	// int32_t						math_test_bitmask(lua_State* L, int32_t value, int32_t bitmask);
 
-	// int32_t						math_set_bitmask(lua_State* L, int32_t value, int32_t bitmask);
+int32_t math_deg_to_rad(lua_State* L)
+{
+	LuaStack stack(L);
+
+	float deg = stack.get_float(1);
+
+	stack.push_float(math::deg_to_rad(deg));
+
+	return 1;
+}
+
+int32_t math_rad_to_deg(lua_State* L)
+{
+	LuaStack stack(L);
+
+	float rad = stack.get_float(1);
+
+	stack.push_float(math::rad_to_deg(rad));
+
+	return 1;
+}
+
+int32_t math_next_pow_2(lua_State* L)
+{
+	LuaStack stack(L);
+
+	uint32_t x = stack.get_int(1);
+
+	stack.push_int(math::next_pow_2(x));
+
+	return 1;
+}
+
+int32_t 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));
+
+	return 1;
+}
+
+int32_t math_ceil(lua_State* L)
+{
+	LuaStack stack(L);
+
+	float x = stack.get_float(1);
+
+	stack.push_float(math::ceil(x));
+
+	return 1;
+}
+
+int32_t math_floor(lua_State* L)
+{
+	LuaStack stack(L);
+
+	float x = stack.get_float(1);
+
+	stack.push_float(math::floor(x));
+
+	return 1;
+}
+
+int32_t math_sqrt(lua_State* L)
+{
+	LuaStack stack(L);
 
-	// int32_t						math_unset_bitmask(lua_State* L, int32_t value, int32_t bitmask);					
+	float x = stack.get_float(1);
 
-	// int32_t						math_deg_to_rad(lua_State* L, float deg);
+	stack.push_float(math::sqrt(x));
 
-	// int32_t						math_rad_to_deg(lua_State* L, float rad);
+	return 1;
+}
 
-	// int32_t						math_next_pow_2(lua_State* L, uint32_t x);
+int32_t math_inv_sqrt(lua_State* L)
+{
+	LuaStack stack(L);
 
-	// int32_t						math_is_pow_2(lua_State* L, uint32_t x);	
+	float x = stack.get_float(1);
 
-	// int32_t						math_ceil(lua_State* L, float x);		
+	stack.push_float(math::inv_sqrt(x));
 
-	// int32_t						math_floor(lua_State* L, float x);	
+	return 1;
+}
 
-	// int32_t						math_sqrt(lua_State* L, float x);	
+int32_t math_sin(lua_State* L)
+{
+	LuaStack stack(L);
 
-	// int32_t						math_inv_sqrt(lua_State* L, float x);
+	float x = stack.get_float(1);
+
+	stack.push_float(math::sin(x));
+
+	return 1;
+}
+
+int32_t math_cos(lua_State* L)
+{
+	LuaStack stack(L);
+
+	float x = stack.get_float(1);
+
+	stack.push_float(math::cos(x));
+
+	return 1;
+}
 
-	// int32_t						math_sin(lua_State* L, float x);	
+int32_t math_asin(lua_State* L)
+{
+	LuaStack stack(L);
 
-	// int32_t						math_cos(lua_State* L, float x);
+	float x = stack.get_float(1);
 
-	// int32_t						math_asin(lua_State* L, float x);	
+	stack.push_float(math::asin(x));
 
-	// int32_t						math_acos(lua_State* L, float x);	
+	return 1;
+}
 
-	// int32_t						math_tan(lua_State* L, float x);		
+int32_t math_acos(lua_State* L)
+{
+	LuaStack stack(L);
 
-	// int32_t						math_atan2(lua_State* L, float y, float x);	
+	float x = stack.get_float(1);
 
-	// int32_t						math_abs(lua_State* L, float x);			
+	stack.push_float(math::acos(x));
 
-	// int32_t						math_fmod(lua_State* L, float n, float d);			
+	return 1;
+}
 
-//-------------------------------------------------------------------
-int32_t math_equals(lua_State* L)
+int32_t math_tan(lua_State* L)
 {
 	LuaStack stack(L);
 
-	float a = stack.get_float(1);
-	float b = stack.get_float(2);
+	float x = stack.get_float(1);
 
-	stack.push_bool(math::equals(a, b, math::FLOAT_PRECISION));
+	stack.push_float(math::tan(x));
 
 	return 1;
 }
 
-// //-------------------------------------------------------------------
-// int32_t math_test_bitmask(lua_State* L, int32_t value, int32_t bitmask)
-// {
-// 	return math::test_bitmask(value, bitmask);
-// }
+int32_t math_atan2(lua_State* L)
+{
+	LuaStack stack(L);
 
-// //-------------------------------------------------------------------
-// int32_t math_set_bitmask(lua_State* L, int32_t value, int32_t bitmask)
-// {
-// 	return math::set_bitmask(value, bitmask);
-// }
+	float x = stack.get_float(1);
+	float y = stack.get_float(2);
 
-// //-------------------------------------------------------------------
-// int32_t math_unset_bitmask(lua_State* L, int32_t value, int32_t bitmask)
-// {
-// 	return math::unset_bitmask(value, bitmask);
-// }
+	stack.push_float(math::atan2(x, y));
 
-// //-------------------------------------------------------------------
-// int32_t math_deg_to_rad(lua_State* L, float deg)
-// {
-// 	return math::deg_to_rad(deg);
-// }
+	return 1;
+}
 
-// //-------------------------------------------------------------------
-// inatt32_t math_rad_to_deg(lua_State* L, float rad)
-// {
-// 	return math::rad_to_deg(rad);
-// }
+int32_t math_abs(lua_State* L)
+{
+	LuaStack stack(L);
 
-// //-------------------------------------------------------------------
-// int32_t math_next_pow_2(lua_State* L, uint32_t x)
-// {
-// 	return math::next_pow_2(x);
-// }
+	float x = stack.get_float(1);
 
-// //-------------------------------------------------------------------
-// int32_t math_is_pow_2(lua_State* L, uint32_t x)
-// {
-// 	return math::is_pow_2(x);
-// }
+	stack.push_float(math::abs(x));
 
-// //-------------------------------------------------------------------
-// int32_t math_ceil(lua_State* L, float x)
-// {
-// 	return math::ceil(x);
-// }
+	return 1;
+}
 
-// //-------------------------------------------------------------------
-// int32_t math_floor(lua_State* L, float x)
-// {
-// 	return math::floor(x);
-// }
+int32_t math_fmod(lua_State* L)
+{
+	LuaStack stack(L);
 
-// //-------------------------------------------------------------------
-// int32_t math_sqrt(lua_State* L, float x)
-// {
-// 	return math::sqrt(x);
-// }
+	float x = stack.get_float(1);
+	float y = stack.get_float(2);
 
-// //-------------------------------------------------------------------
-// int32_t math_inv_sqrt(lua_State* L, float x)
-// {
-// 	return math::inv_sqrt(x);
-// }
+	stack.push_float(math::fmod(x, y));
 
-// //-------------------------------------------------------------------
-// int32_t math_sin(lua_State* L, float x)
-// {
-// 	return math::sin(x);
-// }
-
-// //-------------------------------------------------------------------
-// int32_t math_cos(lua_State* L, float x)
-// {
-// 	return math::cos(x);
-// }
-
-// //-------------------------------------------------------------------
-// int32_t math_asin(lua_State* L, float x)
-// {
-// 	return math::asin(x);
-// }
-
-// //-------------------------------------------------------------------
-// int32_t math_acos(lua_State* L, float x)
-// {
-// 	return math::acos(x);
-// }
-
-// //-------------------------------------------------------------------
-// int32_t math_tan(lua_State* L, float x)
-// {
-// 	return math::tan(x);
-// }
-
-// //-------------------------------------------------------------------
-// int32_t math_atan2(lua_State* L, float y, float x)
-// {
-// 	return math::atan2(y, x);
-// }
-
-// //-------------------------------------------------------------------
-// int32_t math_abs(lua_State* L, float x)
-// {
-// 	return math::abs(x);
-// }
-
-// //-------------------------------------------------------------------
-// int32_t math_fmod(lua_State* L, float n, float d)
-// {
-// 	return math::fmod(n, d);
-// }
-
-static const struct luaL_Reg Math [] = {
-	{"equals", math_equals},
-	{NULL, NULL}	
-};
+	return 1;
+}
 
+} // extern "C"
+
+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);
 }
 
 } // namespace crown