Removed last references to GLM_FORCE_RADIANS

glm/detail/dummy.cpp

@@ -29,7 +29,6 @@
 /// dummy.cpp exist only a wordaround for CMake file.
 ///////////////////////////////////////////////////////////////////////////////////
 
-#define GLM_FORCE_RADIANS
 #define GLM_MESSAGES
 #include "../glm.hpp"
 #include <limits>

glm/gtc/matrix_transform.hpp

@@ -89,7 +89,7 @@ namespace glm
 	/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle. 
 	/// 
 	/// @param m Input matrix multiplied by this rotation matrix.
-	/// @param angle Rotation angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param angle Rotation angle expressed in radians.
 	/// @param axis Rotation axis, recommanded to be normalized.
 	/// @tparam T Value type used to build the matrix. Supported: half, float or double.
 	/// @see gtc_matrix_transform
@@ -175,7 +175,7 @@ namespace glm
 
 	/// Creates a matrix for a symetric perspective-view frustum.
 	/// 
-	/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param fovy Expressed in radians.
 	/// @param aspect 
 	/// @param near 
 	/// @param far 
@@ -190,7 +190,7 @@ namespace glm
 
 	/// Builds a perspective projection matrix based on a field of view.
 	/// 
-	/// @param fov Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param fov Expressed in radians.
 	/// @param width 
 	/// @param height 
 	/// @param near 
@@ -207,7 +207,7 @@ namespace glm
 
 	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite.
 	/// 
-	/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param fovy Expressed in radians.
 	/// @param aspect 
 	/// @param near 
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
@@ -218,7 +218,7 @@ namespace glm
 
 	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
 	/// 
-	/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param fovy Expressed in radians.
 	/// @param aspect 
 	/// @param near 
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
@@ -229,7 +229,7 @@ namespace glm
 
 	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
 	/// 
-	/// @param fovy Expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param fovy Expressed in radians.
 	/// @param aspect 
 	/// @param near 
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.

glm/gtc/matrix_transform.inl

