Rewrite LuaStack::push_vec2/vec3/quat/mat4() to massively improve Lua bindings writing

engine/lua/LuaAccelerometer.cpp

@@ -37,10 +37,7 @@ CE_EXPORT int32_t accelerometer_orientation(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* orientation = next_vec3();
-	*orientation = device()->accelerometer()->orientation();
-
-	stack.push_vec3(orientation);
+	stack.push_vec3(device()->accelerometer()->orientation());
 
 	return 1;
 }

engine/lua/LuaMat4.cpp

@@ -41,26 +41,21 @@ CE_EXPORT int32_t mat4(lua_State* L)
 	float m0 = stack.get_float(1);
 	float m1 = stack.get_float(2);
 	float m2 = stack.get_float(3);
-	float m4 = stack.get_float(4);	
-	float m5 = stack.get_float(5);
-	float m6 = stack.get_float(6);	
-	float m8 = stack.get_float(7);
-	float m9 = stack.get_float(8);
-	float m10 = stack.get_float(9);
-
-	Mat4* mat = next_mat4();
-
-	mat->m[0] = m0;
-	mat->m[1] = m1;
-	mat->m[2] = m2;
-	mat->m[4] = m4;
-	mat->m[5] = m5;
-	mat->m[6] = m6;
-	mat->m[8] = m8;
-	mat->m[9] = m9;
-	mat->m[10] = m10;
-
-	stack.push_mat4(mat);
+	float m3 = stack.get_float(4);
+	float m4 = stack.get_float(5);	
+	float m5 = stack.get_float(6);
+	float m6 = stack.get_float(7);
+	float m7 = stack.get_float(8);
+	float m8 = stack.get_float(9);
+	float m9 = stack.get_float(10);
+	float m10 = stack.get_float(11);
+	float m11 = stack.get_float(12);
+	float m12 = stack.get_float(13);
+	float m13 = stack.get_float(14);
+	float m14 = stack.get_float(15);
+	float m15 = stack.get_float(16);
+
+	stack.push_mat4(Mat4(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10, m11, m12, m13, m14, m15));
 
 	return 1;
 }
@@ -70,12 +65,10 @@ CE_EXPORT int32_t mat4_add(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-	Mat4* b = stack.get_mat4(2);
+	Mat4& a = stack.get_mat4(1);
+	Mat4& b = stack.get_mat4(2);
 
-	*a += *b;
-
-	stack.push_mat4(a);
+	stack.push_mat4(a + b);
 
 	return 1;
 }
@@ -85,12 +78,10 @@ CE_EXPORT int32_t mat4_subtract(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = (Mat4*)stack.get_mat4(1);
-	Mat4* b = (Mat4*)stack.get_mat4(2);
-
-	*a -= *b;
+	Mat4& a = stack.get_mat4(1);
+	Mat4& b = stack.get_mat4(2);
 
-	stack.push_mat4(a);
+	stack.push_mat4(a - b);
 
 	return 1;
 }
@@ -100,12 +91,10 @@ CE_EXPORT int32_t mat4_multiply(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-	Mat4* b = stack.get_mat4(2);
-
-	*a *= *b;
+	Mat4& a = stack.get_mat4(1);
+	Mat4& b = stack.get_mat4(2);
 
-	stack.push_mat4(a);
+	stack.push_mat4(a * b);
 
 	return 1;
 }	
@@ -115,12 +104,10 @@ CE_EXPORT int32_t mat4_multiply_by_scalar(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = (Mat4*)stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 	float k = stack.get_float(2);
 
-	*a *= k;
-
-	stack.push_mat4(a);
+	stack.push_mat4(a * k);
 
 	return 1;
 }
@@ -130,12 +117,10 @@ CE_EXPORT int32_t mat4_divide_by_scalar(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = (Mat4*)stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 	float k = stack.get_float(2);
 
-	*a /= k;
-
-	stack.push_mat4(a);
+	stack.push_mat4(a / k);
 
 	return 1;
 }
@@ -145,10 +130,10 @@ CE_EXPORT int32_t mat4_build_rotation_x(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = (Mat4*)stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 	float k = stack.get_float(2);
 
-	a->build_rotation_x(k);
+	a.build_rotation_x(k);
 
 	return 0;
 }
@@ -158,10 +143,10 @@ CE_EXPORT int32_t mat4_build_rotation_y(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 	float k = stack.get_float(2);
 
-	a->build_rotation_y(k);
+	a.build_rotation_y(k);
 
 	return 0;
 }
@@ -171,10 +156,10 @@ CE_EXPORT int32_t mat4_build_rotation_z(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = (Mat4*)stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 	float k = stack.get_float(2);
 
-	a->build_rotation_z(k);
+	a.build_rotation_z(k);
 
 	return 0;
 }
@@ -184,11 +169,11 @@ CE_EXPORT int32_t mat4_build_rotation(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = (Mat4*)stack.get_mat4(1);
-	Vec3* d = (Vec3*)stack.get_vec3(2);
+	Mat4& a = stack.get_mat4(1);
+	Vec3& d = stack.get_vec3(2);
 	float k = stack.get_float(3);
 
-	a->build_rotation(*d, k);
+	a.build_rotation(d, k);
 
 	return 0;
 }
@@ -198,13 +183,13 @@ CE_EXPORT int32_t mat4_build_projection_perspective_rh(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 	float fovy = stack.get_float(2);
 	float aspect = stack.get_float(3);
 	float near = stack.get_float(4);
 	float far = stack.get_float(5);
 
-	a->build_projection_perspective_rh(fovy, aspect, near, far);
+	a.build_projection_perspective_rh(fovy, aspect, near, far);
 
 	return 0;
 }
