Vec2 binding implemented

lua/Vec2Binds.cpp

@@ -1,6 +1,8 @@
+#include "LuaStack.h"
 #include "Device.h"
 #include "ScriptSystem.h"
-
+#include "Vec2Binds.h"
+#include "OS.h"
 
 namespace crown
 {
@@ -8,136 +10,244 @@ namespace crown
 extern "C"
 {
 
-	Vec2&				vec2(float nx, float ny);					
+int32_t	vec2(lua_State* L)
+{
+	LuaStack stack(L);
 
-	Vec2&				vec2_add(Vec2& self, const Vec2& a);			
+	float x = stack.get_float(1);
+	float y = stack.get_float(2);
 
-	Vec2& 				vec2_subtract(Vec2& self, const Vec2& a);			
+	stack.push_lightudata(device()->script_system()->next_vec2(x, y));
 
-	Vec2&				vec2_multiply(Vec2& self, float k);			
+	return 1;
+}
 
-	Vec2&				vec2_divide(Vec2& self, float k);
+int32_t vec2_add(lua_State* L)
+{
+	LuaStack stack(L);
 
-	float				vec2_dot(Vec2& self, const Vec2& a);				
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+	Vec2* b = (Vec2*) stack.get_lightudata(2);
 
-	bool				vec2_equals(Vec2& self, const Vec2& other);	
+	*a += *b;
 
-	bool				vec2_lower(Vec2& self, const Vec2& other);		
+	stack.push_lightudata(a);
 
-	bool				vec2_greater(Vec2& self, const Vec2& other);
+	return 1;
+}
 
-	float				vec2_length(Vec2& self);
+int32_t vec2_subtract(lua_State* L)
+{
+	LuaStack stack(L);
 
-	float				vec2_squared_length(Vec2& self);
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+	Vec2* b = (Vec2*) stack.get_lightudata(2);
 
-	void				vec2_set_length(Vec2& self, float len);					
+	*a -= *b;
 
-	Vec2&				vec2_normalize(Vec2& self);
+	stack.push_lightudata(a);
 
-	Vec2&				vec2_negate(Vec2& self);
+	return 1;
+}
 
-	float				vec2_get_distance_to(Vec2& self, const Vec2& a);
+int32_t vec2_multiply(lua_State* L)
+{
+	LuaStack stack(L);
 
-	float				vec2_get_angle_between(Vec2& self, const Vec2& a);
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+	float k = stack.get_float(2);
 
-	void				vec2_zero(Vec2& self);
-}
+	*a *= k;
 
-Vec2& vec2(float nx, float ny)
-{
-	return device()->script_system()->next_vec2(nx, ny);
-}
+	stack.push_lightudata(a);
 
-Vec2& vec2_add(Vec2& self, const Vec2& a)
+	return 1;
+}			
+	
+int32_t vec2_divide(lua_State* L)
 {
-	self += a;
+	LuaStack stack(L);
+	
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+	float k = stack.get_float(2);
 
-	return self;
-}
+	*a /= k;
 
-Vec2& vec2_subtract(Vec2& self, const Vec2& a)
-{
-	self -= a;
+	stack.push_lightudata(a);
 
-	return self;
+	return 1;
 }
 
-Vec2& vec2_multiply(Vec2& self, float k)
+int32_t vec2_dot(lua_State* L)
 {
-	self *= k;
+	LuaStack stack(L);
+	
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+	Vec2* b = (Vec2*) stack.get_lightudata(2);
+
+	stack.push_float(a->dot(*b));
 
-	return self;
+	return 1;
 }
 
-Vec2& vec2_divide(Vec2& self, float k)
+int32_t vec2_equals(lua_State* L)
 {
-	self /= k;
+	LuaStack stack(L);
+	
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+	Vec2* b = (Vec2*) stack.get_lightudata(2);
 
-	return self;
+	stack.push_bool(*a == *b);
+
+	return 1;
 }
 
-float vec2_dot(Vec2& self, const Vec2& a)
+int32_t vec2_lower(lua_State* L)
 {
-	return self.dot(a);
+	LuaStack stack(L);
+	
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+	Vec2* b = (Vec2*) stack.get_lightudata(2);
+
+	stack.push_bool(*a < *b);
+
+	return 1;
 }
 
-bool vec2_equals(Vec2& self, const Vec2& other)
+int32_t vec2_greater(lua_State* L)
 {
-	return self == other;
+	LuaStack stack(L);
+	
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+	Vec2* b = (Vec2*) stack.get_lightudata(2);
+	
+	stack.push_bool(*a > *b);
+
+	return 1;
 }
 
-bool vec2_lower(Vec2& self, const Vec2& other)
+int32_t vec2_length(lua_State* L)
 {
-	return self < other;
+	LuaStack stack(L);
+
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+
+	stack.push_float(a->length());
+
+	return 1;
 }
 
-bool vec2_greater(Vec2& self, const Vec2& other)
+int32_t vec2_squared_length(lua_State* L)
 {
-	return self > other;
+	LuaStack stack(L);
+
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+
+	stack.push_float(a->squared_length());
+
+	return 1;
 }
 
-float vec2_length(Vec2& self)
+int32_t vec2_set_length(lua_State* L)
 {
-	self.length();
+	LuaStack stack(L);
+
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+	float len = stack.get_float(2);
+
+	a->set_length(len);
+
+	return 0;
 }
 
-float vec2_squared_length(Vec2& self)
+int32_t	vec2_normalize(lua_State* L)
 {
-	return self.squared_length();
+	LuaStack stack(L);
+
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+
+	a->normalize();
+
+	stack.push_lightudata(a);
+
+	return 1;
 }
 
-void vec2_set_length(Vec2& self, float len)
+int32_t	vec2_negate(lua_State* L)
 {
-	self.set_length(len);
+	LuaStack stack(L);
+
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+
+	a->negate();
+
+	stack.push_lightudata(a);
+
+	return 1;
 }
 
-Vec2& vec2_normalize(Vec2& self)
+int32_t	vec2_get_distance_to(lua_State* L)
 {
-	self.normalize();
+	LuaStack stack(L);
+	
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+	Vec2* b = (Vec2*) stack.get_lightudata(2);
 
-	return self;
+	stack.push_float(a->get_distance_to(*b));
+
+	return 1;
 }
 
-Vec2& vec2_negate(Vec2& self)
+int32_t	vec2_get_angle_between(lua_State* L)
 {
-	self.negate();
+	LuaStack stack(L);
+	
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+	Vec2* b = (Vec2*) stack.get_lightudata(2);
+
+	stack.push_float(a->get_angle_between(*b));
 
-	return self;
+	return 1;
 }
 
-float vec2_get_distance_to(Vec2& self, const Vec2& a)
+int32_t	vec2_zero(lua_State* L)
 {
-	return self.get_distance_to(a);
+	LuaStack stack(L);
+
+	Vec2* a = (Vec2*) stack.get_lightudata(1);
+
+	a->zero();
+
+	return 0;
 }
 
-float vec2_get_angle_between(Vec2& self, const Vec2& a)
+static const struct luaL_Reg Vec2 [] = {
+	{"new", 			vec2},
+	{"add", 			vec2_add},
+	{"sub", 			vec2_subtract},
+	{"mul", 			vec2_multiply},
+	{"div", 			vec2_divide},
+	{"dot", 			vec2_dot},
+	{"equals", 			vec2_equals},
+	{"lower", 			vec2_lower},
+	{"greater", 		vec2_greater},
+	{"len", 			vec2_length},
+	{"squared_len", 	vec2_squared_length},
+	{"set_len", 		vec2_set_length},
+	{"norm", 			vec2_normalize},
+	{"neg", 			vec2_negate},
+	{"dist_to", 		vec2_get_distance_to},
+	{"angle_between", 	vec2_get_angle_between},
+	{"zero", 			vec2_zero},
+	{NULL, NULL}	
+};
+
+int32_t luaopen_libcrownlua(lua_State* L)
 {
-	return self.get_angle_between(a);
+	luaL_register(L, "Vec2", Vec2);
+	return 1;
 }
 
-void vec2_zero(Vec2& self)
-{
-	self.zero();
 }
 
 } // namespace crown

