Added GLM_FORCE_EXPLICIT_CTOR to require explicit type conversions #269

glm/detail/type_mat2x2.hpp

@@ -92,8 +92,14 @@ namespace glm
 
 		//////////////////////////////////////
 		// Matrix conversions
+
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
 			template <typename U, precision Q>
 			GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U, Q> const & m);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tmat2x2(tmat2x2<U, Q> const & m);
+#		endif
 
 		GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T, P> const & x);

glm/detail/type_mat2x3.hpp

@@ -75,6 +75,7 @@ namespace glm
 
 		//////////////////////////////////////
 		// Conversions
+
 		template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2>
 		GLM_FUNC_DECL tmat2x3(
 			X1 const & x1, Y1 const & y1, Z1 const & z1,
@@ -87,8 +88,14 @@ namespace glm
 
 		//////////////////////////////////////
 		// Matrix conversion
+
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
 			template <typename U, precision Q>
 			GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U, Q> const & m);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tmat2x3(tmat2x3<U, Q> const & m);
+#		endif
 
 		GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T, P> const & x);

glm/detail/type_mat2x4.hpp

@@ -89,8 +89,14 @@ namespace glm
 
 		//////////////////////////////////////
 		// Matrix conversions
+
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
 			template <typename U, precision Q>
 			GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U, Q> const & m);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tmat2x4(tmat2x4<U, Q> const & m);
+#		endif
 
 		GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T, P> const & x);

glm/detail/type_mat3x2.hpp

@@ -77,6 +77,7 @@ namespace glm
 
 		//////////////////////////////////////
 		// Conversions
+
 		template<
 			typename X1, typename Y1,
 			typename X2, typename Y2,
@@ -92,9 +93,16 @@ namespace glm
 			tvec2<V2, P> const & v2,
 			tvec2<V3, P> const & v3);
 
+		//////////////////////////////////////
 		// Matrix conversions
+
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
 			template <typename U, precision Q>
 			GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U, Q> const & m);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tmat3x2(tmat3x2<U, Q> const & m);
+#		endif
 
 		GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T, P> const & x);

glm/detail/type_mat3x3.hpp

@@ -81,6 +81,7 @@ namespace glm
 
 		//////////////////////////////////////
 		// Conversions
+
 		template<
 			typename X1, typename Y1, typename Z1,
 			typename X2, typename Y2, typename Z2,
@@ -96,9 +97,16 @@ namespace glm
 			tvec3<V2, P> const & v2,
 			tvec3<V3, P> const & v3);
 
+		//////////////////////////////////////
 		// Matrix conversions
+
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
 			template <typename U, precision Q>
 			GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U, Q> const & m);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tmat3x3(tmat3x3<U, Q> const & m);
+#		endif
 
 		GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T, P> const & x);

glm/detail/type_mat3x4.hpp

@@ -92,9 +92,16 @@ namespace glm
 			tvec4<V2, P> const & v2,
 			tvec4<V3, P> const & v3);
 
+		//////////////////////////////////////
 		// Matrix conversion
+
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
 			template <typename U, precision Q>
 			GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U, Q> const & m);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tmat3x4(tmat3x4<U, Q> const & m);
+#		endif
 
 		GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T, P> const & x);

glm/detail/type_mat4x2.hpp

@@ -98,9 +98,16 @@ namespace glm
 			tvec2<V3, P> const & v3,
 			tvec2<V4, P> const & v4);
 
+		//////////////////////////////////////
 		// Matrix conversions
+
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
 			template <typename U, precision Q>
 			GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U, Q> const & m);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tmat4x2(tmat4x2<U, Q> const & m);
+#		endif
 
 		GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T, P> const & x);

glm/detail/type_mat4x3.hpp

@@ -97,9 +97,16 @@ namespace glm
 			tvec3<V3, P> const & v3,
 			tvec3<V4, P> const & v4);
 
+		//////////////////////////////////////
 		// Matrix conversions
+
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
 			template <typename U, precision Q>
 			GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U, Q> const & m);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tmat4x3(tmat4x3<U, Q> const & m);
+#		endif
 
 		GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T, P> const & x);

glm/detail/type_mat4x4.hpp

@@ -103,9 +103,16 @@ namespace glm
 			tvec4<V3, P> const & v3,
 			tvec4<V4, P> const & v4);
 
+		//////////////////////////////////////
 		// Matrix conversions