@@ -214,13 +199,13 @@ CE_EXPORT int32_t mat4_build_projection_perspective_lh(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 	float fovy = stack.get_float(2);
 	float aspect = stack.get_float(3);
 	float near = stack.get_float(4);
 	float far = stack.get_float(5);
 
-	a->build_projection_perspective_lh(fovy, aspect, near, far);
+	a.build_projection_perspective_lh(fovy, aspect, near, far);
 
 	return 0;
 }
@@ -230,13 +215,13 @@ CE_EXPORT int32_t mat4_build_projection_ortho_rh(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 	float width = stack.get_float(2);
 	float height = stack.get_float(3);
 	float near = stack.get_float(4);
 	float far = stack.get_float(5);
 
-	a->build_projection_ortho_rh(width, height, near, far);
+	a.build_projection_ortho_rh(width, height, near, far);
 
 	return 0;
 }
@@ -246,13 +231,13 @@ CE_EXPORT int32_t mat4_build_projection_ortho_lh(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 	float width = stack.get_float(2);
 	float height = stack.get_float(3);
 	float near = stack.get_float(4);
 	float far = stack.get_float(5);
 
-	a->build_projection_ortho_lh(width, height, near, far);
+	a.build_projection_ortho_lh(width, height, near, far);
 
 	return 0;
 }
@@ -262,13 +247,13 @@ CE_EXPORT int32_t mat4_build_projection_ortho_2d_rh(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 	float width = stack.get_float(2);
 	float height = stack.get_float(3);
 	float near = stack.get_float(4);
 	float far = stack.get_float(5);
 
-	a->build_projection_ortho_2d_rh(width, height, near, far);
+	a.build_projection_ortho_2d_rh(width, height, near, far);
 
 	return 0;
 }
@@ -278,12 +263,12 @@ CE_EXPORT int32_t mat4_build_look_at_rh(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-	Vec3* pos = stack.get_vec3(2);
-	Vec3* target = stack.get_vec3(3);
-	Vec3* up = stack.get_vec3(4);
+	Mat4& a = stack.get_mat4(1);
+	Vec3& pos = stack.get_vec3(2);
+	Vec3& target = stack.get_vec3(3);
+	Vec3& up = stack.get_vec3(4);
 
-	a->build_look_at_rh(*pos, *target, *up);
+	a.build_look_at_rh(pos, target, up);
 
 	return 0;
 }
@@ -293,12 +278,12 @@ CE_EXPORT int32_t mat4_build_look_at_lh(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-	Vec3* pos = stack.get_vec3(2);
-	Vec3* target = stack.get_vec3(3);
-	Vec3* up = stack.get_vec3(4);
+	Mat4& a = stack.get_mat4(1);
+	Vec3& pos = stack.get_vec3(2);
+	Vec3& target = stack.get_vec3(3);
+	Vec3& up = stack.get_vec3(4);
 
-	a->build_look_at_lh(*pos, *target, *up);
+	a.build_look_at_lh(pos, target, up);
 
 	return 0;
 }
@@ -308,12 +293,12 @@ CE_EXPORT int32_t mat4_build_viewpoint_billboard(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-	Vec3* pos = stack.get_vec3(2);
-	Vec3* target = stack.get_vec3(3);
-	Vec3* up = stack.get_vec3(4);
+	Mat4& a = stack.get_mat4(1);
+	Vec3& pos = stack.get_vec3(2);
+	Vec3& target = stack.get_vec3(3);
+	Vec3& up = stack.get_vec3(4);
 
-	a->build_viewpoint_billboard(*pos, *target, *up);
+	a.build_viewpoint_billboard(pos, target, up);
 
 	return 0;
 }
@@ -323,12 +308,12 @@ CE_EXPORT int32_t mat4_build_axis_billboard(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-	Vec3* pos = stack.get_vec3(2);
-	Vec3* target = stack.get_vec3(3);
-	Vec3* up = stack.get_vec3(4);
+	Mat4& a = stack.get_mat4(1);
+	Vec3& pos = stack.get_vec3(2);
+	Vec3& target = stack.get_vec3(3);
+	Vec3& up = stack.get_vec3(4);
 
-	a->build_axis_billboard(*pos, *target, *up);
+	a.build_axis_billboard(pos, target, up);
 
 	return 0;
 }
@@ -338,11 +323,9 @@ CE_EXPORT int32_t mat4_transpose(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-
-	a->transpose();
+	Mat4& a = stack.get_mat4(1);
 
-	stack.push_mat4(a);
+	stack.push_mat4(a.transpose());
 
 	return 1;
 }
@@ -352,9 +335,9 @@ CE_EXPORT int32_t mat4_determinant(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 
-	stack.push_float(a->get_determinant());
+	stack.push_float(a.get_determinant());
 
 	return 1;
 }
@@ -364,11 +347,9 @@ CE_EXPORT int32_t mat4_invert(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 
-	a->invert();
-
-	stack.push_mat4(a);
+	stack.push_mat4(a.invert());
 
 	return 1;
 }
@@ -378,9 +359,9 @@ CE_EXPORT int32_t mat4_load_identity(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 
-	a->load_identity();
+	a.load_identity();
 
 	return 0;
 }
@@ -390,12 +371,9 @@ CE_EXPORT int32_t mat4_x(lua_State* L)
 {	
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-
-	Vec3* x = next_vec3();
-	*x = a->x();
+	Mat4& a = stack.get_mat4(1);
 
-	stack.push_vec3(x);
+	stack.push_vec3(a.x());
 
 	return 1;
 }
@@ -405,12 +383,9 @@ CE_EXPORT int32_t mat4_y(lua_State* L)
 {	
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-
-	Vec3* y = next_vec3();
-	*y = a->y();
+	Mat4& a = stack.get_mat4(1);
 
-	stack.push_vec3(y);
+	stack.push_vec3(a.y());
 
 	return 1;
 }
@@ -420,12 +395,9 @@ CE_EXPORT int32_t mat4_z(lua_State* L)
 {	
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 
-	Vec3* z = next_vec3();
-	*z = a->z();
-
-	stack.push_vec3(z);
+	stack.push_vec3(a.z());
 
 	return 1;
 }
