From aeba3c6fe7099d9fd8dd63ddaa77bcbc1e9bb5e2 Mon Sep 17 00:00:00 2001
From: Christophe Riccio <mail@g-truc.net>
Date: Sat, 11 Jan 2014 21:12:53 +0100
Subject: [PATCH] Quiet most GLM_FORCE_RADIANS messages

---
 glm/detail/dummy.cpp                      |   1 +
 glm/detail/type_mat.hpp                   |   5 +-
 glm/detail/type_mat2x2.inl                |  14 +-
 glm/detail/type_mat3x3.inl                |  23 +-
 glm/gtc/noise.hpp                         |   1 +
 glm/gtc/ulp.hpp                           |   2 +
 glm/gtc/ulp.inl                           |   1 +
 test/core/core_func_common.cpp            |   1 +
 test/core/core_func_exponential.cpp       |   1 +
 test/core/core_func_geometric.cpp         |   1 +
 test/core/core_func_integer.cpp           |   1 +
 test/core/core_func_matrix.cpp            |   1 +
 test/core/core_func_noise.cpp             |   2 +
 test/core/core_func_packing.cpp           |   1 +
 test/core/core_func_swizzle.cpp           |   1 +
 test/core/core_func_trigonometric.cpp     |   1 +
 test/core/core_func_vector_relational.cpp |   1 +
 test/core/core_type_cast.cpp              |   1 +
 test/core/core_type_float.cpp             |  24 +-
 test/core/core_type_int.cpp               |   1 +
 test/core/core_type_length.cpp            |   1 +
 test/core/core_type_mat2x2.cpp            |   1 +
 test/core/core_type_mat2x3.cpp            |   1 +
 test/core/core_type_mat2x4.cpp            |   1 +
 test/core/core_type_mat3x2.cpp            |   1 +
 test/core/core_type_mat3x3.cpp            |   1 +
 test/core/core_type_mat3x4.cpp            |   1 +
 test/core/core_type_mat4x2.cpp            |   1 +
 test/core/core_type_mat4x3.cpp            |   1 +
 test/core/core_type_mat4x4.cpp            |   1 +
 test/core/core_type_vec1.cpp              |   2 +-
 test/core/core_type_vec2.cpp              |   1 +
 test/core/core_type_vec3.cpp              |   1 +
 test/core/core_type_vec4.cpp              |   1 +
 test/gtc/gtc_constants.cpp                |   2 +-
 test/gtc/gtc_epsilon.cpp                  |   1 +
 test/gtc/gtc_matrix_access.cpp            |  11 +-
 test/gtc/gtc_matrix_integer.cpp           |   2 +-
 test/gtc/gtc_matrix_inverse.cpp           |   2 +-
 test/gtc/gtc_matrix_transform.cpp         |   1 -
 test/gtc/gtc_noise.cpp                    |   2 +-
 test/gtc/gtc_packing.cpp                  |   2 +-
 test/gtc/gtc_quaternion.cpp               |  45 +--
 test/gtc/gtc_random.cpp                   |   2 +-
 test/gtc/gtc_reciprocal.cpp               |   6 +-
 test/gtc/gtc_type_precision.cpp           |   2 +-
 test/gtc/gtc_type_ptr.cpp                 | 442 +++++++++++-----------
 test/gtc/gtc_ulp.cpp                      |   2 +-
 test/gtx/gtx_associated_min_max.cpp       |   4 +-
 test/gtx/gtx_bit.cpp                      |   4 +-
 test/gtx/gtx_closest_point.cpp            |   4 +-
 test/gtx/gtx_color_space.cpp              |   4 +-
 test/gtx/gtx_color_space_YCoCg.cpp        |   4 +-
 test/gtx/gtx_compatibility.cpp            |   2 +-
 test/gtx/gtx_component_wise.cpp           |   4 +-
 test/gtx/gtx_dual_quaternion.cpp          |   1 +
 test/gtx/gtx_euler_angle.cpp              |  10 +-
 test/gtx/gtx_extend.cpp                   |   2 +-
 test/gtx/gtx_extented_min_max.cpp         |   4 +-
 test/gtx/gtx_fast_exponential.cpp         |   2 +-
 test/gtx/gtx_fast_square_root.cpp         |   2 +-
 test/gtx/gtx_fast_trigonometry.cpp        |   2 +-
 test/gtx/gtx_gradient_paint.cpp           |   2 +-
 test/gtx/gtx_handed_coordinate_space.cpp  |   2 +-
 test/gtx/gtx_inertia.cpp                  |   2 +-
 test/gtx/gtx_integer.cpp                  |   2 +-
 test/gtx/gtx_intersect.cpp                |   2 +-
 test/gtx/gtx_io.cpp                       |   2 +-
 test/gtx/gtx_log_base.cpp                 |   2 +-
 test/gtx/gtx_matrix_cross_product.cpp     |   2 +-
 test/gtx/gtx_matrix_interpolation.cpp     |   4 +-
 test/gtx/gtx_matrix_major_storage.cpp     |   2 +-
 test/gtx/gtx_matrix_operation.cpp         |   2 +-
 test/gtx/gtx_matrix_query.cpp             |   2 +-
 test/gtx/gtx_multiple.cpp                 |   2 +-
 test/gtx/gtx_norm.cpp                     |   2 +-
 test/gtx/gtx_normal.cpp                   |   2 +-
 test/gtx/gtx_normalize_dot.cpp            |   2 +-
 test/gtx/gtx_number_precision.cpp         |   2 +-
 test/gtx/gtx_optimum_pow.cpp              |   1 +
 test/gtx/gtx_orthonormalize.cpp           |   1 +
 test/gtx/gtx_perpendicular.cpp            |   1 +
 test/gtx/gtx_polar_coordinates.cpp        |   1 +
 test/gtx/gtx_projection.cpp               |   1 +
 test/gtx/gtx_quaternion.cpp               |  11 +-
 test/gtx/gtx_rotate_normalized_axis.cpp   |   3 +-
 test/gtx/gtx_rotate_vector.cpp            |  92 ++---
 test/gtx/gtx_scalar_relational.cpp        |   1 +
 test/gtx/gtx_simd_mat4.cpp                |   1 +
 test/gtx/gtx_simd_vec4.cpp                |   3 +-
 test/gtx/gtx_spline.cpp                   |   1 +
 test/gtx/gtx_string_cast.cpp              |   1 +
 test/gtx/gtx_vector_angle.cpp             |  21 +-
 test/gtx/gtx_vector_query.cpp             |   1 +
 94 files changed, 435 insertions(+), 411 deletions(-)

diff --git a/glm/detail/dummy.cpp b/glm/detail/dummy.cpp
index 8cdc27dd..a95afcd3 100644
--- a/glm/detail/dummy.cpp
+++ b/glm/detail/dummy.cpp
@@ -29,6 +29,7 @@
 /// dummy.cpp exist only a wordaround for CMake file.
 ///////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #define GLM_MESSAGES
 #include "../glm.hpp"
 #include <limits>
diff --git a/glm/detail/type_mat.hpp b/glm/detail/type_mat.hpp
index 25095382..a46c4068 100644
--- a/glm/detail/type_mat.hpp
+++ b/glm/detail/type_mat.hpp
@@ -43,7 +43,10 @@ namespace detail
 	template <typename T, precision P> struct tmat4x2;
 	template <typename T, precision P> struct tmat4x3;
 	template <typename T, precision P> struct tmat4x4;
-	
+
+	template <class colType, typename rowType>
+	struct mat_trait{};
+
 	template <template <class, precision> class matType, typename T, precision P>
 	struct compute_inverse{};
 }//namespace detail
diff --git a/glm/detail/type_mat2x2.inl b/glm/detail/type_mat2x2.inl
index fc7414d8..7919a251 100644
--- a/glm/detail/type_mat2x2.inl
+++ b/glm/detail/type_mat2x2.inl
@@ -396,7 +396,7 @@ namespace detail
 	template <typename T, precision P>
 	struct compute_inverse<detail::tmat2x2, T, P>
 	{
-		static detail::tmat2x2<T, P> call(detail::tmat2x2<T, P> const & m)
+		GLM_FUNC_QUALIFIER static detail::tmat2x2<T, P> call(detail::tmat2x2<T, P> const & m)
 		{
 			T Determinant = determinant(m);
 
@@ -410,18 +410,6 @@ namespace detail
 		}
 	};
 
-	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> compute_inverse_mat2(tmat2x2<T, P> const & m)
-	{
-		T Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
-
-		tmat2x2<T, P> Inverse(
-			+ m[1][1] / Determinant, - m[0][1] / Determinant,
-			- m[1][0] / Determinant, + m[0][0] / Determinant);
-
-		return Inverse;
-	}
-
 	//////////////////////////////////////////////////////////////
 	// Binary operators
 
