Merge 0.9.8

glm/detail/setup.hpp

@@ -3,6 +3,28 @@
 
 #pragma once
 
+#if (defined(GLM_FORCE_SWIZZLE) || defined(GLM_SWIZZLE)) && defined(GLM_FORCE_UNRESTRICTED_GENTYPE)
+#	error "Both GLM_FORCE_SWIZZLE and GLM_FORCE_UNRESTRICTED_GENTYPE can't be defined at the same time"
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////
+// Messages
+
+#ifdef GLM_MESSAGES
+#	pragma message("GLM: GLM_MESSAGES is deprecated, use GLM_FORCE_MESSAGES instead")
+#endif
+
+#define GLM_MESSAGES_ENABLED 1
+#define GLM_MESSAGES_DISABLE 0
+
+#if defined(GLM_FORCE_MESSAGES) || defined(GLM_MESSAGES)
+#	undef GLM_MESSAGES
+#	define GLM_MESSAGES GLM_MESSAGES_ENABLED
+#else
+#	undef GLM_MESSAGES
+#	define GLM_MESSAGES GLM_MESSAGES_DISABLE
+#endif
+
 #include <cassert>
 #include <cstddef>
 #include "../simd/platform.h"
@@ -16,13 +38,13 @@
 #define GLM_VERSION_PATCH			9
 #define GLM_VERSION_REVISION		0
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_VERSION_DISPLAYED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_VERSION_DISPLAYED)
 #	define GLM_MESSAGE_VERSION_DISPLAYED
 #	pragma message ("GLM: version 0.9.9.0")
 #endif//GLM_MESSAGES
 
 // Report compiler detection
-#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPILER_DISPLAYED)
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_COMPILER_DISPLAYED)
 #	define GLM_MESSAGE_COMPILER_DISPLAYED
 #	if GLM_COMPILER & GLM_COMPILER_CUDA
 #		pragma message("GLM: CUDA compiler detected")
@@ -54,7 +76,7 @@
 #	error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message."
 #endif//GLM_MODEL
 
-#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_MODEL_DISPLAYED)
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_MODEL_DISPLAYED)
 #	define GLM_MESSAGE_MODEL_DISPLAYED
 #	if(GLM_MODEL == GLM_MODEL_64)
 #		pragma message("GLM: 64 bits model")
@@ -63,7 +85,7 @@
 #	endif//GLM_MODEL
 #endif//GLM_MESSAGES
 
-#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_ARCH_DISPLAYED)
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_ARCH_DISPLAYED)
 #	define GLM_MESSAGE_ARCH_DISPLAYED
 #	if(GLM_ARCH == GLM_ARCH_PURE)
 #		pragma message("GLM: Platform independent code")
@@ -230,7 +252,7 @@
 #	endif
 #endif
 
-#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_LANG_DISPLAYED)
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_LANG_DISPLAYED)
 #	define GLM_MESSAGE_LANG_DISPLAYED
 
 #	if GLM_LANG & GLM_LANG_CXX1Z_FLAG
@@ -524,17 +546,44 @@
 ///////////////////////////////////////////////////////////////////////////////////
 // Swizzle operators
 
-// User defines: GLM_SWIZZLE
+// User defines: GLM_FORCE_SWIZZLE
 
-#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED)
+#ifdef GLM_SWIZZLE
+#	pragma message("GLM: GLM_SWIZZLE is deprecated, use GLM_FORCE_SWIZZLE instead")
+#endif
+
+#define GLM_SWIZZLE_ENABLED 1
+#define GLM_SWIZZLE_DISABLE 0
+
+#if defined(GLM_FORCE_SWIZZLE) || defined(GLM_SWIZZLE)
+#	undef GLM_SWIZZLE
+#	define GLM_SWIZZLE GLM_SWIZZLE_ENABLED
+#else
+#	undef GLM_SWIZZLE
+#	define GLM_SWIZZLE GLM_SWIZZLE_DISABLE
+#endif
+
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED)
 #	define GLM_MESSAGE_SWIZZLE_DISPLAYED
-#	if defined(GLM_SWIZZLE)
+#	if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 #		pragma message("GLM: Swizzling operators enabled")
 #	else
 #		pragma message("GLM: Swizzling operators disabled, #define GLM_SWIZZLE to enable swizzle operators")
 #	endif
 #endif//GLM_MESSAGES
 
+///////////////////////////////////////////////////////////////////////////////////
+// Allows using not basic types as genType
+
+// #define GLM_FORCE_UNRESTRICTED_GENTYPE
+
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_UNRESTRICTED_GENTYPE_DISPLAYED)
+#	define GLM_MESSAGE_UNRESTRICTED_GENTYPE_DISPLAYED
+#	ifdef GLM_FORCE_UNRESTRICTED_GENTYPE
+#		pragma message("GLM: Use unrestricted genType")
+#	endif
+#endif//GLM_MESSAGES
+
 ///////////////////////////////////////////////////////////////////////////////////
 // Clip control
 
@@ -551,6 +600,15 @@
 #	define GLM_DEPTH_CLIP_SPACE GLM_DEPTH_NEGATIVE_ONE_TO_ONE
 #endif
 
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_DEPTH_DISPLAYED)
+#	define GLM_MESSAGE_DEPTH_DISPLAYED
+#	if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
+#		pragma message("GLM: Depth clip space: Zero to one")
+#	else
+#		pragma message("GLM: Depth clip space: negative one to one")
+#	endif
+#endif//GLM_MESSAGES
+
 ///////////////////////////////////////////////////////////////////////////////////
 // Coordinate system, define GLM_FORCE_LEFT_HANDED before including GLM
 // to use left handed coordinate system by default.
@@ -568,6 +626,15 @@
 #	define GLM_COORDINATE_SYSTEM GLM_RIGHT_HANDED
 #endif
 
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_HANDED_DISPLAYED)
+#	define GLM_MESSAGE_HANDED_DISPLAYED
+#	if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
+#		pragma message("GLM: Coordinate system: left handed")
+#	else
+#		pragma message("GLM: Coordinate system: right handed")
+#	endif
+#endif//GLM_MESSAGES
+
 ///////////////////////////////////////////////////////////////////////////////////
 // Qualifiers
 
@@ -617,7 +684,7 @@
 #	define GLM_VECTOR_CALL
 #endif//GLM_COMPILER
 
-#if GLM_HAS_DEFAULTED_FUNCTIONS
+#if GLM_HAS_DEFAULTED_FUNCTIONS && !defined(GLM_FORCE_UNRESTRICTED_GENTYPE)
 #	define GLM_DEFAULT = default
 #	ifdef GLM_FORCE_NO_CTOR_INIT
 #		define GLM_DEFAULT_CTOR = default
@@ -674,7 +741,7 @@ namespace glm
 #	endif
 }//namespace glm
 
-#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_FORCE_SIZE_T_LENGTH)
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_FORCE_SIZE_T_LENGTH)
 #	define GLM_MESSAGE_FORCE_SIZE_T_LENGTH
 #	if defined GLM_FORCE_SIZE_T_LENGTH
 #		pragma message("GLM: .length() returns glm::length_t, a typedef of std::size_t")

glm/detail/type_vec1.hpp

@@ -5,7 +5,7 @@
 
 #include "../fwd.hpp"
 #include "type_vec.hpp"
-#ifdef GLM_SWIZZLE
+#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 #	if GLM_HAS_UNRESTRICTED_UNIONS
 #		include "_swizzle.hpp"
 #	else