lua/Vec2Binds.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "Vec2.h"
+#include "lua.hpp"
+
+namespace crown
+{
+
+extern "C"
+{
+	/// Constructor
+	int32_t				vec2(lua_State* L);					
+	/// a + b
+	int32_t				vec2_add(lua_State* L);			
+	/// a - b
+	int32_t 			vec2_subtract(lua_State* L);			
+	///
+	int32_t				vec2_multiply(lua_State* L);			
+	///
+	int32_t				vec2_divide(lua_State* L);
+	///
+	int32_t				vec2_dot(lua_State* L);				
+	///
+	int32_t				vec2_equals(lua_State* L);	
+	///
+	int32_t				vec2_lower(lua_State* L);		
+	///
+	int32_t				vec2_greater(lua_State* L);
+	///
+	int32_t				vec2_length(lua_State* L);
+	///
+	int32_t				vec2_squared_length(lua_State* L);
+	///
+	int32_t				vec2_set_length(lua_State* L);					
+	///
+	int32_t				vec2_normalize(lua_State* L);
+	///
+	int32_t				vec2_negate(lua_State* L);
+	///
+	int32_t				vec2_get_distance_to(lua_State* L);
+	///
+	int32_t				vec2_get_angle_between(lua_State* L);
+	///
+	int32_t				vec2_zero(lua_State* L);
+}
+
+} // namespace crown