+
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
 			template <typename U, precision Q>
 			GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U, Q> const & m);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tmat4x4(tmat4x4<U, Q> const & m);
+#		endif
 
 		GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T, P> const & x);

glm/gtc/quaternion.hpp

@@ -95,6 +95,14 @@ namespace glm
 		//////////////////////////////////////
 		// Convertions
 
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
+			template <typename U, precision Q>
+			GLM_FUNC_DECL explicit tquat(tquat<U, Q> const & q);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tquat(tquat<U, Q> const & q);
+#		endif
+
 		/// Create a quaternion from two normalized axis
 		/// 
 		/// @param u A first normalized axis
@@ -102,6 +110,7 @@ namespace glm
 		/// @see gtc_quaternion
 		/// @see http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
 		GLM_FUNC_DECL explicit tquat(tvec3<T, P> const & u,	tvec3<T, P> const & v);
+
 		/// Build a quaternion from euler angles (pitch, yaw, roll), in radians.
 		GLM_FUNC_DECL explicit tquat(tvec3<T, P> const & eulerAngles);
 		GLM_FUNC_DECL explicit tquat(tmat3x3<T, P> const & m);

glm/gtc/quaternion.inl

@@ -112,6 +112,15 @@ namespace detail
 	//////////////////////////////////////////////////////////////
 	// Conversions
 
+	template <typename T, precision P>
+	template <typename U, precision Q>
+	GLM_FUNC_QUALIFIER tquat<T, P>::tquat(tquat<U, Q> const & q)
+		: x(static_cast<T>(q.x))
+		, y(static_cast<T>(q.y))
+		, z(static_cast<T>(q.z))
+		, w(static_cast<T>(q.w))
+	{}
+
 	//template <typename valType> 
 	//GLM_FUNC_QUALIFIER tquat<valType>::tquat
 	//(

glm/gtx/dual_quaternion.hpp

@@ -89,6 +89,14 @@ namespace glm
 		//////////////////////////////////////////////////////////////
 		// tdualquat conversions
 
+#		ifdef GLM_FORCE_EXPLICIT_CTOR
+			template <typename U, precision Q>
+			GLM_FUNC_DECL explicit tdualquat(tdualquat<U, Q> const & q);
+#		else
+			template <typename U, precision Q>
+			GLM_FUNC_DECL tdualquat(tdualquat<U, Q> const & q);
+#		endif
+
 		GLM_FUNC_DECL explicit tdualquat(tmat2x4<T, P> const & holder_mat);
 		GLM_FUNC_DECL explicit tdualquat(tmat3x4<T, P> const & aug_mat);
 		

glm/gtx/dual_quaternion.inl

@@ -56,7 +56,8 @@ namespace glm
 	template <typename T, precision P>
 	template <precision Q>
 	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tdualquat<T, Q> const & d)
-		: real(d.real), dual(d.dual)
+		: real(d.real)
+		, dual(d.dual)
 	{}
 
 	//////////////////////////////////////
@@ -87,6 +88,14 @@ namespace glm
 
 	//////////////////////////////////////////////////////////////
 	// tdualquat conversions
+
+	template <typename T, precision P>
+	template <typename U, precision Q>
+	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tdualquat<U, Q> const & q)
+		: real(q.real)
+		, dual(q.dual)
+	{}
+
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tdualquat<T, P>::tdualquat(tmat2x4<T, P> const & m)
 	{

readme.txt

@@ -57,6 +57,7 @@ Features:
 - Added GTC_bitfield extension, promoted GTX_bit
 - Added GTC_integer extension, promoted GTX_bit
 - Added GTC_round extension, promoted GTX_bit
+- Added GLM_FORCE_EXPLICIT_CTOR to require explicit type conversions #269
 
 Improvements:
 - Rely on C++11 to implement isinf and isnan

test/core/core_func_common.cpp

@@ -7,6 +7,8 @@
 // File    : test/core/func_common.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+#define GLM_FORCE_EXPLICIT_CTOR
+#include <glm/common.hpp>
 #include <glm/gtc/constants.hpp>
 #include <glm/gtc/epsilon.hpp>
 #include <glm/gtc/vec1.hpp>
@@ -16,8 +18,10 @@
 #include <cmath>
 #include <ctime>
 
-int test_floor()
+namespace floor_
 {
+	int test()
+	{
 		int Error(0);
 
 		{
@@ -87,10 +91,13 @@ int test_floor()
 		}
 
 		return Error;
-}
+	}
+}//namespace floor
 