@@ -52,14 +52,9 @@ namespace glm
 		detail::tvec3<T, P> const & v
 	)
 	{
-#ifdef GLM_FORCE_RADIANS
+		T const a = angle;
-		T a = angle;
+		T const c = cos(a);
-#else
+		T const s = sin(a);
-#		pragma message("GLM: rotate function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		T a = radians(angle);
-#endif
-		T c = cos(a);
-		T s = sin(a);
 
 		detail::tvec3<T, P> axis(normalize(v));
 		detail::tvec3<T, P> temp((T(1) - c) * axis);
@@ -93,14 +88,9 @@ namespace glm
 		detail::tvec3<T, P> const & v
 	)
 	{
-#ifdef GLM_FORCE_RADIANS
 		T const a = angle;
-#else
+		T const c = cos(a);
-#		pragma message("GLM: rotate_slow function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
+		T const s = sin(a);
-		T const a = radians(angle);
-#endif
-		T c = cos(a);
-		T s = sin(a);
 		detail::tmat4x4<T, P> Result;
 
 		detail::tvec3<T, P> axis = normalize(v);
@@ -126,10 +116,10 @@ namespace glm
 
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> scale
-		(
+	(
 		detail::tmat4x4<T, P> const & m,
 		detail::tvec3<T, P> const & v
-		)
+	)
 	{
 		detail::tmat4x4<T, P> Result(detail::tmat4x4<T, P>::_null);
 		Result[0] = m[0] * v[0];
@@ -226,14 +216,8 @@ namespace glm
 		assert(aspect != static_cast<T>(0));
 		assert(zFar != zNear);
 
-#ifdef GLM_FORCE_RADIANS
 		T const rad = fovy;
-#else
+		T const tanHalfFovy = tan(rad / static_cast<T>(2));
-#		pragma message("GLM: perspective function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		T const rad = glm::radians(fovy);
-#endif
-
-		T tanHalfFovy = tan(rad / static_cast<T>(2));
 
 		detail::tmat4x4<T, defaultp> Result(static_cast<T>(0));
 		Result[0][0] = static_cast<T>(1) / (aspect * tanHalfFovy);
@@ -258,14 +242,9 @@ namespace glm
 		assert(height > static_cast<T>(0));
 		assert(fov > static_cast<T>(0));
 	
-#ifdef GLM_FORCE_RADIANS
+		T const rad = fov;
-		T rad = fov;
+		T const h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
-#else
+		T const w = h * height / width; ///todo max(width , Height) / min(width , Height)?
-#		pragma message("GLM: perspectiveFov function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		T rad = glm::radians(fov);
-#endif
-		T h = glm::cos(static_cast<T>(0.5) * rad) / glm::sin(static_cast<T>(0.5) * rad);
-		T w = h * height / width; ///todo max(width , Height) / min(width , Height)?
 
 		detail::tmat4x4<T, defaultp> Result(static_cast<T>(0));
 		Result[0][0] = w;
@@ -284,16 +263,11 @@ namespace glm
 		T zNear
 	)
 	{
-#ifdef GLM_FORCE_RADIANS
 		T const range = tan(fovy / T(2)) * zNear;
-#else
+		T const left = -range * aspect;
-#		pragma message("GLM: infinitePerspective function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
+		T const right = range * aspect;
-		T const range = tan(radians(fovy / T(2))) * zNear;	
+		T const bottom = -range;
-#endif
+		T const top = range;
-		T left = -range * aspect;
-		T right = range * aspect;
-		T bottom = -range;
-		T top = range;
 
 		detail::tmat4x4<T, defaultp> Result(T(0));
 		Result[0][0] = (T(2) * zNear) / (right - left);
@@ -314,16 +288,11 @@ namespace glm
 		T ep
 	)
 	{
-#ifdef GLM_FORCE_RADIANS
+		T const range = tan(fovy / T(2)) * zNear;	
-		T range = tan(fovy / T(2)) * zNear;	
+		T const left = -range * aspect;
-#else
+		T const right = range * aspect;
-#		pragma message("GLM: tweakedInfinitePerspective function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
+		T const bottom = -range;
-		T range = tan(radians(fovy / T(2))) * zNear;	
+		T const top = range;
-#endif
-		T left = -range * aspect;
-		T right = range * aspect;
-		T bottom = -range;
-		T top = range;
 
 		detail::tmat4x4<T, defaultp> Result(T(0));
 		Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
@@ -420,9 +389,9 @@ namespace glm
 		detail::tvec3<T, P> const & up
 	)
 	{
-		detail::tvec3<T, P> f(normalize(center - eye));
+		detail::tvec3<T, P> const f(normalize(center - eye));
-		detail::tvec3<T, P> s(normalize(cross(f, up)));
+		detail::tvec3<T, P> const s(normalize(cross(f, up)));
-		detail::tvec3<T, P> u(cross(s, f));
+		detail::tvec3<T, P> const u(cross(s, f));
 
 		detail::tmat4x4<T, P> Result(1);
 		Result[0][0] = s.x;

glm/gtc/quaternion.hpp

@@ -247,7 +247,7 @@ namespace detail
 	/// Rotates a quaternion from a vector of 3 components axis and an angle.
 	/// 
 	/// @param q Source orientation
-	/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param angle Angle expressed in radians.
 	/// @param axis Axis of the rotation
 	/// 
 	/// @see gtc_quaternion
@@ -265,19 +265,19 @@ namespace detail
 	GLM_FUNC_DECL detail::tvec3<T, P> eulerAngles(
 		detail::tquat<T, P> const & x);
 
-	/// Returns roll value of euler angles expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
+	/// Returns roll value of euler angles expressed in radians.
 	///
 	/// @see gtx_quaternion
 	template <typename T, precision P>
 	GLM_FUNC_DECL T roll(detail::tquat<T, P> const & x);
 
-	/// Returns pitch value of euler angles expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
+	/// Returns pitch value of euler angles expressed in radians.
 	///
 	/// @see gtx_quaternion
 	template <typename T, precision P>
 	GLM_FUNC_DECL T pitch(detail::tquat<T, P> const & x);
 
-	/// Returns yaw value of euler angles expressed in radians if GLM_FORCE_RADIANS is defined or degrees otherwise.
+	/// Returns yaw value of euler angles expressed in radians.
 	///
 	/// @see gtx_quaternion
 	template <typename T, precision P>
@@ -326,7 +326,7 @@ namespace detail
 
 	/// Build a quaternion from an angle and a normalized axis.
 	///
-	/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param angle Angle expressed in radians.
 	/// @param axis Axis of the quaternion, must be normalized.
 	///
 	/// @see gtc_quaternion

glm/gtc/quaternion.inl

@@ -615,12 +615,7 @@ namespace detail
 			Tmp.z *= oneOverLen;
 		}
 
-#ifdef GLM_FORCE_RADIANS
 		T const AngleRad(angle);
-#else
-#		pragma message("GLM: rotate function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		T const AngleRad = radians(angle);
-#endif
 		T const Sin = sin(AngleRad * T(0.5));
 
 		return q * detail::tquat<T, P>(cos(AngleRad * T(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);
@@ -642,12 +637,7 @@ namespace detail
 		detail::tquat<T, P> const & q
 	)
 	{
-#ifdef GLM_FORCE_RADIANS
 		return T(atan(T(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z));
-#else
-#		pragma message("GLM: roll function returning degrees is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		return glm::degrees(atan(T(2) * (q.x * q.y + q.w * q.z), q.w * q.w + q.x * q.x - q.y * q.y - q.z * q.z));
-#endif
 	}
 
 	template <typename T, precision P>
@@ -656,12 +646,7 @@ namespace detail
 		detail::tquat<T, P> const & q
 	)
 	{
-#ifdef GLM_FORCE_RADIANS
 		return T(atan(T(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z));
-#else
-#		pragma message("GLM: pitch function returning degrees is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		return glm::degrees(atan(T(2) * (q.y * q.z + q.w * q.x), q.w * q.w - q.x * q.x - q.y * q.y + q.z * q.z));
-#endif
 	}
 
 	template <typename T, precision P>
@@ -670,12 +655,7 @@ namespace detail
 		detail::tquat<T, P> const & q
 	)
 	{
-#ifdef GLM_FORCE_RADIANS
 		return asin(T(-2) * (q.x * q.z - q.w * q.y));
-#else
-#		pragma message("GLM: yaw function returning degrees is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		return glm::degrees(asin(T(-2) * (q.x * q.z - q.w * q.y)));
-#endif
 	}
 
 	template <typename T, precision P>
@@ -800,12 +780,7 @@ namespace detail
 		detail::tquat<T, P> const & x
 	)
 	{
-#ifdef GLM_FORCE_RADIANS
 		return acos(x.w) * T(2);
-#else
-#		pragma message("GLM: angle function returning degrees is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		return glm::degrees(acos(x.w) * T(2));
-#endif
 	}
 
 	template <typename T, precision P>
@@ -830,15 +805,10 @@ namespace detail
 	{
 		detail::tquat<T, P> result;
 
-#ifdef GLM_FORCE_RADIANS
 		T const a(angle);
-#else
+		T const s = glm::sin(a * static_cast<T>(0.5));
-#		pragma message("GLM: angleAxis function taking degrees as a parameter is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		T const a(glm::radians(angle));
-#endif
-		T s = glm::sin(a * T(0.5));
 
-		result.w = glm::cos(a * T(0.5));
+		result.w = glm::cos(a * static_cast<T>(0.5));
 		result.x = v.x * s;
 		result.y = v.y * s;
 		result.z = v.z * s;

glm/gtx/matrix_transform_2d.inl

@@ -47,13 +47,9 @@ namespace glm
 		detail::tmat3x3<T, P> const & m,
 		T const & angle)
 	{
-	#ifdef GLM_FORCE_RADIANS
+		T const a = angle;
-		T a = angle;
+		T const c = cos(a);
-	#else
+		T const s = sin(a);
-		T a = radians(angle);		
-	#endif
-		T c = cos(a);
-		T s = sin(a);
 
 		detail::tmat3x3<T, P> Result(detail::tmat3x3<T, P>::_null);
 		Result[0] = m[0] * c + m[1] * s;

glm/gtx/polar_coordinates.inl

@@ -19,18 +19,10 @@ namespace glm
 		detail::tvec3<T, P> const tmp(euclidean / Length);
 		T const xz_dist(sqrt(tmp.x * tmp.x + tmp.z * tmp.z));
 
-#ifdef GLM_FORCE_RADIANS
 		return detail::tvec3<T, P>(
 			atan(xz_dist, tmp.y),	// latitude
 			atan(tmp.x, tmp.z),		// longitude
 			xz_dist);				// xz distance
-#else
-#		pragma message("GLM: polar function returning degrees is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		return detail::tvec3<T, P>(
-			degrees(atan(xz_dist, tmp.y)),	// latitude
-			degrees(atan(tmp.x, tmp.z)),	// longitude
-			xz_dist);						// xz distance
-#endif
 	}
 
 	template <typename T, precision P>
