Removed last references to GLM_FORCE_RADIANS

2014-08-04 00:10:12 +02:00
parent fa6bec2f3d
commit 2b747cbbad
98 changed files with 49 additions and 227 deletions
--- a/test/core/core_func_common.cpp
+++ b/test/core/core_func_common.cpp
@@ -10,7 +10,6 @@
 //#include <boost/array.hpp>
 //#include <boost/date_time/posix_time/posix_time.hpp>
 //#include <boost/thread/thread.hpp>
-#define GLM_FORCE_RADIANS
 #include <glm/gtc/constants.hpp>
 #include <glm/gtc/epsilon.hpp>
 #include <cstdio>
--- a/test/core/core_func_exponential.cpp
+++ b/test/core/core_func_exponential.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/func_exponential.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/common.hpp>
 #include <glm/exponential.hpp>
 #include <glm/gtc/ulp.hpp>
--- a/test/core/core_func_geometric.cpp
+++ b/test/core/core_func_geometric.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/func_geometric.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/geometric.hpp>
 #include <glm/gtc/epsilon.hpp>

--- a/test/core/core_func_integer.cpp
+++ b/test/core/core_func_integer.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/func_integer.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/integer.hpp>
 #include <iostream>

--- a/test/core/core_func_matrix.cpp
+++ b/test/core/core_func_matrix.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/func_matrix.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/matrix.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/ulp.hpp>
--- a/test/core/core_func_noise.cpp
+++ b/test/core/core_func_noise.cpp
@@ -7,8 +7,6 @@
 // File    : test/core/func_noise.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