-int test_modf()
+namespace modf_
 {
+	int test()
+	{
 		int Error(0);
 
 		{
@@ -130,10 +137,13 @@ int test_modf()
 		}
 
 		return Error;
-}
+	}
+}//namespace modf
 
-int test_floatBitsToInt()
+namespace floatBitsToInt
 {
+	int test()
+	{
 		int Error = 0;
 	
 		{
@@ -176,10 +186,13 @@ int test_floatBitsToInt()
 		}
 	
 		return Error;
-}
+	}
+}//namespace floatBitsToInt
 
-int test_floatBitsToUint()
+namespace floatBitsToUint
 {
+	int test()
+	{
 		int Error = 0;
 	
 		{
@@ -221,10 +234,13 @@ int test_floatBitsToUint()
 		}
 	
 		return Error;
-}
+	}
+}//namespace floatBitsToUint
 
-int test_min()
+namespace min_
 {
+	int test()
+	{
 		int Error = 0;
 
 		glm::vec1 A0 = glm::min(glm::vec1(1), glm::vec1(1));
@@ -245,10 +261,13 @@ int test_min()
 		Error += D2 ? 0 : 1;
 
 		return Error;
-}
+	}
+}//namespace min_
 
-int test_max()
+namespace max_
 {
+	int test()
+	{
 		int Error = 0;
 
 		glm::vec1 A0 = glm::max(glm::vec1(1), glm::vec1(1));
@@ -269,19 +288,23 @@ int test_max()
 		Error += D2 ? 0 : 1;
 
 		return Error;
-}
+	}
+}//namespace max_
 
-int test_clamp()
+namespace clamp_
 {
+	int test()
+	{
 		int Error = 0;
 
 		return Error;
-}
+	}
+}//namespace clamp_
 