@@ -435,10 +407,10 @@ CE_EXPORT int32_t mat4_set_x(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-	Vec3* x = stack.get_vec3(2);
+	Mat4& a = stack.get_mat4(1);
+	Vec3& x = stack.get_vec3(2);
 
-	a->set_x(*x);
+	a.set_x(x);
 
 	return 0;
 }
@@ -448,10 +420,10 @@ CE_EXPORT int32_t mat4_set_y(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-	Vec3* y = stack.get_vec3(2);
+	Mat4& a = stack.get_mat4(1);
+	Vec3& y = stack.get_vec3(2);
 
-	a->set_y(*y);
+	a.set_y(y);
 
 	return 0;
 }
@@ -461,10 +433,10 @@ CE_EXPORT int32_t mat4_set_z(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-	Vec3* z = stack.get_vec3(2);
+	Mat4& a = stack.get_mat4(1);
+	Vec3& z = stack.get_vec3(2);
 
-	a->set_z(*z);
+	a.set_z(z);
 
 	return 0;
 }
@@ -474,12 +446,9 @@ CE_EXPORT int32_t mat4_translation(lua_State* L)
 {	
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-
-	Vec3* translation = next_vec3();
-	*translation = a->translation();
+	Mat4& a = stack.get_mat4(1);
 
-	stack.push_vec3(translation);
+	stack.push_vec3(a.translation());
 
 	return 1;
 }
@@ -489,10 +458,10 @@ CE_EXPORT int32_t mat4_set_translation(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-	Vec3* trans = stack.get_vec3(2);
+	Mat4& a = stack.get_mat4(1);
+	Vec3& trans = stack.get_vec3(2);
 
-	a->set_translation(*trans);
+	a.set_translation(trans);
 
 	return 0;
 }
@@ -502,12 +471,9 @@ CE_EXPORT int32_t mat4_get_scale(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-
-	Vec3* scale = next_vec3();
-	*scale = a->get_scale();
+	Mat4& a = stack.get_mat4(1);
 
-	stack.push_vec3(scale);
+	stack.push_vec3(a.get_scale());
 
 	return 1;
 }
@@ -517,10 +483,10 @@ CE_EXPORT int32_t mat4_set_scale(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
-	Vec3* scale = stack.get_vec3(2);
+	Mat4& a = stack.get_mat4(1);
+	Vec3& scale = stack.get_vec3(2);
 
-	a->set_scale(*scale);
+	a.set_scale(scale);
 
 	return 0;
 }
@@ -530,12 +496,12 @@ CE_EXPORT int32_t mat4_print(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Mat4* a = stack.get_mat4(1);
+	Mat4& a = stack.get_mat4(1);
 
-	os::printf("|%.1f|%.1f|%.1f|%.1f|\n", a->m[0], a->m[4], a->m[8], a->m[12]);
-	os::printf("|%.1f|%.1f|%.1f|%.1f|\n", a->m[1], a->m[5], a->m[9], a->m[13]);
-	os::printf("|%.1f|%.1f|%.1f|%.1f|\n", a->m[2], a->m[6], a->m[10], a->m[14]);
-	os::printf("|%.1f|%.1f|%.1f|%.1f|\n", a->m[3], a->m[7], a->m[11], a->m[15]);
+	os::printf("|%.1f|%.1f|%.1f|%.1f|\n", a.m[0], a.m[4], a.m[8], a.m[12]);
+	os::printf("|%.1f|%.1f|%.1f|%.1f|\n", a.m[1], a.m[5], a.m[9], a.m[13]);
+	os::printf("|%.1f|%.1f|%.1f|%.1f|\n", a.m[2], a.m[6], a.m[10], a.m[14]);
+	os::printf("|%.1f|%.1f|%.1f|%.1f|\n", a.m[3], a.m[7], a.m[11], a.m[15]);
 
 	return 0;
 }

engine/lua/LuaMouse.cpp

@@ -82,11 +82,7 @@ CE_EXPORT int32_t mouse_cursor_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* xy = next_vec2();
-
-	*xy = device()->mouse()->cursor_xy();
-
-	stack.push_vec2(xy);
+	stack.push_vec2(device()->mouse()->cursor_xy());
 
 	return 1;
 }
@@ -96,9 +92,9 @@ CE_EXPORT int32_t mouse_set_cursor_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* xy = stack.get_vec2(1);
+	Vec2& xy = stack.get_vec2(1);
 
-	device()->mouse()->set_cursor_xy(*xy);
+	device()->mouse()->set_cursor_xy(xy);
 
 	return 0;
 }
@@ -108,10 +104,7 @@ CE_EXPORT int32_t mouse_cursor_relative_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* xy = next_vec2();
-	*xy = device()->mouse()->cursor_relative_xy();
-
-	stack.push_vec2(xy);
+	stack.push_vec2(device()->mouse()->cursor_relative_xy());
 
 	return 1;
 }
@@ -121,9 +114,9 @@ CE_EXPORT int32_t mouse_set_cursor_relative_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* xy = (Vec2*) stack.get_vec2(1);
+	Vec2& xy = stack.get_vec2(1);
 
-	device()->mouse()->set_cursor_relative_xy(*xy);
+	device()->mouse()->set_cursor_relative_xy(xy);
 
 	return 0;
 }

engine/lua/LuaQuat.cpp

@@ -39,14 +39,9 @@ CE_EXPORT int32_t quat(lua_State* L)
 	LuaStack stack(L);
 
 	float w = stack.get_float(1);
-	Vec3* v = stack.get_vec3(2);
+	Vec3& v = stack.get_vec3(2);
 
-	Quat* quat = next_quat();
-
-	quat->w = w;
-	quat->v = *v;
-
-	stack.push_quat(quat);
+	stack.push_quat(Quat(v, w));
 
 	return 1;
 }