@@ -44,7 +44,7 @@ namespace glm
 				T r;
 				T s;
 /*
-#				ifdef GLM_SWIZZLE
+#				if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 					_GLM_SWIZZLE1_2_MEMBERS(T, P, tvec2, x)
 					_GLM_SWIZZLE1_2_MEMBERS(T, P, tvec2, r)
 					_GLM_SWIZZLE1_2_MEMBERS(T, P, tvec2, s)
@@ -66,7 +66,7 @@ namespace glm
 #		else
 			union {T x, r, s;};
 /*
-#			ifdef GLM_SWIZZLE
+#			if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 				GLM_SWIZZLE_GEN_VEC_FROM_VEC1(T, P, tvec2, tvec2, tvec3, tvec4)
 #			endif//GLM_SWIZZLE*/
 #		endif
@@ -110,13 +110,13 @@ namespace glm
 
 		// -- Swizzle constructors --
 /*
-#		if(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE))
+#		if(GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED))
 			template <int E0>
 			GLM_FUNC_DECL tvec1(detail::_swizzle<1, T, P, tvec1, E0, -1,-2,-3> const & that)
 			{
 				*this = that();
 			}
-#		endif//(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE))
+#		endif//(GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED))
 */
 		// -- Unary arithmetic operators --
 

glm/detail/type_vec2.hpp

@@ -4,7 +4,7 @@
 #pragma once
 
 #include "type_vec.hpp"
-#ifdef GLM_SWIZZLE
+#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 #	if GLM_HAS_UNRESTRICTED_UNIONS
 #		include "_swizzle.hpp"
 #	else
@@ -43,7 +43,7 @@ namespace glm
 				struct{ T r, g; };
 				struct{ T s, t; };
 
-#				ifdef GLM_SWIZZLE
+#				if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 					_GLM_SWIZZLE2_2_MEMBERS(T, P, glm::tvec2, x, y)
 					_GLM_SWIZZLE2_2_MEMBERS(T, P, glm::tvec2, r, g)
 					_GLM_SWIZZLE2_2_MEMBERS(T, P, glm::tvec2, s, t)
@@ -67,7 +67,7 @@ namespace glm
 			union {T x, r, s;};
 			union {T y, g, t;};
 
-#			ifdef GLM_SWIZZLE
+#			if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 				GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P, tvec2, tvec2, tvec3, tvec4)
 #			endif//GLM_SWIZZLE
 #		endif
@@ -116,13 +116,13 @@ namespace glm
 		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec2(tvec2<U, Q> const & v);
 
 		// -- Swizzle constructors --
-#		if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)
+#		if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
 			template <int E0, int E1>
 			GLM_FUNC_DECL tvec2(detail::_swizzle<2, T, P, glm::tvec2, E0, E1,-1,-2> const& that)
 			{
 				*this = that();
 			}
-#		endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)
+#		endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
 
 		// -- Unary arithmetic operators --
 

glm/detail/type_vec3.hpp

@@ -4,13 +4,13 @@
 #pragma once
 
 #include "type_vec.hpp"
-#ifdef GLM_SWIZZLE
+#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 #	if GLM_HAS_UNRESTRICTED_UNIONS
 #		include "_swizzle.hpp"
 #	else
 #		include "_swizzle_func.hpp"
 #	endif
-#endif //GLM_SWIZZLE
+#endif //GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 #include <cstddef>
 
 namespace glm
@@ -43,7 +43,7 @@ namespace glm
 				struct{ T r, g, b; };
 				struct{ T s, t, p; };
 
-#				ifdef GLM_SWIZZLE
+#				if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 					_GLM_SWIZZLE3_2_MEMBERS(T, P, glm::tvec2, x, y, z)
 					_GLM_SWIZZLE3_2_MEMBERS(T, P, glm::tvec2, r, g, b)
 					_GLM_SWIZZLE3_2_MEMBERS(T, P, glm::tvec2, s, t, p)
@@ -67,7 +67,7 @@ namespace glm
 			union { T y, g, t; };
 			union { T z, b, p; };
 
-#			ifdef GLM_SWIZZLE
+#			if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 				GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P, tvec3, tvec2, tvec3, tvec4)
 #			endif//GLM_SWIZZLE
 #		endif//GLM_LANG
@@ -125,7 +125,7 @@ namespace glm
 		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec3(tvec3<U, Q> const & v);
 
 		// -- Swizzle constructors --
-#		if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)
+#		if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
 			template <int E0, int E1, int E2>
 			GLM_FUNC_DECL tvec3(detail::_swizzle<3, T, P, glm::tvec3, E0, E1, E2, -1> const & that)
 			{
@@ -143,7 +143,7 @@ namespace glm
 			{
 				*this = tvec3<T, P>(scalar, v());
 			}
-#		endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)
+#		endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
 
 		// -- Unary arithmetic operators --
 

glm/detail/type_vec4.hpp

@@ -4,7 +4,7 @@
 #pragma once
 
 #include "type_vec.hpp"
-#ifdef GLM_SWIZZLE
+#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 #	if GLM_HAS_UNRESTRICTED_UNIONS
 #		include "_swizzle.hpp"
 #	else
@@ -45,7 +45,7 @@ namespace glm
 
 				typename detail::storage<T, sizeof(T) * 4, detail::is_aligned<P>::value>::type data;
 
-#				ifdef GLM_SWIZZLE
+#				if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 					_GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, x, y, z, w)
 					_GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, r, g, b, a)
 					_GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, s, t, p, q)
@@ -70,7 +70,7 @@ namespace glm
 			union { T z, b, p; };
 			union { T w, a, q; };
 
-#			ifdef GLM_SWIZZLE
+#			if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 				GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, tvec4, tvec2, tvec3, tvec4)
 #			endif//GLM_SWIZZLE
 #		endif
@@ -146,7 +146,7 @@ namespace glm
 		GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec4(tvec4<U, Q> const& v);
 
 		// -- Swizzle constructors --
-#		if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)
+#		if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
 			template <int E0, int E1, int E2, int E3>
 			GLM_FUNC_DECL tvec4(detail::_swizzle<4, T, P, glm::tvec4, E0, E1, E2, E3> const & that)
 			{
@@ -188,7 +188,7 @@ namespace glm
 			{
 				*this = tvec4<T, P>(x, v());
 			}
-#		endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)
+#		endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
 
 		// -- Unary arithmetic operators --
 

glm/detail/type_vec4_simd.inl

@@ -6,7 +6,7 @@
 namespace glm{
 namespace detail
 {
-#	ifdef GLM_SWIZZLE
+#	if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 	template <precision P, int E0, int E1, int E2, int E3>
 	struct _swizzle_base1<4, float, P, glm::tvec4, E0,E1,E2,E3, true> : public _swizzle_base0<float, 4>
 	{ 
@@ -49,7 +49,7 @@ namespace detail
 			return Result;
 		}
 	};
-#	endif//GLM_SWIZZLE
+#	endif// GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
 
 	template <precision P>
 	struct compute_vec4_add<float, P, true>

glm/ext.hpp

@@ -27,7 +27,9 @@
 
 #pragma once
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_EXT_INCLUDED_DISPLAYED))
+#include "glm.hpp"
+
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_EXT_INCLUDED_DISPLAYED)
 #	define GLM_MESSAGE_EXT_INCLUDED_DISPLAYED
 #	pragma message("GLM: All extensions included (not recommanded)")
 #endif//GLM_MESSAGES

glm/glm.hpp

@@ -60,7 +60,7 @@
 #include <cassert>
 #include "fwd.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_CORE_INCLUDED_DISPLAYED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_CORE_INCLUDED_DISPLAYED)
 #	define GLM_MESSAGE_CORE_INCLUDED_DISPLAYED
 #	pragma message("GLM: Core library included")
 #endif//GLM_MESSAGES

glm/gtc/bitfield.hpp

@@ -20,7 +20,7 @@
 #include "../detail/_vectorize.hpp"
 #include <limits>
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_bitfield extension included")
 #endif
 

glm/gtc/color_space.hpp