-
 int main()
 {
 	int Failed = 0;
--- a/test/core/core_func_packing.cpp
+++ b/test/core/core_func_packing.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/func_packing.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtc/epsilon.hpp>
 #include <glm/vector_relational.hpp>
--- a/test/core/core_func_swizzle.cpp
+++ b/test/core/core_func_swizzle.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/core_func_swizzle.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #define GLM_MESSAGES
 #define GLM_SWIZZLE
 #include <glm/glm.hpp>
--- a/test/core/core_func_trigonometric.cpp
+++ b/test/core/core_func_trigonometric.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/func_trigonometric.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>

 int main()
--- a/test/core/core_func_vector_relational.cpp
+++ b/test/core/core_func_vector_relational.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/vector_relational.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>

 int main()
--- a/test/core/core_type_cast.cpp
+++ b/test/core/core_type_cast.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_cast.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <algorithm>
 #include <vector>
--- a/test/core/core_type_float.cpp
+++ b/test/core/core_type_float.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_float.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>

 int test_float_size()
--- a/test/core/core_type_int.cpp
+++ b/test/core/core_type_int.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_int.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>

 int test_int_size()
--- a/test/core/core_type_length.cpp
+++ b/test/core/core_type_length.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_length.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>

 int test_length_mat_non_squared()
--- a/test/core/core_type_mat2x2.cpp
+++ b/test/core/core_type_mat2x2.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_mat2x2.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/epsilon.hpp>
 #include <glm/matrix.hpp>
 #include <glm/vector_relational.hpp>
--- a/test/core/core_type_mat2x3.cpp
+++ b/test/core/core_type_mat2x3.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_mat2x3.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/mat2x3.hpp>
 #include <vector>
--- a/test/core/core_type_mat2x4.cpp
+++ b/test/core/core_type_mat2x4.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_mat2x4.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/mat2x4.hpp>
 #include <vector>
--- a/test/core/core_type_mat3x2.cpp
+++ b/test/core/core_type_mat3x2.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_mat3x2.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/mat3x2.hpp>
 #include <vector>
--- a/test/core/core_type_mat3x3.cpp
+++ b/test/core/core_type_mat3x3.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_mat3x3.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/epsilon.hpp>
 #include <glm/matrix.hpp>
 #include <glm/vector_relational.hpp>
--- a/test/core/core_type_mat3x4.cpp
+++ b/test/core/core_type_mat3x4.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_mat3x4.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/mat3x4.hpp>
 #include <vector>
--- a/test/core/core_type_mat4x2.cpp
+++ b/test/core/core_type_mat4x2.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_mat4x2.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/mat4x2.hpp>
 #include <vector>
--- a/test/core/core_type_mat4x3.cpp
+++ b/test/core/core_type_mat4x3.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_mat4x3.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/mat4x3.hpp>
 #include <vector>
--- a/test/core/core_type_mat4x4.cpp
+++ b/test/core/core_type_mat4x4.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_mat4x4.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/epsilon.hpp>
 #include <glm/matrix.hpp>
 #include <glm/mat4x4.hpp>
--- a/test/core/core_type_vec1.cpp
+++ b/test/core/core_type_vec1.cpp
@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////

 #define GLM_SWIZZLE
-#define GLM_FORCE_RADIANS
 #include <glm/gtx/vec1.hpp>

 int test_operators()
--- a/test/core/core_type_vec2.cpp
+++ b/test/core/core_type_vec2.cpp
@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////

 #define GLM_SWIZZLE
-#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/vec2.hpp>
 #include <vector>
--- a/test/core/core_type_vec3.cpp
+++ b/test/core/core_type_vec3.cpp
@@ -7,7 +7,6 @@
 // File    : test/core/type_vec3.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #define GLM_SWIZZLE
 #include <glm/vector_relational.hpp>
 #include <glm/geometric.hpp>
--- a/test/core/core_type_vec4.cpp
+++ b/test/core/core_type_vec4.cpp
@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////

 #define GLM_SWIZZLE
-#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
--- a/test/gtc/gtc_constants.cpp
+++ b/test/gtc/gtc_constants.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/constants.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/constants.hpp>

 int test_epsilon()
--- a/test/gtc/gtc_epsilon.cpp
+++ b/test/gtc/gtc_epsilon.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/epsilon.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/epsilon.hpp>
 #include <glm/gtc/constants.hpp>
 #include <glm/vector_relational.hpp>
--- a/test/gtc/gtc_matrix_access.cpp
+++ b/test/gtc/gtc_matrix_access.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/matrix_access.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/matrix_access.hpp>
 #include <glm/mat2x2.hpp>
 #include <glm/mat2x3.hpp>
--- a/test/gtc/gtc_matrix_integer.cpp
+++ b/test/gtc/gtc_matrix_integer.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/matrix_integer.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/matrix_integer.hpp>

 int main()
--- a/test/gtc/gtc_matrix_inverse.cpp
+++ b/test/gtc/gtc_matrix_inverse.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/matrix_inverse.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/matrix_inverse.hpp>

 int main()
--- a/test/gtc/gtc_matrix_transform.cpp
+++ b/test/gtc/gtc_matrix_transform.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/matrix_transform.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/constants.hpp>

--- a/test/gtc/gtc_noise.cpp
+++ b/test/gtc/gtc_noise.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/noise.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/noise.hpp>
 #include <gli/gli.hpp>
 #include <gli/gtx/loader.hpp>
--- a/test/gtc/gtc_packing.cpp
+++ b/test/gtc/gtc_packing.cpp
@@ -26,7 +26,6 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/packing.hpp>
 #include <cstdio>
 #include <vector>
--- a/test/gtc/gtc_quaternion.cpp
+++ b/test/gtc/gtc_quaternion.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/quaternion.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/quaternion.hpp>
 #include <glm/gtc/epsilon.hpp>
 #include <glm/vector_relational.hpp>
--- a/test/gtc/gtc_random.cpp
+++ b/test/gtc/gtc_random.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/random.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/random.hpp>
 #include <glm/gtc/epsilon.hpp>
 #include <iostream>
--- a/test/gtc/gtc_reciprocal.cpp
+++ b/test/gtc/gtc_reciprocal.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/reciprocal.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/reciprocal.hpp>

 int main()
--- a/test/gtc/gtc_type_precision.cpp
+++ b/test/gtc/gtc_type_precision.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/type_precision.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtc/quaternion.hpp>
 #include <vector>
--- a/test/gtc/gtc_type_ptr.cpp
+++ b/test/gtc/gtc_type_ptr.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/type_ptr.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_ptr.hpp>

 int test_value_ptr_vec()
--- a/test/gtc/gtc_ulp.cpp
+++ b/test/gtc/gtc_ulp.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/ulp.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/ulp.hpp>
 #include <iostream>
 #include <limits>
--- a/test/gtx/gtx_associated_min_max.cpp
+++ b/test/gtx/gtx_associated_min_max.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/associated_min_max.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/associated_min_max.hpp>

--- a/test/gtx/gtx_bit.cpp
+++ b/test/gtx/gtx_bit.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/bit.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtx/bit.hpp>
 #include <glm/gtc/type_precision.hpp>

--- a/test/gtx/gtx_closest_point.cpp
+++ b/test/gtx/gtx_closest_point.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/associated_min_max.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/associated_min_max.hpp>

--- a/test/gtx/gtx_color_space.cpp
+++ b/test/gtx/gtx_color_space.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/color_space.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/color_space.hpp>

--- a/test/gtx/gtx_color_space_YCoCg.cpp
+++ b/test/gtx/gtx_color_space_YCoCg.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/color_space_YCoCg.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/color_space_YCoCg.hpp>

--- a/test/gtx/gtx_compatibility.cpp
+++ b/test/gtx/gtx_compatibility.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/compatibility.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/compatibility.hpp>

--- a/test/gtx/gtx_component_wise.cpp
+++ b/test/gtx/gtx_component_wise.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/component_wise.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/component_wise.hpp>

--- a/test/gtx/gtx_dual_quaternion.cpp
+++ b/test/gtx/gtx_dual_quaternion.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtc/gtc_dual_quaternion.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtx/dual_quaternion.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/epsilon.hpp>
--- a/test/gtx/gtx_euler_angle.cpp
+++ b/test/gtx/gtx_euler_angle.cpp
@@ -9,7 +9,6 @@

 // Code sample from Filippo Ramaciotti

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/epsilon.hpp>
 #include <glm/gtx/string_cast.hpp>
--- a/test/gtx/gtx_extend.cpp
+++ b/test/gtx/gtx_extend.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/extend.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/extend.hpp>

--- a/test/gtx/gtx_extented_min_max.cpp
+++ b/test/gtx/gtx_extented_min_max.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/associated_min_max.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/associated_min_max.hpp>

--- a/test/gtx/gtx_fast_exponential.cpp
+++ b/test/gtx/gtx_fast_exponential.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/associated_min_max.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/fast_exponential.hpp>

--- a/test/gtx/gtx_fast_square_root.cpp
+++ b/test/gtx/gtx_fast_square_root.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/fast_square_root.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtx/fast_square_root.hpp>
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtc/epsilon.hpp>
--- a/test/gtx/gtx_fast_trigonometry.cpp
+++ b/test/gtx/gtx_fast_trigonometry.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/fast_trigonometry.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/fast_trigonometry.hpp>

--- a/test/gtx/gtx_gradient_paint.cpp
+++ b/test/gtx/gtx_gradient_paint.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/gradient_paint.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtx/gradient_paint.hpp>

 int test_radialGradient()
--- a/test/gtx/gtx_handed_coordinate_space.cpp
+++ b/test/gtx/gtx_handed_coordinate_space.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/handed_coordinate_space.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/handed_coordinate_space.hpp>

--- a/test/gtx/gtx_inertia.cpp
+++ b/test/gtx/gtx_inertia.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/inertia.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/inertia.hpp>

--- a/test/gtx/gtx_integer.cpp
+++ b/test/gtx/gtx_integer.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/gtx_integer.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/epsilon.hpp>
 #include <glm/gtx/integer.hpp>
 #include <cstdio>
--- a/test/gtx/gtx_intersect.cpp
+++ b/test/gtx/gtx_intersect.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/intersect.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/intersect.hpp>

--- a/test/gtx/gtx_io.cpp
+++ b/test/gtx/gtx_io.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/io.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/io.hpp>
 #include <iostream>
--- a/test/gtx/gtx_log_base.cpp
+++ b/test/gtx/gtx_log_base.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/log_base.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/log_base.hpp>

--- a/test/gtx/gtx_matrix_cross_product.cpp
+++ b/test/gtx/gtx_matrix_cross_product.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/matrix_cross_product.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/matrix_cross_product.hpp>

--- a/test/gtx/gtx_matrix_interpolation.cpp
+++ b/test/gtx/gtx_matrix_interpolation.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/matrix_interpolation.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtx/matrix_interpolation.hpp>

 int main()
--- a/test/gtx/gtx_matrix_major_storage.cpp
+++ b/test/gtx/gtx_matrix_major_storage.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/matrix_major_storage.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/matrix_major_storage.hpp>

--- a/test/gtx/gtx_matrix_operation.cpp
+++ b/test/gtx/gtx_matrix_operation.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/matrix_operation.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/matrix_operation.hpp>

--- a/test/gtx/gtx_matrix_query.cpp
+++ b/test/gtx/gtx_matrix_query.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/matrix_query.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtx/matrix_query.hpp>

 int test_isNull()
--- a/test/gtx/gtx_matrix_transform_2d.cpp
+++ b/test/gtx/gtx_matrix_transform_2d.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/matrix_transform_2d.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtx/matrix_transform_2d.hpp>

 int main()
--- a/test/gtx/gtx_multiple.cpp
+++ b/test/gtx/gtx_multiple.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/gtx_multiple.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtx/multiple.hpp>

 int test_higher_int()
--- a/test/gtx/gtx_norm.cpp
+++ b/test/gtx/gtx_norm.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/norm.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/norm.hpp>

--- a/test/gtx/gtx_normal.cpp
+++ b/test/gtx/gtx_normal.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/normal.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/normal.hpp>

--- a/test/gtx/gtx_normalize_dot.cpp
+++ b/test/gtx/gtx_normalize_dot.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/normalize_dot.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/normalize_dot.hpp>

--- a/test/gtx/gtx_number_precision.cpp
+++ b/test/gtx/gtx_number_precision.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/number_precision.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/number_precision.hpp>

--- a/test/gtx/gtx_optimum_pow.cpp
+++ b/test/gtx/gtx_optimum_pow.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/optimum_pow.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/optimum_pow.hpp>
--- a/test/gtx/gtx_orthonormalize.cpp
+++ b/test/gtx/gtx_orthonormalize.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/orthonormalize.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/orthonormalize.hpp>
--- a/test/gtx/gtx_perpendicular.cpp
+++ b/test/gtx/gtx_perpendicular.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/perpendicular.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/perpendicular.hpp>
--- a/test/gtx/gtx_polar_coordinates.cpp
+++ b/test/gtx/gtx_polar_coordinates.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/polar_coordinates.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/polar_coordinates.hpp>
--- a/test/gtx/gtx_projection.cpp
+++ b/test/gtx/gtx_projection.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/projection.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/projection.hpp>
--- a/test/gtx/gtx_quaternion.cpp
+++ b/test/gtx/gtx_quaternion.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/quaternion.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/epsilon.hpp>
 #include <glm/gtc/type_ptr.hpp>
 #include <glm/gtc/matrix_transform.hpp>
--- a/test/gtx/gtx_rotate_normalized_axis.cpp
+++ b/test/gtx/gtx_rotate_normalized_axis.cpp
@@ -26,7 +26,6 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtx/rotate_normalized_axis.hpp>

--- a/test/gtx/gtx_rotate_vector.cpp
+++ b/test/gtx/gtx_rotate_vector.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/rotate_vector.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/constants.hpp>
 #include <glm/gtx/rotate_vector.hpp>

--- a/test/gtx/gtx_scalar_relational.cpp
+++ b/test/gtx/gtx_scalar_relational.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/gtx_scalar_relational.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtx/scalar_relational.hpp>
 #include <cstdio>
--- a/test/gtx/gtx_simd_mat4.cpp
+++ b/test/gtx/gtx_simd_mat4.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/simd-mat4.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/quaternion.hpp>
--- a/test/gtx/gtx_simd_vec4.cpp
+++ b/test/gtx/gtx_simd_vec4.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/simd-vec4.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtx/simd_vec4.hpp>
 #include <cstdio>
--- a/test/gtx/gtx_spline.cpp
+++ b/test/gtx/gtx_spline.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/associated_min_max.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/spline.hpp>
--- a/test/gtx/gtx_string_cast.cpp
+++ b/test/gtx/gtx_string_cast.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/string_cast.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtx/string_cast.hpp>
 #include <iostream>
--- a/test/gtx/gtx_vector_angle.cpp
+++ b/test/gtx/gtx_vector_angle.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/vector_angle.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/gtc/constants.hpp>
 #include <glm/gtx/vector_angle.hpp>
 #include <iostream>
--- a/test/gtx/gtx_vector_query.cpp
+++ b/test/gtx/gtx_vector_query.cpp
@@ -7,7 +7,6 @@
 // File    : test/gtx/vector_query.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////

-#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtx/vector_query.hpp>