CE_EXPORT included in each definitions

src/lua/AccelerometerBinds.cpp

@@ -6,11 +6,8 @@
 namespace crown
 {
 
-extern "C"
-{
-
 //-----------------------------------------------------------------------------
-int32_t accelerometer_orientation(lua_State* L)
+CE_EXPORT int32_t accelerometer_orientation(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -22,8 +19,6 @@ int32_t accelerometer_orientation(lua_State* L)
 	return 1;
 }
 
-} // extern "C"
-
 //-----------------------------------------------------------------------------
 void load_accelerometer(LuaEnvironment& env)
 {

src/lua/CameraBinds.cpp

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

src/lua/KeyboardBinds.cpp

@@ -6,10 +6,8 @@
 namespace crown
 {
 
-extern "C"
-{
-
-int32_t keyboard_modifier_pressed(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t keyboard_modifier_pressed(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -20,7 +18,8 @@ int32_t keyboard_modifier_pressed(lua_State* L)
 	return 1;
 }
 
-int32_t keyboard_key_pressed(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t keyboard_key_pressed(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -31,7 +30,8 @@ int32_t keyboard_key_pressed(lua_State* L)
 	return 1;
 }
 
-int32_t keyboard_key_released(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t keyboard_key_released(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -42,8 +42,7 @@ int32_t keyboard_key_released(lua_State* L)
 	return 1;
 }
 
-} // extern "C"
-
+//-----------------------------------------------------------------------------
 void load_keyboard(LuaEnvironment& env)
 {
 	env.load_module_function("Keyboard", "modifier_pressed",	keyboard_modifier_pressed);

src/lua/LuaEnvironment.cpp

@@ -23,6 +23,7 @@ void LuaEnvironment::load_module_function(const char* module, const char* name,
 	luaL_register(m_state, module, entry);
 }
 
+//-----------------------------------------------------------------------------
 CE_EXPORT int32_t luaopen_libcrownlua(lua_State* L)
 {
 	LuaEnvironment env(L);

src/lua/Mat4Binds.cpp

@@ -7,10 +7,8 @@
 namespace crown
 {
 
-extern "C"
-{
-
-int32_t mat4(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -40,8 +38,9 @@ int32_t mat4(lua_State* L)
 
 	return 1;
 }
-					
-int32_t mat4_add(lua_State* L)
+
+//-----------------------------------------------------------------------------					
+CE_EXPORT int32_t mat4_add(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -55,7 +54,8 @@ int32_t mat4_add(lua_State* L)
 	return 1;
 }
 
-int32_t mat4_subtract(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_subtract(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -69,7 +69,8 @@ int32_t mat4_subtract(lua_State* L)
 	return 1;
 }
 
-int32_t mat4_multiply(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_multiply(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -83,7 +84,8 @@ int32_t mat4_multiply(lua_State* L)
 	return 1;
 }	
 
-int32_t mat4_multiply_by_scalar(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_multiply_by_scalar(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -97,7 +99,8 @@ int32_t mat4_multiply_by_scalar(lua_State* L)
 	return 1;
 }
 
-int32_t mat4_divide_by_scalar(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_divide_by_scalar(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -111,7 +114,8 @@ int32_t mat4_divide_by_scalar(lua_State* L)
 	return 1;
 }
 
-int32_t mat4_build_rotation_x(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_rotation_x(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -123,7 +127,8 @@ int32_t mat4_build_rotation_x(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_build_rotation_y(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_rotation_y(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -135,7 +140,8 @@ int32_t mat4_build_rotation_y(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_build_rotation_z(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_rotation_z(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -147,7 +153,8 @@ int32_t mat4_build_rotation_z(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_build_rotation(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_rotation(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -160,7 +167,8 @@ int32_t mat4_build_rotation(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_build_projection_perspective_rh(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_projection_perspective_rh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -175,7 +183,8 @@ int32_t mat4_build_projection_perspective_rh(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_build_projection_perspective_lh(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_projection_perspective_lh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -190,7 +199,8 @@ int32_t mat4_build_projection_perspective_lh(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_build_projection_ortho_rh(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_projection_ortho_rh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -205,7 +215,8 @@ int32_t mat4_build_projection_ortho_rh(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_build_projection_ortho_lh(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_projection_ortho_lh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -220,7 +231,8 @@ int32_t mat4_build_projection_ortho_lh(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_build_projection_ortho_2d_rh(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_projection_ortho_2d_rh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -235,7 +247,8 @@ int32_t mat4_build_projection_ortho_2d_rh(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_build_look_at_rh(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_look_at_rh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -249,7 +262,8 @@ int32_t mat4_build_look_at_rh(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_build_look_at_lh(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_look_at_lh(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -263,7 +277,8 @@ int32_t mat4_build_look_at_lh(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_build_viewpoint_billboard(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_viewpoint_billboard(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -277,7 +292,8 @@ int32_t mat4_build_viewpoint_billboard(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_build_axis_billboard(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_build_axis_billboard(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -291,7 +307,8 @@ int32_t mat4_build_axis_billboard(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_transpose(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_transpose(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -304,7 +321,8 @@ int32_t mat4_transpose(lua_State* L)
 	return 1;
 }
 
-int32_t mat4_determinant(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_determinant(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -315,7 +333,8 @@ int32_t mat4_determinant(lua_State* L)
 	return 1;
 }
 
-int32_t mat4_invert(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_invert(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -328,7 +347,8 @@ int32_t mat4_invert(lua_State* L)
 	return 1;
 }
 
-int32_t mat4_load_identity(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_load_identity(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -339,7 +359,8 @@ int32_t mat4_load_identity(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_get_translation(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_get_translation(lua_State* L)
 {	
 	LuaStack stack(L);
 
@@ -353,7 +374,8 @@ int32_t mat4_get_translation(lua_State* L)
 	return 1;
 }
 
-int32_t mat4_set_translation(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_set_translation(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -365,7 +387,8 @@ int32_t mat4_set_translation(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_get_scale(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_get_scale(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -379,7 +402,8 @@ int32_t mat4_get_scale(lua_State* L)
 	return 1;
 }
 
-int32_t mat4_set_scale(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_set_scale(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -391,7 +415,8 @@ int32_t mat4_set_scale(lua_State* L)
 	return 0;
 }
 
-int32_t mat4_print(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t mat4_print(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -405,8 +430,7 @@ int32_t mat4_print(lua_State* L)
 	return 0;
 }
 
-} //extern "C"
-
+//-----------------------------------------------------------------------------
 void load_mat4(LuaEnvironment& env)
 {
 	env.load_module_function("Mat4", "new", 							mat4);

src/lua/MathBinds.cpp

@@ -5,10 +5,8 @@
 namespace crown
 {
 
-extern "C"
-{
-
-int32_t math_deg_to_rad(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_deg_to_rad(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -19,7 +17,8 @@ int32_t math_deg_to_rad(lua_State* L)
 	return 1;
 }
 
-int32_t math_rad_to_deg(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_rad_to_deg(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -30,7 +29,8 @@ int32_t math_rad_to_deg(lua_State* L)
 	return 1;
 }
 
-int32_t math_next_pow_2(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_next_pow_2(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -41,7 +41,8 @@ int32_t math_next_pow_2(lua_State* L)
 	return 1;
 }
 
-int32_t math_is_pow_2(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_is_pow_2(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -52,7 +53,8 @@ int32_t math_is_pow_2(lua_State* L)
 	return 1;
 }
 
-int32_t math_ceil(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_ceil(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -63,7 +65,8 @@ int32_t math_ceil(lua_State* L)
 	return 1;
 }
 
-int32_t math_floor(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_floor(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -74,7 +77,8 @@ int32_t math_floor(lua_State* L)
 	return 1;
 }
 
-int32_t math_sqrt(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_sqrt(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -85,7 +89,8 @@ int32_t math_sqrt(lua_State* L)
 	return 1;
 }
 
-int32_t math_inv_sqrt(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_inv_sqrt(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -96,7 +101,8 @@ int32_t math_inv_sqrt(lua_State* L)
 	return 1;
 }
 
-int32_t math_sin(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_sin(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -107,7 +113,8 @@ int32_t math_sin(lua_State* L)
 	return 1;
 }
 
-int32_t math_cos(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_cos(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -118,7 +125,8 @@ int32_t math_cos(lua_State* L)
 	return 1;
 }
 
-int32_t math_asin(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_asin(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -129,7 +137,8 @@ int32_t math_asin(lua_State* L)
 	return 1;
 }
 
-int32_t math_acos(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_acos(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -140,7 +149,8 @@ int32_t math_acos(lua_State* L)
 	return 1;
 }
 
-int32_t math_tan(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_tan(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -151,7 +161,8 @@ int32_t math_tan(lua_State* L)
 	return 1;
 }
 
-int32_t math_atan2(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_atan2(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -163,7 +174,8 @@ int32_t math_atan2(lua_State* L)
 	return 1;
 }
 
-int32_t math_abs(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_abs(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -174,7 +186,8 @@ int32_t math_abs(lua_State* L)
 	return 1;
 }
 
-int32_t math_fmod(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t math_fmod(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -186,8 +199,7 @@ int32_t math_fmod(lua_State* L)
 	return 1;
 }
 
-} // extern "C"
-
+//-----------------------------------------------------------------------------
 void load_math(LuaEnvironment& env)
 {
 	env.load_module_function("Math", "deg_to_rad", 	math_deg_to_rad);

src/lua/MouseBinds.cpp

@@ -7,11 +7,8 @@
 namespace crown
 {
 
-extern "C"
-{
-
 //-----------------------------------------------------------------------------
-int32_t mouse_button_pressed(lua_State* L)
+CE_EXPORT int32_t mouse_button_pressed(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -23,7 +20,7 @@ int32_t mouse_button_pressed(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-int32_t mouse_button_released(lua_State* L)
+CE_EXPORT int32_t mouse_button_released(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -35,7 +32,7 @@ int32_t mouse_button_released(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-int32_t mouse_cursor_xy(lua_State* L)
+CE_EXPORT int32_t mouse_cursor_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -49,7 +46,7 @@ int32_t mouse_cursor_xy(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-int32_t mouse_set_cursor_xy(lua_State* L)
+CE_EXPORT int32_t mouse_set_cursor_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -61,7 +58,7 @@ int32_t mouse_set_cursor_xy(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-int32_t mouse_cursor_relative_xy(lua_State* L)
+CE_EXPORT int32_t mouse_cursor_relative_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -74,7 +71,7 @@ int32_t mouse_cursor_relative_xy(lua_State* L)
 }
 
 //-----------------------------------------------------------------------------
-int32_t mouse_set_cursor_relative_xy(lua_State* L)
+CE_EXPORT int32_t mouse_set_cursor_relative_xy(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -85,8 +82,6 @@ int32_t mouse_set_cursor_relative_xy(lua_State* L)
 	return 0;
 }
 
-} // extern "C"
-
 //-----------------------------------------------------------------------------
 void load_mouse(LuaEnvironment& env)
 {

src/lua/QuatBinds.cpp

@@ -7,10 +7,8 @@
 namespace crown
 {
 
-extern "C"
-{
-
-int32_t quat(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t quat(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -27,7 +25,8 @@ int32_t quat(lua_State* L)
 	return 1;
 }
 
-int32_t quat_negate(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t quat_negate(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -38,7 +37,8 @@ int32_t quat_negate(lua_State* L)
 	return 0;
 }
 
-int32_t quat_load_identity(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t quat_load_identity(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -49,7 +49,8 @@ int32_t quat_load_identity(lua_State* L)
 	return 0;
 }
 
-int32_t quat_length(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t quat_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -60,7 +61,8 @@ int32_t quat_length(lua_State* L)
 	return 1;
 }
 
-int32_t quat_conjugate(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t quat_conjugate(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -74,7 +76,8 @@ int32_t quat_conjugate(lua_State* L)
 	return 1;
 }
 
-int32_t quat_inverse(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t quat_inverse(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -88,7 +91,8 @@ int32_t quat_inverse(lua_State* L)
 	return 1;
 }
 
-int32_t quat_cross(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t quat_cross(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -102,7 +106,8 @@ int32_t quat_cross(lua_State* L)
 	return 1;
 }
 
-int32_t quat_multiply(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t quat_multiply(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -116,7 +121,8 @@ int32_t quat_multiply(lua_State* L)
 	return 1;
 }
 
-int32_t quat_power(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t quat_power(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -130,8 +136,7 @@ int32_t quat_power(lua_State* L)
 	return 1;
 }
 
-} // extern "C"
-
+//-----------------------------------------------------------------------------
 void load_quat(LuaEnvironment& env)
 {
 	env.load_module_function("Quat", "new", quat);

src/lua/Vec2Binds.cpp

@@ -6,10 +6,8 @@
 namespace crown
 {
 
-extern "C"
-{
-
-int32_t	vec2(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -26,7 +24,8 @@ int32_t	vec2(lua_State* L)
 	return 1;
 }
 
-int32_t vec2_values(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_values(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -41,8 +40,8 @@ int32_t vec2_values(lua_State* L)
 	return 2;
 }
 
-
-int32_t vec2_add(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_add(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -56,7 +55,8 @@ int32_t vec2_add(lua_State* L)
 	return 1;
 }
 
-int32_t vec2_subtract(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_subtract(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -70,7 +70,8 @@ int32_t vec2_subtract(lua_State* L)
 	return 1;
 }
 
-int32_t vec2_multiply(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_multiply(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -83,8 +84,9 @@ int32_t vec2_multiply(lua_State* L)
 
 	return 1;
 }			
-	
-int32_t vec2_divide(lua_State* L)
+
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_divide(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -98,7 +100,8 @@ int32_t vec2_divide(lua_State* L)
 	return 1;
 }
 
-int32_t vec2_dot(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_dot(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -110,7 +113,8 @@ int32_t vec2_dot(lua_State* L)
 	return 1;
 }
 
-int32_t vec2_equals(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_equals(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -122,7 +126,8 @@ int32_t vec2_equals(lua_State* L)
 	return 1;
 }
 
-int32_t vec2_lower(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_lower(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -134,7 +139,8 @@ int32_t vec2_lower(lua_State* L)
 	return 1;
 }
 
-int32_t vec2_greater(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_greater(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -146,7 +152,8 @@ int32_t vec2_greater(lua_State* L)
 	return 1;
 }
 
-int32_t vec2_length(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -157,7 +164,8 @@ int32_t vec2_length(lua_State* L)
 	return 1;
 }
 
-int32_t vec2_squared_length(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_squared_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -168,7 +176,8 @@ int32_t vec2_squared_length(lua_State* L)
 	return 1;
 }
 
-int32_t vec2_set_length(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_set_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -180,7 +189,8 @@ int32_t vec2_set_length(lua_State* L)
 	return 0;
 }
 
-int32_t	vec2_normalize(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_normalize(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -193,7 +203,8 @@ int32_t	vec2_normalize(lua_State* L)
 	return 1;
 }
 
-int32_t	vec2_negate(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_negate(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -206,7 +217,8 @@ int32_t	vec2_negate(lua_State* L)
 	return 1;
 }
 
-int32_t	vec2_get_distance_to(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_get_distance_to(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -218,7 +230,8 @@ int32_t	vec2_get_distance_to(lua_State* L)
 	return 1;
 }
 
-int32_t	vec2_get_angle_between(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_get_angle_between(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -230,7 +243,8 @@ int32_t	vec2_get_angle_between(lua_State* L)
 	return 1;
 }
 
-int32_t	vec2_zero(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec2_zero(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -241,8 +255,7 @@ int32_t	vec2_zero(lua_State* L)
 	return 0;
 }
 
-} // extern "C"
-
+//-----------------------------------------------------------------------------
 void load_vec2(LuaEnvironment& env)
 {
 	env.load_module_function("Vec2", "new", vec2);

src/lua/Vec3Binds.cpp

@@ -5,13 +5,8 @@
 namespace crown
 {
 
-/// Lightweight bind for Vec3 
-
-extern "C"
-{
-
-//------------------------------------------------------------
-int32_t vec3(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -30,8 +25,8 @@ int32_t vec3(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_values(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_values(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -48,8 +43,8 @@ int32_t vec3_values(lua_State* L)
 	return 3;
 }
 
-//------------------------------------------------------------
-int32_t vec3_add(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_add(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -63,8 +58,8 @@ int32_t vec3_add(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_subtract(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_subtract(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -78,8 +73,8 @@ int32_t vec3_subtract(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_multiply(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_multiply(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -93,8 +88,8 @@ int32_t vec3_multiply(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_divide(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_divide(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -108,8 +103,8 @@ int32_t vec3_divide(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_dot(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_dot(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -121,8 +116,8 @@ int32_t vec3_dot(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_cross(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_cross(lua_State* L)
 {
 	LuaStack stack(L);
 	
@@ -137,8 +132,8 @@ int32_t vec3_cross(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_equals(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_equals(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -150,8 +145,8 @@ int32_t vec3_equals(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_lower(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_lower(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -163,8 +158,8 @@ int32_t vec3_lower(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_greater(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_greater(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -176,8 +171,8 @@ int32_t vec3_greater(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_length(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -188,8 +183,8 @@ int32_t vec3_length(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_squared_length(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_squared_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -200,8 +195,8 @@ int32_t vec3_squared_length(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_set_length(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_set_length(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -213,8 +208,8 @@ int32_t vec3_set_length(lua_State* L)
 	return 0;
 }
 
-//------------------------------------------------------------
-int32_t vec3_normalize(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_normalize(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -225,8 +220,8 @@ int32_t vec3_normalize(lua_State* L)
 	return 0;
 }
 
-//------------------------------------------------------------
-int32_t vec3_negate(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_negate(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -237,8 +232,8 @@ int32_t vec3_negate(lua_State* L)
 	return 0;
 }
 
-//------------------------------------------------------------
-int32_t vec3_get_distance_to(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_get_distance_to(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -250,8 +245,8 @@ int32_t vec3_get_distance_to(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_get_angle_between(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_get_angle_between(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -263,8 +258,8 @@ int32_t vec3_get_angle_between(lua_State* L)
 	return 1;
 }
 
-//------------------------------------------------------------
-int32_t vec3_zero(lua_State* L)
+//-----------------------------------------------------------------------------
+CE_EXPORT int32_t vec3_zero(lua_State* L)
 {
 	LuaStack stack(L);
 
@@ -275,8 +270,7 @@ int32_t vec3_zero(lua_State* L)
 	return 0;
 }	
 
-} // extern "C"
-
+//-----------------------------------------------------------------------------
 void load_vec3(LuaEnvironment& env)
 {
 	env.load_module_function("Vec3", "new", 				vec3);