@@ -56,9 +51,9 @@ CE_EXPORT int32_t quat_negate(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Quat* q = stack.get_quat(1);
+	Quat& q = stack.get_quat(1);
 
-	q->negate();
+	q.negate();
 
 	return 0;
 }
@@ -68,9 +63,9 @@ CE_EXPORT int32_t quat_load_identity(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Quat* q = stack.get_quat(1);
+	Quat& q = stack.get_quat(1);
 
-	q->load_identity();
+	q.load_identity();
 
 	return 0;
 }
@@ -80,9 +75,9 @@ CE_EXPORT int32_t quat_length(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Quat* q = stack.get_quat(1);
+	Quat& q = stack.get_quat(1);
 
-	stack.push_float(q->length());
+	stack.push_float(q.length());
 
 	return 1;
 }
@@ -92,12 +87,9 @@ CE_EXPORT int32_t quat_conjugate(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Quat* q = stack.get_quat(1);
+	Quat& q = stack.get_quat(1);
 
-	Quat* conjugate = next_quat();
-	*conjugate = q->get_conjugate();
-
-	stack.push_quat(conjugate);
+	stack.push_quat(q.get_conjugate());
 
 	return 1;
 }
@@ -107,12 +99,9 @@ CE_EXPORT int32_t quat_inverse(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Quat* q = stack.get_quat(1);
-
-	Quat* inverse = next_quat();
-	*inverse = q->get_inverse();
+	Quat& q = stack.get_quat(1);
 
-	stack.push_quat(inverse);
+	stack.push_quat(q.get_inverse());
 
 	return 1;
 }
@@ -122,12 +111,10 @@ CE_EXPORT int32_t quat_cross(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Quat* q1 = stack.get_quat(1);
-	Quat* q2 = stack.get_quat(2);
+	Quat& q1 = stack.get_quat(1);
+	Quat& q2 = stack.get_quat(2);
 
-	*q1 = (*q1) * (*q2);
-
-	stack.push_quat(q1);
+	stack.push_quat(q1 * q2);
 
 	return 1;
 }
@@ -137,12 +124,10 @@ CE_EXPORT int32_t quat_multiply(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Quat* q = stack.get_quat(1);
+	Quat& q = stack.get_quat(1);
 	float k = stack.get_float(2);
 
-	*q = (*q) * k;
-
-	stack.push_quat(q);
+	stack.push_quat(q * k);
 
 	return 1;
 }
@@ -152,12 +137,10 @@ CE_EXPORT int32_t quat_power(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Quat* q = stack.get_quat(1);
+	Quat& q = stack.get_quat(1);
 	float k = stack.get_float(2);
 
-	q->power(k);
-
-	stack.push_quat(q);
+	stack.push_quat(q.power(k));
 
 	return 1;
 }
@@ -165,15 +148,15 @@ CE_EXPORT int32_t quat_power(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_quat(LuaEnvironment& env)
 {
-	env.load_module_function("Quat", "new", quat);
-	env.load_module_function("Quat", "negate", quat_negate);
-	env.load_module_function("Quat", "load_identity", quat_load_identity);
-	env.load_module_function("Quat", "length", quat_length);
-	env.load_module_function("Quat", "conjugate", quat_conjugate);
-	env.load_module_function("Quat", "inverse", quat_inverse);
-	env.load_module_function("Quat", "cross", quat_cross);
-	env.load_module_function("Quat", "mul", quat_multiply);
-	env.load_module_function("Quat", "pow", quat_power);
+	env.load_module_function("Quat", "new",				quat);
+	env.load_module_function("Quat", "negate",			quat_negate);
+	env.load_module_function("Quat", "load_identity",	quat_load_identity);
+	env.load_module_function("Quat", "length",			quat_length);
+	env.load_module_function("Quat", "conjugate",		quat_conjugate);
+	env.load_module_function("Quat", "inverse",			quat_inverse);
+	env.load_module_function("Quat", "cross",			quat_cross);
+	env.load_module_function("Quat", "mul",				quat_multiply);
+	env.load_module_function("Quat", "pow",				quat_power);
 }
 
 } //namespace crown

engine/lua/LuaStack.cpp

@@ -51,35 +51,35 @@ static Quat 			quat_buffer[LUA_QUAT_BUFFER_SIZE];
 static uint32_t 		quat_used = 0;
 
 //-----------------------------------------------------------------------------
-Vec2* next_vec2()
+static Vec2* next_vec2(const Vec2& v)
 {
 	CE_ASSERT(vec2_used < LUA_VEC2_BUFFER_SIZE, "Maximum number of Vec2 reached");
 
-	return &vec2_buffer[vec2_used++];
+	return &(vec2_buffer[vec2_used++] = v);
 }
 
 //-----------------------------------------------------------------------------
-Vec3* next_vec3()
+static Vec3* next_vec3(const Vec3& v)
 {
 	CE_ASSERT(vec3_used < LUA_VEC3_BUFFER_SIZE, "Maximum number of Vec3 reached");
 
-	return &vec3_buffer[vec3_used++];
+	return &(vec3_buffer[vec3_used++] = v);
 }
 
 //-----------------------------------------------------------------------------
-Mat4* next_mat4()
+static Mat4* next_mat4(const Mat4& m)
 {
 	CE_ASSERT(mat4_used < LUA_MAT4_BUFFER_SIZE, "Maximum number of Mat4 reached");
 
-	return &mat4_buffer[mat4_used++];
+	return &(mat4_buffer[mat4_used++] = m);
 }
 
 //-----------------------------------------------------------------------------
-Quat* next_quat()
+static Quat* next_quat(const Quat& q)
 {
 	CE_ASSERT(quat_used < LUA_QUAT_BUFFER_SIZE, "Maximum number of Quat reached");
 
-	return &quat_buffer[quat_used++];
+	return &(quat_buffer[quat_used++] = q);
 }
 
 //-----------------------------------------------------------------------------	