@@ -39,14 +31,8 @@ namespace glm
 		detail::tvec2<T, P> const & polar
 	)
 	{
-#ifdef GLM_FORCE_RADIANS
 		T const latitude(polar.x);
 		T const longitude(polar.y);
-#else
-#		pragma message("GLM: euclidean function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		T const latitude(radians(polar.x));
-		T const longitude(radians(polar.y));
-#endif
 
 		return detail::tvec3<T, P>(
 			cos(latitude) * sin(longitude),

glm/gtx/rotate_normalized_axis.inl

@@ -36,18 +36,13 @@ namespace glm
 		detail::tvec3<T, P> const & v
 	)
 	{
-#ifdef GLM_FORCE_RADIANS
+		T const a = angle;
-		T a = angle;
+		T const c = cos(a);
-#else
+		T const s = sin(a);
-#		pragma message("GLM: rotateNormalizedAxis function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		T a = radians(angle);
-#endif
-		T c = cos(a);
-		T s = sin(a);
 
-		detail::tvec3<T, P> axis = v;
+		detail::tvec3<T, P> const axis(v);
 
-		detail::tvec3<T, P> temp = (T(1) - c) * axis;
+		detail::tvec3<T, P> const temp((static_cast<T>(1) - c) * axis);
 
 		detail::tmat4x4<T, P> Rotate(detail::tmat4x4<T, P>::_null);
 		Rotate[0][0] = c + temp[0] * axis[0];
@@ -78,14 +73,9 @@ namespace glm
 		detail::tvec3<T, P> const & v
 	)
 	{
-		detail::tvec3<T, P> Tmp = v;
+		detail::tvec3<T, P> const Tmp(v);
 
-#ifdef GLM_FORCE_RADIANS
 		T const AngleRad(angle);
-#else
-#		pragma message("GLM: rotateNormalizedAxis function taking degrees as parameters is deprecated. #define GLM_FORCE_RADIANS before including GLM headers to remove this message.")
-		T const AngleRad = radians(angle);
-#endif
 		T const Sin = sin(AngleRad * T(0.5));
 
 		return q * detail::tquat<T, P>(cos(AngleRad * static_cast<T>(0.5)), Tmp.x * Sin, Tmp.y * Sin, Tmp.z * Sin);

glm/gtx/simd_quat.hpp

@@ -296,7 +296,7 @@ namespace detail
 
 	/// Build a quaternion from an angle and a normalized axis.
 	///
-	/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param angle Angle expressed in radians.
 	/// @param axis Axis of the quaternion, must be normalized. 
 	///
 	/// @see gtc_quaternion
@@ -306,7 +306,7 @@ namespace detail
 
 	/// Build a quaternion from an angle and a normalized axis. 
 	///
-	/// @param angle Angle expressed in radians if GLM_FORCE_RADIANS is define or degrees otherwise.
+	/// @param angle Angle expressed in radians.
 	/// @param x x component of the x-axis, x, y, z must be a normalized axis
 	/// @param y y component of the y-axis, x, y, z must be a normalized axis
 	/// @param z z component of the z-axis, x, y, z must be a normalized axis

readme.txt

@@ -45,6 +45,7 @@ GLM 0.9.6.0: 2014-XX-XX
 - Added move contructors and assignment operators (#141)
 - Use pragma once
 - Fixed Visual Studio 14 compiler warnings
+- Added *vec1 support to *vec2 types
 
 ================================================================================
 GLM 0.9.5.5: 2014-XX-XX

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>

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>

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>
 

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>
 

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>

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;

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>

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>

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()

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()

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>

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()

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()

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()

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>

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>

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>

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>

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>

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>

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>

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>

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>

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()

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>

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>

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>

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()

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>

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>

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()

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()

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>
 

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>

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>

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>

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>

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()

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>

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()

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>

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>
 

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>
 

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>
 

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>
 

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>
 

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>
 

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>
 

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>

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>

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>
 

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>
 

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>
 

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>

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>
 

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()

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>
 

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>
 

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>

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>
 

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>

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>
 

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>
 

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()

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>
 

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>
 

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()

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()

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()

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>
 

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>
 

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>
 

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>
 

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>

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>

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>

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>

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>

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>

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>
 

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>
 

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>

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>

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>

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>

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>

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>

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>