-namespace test_mix
+namespace mix_
 {
 	template <typename T, typename B>
-	struct test
+	struct entry
 	{
 		T x;
 		T y;
@@ -289,7 +312,7 @@ namespace test_mix
 		T Result;
 	};
 
-	test<float, bool> TestBool[] = 
+	entry<float, bool> TestBool[] =
 	{
 		{0.0f, 1.0f, false, 0.0f},
 		{0.0f, 1.0f, true, 1.0f},
@@ -297,7 +320,7 @@ namespace test_mix
 		{-1.0f, 1.0f, true, 1.0f}
 	};
 
-	test<float, float> TestFloat[] = 
+	entry<float, float> TestFloat[] =
 	{
 		{0.0f, 1.0f, 0.0f, 0.0f},
 		{0.0f, 1.0f, 1.0f, 1.0f},
@@ -305,7 +328,7 @@ namespace test_mix
 		{-1.0f, 1.0f, 1.0f, 1.0f}
 	};
 
-	test<glm::vec2, bool> TestVec2Bool[] = 
+	entry<glm::vec2, bool> TestVec2Bool[] =
 	{
 		{glm::vec2(0.0f), glm::vec2(1.0f), false, glm::vec2(0.0f)},
 		{glm::vec2(0.0f), glm::vec2(1.0f), true, glm::vec2(1.0f)},
@@ -313,7 +336,7 @@ namespace test_mix
 		{glm::vec2(-1.0f), glm::vec2(1.0f), true, glm::vec2(1.0f)}
 	};
 
-	test<glm::vec2, glm::bvec2> TestBVec2[] = 
+	entry<glm::vec2, glm::bvec2> TestBVec2[] =
 	{
 		{glm::vec2(0.0f), glm::vec2(1.0f), glm::bvec2(false), glm::vec2(0.0f)},
 		{glm::vec2(0.0f), glm::vec2(1.0f), glm::bvec2(true), glm::vec2(1.0f)},
@@ -322,7 +345,7 @@ namespace test_mix
 		{glm::vec2(-1.0f), glm::vec2(1.0f), glm::bvec2(true, false), glm::vec2(1.0f, -1.0f)}
 	};
 
-	test<glm::vec3, bool> TestVec3Bool[] = 
+	entry<glm::vec3, bool> TestVec3Bool[] =
 	{
 		{glm::vec3(0.0f), glm::vec3(1.0f), false, glm::vec3(0.0f)},
 		{glm::vec3(0.0f), glm::vec3(1.0f), true, glm::vec3(1.0f)},
@@ -330,7 +353,7 @@ namespace test_mix
 		{glm::vec3(-1.0f), glm::vec3(1.0f), true, glm::vec3(1.0f)}
 	};
 
-	test<glm::vec3, glm::bvec3> TestBVec3[] = 
+	entry<glm::vec3, glm::bvec3> TestBVec3[] =
 	{
 		{glm::vec3(0.0f), glm::vec3(1.0f), glm::bvec3(false), glm::vec3(0.0f)},
 		{glm::vec3(0.0f), glm::vec3(1.0f), glm::bvec3(true), glm::vec3(1.0f)},
@@ -339,7 +362,7 @@ namespace test_mix
 		{glm::vec3(1.0f, 2.0f, 3.0f), glm::vec3(4.0f, 5.0f, 6.0f), glm::bvec3(true, false, true), glm::vec3(4.0f, 2.0f, 6.0f)}
 	};
 
-	test<glm::vec4, bool> TestVec4Bool[] = 
+	entry<glm::vec4, bool> TestVec4Bool[] = 
 	{
 		{glm::vec4(0.0f), glm::vec4(1.0f), false, glm::vec4(0.0f)},
 		{glm::vec4(0.0f), glm::vec4(1.0f), true, glm::vec4(1.0f)},
@@ -347,7 +370,7 @@ namespace test_mix
 		{glm::vec4(-1.0f), glm::vec4(1.0f), true, glm::vec4(1.0f)}
 	};
 
-	test<glm::vec4, glm::bvec4> TestBVec4[] = 
+	entry<glm::vec4, glm::bvec4> TestBVec4[] = 
 	{
 		{glm::vec4(0.0f), glm::vec4(1.0f), glm::bvec4(false), glm::vec4(0.0f)},
 		{glm::vec4(0.0f), glm::vec4(1.0f), glm::bvec4(true), glm::vec4(1.0f)},
@@ -356,13 +379,13 @@ namespace test_mix
 		{glm::vec4(1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(5.0f, 6.0f, 7.0f, 8.0f), glm::bvec4(true, false, true, false), glm::vec4(5.0f, 2.0f, 7.0f, 4.0f)}
 	};
 
-	int run()
+	int test()
 	{
 		int Error = 0;
 
 		// Float with bool
 		{
-			for(std::size_t i = 0; i < sizeof(TestBool) / sizeof(test<float, bool>); ++i)
+			for(std::size_t i = 0; i < sizeof(TestBool) / sizeof(entry<float, bool>); ++i)
 			{
 				float Result = glm::mix(TestBool[i].x, TestBool[i].y, TestBool[i].a);
 				Error += glm::epsilonEqual(Result, TestBool[i].Result, glm::epsilon<float>()) ? 0 : 1;
@@ -371,7 +394,7 @@ namespace test_mix
 
 		// Float with float
 		{
-			for(std::size_t i = 0; i < sizeof(TestFloat) / sizeof(test<float, float>); ++i)
+			for(std::size_t i = 0; i < sizeof(TestFloat) / sizeof(entry<float, float>); ++i)
 			{
 				float Result = glm::mix(TestFloat[i].x, TestFloat[i].y, TestFloat[i].a);
 				Error += glm::epsilonEqual(Result, TestFloat[i].Result, glm::epsilon<float>()) ? 0 : 1;
@@ -380,7 +403,7 @@ namespace test_mix
 
 		// vec2 with bool
 		{
-			for(std::size_t i = 0; i < sizeof(TestVec2Bool) / sizeof(test<glm::vec2, bool>); ++i)
+			for(std::size_t i = 0; i < sizeof(TestVec2Bool) / sizeof(entry<glm::vec2, bool>); ++i)
 			{
 				glm::vec2 Result = glm::mix(TestVec2Bool[i].x, TestVec2Bool[i].y, TestVec2Bool[i].a);
 				Error += glm::epsilonEqual(Result.x, TestVec2Bool[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
@@ -390,7 +413,7 @@ namespace test_mix
 
 		// vec2 with bvec2
 		{
-			for(std::size_t i = 0; i < sizeof(TestBVec2) / sizeof(test<glm::vec2, glm::bvec2>); ++i)
+			for(std::size_t i = 0; i < sizeof(TestBVec2) / sizeof(entry<glm::vec2, glm::bvec2>); ++i)
 			{
 				glm::vec2 Result = glm::mix(TestBVec2[i].x, TestBVec2[i].y, TestBVec2[i].a);
 				Error += glm::epsilonEqual(Result.x, TestBVec2[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
@@ -400,7 +423,7 @@ namespace test_mix
 
 		// vec3 with bool
 		{
-			for(std::size_t i = 0; i < sizeof(TestVec3Bool) / sizeof(test<glm::vec3, bool>); ++i)
+			for(std::size_t i = 0; i < sizeof(TestVec3Bool) / sizeof(entry<glm::vec3, bool>); ++i)
 			{
 				glm::vec3 Result = glm::mix(TestVec3Bool[i].x, TestVec3Bool[i].y, TestVec3Bool[i].a);
 				Error += glm::epsilonEqual(Result.x, TestVec3Bool[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
@@ -411,7 +434,7 @@ namespace test_mix
 
 		// vec3 with bvec3
 		{
-			for(std::size_t i = 0; i < sizeof(TestBVec3) / sizeof(test<glm::vec3, glm::bvec3>); ++i)
+			for(std::size_t i = 0; i < sizeof(TestBVec3) / sizeof(entry<glm::vec3, glm::bvec3>); ++i)
 			{
 				glm::vec3 Result = glm::mix(TestBVec3[i].x, TestBVec3[i].y, TestBVec3[i].a);
 				Error += glm::epsilonEqual(Result.x, TestBVec3[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
@@ -422,7 +445,7 @@ namespace test_mix
 
 		// vec4 with bool
 		{
-			for(std::size_t i = 0; i < sizeof(TestVec4Bool) / sizeof(test<glm::vec4, bool>); ++i)
+			for(std::size_t i = 0; i < sizeof(TestVec4Bool) / sizeof(entry<glm::vec4, bool>); ++i)
 			{
 				glm::vec4 Result = glm::mix(TestVec4Bool[i].x, TestVec4Bool[i].y, TestVec4Bool[i].a);
 				Error += glm::epsilonEqual(Result.x, TestVec4Bool[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
@@ -434,7 +457,7 @@ namespace test_mix
 
 		// vec4 with bvec4
 		{
-			for(std::size_t i = 0; i < sizeof(TestBVec4) / sizeof(test<glm::vec4, glm::bvec4>); ++i)
+			for(std::size_t i = 0; i < sizeof(TestBVec4) / sizeof(entry<glm::vec4, glm::bvec4>); ++i)
 			{
 				glm::vec4 Result = glm::mix(TestBVec4[i].x, TestBVec4[i].y, TestBVec4[i].a);
 				Error += glm::epsilonEqual(Result.x, TestBVec4[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
@@ -446,26 +469,26 @@ namespace test_mix
 
 		return Error;
 	}
-}//namespace test_mix
+}//namespace mix_
 
-namespace test_step
+namespace step_
 {
 	template <typename EDGE, typename VEC>
-	struct test
+	struct entry
 	{
 		EDGE edge;
 		VEC x;
 		VEC result;
 	};
 
-	test<float, glm::vec4> TestVec4Scalar [] =
+	entry<float, glm::vec4> TestVec4Scalar [] =
 	{
 		{ 0.0f, glm::vec4(1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(1.0f) },
 		{ 1.0f, glm::vec4(1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(1.0f) },
 		{ 0.0f, glm::vec4(-1.0f, -2.0f, -3.0f, -4.0f), glm::vec4(0.0f) }
 	};
 
-	test<glm::vec4, glm::vec4> TestVec4Vector [] =
+	entry<glm::vec4, glm::vec4> TestVec4Vector [] =
 	{
 		{ glm::vec4(-1.0f, -2.0f, -3.0f, -4.0f), glm::vec4(-2.0f, -3.0f, -4.0f, -5.0f), glm::vec4(0.0f) },
 		{ glm::vec4( 0.0f, 1.0f, 2.0f, 3.0f), glm::vec4( 1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(1.0f) },
@@ -473,13 +496,13 @@ namespace test_step
 		{ glm::vec4( 0.0f, 1.0f, 2.0f, 3.0f), glm::vec4(-1.0f,-2.0f,-3.0f,-4.0f), glm::vec4(0.0f) }
 	};
 
-	int run()
+	int test()
 	{
 		int Error = 0;
 
 		// vec4 and float
 		{
-			for (std::size_t i = 0; i < sizeof(TestVec4Scalar) / sizeof(test<float, glm::vec4>); ++i)
+			for (std::size_t i = 0; i < sizeof(TestVec4Scalar) / sizeof(entry<float, glm::vec4>); ++i)
 			{
 				glm::vec4 Result = glm::step(TestVec4Scalar[i].edge, TestVec4Scalar[i].x);
 				Error += glm::all(glm::epsilonEqual(Result, TestVec4Scalar[i].result, glm::epsilon<float>())) ? 0 : 1;
@@ -488,7 +511,7 @@ namespace test_step
 
 		// vec4 and vec4
 		{
-			for (std::size_t i = 0; i < sizeof(TestVec4Vector) / sizeof(test<glm::vec4, glm::vec4>); ++i)
+			for (std::size_t i = 0; i < sizeof(TestVec4Vector) / sizeof(entry<glm::vec4, glm::vec4>); ++i)
 			{
 				glm::vec4 Result = glm::step(TestVec4Vector[i].edge, TestVec4Vector[i].x);
 				Error += glm::all(glm::epsilonEqual(Result, TestVec4Vector[i].result, glm::epsilon<float>())) ? 0 : 1;
@@ -497,10 +520,12 @@ namespace test_step
 
 		return Error;
 	}
-}//namespace test_step
+}//namespace step_
 
-int test_round()
+namespace round_
 {
+	int test()
+	{
 		int Error = 0;
 	
 		{
@@ -538,10 +563,13 @@ int test_round()
 		}
 	
 		return Error;
-}
+	}
+}//namespace round_
 
-int test_roundEven()
+namespace roundEven
 {
+	int test()
+	{
 		int Error = 0;
 
 		{
@@ -681,10 +709,13 @@ int test_roundEven()
 		}
 
 		return Error;
-}
+	}
+}//namespace roundEven
 
-int test_isnan()
+namespace isnan_
 {
+	int test()
+	{
 		int Error = 0;
 
 		float Zero_f = 0.0;
@@ -705,10 +736,13 @@ int test_isnan()
 		}
 
 		return Error;
-}
+	}
+}//namespace isnan_
 
-int test_isinf()
+namespace isinf_
 {
+	int test()
+	{
 		int Error = 0;
 
 		float Zero_f = 0.0;
@@ -737,7 +771,8 @@ int test_isinf()
 		}
 
 		return Error;
-}
+	}
+}//namespace isinf_
 
 namespace sign
 {
@@ -1018,18 +1053,18 @@ int main()
 	int Error(0);
 
 	Error += sign::test();
-	Error += test_floor();
-	Error += test_modf();
-	Error += test_floatBitsToInt();
-	Error += test_floatBitsToUint();
-	Error += test_step::run();
-	Error += test_max();
-	Error += test_min();
-	Error += test_mix::run();
-	Error += test_round();
-	Error += test_roundEven();
-	Error += test_isnan();
-	Error += test_isinf();
+	Error += floor_::test();
+	Error += modf_::test();
+	Error += floatBitsToInt::test();
+	Error += floatBitsToUint::test();
+	Error += step_::test();
+	Error += max_::test();
+	Error += min_::test();
+	Error += mix_::test();
+	Error += round_::test();
+	Error += roundEven::test();
+	Error += isnan_::test();
+	Error += isinf_::test();
 
 #	ifdef GLM_TEST_ENABLE_PERF
 		Error += sign::perf();

test/core/core_type_mat4x4.cpp

@@ -13,16 +13,9 @@
 #include <cstdio>
 #include <vector>
 
-void print(glm::dmat4 const & Mat0)
-{
-	printf("mat4(\n");
-	printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[0][0], Mat0[0][1], Mat0[0][2], Mat0[0][3]);
-	printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[1][0], Mat0[1][1], Mat0[1][2], Mat0[1][3]);
-	printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[2][0], Mat0[2][1], Mat0[2][2], Mat0[2][3]);
-	printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f))\n\n", Mat0[3][0], Mat0[3][1], Mat0[3][2], Mat0[3][3]);
-}
 
-void print(glm::mat4 const & Mat0)
+template <typename genType>
+void print(genType const & Mat0)
 {
 	printf("mat4(\n");
 	printf("\tvec4(%2.9f, %2.9f, %2.9f, %2.9f)\n", Mat0[0][0], Mat0[0][1], Mat0[0][2], Mat0[0][3]);