@@ -143,35 +143,27 @@ void LuaStack::push_lightdata(void* data)
 }
 
 //-----------------------------------------------------------------------------
-void LuaStack::push_vec2(Vec2* v)
+void LuaStack::push_vec2(const Vec2& v)
 {
-	CE_ASSERT(v >= &vec2_buffer[0] && v <= &vec2_buffer[LUA_VEC2_BUFFER_SIZE-1], "Vec2 type error");
-
-	lua_pushlightuserdata(m_state, v);
+	lua_pushlightuserdata(m_state, next_vec2(v));
 }
 
 //-----------------------------------------------------------------------------
-void LuaStack::push_vec3(Vec3* v)
+void LuaStack::push_vec3(const Vec3& v)
 {
-	CE_ASSERT(v >= &vec3_buffer[0] && v <= &vec3_buffer[LUA_VEC3_BUFFER_SIZE-1], "Vec3 type error");
-
-	lua_pushlightuserdata(m_state, v);
+	lua_pushlightuserdata(m_state, next_vec3(v));
 }
 
 //-----------------------------------------------------------------------------
-void LuaStack::push_mat4(Mat4* m)
+void LuaStack::push_mat4(const Mat4& m)
 {
-	CE_ASSERT(m >= &mat4_buffer[0] && m <= &mat4_buffer[LUA_MAT4_BUFFER_SIZE-1], "Mat4 type error");
-
-	lua_pushlightuserdata(m_state, m);
+	lua_pushlightuserdata(m_state, next_mat4(m));
 }
 
 //-----------------------------------------------------------------------------
-void LuaStack::push_quat(Quat* q)
+void LuaStack::push_quat(const Quat& q)
 {
-	CE_ASSERT(q >= &quat_buffer[0] && q <= &quat_buffer[LUA_MAT4_BUFFER_SIZE-1], "Quat type error");
-
-	lua_pushlightuserdata(m_state, q);
+	lua_pushlightuserdata(m_state, next_quat(q));
 }
 
 //-----------------------------------------------------------------------------
@@ -209,7 +201,7 @@ void* LuaStack::get_lightdata(int32_t index)
 }
 
 //-----------------------------------------------------------------------------
-Vec2* LuaStack::get_vec2(int32_t index)
+Vec2& LuaStack::get_vec2(int32_t index)
 {
 	CE_ASSERT(lua_islightuserdata(m_state, index), "Not a lightuserdata object");
 
@@ -217,11 +209,11 @@ Vec2* LuaStack::get_vec2(int32_t index)
 
 	CE_ASSERT(v >= &vec2_buffer[0] && v <= &vec2_buffer[LUA_VEC2_BUFFER_SIZE-1], "Vec2 type error");
 
-	return v;
+	return *v;
 }
 
 //-----------------------------------------------------------------------------
-Vec3* LuaStack::get_vec3(int32_t index)
+Vec3& LuaStack::get_vec3(int32_t index)
 {
 	CE_ASSERT(lua_islightuserdata(m_state, index), "Not a lightuserdata object");
 
@@ -229,11 +221,11 @@ Vec3* LuaStack::get_vec3(int32_t index)
 
 	CE_ASSERT(v >= &vec3_buffer[0] && v <= &vec3_buffer[LUA_VEC3_BUFFER_SIZE-1], "Vec3 type error");
 
-	return v;
+	return *v;
 }
 
 //-----------------------------------------------------------------------------
-Mat4* LuaStack::get_mat4(int32_t index)
+Mat4& LuaStack::get_mat4(int32_t index)
 {
 	CE_ASSERT(lua_islightuserdata(m_state, index), "Not a lightuserdata object");
 
@@ -241,11 +233,11 @@ Mat4* LuaStack::get_mat4(int32_t index)
 
 	CE_ASSERT(m >= &mat4_buffer[0] && m <= &mat4_buffer[LUA_MAT4_BUFFER_SIZE-1], "Mat4 type error");
 
-	return m;
+	return *m;
 }
 
 //-----------------------------------------------------------------------------
-Quat* LuaStack::get_quat(int32_t index)
+Quat& LuaStack::get_quat(int32_t index)
 {
 	CE_ASSERT(lua_islightuserdata(m_state, index), "Not a lightuserdata object");
 
@@ -253,7 +245,7 @@ Quat* LuaStack::get_quat(int32_t index)
 
 	CE_ASSERT(q >= &quat_buffer[0] && q <= &quat_buffer[LUA_QUAT_BUFFER_SIZE-1], "Quat type error");
 
-	return q;
+	return *q;
 }
 
-} // namespace crown
+} // namespace crown

engine/lua/LuaStack.h

@@ -37,12 +37,6 @@ class Vec3;
 class Mat4;
 class Quat;
 
-Vec2* next_vec2();
-Vec3* next_vec3();
-
-Mat4* next_mat4();
-Quat* next_quat();
-
 class LuaStack
 {
 public:
@@ -67,13 +61,13 @@ public:
 
 	void					push_lightdata(void* data);
 
-	void					push_vec2(Vec2* v);
+	void					push_vec2(const Vec2& v);
 
-	void					push_vec3(Vec3* v);
+	void					push_vec3(const Vec3& v);
 
-	void					push_mat4(Mat4* m);
+	void					push_mat4(const Mat4& m);
 
-	void					push_quat(Quat* q);
+	void					push_quat(const Quat& q);
 
 	bool 					get_bool(int32_t index);
 
@@ -85,13 +79,10 @@ public:
 
 	void*					get_lightdata(int32_t index);
 
-	Vec2*					get_vec2(int32_t index);
-
-	Vec3*					get_vec3(int32_t index);
-
-	Mat4*					get_mat4(int32_t index);
-
-	Quat*					get_quat(int32_t index);
+	Vec2&					get_vec2(int32_t index);
+	Vec3&					get_vec3(int32_t index);
+	Mat4&					get_mat4(int32_t index);
+	Quat&					get_quat(int32_t index);
 
 private:
 

engine/lua/LuaVec2.cpp

@@ -39,12 +39,7 @@ CE_EXPORT int32_t vec2(lua_State* L)
 	float x = stack.get_float(1);
 	float y = stack.get_float(2);
 
-	Vec2* vec = next_vec2();
-
-	vec->x = x;
-	vec->y = y;
-
-	stack.push_vec2(vec);
+	stack.push_vec2(Vec2(x, y));
 
 	return 1;
 }