@@ -21,7 +21,7 @@
 #include "../vec4.hpp"
 #include <limits>
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_color_space extension included")
 #endif
 

glm/gtc/constants.hpp

@@ -16,7 +16,7 @@
 // Dependencies
 #include "../detail/setup.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_constants extension included")
 #endif
 

glm/gtc/epsilon.hpp

@@ -18,7 +18,7 @@
 #include "../detail/setup.hpp"
 #include "../detail/precision.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_epsilon extension included")
 #endif
 

glm/gtc/functions.hpp

@@ -19,7 +19,7 @@
 #include "../detail/precision.hpp"
 #include "../detail/type_vec2.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_functions extension included")
 #endif
 

glm/gtc/integer.hpp

@@ -21,7 +21,7 @@
 #include "../detail/func_exponential.hpp"
 #include <limits>
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_integer extension included")
 #endif
 

glm/gtc/matrix_access.hpp

@@ -14,7 +14,7 @@
 // Dependency:
 #include "../detail/setup.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_matrix_access extension included")
 #endif
 

glm/gtc/matrix_integer.hpp

@@ -22,7 +22,7 @@
 #include "../mat4x3.hpp"
 #include "../mat4x4.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_matrix_integer extension included")
 #endif
 

glm/gtc/matrix_inverse.hpp

@@ -18,7 +18,7 @@
 #include "../mat3x3.hpp"
 #include "../mat4x4.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_matrix_inverse extension included")
 #endif
 

glm/gtc/matrix_transform.hpp

@@ -27,7 +27,7 @@
 #include "../vec4.hpp"
 #include "../gtc/constants.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_matrix_transform extension included")
 #endif
 

glm/gtc/matrix_transform.inl