diff --git a/glm/detail/type_mat3x3.inl b/glm/detail/type_mat3x3.inl
index 81a15874..b64a5bfc 100644
--- a/glm/detail/type_mat3x3.inl
+++ b/glm/detail/type_mat3x3.inl
@@ -435,22 +435,21 @@ namespace detail
 	{
 		static detail::tmat3x3<T, P> call(detail::tmat3x3<T, P> const & m)
 		{
-			T Determinant =
+			T OneOverDeterminant = static_cast<T>(1) / (
 				+ m[0][0] * (m[1][1] * m[2][2] - m[2][1] * m[1][2])
 				- m[1][0] * (m[0][1] * m[2][2] - m[2][1] * m[0][2])
-				+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+				+ m[2][0] * (m[0][1] * m[1][2] - m[1][1] * m[0][2]));
 
 			detail::tmat3x3<T, P> Inverse(detail::tmat3x3<T, P>::_null);
-			Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
-			Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
-			Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
-			Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
-			Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
-			Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
-			Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
-			Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
-			Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
-			Inverse /= Determinant;
+			Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDeterminant;
+			Inverse[1][0] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDeterminant;
+			Inverse[2][0] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDeterminant;
+			Inverse[0][1] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDeterminant;
+			Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDeterminant;
+			Inverse[2][1] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDeterminant;
+			Inverse[0][2] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDeterminant;
+			Inverse[1][2] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDeterminant;
+			Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDeterminant;
 
 			return Inverse;
 		}
diff --git a/glm/gtc/noise.hpp b/glm/gtc/noise.hpp
index 873e3337..0682c76a 100644
--- a/glm/gtc/noise.hpp
+++ b/glm/gtc/noise.hpp
@@ -43,6 +43,7 @@
 
 // Dependencies
 #include "../detail/setup.hpp"
+#include "../detail/precision.hpp"
 
 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
 #	pragma message("GLM: GLM_GTC_noise extension included")
diff --git a/glm/gtc/ulp.hpp b/glm/gtc/ulp.hpp
index 8dcb5c1b..ee67ac61 100644
--- a/glm/gtc/ulp.hpp
+++ b/glm/gtc/ulp.hpp
@@ -41,6 +41,8 @@
 
 // Dependencies
 #include "../detail/setup.hpp"
+#include "../detail/precision.hpp"
+#include "../detail/type_int.hpp"
 
 #if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
 #	pragma message("GLM: GLM_GTC_ulp extension included")
diff --git a/glm/gtc/ulp.inl b/glm/gtc/ulp.inl
index 968571aa..880d4803 100644
--- a/glm/gtc/ulp.inl
+++ b/glm/gtc/ulp.inl
@@ -36,6 +36,7 @@
 #include "../detail/type_int.hpp"
 #include <cmath>
 #include <cfloat>
+#include <limits>
 
 #if(GLM_COMPILER & GLM_COMPILER_VC)
 #	pragma warning(push)
diff --git a/test/core/core_func_common.cpp b/test/core/core_func_common.cpp
index 6c996861..0c509d35 100644
--- a/test/core/core_func_common.cpp
+++ b/test/core/core_func_common.cpp
@@ -10,6 +10,7 @@
 //#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>
diff --git a/test/core/core_func_exponential.cpp b/test/core/core_func_exponential.cpp
index bc1966cd..04d0036e 100644
--- a/test/core/core_func_exponential.cpp
+++ b/test/core/core_func_exponential.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/func_exponential.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/common.hpp>
 #include <glm/exponential.hpp>
 #include <glm/gtc/ulp.hpp>
diff --git a/test/core/core_func_geometric.cpp b/test/core/core_func_geometric.cpp
index 07aa34c9..88eb4c71 100644
--- a/test/core/core_func_geometric.cpp
+++ b/test/core/core_func_geometric.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/func_geometric.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/geometric.hpp>
 #include <glm/gtc/epsilon.hpp>
 
diff --git a/test/core/core_func_integer.cpp b/test/core/core_func_integer.cpp
index f18ed790..d1fcec87 100644
--- a/test/core/core_func_integer.cpp
+++ b/test/core/core_func_integer.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/func_integer.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/integer.hpp>
 #include <iostream>
 
diff --git a/test/core/core_func_matrix.cpp b/test/core/core_func_matrix.cpp
index 1f117956..ca52f724 100644
--- a/test/core/core_func_matrix.cpp
+++ b/test/core/core_func_matrix.cpp
@@ -7,6 +7,7 @@
 // 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>
diff --git a/test/core/core_func_noise.cpp b/test/core/core_func_noise.cpp
index e9788702..5d967a69 100644
--- a/test/core/core_func_noise.cpp
+++ b/test/core/core_func_noise.cpp
@@ -7,6 +7,8 @@
 // File    : test/core/func_noise.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
+
 int main()
 {
 	int Failed = 0;
diff --git a/test/core/core_func_packing.cpp b/test/core/core_func_packing.cpp
index 236f51e3..43644936 100644
--- a/test/core/core_func_packing.cpp
+++ b/test/core/core_func_packing.cpp
@@ -7,6 +7,7 @@
 // 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>
diff --git a/test/core/core_func_swizzle.cpp b/test/core/core_func_swizzle.cpp
index 0add4cb1..1d7a7a86 100644
--- a/test/core/core_func_swizzle.cpp
+++ b/test/core/core_func_swizzle.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/core_func_swizzle.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #define GLM_MESSAGES
 #define GLM_SWIZZLE
 #include <glm/glm.hpp>
diff --git a/test/core/core_func_trigonometric.cpp b/test/core/core_func_trigonometric.cpp
index 57dff974..0dda2a3b 100644
--- a/test/core/core_func_trigonometric.cpp
+++ b/test/core/core_func_trigonometric.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/func_trigonometric.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 
 int main()
diff --git a/test/core/core_func_vector_relational.cpp b/test/core/core_func_vector_relational.cpp
index e078241f..46e64df0 100644
--- a/test/core/core_func_vector_relational.cpp
+++ b/test/core/core_func_vector_relational.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/vector_relational.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 
 int main()
diff --git a/test/core/core_type_cast.cpp b/test/core/core_type_cast.cpp
index ca43804d..7c002886 100644
--- a/test/core/core_type_cast.cpp
+++ b/test/core/core_type_cast.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_cast.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 
 struct my_vec2
diff --git a/test/core/core_type_float.cpp b/test/core/core_type_float.cpp
index 92724bf3..e51a4052 100644
--- a/test/core/core_type_float.cpp
+++ b/test/core/core_type_float.cpp
@@ -7,19 +7,20 @@
 // File    : test/core/type_float.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 
 int test_float_size()
 {
-    return
-        sizeof(glm::float_t) != sizeof(glm::lowp_float) &&
-        sizeof(glm::float_t) != sizeof(glm::mediump_float) && 
-        sizeof(glm::float_t) != sizeof(glm::highp_float);
+	return
+		sizeof(glm::float_t) != sizeof(glm::lowp_float) &&
+		sizeof(glm::float_t) != sizeof(glm::mediump_float) && 
+		sizeof(glm::float_t) != sizeof(glm::highp_float);
 }
 
 int test_float_precision()
 {
-    return (
+	return (
 		sizeof(glm::lowp_float) <= sizeof(glm::mediump_float) && 
 		sizeof(glm::mediump_float) <= sizeof(glm::highp_float)) ? 0 : 1;
 }
@@ -31,13 +32,10 @@ int test_vec2()
 
 int main()
 {
-    int Error = 0;
-    
-    Error += test_float_size();
-    Error += test_float_precision();
-    
+	int Error = 0;
+
+	Error += test_float_size();
+	Error += test_float_precision();
+
 	return Error;
 }
-
-
-
diff --git a/test/core/core_type_int.cpp b/test/core/core_type_int.cpp
index 054c5c1d..d2736107 100644
--- a/test/core/core_type_int.cpp
+++ b/test/core/core_type_int.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_int.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 
 int test_int_size()
diff --git a/test/core/core_type_length.cpp b/test/core/core_type_length.cpp
index 879caff8..cdbcd671 100644
--- a/test/core/core_type_length.cpp
+++ b/test/core/core_type_length.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_length.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 
 int test_length_mat_non_squared()
diff --git a/test/core/core_type_mat2x2.cpp b/test/core/core_type_mat2x2.cpp
index 512f50d5..d65d0ce8 100644
--- a/test/core/core_type_mat2x2.cpp
+++ b/test/core/core_type_mat2x2.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_mat2x2.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/epsilon.hpp>
 #include <glm/matrix.hpp>
 #include <glm/vector_relational.hpp>
diff --git a/test/core/core_type_mat2x3.cpp b/test/core/core_type_mat2x3.cpp
index b36bdca3..24847f7c 100644
--- a/test/core/core_type_mat2x3.cpp
+++ b/test/core/core_type_mat2x3.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_mat2x3.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/mat2x3.hpp>
 #include <vector>
diff --git a/test/core/core_type_mat2x4.cpp b/test/core/core_type_mat2x4.cpp
index 97abafce..8f7e1408 100644
--- a/test/core/core_type_mat2x4.cpp
+++ b/test/core/core_type_mat2x4.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_mat2x4.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/mat2x4.hpp>
 #include <vector>
diff --git a/test/core/core_type_mat3x2.cpp b/test/core/core_type_mat3x2.cpp
index 6e2aa7b9..facf3f14 100644
--- a/test/core/core_type_mat3x2.cpp
+++ b/test/core/core_type_mat3x2.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_mat3x2.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/mat3x2.hpp>
 #include <vector>
diff --git a/test/core/core_type_mat3x3.cpp b/test/core/core_type_mat3x3.cpp
index 21e8f893..7599cec4 100644
--- a/test/core/core_type_mat3x3.cpp
+++ b/test/core/core_type_mat3x3.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_mat3x3.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/epsilon.hpp>
 #include <glm/matrix.hpp>
 #include <glm/vector_relational.hpp>
diff --git a/test/core/core_type_mat3x4.cpp b/test/core/core_type_mat3x4.cpp
index 1d68e7f8..793e84fc 100644
--- a/test/core/core_type_mat3x4.cpp
+++ b/test/core/core_type_mat3x4.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_mat3x4.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/mat3x4.hpp>
 #include <vector>
diff --git a/test/core/core_type_mat4x2.cpp b/test/core/core_type_mat4x2.cpp
index 68026f80..4b7a79a9 100644
--- a/test/core/core_type_mat4x2.cpp
+++ b/test/core/core_type_mat4x2.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_mat4x2.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/mat4x2.hpp>
 #include <vector>
diff --git a/test/core/core_type_mat4x3.cpp b/test/core/core_type_mat4x3.cpp
index d84ca4dc..639592f4 100644
--- a/test/core/core_type_mat4x3.cpp
+++ b/test/core/core_type_mat4x3.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_mat4x3.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/mat4x3.hpp>
 #include <vector>
diff --git a/test/core/core_type_mat4x4.cpp b/test/core/core_type_mat4x4.cpp
index 6c6abc2f..b2dad8e2 100644
--- a/test/core/core_type_mat4x4.cpp
+++ b/test/core/core_type_mat4x4.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_mat4x4.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/epsilon.hpp>
 #include <glm/matrix.hpp>
 #include <glm/mat4x4.hpp>
diff --git a/test/core/core_type_vec1.cpp b/test/core/core_type_vec1.cpp
index 0f1b6a53..f76578dc 100644
--- a/test/core/core_type_vec1.cpp
+++ b/test/core/core_type_vec1.cpp
@@ -7,7 +7,7 @@
 // File    : test/core/type_vec1.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtx/vec1.hpp>
 
 int test_operators()
diff --git a/test/core/core_type_vec2.cpp b/test/core/core_type_vec2.cpp
index a12fd9c0..73ab7632 100644
--- a/test/core/core_type_vec2.cpp
+++ b/test/core/core_type_vec2.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_vec2.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/vec2.hpp>
 #include <vector>
diff --git a/test/core/core_type_vec3.cpp b/test/core/core_type_vec3.cpp
index 6bfb373f..4cce22fc 100644
--- a/test/core/core_type_vec3.cpp
+++ b/test/core/core_type_vec3.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_vec3.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #define GLM_SWIZZLE
 #include <glm/vector_relational.hpp>
 #include <glm/geometric.hpp>
diff --git a/test/core/core_type_vec4.cpp b/test/core/core_type_vec4.cpp
index 73655e23..c341b88b 100644
--- a/test/core/core_type_vec4.cpp
+++ b/test/core/core_type_vec4.cpp
@@ -7,6 +7,7 @@
 // File    : test/core/type_vec4.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/vector_relational.hpp>
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
diff --git a/test/gtc/gtc_constants.cpp b/test/gtc/gtc_constants.cpp
index ffb1e5a5..8c10f24f 100644
--- a/test/gtc/gtc_constants.cpp
+++ b/test/gtc/gtc_constants.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtc/constants.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/constants.hpp>
 
 int test_epsilon()
diff --git a/test/gtc/gtc_epsilon.cpp b/test/gtc/gtc_epsilon.cpp
index 6ef111c8..30fb4a4b 100644
--- a/test/gtc/gtc_epsilon.cpp
+++ b/test/gtc/gtc_epsilon.cpp
@@ -7,6 +7,7 @@
 // File    : test/gtc/epsilon.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/epsilon.hpp>
 #include <glm/gtc/constants.hpp>
 #include <glm/vector_relational.hpp>
diff --git a/test/gtc/gtc_matrix_access.cpp b/test/gtc/gtc_matrix_access.cpp
index c65a15f9..cfaac5f0 100644
--- a/test/gtc/gtc_matrix_access.cpp
+++ b/test/gtc/gtc_matrix_access.cpp
@@ -7,8 +7,17 @@
 // File    : test/gtc/matrix_access.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/matrix_access.hpp>
+#include <glm/mat2x2.hpp>
+#include <glm/mat2x3.hpp>
+#include <glm/mat2x4.hpp>
+#include <glm/mat3x2.hpp>
+#include <glm/mat3x3.hpp>
+#include <glm/mat3x4.hpp>
+#include <glm/mat4x2.hpp>
+#include <glm/mat4x3.hpp>
+#include <glm/mat4x4.hpp>
 
 int test_mat2x2_row_set()
 {
diff --git a/test/gtc/gtc_matrix_integer.cpp b/test/gtc/gtc_matrix_integer.cpp
index 655f3ed5..58c07b9d 100644
--- a/test/gtc/gtc_matrix_integer.cpp
+++ b/test/gtc/gtc_matrix_integer.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtc/matrix_integer.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/matrix_integer.hpp>
 
 int main()
diff --git a/test/gtc/gtc_matrix_inverse.cpp b/test/gtc/gtc_matrix_inverse.cpp
index f9675da8..bd296461 100644
--- a/test/gtc/gtc_matrix_inverse.cpp
+++ b/test/gtc/gtc_matrix_inverse.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtc/matrix_inverse.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/matrix_inverse.hpp>
 
 int main()
diff --git a/test/gtc/gtc_matrix_transform.cpp b/test/gtc/gtc_matrix_transform.cpp
index d91e0128..05d5f50e 100644
--- a/test/gtc/gtc_matrix_transform.cpp
+++ b/test/gtc/gtc_matrix_transform.cpp
@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #define GLM_FORCE_RADIANS
-#include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtc/constants.hpp>
 
diff --git a/test/gtc/gtc_noise.cpp b/test/gtc/gtc_noise.cpp
index 4200412e..1939f258 100644
--- a/test/gtc/gtc_noise.cpp
+++ b/test/gtc/gtc_noise.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtc/noise.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/noise.hpp>
 #include <gli/gli.hpp>
 #include <gli/gtx/loader.hpp>
diff --git a/test/gtc/gtc_packing.cpp b/test/gtc/gtc_packing.cpp
index 1834c01b..8acfb74f 100644
--- a/test/gtc/gtc_packing.cpp
+++ b/test/gtc/gtc_packing.cpp
@@ -26,7 +26,7 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/packing.hpp>
 #include <cstdio>
 #include <vector>
diff --git a/test/gtc/gtc_quaternion.cpp b/test/gtc/gtc_quaternion.cpp
index c672754c..01dda9b6 100644
--- a/test/gtc/gtc_quaternion.cpp
+++ b/test/gtc/gtc_quaternion.cpp
@@ -7,6 +7,7 @@
 // File    : test/gtc/quaternion.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/quaternion.hpp>
 #include <glm/gtc/epsilon.hpp>
 #include <glm/vector_relational.hpp>
@@ -16,28 +17,28 @@ int test_quat_angle()
 	int Error = 0;
 
 	{
-		glm::quat Q = glm::angleAxis(45.0f, glm::vec3(0, 0, 1));
+		glm::quat Q = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
 		glm::quat N = glm::normalize(Q);
 		float L = glm::length(N);
 		Error += glm::epsilonEqual(L, 1.0f, 0.01f) ? 0 : 1;
 		float A = glm::angle(N);
-		Error += glm::epsilonEqual(A, 45.0f, 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(A, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
 	}
 	{
-		glm::quat Q = glm::angleAxis(45.0f, glm::normalize(glm::vec3(0, 1, 1)));
+		glm::quat Q = glm::angleAxis(glm::pi<float>() * 0.25f, glm::normalize(glm::vec3(0, 1, 1)));
 		glm::quat N = glm::normalize(Q);
 		float L = glm::length(N);
 		Error += glm::epsilonEqual(L, 1.0f, 0.01f) ? 0 : 1;
 		float A = glm::angle(N);
-		Error += glm::epsilonEqual(A, 45.0f, 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(A, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
 	}
 	{
-		glm::quat Q = glm::angleAxis(45.0f, glm::normalize(glm::vec3(1, 2, 3)));
+		glm::quat Q = glm::angleAxis(glm::pi<float>() * 0.25f, glm::normalize(glm::vec3(1, 2, 3)));
 		glm::quat N = glm::normalize(Q);
 		float L = glm::length(N);
 		Error += glm::epsilonEqual(L, 1.0f, 0.01f) ? 0 : 1;
 		float A = glm::angle(N);
-		Error += glm::epsilonEqual(A, 45.0f, 0.01f) ? 0 : 1;
+		Error += glm::epsilonEqual(A, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
 	}
 
 	return Error;
@@ -48,9 +49,9 @@ int test_quat_angleAxis()
 	int Error = 0;
 
 	glm::quat A = glm::angleAxis(0.0f, glm::vec3(0, 0, 1));
-	glm::quat B = glm::angleAxis(90.0f, glm::vec3(0, 0, 1));
+	glm::quat B = glm::angleAxis(glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
 	glm::quat C = glm::mix(A, B, 0.5f);
-	glm::quat D = glm::angleAxis(45.0f, glm::vec3(0, 0, 1));
+	glm::quat D = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
 
 	Error += glm::epsilonEqual(C.x, D.x, 0.01f) ? 0 : 1;
 	Error += glm::epsilonEqual(C.y, D.y, 0.01f) ? 0 : 1;
@@ -65,9 +66,9 @@ int test_quat_mix()
 	int Error = 0;
 
 	glm::quat A = glm::angleAxis(0.0f, glm::vec3(0, 0, 1));
-	glm::quat B = glm::angleAxis(90.0f, glm::vec3(0, 0, 1));
+	glm::quat B = glm::angleAxis(glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
 	glm::quat C = glm::mix(A, B, 0.5f);
-	glm::quat D = glm::angleAxis(45.0f, glm::vec3(0, 0, 1));
+	glm::quat D = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
 
 	Error += glm::epsilonEqual(C.x, D.x, 0.01f) ? 0 : 1;
 	Error += glm::epsilonEqual(C.y, D.y, 0.01f) ? 0 : 1;
@@ -92,19 +93,19 @@ int test_quat_normalize()
 	int Error(0);
 
 	{
-		glm::quat Q = glm::angleAxis(45.0f, glm::vec3(0, 0, 1));
+		glm::quat Q = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
 		glm::quat N = glm::normalize(Q);
 		float L = glm::length(N);
 		Error += glm::epsilonEqual(L, 1.0f, 0.000001f) ? 0 : 1;
 	}
 	{
-		glm::quat Q = glm::angleAxis(45.0f, glm::vec3(0, 0, 2));
+		glm::quat Q = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 2));
 		glm::quat N = glm::normalize(Q);
 		float L = glm::length(N);
 		Error += glm::epsilonEqual(L, 1.0f, 0.000001f) ? 0 : 1;
 	}
 	{
-		glm::quat Q = glm::angleAxis(45.0f, glm::vec3(1, 2, 3));
+		glm::quat Q = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(1, 2, 3));
 		glm::quat N = glm::normalize(Q);
 		float L = glm::length(N);
 		Error += glm::epsilonEqual(L, 1.0f, 0.000001f) ? 0 : 1;
@@ -170,7 +171,7 @@ int test_quat_slerp()
 	// certainly not a 135° rotation
 	glm::quat Y45rot3 = glm::slerp(id , -Y90rot, 0.5f);
 	float Y45angle3 = glm::angle(Y45rot3);
-	Error += glm::epsilonEqual(Y45angle3, 45.f, Epsilon) ? 0 : 1;
+	Error += glm::epsilonEqual(Y45angle3, glm::pi<float>() * 0.25f, Epsilon) ? 0 : 1;
 	Error += glm::all(glm::epsilonEqual(Ym45rot2, Y45rot3, Epsilon)) ? 0 : 1;
 
 	// Same, but inverted
@@ -188,7 +189,7 @@ int test_quat_slerp()
 	// Must be 90° rotation on almost any axis that is on the XZ plane
 	glm::quat XZ90rot = glm::slerp(id, -Y90rot, 0.5f);
 	float XZ90angle = glm::angle(XZ90rot); // Must be PI/4 = 0.78;
-	Error += glm::epsilonEqual(XZ90angle, 45.f, Epsilon) ? 0 : 1;
+	Error += glm::epsilonEqual(XZ90angle, glm::pi<float>() * 0.25f, Epsilon) ? 0 : 1;
 
 	// Testing almost equal quaternions (this test should pass through the linear interpolation)
 	// Must be 0 0.00X 0 0.99999
@@ -210,15 +211,15 @@ int test_quat_mul()
 	glm::quat temp5 = glm::normalize(temp1 * temp2);
 	glm::vec3 temp6 = temp5 * glm::vec3(0.0, 1.0, 0.0) * glm::inverse(temp5);
 
-  {
-    glm::quat temp7;
+	{
+		glm::quat temp7;
 
-    temp7 *= temp5;
-    temp7 *= glm::inverse(temp5);
+		temp7 *= temp5;
+		temp7 *= glm::inverse(temp5);
+
+		Error += temp7 != glm::quat();
+	}
 
-    Error += temp7 != glm::quat();
-  }
-  
 	return Error;
 }
 
diff --git a/test/gtc/gtc_random.cpp b/test/gtc/gtc_random.cpp
index 79ddbb0a..902a3b52 100644
--- a/test/gtc/gtc_random.cpp
+++ b/test/gtc/gtc_random.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtc/random.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/random.hpp>
 #include <glm/gtc/epsilon.hpp>
 #include <iostream>
diff --git a/test/gtc/gtc_reciprocal.cpp b/test/gtc/gtc_reciprocal.cpp
index e9d80e26..2fd51d61 100644
--- a/test/gtc/gtc_reciprocal.cpp
+++ b/test/gtc/gtc_reciprocal.cpp
@@ -7,16 +7,12 @@
 // File    : test/gtc/reciprocal.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/reciprocal.hpp>
 
 int main()
 {
 	int Error(0);
 
-
-
 	return Error;
 }
-
-
diff --git a/test/gtc/gtc_type_precision.cpp b/test/gtc/gtc_type_precision.cpp
index d523567c..653cb8b8 100644
--- a/test/gtc/gtc_type_precision.cpp
+++ b/test/gtc/gtc_type_precision.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtc/type_precision.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtc/quaternion.hpp>
 #include <vector>
diff --git a/test/gtc/gtc_type_ptr.cpp b/test/gtc/gtc_type_ptr.cpp
index c8b26fde..df579f64 100644
--- a/test/gtc/gtc_type_ptr.cpp
+++ b/test/gtc/gtc_type_ptr.cpp
@@ -7,256 +7,256 @@
 // File    : test/gtc/type_ptr.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_ptr.hpp>
 
 int test_value_ptr_vec()
 {
-    int Error = 0;
-    
-    {
-        glm::vec2 v(1.0);
-        float * p = glm::value_ptr(v);
-        Error += p == &v[0] ? 0 : 1;
-    }
-    {
-        glm::vec3 v(1.0);
-        float * p = glm::value_ptr(v);
-        Error += p == &v[0] ? 0 : 1;
-    }
-    {
-        glm::vec4 v(1.0);
-        float * p = glm::value_ptr(v);
-        Error += p == &v[0] ? 0 : 1;
-    }
-    
-    {
-        glm::dvec2 v(1.0);
-        double * p = glm::value_ptr(v);
-        Error += p == &v[0] ? 0 : 1;
-    }
-    {
-        glm::dvec3 v(1.0);
-        double * p = glm::value_ptr(v);
-        Error += p == &v[0] ? 0 : 1;
-    }
-    {
-        glm::dvec4 v(1.0);
-        double * p = glm::value_ptr(v);
-        Error += p == &v[0] ? 0 : 1;
-    }
-    
-    return Error;
+	int Error = 0;
+
+	{
+		glm::vec2 v(1.0);
+		float * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::vec3 v(1.0);
+		float * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::vec4 v(1.0);
+		float * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+
+	{
+		glm::dvec2 v(1.0);
+		double * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::dvec3 v(1.0);
+		double * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::dvec4 v(1.0);
+		double * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+
+	return Error;
 }
 
 int test_value_ptr_vec_const()
 {
-    int Error = 0;
-    
-    {
-        glm::vec2 const v(1.0);
-        float const * p = glm::value_ptr(v);
-        Error += p == &v[0] ? 0 : 1;
-    }
-    {
-        glm::vec3 const v(1.0);
-        float const * p = glm::value_ptr(v);
-        Error += p == &v[0] ? 0 : 1;
-    }
-    {
-        glm::vec4 const v(1.0);
-        float const * p = glm::value_ptr(v);
-        Error += p == &v[0] ? 0 : 1;
-    }
-    
-    {
-        glm::dvec2 const v(1.0);
-        double const * p = glm::value_ptr(v);
-        Error += p == &v[0] ? 0 : 1;
-    }
-    {
-        glm::dvec3 const v(1.0);
-        double const * p = glm::value_ptr(v);
-        Error += p == &v[0] ? 0 : 1;
-    }
-    {
-        glm::dvec4 const v(1.0);
-        double const * p = glm::value_ptr(v);
-        Error += p == &v[0] ? 0 : 1;
-    }
-    
-    return Error;
+	int Error = 0;
+
+	{
+		glm::vec2 const v(1.0);
+		float const * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::vec3 const v(1.0);
+		float const * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::vec4 const v(1.0);
+		float const * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+
+	{
+		glm::dvec2 const v(1.0);
+		double const * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::dvec3 const v(1.0);
+		double const * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+	{
+		glm::dvec4 const v(1.0);
+		double const * p = glm::value_ptr(v);
+		Error += p == &v[0] ? 0 : 1;
+	}
+
+	return Error;
 }
 
 int test_value_ptr_mat()
 {
-    int Error = 0;
-    
-    {
-        glm::mat2x2 m(1.0);
-        float * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat2x3 m(1.0);
-        float * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat2x4 m(1.0);
-        float * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat3x2 m(1.0);
-        float * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat3x3 m(1.0);
-        float * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat3x4 m(1.0);
-        float * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat4x2 m(1.0);
-        float * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat4x3 m(1.0);
-        float * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat4x4 m(1.0);
-        float * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    
-    return Error;
+	int Error = 0;
+
+	{
+		glm::mat2x2 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat2x3 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat2x4 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat3x2 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat3x3 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat3x4 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat4x2 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat4x3 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat4x4 m(1.0);
+		float * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+
+	return Error;
 }
 
 int test_value_ptr_mat_const()
 {
-    int Error = 0;
-    
-    {
-        glm::mat2x2 const m(1.0);
-        float const * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat2x3 const m(1.0);
-        float const * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat2x4 const m(1.0);
-        float const * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat3x2 const m(1.0);
-        float const * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat3x3 const m(1.0);
-        float const * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat3x4 const m(1.0);
-        float const * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat4x2 const m(1.0);
-        float const * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat4x3 const m(1.0);
-        float const * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    {
-        glm::mat4x4 const m(1.0);
-        float const * p = glm::value_ptr(m);
-        Error += p == &m[0][0] ? 0 : 1;
-    }
-    
-    return Error;
+	int Error = 0;
+
+	{
+		glm::mat2x2 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat2x3 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat2x4 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat3x2 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat3x3 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat3x4 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat4x2 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat4x3 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+	{
+		glm::mat4x4 const m(1.0);
+		float const * p = glm::value_ptr(m);
+		Error += p == &m[0][0] ? 0 : 1;
+	}
+
+	return Error;
 }
 
 int test_make_pointer_mat()
 {
-    int Error = 0;
+	int Error = 0;
 
-    float ArrayA[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
-    double ArrayB[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
- 
-    glm::mat2x2 Mat2x2A = glm::make_mat2x2(ArrayA);
-    glm::mat2x3 Mat2x3A = glm::make_mat2x3(ArrayA);
-    glm::mat2x4 Mat2x4A = glm::make_mat2x4(ArrayA);
-    glm::mat3x2 Mat3x2A = glm::make_mat3x2(ArrayA);
-    glm::mat3x3 Mat3x3A = glm::make_mat3x3(ArrayA);
-    glm::mat3x4 Mat3x4A = glm::make_mat3x4(ArrayA);
-    glm::mat4x2 Mat4x2A = glm::make_mat4x2(ArrayA);
-    glm::mat4x3 Mat4x3A = glm::make_mat4x3(ArrayA);
-    glm::mat4x4 Mat4x4A = glm::make_mat4x4(ArrayA);
-  
-    glm::dmat2x2 Mat2x2B = glm::make_mat2x2(ArrayB);
-    glm::dmat2x3 Mat2x3B = glm::make_mat2x3(ArrayB);
-    glm::dmat2x4 Mat2x4B = glm::make_mat2x4(ArrayB);
-    glm::dmat3x2 Mat3x2B = glm::make_mat3x2(ArrayB);
-    glm::dmat3x3 Mat3x3B = glm::make_mat3x3(ArrayB);
-    glm::dmat3x4 Mat3x4B = glm::make_mat3x4(ArrayB);
-    glm::dmat4x2 Mat4x2B = glm::make_mat4x2(ArrayB);
-    glm::dmat4x3 Mat4x3B = glm::make_mat4x3(ArrayB);
-    glm::dmat4x4 Mat4x4B = glm::make_mat4x4(ArrayB);
-	
-    return Error;
+	float ArrayA[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+	double ArrayB[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+
+	glm::mat2x2 Mat2x2A = glm::make_mat2x2(ArrayA);
+	glm::mat2x3 Mat2x3A = glm::make_mat2x3(ArrayA);
+	glm::mat2x4 Mat2x4A = glm::make_mat2x4(ArrayA);
+	glm::mat3x2 Mat3x2A = glm::make_mat3x2(ArrayA);
+	glm::mat3x3 Mat3x3A = glm::make_mat3x3(ArrayA);
+	glm::mat3x4 Mat3x4A = glm::make_mat3x4(ArrayA);
+	glm::mat4x2 Mat4x2A = glm::make_mat4x2(ArrayA);
+	glm::mat4x3 Mat4x3A = glm::make_mat4x3(ArrayA);
+	glm::mat4x4 Mat4x4A = glm::make_mat4x4(ArrayA);
+
+	glm::dmat2x2 Mat2x2B = glm::make_mat2x2(ArrayB);
+	glm::dmat2x3 Mat2x3B = glm::make_mat2x3(ArrayB);
+	glm::dmat2x4 Mat2x4B = glm::make_mat2x4(ArrayB);
+	glm::dmat3x2 Mat3x2B = glm::make_mat3x2(ArrayB);
+	glm::dmat3x3 Mat3x3B = glm::make_mat3x3(ArrayB);
+	glm::dmat3x4 Mat3x4B = glm::make_mat3x4(ArrayB);
+	glm::dmat4x2 Mat4x2B = glm::make_mat4x2(ArrayB);
+	glm::dmat4x3 Mat4x3B = glm::make_mat4x3(ArrayB);
+	glm::dmat4x4 Mat4x4B = glm::make_mat4x4(ArrayB);
+
+	return Error;
 }
 
 int test_make_pointer_vec()
 {
-    int Error = 0;
-    
-    float ArrayA[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
-    int ArrayB[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
-    bool ArrayC[] = {true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false};
-    
-    glm::vec2 Vec2A = glm::make_vec2(ArrayA);
-    glm::vec3 Vec3A = glm::make_vec3(ArrayA);
-    glm::vec4 Vec4A = glm::make_vec4(ArrayA);
-    
-    glm::ivec2 Vec2B = glm::make_vec2(ArrayB);
-    glm::ivec3 Vec3B = glm::make_vec3(ArrayB);
-    glm::ivec4 Vec4B = glm::make_vec4(ArrayB);
-  
-    glm::bvec2 Vec2C = glm::make_vec2(ArrayC);
-    glm::bvec3 Vec3C = glm::make_vec3(ArrayC);
-    glm::bvec4 Vec4C = glm::make_vec4(ArrayC);
-    
-    return Error;
+	int Error = 0;
+
+	float ArrayA[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+	int ArrayB[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+	bool ArrayC[] = {true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false};
+
+	glm::vec2 Vec2A = glm::make_vec2(ArrayA);
+	glm::vec3 Vec3A = glm::make_vec3(ArrayA);
+	glm::vec4 Vec4A = glm::make_vec4(ArrayA);
+
+	glm::ivec2 Vec2B = glm::make_vec2(ArrayB);
+	glm::ivec3 Vec3B = glm::make_vec3(ArrayB);
+	glm::ivec4 Vec4B = glm::make_vec4(ArrayB);
+
+	glm::bvec2 Vec2C = glm::make_vec2(ArrayC);
+	glm::bvec3 Vec3C = glm::make_vec3(ArrayC);
+	glm::bvec4 Vec4C = glm::make_vec4(ArrayC);
+
+	return Error;
 }
 
 int main()
 {
 	int Error = 0;
-    
-    Error += test_make_pointer_vec();
-    Error += test_make_pointer_mat();
-    Error += test_value_ptr_vec();
-    Error += test_value_ptr_vec_const();
-    Error += test_value_ptr_mat();
-    Error += test_value_ptr_mat_const();
-    
+
+	Error += test_make_pointer_vec();
+	Error += test_make_pointer_mat();
+	Error += test_value_ptr_vec();
+	Error += test_value_ptr_vec_const();
+	Error += test_value_ptr_mat();
+	Error += test_value_ptr_mat_const();
+
 	return Error;
 }
diff --git a/test/gtc/gtc_ulp.cpp b/test/gtc/gtc_ulp.cpp
index 7d861d14..ae734564 100644
--- a/test/gtc/gtc_ulp.cpp
+++ b/test/gtc/gtc_ulp.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtc/ulp.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/ulp.hpp>
 #include <iostream>
 #include <limits>
diff --git a/test/gtx/gtx_associated_min_max.cpp b/test/gtx/gtx_associated_min_max.cpp
index e3bb267b..9700e31d 100644
--- a/test/gtx/gtx_associated_min_max.cpp
+++ b/test/gtx/gtx_associated_min_max.cpp
@@ -7,9 +7,7 @@
 // File    : test/gtx/associated_min_max.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <emmintrin.h>
-
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/associated_min_max.hpp>
 
diff --git a/test/gtx/gtx_bit.cpp b/test/gtx/gtx_bit.cpp
index bc5e4523..d3ec857a 100644
--- a/test/gtx/gtx_bit.cpp
+++ b/test/gtx/gtx_bit.cpp
@@ -7,11 +7,11 @@
 // File    : test/gtx/bit.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <emmintrin.h>
-
+#define GLM_FORCE_RADIANS
 #include <glm/gtx/bit.hpp>
 #include <glm/gtc/type_precision.hpp>
 
+#include <emmintrin.h>
 #if(GLM_ARCH != GLM_ARCH_PURE)
 #	include <glm/detail/intrinsic_integer.hpp>
 #endif
diff --git a/test/gtx/gtx_closest_point.cpp b/test/gtx/gtx_closest_point.cpp
index e3bb267b..9700e31d 100644
--- a/test/gtx/gtx_closest_point.cpp
+++ b/test/gtx/gtx_closest_point.cpp
@@ -7,9 +7,7 @@
 // File    : test/gtx/associated_min_max.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <emmintrin.h>
-
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/associated_min_max.hpp>
 
diff --git a/test/gtx/gtx_color_space.cpp b/test/gtx/gtx_color_space.cpp
index 1dbe0444..a4e909c5 100644
--- a/test/gtx/gtx_color_space.cpp
+++ b/test/gtx/gtx_color_space.cpp
@@ -7,9 +7,7 @@
 // File    : test/gtx/color_space.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <emmintrin.h>
-
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/color_space.hpp>
 
diff --git a/test/gtx/gtx_color_space_YCoCg.cpp b/test/gtx/gtx_color_space_YCoCg.cpp
index 83fd1fb5..86c39a89 100644
--- a/test/gtx/gtx_color_space_YCoCg.cpp
+++ b/test/gtx/gtx_color_space_YCoCg.cpp
@@ -7,9 +7,7 @@
 // File    : test/gtx/color_space_YCoCg.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <emmintrin.h>
-
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/color_space_YCoCg.hpp>
 
diff --git a/test/gtx/gtx_compatibility.cpp b/test/gtx/gtx_compatibility.cpp
index 0ee1d236..c462c545 100644
--- a/test/gtx/gtx_compatibility.cpp
+++ b/test/gtx/gtx_compatibility.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/compatibility.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/compatibility.hpp>
 
diff --git a/test/gtx/gtx_component_wise.cpp b/test/gtx/gtx_component_wise.cpp
index 674acb72..35bcc452 100644
--- a/test/gtx/gtx_component_wise.cpp
+++ b/test/gtx/gtx_component_wise.cpp
@@ -7,9 +7,7 @@
 // File    : test/gtx/component_wise.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <emmintrin.h>
-
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/component_wise.hpp>
 
diff --git a/test/gtx/gtx_dual_quaternion.cpp b/test/gtx/gtx_dual_quaternion.cpp
index 334bbda9..932ae090 100644
--- a/test/gtx/gtx_dual_quaternion.cpp
+++ b/test/gtx/gtx_dual_quaternion.cpp
@@ -7,6 +7,7 @@
 // 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>
diff --git a/test/gtx/gtx_euler_angle.cpp b/test/gtx/gtx_euler_angle.cpp
index 037ef675..16597809 100644
--- a/test/gtx/gtx_euler_angle.cpp
+++ b/test/gtx/gtx_euler_angle.cpp
@@ -1,7 +1,15 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// Created : 2013-10-25
+// Updated : 2014-01-11
+// Licence : This source is under MIT licence
+// File    : test/gtx/euler_angle.cpp
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
 // Code sample from Filippo Ramaciotti
 
 #define GLM_FORCE_RADIANS
-#include <glm/glm.hpp>
 #include <glm/gtc/matrix_transform.hpp>
 #include <glm/gtx/string_cast.hpp>
 #include <glm/gtx/euler_angles.hpp>
diff --git a/test/gtx/gtx_extend.cpp b/test/gtx/gtx_extend.cpp
index a75bef40..593fa165 100644
--- a/test/gtx/gtx_extend.cpp
+++ b/test/gtx/gtx_extend.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/extend.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/extend.hpp>
 
diff --git a/test/gtx/gtx_extented_min_max.cpp b/test/gtx/gtx_extented_min_max.cpp
index e3bb267b..9700e31d 100644
--- a/test/gtx/gtx_extented_min_max.cpp
+++ b/test/gtx/gtx_extented_min_max.cpp
@@ -7,9 +7,7 @@
 // File    : test/gtx/associated_min_max.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <emmintrin.h>
-
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/associated_min_max.hpp>
 
diff --git a/test/gtx/gtx_fast_exponential.cpp b/test/gtx/gtx_fast_exponential.cpp
index c13c0b84..b074fbac 100644
--- a/test/gtx/gtx_fast_exponential.cpp
+++ b/test/gtx/gtx_fast_exponential.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/associated_min_max.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/fast_exponential.hpp>
 
diff --git a/test/gtx/gtx_fast_square_root.cpp b/test/gtx/gtx_fast_square_root.cpp
index 50f4a502..f5322c15 100644
--- a/test/gtx/gtx_fast_square_root.cpp
+++ b/test/gtx/gtx_fast_square_root.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/fast_square_root.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/fast_square_root.hpp>
 
diff --git a/test/gtx/gtx_fast_trigonometry.cpp b/test/gtx/gtx_fast_trigonometry.cpp
index c9432daf..1f86280e 100644
--- a/test/gtx/gtx_fast_trigonometry.cpp
+++ b/test/gtx/gtx_fast_trigonometry.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/fast_trigonometry.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/fast_trigonometry.hpp>
 
diff --git a/test/gtx/gtx_gradient_paint.cpp b/test/gtx/gtx_gradient_paint.cpp
index 85f33567..7320f1f6 100644
--- a/test/gtx/gtx_gradient_paint.cpp
+++ b/test/gtx/gtx_gradient_paint.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/gradient_paint.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtx/gradient_paint.hpp>
 
 int test_radialGradient()
diff --git a/test/gtx/gtx_handed_coordinate_space.cpp b/test/gtx/gtx_handed_coordinate_space.cpp
index 1b8837e4..15894fb1 100644
--- a/test/gtx/gtx_handed_coordinate_space.cpp
+++ b/test/gtx/gtx_handed_coordinate_space.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/handed_coordinate_space.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/handed_coordinate_space.hpp>
 
diff --git a/test/gtx/gtx_inertia.cpp b/test/gtx/gtx_inertia.cpp
index 58f9f0d9..c5c21098 100644
--- a/test/gtx/gtx_inertia.cpp
+++ b/test/gtx/gtx_inertia.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/inertia.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/inertia.hpp>
 
diff --git a/test/gtx/gtx_integer.cpp b/test/gtx/gtx_integer.cpp
index 20810110..5c1b24a6 100644
--- a/test/gtx/gtx_integer.cpp
+++ b/test/gtx/gtx_integer.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/gtx_integer.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/epsilon.hpp>
 #include <glm/gtx/integer.hpp>
 #include <cstdio>
diff --git a/test/gtx/gtx_intersect.cpp b/test/gtx/gtx_intersect.cpp
index 88fa4f44..04b26cdb 100644
--- a/test/gtx/gtx_intersect.cpp
+++ b/test/gtx/gtx_intersect.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/intersect.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/intersect.hpp>
 
diff --git a/test/gtx/gtx_io.cpp b/test/gtx/gtx_io.cpp
index 417eac3a..05ba8e9b 100644
--- a/test/gtx/gtx_io.cpp
+++ b/test/gtx/gtx_io.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/io.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/io.hpp>
 #include <iostream>
diff --git a/test/gtx/gtx_log_base.cpp b/test/gtx/gtx_log_base.cpp
index 79e4d335..10b5c600 100644
--- a/test/gtx/gtx_log_base.cpp
+++ b/test/gtx/gtx_log_base.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/log_base.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/log_base.hpp>
 
diff --git a/test/gtx/gtx_matrix_cross_product.cpp b/test/gtx/gtx_matrix_cross_product.cpp
index a0739d4f..c58efa25 100644
--- a/test/gtx/gtx_matrix_cross_product.cpp
+++ b/test/gtx/gtx_matrix_cross_product.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/matrix_cross_product.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/matrix_cross_product.hpp>
 
diff --git a/test/gtx/gtx_matrix_interpolation.cpp b/test/gtx/gtx_matrix_interpolation.cpp
index a116106d..101832b4 100644
--- a/test/gtx/gtx_matrix_interpolation.cpp
+++ b/test/gtx/gtx_matrix_interpolation.cpp
@@ -7,15 +7,13 @@
 // File    : test/gtx/matrix_interpolation.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtx/matrix_interpolation.hpp>
 
 int main()
 {
 	int Error(0);
 
-
-
 	return Error;
 }
 
diff --git a/test/gtx/gtx_matrix_major_storage.cpp b/test/gtx/gtx_matrix_major_storage.cpp
index 8d6f737e..2ef47e9e 100644
--- a/test/gtx/gtx_matrix_major_storage.cpp
+++ b/test/gtx/gtx_matrix_major_storage.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/matrix_major_storage.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/matrix_major_storage.hpp>
 
diff --git a/test/gtx/gtx_matrix_operation.cpp b/test/gtx/gtx_matrix_operation.cpp
index d41c4832..7e8d2605 100644
--- a/test/gtx/gtx_matrix_operation.cpp
+++ b/test/gtx/gtx_matrix_operation.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/matrix_operation.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/matrix_operation.hpp>
 
diff --git a/test/gtx/gtx_matrix_query.cpp b/test/gtx/gtx_matrix_query.cpp
index 84ce82d4..29a62fb4 100644
--- a/test/gtx/gtx_matrix_query.cpp
+++ b/test/gtx/gtx_matrix_query.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/matrix_query.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtx/matrix_query.hpp>
 
 int test_isNull()
diff --git a/test/gtx/gtx_multiple.cpp b/test/gtx/gtx_multiple.cpp
index 050945bb..61bb2689 100644
--- a/test/gtx/gtx_multiple.cpp
+++ b/test/gtx/gtx_multiple.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/gtx_multiple.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtx/multiple.hpp>
 
 int test_higher_int()
diff --git a/test/gtx/gtx_norm.cpp b/test/gtx/gtx_norm.cpp
index 6b7c089a..a0373e39 100644
--- a/test/gtx/gtx_norm.cpp
+++ b/test/gtx/gtx_norm.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/norm.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/norm.hpp>
 
diff --git a/test/gtx/gtx_normal.cpp b/test/gtx/gtx_normal.cpp
index 54ce2017..1d0ac29e 100644
--- a/test/gtx/gtx_normal.cpp
+++ b/test/gtx/gtx_normal.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/normal.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/normal.hpp>
 
diff --git a/test/gtx/gtx_normalize_dot.cpp b/test/gtx/gtx_normalize_dot.cpp
index 0eafdc24..d212b9a2 100644
--- a/test/gtx/gtx_normalize_dot.cpp
+++ b/test/gtx/gtx_normalize_dot.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/normalize_dot.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/normalize_dot.hpp>
 
diff --git a/test/gtx/gtx_number_precision.cpp b/test/gtx/gtx_number_precision.cpp
index caecd352..9cb52c82 100644
--- a/test/gtx/gtx_number_precision.cpp
+++ b/test/gtx/gtx_number_precision.cpp
@@ -7,7 +7,7 @@
 // File    : test/gtx/number_precision.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/number_precision.hpp>
 
diff --git a/test/gtx/gtx_optimum_pow.cpp b/test/gtx/gtx_optimum_pow.cpp
index 430d0e5e..4b749f23 100644
--- a/test/gtx/gtx_optimum_pow.cpp
+++ b/test/gtx/gtx_optimum_pow.cpp
@@ -7,6 +7,7 @@
 // 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>
diff --git a/test/gtx/gtx_orthonormalize.cpp b/test/gtx/gtx_orthonormalize.cpp
index e9902d63..4a6108dc 100644
--- a/test/gtx/gtx_orthonormalize.cpp
+++ b/test/gtx/gtx_orthonormalize.cpp
@@ -7,6 +7,7 @@
 // File    : test/gtx/orthonormalize.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/orthonormalize.hpp>
diff --git a/test/gtx/gtx_perpendicular.cpp b/test/gtx/gtx_perpendicular.cpp
index 0f2a5fec..bf500473 100644
--- a/test/gtx/gtx_perpendicular.cpp
+++ b/test/gtx/gtx_perpendicular.cpp
@@ -7,6 +7,7 @@
 // File    : test/gtx/perpendicular.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/perpendicular.hpp>
diff --git a/test/gtx/gtx_polar_coordinates.cpp b/test/gtx/gtx_polar_coordinates.cpp
index 957c9884..fbb28861 100644
--- a/test/gtx/gtx_polar_coordinates.cpp
+++ b/test/gtx/gtx_polar_coordinates.cpp
@@ -7,6 +7,7 @@
 // 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>
diff --git a/test/gtx/gtx_projection.cpp b/test/gtx/gtx_projection.cpp
index 777c165b..bd52d935 100644
--- a/test/gtx/gtx_projection.cpp
+++ b/test/gtx/gtx_projection.cpp
@@ -7,6 +7,7 @@
 // File    : test/gtx/projection.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/type_precision.hpp>
 #include <glm/gtx/projection.hpp>
diff --git a/test/gtx/gtx_quaternion.cpp b/test/gtx/gtx_quaternion.cpp
index 7094a21d..49f6b5d9 100644
--- a/test/gtx/gtx_quaternion.cpp
+++ b/test/gtx/gtx_quaternion.cpp
@@ -7,6 +7,7 @@
 // File    : test/gtx/quaternion.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtc/epsilon.hpp>
 #include <glm/gtx/quaternion.hpp>
@@ -16,9 +17,9 @@ int test_quat_fastMix()
 	int Error = 0;
 
 	glm::quat A = glm::angleAxis(0.0f, glm::vec3(0, 0, 1));
-	glm::quat B = glm::angleAxis(90.0f, glm::vec3(0, 0, 1));
+	glm::quat B = glm::angleAxis(glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
 	glm::quat C = glm::fastMix(A, B, 0.5f);
-	glm::quat D = glm::angleAxis(45.0f, glm::vec3(0, 0, 1));
+	glm::quat D = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
 
 	Error += glm::epsilonEqual(C.x, D.x, 0.01f) ? 0 : 1;
 	Error += glm::epsilonEqual(C.y, D.y, 0.01f) ? 0 : 1;
@@ -33,9 +34,9 @@ int test_quat_shortMix()
 	int Error(0);
 
 	glm::quat A = glm::angleAxis(0.0f, glm::vec3(0, 0, 1));
-	glm::quat B = glm::angleAxis(90.0f, glm::vec3(0, 0, 1));
+	glm::quat B = glm::angleAxis(glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
 	glm::quat C = glm::shortMix(A, B, 0.5f);
-	glm::quat D = glm::angleAxis(45.0f, glm::vec3(0, 0, 1));
+	glm::quat D = glm::angleAxis(glm::pi<float>() * 0.25f, glm::vec3(0, 0, 1));
 
 	Error += glm::epsilonEqual(C.x, D.x, 0.01f) ? 0 : 1;
 	Error += glm::epsilonEqual(C.y, D.y, 0.01f) ? 0 : 1;
@@ -78,7 +79,7 @@ int test_rotation()
 
 	float Angle = glm::angle(Rotation);
 
-	Error += glm::abs(Angle - 90.0f) < glm::epsilon<float>() ? 0 : 1;
+	Error += glm::abs(Angle - glm::pi<float>() * 0.5f) < glm::epsilon<float>() ? 0 : 1;
 
 	return Error;
 }
diff --git a/test/gtx/gtx_rotate_normalized_axis.cpp b/test/gtx/gtx_rotate_normalized_axis.cpp
index 5d5c9b9e..aea8fef6 100644
--- a/test/gtx/gtx_rotate_normalized_axis.cpp
+++ b/test/gtx/gtx_rotate_normalized_axis.cpp
@@ -26,12 +26,13 @@
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtx/rotate_normalized_axis.hpp>
 
 int main()
 {
 	int Error(0);
-	
+
 	return Error;
 }
diff --git a/test/gtx/gtx_rotate_vector.cpp b/test/gtx/gtx_rotate_vector.cpp
index 5bf89a7c..516fec47 100644
--- a/test/gtx/gtx_rotate_vector.cpp
+++ b/test/gtx/gtx_rotate_vector.cpp
@@ -7,31 +7,23 @@
 // File    : test/gtx/rotate_vector.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
+#include <glm/gtc/constants.hpp>
 #include <glm/gtx/rotate_vector.hpp>
 
 int test_rotate()
 {
 	int Error = 0;
 
-	glm::vec2 A = glm::rotate(glm::vec2(1, 0), 90.f);
-
-	glm::vec3 B = glm::rotate(glm::vec3(1, 0, 0), 90.f, glm::vec3(0, 0, 1));
-
-	glm::vec4 C = glm::rotate(glm::vec4(1, 0, 0, 1), 90.f, glm::vec3(0, 0, 1));
-
-	glm::vec3 D = glm::rotateX(glm::vec3(1, 0, 0), 90.f);
-
-	glm::vec4 E = glm::rotateX(glm::vec4(1, 0, 0, 1), 90.f);
-
-	glm::vec3 F = glm::rotateY(glm::vec3(1, 0, 0), 90.f);
-
-	glm::vec4 G = glm::rotateY(glm::vec4(1, 0, 0, 1), 90.f);
-
-	glm::vec3 H = glm::rotateZ(glm::vec3(1, 0, 0), 90.f);
-
-	glm::vec4 I = glm::rotateZ(glm::vec4(1, 0, 0,1 ), 90.f);
-
+	glm::vec2 A = glm::rotate(glm::vec2(1, 0), glm::pi<float>() * 0.5f);
+	glm::vec3 B = glm::rotate(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
+	glm::vec4 C = glm::rotate(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f, glm::vec3(0, 0, 1));
+	glm::vec3 D = glm::rotateX(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
+	glm::vec4 E = glm::rotateX(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f);
+	glm::vec3 F = glm::rotateY(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
+	glm::vec4 G = glm::rotateY(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f);
+	glm::vec3 H = glm::rotateZ(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
+	glm::vec4 I = glm::rotateZ(glm::vec4(1, 0, 0,1 ), glm::pi<float>() * 0.5f);
 	glm::mat4 O = glm::orientation(glm::normalize(glm::vec3(1)), glm::vec3(0, 0, 1));
 
 	return Error;
@@ -39,56 +31,54 @@ int test_rotate()
 
 int test_rotateX()
 {
-    int Error = 0;
-      
-    glm::vec3 D = glm::rotateX(glm::vec3(1, 0, 0), 90.f);
-    
-    glm::vec4 E = glm::rotateX(glm::vec4(1, 0, 0, 1), 90.f);
-    
-    return Error;
+	int Error = 0;
+
+	glm::vec3 D = glm::rotateX(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
+	glm::vec4 E = glm::rotateX(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f);
+
+	return Error;
 }
 
 int test_rotateY()
 {
-    int Error = 0;
-    
-    glm::vec3 F = glm::rotateY(glm::vec3(1, 0, 0), 90.f);
-    
-    glm::vec4 G = glm::rotateY(glm::vec4(1, 0, 0, 1), 90.f);
-     
-    return Error;
+	int Error = 0;
+
+	glm::vec3 F = glm::rotateY(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
+	glm::vec4 G = glm::rotateY(glm::vec4(1, 0, 0, 1), glm::pi<float>() * 0.5f);
+
+	return Error;
 }
 
 
 int test_rotateZ()
 {
-    int Error = 0;
-      
-    glm::vec3 H = glm::rotateZ(glm::vec3(1, 0, 0), 90.f);
-    
-    glm::vec4 I = glm::rotateZ(glm::vec4(1, 0, 0,1 ), 90.f);
-    
-    return Error;
+	int Error = 0;
+
+	glm::vec3 H = glm::rotateZ(glm::vec3(1, 0, 0), glm::pi<float>() * 0.5f);
+	glm::vec4 I = glm::rotateZ(glm::vec4(1, 0, 0,1 ), glm::pi<float>() * 0.5f);
+
+	return Error;
 }
 
 int test_orientation()
 {
-    int Error = 0;
-    
-    glm::mat4 O = glm::orientation(glm::normalize(glm::vec3(1)), glm::vec3(0, 0, 1));
-    
-    return Error;
+	int Error = 0;
+
+	glm::mat4 O = glm::orientation(glm::normalize(glm::vec3(1)), glm::vec3(0, 0, 1));
+
+	return Error;
 }
 
 int main()
 {
 	int Error = 0;
-    Error += test_rotate();
-    Error += test_rotateX();
-    Error += test_rotateY();
-    Error += test_rotateZ();
-    Error += test_orientation();
-    
+
+	Error += test_rotate();
+	Error += test_rotateX();
+	Error += test_rotateY();
+	Error += test_rotateZ();
+	Error += test_orientation();
+
 	return Error;
 }
 
diff --git a/test/gtx/gtx_scalar_relational.cpp b/test/gtx/gtx_scalar_relational.cpp
index 096d1dc8..06cc45b9 100644
--- a/test/gtx/gtx_scalar_relational.cpp
+++ b/test/gtx/gtx_scalar_relational.cpp
@@ -7,6 +7,7 @@
 // File    : test/gtx/gtx_scalar_relational.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtx/scalar_relational.hpp>
 #include <cstdio>
diff --git a/test/gtx/gtx_simd_mat4.cpp b/test/gtx/gtx_simd_mat4.cpp
index d7a64638..fd85f7fa 100644
--- a/test/gtx/gtx_simd_mat4.cpp
+++ b/test/gtx/gtx_simd_mat4.cpp
@@ -7,6 +7,7 @@
 // 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>
diff --git a/test/gtx/gtx_simd_vec4.cpp b/test/gtx/gtx_simd_vec4.cpp
index d189e63d..3591125a 100644
--- a/test/gtx/gtx_simd_vec4.cpp
+++ b/test/gtx/gtx_simd_vec4.cpp
@@ -7,6 +7,7 @@
 // File    : test/gtx/simd-vec4.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtx/simd_vec4.hpp>
 #include <cstdio>
@@ -28,7 +29,7 @@ int main()
 	//printf("C1(%2.3f, %2.3f, %2.3f, %2.3f)\n", C1.x, C1.y, C1.z, C1.w);
 	//printf("D1(%2.3f, %2.3f, %2.3f, %2.3f)\n", D1.x, D1.y, D1.z, D1.w);
 
-	__m128 value;
+	__m128 value = _mm_set1_ps(0.0f);
 	__m128 data = _mm_cmpeq_ps(value, value);
 	__m128 add0 = _mm_add_ps(data, data);
 
diff --git a/test/gtx/gtx_spline.cpp b/test/gtx/gtx_spline.cpp
index d82536fe..4feff809 100644
--- a/test/gtx/gtx_spline.cpp
+++ b/test/gtx/gtx_spline.cpp
@@ -7,6 +7,7 @@
 // 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>
diff --git a/test/gtx/gtx_string_cast.cpp b/test/gtx/gtx_string_cast.cpp
index 68bb1180..3e43d2c7 100644
--- a/test/gtx/gtx_string_cast.cpp
+++ b/test/gtx/gtx_string_cast.cpp
@@ -7,6 +7,7 @@
 // File    : test/gtx/string_cast.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtx/string_cast.hpp>
 #include <iostream>
diff --git a/test/gtx/gtx_vector_angle.cpp b/test/gtx/gtx_vector_angle.cpp
index 435b7821..e8306cf6 100644
--- a/test/gtx/gtx_vector_angle.cpp
+++ b/test/gtx/gtx_vector_angle.cpp
@@ -7,7 +7,8 @@
 // File    : test/gtx/vector_angle.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-#include <glm/glm.hpp>
+#define GLM_FORCE_RADIANS
+#include <glm/gtc/constants.hpp>
 #include <glm/gtx/vector_angle.hpp>
 #include <iostream>
 #include <limits>
@@ -17,11 +18,11 @@ int test_angle()
 	int Error = 0;
 	
 	float AngleA = glm::angle(glm::vec2(1, 0), glm::normalize(glm::vec2(1, 1)));
-	Error += glm::epsilonEqual(AngleA, 45.f, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(AngleA, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
 	float AngleB = glm::angle(glm::vec3(1, 0, 0), glm::normalize(glm::vec3(1, 1, 0)));
-	Error += glm::epsilonEqual(AngleB, 45.f, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(AngleB, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
 	float AngleC = glm::angle(glm::vec4(1, 0, 0, 0), glm::normalize(glm::vec4(1, 1, 0, 0)));
-	Error += glm::epsilonEqual(AngleC, 45.f, 0.01f) ? 0 : 1;
+	Error += glm::epsilonEqual(AngleC, glm::pi<float>() * 0.25f, 0.01f) ? 0 : 1;
 
 	return Error;
 }
@@ -31,11 +32,11 @@ int test_orientedAngle_vec2()
 	int Error = 0;
 	
 	float AngleA = glm::orientedAngle(glm::vec2(1, 0), glm::normalize(glm::vec2(1, 1)));
-	Error += AngleA == 45.f ? 0 : 1;
+	Error += AngleA == glm::pi<float>() * 0.25f ? 0 : 1;
 	float AngleB = glm::orientedAngle(glm::vec2(0, 1), glm::normalize(glm::vec2(1, 1)));
-	Error += AngleB == -45.f ? 0 : 1;
+	Error += AngleB == -glm::pi<float>() * 0.25f ? 0 : 1;
 	float AngleC = glm::orientedAngle(glm::normalize(glm::vec2(1, 1)), glm::vec2(0, 1));
-	Error += AngleC == 45.f ? 0 : 1;
+	Error += AngleC == glm::pi<float>() * 0.25f ? 0 : 1;
 
 	return Error;
 }
@@ -45,11 +46,11 @@ int test_orientedAngle_vec3()
 	int Error = 0;
 	
 	float AngleA = glm::orientedAngle(glm::vec3(1, 0, 0), glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 0, 1));
-	Error += AngleA == 45.f ? 0 : 1;
+	Error += AngleA == glm::pi<float>() * 0.25f ? 0 : 1;
 	float AngleB = glm::orientedAngle(glm::vec3(0, 1, 0), glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 0, 1));
-	Error += AngleB == -45.f ? 0 : 1;
+	Error += AngleB == -glm::pi<float>() * 0.25f ? 0 : 1;
 	float AngleC = glm::orientedAngle(glm::normalize(glm::vec3(1, 1, 0)), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1));
-	Error += AngleC == 45.f ? 0 : 1;
+	Error += AngleC == glm::pi<float>() * 0.25f ? 0 : 1;
 
 	return Error;
 }
diff --git a/test/gtx/gtx_vector_query.cpp b/test/gtx/gtx_vector_query.cpp
index d6d8f9fc..607694c1 100644
--- a/test/gtx/gtx_vector_query.cpp
+++ b/test/gtx/gtx_vector_query.cpp
@@ -7,6 +7,7 @@
 // File    : test/gtx/vector_query.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_RADIANS
 #include <glm/glm.hpp>
 #include <glm/gtx/vector_query.hpp>