@@ -54,13 +49,10 @@ CE_EXPORT int32_t vec2_values(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* a = (Vec2*)stack.get_vec2(1);
-
-	float x = a->x;
-	float y = a->y;
+	Vec2& a = stack.get_vec2(1);
 
-	stack.push_float(x);
-	stack.push_float(y);
+	stack.push_float(a.x);
+	stack.push_float(a.y);
 
 	return 2;
 }
@@ -70,12 +62,10 @@ CE_EXPORT int32_t vec2_add(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* a = (Vec2*)stack.get_vec2(1);
-	Vec2* b = (Vec2*)stack.get_vec2(2);
+	Vec2& a = stack.get_vec2(1);
+	Vec2& b = stack.get_vec2(2);
 
-	*a += *b;
-
-	stack.push_vec2(a);
+	stack.push_vec2(a + b);
 
 	return 1;
 }
@@ -85,12 +75,10 @@ CE_EXPORT int32_t vec2_subtract(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* a = (Vec2*) stack.get_vec2(1);
-	Vec2* b = (Vec2*) stack.get_vec2(2);
-
-	*a -= *b;
+	Vec2& a = stack.get_vec2(1);
+	Vec2& b = stack.get_vec2(2);
 
-	stack.push_vec2(a);
+	stack.push_vec2(a - b);
 
 	return 1;
 }
@@ -100,12 +88,10 @@ CE_EXPORT int32_t vec2_multiply(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* a = (Vec2*) stack.get_vec2(1);
+	Vec2& a = stack.get_vec2(1);
 	float k = stack.get_float(2);
 
-	*a *= k;
-
-	stack.push_vec2(a);
+	stack.push_vec2(a * k);
 
 	return 1;
 }			
@@ -115,12 +101,10 @@ CE_EXPORT int32_t vec2_divide(lua_State* L)
 {
 	LuaStack stack(L);
 	
-	Vec2* a = (Vec2*) stack.get_vec2(1);
+	Vec2& a = stack.get_vec2(1);
 	float k = stack.get_float(2);
 
-	*a /= k;
-
-	stack.push_vec2(a);
+	stack.push_vec2(a / k);
 
 	return 1;
 }
@@ -130,10 +114,10 @@ CE_EXPORT int32_t vec2_dot(lua_State* L)
 {
 	LuaStack stack(L);
 	
-	Vec2* a = (Vec2*) stack.get_vec2(1);
-	Vec2* b = (Vec2*) stack.get_vec2(2);
+	Vec2& a = stack.get_vec2(1);
+	Vec2& b = stack.get_vec2(2);
 
-	stack.push_float(a->dot(*b));
+	stack.push_float(a.dot(b));
 
 	return 1;
 }
@@ -143,10 +127,10 @@ CE_EXPORT int32_t vec2_equals(lua_State* L)
 {
 	LuaStack stack(L);
 	
-	Vec2* a = (Vec2*) stack.get_vec2(1);
-	Vec2* b = (Vec2*) stack.get_vec2(2);
+	Vec2& a = stack.get_vec2(1);
+	Vec2& b = stack.get_vec2(2);
 
-	stack.push_bool(*a == *b);
+	stack.push_bool(a == b);
 
 	return 1;
 }
@@ -156,10 +140,10 @@ CE_EXPORT int32_t vec2_lower(lua_State* L)
 {
 	LuaStack stack(L);
 	
-	Vec2* a = (Vec2*) stack.get_vec2(1);
-	Vec2* b = (Vec2*) stack.get_vec2(2);
+	Vec2& a = stack.get_vec2(1);
+	Vec2& b = stack.get_vec2(2);
 
-	stack.push_bool(*a < *b);
+	stack.push_bool(a < b);
 
 	return 1;
 }
@@ -169,10 +153,10 @@ CE_EXPORT int32_t vec2_greater(lua_State* L)
 {
 	LuaStack stack(L);
 	
-	Vec2* a = (Vec2*) stack.get_vec2(1);
-	Vec2* b = (Vec2*) stack.get_vec2(2);
+	Vec2& a = stack.get_vec2(1);
+	Vec2& b = stack.get_vec2(2);
 	
-	stack.push_bool(*a > *b);
+	stack.push_bool(a > b);
 
 	return 1;
 }
@@ -182,9 +166,9 @@ CE_EXPORT int32_t vec2_length(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* a = (Vec2*) stack.get_vec2(1);
+	Vec2& a = stack.get_vec2(1);
 
-	stack.push_float(a->length());
+	stack.push_float(a.length());
 
 	return 1;
 }
@@ -194,9 +178,9 @@ CE_EXPORT int32_t vec2_squared_length(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* a = (Vec2*) stack.get_vec2(1);
+	Vec2& a = stack.get_vec2(1);
 
-	stack.push_float(a->squared_length());
+	stack.push_float(a.squared_length());
 
 	return 1;
 }
@@ -206,10 +190,10 @@ CE_EXPORT int32_t vec2_set_length(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* a = (Vec2*) stack.get_vec2(1);
+	Vec2& a = stack.get_vec2(1);
 	float len = stack.get_float(2);
 
-	a->set_length(len);
+	a.set_length(len);
 
 	return 0;
 }