@@ -8,11 +8,7 @@
 namespace glm
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> translate
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> translate(tmat4x4<T, P> const & m, tvec3<T, P> const & v)
-	(
-		tmat4x4<T, P> const & m,
-		tvec3<T, P> const & v
-	)
 	{
 		tmat4x4<T, P> Result(m);
 		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
@@ -20,12 +16,7 @@ namespace glm
 	}
 	
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate(tmat4x4<T, P> const & m, T angle, tvec3<T, P> const & v)
-	(
-		tmat4x4<T, P> const & m,
-		T angle,
-		tvec3<T, P> const & v
-	)
 	{
 		T const a = angle;
 		T const c = cos(a);
@@ -36,15 +27,15 @@ namespace glm
 
 		tmat4x4<T, P> Rotate(uninitialize);
 		Rotate[0][0] = c + temp[0] * axis[0];
-		Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
+		Rotate[0][1] = temp[0] * axis[1] + s * axis[2];
-		Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
+		Rotate[0][2] = temp[0] * axis[2] - s * axis[1];
 
-		Rotate[1][0] = 0 + temp[1] * axis[0] - s * axis[2];
+		Rotate[1][0] = temp[1] * axis[0] - s * axis[2];
 		Rotate[1][1] = c + temp[1] * axis[1];
-		Rotate[1][2] = 0 + temp[1] * axis[2] + s * axis[0];
+		Rotate[1][2] = temp[1] * axis[2] + s * axis[0];
 
-		Rotate[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
+		Rotate[2][0] = temp[2] * axis[0] + s * axis[1];
-		Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
+		Rotate[2][1] = temp[2] * axis[1] - s * axis[0];
 		Rotate[2][2] = c + temp[2] * axis[2];
 
 		tmat4x4<T, P> Result(uninitialize);
@@ -56,12 +47,7 @@ namespace glm
 	}
 		
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate_slow
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate_slow(tmat4x4<T, P> const & m, T angle, tvec3<T, P> const & v)
-	(
-		tmat4x4<T, P> const & m,
-		T angle, 
-		tvec3<T, P> const & v
-	)
 	{
 		T const a = angle;
 		T const c = cos(a);
@@ -70,31 +56,27 @@ namespace glm
 
 		tvec3<T, P> axis = normalize(v);
 
-		Result[0][0] = c + (1 - c)      * axis.x     * axis.x;
+		Result[0][0] = c + (static_cast<T>(1) - c)      * axis.x     * axis.x;
-		Result[0][1] = (1 - c) * axis.x * axis.y + s * axis.z;
+		Result[0][1] = (static_cast<T>(1) - c) * axis.x * axis.y + s * axis.z;
-		Result[0][2] = (1 - c) * axis.x * axis.z - s * axis.y;
+		Result[0][2] = (static_cast<T>(1) - c) * axis.x * axis.z - s * axis.y;
-		Result[0][3] = 0;
+		Result[0][3] = static_cast<T>(0);
 
-		Result[1][0] = (1 - c) * axis.y * axis.x - s * axis.z;
+		Result[1][0] = (static_cast<T>(1) - c) * axis.y * axis.x - s * axis.z;
-		Result[1][1] = c + (1 - c) * axis.y * axis.y;
+		Result[1][1] = c + (static_cast<T>(1) - c) * axis.y * axis.y;
-		Result[1][2] = (1 - c) * axis.y * axis.z + s * axis.x;
+		Result[1][2] = (static_cast<T>(1) - c) * axis.y * axis.z + s * axis.x;
-		Result[1][3] = 0;
+		Result[1][3] = static_cast<T>(0);
 
-		Result[2][0] = (1 - c) * axis.z * axis.x + s * axis.y;
+		Result[2][0] = (static_cast<T>(1) - c) * axis.z * axis.x + s * axis.y;
-		Result[2][1] = (1 - c) * axis.z * axis.y - s * axis.x;
+		Result[2][1] = (static_cast<T>(1) - c) * axis.z * axis.y - s * axis.x;
-		Result[2][2] = c + (1 - c) * axis.z * axis.z;
+		Result[2][2] = c + (static_cast<T>(1) - c) * axis.z * axis.z;
-		Result[2][3] = 0;
+		Result[2][3] = static_cast<T>(0);
 
 		Result[3] = tvec4<T, P>(0, 0, 0, 1);
 		return m * Result;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> scale
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> scale(tmat4x4<T, P> const & m, tvec3<T, P> const & v)
-	(
-		tmat4x4<T, P> const & m,
-		tvec3<T, P> const & v
-	)
 	{
 		tmat4x4<T, P> Result(uninitialize);
 		Result[0] = m[0] * v[0];
@@ -105,11 +87,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> scale_slow
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> scale_slow(tmat4x4<T, P> const & m, tvec3<T, P> const & v)
-	(
-		tmat4x4<T, P> const & m,
-		tvec3<T, P> const & v
-	)
 	{
 		tmat4x4<T, P> Result(T(1));
 		Result[0][0] = v.x;
@@ -267,13 +245,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspective
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspective(T fovy, T aspect, T zNear, T zFar)
-	(
-		T fovy,
-		T aspect,
-		T zNear,
-		T zFar
-	)
 	{
 #		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
 			return perspectiveLH(fovy, aspect, zNear, zFar);
@@ -283,12 +255,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveRH
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveRH(T fovy, T aspect, T zNear, T zFar)
-	(
-		T fovy,
-		T aspect,
-		T zNear, T zFar
-	)
 	{
 		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
 
@@ -311,12 +278,7 @@ namespace glm
 	}
 	
 	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveLH
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveLH(T fovy, T aspect, T zNear, T zFar)
-	(
-		T fovy,
-		T aspect,
-		T zNear, T zFar
-	)
 	{
 		assert(abs(aspect - std::numeric_limits<T>::epsilon()) > static_cast<T>(0));
 
@@ -339,12 +301,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveFov
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveFov(T fov, T width, T height, T zNear, T zFar)
-	(
-		T fov,
-		T width, T height,
-		T zNear, T zFar
-	)
 	{
 #		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
 			return perspectiveFovLH(fov, width, height, zNear, zFar);
@@ -354,12 +311,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveFovRH
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveFovRH(T fov, T width, T height, T zNear, T zFar)
-	(
-		T fov,
-		T width, T height,
-		T zNear, T zFar
-	)
 	{
 		assert(width > static_cast<T>(0));
 		assert(height > static_cast<T>(0));
@@ -386,12 +338,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveFovLH
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> perspectiveFovLH(T fov, T width, T height, T zNear, T zFar)
-	(
-		T fov,
-		T width, T height,
-		T zNear, T zFar
-	)
 	{
 		assert(width > static_cast<T>(0));
 		assert(height > static_cast<T>(0));
@@ -418,12 +365,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> infinitePerspective
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> infinitePerspective(T fovy, T aspect, T zNear)
-	(
-		T fovy,
-		T aspect,
-		T zNear
-	)
 	{
 #		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
 			return infinitePerspectiveLH(fovy, aspect, zNear);
@@ -433,68 +375,52 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> infinitePerspectiveRH
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> infinitePerspectiveRH(T fovy, T aspect, T zNear)
-	(
-		T fovy,
-		T aspect,
-		T zNear
-	)
 	{
-		T const range = tan(fovy / T(2)) * zNear;
+		T const range = tan(fovy / static_cast<T>(2)) * zNear;
 		T const left = -range * aspect;
 		T const right = range * aspect;
 		T const bottom = -range;
 		T const top = range;
 
-		tmat4x4<T, defaultp> Result(T(0));
+		tmat4x4<T, defaultp> Result(static_cast<T>(0));
-		Result[0][0] = (T(2) * zNear) / (right - left);
+		Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
-		Result[1][1] = (T(2) * zNear) / (top - bottom);
+		Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
-		Result[2][2] = - T(1);
+		Result[2][2] = - static_cast<T>(1);
-		Result[2][3] = - T(1);
+		Result[2][3] = - static_cast<T>(1);
-		Result[3][2] = - T(2) * zNear;
+		Result[3][2] = - static_cast<T>(2) * zNear;
 		return Result;
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> infinitePerspectiveLH
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> infinitePerspectiveLH(T fovy, T aspect, T zNear)
-	(
-		T fovy,
-		T aspect,
-		T zNear
-	)
 	{
-		T const range = tan(fovy / T(2)) * zNear;
+		T const range = tan(fovy / static_cast<T>(2)) * zNear;
 		T const left = -range * aspect;
 		T const right = range * aspect;
 		T const bottom = -range;
 		T const top = range;
 
 		tmat4x4<T, defaultp> Result(T(0));
-		Result[0][0] = (T(2) * zNear) / (right - left);
+		Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
-		Result[1][1] = (T(2) * zNear) / (top - bottom);
+		Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
-		Result[2][2] = T(1);
+		Result[2][2] = static_cast<T>(1);
-		Result[2][3] = T(1);
+		Result[2][3] = static_cast<T>(1);
-		Result[3][2] = - T(2) * zNear;
+		Result[3][2] = - static_cast<T>(2) * zNear;
 		return Result;
 	}
 
 	// Infinite projection matrix: http://www.terathon.com/gdc07_lengyel.pdf
 	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> tweakedInfinitePerspective
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear, T ep)
-	(
-		T fovy,
-		T aspect,
-		T zNear,
-		T ep
-	)
 	{
-		T const range = tan(fovy / T(2)) * zNear;	
+		T const range = tan(fovy / static_cast<T>(2)) * zNear;	
 		T const left = -range * aspect;
 		T const right = range * aspect;
 		T const bottom = -range;
 		T const top = range;
 
-		tmat4x4<T, defaultp> Result(T(0));
+		tmat4x4<T, defaultp> Result(static_cast<T>(0));
 		Result[0][0] = (static_cast<T>(2) * zNear) / (right - left);
 		Result[1][1] = (static_cast<T>(2) * zNear) / (top - bottom);
 		Result[2][2] = ep - static_cast<T>(1);
@@ -504,12 +430,7 @@ namespace glm
 	}
 
 	template <typename T>
-	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> tweakedInfinitePerspective
+	GLM_FUNC_QUALIFIER tmat4x4<T, defaultp> tweakedInfinitePerspective(T fovy, T aspect, T zNear)
-	(
-		T fovy,
-		T aspect,
-		T zNear
-	)
 	{
 		return tweakedInfinitePerspective(fovy, aspect, zNear, epsilon<T>());
 	}
@@ -523,16 +444,16 @@ namespace glm
 		tvec4<U, P> const & viewport
 	)
 	{
-		tvec4<T, P> tmp = tvec4<T, P>(obj, T(1));
+		tvec4<T, P> tmp = tvec4<T, P>(obj, static_cast<T>(1));
 		tmp = model * tmp;
 		tmp = proj * tmp;
 
 		tmp /= tmp.w;
 #		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
-			tmp.x = tmp.x * T(0.5) + T(0.5);
+			tmp.x = tmp.x * static_cast<T>(0.5) + static_cast<T>(0.5);
-			tmp.y = tmp.y * T(0.5) + T(0.5);
+			tmp.y = tmp.y * static_cast<T>(0.5) + static_cast<T>(0.5);
 #		else
-			tmp = tmp * T(0.5) + T(0.5);
+			tmp = tmp * static_cast<T>(0.5) + static_cast<T>(0.5);
 #		endif
 		tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
 		tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
@@ -555,10 +476,10 @@ namespace glm
 		tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
 		tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
 #		if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE
-			tmp.x = tmp.x * T(2) - T(1);
+			tmp.x = tmp.x * static_cast<T>(2) - static_cast<T>(1);
-			tmp.y = tmp.y * T(2) - T(1);
+			tmp.y = tmp.y * static_cast<T>(2) - static_cast<T>(1);
 #		else
-			tmp = tmp * T(2) - T(1);
+			tmp = tmp * static_cast<T>(2) - static_cast<T>(1);
 #		endif
 
 		tvec4<T, P> obj = Inverse * tmp;
@@ -568,36 +489,26 @@ namespace glm
 	}
 
 	template <typename T, precision P, typename U>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> pickMatrix
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> pickMatrix(tvec2<T, P> const & center, tvec2<T, P> const & delta, tvec4<U, P> const & viewport)
-	(
-		tvec2<T, P> const & center,
-		tvec2<T, P> const & delta,
-		tvec4<U, P> const & viewport
-	)
 	{
-		assert(delta.x > T(0) && delta.y > T(0));
+		assert(delta.x > static_cast<T>(0) && delta.y > static_cast<T>(0));
-		tmat4x4<T, P> Result(1.0f);
+		tmat4x4<T, P> Result(static_cast<T>(1));
 
-		if(!(delta.x > T(0) && delta.y > T(0)))
+		if(!(delta.x > static_cast<T>(0) && delta.y > static_cast<T>(0)))
 			return Result; // Error
 
 		tvec3<T, P> Temp(
-			(T(viewport[2]) - T(2) * (center.x - T(viewport[0]))) / delta.x,
+			(static_cast<T>(viewport[2]) - static_cast<T>(2) * (center.x - static_cast<T>(viewport[0]))) / delta.x,
-			(T(viewport[3]) - T(2) * (center.y - T(viewport[1]))) / delta.y,
+			(static_cast<T>(viewport[3]) - static_cast<T>(2) * (center.y - static_cast<T>(viewport[1]))) / delta.y,
-			T(0));
+			static_cast<T>(0));
 
 		// Translate and scale the picked region to the entire window
 		Result = translate(Result, Temp);
-		return scale(Result, tvec3<T, P>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
+		return scale(Result, tvec3<T, P>(static_cast<T>(viewport[2]) / delta.x, static_cast<T>(viewport[3]) / delta.y, static_cast<T>(1)));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> lookAt
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> lookAt(tvec3<T, P> const & eye, tvec3<T, P> const & center, tvec3<T, P> const & up)
-	(
-		tvec3<T, P> const & eye,
-		tvec3<T, P> const & center,
-		tvec3<T, P> const & up
-	)
 	{
 #		if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED
 			return lookAtLH(eye, center, up);

glm/gtc/noise.hpp

@@ -26,7 +26,7 @@
 #include "../vec3.hpp"
 #include "../vec4.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_noise extension included")
 #endif
 

glm/gtc/packing.hpp

@@ -16,7 +16,7 @@
 // Dependency:
 #include "type_precision.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_packing extension included")
 #endif
 

glm/gtc/quaternion.hpp

@@ -21,7 +21,7 @@
 #include "../vec4.hpp"
 #include "../gtc/constants.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_quaternion extension included")
 #endif
 

glm/gtc/random.hpp

@@ -18,7 +18,7 @@
 #include "../vec2.hpp"
 #include "../vec3.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_random extension included")
 #endif
 

glm/gtc/reciprocal.hpp

@@ -15,7 +15,7 @@
 // Dependencies
 #include "../detail/setup.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_reciprocal extension included")
 #endif
 

glm/gtc/round.hpp

@@ -21,7 +21,7 @@
 #include "../common.hpp"
 #include <limits>
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_integer extension included")
 #endif
 

glm/gtc/type_aligned.hpp

@@ -9,15 +9,15 @@
 /// @brief Aligned types.
 /// <glm/gtc/type_aligned.hpp> need to be included to use these features.
 
+#pragma once
+
 #if !GLM_HAS_ALIGNED_TYPE
 #	error "GLM: Aligned types are not supported on this platform"
 #endif
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 # pragma message("GLM: GLM_GTC_type_aligned extension included")
 #endif
 
-#pragma once
-
 #include "../vec2.hpp"
 #include "../vec3.hpp"
 #include "../vec4.hpp"

glm/gtc/type_precision.hpp

@@ -33,7 +33,7 @@
 #include "../mat4x3.hpp"
 #include "../mat4x4.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_type_precision extension included")
 #endif
 

glm/gtc/type_ptr.hpp

@@ -49,7 +49,7 @@
 #include "../mat4x4.hpp"
 #include <cstring>
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_type_ptr extension included")
 #endif
 

glm/gtc/ulp.hpp

@@ -18,7 +18,7 @@
 #include "../detail/precision.hpp"
 #include "../detail/type_int.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_ulp extension included")
 #endif
 

glm/gtc/vec1.hpp

@@ -15,7 +15,7 @@
 #include "../glm.hpp"
 #include "../detail/type_vec1.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTC_vec1 extension included")
 #endif
 

glm/gtx/associated_min_max.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_associated_min_max extension included")
 #endif
 

glm/gtx/bit.hpp

@@ -16,7 +16,7 @@
 // Dependencies
 #include "../gtc/bitfield.hpp"
 
-#if(defined(GLM_MESSAGES))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_bit extension is deprecated, include GLM_GTC_bitfield and GLM_GTC_integer instead")
 #endif
 

glm/gtx/closest_point.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_closest_point extension included")
 #endif
 

glm/gtx/color_space.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_color_space extension included")
 #endif
 

glm/gtx/color_space_YCoCg.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_color_space_YCoCg extension included")
 #endif
 

glm/gtx/common.hpp

@@ -19,7 +19,7 @@
 #include "../vec4.hpp"
 #include "../gtc/vec1.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_common extension included")
 #endif
 

glm/gtx/compatibility.hpp

@@ -17,13 +17,13 @@
 #include "../glm.hpp"
 #include "../gtc/quaternion.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_compatibility extension included")
 #endif
 
-#if(GLM_COMPILER & GLM_COMPILER_VC)
+#if GLM_COMPILER & GLM_COMPILER_VC
 #	include <cfloat>
-#elif(GLM_COMPILER & GLM_COMPILER_GCC)
+#elif GLM_COMPILER & GLM_COMPILER_GCC
 #	include <cmath>
 #	if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
 #		undef isfinite

glm/gtx/component_wise.hpp

@@ -18,7 +18,7 @@
 #include "../detail/setup.hpp"
 #include "../detail/precision.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_component_wise extension included")
 #endif
 

glm/gtx/dual_quaternion.hpp

@@ -21,7 +21,7 @@
 #include "../gtc/constants.hpp"
 #include "../gtc/quaternion.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_dual_quaternion extension included")
 #endif
 

glm/gtx/euler_angles.hpp

@@ -16,7 +16,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_euler_angles extension included")
 #endif
 

glm/gtx/extend.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_extend extension included")
 #endif
 

glm/gtx/extended_min_max.hpp

@@ -16,7 +16,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_extented_min_max extension included")
 #endif
 

glm/gtx/fast_exponential.hpp

@@ -16,7 +16,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_fast_exponential extension included")
 #endif
 

glm/gtx/fast_square_root.hpp

@@ -19,7 +19,7 @@
 #include "../exponential.hpp"
 #include "../geometric.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_fast_square_root extension included")
 #endif
 

glm/gtx/fast_trigonometry.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../gtc/constants.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_fast_trigonometry extension included")
 #endif
 

glm/gtx/gradient_paint.hpp

@@ -16,7 +16,7 @@
 #include "../glm.hpp"
 #include "../gtx/optimum_pow.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_gradient_paint extension included")
 #endif
 

glm/gtx/handed_coordinate_space.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_handed_coordinate_space extension included")
 #endif
 

glm/gtx/integer.hpp

@@ -16,7 +16,7 @@
 #include "../glm.hpp"
 #include "../gtc/integer.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_integer extension included")
 #endif
 

glm/gtx/intersect.hpp

@@ -21,7 +21,7 @@
 #include "../gtx/closest_point.hpp"
 #include "../gtx/vector_query.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_closest_point extension included")
 #endif
 

glm/gtx/io.hpp

@@ -23,7 +23,7 @@
 #include "../glm.hpp"
 #include "../gtx/quaternion.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(glm_ext))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 # pragma message("GLM: GLM_GTX_io extension included")
 #endif
 

glm/gtx/log_base.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_log_base extension included")
 #endif
 

glm/gtx/matrix_cross_product.hpp

@@ -16,7 +16,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_matrix_cross_product extension included")
 #endif
 

glm/gtx/matrix_decompose.hpp

@@ -20,7 +20,7 @@
 #include "../gtc/quaternion.hpp"
 #include "../gtc/matrix_transform.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_matrix_decompose extension included")
 #endif
 

glm/gtx/matrix_interpolation.hpp

@@ -16,7 +16,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_matrix_interpolation extension included")
 #endif
 

glm/gtx/matrix_major_storage.hpp

@@ -16,7 +16,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_matrix_major_storage extension included")
 #endif
 

glm/gtx/matrix_operation.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_matrix_operation extension included")
 #endif
 

glm/gtx/matrix_query.hpp

@@ -18,7 +18,7 @@
 #include "../gtx/vector_query.hpp"
 #include <limits>
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_matrix_query extension included")
 #endif
 

glm/gtx/matrix_transform_2d.hpp

@@ -18,7 +18,7 @@
 #include "../vec2.hpp"
 
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_matrix_transform_2d extension included")
 #endif
 

glm/gtx/mixed_product.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_mixed_product extension included")
 #endif
 

glm/gtx/norm.hpp

@@ -17,7 +17,7 @@
 #include "../detail/func_geometric.hpp"
 #include "../gtx/quaternion.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_norm extension included")
 #endif
 

glm/gtx/normal.hpp

@@ -16,7 +16,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_normal extension included")
 #endif
 

glm/gtx/normalize_dot.hpp

@@ -16,7 +16,7 @@
 // Dependency:
 #include "../gtx/fast_square_root.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_normalize_dot extension included")
 #endif
 

glm/gtx/number_precision.hpp

@@ -18,7 +18,7 @@
 #include "../glm.hpp"
 #include "../gtc/type_precision.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_number_precision extension included")
 #endif
 

glm/gtx/optimum_pow.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_optimum_pow extension included")
 #endif
 

glm/gtx/orthonormalize.hpp

@@ -18,7 +18,7 @@
 #include "../mat3x3.hpp"
 #include "../geometric.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_orthonormalize extension included")
 #endif
 

glm/gtx/perpendicular.hpp

@@ -17,7 +17,7 @@
 #include "../glm.hpp"
 #include "../gtx/projection.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_perpendicular extension included")
 #endif
 

glm/gtx/polar_coordinates.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_polar_coordinates extension included")
 #endif
 

glm/gtx/projection.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../geometric.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_projection extension included")
 #endif
 

glm/gtx/quaternion.hpp

@@ -19,7 +19,7 @@
 #include "../gtc/quaternion.hpp"
 #include "../gtx/norm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_quaternion extension included")
 #endif
 

glm/gtx/quaternion.inl

@@ -7,21 +7,13 @@
 namespace glm
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> cross
+	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tvec3<T, P> const& v, tquat<T, P> const& q)
-	(
-		tvec3<T, P> const & v,
-		tquat<T, P> const & q
-	)
 	{
 		return inverse(q) * v;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> cross
+	GLM_FUNC_QUALIFIER tvec3<T, P> cross(tquat<T, P> const& q, tvec3<T, P> const& v)
-	(
-		tquat<T, P> const & q,
-		tvec3<T, P> const & v
-	)
 	{
 		return q * v;
 	}
@@ -51,25 +43,19 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P> exp
+	GLM_FUNC_QUALIFIER tquat<T, P> exp(tquat<T, P> const& q)
-	(
-		tquat<T, P> const & q
-	)
 	{
 		tvec3<T, P> u(q.x, q.y, q.z);
-		T Angle = glm::length(u);
+		T const Angle = glm::length(u);
 		if (Angle < epsilon<T>())
 			return tquat<T, P>();
 
-		tvec3<T, P> v(u / Angle);
+		tvec3<T, P> const v(u / Angle);
 		return tquat<T, P>(cos(Angle), sin(Angle) * v);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P> log
+	GLM_FUNC_QUALIFIER tquat<T, P> log(tquat<T, P> const& q)
-	(
-		tquat<T, P> const & q
-	)
 	{
 		tvec3<T, P> u(q.x, q.y, q.z);
 		T Vec3Len = length(u);
@@ -110,36 +96,25 @@ namespace glm
 		T Angle = acos(x.w / magnitude);
 		T NewAngle = Angle * y;
 		T Div = sin(NewAngle) / sin(Angle);
-		T Mag = pow(magnitude, y-1);
+		T Mag = pow(magnitude, y - static_cast<T>(1));
 
 		return tquat<T, P>(cos(NewAngle) * magnitude * Mag, x.x * Div * Mag, x.y * Div * Mag, x.z * Div * Mag);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec3<T, P> rotate
+	GLM_FUNC_QUALIFIER tvec3<T, P> rotate(tquat<T, P> const& q, tvec3<T, P> const& v)
-	(
-		tquat<T, P> const & q,
-		tvec3<T, P> const & v
-	)
 	{
 		return q * v;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tvec4<T, P> rotate
+	GLM_FUNC_QUALIFIER tvec4<T, P> rotate(tquat<T, P> const& q, tvec4<T, P> const& v)
-	(
-		tquat<T, P> const & q,
-		tvec4<T, P> const & v
-	)
 	{
 		return q * v;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T extractRealComponent
+	GLM_FUNC_QUALIFIER T extractRealComponent(tquat<T, P> const& q)
-	(
-		tquat<T, P> const & q
-	)
 	{
 		T w = static_cast<T>(1) - q.x * q.x - q.y * q.y - q.z * q.z;
 		if(w < T(0))
@@ -149,21 +124,13 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER T length2
+	GLM_FUNC_QUALIFIER T length2(tquat<T, P> const& q)
-	(
-		tquat<T, P> const & q
-	)
 	{
 		return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P> shortMix
+	GLM_FUNC_QUALIFIER tquat<T, P> shortMix(tquat<T, P> const& x, tquat<T, P> const& y, T const& a)
-	(
-		tquat<T, P> const & x,
-		tquat<T, P> const & y,
-		T const & a
-	)
 	{
 		if(a <= static_cast<T>(0)) return x;
 		if(a >= static_cast<T>(1)) return y;
@@ -200,22 +167,13 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P> fastMix
+	GLM_FUNC_QUALIFIER tquat<T, P> fastMix(tquat<T, P> const& x, tquat<T, P> const& y, T const & a)
-	(
-		tquat<T, P> const & x,
-		tquat<T, P> const & y,
-		T const & a
-	)
 	{
 		return glm::normalize(x * (static_cast<T>(1) - a) + (y * a));
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tquat<T, P> rotation
+	GLM_FUNC_QUALIFIER tquat<T, P> rotation(tvec3<T, P> const& orig, tvec3<T, P> const& dest)
-	(
-		tvec3<T, P> const & orig,
-		tvec3<T, P> const & dest
-	)
 	{
 		T cosTheta = dot(orig, dest);
 		tvec3<T, P> rotationAxis;

glm/gtx/raw_data.hpp

@@ -16,7 +16,7 @@
 #include "../detail/setup.hpp"
 #include "../detail/type_int.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_raw_data extension included")
 #endif
 

glm/gtx/rotate_normalized_axis.hpp

@@ -19,7 +19,7 @@
 #include "../gtc/epsilon.hpp"
 #include "../gtc/quaternion.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_rotate_normalized_axis extension included")
 #endif
 

glm/gtx/rotate_vector.hpp

@@ -17,7 +17,7 @@
 #include "../glm.hpp"
 #include "../gtx/transform.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_rotate_vector extension included")
 #endif
 

glm/gtx/scalar_relational.hpp

@@ -15,7 +15,7 @@
 // Dependency:
 #include "../glm.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_extend extension included")
 #endif
 

glm/gtx/spline.hpp

@@ -16,7 +16,7 @@
 #include "../glm.hpp"
 #include "../gtx/optimum_pow.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_spline extension included")
 #endif
 

glm/gtx/std_based_type.hpp

@@ -16,7 +16,7 @@
 #include "../glm.hpp"
 #include <cstdlib>
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_std_based_type extension included")
 #endif
 

glm/gtx/string_cast.hpp

@@ -27,7 +27,7 @@
 #	error "GLM_GTX_string_cast is not supported on CUDA compiler"
 #endif
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_string_cast extension included")
 #endif
 

glm/gtx/transform.hpp

@@ -19,7 +19,7 @@
 #include "../glm.hpp"
 #include "../gtc/matrix_transform.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_transform extension included")
 #endif
 

glm/gtx/transform.inl

@@ -4,28 +4,21 @@
 namespace glm
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> translate(
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> translate(tvec3<T, P> const & v)
-		tvec3<T, P> const & v)
 	{
-		return translate(
+		return translate(tmat4x4<T, P>(static_cast<T>(1)), v);
-			tmat4x4<T, P>(1.0f), v);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate(
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> rotate(T angle, tvec3<T, P> const & v)
-		T angle, 
-		tvec3<T, P> const & v)
 	{
-		return rotate(
+		return rotate(tmat4x4<T, P>(static_cast<T>(1)), angle, v);
-			tmat4x4<T, P>(1), angle, v);
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> scale(
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> scale(tvec3<T, P> const & v)
-		tvec3<T, P> const & v)
 	{
-		return scale(
+		return scale(tmat4x4<T, P>(static_cast<T>(1)), v);
-			tmat4x4<T, P>(1.0f), v);
 	}
 
 }//namespace glm

glm/gtx/transform2.hpp

@@ -17,7 +17,7 @@
 #include "../glm.hpp"
 #include "../gtx/transform.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_transform2 extension included")
 #endif
 

glm/gtx/transform2.inl

@@ -4,9 +4,7 @@
 namespace glm
 {
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearX2D(
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearX2D(tmat3x3<T, P> const& m, T s)
-		const tmat3x3<T, P>& m, 
-		T s)
 	{
 		tmat3x3<T, P> r(1);
 		r[0][1] = s;
@@ -14,9 +12,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearY2D(
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> shearY2D(tmat3x3<T, P> const& m, T s)
-		const tmat3x3<T, P>& m, 
-		T s)
 	{
 		tmat3x3<T, P> r(1);
 		r[1][0] = s;
@@ -24,10 +20,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> shearX3D(
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> shearX3D(tmat4x4<T, P> const& m, T s, T t)
-		const tmat4x4<T, P>& m, 
-		T s, 
-		T t)
 	{
 		tmat4x4<T, P> r(1);
 		r[1][0] = s;
@@ -36,10 +29,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> shearY3D(
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> shearY3D(tmat4x4<T, P> const& m, T s, T t)
-		const tmat4x4<T, P>& m, 
-		T s, 
-		T t)
 	{
 		tmat4x4<T, P> r(1);
 		r[0][1] = s;
@@ -48,10 +38,7 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> shearZ3D(
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> shearZ3D(tmat4x4<T, P> const& m, T s, T t)
-		const tmat4x4<T, P>& m, 
-		T s, 
-		T t)
 	{
 		tmat4x4<T, P> r(1);
 		r[0][2] = s;
@@ -60,35 +47,31 @@ namespace glm
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat3x3<T, P> reflect2D(
+	GLM_FUNC_QUALIFIER tmat3x3<T, P> reflect2D(tmat3x3<T, P> const& m, tvec3<T, P> const& normal)
-		const tmat3x3<T, P>& m, 
-		const tvec3<T, P>& normal)
 	{
-		tmat3x3<T, P> r(1);
+		tmat3x3<T, P> r(static_cast<T>(1));
-		r[0][0] = 1 - 2 * normal.x * normal.x;
+		r[0][0] = static_cast<T>(1) - static_cast<T>(2) * normal.x * normal.x;
-		r[0][1] = -2 * normal.x * normal.y;
+		r[0][1] = -static_cast<T>(2) * normal.x * normal.y;
-		r[1][0] = -2 * normal.x * normal.y;
+		r[1][0] = -static_cast<T>(2) * normal.x * normal.y;
-		r[1][1] = 1 - 2 * normal.y * normal.y;
+		r[1][1] = static_cast<T>(1) - static_cast<T>(2) * normal.y * normal.y;
 		return m * r;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> reflect3D(
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> reflect3D(tmat4x4<T, P> const& m, tvec3<T, P> const& normal)
-		const tmat4x4<T, P>& m, 
-		const tvec3<T, P>& normal)
 	{
-		tmat4x4<T, P> r(1);
+		tmat4x4<T, P> r(static_cast<T>(1));
-		r[0][0] = 1 - 2 * normal.x * normal.x;
+		r[0][0] = static_cast<T>(1) - static_cast<T>(2) * normal.x * normal.x;
-		r[0][1] = -2 * normal.x * normal.y;
+		r[0][1] = -static_cast<T>(2) * normal.x * normal.y;
-		r[0][2] = -2 * normal.x * normal.z;
+		r[0][2] = -static_cast<T>(2) * normal.x * normal.z;
 
-		r[1][0] = -2 * normal.x * normal.y;
+		r[1][0] = -static_cast<T>(2) * normal.x * normal.y;
-		r[1][1] = 1 - 2 * normal.y * normal.y;
+		r[1][1] = static_cast<T>(1) - static_cast<T>(2) * normal.y * normal.y;
-		r[1][2] = -2 * normal.y * normal.z;
+		r[1][2] = -static_cast<T>(2) * normal.y * normal.z;
 
-		r[2][0] = -2 * normal.x * normal.z;
+		r[2][0] = -static_cast<T>(2) * normal.x * normal.z;
-		r[2][1] = -2 * normal.y * normal.z;
+		r[2][1] = -static_cast<T>(2) * normal.y * normal.z;
-		r[2][2] = 1 - 2 * normal.z * normal.z;
+		r[2][2] = static_cast<T>(1) - static_cast<T>(2) * normal.z * normal.z;
 		return m * r;
 	}
 
@@ -97,11 +80,11 @@ namespace glm
 		const tmat3x3<T, P>& m, 
 		const tvec3<T, P>& normal)
 	{
-		tmat3x3<T, P> r(1);
+		tmat3x3<T, P> r(static_cast<T>(1));
-		r[0][0] = 1 - normal.x * normal.x;
+		r[0][0] = static_cast<T>(1) - normal.x * normal.x;
 		r[0][1] = - normal.x * normal.y;
 		r[1][0] = - normal.x * normal.y;
-		r[1][1] = 1 - normal.y * normal.y;
+		r[1][1] = static_cast<T>(1) - normal.y * normal.y;
 		return m * r;
 	}
 
@@ -110,26 +93,24 @@ namespace glm
 		const tmat4x4<T, P>& m, 
 		const tvec3<T, P>& normal)
 	{
-		tmat4x4<T, P> r(1);
+		tmat4x4<T, P> r(static_cast<T>(1));
-		r[0][0] = 1 - normal.x * normal.x;
+		r[0][0] = static_cast<T>(1) - normal.x * normal.x;
 		r[0][1] = - normal.x * normal.y;
 		r[0][2] = - normal.x * normal.z;
 		r[1][0] = - normal.x * normal.y;
-		r[1][1] = 1 - normal.y * normal.y;
+		r[1][1] = static_cast<T>(1) - normal.y * normal.y;
 		r[1][2] = - normal.y * normal.z;
 		r[2][0] = - normal.x * normal.z;
 		r[2][1] = - normal.y * normal.z;
-		r[2][2] = 1 - normal.z * normal.z;
+		r[2][2] = static_cast<T>(1) - normal.z * normal.z;
 		return m * r;
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> scaleBias(
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> scaleBias(T scale, T bias)
-		T scale, 
-		T bias)
 	{
 		tmat4x4<T, P> result;
-		result[3] = tvec4<T, P>(tvec3<T, P>(bias), T(1));
+		result[3] = tvec4<T, P>(tvec3<T, P>(bias), static_cast<T>(1));
 		result[0][0] = scale;
 		result[1][1] = scale;
 		result[2][2] = scale;
@@ -137,10 +118,7 @@ namespace glm
 	}
 
 	template <typename T, precision P> 
-	GLM_FUNC_QUALIFIER tmat4x4<T, P> scaleBias(
+	GLM_FUNC_QUALIFIER tmat4x4<T, P> scaleBias(tmat4x4<T, P> const& m, T scale, T bias)
-		const tmat4x4<T, P>& m, 
-		T scale, 
-		T bias)
 	{
 		return m * scaleBias(scale, bias);
 	}

glm/gtx/type_aligned.hpp

@@ -18,7 +18,7 @@
 // Dependency:
 #include "../gtc/type_precision.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_type_aligned extension included")
 #endif
 

glm/gtx/type_trait.hpp

@@ -28,7 +28,7 @@
 #include "../gtc/quaternion.hpp"
 #include "../gtx/dual_quaternion.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_type_trait extension included")
 #endif
 

glm/gtx/vector_angle.hpp

@@ -20,7 +20,7 @@
 #include "../gtx/quaternion.hpp"
 #include "../gtx/rotate_vector.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_vector_angle extension included")
 #endif
 

glm/gtx/vector_query.hpp

@@ -17,7 +17,7 @@
 #include <cfloat>
 #include <limits>
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_vector_query extension included")
 #endif
 

glm/gtx/wrap.hpp

@@ -16,7 +16,7 @@
 #include "../glm.hpp"
 #include "../gtc/vec1.hpp"
 
-#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_EXT_INCLUDED)
 #	pragma message("GLM: GLM_GTX_wrap extension included")
 #endif
 

glm/simd/platform.h

@@ -43,7 +43,7 @@
 #endif//
 
 // Report platform detection
-#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_PLATFORM_DISPLAYED))
+#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_PLATFORM_DISPLAYED)
 #	define GLM_MESSAGE_PLATFORM_DISPLAYED
 #	if(GLM_PLATFORM & GLM_PLATFORM_QNXNTO)
 #		pragma message("GLM: QNX platform detected")

readme.md

@@ -80,6 +80,7 @@ glm::mat4 camera(float Translate, glm::vec2 const & Rotate)
 - Added GTC_functions extension
 - Added quaternion version of isnan and isinf #521
 - Added lowestBitValue to GTX_bit #536
+- Added GLM_FORCE_UNRESTRICTED_GENTYPE allowing non basic genType #543
 
 ##### Improvements:
 - Improved SIMD and swizzle operators interactions with GCC and Clang #474
@@ -95,6 +96,7 @@ glm::mat4 camera(float Translate, glm::vec2 const & Rotate)
 - Use Cuda built-in function for abs function implementation with Cuda compiler
 - Factorized GLM_COMPILER_LLVM and GLM_COMPILER_APPLE_CLANG into GLM_COMPILER_CLANG
 - No more warnings for use of long long
+- Added more information to build messages
 
 ##### Fixes:
 - Fixed GTX_extended_min_max filename typo #386
@@ -111,6 +113,8 @@ glm::mat4 camera(float Translate, glm::vec2 const & Rotate)
 - Deprecated GLM_GTX_simd_vec4 extension
 - Deprecated GLM_GTX_simd_mat4 extension
 - Deprecated GLM_GTX_simd_quat extension
+- Deprecated GLM_SWIZZLE, use GLM_FORCE_SWIZZLE instead
+- Deprecated GLM_MESSAGES, use GLM_FORCE_MESSAGES instead
 
 --------------------------------------------------------------------------------
 #### [GLM 0.9.7.6](https://github.com/g-truc/glm/releases/tag/0.9.7.6) - 2016-07-16

test/core/core_func_integer.cpp

@@ -529,8 +529,8 @@ namespace bitfieldReverse
 	{
 		int Error = 0;
 
-		Error += perf32(Samples);
+		Error += perf32(static_cast<glm::uint32>(Samples));
-		Error += perf64(Samples);
+		Error += perf64(static_cast<glm::uint64>(Samples));
 
 		return Error;
 	}
@@ -1459,7 +1459,7 @@ namespace bitCount
 		// bitCount - TimeIf
 		{
 			for(std::size_t i = 0, n = v.size(); i < n; ++i)
-				v[i] = bitCount_if(i);
+				v[i] = bitCount_if(static_cast<int>(i));
 		}
 
 		std::clock_t TimestampsB = std::clock();

test/core/core_func_swizzle.cpp

@@ -1,5 +1,5 @@
-#define GLM_MESSAGES
+#define GLM_FORCE_MESSAGES
-#define GLM_SWIZZLE
+#define GLM_FORCE_SWIZZLE
 #include <glm/glm.hpp>
 
 int test_ivec2_swizzle()

test/core/core_setup_message.cpp

@@ -1,4 +1,4 @@
-#define GLM_MESSAGES
+#define GLM_FORCE_MESSAGES
 #include <glm/vec3.hpp>
 #include <cstdio>
 

test/core/core_type_vec1.cpp

@@ -1,4 +1,4 @@
-#define GLM_SWIZZLE
+#define GLM_FORCE_SWIZZLE
 #include <glm/vector_relational.hpp>
 #include <glm/gtc/vec1.hpp>
 #include <vector>
@@ -65,7 +65,7 @@ int test_vec1_ctor()
 	}
 #endif
 */
-#if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)
+#if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
 	{
 		glm::vec2 A = glm::vec2(1.0f, 2.0f);
 		glm::vec2 B = A.xy;
@@ -76,7 +76,7 @@ int test_vec1_ctor()
 		Error += glm::all(glm::equal(A, C)) ? 0 : 1;
 		Error += glm::all(glm::equal(A, D)) ? 0 : 1;
 	}
-#endif//GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)
+#endif//GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
 
 	{
 		glm::vec2 A = glm::vec2(2.0f);

test/core/core_type_vec2.cpp

@@ -1,4 +1,4 @@
-#define GLM_SWIZZLE
+#define GLM_FORCE_SWIZZLE
 #include <glm/vector_relational.hpp>
 #include <glm/vec2.hpp>
 #include <vector>
@@ -230,7 +230,7 @@ int test_vec2_ctor()
 	}
 #endif
 
-#if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)
+#if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
 	{
 		glm::vec2 A = glm::vec2(1.0f, 2.0f);
 		glm::vec2 B = A.xy;
@@ -241,7 +241,7 @@ int test_vec2_ctor()
 		Error += glm::all(glm::equal(A, C)) ? 0 : 1;
 		Error += glm::all(glm::equal(A, D)) ? 0 : 1;
 	}
-#endif//GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)
+#endif//GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
 
 	{
 		glm::vec2 A = glm::vec2(2.0f);

test/core/core_type_vec3.cpp

@@ -1,4 +1,4 @@
-#define GLM_SWIZZLE
+#define GLM_FORCE_SWIZZLE
 #include <glm/vector_relational.hpp>
 #include <glm/geometric.hpp>
 #include <glm/vec2.hpp>
@@ -40,7 +40,7 @@ int test_vec3_ctor()
 	}
 #endif
 
-#if(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE))
+#if(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE))
 	{
 		glm::vec3 A = glm::vec3(1.0f, 2.0f, 3.0f);
 		glm::vec3 B = A.xyz;
@@ -59,7 +59,7 @@ int test_vec3_ctor()
 		Error += glm::all(glm::equal(A, G)) ? 0 : 1;
 		Error += glm::all(glm::equal(A, H)) ? 0 : 1;
 	}
-#endif//(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE))
+#endif//(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE))
 
 	{
 		glm::vec3 A(1);

test/core/core_type_vec4.cpp

@@ -1,5 +1,5 @@
 #define GLM_FORCE_ALIGNED
-#define GLM_SWIZZLE
+#define GLM_FORCE_SWIZZLE
 #include <glm/vector_relational.hpp>
 #include <glm/vec2.hpp>
 #include <glm/vec3.hpp>
@@ -68,7 +68,7 @@ int test_vec4_ctor()
 	}
 #endif
 
-#if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)
+#if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
 	{
 		glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f);
 		glm::vec4 B = A.xyzw;
@@ -97,7 +97,7 @@ int test_vec4_ctor()
 		Error += glm::all(glm::equal(A, L)) ? 0 : 1;
 		Error += glm::all(glm::equal(A, M)) ? 0 : 1;
 	}
-#endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)
+#endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
 
 	{
 		glm::vec4 A(1);

test/gtc/gtc_type_aligned.cpp

@@ -1,4 +1,4 @@
-#define GLM_MESSAGES
+#define GLM_FORCE_MESSAGES
 #include <glm/glm.hpp>
 
 #if GLM_HAS_ALIGNED_TYPE