@@ -219,11 +203,9 @@ CE_EXPORT int32_t vec2_normalize(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* a = (Vec2*) stack.get_vec2(1);
+	Vec2& a = stack.get_vec2(1);
 
-	a->normalize();
-
-	stack.push_vec2(a);
+	stack.push_vec2(a.normalize());
 
 	return 1;
 }
@@ -233,11 +215,9 @@ CE_EXPORT int32_t vec2_negate(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* a = (Vec2*) stack.get_vec2(1);
-
-	a->negate();
+	Vec2& a = stack.get_vec2(1);
 
-	stack.push_vec2(a);
+	stack.push_vec2(a.negate());
 
 	return 1;
 }
@@ -247,10 +227,10 @@ CE_EXPORT int32_t vec2_get_distance_to(lua_State* L)
 {
 	LuaStack stack(L);
 	
-	Vec2* a = (Vec2*) stack.get_vec2(1);
-	Vec2* b = (Vec2*) stack.get_vec2(2);
+	Vec2& a = stack.get_vec2(1);
+	Vec2& b = stack.get_vec2(2);
 
-	stack.push_float(a->get_distance_to(*b));
+	stack.push_float(a.get_distance_to(b));
 
 	return 1;
 }
@@ -260,10 +240,10 @@ CE_EXPORT int32_t vec2_get_angle_between(lua_State* L)
 {
 	LuaStack stack(L);
 	
-	Vec2* a = (Vec2*) stack.get_vec2(1);
-	Vec2* b = (Vec2*) stack.get_vec2(2);
+	Vec2& a = stack.get_vec2(1);
+	Vec2& b = stack.get_vec2(2);
 
-	stack.push_float(a->get_angle_between(*b));
+	stack.push_float(a.get_angle_between(b));
 
 	return 1;
 }
@@ -273,9 +253,9 @@ CE_EXPORT int32_t vec2_zero(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec2* a = (Vec2*) stack.get_vec2(1);
+	Vec2& a = stack.get_vec2(1);
 
-	a->zero();
+	a.zero();
 
 	return 0;
 }
@@ -283,24 +263,24 @@ CE_EXPORT int32_t vec2_zero(lua_State* L)
 //-----------------------------------------------------------------------------
 void load_vec2(LuaEnvironment& env)
 {
-	env.load_module_function("Vec2", "new", vec2);
-	env.load_module_function("Vec2", "val", vec2_values);
-	env.load_module_function("Vec2", "add", vec2_add);
-	env.load_module_function("Vec2", "sub", vec2_subtract);
-	env.load_module_function("Vec2", "mul", vec2_multiply);
-	env.load_module_function("Vec2", "div", vec2_divide);
-	env.load_module_function("Vec2", "dot", vec2_dot);
-	env.load_module_function("Vec2", "equals", vec2_equals);
-	env.load_module_function("Vec2", "lower", vec2_lower);
-	env.load_module_function("Vec2", "greater", vec2_greater);
-	env.load_module_function("Vec2", "length", vec2_length);
-	env.load_module_function("Vec2", "squared_length", vec2_squared_length);
-	env.load_module_function("Vec2", "set_length", vec2_set_length);
-	env.load_module_function("Vec2", "normalize", vec2_normalize);
-	env.load_module_function("Vec2", "negate", vec2_negate);
-	env.load_module_function("Vec2", "get_distance_to", vec2_get_distance_to);
-	env.load_module_function("Vec2", "get_angle_between", vec2_get_angle_between);
-	env.load_module_function("Vec2", "zero", vec2_zero);
+	env.load_module_function("Vec2", "new",					vec2);
+	env.load_module_function("Vec2", "val",					vec2_values);
+	env.load_module_function("Vec2", "add",					vec2_add);
+	env.load_module_function("Vec2", "sub",					vec2_subtract);
+	env.load_module_function("Vec2", "mul",					vec2_multiply);
+	env.load_module_function("Vec2", "div",					vec2_divide);
+	env.load_module_function("Vec2", "dot",					vec2_dot);
+	env.load_module_function("Vec2", "equals",				vec2_equals);
+	env.load_module_function("Vec2", "lower",				vec2_lower);
+	env.load_module_function("Vec2", "greater",				vec2_greater);
+	env.load_module_function("Vec2", "length",				vec2_length);
+	env.load_module_function("Vec2", "squared_length",		vec2_squared_length);
+	env.load_module_function("Vec2", "set_length",			vec2_set_length);
+	env.load_module_function("Vec2", "normalize",			vec2_normalize);
+	env.load_module_function("Vec2", "negate",				vec2_negate);
+	env.load_module_function("Vec2", "get_distance_to",		vec2_get_distance_to);
+	env.load_module_function("Vec2", "get_angle_between",	vec2_get_angle_between);
+	env.load_module_function("Vec2", "zero",				vec2_zero);
 }
 
 } // namespace crown

engine/lua/LuaVec3.cpp

@@ -40,13 +40,7 @@ CE_EXPORT int32_t vec3(lua_State* L)
 	float y = stack.get_float(2);
 	float z = stack.get_float(3);
 
-	Vec3* vec = next_vec3();
-
-	vec->x = x;
-	vec->y = y;
-	vec->z = z;
-
-	stack.push_vec3(vec);
+	stack.push_vec3(Vec3(x, y, z));
 
 	return 1;
 }
@@ -56,15 +50,11 @@ CE_EXPORT int32_t vec3_values(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
+	Vec3& a = stack.get_vec3(1);
 
-	float x = a->x;
-	float y = a->y;
-	float z = a->z;
-
-	stack.push_float(x);
-	stack.push_float(y);
-	stack.push_float(z);
+	stack.push_float(a.x);
+	stack.push_float(a.y);
+	stack.push_float(a.z);
 
 	return 3;
 }
@@ -74,12 +64,10 @@ CE_EXPORT int32_t vec3_add(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
-	Vec3* b = stack.get_vec3(2);
-
-	*a += *b;
+	Vec3& a = stack.get_vec3(1);
+	Vec3& b = stack.get_vec3(2);
 
-	stack.push_vec3(a);
+	stack.push_vec3(a + b);
 
 	return 1;
 }
@@ -89,12 +77,10 @@ CE_EXPORT int32_t vec3_subtract(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
-	Vec3* b = stack.get_vec3(2);
+	Vec3& a = stack.get_vec3(1);
+	Vec3& b = stack.get_vec3(2);
 
-	*a -= *b;
-
-	stack.push_vec3(a);
+	stack.push_vec3(a - b);
 
 	return 1;
 }
@@ -104,12 +90,10 @@ CE_EXPORT int32_t vec3_multiply(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
+	Vec3& a = stack.get_vec3(1);
 	float b = stack.get_float(2);
 
-	*a *= b;
-
-	stack.push_vec3(a);
+	stack.push_vec3(a * b);
 
 	return 1;
 }
@@ -119,12 +103,10 @@ CE_EXPORT int32_t vec3_divide(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
+	Vec3& a = stack.get_vec3(1);
 	float b = stack.get_float(2);
 
-	*a /= b;
-
-	stack.push_vec3(a);
+	stack.push_vec3(a / b);
 
 	return 1;
 }
@@ -134,10 +116,10 @@ CE_EXPORT int32_t vec3_dot(lua_State* L)
 {
 	LuaStack stack(L);
 	
-	Vec3* a = stack.get_vec3(1);
-	Vec3* b = stack.get_vec3(2);
+	Vec3& a = stack.get_vec3(1);
+	Vec3& b = stack.get_vec3(2);
 
-	stack.push_float(a->dot(*b));
+	stack.push_float(a.dot(b));
 
 	return 1;
 }
@@ -147,13 +129,10 @@ CE_EXPORT int32_t vec3_cross(lua_State* L)
 {
 	LuaStack stack(L);
 	
-	Vec3* a = stack.get_vec3(1);
-	Vec3* b = stack.get_vec3(2);
-
-	/// CHECK CHECK CHECK
-	*a = a->cross(*b);
+	Vec3& a = stack.get_vec3(1);
+	Vec3& b = stack.get_vec3(2);
 
-	stack.push_vec3(a);
+	stack.push_vec3(a.cross(b));
 
 	return 1;
 }
@@ -163,10 +142,10 @@ CE_EXPORT int32_t vec3_equals(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
-	Vec3* b = stack.get_vec3(2);
+	Vec3& a = stack.get_vec3(1);
+	Vec3& b = stack.get_vec3(2);
 
-	stack.push_bool(*a == *b);
+	stack.push_bool(a == b);
 
 	return 1;
 }
@@ -176,10 +155,10 @@ CE_EXPORT int32_t vec3_lower(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
-	Vec3* b = stack.get_vec3(2);
+	Vec3& a = stack.get_vec3(1);
+	Vec3& b = stack.get_vec3(2);
 
-	stack.push_bool(*a < *b);
+	stack.push_bool(a < b);
 
 	return 1;
 }
@@ -189,10 +168,10 @@ CE_EXPORT int32_t vec3_greater(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
-	Vec3* b = stack.get_vec3(2);
+	Vec3& a = stack.get_vec3(1);
+	Vec3& b = stack.get_vec3(2);
 
-	stack.push_bool(*a > *b);
+	stack.push_bool(a > b);
 
 	return 1;
 }
@@ -202,9 +181,9 @@ CE_EXPORT int32_t vec3_length(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
+	Vec3& a = stack.get_vec3(1);
 
-	stack.push_float(a->length());
+	stack.push_float(a.length());
 
 	return 1;
 }
@@ -214,9 +193,9 @@ CE_EXPORT int32_t vec3_squared_length(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
+	Vec3& a = stack.get_vec3(1);
 
-	stack.push_float(a->squared_length());
+	stack.push_float(a.squared_length());
 
 	return 1;
 }
@@ -226,10 +205,10 @@ CE_EXPORT int32_t vec3_set_length(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
+	Vec3& a = stack.get_vec3(1);
 	float len = stack.get_float(2);
 
-	a->set_length(len);
+	a.set_length(len);
 
 	return 0;
 }
@@ -239,9 +218,9 @@ CE_EXPORT int32_t vec3_normalize(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
+	Vec3& a = stack.get_vec3(1);
 
-	a->normalize();
+	a.normalize();
 
 	return 0;
 }
@@ -251,9 +230,9 @@ CE_EXPORT int32_t vec3_negate(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
+	Vec3& a = stack.get_vec3(1);
 
-	a->negate();
+	a.negate();
 
 	return 0;
 }
@@ -263,10 +242,10 @@ CE_EXPORT int32_t vec3_get_distance_to(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
-	Vec3* b = stack.get_vec3(2);
+	Vec3& a = stack.get_vec3(1);
+	Vec3& b = stack.get_vec3(2);
 
-	stack.push_float(a->get_distance_to(*b));
+	stack.push_float(a.get_distance_to(b));
 
 	return 1;
 }
@@ -276,10 +255,10 @@ CE_EXPORT int32_t vec3_get_angle_between(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
-	Vec3* b = stack.get_vec3(2);
+	Vec3& a = stack.get_vec3(1);
+	Vec3& b = stack.get_vec3(2);
 
-	stack.push_float(a->get_angle_between(*b));
+	stack.push_float(a.get_angle_between(b));
 
 	return 1;
 }
@@ -289,9 +268,9 @@ CE_EXPORT int32_t vec3_zero(lua_State* L)
 {
 	LuaStack stack(L);
 
-	Vec3* a = stack.get_vec3(1);
+	Vec3& a = stack.get_vec3(1);
 
-	a->zero();
+	a.zero();
 
 	return 0;
 }