Removed gtc and gtx namespaces

doc/pages.doxy

@@ -311,11 +311,11 @@ void foo()
 	
 	<dl>
 		<dt>glRotate[fd]</dt>
-		<dd>\link glm::gtc::rotate glm::rotate \endlink</dd>
+		<dd>\link glm::rotate glm::rotate \endlink</dd>
 		<dt>glScale[fd]</dt>
-		<dd>\link glm::gtc::scale glm::scale \endlink</dd>
+		<dd>\link glm::scale glm::scale \endlink</dd>
 		<dt>glTranslate[fd]</dt>
-		<dd>\link glm::gtc::translate glm::translate \endlink</dd>
+		<dd>\link glm::translate glm::translate \endlink</dd>
 		<dt>glLoadIdentity</dt>
 		<dd>The default constructor of all matrix types creates an identity matrix.</dd>
 		<dt>glMultMatrix[fd]</dt>
@@ -325,24 +325,24 @@ void foo()
 		<dt>glMultTransposeMatrix</dt>
 		<dd>Combine the last two.</dd>
 		<dt>glFrustum</dt>
-		<dd>\link glm::gtc::frustum glm::frustum \endlink</dd>
+		<dd>\link glm::frustum glm::frustum \endlink</dd>
 		<dt>glOrtho</dt>
-		<dd>\link glm::gtc::ortho glm::ortho \endlink</dd>
+		<dd>\link glm::ortho glm::ortho \endlink</dd>
 		<dt>gluLookAt</dt>
-		<dd>\link glm::gtc::lookAt glm::lookAt \endlink</dd>
+		<dd>\link glm::lookAt glm::lookAt \endlink</dd>
 	</dl>
 	
 	\section deprecated_glu GLU function replacements
 	
 	<dl>
 		<dt>gluOrtho2D</dt>
-		<dd>\link glm::gtc::ortho glm::ortho \endlink</dd>
+		<dd>\link glm::ortho glm::ortho \endlink</dd>
 		<dt>gluPerspective</dt>
-		<dd>\link glm::gtc::perspective glm::perspective \endlink</dd>
+		<dd>\link glm::perspective glm::perspective \endlink</dd>
 		<dt>gluProject</dt>
-		<dd>\link glm::gtc::project glm::project \endlink</dd>
+		<dd>\link glm::project glm::project \endlink</dd>
 		<dt>gluUnProject</dt>
-		<dd>\link glm::gtc::unProject glm::unProject \endlink</dd>
+		<dd>\link glm::unProject glm::unProject \endlink</dd>
 	</dl>
 **/
 

glm/core/func_common.hpp

@@ -31,8 +31,7 @@
 
 #include "_fixes.hpp"
 
-namespace glm{
-namespace core
+namespace glm
 {
 	/// @addtogroup core_funcs
 	/// @{
@@ -367,7 +366,6 @@ namespace core
 	genType ldexp(genType const & x, genIType const & exp);
 
 	/// @}
-}//namespace core
 }//namespace glm
 
 #include "func_common.inl"

glm/core/func_common.inl

@@ -38,8 +38,6 @@ namespace detail
     };
 }//namespace detail
 
-namespace core
-{
 	// abs
 	template <typename genFIType>
     GLM_FUNC_QUALIFIER genFIType abs(
@@ -728,7 +726,7 @@ namespace core
 		//if(x >= maxVal) return maxVal; 
         //if(x <= minVal) return minVal;
 	    //return x;
-		return glm::max(glm::min(x, maxVal), minVal);
+		return max(min(x, maxVal), minVal);
     }
 
     template <typename T>
@@ -1566,5 +1564,4 @@ namespace core
 		return std::frexp(x, exp);
 	}
 
-}//namespace core
 }//namespace glm

glm/core/func_exponential.hpp

@@ -10,10 +10,9 @@
 #ifndef glm_core_func_exponential
 #define glm_core_func_exponential
 
-namespace glm{
-namespace core
+namespace glm
 {
-	/// \addtogroup core_funcs
+	/// @addtogroup core_funcs
 	/// @{
 
 	//! Returns x raised to the y power. 
@@ -69,7 +68,6 @@ namespace core
 	genType inversesqrt(genType const & x);
 
 	/// @}
-}//namespace core
 }//namespace glm
 
 #include "func_exponential.inl"

glm/core/func_exponential.inl

@@ -7,8 +7,7 @@
 // File    : glm/core/func_exponential.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace core
+namespace glm
 {
     // pow
     template <typename genType>
@@ -349,5 +348,4 @@ namespace core
             inversesqrt(x.w));
     }
 
-}//namespace core
 }//namespace glm

glm/core/func_geometric.hpp

@@ -10,8 +10,7 @@
 #ifndef glm_core_func_geometric
 #define glm_core_func_geometric
 
-namespace glm{
-namespace core
+namespace glm
 {
 	/// \addtogroup core_funcs
 	/// @{
@@ -92,7 +91,6 @@ namespace core
 		typename genType::value_type const & eta);
 
 	/// @}
-}//namespace core
 }//namespace glm
 
 #include "func_geometric.inl"

glm/core/func_geometric.inl

@@ -7,8 +7,7 @@
 // File    : glm/core/func_geometric.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace core
+namespace glm
 {
     // length
     template <typename genType>
@@ -281,5 +280,4 @@ namespace core
             return eta * I - (eta * dotValue + sqrt(k)) * N;
     }
 
-}//namespace core
 }//namespace glm

glm/core/func_integer.hpp

@@ -10,10 +10,9 @@
 #ifndef glm_core_func_integer
 #define glm_core_func_integer
 
-namespace glm{
-namespace core
+namespace glm
 {
-	/// \addtogroup core_funcs
+	/// @addtogroup core_funcs
 	/// @{
 
 	//! Adds 32-bit unsigned integer x and y, returning the sum
@@ -140,7 +139,6 @@ namespace core
 	typename C<T>::signed_type findMSB(C<T> const & Value);
 
 	/// @}
-}//namespace core
 }//namespace glm
 
 #include "func_integer.inl"

glm/core/func_integer.inl

@@ -7,581 +7,578 @@
 // File    : glm/core/func_integer.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace core
+namespace glm
 {
-		// uaddCarry
-		template <typename genUType>
-		GLM_FUNC_QUALIFIER genUType uaddCarry
-		(
-			genUType const & x, 
-			genUType const & y, 
-			genUType & Carry
-		)
-		{
-			detail::highp_uint_t Value64 = detail::highp_uint_t(x) + detail::highp_uint_t(y);
-			genUType Result = genUType(Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(32)));
-			Carry = (Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(32))) > 1 ? 1 : 0;
-			return Result;
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec2<T> uaddCarry
-		(
-			detail::tvec2<T> const & x, 
-			detail::tvec2<T> const & y, 
-			detail::tvec2<T> & Carry
-		)
-		{
-			return detail::tvec2<T>(
-				uaddCarry(x[0], y[0], Carry[0]),
-				uaddCarry(x[1], y[1], Carry[1]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec3<T> uaddCarry
-		(
-			detail::tvec3<T> const & x, 
-			detail::tvec3<T> const & y, 
-			detail::tvec3<T> & Carry
-		)
-		{
-			return detail::tvec3<T>(
-				uaddCarry(x[0], y[0], Carry[0]),
-				uaddCarry(x[1], y[1], Carry[1]),
-				uaddCarry(x[2], y[2], Carry[2]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec4<T> uaddCarry
-		(
-			detail::tvec4<T> const & x, 
-			detail::tvec4<T> const & y, 
-			detail::tvec4<T> & Carry
-		)
-		{
-			return detail::tvec4<T>(
-				uaddCarry(x[0], y[0], Carry[0]),
-				uaddCarry(x[1], y[1], Carry[1]),
-				uaddCarry(x[2], y[2], Carry[2]),
-				uaddCarry(x[3], y[3], Carry[3]));
-		}
-
-		// usubBorrow
-		template <typename genUType>
-		GLM_FUNC_QUALIFIER genUType usubBorrow
-		(
-			genUType const & x, 
-			genUType const & y, 
-			genUType & Borrow
-		)
-		{
-			Borrow = x >= y ? 0 : 1;
-			if(x > y)
-				return genUType(detail::highp_int_t(x) - detail::highp_int_t(y));
-			else
-				return genUType(detail::highp_int_t(1) << detail::highp_int_t(32) + detail::highp_int_t(x) - detail::highp_int_t(y));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec2<T> usubBorrow
-		(
-			detail::tvec2<T> const & x, 
-			detail::tvec2<T> const & y, 
-			detail::tvec2<T> & Borrow
-		)
-		{
-			return detail::tvec2<T>(
-				usubBorrow(x[0], y[0], Borrow[0]),
-				usubBorrow(x[1], y[1], Borrow[1]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec3<T> usubBorrow
-		(
-			detail::tvec3<T> const & x, 
-			detail::tvec3<T> const & y, 
-			detail::tvec3<T> & Borrow
-		)
-		{
-			return detail::tvec3<T>(
-				usubBorrow(x[0], y[0], Borrow[0]),
-				usubBorrow(x[1], y[1], Borrow[1]),
-				usubBorrow(x[2], y[2], Borrow[2]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec4<T> usubBorrow
-		(
-			detail::tvec4<T> const & x, 
-			detail::tvec4<T> const & y, 
-			detail::tvec4<T> & Borrow
-		)
-		{
-			return detail::tvec4<T>(
-				usubBorrow(x[0], y[0], Borrow[0]),
-				usubBorrow(x[1], y[1], Borrow[1]),
-				usubBorrow(x[2], y[2], Borrow[2]),
-				usubBorrow(x[3], y[3], Borrow[3]));
-		}
-
-		// umulExtended
-		template <typename genUType>
-		GLM_FUNC_QUALIFIER void umulExtended
-		(
-			genUType const & x, 
-			genUType const & y, 
-			genUType & msb, 
-			genUType & lsb
-		)
-		{
-			detail::highp_uint_t ValueX64 = x;
-			detail::highp_uint_t ValueY64 = y;
-			detail::highp_uint_t Value64 = ValueX64 * ValueY64;
-			msb = *(genUType*)&genUType(Value64 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
-			lsb = *(genUType*)&genUType(Value64 >> detail::highp_uint_t(32));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec2<T> umulExtended
-		(
-			detail::tvec2<T> const & x, 
-			detail::tvec2<T> const & y, 
-			detail::tvec2<T> & msb, 
-			detail::tvec2<T> & lsb
-		)
-		{
-			return detail::tvec2<T>(
-				umulExtended(x[0], y[0], msb, lsb),
-				umulExtended(x[1], y[1], msb, lsb));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec3<T> umulExtended
-		(
-			detail::tvec3<T> const & x, 
-			detail::tvec3<T> const & y, 
-			detail::tvec3<T> & msb, 
-			detail::tvec3<T> & lsb
-		)
-		{
-			return detail::tvec3<T>(
-				umulExtended(x[0], y[0], msb, lsb),
-				umulExtended(x[1], y[1], msb, lsb),
-				umulExtended(x[2], y[2], msb, lsb));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec4<T> umulExtended
-		(
-			detail::tvec4<T> const & x, 
-			detail::tvec4<T> const & y, 
-			detail::tvec4<T> & msb, 
-			detail::tvec4<T> & lsb
-		)
-		{
-			return detail::tvec4<T>(
-				umulExtended(x[0], y[0], msb, lsb),
-				umulExtended(x[1], y[1], msb, lsb),
-				umulExtended(x[2], y[2], msb, lsb),
-				umulExtended(x[3], y[3], msb, lsb));
-		}
-
-		// imulExtended
-		template <typename genIType>
-		GLM_FUNC_QUALIFIER void imulExtended
-		(
-			genIType const & x, 
-			genIType const & y, 
-			genIType & msb, 
-			genIType & lsb
-		)
-		{
-			detail::highp_int_t ValueX64 = x;
-			detail::highp_int_t ValueY64 = y;
-			detail::highp_int_t Value64 = ValueX64 * ValueY64;
-			msb = *(genIType*)&genIType(Value64 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
-			lsb = *(genIType*)&genIType(Value64 >> detail::highp_uint_t(32));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec2<T> imulExtended
-		(
-			detail::tvec2<T> const & x, 
-			detail::tvec2<T> const & y, 
-			detail::tvec2<T> & msb, 
-			detail::tvec2<T> & lsb
-		)
-		{
-			return detail::tvec2<T>(
-				imulExtended(x[0], y[0], msb, lsb),
-				imulExtended(x[1], y[1], msb, lsb));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec3<T> imulExtended
-		(
-			detail::tvec3<T> const & x, 
-			detail::tvec3<T> const & y, 
-			detail::tvec3<T> & msb, 
-			detail::tvec3<T> & lsb
-		)
-		{
-			return detail::tvec3<T>(
-				imulExtended(x[0], y[0], msb, lsb),
-				imulExtended(x[1], y[1], msb, lsb),
-				imulExtended(x[2], y[2], msb, lsb));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec4<T> imulExtended
-		(
-			detail::tvec4<T> const & x, 
-			detail::tvec4<T> const & y, 
-			detail::tvec4<T> & msb, 
-			detail::tvec4<T> & lsb
-		)
-		{
-			return detail::tvec4<T>(
-				imulExtended(x[0], y[0], msb, lsb),
-				imulExtended(x[1], y[1], msb, lsb),
-				imulExtended(x[2], y[2], msb, lsb),
-				imulExtended(x[3], y[3], msb, lsb));
-		}
-
-		// bitfieldExtract
-		template <typename genIUType>
-		GLM_FUNC_QUALIFIER genIUType bitfieldExtract
-		(
-			genIUType const & Value, 
-			int const & Offset, 
-			int const & Bits
-		)
-		{
-			int GenSize = int(sizeof(genIUType)) << int(3);
-
-			assert(Offset + Bits <= GenSize);
-
-			genIUType ShiftLeft = Bits ? Value << (GenSize - (Bits + Offset)) : genIUType(0);
-			genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Bits);
-
-			return ShiftBack;
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldExtract
-		(
-			detail::tvec2<T> const & Value, 
-			int const & Offset, 
-			int const & Bits
-		)
-		{
-			return detail::tvec2<T>(
-				bitfieldExtract(Value[0]),
-				bitfieldExtract(Value[1]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldExtract
-		(
-			detail::tvec3<T> const & Value, 
-			int const & Offset, 
-			int const & Bits
-		)
-		{
-			return detail::tvec3<T>(
-				bitfieldExtract(Value[0]),
-				bitfieldExtract(Value[1]),
-				bitfieldExtract(Value[2]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldExtract
-		(
-			detail::tvec4<T> const & Value, 
-			int const & Offset, 
-			int const & Bits
-		)
-		{
-			return detail::tvec4<T>(
-				bitfieldExtract(Value[0]),
-				bitfieldExtract(Value[1]),
-				bitfieldExtract(Value[2]),
-				bitfieldExtract(Value[3]));
-		}
-
-		// bitfieldInsert
-		template <typename genIUType>
-		GLM_FUNC_QUALIFIER genIUType bitfieldInsert
-		(
-			genIUType const & Base, 
-			genIUType const & Insert, 
-			int const & Offset, 
-			int const & Bits
-		)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
-			assert(Offset + Bits <= sizeof(genIUType));
-
-			if(Bits == 0)
-				return Base;
-
-			genIUType Mask = 0;
-			for(int Bit = Offset; Bit < Offset + Bits; ++Bit)
-				Mask |= (1 << Bit);
-
-			return (Base & ~Mask) | (Insert & Mask);
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldInsert
-		(
-			detail::tvec2<T> const & Base, 
-			detail::tvec2<T> const & Insert, 
-			int const & Offset, 
-			int const & Bits
-		)
-		{
-			return detail::tvec2<T>(
-				bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-				bitfieldInsert(Base[1], Insert[1], Offset, Bits));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldInsert
-		(
-			detail::tvec3<T> const & Base, 
-			detail::tvec3<T> const & Insert, 
-			int const & Offset, 
-			int const & Bits
-		)
-		{
-			return detail::tvec3<T>(
-				bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-				bitfieldInsert(Base[1], Insert[1], Offset, Bits),
-				bitfieldInsert(Base[2], Insert[2], Offset, Bits));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldInsert
-		(
-			detail::tvec4<T> const & Base, 
-			detail::tvec4<T> const & Insert, 
-			int const & Offset, 
-			int const & Bits
-		)
-		{
-			return detail::tvec4<T>(
-				bitfieldInsert(Base[0], Insert[0], Offset, Bits),
-				bitfieldInsert(Base[1], Insert[1], Offset, Bits),
-				bitfieldInsert(Base[2], Insert[2], Offset, Bits),
-				bitfieldInsert(Base[3], Insert[3], Offset, Bits));
-		}
-
-		// bitfieldReverse
-		template <typename genIUType>
-		GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType const & Value)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
-
-			genIUType Out = 0;
-			std::size_t BitSize = sizeof(genIUType) * 8;
-			for(std::size_t i = 0; i < BitSize; ++i)
-				if(Value & (genIUType(1) << i))
-					Out |= genIUType(1) << (BitSize - 1 - i);
-			return Out;
-		}	
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldReverse
-		(
-			detail::tvec2<T> const & value
-		)
-		{
-			return detail::tvec2<T>(
-				bitfieldReverse(value[0]),
-				bitfieldReverse(value[1]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldReverse
-		(
-			detail::tvec3<T> const & value
-		)
-		{
-			return detail::tvec3<T>(
-				bitfieldReverse(value[0]),
-				bitfieldReverse(value[1]),
-				bitfieldReverse(value[2]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldReverse
-		(
-			detail::tvec4<T> const & value
-		)
-		{
-			return detail::tvec4<T>(
-				bitfieldReverse(value[0]),
-				bitfieldReverse(value[1]),
-				bitfieldReverse(value[2]),
-				bitfieldReverse(value[3]));
-		}
-
-		// bitCount
-		template <typename genIUType>
-		GLM_FUNC_QUALIFIER int bitCount(genIUType const & Value)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
-
-			int Count = 0;
-			for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
-			{
-				if(Value & (1 << i))
-					++Count;
-			}
-			return Count;
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec2<int> bitCount
-		(
-			detail::tvec2<T> const & value
-		)
-		{
-			return detail::tvec2<int>(
-				bitCount(value[0]),
-				bitCount(value[1]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec3<int> bitCount
-		(
-			detail::tvec3<T> const & value
-		)
-		{
-			return detail::tvec3<int>(
-				bitCount(value[0]),
-				bitCount(value[1]),
-				bitCount(value[2]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec4<int> bitCount
-		(
-			detail::tvec4<T> const & value
-		)
-		{
-			return detail::tvec4<int>(
-				bitCount(value[0]),
-				bitCount(value[1]),
-				bitCount(value[2]),
-				bitCount(value[3]));
-		}
-
-		// findLSB
-		template <typename genIUType>
-		GLM_FUNC_QUALIFIER int findLSB
-		(
-			genIUType const & Value
-		)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
-			if(Value == 0)
-				return -1;
-
-			genIUType Bit;
-			for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){}
-			return Bit;
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec2<int> findLSB
-		(
-			detail::tvec2<T> const & value
-		)
-		{
-			return detail::tvec2<int>(
-				findLSB(value[0]),
-				findLSB(value[1]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec3<int> findLSB
-		(
-			detail::tvec3<T> const & value
-		)
-		{
-			return detail::tvec3<int>(
-				findLSB(value[0]),
-				findLSB(value[1]),
-				findLSB(value[2]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec4<int> findLSB
-		(
-			detail::tvec4<T> const & value
-		)
-		{
-			return detail::tvec4<int>(
-				findLSB(value[0]),
-				findLSB(value[1]),
-				findLSB(value[2]),
-				findLSB(value[3]));
-		}
-
-		// findMSB
-		template <typename genIUType>
-		GLM_FUNC_QUALIFIER int findMSB
-		(
-			genIUType const & Value
-		)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
-			if(Value == 0)
-				return -1;
-
-			genIUType bit = genIUType(-1);
-			for(genIUType tmp = Value; tmp; tmp >>= 1, ++bit){}
-			return bit;
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec2<int> findMSB
-		(
-			detail::tvec2<T> const & value
-		)
-		{
-			return detail::tvec2<int>(
-				findMSB(value[0]),
-				findMSB(value[1]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec3<int> findMSB
-		(
-			detail::tvec3<T> const & value
-		)
-		{
-			return detail::tvec3<int>(
-				findMSB(value[0]),
-				findMSB(value[1]),
-				findMSB(value[2]));
-		}
-
-		template <typename T>
-		GLM_FUNC_QUALIFIER detail::tvec4<int> findMSB
-		(
-			detail::tvec4<T> const & value
-		)
-		{
-			return detail::tvec4<int>(
-				findMSB(value[0]),
-				findMSB(value[1]),
-				findMSB(value[2]),
-				findMSB(value[3]));
-		}
-
-}//namespace core
+	// uaddCarry
+	template <typename genUType>
+	GLM_FUNC_QUALIFIER genUType uaddCarry
+	(
+		genUType const & x, 
+		genUType const & y, 
+		genUType & Carry
+	)
+	{
+		detail::highp_uint_t Value64 = detail::highp_uint_t(x) + detail::highp_uint_t(y);
+		genUType Result = genUType(Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(32)));
+		Carry = (Value64 % (detail::highp_uint_t(1) << detail::highp_uint_t(32))) > 1 ? 1 : 0;
+		return Result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> uaddCarry
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y, 
+		detail::tvec2<T> & Carry
+	)
+	{
+		return detail::tvec2<T>(
+			uaddCarry(x[0], y[0], Carry[0]),
+			uaddCarry(x[1], y[1], Carry[1]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> uaddCarry
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y, 
+		detail::tvec3<T> & Carry
+	)
+	{
+		return detail::tvec3<T>(
+			uaddCarry(x[0], y[0], Carry[0]),
+			uaddCarry(x[1], y[1], Carry[1]),
+			uaddCarry(x[2], y[2], Carry[2]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> uaddCarry
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y, 
+		detail::tvec4<T> & Carry
+	)
+	{
+		return detail::tvec4<T>(
+			uaddCarry(x[0], y[0], Carry[0]),
+			uaddCarry(x[1], y[1], Carry[1]),
+			uaddCarry(x[2], y[2], Carry[2]),
+			uaddCarry(x[3], y[3], Carry[3]));
+	}
+
+	// usubBorrow
+	template <typename genUType>
+	GLM_FUNC_QUALIFIER genUType usubBorrow
+	(
+		genUType const & x, 
+		genUType const & y, 
+		genUType & Borrow
+	)
+	{
+		Borrow = x >= y ? 0 : 1;
+		if(x > y)
+			return genUType(detail::highp_int_t(x) - detail::highp_int_t(y));
+		else
+			return genUType(detail::highp_int_t(1) << detail::highp_int_t(32) + detail::highp_int_t(x) - detail::highp_int_t(y));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> usubBorrow
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y, 
+		detail::tvec2<T> & Borrow
+	)
+	{
+		return detail::tvec2<T>(
+			usubBorrow(x[0], y[0], Borrow[0]),
+			usubBorrow(x[1], y[1], Borrow[1]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> usubBorrow
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y, 
+		detail::tvec3<T> & Borrow
+	)
+	{
+		return detail::tvec3<T>(
+			usubBorrow(x[0], y[0], Borrow[0]),
+			usubBorrow(x[1], y[1], Borrow[1]),
+			usubBorrow(x[2], y[2], Borrow[2]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> usubBorrow
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y, 
+		detail::tvec4<T> & Borrow
+	)
+	{
+		return detail::tvec4<T>(
+			usubBorrow(x[0], y[0], Borrow[0]),
+			usubBorrow(x[1], y[1], Borrow[1]),
+			usubBorrow(x[2], y[2], Borrow[2]),
+			usubBorrow(x[3], y[3], Borrow[3]));
+	}
+
+	// umulExtended
+	template <typename genUType>
+	GLM_FUNC_QUALIFIER void umulExtended
+	(
+		genUType const & x, 
+		genUType const & y, 
+		genUType & msb, 
+		genUType & lsb
+	)
+	{
+		detail::highp_uint_t ValueX64 = x;
+		detail::highp_uint_t ValueY64 = y;
+		detail::highp_uint_t Value64 = ValueX64 * ValueY64;
+		msb = *(genUType*)&genUType(Value64 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
+		lsb = *(genUType*)&genUType(Value64 >> detail::highp_uint_t(32));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> umulExtended
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y, 
+		detail::tvec2<T> & msb, 
+		detail::tvec2<T> & lsb
+	)
+	{
+		return detail::tvec2<T>(
+			umulExtended(x[0], y[0], msb, lsb),
+			umulExtended(x[1], y[1], msb, lsb));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> umulExtended
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y, 
+		detail::tvec3<T> & msb, 
+		detail::tvec3<T> & lsb
+	)
+	{
+		return detail::tvec3<T>(
+			umulExtended(x[0], y[0], msb, lsb),
+			umulExtended(x[1], y[1], msb, lsb),
+			umulExtended(x[2], y[2], msb, lsb));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> umulExtended
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y, 
+		detail::tvec4<T> & msb, 
+		detail::tvec4<T> & lsb
+	)
+	{
+		return detail::tvec4<T>(
+			umulExtended(x[0], y[0], msb, lsb),
+			umulExtended(x[1], y[1], msb, lsb),
+			umulExtended(x[2], y[2], msb, lsb),
+			umulExtended(x[3], y[3], msb, lsb));
+	}
+
+	// imulExtended
+	template <typename genIType>
+	GLM_FUNC_QUALIFIER void imulExtended
+	(
+		genIType const & x, 
+		genIType const & y, 
+		genIType & msb, 
+		genIType & lsb
+	)
+	{
+		detail::highp_int_t ValueX64 = x;
+		detail::highp_int_t ValueY64 = y;
+		detail::highp_int_t Value64 = ValueX64 * ValueY64;
+		msb = *(genIType*)&genIType(Value64 & ((detail::highp_uint_t(1) << detail::highp_uint_t(32)) - detail::highp_uint_t(1)));
+		lsb = *(genIType*)&genIType(Value64 >> detail::highp_uint_t(32));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> imulExtended
+	(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & y, 
+		detail::tvec2<T> & msb, 
+		detail::tvec2<T> & lsb
+	)
+	{
+		return detail::tvec2<T>(
+			imulExtended(x[0], y[0], msb, lsb),
+			imulExtended(x[1], y[1], msb, lsb));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> imulExtended
+	(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & y, 
+		detail::tvec3<T> & msb, 
+		detail::tvec3<T> & lsb
+	)
+	{
+		return detail::tvec3<T>(
+			imulExtended(x[0], y[0], msb, lsb),
+			imulExtended(x[1], y[1], msb, lsb),
+			imulExtended(x[2], y[2], msb, lsb));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> imulExtended
+	(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & y, 
+		detail::tvec4<T> & msb, 
+		detail::tvec4<T> & lsb
+	)
+	{
+		return detail::tvec4<T>(
+			imulExtended(x[0], y[0], msb, lsb),
+			imulExtended(x[1], y[1], msb, lsb),
+			imulExtended(x[2], y[2], msb, lsb),
+			imulExtended(x[3], y[3], msb, lsb));
+	}
+
+	// bitfieldExtract
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldExtract
+	(
+		genIUType const & Value, 
+		int const & Offset, 
+		int const & Bits
+	)
+	{
+		int GenSize = int(sizeof(genIUType)) << int(3);
+
+		assert(Offset + Bits <= GenSize);
+
+		genIUType ShiftLeft = Bits ? Value << (GenSize - (Bits + Offset)) : genIUType(0);
+		genIUType ShiftBack = ShiftLeft >> genIUType(GenSize - Bits);
+
+		return ShiftBack;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldExtract
+	(
+		detail::tvec2<T> const & Value, 
+		int const & Offset, 
+		int const & Bits
+	)
+	{
+		return detail::tvec2<T>(
+			bitfieldExtract(Value[0]),
+			bitfieldExtract(Value[1]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldExtract
+	(
+		detail::tvec3<T> const & Value, 
+		int const & Offset, 
+		int const & Bits
+	)
+	{
+		return detail::tvec3<T>(
+			bitfieldExtract(Value[0]),
+			bitfieldExtract(Value[1]),
+			bitfieldExtract(Value[2]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldExtract
+	(
+		detail::tvec4<T> const & Value, 
+		int const & Offset, 
+		int const & Bits
+	)
+	{
+		return detail::tvec4<T>(
+			bitfieldExtract(Value[0]),
+			bitfieldExtract(Value[1]),
+			bitfieldExtract(Value[2]),
+			bitfieldExtract(Value[3]));
+	}
+
+	// bitfieldInsert
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldInsert
+	(
+		genIUType const & Base, 
+		genIUType const & Insert, 
+		int const & Offset, 
+		int const & Bits
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldInsert' only accept integer values");
+		assert(Offset + Bits <= sizeof(genIUType));
+
+		if(Bits == 0)
+			return Base;
+
+		genIUType Mask = 0;
+		for(int Bit = Offset; Bit < Offset + Bits; ++Bit)
+			Mask |= (1 << Bit);
+
+		return (Base & ~Mask) | (Insert & Mask);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldInsert
+	(
+		detail::tvec2<T> const & Base, 
+		detail::tvec2<T> const & Insert, 
+		int const & Offset, 
+		int const & Bits
+	)
+	{
+		return detail::tvec2<T>(
+			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
+			bitfieldInsert(Base[1], Insert[1], Offset, Bits));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldInsert
+	(
+		detail::tvec3<T> const & Base, 
+		detail::tvec3<T> const & Insert, 
+		int const & Offset, 
+		int const & Bits
+	)
+	{
+		return detail::tvec3<T>(
+			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
+			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
+			bitfieldInsert(Base[2], Insert[2], Offset, Bits));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldInsert
+	(
+		detail::tvec4<T> const & Base, 
+		detail::tvec4<T> const & Insert, 
+		int const & Offset, 
+		int const & Bits
+	)
+	{
+		return detail::tvec4<T>(
+			bitfieldInsert(Base[0], Insert[0], Offset, Bits),
+			bitfieldInsert(Base[1], Insert[1], Offset, Bits),
+			bitfieldInsert(Base[2], Insert[2], Offset, Bits),
+			bitfieldInsert(Base[3], Insert[3], Offset, Bits));
+	}
+
+	// bitfieldReverse
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER genIUType bitfieldReverse(genIUType const & Value)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitfieldReverse' only accept integer values");
+
+		genIUType Out = 0;
+		std::size_t BitSize = sizeof(genIUType) * 8;
+		for(std::size_t i = 0; i < BitSize; ++i)
+			if(Value & (genIUType(1) << i))
+				Out |= genIUType(1) << (BitSize - 1 - i);
+		return Out;
+	}	
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> bitfieldReverse
+	(
+		detail::tvec2<T> const & value
+	)
+	{
+		return detail::tvec2<T>(
+			bitfieldReverse(value[0]),
+			bitfieldReverse(value[1]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> bitfieldReverse
+	(
+		detail::tvec3<T> const & value
+	)
+	{
+		return detail::tvec3<T>(
+			bitfieldReverse(value[0]),
+			bitfieldReverse(value[1]),
+			bitfieldReverse(value[2]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> bitfieldReverse
+	(
+		detail::tvec4<T> const & value
+	)
+	{
+		return detail::tvec4<T>(
+			bitfieldReverse(value[0]),
+			bitfieldReverse(value[1]),
+			bitfieldReverse(value[2]),
+			bitfieldReverse(value[3]));
+	}
+
+	// bitCount
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER int bitCount(genIUType const & Value)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'bitCount' only accept integer values");
+
+		int Count = 0;
+		for(std::size_t i = 0; i < sizeof(genIUType) * std::size_t(8); ++i)
+		{
+			if(Value & (1 << i))
+				++Count;
+		}
+		return Count;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<int> bitCount
+	(
+		detail::tvec2<T> const & value
+	)
+	{
+		return detail::tvec2<int>(
+			bitCount(value[0]),
+			bitCount(value[1]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<int> bitCount
+	(
+		detail::tvec3<T> const & value
+	)
+	{
+		return detail::tvec3<int>(
+			bitCount(value[0]),
+			bitCount(value[1]),
+			bitCount(value[2]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<int> bitCount
+	(
+		detail::tvec4<T> const & value
+	)
+	{
+		return detail::tvec4<int>(
+			bitCount(value[0]),
+			bitCount(value[1]),
+			bitCount(value[2]),
+			bitCount(value[3]));
+	}
+
+	// findLSB
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER int findLSB
+	(
+		genIUType const & Value
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findLSB' only accept integer values");
+		if(Value == 0)
+			return -1;
+
+		genIUType Bit;
+		for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){}
+		return Bit;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<int> findLSB
+	(
+		detail::tvec2<T> const & value
+	)
+	{
+		return detail::tvec2<int>(
+			findLSB(value[0]),
+			findLSB(value[1]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<int> findLSB
+	(
+		detail::tvec3<T> const & value
+	)
+	{
+		return detail::tvec3<int>(
+			findLSB(value[0]),
+			findLSB(value[1]),
+			findLSB(value[2]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<int> findLSB
+	(
+		detail::tvec4<T> const & value
+	)
+	{
+		return detail::tvec4<int>(
+			findLSB(value[0]),
+			findLSB(value[1]),
+			findLSB(value[2]),
+			findLSB(value[3]));
+	}
+
+	// findMSB
+	template <typename genIUType>
+	GLM_FUNC_QUALIFIER int findMSB
+	(
+		genIUType const & Value
+	)
+	{
+		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, "'findMSB' only accept integer values");
+		if(Value == 0)
+			return -1;
+
+		genIUType bit = genIUType(-1);
+		for(genIUType tmp = Value; tmp; tmp >>= 1, ++bit){}
+		return bit;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<int> findMSB
+	(
+		detail::tvec2<T> const & value
+	)
+	{
+		return detail::tvec2<int>(
+			findMSB(value[0]),
+			findMSB(value[1]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<int> findMSB
+	(
+		detail::tvec3<T> const & value
+	)
+	{
+		return detail::tvec3<int>(
+			findMSB(value[0]),
+			findMSB(value[1]),
+			findMSB(value[2]));
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<int> findMSB
+	(
+		detail::tvec4<T> const & value
+	)
+	{
+		return detail::tvec4<int>(
+			findMSB(value[0]),
+			findMSB(value[1]),
+			findMSB(value[2]),
+			findMSB(value[3]));
+	}
 }//namespace glm

glm/core/func_matrix.hpp

@@ -10,10 +10,9 @@
 #ifndef glm_core_func_matrix
 #define glm_core_func_matrix
 
-namespace glm{
-namespace core
+namespace glm
 {
-	/// \addtogroup core_funcs
+	/// @addtogroup core_funcs
 	/// @{
 
 	//! Multiply matrix x by matrix y component-wise, i.e., 
@@ -94,7 +93,6 @@ namespace core
 		detail::tmat4x4<T> const & m);
 
 	/// @}
-}//namespace core
 }//namespace glm
 
 #include "func_matrix.inl"

glm/core/func_matrix.inl

@@ -7,33 +7,32 @@
 // File    : glm/core/func_matrix.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace core
+namespace glm
 {
-    // matrixCompMult
-    template <typename matType>
-    GLM_FUNC_QUALIFIER matType matrixCompMult
+	// matrixCompMult
+	template <typename matType>
+	GLM_FUNC_QUALIFIER matType matrixCompMult
 	(
 		matType const & x, 
 		matType const & y
 	)
-    {
+	{
 		GLM_STATIC_ASSERT(detail::type<typename matType::value_type>::is_float, "'matrixCompMult' only accept floating-point inputs");
 
-        matType result(matType::null);
+		matType result(matType::null);
 		for(typename matType::size_type i = 0; i < matType::col_size(); ++i)
 			result[i] = x[i] * y[i];
-        return result;
-    }
+		return result;
+	}
 
 	// outerProduct
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat2x2<T> outerProduct
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x2<T> outerProduct
 	(
 		detail::tvec2<T> const & c, 
 		detail::tvec2<T> const & r
 	)
-    {
+	{
 		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
 
 		detail::tmat2x2<T> m(detail::tmat2x2<T>::null);
@@ -41,40 +40,40 @@ namespace core
 		m[0][1] = c[1] * r[0];
 		m[1][0] = c[0] * r[1];
 		m[1][1] = c[1] * r[1];
-        return m;
-    }
+		return m;
+	}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat3x3<T> outerProduct
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x3<T> outerProduct
 	(
 		detail::tvec3<T> const & c, 
 		detail::tvec3<T> const & r
 	)
-    {
+	{
 		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
 
 		detail::tmat3x3<T> m(detail::tmat3x3<T>::null);
 		for(typename detail::tmat3x3<T>::size_type i = 0; i < detail::tmat3x3<T>::col_size(); ++i)
 			m[i] = c * r[i];
-        return m;
-    }
+		return m;
+	}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> outerProduct
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> outerProduct
 	(
 		detail::tvec4<T> const & c, 
 		detail::tvec4<T> const & r
 	)
-    {
+	{
 		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'outerProduct' only accept floating-point inputs");
 
 		detail::tmat4x4<T> m(detail::tmat4x4<T>::null);
 		for(typename detail::tmat4x4<T>::size_type i = 0; i < detail::tmat4x4<T>::col_size(); ++i)
 			m[i] = c * r[i];
-        return m;
-    }
+		return m;
+	}
 
-    template <typename T>
+	template <typename T>
 	GLM_FUNC_QUALIFIER detail::tmat2x3<T> outerProduct
 	(
 		detail::tvec3<T> const & c, 
@@ -93,7 +92,7 @@ namespace core
 		return m;
 	}
 
-    template <typename T>
+	template <typename T>
 	GLM_FUNC_QUALIFIER detail::tmat3x2<T> outerProduct
 	(
 		detail::tvec2<T> const & c, 
@@ -204,113 +203,113 @@ namespace core
 		return m;
 	}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat2x2<T> transpose
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x2<T> transpose
 	(
 		detail::tmat2x2<T> const & m
 	)
-    {
+	{
 		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
 
-        detail::tmat2x2<T> result(detail::tmat2x2<T>::null);
-        result[0][0] = m[0][0];
-        result[0][1] = m[1][0];
-        result[1][0] = m[0][1];
-        result[1][1] = m[1][1];
-        return result;
-    }
+		detail::tmat2x2<T> result(detail::tmat2x2<T>::null);
+		result[0][0] = m[0][0];
+		result[0][1] = m[1][0];
+		result[1][0] = m[0][1];
+		result[1][1] = m[1][1];
+		return result;
+	}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat3x3<T> transpose
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x3<T> transpose
 	(
 		detail::tmat3x3<T> const & m
 	)
-    {
+	{
 		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
 
-        detail::tmat3x3<T> result(detail::tmat3x3<T>::null);
-        result[0][0] = m[0][0];
-        result[0][1] = m[1][0];
-        result[0][2] = m[2][0];
+		detail::tmat3x3<T> result(detail::tmat3x3<T>::null);
+		result[0][0] = m[0][0];
+		result[0][1] = m[1][0];
+		result[0][2] = m[2][0];
 
-        result[1][0] = m[0][1];
-        result[1][1] = m[1][1];
-        result[1][2] = m[2][1];
+		result[1][0] = m[0][1];
+		result[1][1] = m[1][1];
+		result[1][2] = m[2][1];
 
-        result[2][0] = m[0][2];
-        result[2][1] = m[1][2];
-        result[2][2] = m[2][2];
-        return result;
-    }
+		result[2][0] = m[0][2];
+		result[2][1] = m[1][2];
+		result[2][2] = m[2][2];
+		return result;
+	}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> transpose
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> transpose
 	(
 		detail::tmat4x4<T> const & m
 	)
-    {
+	{
 		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
 
-        detail::tmat4x4<T> result(detail::tmat4x4<T>::null);
-        result[0][0] = m[0][0];
-        result[0][1] = m[1][0];
-        result[0][2] = m[2][0];
-        result[0][3] = m[3][0];
-
-        result[1][0] = m[0][1];
-        result[1][1] = m[1][1];
-        result[1][2] = m[2][1];
-        result[1][3] = m[3][1];
-
-        result[2][0] = m[0][2];
-        result[2][1] = m[1][2];
-        result[2][2] = m[2][2];
-        result[2][3] = m[3][2];
-
-        result[3][0] = m[0][3];
-        result[3][1] = m[1][3];
-        result[3][2] = m[2][3];
-        result[3][3] = m[3][3];
-        return result;
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat2x3<T> transpose
+		detail::tmat4x4<T> result(detail::tmat4x4<T>::null);
+		result[0][0] = m[0][0];
+		result[0][1] = m[1][0];
+		result[0][2] = m[2][0];
+		result[0][3] = m[3][0];
+
+		result[1][0] = m[0][1];
+		result[1][1] = m[1][1];
+		result[1][2] = m[2][1];
+		result[1][3] = m[3][1];
+
+		result[2][0] = m[0][2];
+		result[2][1] = m[1][2];
+		result[2][2] = m[2][2];
+		result[2][3] = m[3][2];
+
+		result[3][0] = m[0][3];
+		result[3][1] = m[1][3];
+		result[3][2] = m[2][3];
+		result[3][3] = m[3][3];
+		return result;
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x3<T> transpose
 	(
 		detail::tmat3x2<T> const & m
 	)
-    {
+	{
 		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
 
-        detail::tmat2x3<T> result(detail::tmat2x3<T>::null);
-        result[0][0] = m[0][0];
-        result[0][1] = m[1][0];
+		detail::tmat2x3<T> result(detail::tmat2x3<T>::null);
+		result[0][0] = m[0][0];
+		result[0][1] = m[1][0];
 		result[0][2] = m[2][0];
-        result[1][0] = m[0][1];
-        result[1][1] = m[1][1];
+		result[1][0] = m[0][1];
+		result[1][1] = m[1][1];
 		result[1][2] = m[2][1];
-        return result;
-    }
+		return result;
+	}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat3x2<T> transpose
+	template <typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x2<T> transpose
 	(
 		detail::tmat2x3<T> const & m
 	)
-    {
+	{
 		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
 
-        detail::tmat3x2<T> result(detail::tmat3x2<T>::null);
-        result[0][0] = m[0][0];
-        result[0][1] = m[1][0];
-        result[1][0] = m[0][1];
-        result[1][1] = m[1][1];
-        result[2][0] = m[0][2];
-        result[2][1] = m[1][2];
-        return result;
-    }
-
-    template <typename T>
+		detail::tmat3x2<T> result(detail::tmat3x2<T>::null);
+		result[0][0] = m[0][0];
+		result[0][1] = m[1][0];
+		result[1][0] = m[0][1];
+		result[1][1] = m[1][1];
+		result[2][0] = m[0][2];
+		result[2][1] = m[1][2];
+		return result;
+	}
+
+	template <typename T>
 	GLM_FUNC_QUALIFIER detail::tmat2x4<T> transpose
 	(
 		detail::tmat4x2<T> const & m
@@ -319,18 +318,18 @@ namespace core
 		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
 
 		detail::tmat2x4<T> result(detail::tmat2x4<T>::null);
-        result[0][0] = m[0][0];
-        result[0][1] = m[1][0];
+		result[0][0] = m[0][0];
+		result[0][1] = m[1][0];
 		result[0][2] = m[2][0];
 		result[0][3] = m[3][0];
-        result[1][0] = m[0][1];
-        result[1][1] = m[1][1];
+		result[1][0] = m[0][1];
+		result[1][1] = m[1][1];
 		result[1][2] = m[2][1];
 		result[1][3] = m[3][1];
 		return result;
 	}
 
-    template <typename T>
+	template <typename T>
 	GLM_FUNC_QUALIFIER detail::tmat4x2<T> transpose
 	(
 		detail::tmat2x4<T> const & m
@@ -338,19 +337,19 @@ namespace core
 	{
 		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
 
-        detail::tmat4x2<T> result(detail::tmat4x2<T>::null);
-        result[0][0] = m[0][0];
-        result[0][1] = m[1][0];
-        result[1][0] = m[0][1];
-        result[1][1] = m[1][1];
-        result[2][0] = m[0][2];
-        result[2][1] = m[1][2];
-        result[3][0] = m[0][3];
-        result[3][1] = m[1][3];
-        return result;
+		detail::tmat4x2<T> result(detail::tmat4x2<T>::null);
+		result[0][0] = m[0][0];
+		result[0][1] = m[1][0];
+		result[1][0] = m[0][1];
+		result[1][1] = m[1][1];
+		result[2][0] = m[0][2];
+		result[2][1] = m[1][2];
+		result[3][0] = m[0][3];
+		result[3][1] = m[1][3];
+		return result;
 	}
 
-    template <typename T>
+	template <typename T>
 	GLM_FUNC_QUALIFIER detail::tmat3x4<T> transpose
 	(
 		detail::tmat4x3<T> const & m
@@ -359,22 +358,22 @@ namespace core
 		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
 
 		detail::tmat3x4<T> result(detail::tmat3x4<T>::null);
-        result[0][0] = m[0][0];
-        result[0][1] = m[1][0];
+		result[0][0] = m[0][0];
+		result[0][1] = m[1][0];
 		result[0][2] = m[2][0];
 		result[0][3] = m[3][0];
-        result[1][0] = m[0][1];
-        result[1][1] = m[1][1];
+		result[1][0] = m[0][1];
+		result[1][1] = m[1][1];
 		result[1][2] = m[2][1];
 		result[1][3] = m[3][1];
-        result[2][0] = m[0][2];
-        result[2][1] = m[1][2];
+		result[2][0] = m[0][2];
+		result[2][1] = m[1][2];
 		result[2][2] = m[2][2];
 		result[2][3] = m[3][2];
 		return result;
 	}
 
-    template <typename T>
+	template <typename T>
 	GLM_FUNC_QUALIFIER detail::tmat4x3<T> transpose
 	(
 		detail::tmat3x4<T> const & m
@@ -382,20 +381,20 @@ namespace core
 	{
 		GLM_STATIC_ASSERT(detail::type<T>::is_float, "'transpose' only accept floating-point inputs");
 
-        detail::tmat4x3<T> result(detail::tmat4x3<T>::null);
-        result[0][0] = m[0][0];
-        result[0][1] = m[1][0];
+		detail::tmat4x3<T> result(detail::tmat4x3<T>::null);
+		result[0][0] = m[0][0];
+		result[0][1] = m[1][0];
 		result[0][2] = m[2][0];
-        result[1][0] = m[0][1];
-        result[1][1] = m[1][1];
+		result[1][0] = m[0][1];
+		result[1][1] = m[1][1];
 		result[1][2] = m[2][1];
-        result[2][0] = m[0][2];
-        result[2][1] = m[1][2];
+		result[2][0] = m[0][2];
+		result[2][1] = m[1][2];
 		result[2][2] = m[2][2];
-        result[3][0] = m[0][3];
-        result[3][1] = m[1][3];
+		result[3][0] = m[0][3];
+		result[3][1] = m[1][3];
 		result[3][2] = m[2][3];
-        return result;
+		return result;
 	}
 
 	template <typename T>
@@ -445,9 +444,9 @@ namespace core
 			- (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05));
 
 		return m[0][0] * DetCof[0]
-			 + m[0][1] * DetCof[1]
-			 + m[0][2] * DetCof[2]
-			 + m[0][3] * DetCof[3];
+				+ m[0][1] * DetCof[1]
+				+ m[0][2] * DetCof[2]
+				+ m[0][3] * DetCof[3];
 	}
 
 	template <typename T> 
@@ -561,6 +560,4 @@ namespace core
 	    
 		return Inverse;
 	}
-
-}//namespace core
 }//namespace glm

glm/core/func_noise.hpp

@@ -10,10 +10,9 @@
 #ifndef glm_core_func_noise
 #define glm_core_func_noise
 
-namespace glm{
-namespace core
+namespace glm
 {
-	/// \addtogroup core_funcs
+	/// @addtogroup core_funcs
 	/// @{
 
 	//! Returns a 1D noise value based on the input value x.
@@ -45,7 +44,6 @@ namespace core
 	detail::tvec4<typename genType::value_type> noise4(genType const & x);
 
 	/// @}
-}//namespace core
 }//namespace glm
 
 #include "func_noise.inl"

glm/core/func_packing.hpp

@@ -10,11 +10,10 @@
 #ifndef glm_core_func_packing
 #define glm_core_func_packing
 
-namespace glm{
-namespace core
+namespace glm
 {
-	/// \addtogroup core_funcs
-	///@{
+	/// @addtogroup core_funcs
+	/// @{
 
     //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
     //! Then, the results are packed into the returned 32-bit unsigned integer.
@@ -114,7 +113,6 @@ namespace core
 	detail::tvec2<detail::uint32> unpackDouble2x32(double const & v);
 
 	/// @}
-}//namespace core
 }//namespace glm
 
 #include "func_packing.inl"

glm/core/func_packing.inl

@@ -8,77 +8,75 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace core
+
+GLM_FUNC_QUALIFIER detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v)
 {
-		GLM_FUNC_QUALIFIER detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v)
-		{
-			detail::uint16 A((detail::uint16)round(clamp(v.x, 0.0f, 1.0f) * 65535.0f));
-			detail::uint16 B((detail::uint16)round(clamp(v.y, 0.0f, 1.0f) * 65535.0f));
-			return detail::uint32((B << 16) | A);
-		}
+	detail::uint16 A((detail::uint16)round(clamp(v.x, 0.0f, 1.0f) * 65535.0f));
+	detail::uint16 B((detail::uint16)round(clamp(v.y, 0.0f, 1.0f) * 65535.0f));
+	return detail::uint32((B << 16) | A);
+}
 
-		GLM_FUNC_QUALIFIER detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v)
-		{
-			 detail::uint8 A((detail::uint8)round(clamp(v.x, 0.0f, 1.0f) * 255.0f));
-			 detail::uint8 B((detail::uint8)round(clamp(v.y, 0.0f, 1.0f) * 255.0f));
-			 detail::uint8 C((detail::uint8)round(clamp(v.z, 0.0f, 1.0f) * 255.0f));
-			 detail::uint8 D((detail::uint8)round(clamp(v.w, 0.0f, 1.0f) * 255.0f));
-			 return detail::uint32((D << 24) | (C << 16) | (B << 8) | A);
-		}
+GLM_FUNC_QUALIFIER detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v)
+{
+		detail::uint8 A((detail::uint8)round(clamp(v.x, 0.0f, 1.0f) * 255.0f));
+		detail::uint8 B((detail::uint8)round(clamp(v.y, 0.0f, 1.0f) * 255.0f));
+		detail::uint8 C((detail::uint8)round(clamp(v.z, 0.0f, 1.0f) * 255.0f));
+		detail::uint8 D((detail::uint8)round(clamp(v.w, 0.0f, 1.0f) * 255.0f));
+		return detail::uint32((D << 24) | (C << 16) | (B << 8) | A);
+}
 
-		GLM_FUNC_QUALIFIER detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v)
-		{
-			 detail::uint8 A((detail::uint8)round(clamp(v.x,-1.0f, 1.0f) * 255.0f));
-			 detail::uint8 B((detail::uint8)round(clamp(v.y,-1.0f, 1.0f) * 255.0f));
-			 detail::uint8 C((detail::uint8)round(clamp(v.z,-1.0f, 1.0f) * 255.0f));
-			 detail::uint8 D((detail::uint8)round(clamp(v.w,-1.0f, 1.0f) * 255.0f));
-			 return detail::uint32((D << 24) | (C << 16) | (B << 8) | A);
-		}
+GLM_FUNC_QUALIFIER detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v)
+{
+		detail::uint8 A((detail::uint8)round(clamp(v.x,-1.0f, 1.0f) * 255.0f));
+		detail::uint8 B((detail::uint8)round(clamp(v.y,-1.0f, 1.0f) * 255.0f));
+		detail::uint8 C((detail::uint8)round(clamp(v.z,-1.0f, 1.0f) * 255.0f));
+		detail::uint8 D((detail::uint8)round(clamp(v.w,-1.0f, 1.0f) * 255.0f));
+		return detail::uint32((D << 24) | (C << 16) | (B << 8) | A);
+}
 
-		GLM_FUNC_QUALIFIER detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p)
-		{
-			detail::uint16 A(detail::uint16(p >> 0));
-			detail::uint16 B(detail::uint16(p >> 16));
-			return detail::tvec2<detail::float32>(
-				A * 1.0f / 65535.0f, 
-				B * 1.0f / 65535.0f);
-		}
+GLM_FUNC_QUALIFIER detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p)
+{
+	detail::uint16 A(detail::uint16(p >> 0));
+	detail::uint16 B(detail::uint16(p >> 16));
+	return detail::tvec2<detail::float32>(
+		A * 1.0f / 65535.0f, 
+		B * 1.0f / 65535.0f);
+}
 
-		GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p)
-		{
-			detail::uint8 A(detail::uint8(p >> 0));
-			detail::uint8 B(detail::uint8(p >> 8));
-			detail::uint8 C(detail::uint8(p >> 16));
-			detail::uint8 D(detail::uint8(p >> 24));
-			return detail::tvec4<detail::float32>(
-				A * 1.0f / 255.0f, 
-				B * 1.0f / 255.0f,
-				C * 1.0f / 255.0f,
-				D * 1.0f / 255.0f);
-		}
+GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p)
+{
+	detail::uint8 A(detail::uint8(p >> 0));
+	detail::uint8 B(detail::uint8(p >> 8));
+	detail::uint8 C(detail::uint8(p >> 16));
+	detail::uint8 D(detail::uint8(p >> 24));
+	return detail::tvec4<detail::float32>(
+		A * 1.0f / 255.0f, 
+		B * 1.0f / 255.0f,
+		C * 1.0f / 255.0f,
+		D * 1.0f / 255.0f);
+}
 
-		GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p)
-		{
-			detail::uint8 A(detail::uint8(p >> 0));
-			detail::uint8 B(detail::uint8(p >> 8));
-			detail::uint8 C(detail::uint8(p >> 16));
-			detail::uint8 D(detail::uint8(p >> 24));
-			return clamp(detail::tvec4<detail::float32>(
-				A * 1.0f / 127.0f, 
-				B * 1.0f / 127.0f,
-				C * 1.0f / 127.0f,
-				D * 1.0f / 127.0f), -1.0f, 1.0f);
-		}
+GLM_FUNC_QUALIFIER detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p)
+{
+	detail::uint8 A(detail::uint8(p >> 0));
+	detail::uint8 B(detail::uint8(p >> 8));
+	detail::uint8 C(detail::uint8(p >> 16));
+	detail::uint8 D(detail::uint8(p >> 24));
+	return clamp(detail::tvec4<detail::float32>(
+		A * 1.0f / 127.0f, 
+		B * 1.0f / 127.0f,
+		C * 1.0f / 127.0f,
+		D * 1.0f / 127.0f), -1.0f, 1.0f);
+}
 
-		GLM_FUNC_QUALIFIER double packDouble2x32(detail::tvec2<detail::uint32> const & v)
-		{
-			return *(double*)&v;
-		}
+GLM_FUNC_QUALIFIER double packDouble2x32(detail::tvec2<detail::uint32> const & v)
+{
+	return *(double*)&v;
+}
 
-		GLM_FUNC_QUALIFIER detail::tvec2<detail::uint32> unpackDouble2x32(double const & v)
-		{
-			return *(detail::tvec2<detail::uint32>*)&v;
-		}
+GLM_FUNC_QUALIFIER detail::tvec2<detail::uint32> unpackDouble2x32(double const & v)
+{
+	return *(detail::tvec2<detail::uint32>*)&v;
+}
 
-}//namespace core
 }//namespace glm

glm/core/func_trigonometric.hpp

@@ -10,10 +10,9 @@
 #ifndef glm_core_func_trigonometric
 #define glm_core_func_trigonometric
 
-namespace glm{
-namespace core
+namespace glm
 {
-	/// \addtogroup core_funcs
+	/// @addtogroup core_funcs
 	/// @{
 
 	//! Converts degrees to radians and returns the result.
@@ -135,7 +134,6 @@ namespace core
 	genType atanh(genType const & x);
 
 	/// @}
-}//namespace core
 }//namespace glm
 
 #include "func_trigonometric.inl"

glm/core/func_trigonometric.inl

@@ -8,733 +8,731 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace core
-{
-    // radians
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType radians
-	(
-		genType const & degrees
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'radians' only accept floating-point input");
-
-        const genType pi = genType(3.1415926535897932384626433832795);
-        return degrees * (pi / genType(180));
-    }
-
-    template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> radians
-	(
-		detail::tvec2<T> const & degrees
-	)
-    {
-        return detail::tvec2<T>(
-            radians(degrees.x),
-            radians(degrees.y));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> radians
-	(
-		detail::tvec3<T> const & degrees
-	)
-    {
-        return detail::tvec3<T>(
-            radians(degrees.x),
-            radians(degrees.y),
-            radians(degrees.z));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> radians
-	(
-		detail::tvec4<T> const & degrees
-	)
-    {
-        return detail::tvec4<T>(
-            radians(degrees.x),
-            radians(degrees.y),
-            radians(degrees.z),
-            radians(degrees.w));
-    }
-
-    // degrees
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType degrees
-	(
-		genType const & radians
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'degrees' only accept floating-point input");
-
-        const genType pi = genType(3.1415926535897932384626433832795);
-        return radians * (genType(180) / pi);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> degrees
-	(
-		detail::tvec2<T> const & radians
-	)
-    {
-        return detail::tvec2<T>(
-            degrees(radians.x),
-            degrees(radians.y));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> degrees
-	(	
-		detail::tvec3<T> const & radians
-	)
-    {
-        return detail::tvec3<T>(
-            degrees(radians.x),
-            degrees(radians.y),
-            degrees(radians.z));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> degrees
-	(
-		detail::tvec4<T> const & radians
-	)
-    {
-        return detail::tvec4<T>(
-            degrees(radians.x),
-            degrees(radians.y),
-            degrees(radians.z),
-            degrees(radians.w));
-    }
-
-    // sin
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType sin
-	(
-		genType const & angle
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sin' only accept floating-point input");
-
-		return ::std::sin(angle);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> sin
-	(
-		detail::tvec2<T> const & angle
-	)
-    {
-        return detail::tvec2<T>(
-            sin(angle.x),
-            sin(angle.y));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> sin
-	(
-		detail::tvec3<T> const & angle
-	)
-    {
-        return detail::tvec3<T>(
-            sin(angle.x),
-            sin(angle.y),
-            sin(angle.z));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> sin
-	(
-		detail::tvec4<T> const & angle
-	)
-    {
-        return detail::tvec4<T>(
-            sin(angle.x),
-            sin(angle.y),
-            sin(angle.z),
-            sin(angle.w));
-    }
-
-    // cos
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType cos(genType const & angle)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cos' only accept floating-point input");
-
-        return ::std::cos(angle);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> cos
-	(
-		detail::tvec2<T> const & angle
-	)
-    {
-        return detail::tvec2<T>(
-            cos(angle.x),
-            cos(angle.y));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> cos
-	(
-		detail::tvec3<T> const & angle
-	)
-    {
-        return detail::tvec3<T>(
-            cos(angle.x),
-            cos(angle.y),
-            cos(angle.z));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> cos
-	(	
-		detail::tvec4<T> const & angle
-	)
-    {
-        return detail::tvec4<T>(
-            cos(angle.x),
-            cos(angle.y),
-            cos(angle.z),
-            cos(angle.w));
-    }
-
-    // tan
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType tan
-	(
-		genType const & angle
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'tan' only accept floating-point input");
-
-        return ::std::tan(angle);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> tan
-	(
-		detail::tvec2<T> const & angle
-	)
-    {
-        return detail::tvec2<T>(
-            tan(angle.x),
-            tan(angle.y));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> tan
-	(
-		detail::tvec3<T> const & angle
-	)
-    {
-        return detail::tvec3<T>(
-            tan(angle.x),
-            tan(angle.y),
-            tan(angle.z));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> tan
-	(
-		detail::tvec4<T> const & angle
-	)
-    {
-        return detail::tvec4<T>(
-            tan(angle.x),
-            tan(angle.y),
-            tan(angle.z),
-            tan(angle.w));
-    }
-
-    // asin
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType asin
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asin' only accept floating-point input");
-
-        return ::std::asin(x);
-    }
-
-    template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> asin
-	(
-		detail::tvec2<T> const & x
-	)
-    {
-        return detail::tvec2<T>(
-            asin(x.x),
-            asin(x.y));
-    }
-
-    template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> asin
-	(
-		detail::tvec3<T> const & x
-	)
-    {
-        return detail::tvec3<T>(
-            asin(x.x),
-            asin(x.y),
-            asin(x.z));
-    }
-
-    template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> asin
-	(
-		detail::tvec4<T> const & x
-	)
-    {
-        return detail::tvec4<T>(
-            asin(x.x),
-            asin(x.y),
-            asin(x.z),
-            asin(x.w));
-    }
-
-    // acos
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType acos
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acos' only accept floating-point input");
-
-        return ::std::acos(x);
-    }
-
-    template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec2<T> acos
-	(
-		detail::tvec2<T> const & x
-	)
-    {
-        return detail::tvec2<T>(
-            acos(x.x),
-            acos(x.y));
-    }
-
-    template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> acos
-	(
-		detail::tvec3<T> const & x
-	)
-    {
-        return detail::tvec3<T>(
-            acos(x.x),
-            acos(x.y),
-            acos(x.z));
-    }
-
-    template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> acos
-	(
-		detail::tvec4<T> const & x
-	)
-    {
-        return detail::tvec4<T>(
-            acos(x.x),
-            acos(x.y),
-            acos(x.z),
-            acos(x.w));
-    }
-
-    // atan
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType atan
-	(
-		genType const & y, 
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atan' only accept floating-point input");
-
-        return ::std::atan2(y, x);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> atan
-	(
-		detail::tvec2<T> const & y, 
-		detail::tvec2<T> const & x
-	)
-    {
-        return detail::tvec2<T>(
-            atan(y.x, x.x),
-            atan(y.y, x.y));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> atan
-	(
-		detail::tvec3<T> const & y, 
-		detail::tvec3<T> const & x
-	)
-    {
-        return detail::tvec3<T>(
-            atan(y.x, x.x),
-            atan(y.y, x.y),
-            atan(y.z, x.z));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> atan
-	(
-		detail::tvec4<T> const & y, 
-		detail::tvec4<T> const & x
-	)
-    {
-        return detail::tvec4<T>(
-            atan(y.x, x.x),
-            atan(y.y, x.y),
-            atan(y.z, x.z),
-            atan(y.w, x.w));
-    }
-
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType atan
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atan' only accept floating-point input");
-
-        return ::std::atan(x);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> atan
-	(
-		detail::tvec2<T> const & x
-	)
-    {
-        return detail::tvec2<T>(
-            atan(x.x),
-            atan(x.y));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> atan
-	(
-		detail::tvec3<T> const & x
-	)
-    {
-        return detail::tvec3<T>(
-            atan(x.x),
-            atan(x.y),
-            atan(x.z));
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> atan
-	(
-		detail::tvec4<T> const & x
-	)
-    {
-        return detail::tvec4<T>(
-            atan(x.x),
-            atan(x.y),
-            atan(x.z),
-            atan(x.w));
-    }
-
-    // sinh
-    template <typename genType> 
-    GLM_FUNC_QUALIFIER genType sinh
-	(
-		genType const & angle
-	)
-    {
-        GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sinh' only accept floating-point input");
-
-		return std::sinh(angle);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec2<T> sinh
-	(
-		detail::tvec2<T> const & angle
-	)
-    {
-        return detail::tvec2<T>(
-            sinh(angle.x),
-            sinh(angle.y));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> sinh
-	(
-		detail::tvec3<T> const & angle
-	)
-    {
-        return detail::tvec3<T>(
-            sinh(angle.x),
-            sinh(angle.y),
-            sinh(angle.z));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec4<T> sinh
-	(
-		detail::tvec4<T> const & angle
-	)
-    {
-        return detail::tvec4<T>(
-            sinh(angle.x),
-            sinh(angle.y),
-            sinh(angle.z),
-            sinh(angle.w));
-    }
-
-    // cosh
-    template <typename genType> 
-    GLM_FUNC_QUALIFIER genType cosh
-	(
-		genType const & angle
-	)
-    {
-        GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cosh' only accept floating-point input");
-
-		return std::cosh(angle);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec2<T> cosh
-	(
-		detail::tvec2<T> const & angle
-	)
-    {
-        return detail::tvec2<T>(
-            cosh(angle.x),
-            cosh(angle.y));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> cosh
-	(
-		detail::tvec3<T> const & angle
-	)
-    {
-        return detail::tvec3<T>(
-            cosh(angle.x),
-            cosh(angle.y),
-            cosh(angle.z));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec4<T> cosh
-	(
-		detail::tvec4<T> const & angle
-	)
-    {
-        return detail::tvec4<T>(
-            cosh(angle.x),
-            cosh(angle.y),
-            cosh(angle.z),
-            cosh(angle.w));
-    }
-
-    // tanh
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType tanh
-	(
-		genType const & angle
-	)
-    {
-        GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'tanh' only accept floating-point input");
-
-		return std::tanh(angle);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec2<T> tanh
-	(
-		detail::tvec2<T> const & angle
-	)
-    {
-        return detail::tvec2<T>(
-            tanh(angle.x),
-            tanh(angle.y));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> tanh
-	(
-		detail::tvec3<T> const & angle
-	)
-    {
-        return detail::tvec3<T>(
-            tanh(angle.x),
-            tanh(angle.y),
-            tanh(angle.z));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec4<T> tanh
-	(
-		detail::tvec4<T> const & angle
-	)
-    {
-        return detail::tvec4<T>(
-            tanh(angle.x),
-            tanh(angle.y),
-            tanh(angle.z),
-            tanh(angle.w));
-    }
-
-    // asinh
-    template <typename genType> 
-    GLM_FUNC_QUALIFIER genType asinh
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asinh' only accept floating-point input");
+
+// radians
+template <typename genType>
+GLM_FUNC_QUALIFIER genType radians
+(
+	genType const & degrees
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'radians' only accept floating-point input");
+
+    const genType pi = genType(3.1415926535897932384626433832795);
+    return degrees * (pi / genType(180));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> radians
+(
+	detail::tvec2<T> const & degrees
+)
+{
+    return detail::tvec2<T>(
+        radians(degrees.x),
+        radians(degrees.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> radians
+(
+	detail::tvec3<T> const & degrees
+)
+{
+    return detail::tvec3<T>(
+        radians(degrees.x),
+        radians(degrees.y),
+        radians(degrees.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> radians
+(
+	detail::tvec4<T> const & degrees
+)
+{
+    return detail::tvec4<T>(
+        radians(degrees.x),
+        radians(degrees.y),
+        radians(degrees.z),
+        radians(degrees.w));
+}
+
+// degrees
+template <typename genType>
+GLM_FUNC_QUALIFIER genType degrees
+(
+	genType const & radians
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'degrees' only accept floating-point input");
+
+    const genType pi = genType(3.1415926535897932384626433832795);
+    return radians * (genType(180) / pi);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> degrees
+(
+	detail::tvec2<T> const & radians
+)
+{
+    return detail::tvec2<T>(
+        degrees(radians.x),
+        degrees(radians.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> degrees
+(	
+	detail::tvec3<T> const & radians
+)
+{
+    return detail::tvec3<T>(
+        degrees(radians.x),
+        degrees(radians.y),
+        degrees(radians.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> degrees
+(
+	detail::tvec4<T> const & radians
+)
+{
+    return detail::tvec4<T>(
+        degrees(radians.x),
+        degrees(radians.y),
+        degrees(radians.z),
+        degrees(radians.w));
+}
+
+// sin
+template <typename genType>
+GLM_FUNC_QUALIFIER genType sin
+(
+	genType const & angle
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sin' only accept floating-point input");
+
+	return ::std::sin(angle);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> sin
+(
+	detail::tvec2<T> const & angle
+)
+{
+    return detail::tvec2<T>(
+        sin(angle.x),
+        sin(angle.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> sin
+(
+	detail::tvec3<T> const & angle
+)
+{
+    return detail::tvec3<T>(
+        sin(angle.x),
+        sin(angle.y),
+        sin(angle.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> sin
+(
+	detail::tvec4<T> const & angle
+)
+{
+    return detail::tvec4<T>(
+        sin(angle.x),
+        sin(angle.y),
+        sin(angle.z),
+        sin(angle.w));
+}
+
+// cos
+template <typename genType>
+GLM_FUNC_QUALIFIER genType cos(genType const & angle)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cos' only accept floating-point input");
+
+    return ::std::cos(angle);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> cos
+(
+	detail::tvec2<T> const & angle
+)
+{
+    return detail::tvec2<T>(
+        cos(angle.x),
+        cos(angle.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> cos
+(
+	detail::tvec3<T> const & angle
+)
+{
+    return detail::tvec3<T>(
+        cos(angle.x),
+        cos(angle.y),
+        cos(angle.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> cos
+(	
+	detail::tvec4<T> const & angle
+)
+{
+    return detail::tvec4<T>(
+        cos(angle.x),
+        cos(angle.y),
+        cos(angle.z),
+        cos(angle.w));
+}
+
+// tan
+template <typename genType>
+GLM_FUNC_QUALIFIER genType tan
+(
+	genType const & angle
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'tan' only accept floating-point input");
+
+    return ::std::tan(angle);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> tan
+(
+	detail::tvec2<T> const & angle
+)
+{
+    return detail::tvec2<T>(
+        tan(angle.x),
+        tan(angle.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> tan
+(
+	detail::tvec3<T> const & angle
+)
+{
+    return detail::tvec3<T>(
+        tan(angle.x),
+        tan(angle.y),
+        tan(angle.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> tan
+(
+	detail::tvec4<T> const & angle
+)
+{
+    return detail::tvec4<T>(
+        tan(angle.x),
+        tan(angle.y),
+        tan(angle.z),
+        tan(angle.w));
+}
+
+// asin
+template <typename genType>
+GLM_FUNC_QUALIFIER genType asin
+(
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asin' only accept floating-point input");
+
+    return ::std::asin(x);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> asin
+(
+	detail::tvec2<T> const & x
+)
+{
+    return detail::tvec2<T>(
+        asin(x.x),
+        asin(x.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> asin
+(
+	detail::tvec3<T> const & x
+)
+{
+    return detail::tvec3<T>(
+        asin(x.x),
+        asin(x.y),
+        asin(x.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> asin
+(
+	detail::tvec4<T> const & x
+)
+{
+    return detail::tvec4<T>(
+        asin(x.x),
+        asin(x.y),
+        asin(x.z),
+        asin(x.w));
+}
+
+// acos
+template <typename genType>
+GLM_FUNC_QUALIFIER genType acos
+(
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acos' only accept floating-point input");
+
+    return ::std::acos(x);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> acos
+(
+	detail::tvec2<T> const & x
+)
+{
+    return detail::tvec2<T>(
+        acos(x.x),
+        acos(x.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> acos
+(
+	detail::tvec3<T> const & x
+)
+{
+    return detail::tvec3<T>(
+        acos(x.x),
+        acos(x.y),
+        acos(x.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> acos
+(
+	detail::tvec4<T> const & x
+)
+{
+    return detail::tvec4<T>(
+        acos(x.x),
+        acos(x.y),
+        acos(x.z),
+        acos(x.w));
+}
+
+// atan
+template <typename genType>
+GLM_FUNC_QUALIFIER genType atan
+(
+	genType const & y, 
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atan' only accept floating-point input");
+
+    return ::std::atan2(y, x);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> atan
+(
+	detail::tvec2<T> const & y, 
+	detail::tvec2<T> const & x
+)
+{
+    return detail::tvec2<T>(
+        atan(y.x, x.x),
+        atan(y.y, x.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> atan
+(
+	detail::tvec3<T> const & y, 
+	detail::tvec3<T> const & x
+)
+{
+    return detail::tvec3<T>(
+        atan(y.x, x.x),
+        atan(y.y, x.y),
+        atan(y.z, x.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> atan
+(
+	detail::tvec4<T> const & y, 
+	detail::tvec4<T> const & x
+)
+{
+    return detail::tvec4<T>(
+        atan(y.x, x.x),
+        atan(y.y, x.y),
+        atan(y.z, x.z),
+        atan(y.w, x.w));
+}
+
+template <typename genType>
+GLM_FUNC_QUALIFIER genType atan
+(
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atan' only accept floating-point input");
+
+    return ::std::atan(x);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> atan
+(
+	detail::tvec2<T> const & x
+)
+{
+    return detail::tvec2<T>(
+        atan(x.x),
+        atan(x.y));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> atan
+(
+	detail::tvec3<T> const & x
+)
+{
+    return detail::tvec3<T>(
+        atan(x.x),
+        atan(x.y),
+        atan(x.z));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> atan
+(
+	detail::tvec4<T> const & x
+)
+{
+    return detail::tvec4<T>(
+        atan(x.x),
+        atan(x.y),
+        atan(x.z),
+        atan(x.w));
+}
+
+// sinh
+template <typename genType> 
+GLM_FUNC_QUALIFIER genType sinh
+(
+	genType const & angle
+)
+{
+    GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'sinh' only accept floating-point input");
+
+	return std::sinh(angle);
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> sinh
+(
+	detail::tvec2<T> const & angle
+)
+{
+    return detail::tvec2<T>(
+        sinh(angle.x),
+        sinh(angle.y));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> sinh
+(
+	detail::tvec3<T> const & angle
+)
+{
+    return detail::tvec3<T>(
+        sinh(angle.x),
+        sinh(angle.y),
+        sinh(angle.z));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> sinh
+(
+	detail::tvec4<T> const & angle
+)
+{
+    return detail::tvec4<T>(
+        sinh(angle.x),
+        sinh(angle.y),
+        sinh(angle.z),
+        sinh(angle.w));
+}
+
+// cosh
+template <typename genType> 
+GLM_FUNC_QUALIFIER genType cosh
+(
+	genType const & angle
+)
+{
+    GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'cosh' only accept floating-point input");
+
+	return std::cosh(angle);
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> cosh
+(
+	detail::tvec2<T> const & angle
+)
+{
+    return detail::tvec2<T>(
+        cosh(angle.x),
+        cosh(angle.y));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> cosh
+(
+	detail::tvec3<T> const & angle
+)
+{
+    return detail::tvec3<T>(
+        cosh(angle.x),
+        cosh(angle.y),
+        cosh(angle.z));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> cosh
+(
+	detail::tvec4<T> const & angle
+)
+{
+    return detail::tvec4<T>(
+        cosh(angle.x),
+        cosh(angle.y),
+        cosh(angle.z),
+        cosh(angle.w));
+}
+
+// tanh
+template <typename genType>
+GLM_FUNC_QUALIFIER genType tanh
+(
+	genType const & angle
+)
+{
+    GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'tanh' only accept floating-point input");
+
+	return std::tanh(angle);
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> tanh
+(
+	detail::tvec2<T> const & angle
+)
+{
+    return detail::tvec2<T>(
+        tanh(angle.x),
+        tanh(angle.y));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> tanh
+(
+	detail::tvec3<T> const & angle
+)
+{
+    return detail::tvec3<T>(
+        tanh(angle.x),
+        tanh(angle.y),
+        tanh(angle.z));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> tanh
+(
+	detail::tvec4<T> const & angle
+)
+{
+    return detail::tvec4<T>(
+        tanh(angle.x),
+        tanh(angle.y),
+        tanh(angle.z),
+        tanh(angle.w));
+}
+
+// asinh
+template <typename genType> 
+GLM_FUNC_QUALIFIER genType asinh
+(
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'asinh' only accept floating-point input");
 		
-		return (x < genType(0) ? genType(-1) : (x > genType(0) ? genType(1) : genType(0))) * log(abs(x) + sqrt(genType(1) + x * x));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec2<T> asinh
-	(
-		detail::tvec2<T> const & x
-	)
-    {
-        return detail::tvec2<T>(
-            asinh(x.x),
-            asinh(x.y));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> asinh
-	(
-		detail::tvec3<T> const & x
-	)
-    {
-        return detail::tvec3<T>(
-            asinh(x.x),
-            asinh(x.y),
-            asinh(x.z));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec4<T> asinh
-	(
-		detail::tvec4<T> const & x
-	)
-    {
-        return detail::tvec4<T>(
-            asinh(x.x),
-            asinh(x.y),
-            asinh(x.z),
-            asinh(x.w));
-    }
-
-    // acosh
-    template <typename genType> 
-    GLM_FUNC_QUALIFIER genType acosh
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acosh' only accept floating-point input");
-
-		if(x < genType(1))
-			return genType(0);
-		return log(x + sqrt(x * x - genType(1)));
-    }
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec2<T> acosh
-	(
-		detail::tvec2<T> const & x
-	)
-	{
-		return detail::tvec2<T>(
-			acosh(x.x),
-			acosh(x.y));
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> acosh
-	(
-		detail::tvec3<T> const & x
-	)
-    {
-        return detail::tvec3<T>(
-            acosh(x.x),
-            acosh(x.y),
-            acosh(x.z));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec4<T> acosh
-	(
-		detail::tvec4<T> const & x
-	)
-    {
-        return detail::tvec4<T>(
-            acosh(x.x),
-            acosh(x.y),
-            acosh(x.z),
-            acosh(x.w));
-    }
-
-    // atanh
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType atanh
-	(
-		genType const & x
-	)
-    {
-		GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atanh' only accept floating-point input");
+	return (x < genType(0) ? genType(-1) : (x > genType(0) ? genType(1) : genType(0))) * log(abs(x) + sqrt(genType(1) + x * x));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> asinh
+(
+	detail::tvec2<T> const & x
+)
+{
+    return detail::tvec2<T>(
+        asinh(x.x),
+        asinh(x.y));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> asinh
+(
+	detail::tvec3<T> const & x
+)
+{
+    return detail::tvec3<T>(
+        asinh(x.x),
+        asinh(x.y),
+        asinh(x.z));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> asinh
+(
+	detail::tvec4<T> const & x
+)
+{
+    return detail::tvec4<T>(
+        asinh(x.x),
+        asinh(x.y),
+        asinh(x.z),
+        asinh(x.w));
+}
+
+// acosh
+template <typename genType> 
+GLM_FUNC_QUALIFIER genType acosh
+(
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'acosh' only accept floating-point input");
+
+	if(x < genType(1))
+		return genType(0);
+	return log(x + sqrt(x * x - genType(1)));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> acosh
+(
+	detail::tvec2<T> const & x
+)
+{
+	return detail::tvec2<T>(
+		acosh(x.x),
+		acosh(x.y));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> acosh
+(
+	detail::tvec3<T> const & x
+)
+{
+    return detail::tvec3<T>(
+        acosh(x.x),
+        acosh(x.y),
+        acosh(x.z));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> acosh
+(
+	detail::tvec4<T> const & x
+)
+{
+    return detail::tvec4<T>(
+        acosh(x.x),
+        acosh(x.y),
+        acosh(x.z),
+        acosh(x.w));
+}
+
+// atanh
+template <typename genType>
+GLM_FUNC_QUALIFIER genType atanh
+(
+	genType const & x
+)
+{
+	GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'atanh' only accept floating-point input");
 		
-		if(abs(x) >= genType(1))
-			return 0;
-		return genType(0.5) * log((genType(1) + x) / (genType(1) - x));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec2<T> atanh
-	(
-		detail::tvec2<T> const & x
-	)
-    {
-        return detail::tvec2<T>(
-            atanh(x.x),
-            atanh(x.y));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> atanh
-	(
-		detail::tvec3<T> const & x
-	)
-    {
-        return detail::tvec3<T>(
-            atanh(x.x),
-            atanh(x.y),
-            atanh(x.z));
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec4<T> atanh
-	(
-		detail::tvec4<T> const & x
-	)
-    {
-        return detail::tvec4<T>(
-            atanh(x.x),
-            atanh(x.y),
-            atanh(x.z),
-            atanh(x.w));
-    }
-
-}//namespace core
+	if(abs(x) >= genType(1))
+		return 0;
+	return genType(0.5) * log((genType(1) + x) / (genType(1) - x));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> atanh
+(
+	detail::tvec2<T> const & x
+)
+{
+    return detail::tvec2<T>(
+        atanh(x.x),
+        atanh(x.y));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> atanh
+(
+	detail::tvec3<T> const & x
+)
+{
+    return detail::tvec3<T>(
+        atanh(x.x),
+        atanh(x.y),
+        atanh(x.z));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> atanh
+(
+	detail::tvec4<T> const & x
+)
+{
+    return detail::tvec4<T>(
+        atanh(x.x),
+        atanh(x.y),
+        atanh(x.z),
+        atanh(x.w));
+}
+
 }//namespace glm

glm/core/func_vector_relational.hpp

@@ -12,10 +12,9 @@
 
 #include "_detail.hpp"
 
-namespace glm{
-namespace core
+namespace glm
 {
-	/// \addtogroup core_funcs
+	/// @addtogroup core_funcs
 	/// @{
 
 	//! Returns the component-wise comparison result of x < y.
@@ -197,7 +196,6 @@ namespace core
 	}
 
 	/// @}
-}//namespace core
 }//namespace glm
 
 #include "func_vector_relational.inl"

glm/core/hint.hpp

@@ -16,6 +16,6 @@ namespace glm
 	class dont_care {};
 	class nicest {};
 	class fastest {};
-};
+}//namespace glm
 
 #endif//glm_core_type

glm/glm.hpp

@@ -43,16 +43,6 @@
 #	pragma message("GLM: Core library included")
 #endif//GLM_MESSAGE
 
-namespace glm
-{
-	namespace gtc{}
-	namespace gtx{}
-	namespace virtrev{}
-	
-	using namespace gtc;
-	using namespace gtx;
-}//namespace glm
-
 #include "./core/_detail.hpp"
 #include "./core/type.hpp"
 

glm/gtc/half_float.hpp

@@ -349,8 +349,6 @@ namespace detail
 }
 //namespace detail
 
-namespace gtc
-{
 	/// @addtogroup gtc_half_float
 	/// @{
 
@@ -419,7 +417,6 @@ namespace gtc
 	typedef detail::tmat4x4<detail::thalf>	hmat4x4;
     
 	/// @}
-}// namespace gtc
 }// namespace glm
 
 #include "half_float.inl"

glm/gtc/matrix_access.hpp

@@ -44,9 +44,8 @@
 #	pragma message("GLM: GLM_GTC_matrix_access extension included")
 #endif
 
-namespace glm{
-namespace gtc{
-    
+namespace glm
+{
 	/// @addtogroup gtc_matrix_access
 	/// @{
 
@@ -81,7 +80,6 @@ namespace gtc{
 		typename genType::col_type const & x);
 
 	/// @}
-}//namespace gtc
 }//namespace glm
 
 #include "matrix_access.inl"

glm/gtc/matrix_access.inl

@@ -8,50 +8,48 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtc
+
+template <typename genType>
+GLM_FUNC_QUALIFIER genType row(
+	genType const & m, 
+	int index, 
+	typename genType::row_type const & x)
 {
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType row(
-		genType const & m, 
-		int index, 
-		typename genType::row_type const & x)
-    {
-        genType Result = m;
-        for(typename genType::size_type i = 0; i < genType::row_size(); ++i)
-			Result[i][index] = x[i];
-        return Result;
-    }
+    genType Result = m;
+    for(typename genType::size_type i = 0; i < genType::row_size(); ++i)
+		Result[i][index] = x[i];
+    return Result;
+}
 
-    template <typename genType>
-    GLM_FUNC_QUALIFIER typename genType::row_type row(
-		genType const & m, 
-		int index)
-    {
-		typename genType::row_type Result;
-		for(typename genType::size_type i = 0; i < genType::row_size(); ++i)
-			Result[i] = m[i][index];
-		return Result;
-    }
+template <typename genType>
+GLM_FUNC_QUALIFIER typename genType::row_type row(
+	genType const & m, 
+	int index)
+{
+	typename genType::row_type Result;
+	for(typename genType::size_type i = 0; i < genType::row_size(); ++i)
+		Result[i] = m[i][index];
+	return Result;
+}
 
-    template <typename genType>
-    GLM_FUNC_QUALIFIER genType column(
-		genType const & m, 
-		int index, 
-		typename genType::col_type const & x)
-    {
-        genType Result = m;
-        Result[index] = x;
-        return Result;
-    }
+template <typename genType>
+GLM_FUNC_QUALIFIER genType column(
+	genType const & m, 
+	int index, 
+	typename genType::col_type const & x)
+{
+    genType Result = m;
+    Result[index] = x;
+    return Result;
+}
 
-    template <typename genType>
-    GLM_FUNC_QUALIFIER typename genType::col_type column(
-		genType const & m, 
-		int index)
-    {
-        return m[index];
-    }
+template <typename genType>
+GLM_FUNC_QUALIFIER typename genType::col_type column(
+	genType const & m, 
+	int index)
+{
+    return m[index];
+}
 
-}//namespace gtc
 }//namespace glm
 

glm/gtc/matrix_integer.hpp

@@ -44,10 +44,9 @@
 #	pragma message("GLM: GLM_GTC_matrix_integer extension included")
 #endif
 
-namespace glm{
-namespace gtc{
-
-	/// \addtogroup gtc_matrix_integer
+namespace glm
+{
+	/// @addtogroup gtc_matrix_integer
 	/// @{
 
 	typedef detail::tmat2x2<highp_int>				highp_imat2;	//!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
@@ -217,7 +216,6 @@ namespace gtc{
 #endif//GLM_PRECISION
 
 	/// @}
-}//namespace gtc
 }//namespace glm
 
 #endif//glm_gtc_matrix_integer

glm/gtc/matrix_inverse.hpp

@@ -44,8 +44,7 @@
 #	pragma message("GLM: GLM_GTC_matrix_inverse extension included")
 #endif
 
-namespace glm{
-namespace gtc
+namespace glm
 {
 	/// @addtogroup gtc_matrix_inverse
 	/// @{
@@ -62,7 +61,6 @@ namespace gtc
 		genType const & m);
 
 	/// @}
-}//namespace gtc
 }//namespace glm
 
 #include "matrix_inverse.inl"

glm/gtc/matrix_inverse.inl

@@ -8,130 +8,128 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtc{
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> affineInverse
-	(
-		detail::tmat3x3<T> const & m
-	)
-	{
-		detail::tmat3x3<T> Result(m);
-		Result[2] = detail::tvec3<T>(0, 0, 1);
-		Result = transpose(Result);
-		detail::tvec3<T> Translation = Result * detail::tvec3<T>(-detail::tvec2<T>(m[2]), m[2][2]);
-		Result[2] = Translation;
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> affineInverse
-	(
-		detail::tmat4x4<T> const & m
-	)
-	{
-		detail::tmat4x4<T> Result(m);
-		Result[3] = detail::tvec4<T>(0, 0, 0, 1);
-		Result = transpose(Result);
-		detail::tvec4<T> Translation = Result * detail::tvec4<T>(-detail::tvec3<T>(m[3]), m[3][3]);
-		Result[3] = Translation;
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<valType> inverseTranspose(
-		detail::tmat2x2<valType> const & m)
-	{
-		valType Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
-
-		detail::tmat2x2<valType> Inverse(
-			+ m[1][1] / Determinant,
-			- m[0][1] / Determinant,
-			- m[1][0] / Determinant, 
-			+ m[0][0] / Determinant);
-
-		return Inverse;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<valType> inverseTranspose(
-		detail::tmat3x3<valType> const & m)
-	{
-		valType Determinant = 
-			+ m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])
-			- m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
-			+ m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
-
-		detail::tmat3x3<valType> Inverse;
-		Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
-		Inverse[0][1] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
-		Inverse[0][2] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
-		Inverse[1][0] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
-		Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
-		Inverse[1][2] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
-		Inverse[2][0] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
-		Inverse[2][1] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
-		Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
-		Inverse /= Determinant;
-
-		return Inverse;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> inverseTranspose(
-		detail::tmat4x4<valType> const & m)
-	{
-		valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		valType SubFactor11 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-		valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-		valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-		valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-		valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-		valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-
-		detail::tmat4x4<valType> Inverse;
-		Inverse[0][0] = + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02);
-		Inverse[0][1] = - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04);
-		Inverse[0][2] = + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05);
-		Inverse[0][3] = - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05);
-
-		Inverse[1][0] = - (m[0][1] * SubFactor00 - m[0][2] * SubFactor01 + m[0][3] * SubFactor02);
-		Inverse[1][1] = + (m[0][0] * SubFactor00 - m[0][2] * SubFactor03 + m[0][3] * SubFactor04);
-		Inverse[1][2] = - (m[0][0] * SubFactor01 - m[0][1] * SubFactor03 + m[0][3] * SubFactor05);
-		Inverse[1][3] = + (m[0][0] * SubFactor02 - m[0][1] * SubFactor04 + m[0][2] * SubFactor05);
-
-		Inverse[2][0] = + (m[0][1] * SubFactor06 - m[0][2] * SubFactor07 + m[0][3] * SubFactor08);
-		Inverse[2][1] = - (m[0][0] * SubFactor06 - m[0][2] * SubFactor09 + m[0][3] * SubFactor10);
-		Inverse[2][2] = + (m[0][0] * SubFactor11 - m[0][1] * SubFactor09 + m[0][3] * SubFactor12);
-		Inverse[2][3] = - (m[0][0] * SubFactor08 - m[0][1] * SubFactor10 + m[0][2] * SubFactor12);
-
-		Inverse[3][0] = - (m[0][1] * SubFactor13 - m[0][2] * SubFactor14 + m[0][3] * SubFactor15);
-		Inverse[3][1] = + (m[0][0] * SubFactor13 - m[0][2] * SubFactor16 + m[0][3] * SubFactor17);
-		Inverse[3][2] = - (m[0][0] * SubFactor14 - m[0][1] * SubFactor16 + m[0][3] * SubFactor18);
-		Inverse[3][3] = + (m[0][0] * SubFactor15 - m[0][1] * SubFactor17 + m[0][2] * SubFactor18);
-
-		valType Determinant = 
-			+ m[0][0] * Inverse[0][0] 
-			+ m[0][1] * Inverse[0][1] 
-			+ m[0][2] * Inverse[0][2] 
-			+ m[0][3] * Inverse[0][3];
-
-		Inverse /= Determinant;
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat3x3<T> affineInverse
+(
+	detail::tmat3x3<T> const & m
+)
+{
+	detail::tmat3x3<T> Result(m);
+	Result[2] = detail::tvec3<T>(0, 0, 1);
+	Result = transpose(Result);
+	detail::tvec3<T> Translation = Result * detail::tvec3<T>(-detail::tvec2<T>(m[2]), m[2][2]);
+	Result[2] = Translation;
+	return Result;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> affineInverse
+(
+	detail::tmat4x4<T> const & m
+)
+{
+	detail::tmat4x4<T> Result(m);
+	Result[3] = detail::tvec4<T>(0, 0, 0, 1);
+	Result = transpose(Result);
+	detail::tvec4<T> Translation = Result * detail::tvec4<T>(-detail::tvec3<T>(m[3]), m[3][3]);
+	Result[3] = Translation;
+	return Result;
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat2x2<valType> inverseTranspose(
+	detail::tmat2x2<valType> const & m)
+{
+	valType Determinant = m[0][0] * m[1][1] - m[1][0] * m[0][1];
+
+	detail::tmat2x2<valType> Inverse(
+		+ m[1][1] / Determinant,
+		- m[0][1] / Determinant,
+		- m[1][0] / Determinant, 
+		+ m[0][0] / Determinant);
+
+	return Inverse;
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat3x3<valType> inverseTranspose(
+	detail::tmat3x3<valType> const & m)
+{
+	valType Determinant = 
+		+ m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1])
+		- m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0])
+		+ m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
+
+	detail::tmat3x3<valType> Inverse;
+	Inverse[0][0] = + (m[1][1] * m[2][2] - m[2][1] * m[1][2]);
+	Inverse[0][1] = - (m[1][0] * m[2][2] - m[2][0] * m[1][2]);
+	Inverse[0][2] = + (m[1][0] * m[2][1] - m[2][0] * m[1][1]);
+	Inverse[1][0] = - (m[0][1] * m[2][2] - m[2][1] * m[0][2]);
+	Inverse[1][1] = + (m[0][0] * m[2][2] - m[2][0] * m[0][2]);
+	Inverse[1][2] = - (m[0][0] * m[2][1] - m[2][0] * m[0][1]);
+	Inverse[2][0] = + (m[0][1] * m[1][2] - m[1][1] * m[0][2]);
+	Inverse[2][1] = - (m[0][0] * m[1][2] - m[1][0] * m[0][2]);
+	Inverse[2][2] = + (m[0][0] * m[1][1] - m[1][0] * m[0][1]);
+	Inverse /= Determinant;
+
+	return Inverse;
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> inverseTranspose(
+	detail::tmat4x4<valType> const & m)
+{
+	valType SubFactor00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+	valType SubFactor01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+	valType SubFactor02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+	valType SubFactor03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+	valType SubFactor04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+	valType SubFactor05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+	valType SubFactor06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+	valType SubFactor07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+	valType SubFactor08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+	valType SubFactor09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+	valType SubFactor10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+	valType SubFactor11 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+	valType SubFactor12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+	valType SubFactor13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+	valType SubFactor14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+	valType SubFactor15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+	valType SubFactor16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+	valType SubFactor17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+	valType SubFactor18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
+	detail::tmat4x4<valType> Inverse;
+	Inverse[0][0] = + (m[1][1] * SubFactor00 - m[1][2] * SubFactor01 + m[1][3] * SubFactor02);
+	Inverse[0][1] = - (m[1][0] * SubFactor00 - m[1][2] * SubFactor03 + m[1][3] * SubFactor04);
+	Inverse[0][2] = + (m[1][0] * SubFactor01 - m[1][1] * SubFactor03 + m[1][3] * SubFactor05);
+	Inverse[0][3] = - (m[1][0] * SubFactor02 - m[1][1] * SubFactor04 + m[1][2] * SubFactor05);
+
+	Inverse[1][0] = - (m[0][1] * SubFactor00 - m[0][2] * SubFactor01 + m[0][3] * SubFactor02);
+	Inverse[1][1] = + (m[0][0] * SubFactor00 - m[0][2] * SubFactor03 + m[0][3] * SubFactor04);
+	Inverse[1][2] = - (m[0][0] * SubFactor01 - m[0][1] * SubFactor03 + m[0][3] * SubFactor05);
+	Inverse[1][3] = + (m[0][0] * SubFactor02 - m[0][1] * SubFactor04 + m[0][2] * SubFactor05);
+
+	Inverse[2][0] = + (m[0][1] * SubFactor06 - m[0][2] * SubFactor07 + m[0][3] * SubFactor08);
+	Inverse[2][1] = - (m[0][0] * SubFactor06 - m[0][2] * SubFactor09 + m[0][3] * SubFactor10);
+	Inverse[2][2] = + (m[0][0] * SubFactor11 - m[0][1] * SubFactor09 + m[0][3] * SubFactor12);
+	Inverse[2][3] = - (m[0][0] * SubFactor08 - m[0][1] * SubFactor10 + m[0][2] * SubFactor12);
+
+	Inverse[3][0] = - (m[0][1] * SubFactor13 - m[0][2] * SubFactor14 + m[0][3] * SubFactor15);
+	Inverse[3][1] = + (m[0][0] * SubFactor13 - m[0][2] * SubFactor16 + m[0][3] * SubFactor17);
+	Inverse[3][2] = - (m[0][0] * SubFactor14 - m[0][1] * SubFactor16 + m[0][3] * SubFactor18);
+	Inverse[3][3] = + (m[0][0] * SubFactor15 - m[0][1] * SubFactor17 + m[0][2] * SubFactor18);
+
+	valType Determinant = 
+		+ m[0][0] * Inverse[0][0] 
+		+ m[0][1] * Inverse[0][1] 
+		+ m[0][2] * Inverse[0][2] 
+		+ m[0][3] * Inverse[0][3];
+
+	Inverse /= Determinant;
     
-		return Inverse;
-	}
+	return Inverse;
+}
 
-}//namespace gtc
 }//namespace glm

glm/gtc/matrix_transform.hpp

@@ -53,8 +53,7 @@
 #	pragma message("GLM: GLM_GTC_matrix_transform extension included")
 #endif
 
-namespace glm{
-namespace gtc
+namespace glm
 {
 	/// @addtogroup gtc_matrix_transform
 	/// @{
@@ -62,9 +61,9 @@ namespace gtc
 	/// Builds a translation 4 * 4 matrix created from a vector of 3 components.
 	/// @see - gtc_matrix_transform
 	/// @see - gtx_transform:
-	/// - @link glm::gtx::translate(T x, T y, T z) translate(T x, T y, T z) @endlink
-	/// - @link glm::gtx::translate(detail::tmat4x4<T> const & m, T x, T y, T z) translate(mat4x4<T> const & m, T x, T y, T z) @endlink
-	/// - @link glm::gtx::translate(detail::tvec3<T> const & v) translate(vec3<T> const & v) @endlink
+	/// - @link translate(T x, T y, T z) translate(T x, T y, T z) @endlink
+	/// - @link translate(detail::tmat4x4<T> const & m, T x, T y, T z) translate(mat4x4<T> const & m, T x, T y, T z) @endlink
+	/// - @link translate(detail::tvec3<T> const & v) translate(vec3<T> const & v) @endlink
 	template <typename T> 
 	detail::tmat4x4<T> translate(
 		detail::tmat4x4<T> const & m,
@@ -73,9 +72,9 @@ namespace gtc
 	/// Builds a rotation 4 * 4 matrix created from an axis vector and an angle expressed in degrees. 
 	/// @see - gtc_matrix_transform
 	/// @see - gtx_transform:
-	/// - @link glm::gtx::rotate(T angle, T x, T y, T z) rotate(T const & angle, T const & x, T const & y, T const & z) @endlink
-	/// - @link glm::gtx::rotate(detail::tmat4x4<T> const & m, T angle, T x, T y, T z) rotate(mat4x4<T> const & m, T const & angle, T const & x, T const & y, T const & z) @endlink
-	/// - @link glm::gtx::rotate(T angle, detail::tvec3<T> const & v) rotate(T const & angle, vec3<T> const & v) @endlink
+	/// - @link rotate(T angle, T x, T y, T z) rotate(T const & angle, T const & x, T const & y, T const & z) @endlink
+	/// - @link rotate(detail::tmat4x4<T> const & m, T angle, T x, T y, T z) rotate(mat4x4<T> const & m, T const & angle, T const & x, T const & y, T const & z) @endlink
+	/// - @link rotate(T angle, detail::tvec3<T> const & v) rotate(T const & angle, vec3<T> const & v) @endlink
 	template <typename T> 
 	detail::tmat4x4<T> rotate(
 		detail::tmat4x4<T> const & m,
@@ -85,9 +84,9 @@ namespace gtc
 	/// Builds a scale 4 * 4 matrix created from 3 scalars. 
 	/// @see - gtc_matrix_transform
 	/// @see - gtx_transform:
-	/// - @link glm::gtx::scale(T x, T y, T z) scale(T const & x, T const & y, T const & z) @endlink
-	/// - @link glm::gtx::scale(detail::tmat4x4<T> const & m, T x, T y, T z) scale(mat4x4<T> const & m, T const & angle, T const & x, T const & y, T const & z) @endlink
-	/// - @link glm::gtx::scale(detail::tvec3<T> const & v) scale(vec3<T> const & v) @endlink
+	/// - @link scale(T x, T y, T z) scale(T const & x, T const & y, T const & z) @endlink
+	/// - @link scale(detail::tmat4x4<T> const & m, T x, T y, T z) scale(mat4x4<T> const & m, T const & angle, T const & x, T const & y, T const & z) @endlink
+	/// - @link scale(detail::tvec3<T> const & v) scale(vec3<T> const & v) @endlink
 	template <typename T> 
 	detail::tmat4x4<T> scale(
 		detail::tmat4x4<T> const & m,
@@ -95,7 +94,7 @@ namespace gtc
 
 	/// Creates a matrix for an orthographic parallel viewing volume.
 	/// @see - gtc_matrix_transform:
-	/// - @link glm::gtc::ortho(T const & left, T const & right, T const & bottom, T const & top) ortho(T const & left, T const & right, T const & bottom, T const & top) @endlink
+	/// - @link glm::ortho(T const & left, T const & right, T const & bottom, T const & top) ortho(T const & left, T const & right, T const & bottom, T const & top) @endlink
 	template <typename T> 
 	detail::tmat4x4<T> ortho(
 		T const & left, 
@@ -107,7 +106,7 @@ namespace gtc
 
 	/// Creates a matrix for projecting two-dimensional coordinates onto the screen.
 	/// @see - gtc_matrix_transform:
-    /// - @link glm::gtc::ortho(T const & left, T const & right, T const & bottom, T const & top, T const & zNear, T const & zFar) ortho(T const & left, T const & right, T const & bottom, T const & top, T const & zNear, T const & zFar) @endlink
+    /// - @link glm::ortho(T const & left, T const & right, T const & bottom, T const & top, T const & zNear, T const & zFar) ortho(T const & left, T const & right, T const & bottom, T const & top, T const & zNear, T const & zFar) @endlink
 	template <typename T> 
 	detail::tmat4x4<T> ortho(
 		T const & left, 
@@ -196,7 +195,6 @@ namespace gtc
 		detail::tvec3<T> const & up);
 
 	/// @}
-}//namespace gtc
 }//namespace glm
 
 #include "matrix_transform.inl"

glm/gtc/matrix_transform.inl

@@ -8,389 +8,387 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtc{
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate
-	(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v
-	)
-    {
-		detail::tmat4x4<T> Result(m);
-		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
-		return Result;
-    }
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate
+(
+	detail::tmat4x4<T> const & m,
+	detail::tvec3<T> const & v
+)
+{
+	detail::tmat4x4<T> Result(m);
+	Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
+	return Result;
+}
 		
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate
-	(
-		detail::tmat4x4<T> const & m,
-		T const & angle, 
-		detail::tvec3<T> const & v
-	)
-    {
-        T a = radians(angle);
-        T c = cos(a);
-        T s = sin(a);
-
-        detail::tvec3<T> axis = normalize(v);
-
-		detail::tvec3<T> temp = (T(1) - c) * axis;
-
-        detail::tmat4x4<T> Rotate(detail::tmat4x4<T>::null);
-		Rotate[0][0] = c + temp[0] * axis[0];
-	    Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
-	    Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
-
-	    Rotate[1][0] = 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[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
-	    Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
-	    Rotate[2][2] = c + temp[2] * axis[2];
-
-		detail::tmat4x4<T> Result(detail::tmat4x4<T>::null);
-		Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
-		Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
-		Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
-		Result[3] = m[3];
-		return Result;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale
-	(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v
-	)
-    {
-        detail::tmat4x4<T> Result(detail::tmat4x4<T>::null);
-		Result[0] = m[0] * v[0];
-		Result[1] = m[1] * v[1];
-		Result[2] = m[2] * v[2];
-		Result[3] = m[3];
-		return Result;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate_slow
-	(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v
-	)
-    {
-        detail::tmat4x4<T> Result(T(1));
-        Result[3] = detail::tvec4<T>(v, T(1));
-        return m * Result;
-
-		//detail::tmat4x4<valType> Result(m);
-		Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
-		//Result[3][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0];
-		//Result[3][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1];
-		//Result[3][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
-		//Result[3][3] = m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3];
-		//return Result;
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate
+(
+	detail::tmat4x4<T> const & m,
+	T const & angle, 
+	detail::tvec3<T> const & v
+)
+{
+    T a = radians(angle);
+    T c = cos(a);
+    T s = sin(a);
+
+    detail::tvec3<T> axis = normalize(v);
+
+	detail::tvec3<T> temp = (T(1) - c) * axis;
+
+    detail::tmat4x4<T> Rotate(detail::tmat4x4<T>::null);
+	Rotate[0][0] = c + temp[0] * axis[0];
+	Rotate[0][1] = 0 + temp[0] * axis[1] + s * axis[2];
+	Rotate[0][2] = 0 + temp[0] * axis[2] - s * axis[1];
+
+	Rotate[1][0] = 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[2][0] = 0 + temp[2] * axis[0] + s * axis[1];
+	Rotate[2][1] = 0 + temp[2] * axis[1] - s * axis[0];
+	Rotate[2][2] = c + temp[2] * axis[2];
+
+	detail::tmat4x4<T> Result(detail::tmat4x4<T>::null);
+	Result[0] = m[0] * Rotate[0][0] + m[1] * Rotate[0][1] + m[2] * Rotate[0][2];
+	Result[1] = m[0] * Rotate[1][0] + m[1] * Rotate[1][1] + m[2] * Rotate[1][2];
+	Result[2] = m[0] * Rotate[2][0] + m[1] * Rotate[2][1] + m[2] * Rotate[2][2];
+	Result[3] = m[3];
+	return Result;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale
+(
+	detail::tmat4x4<T> const & m,
+	detail::tvec3<T> const & v
+)
+{
+    detail::tmat4x4<T> Result(detail::tmat4x4<T>::null);
+	Result[0] = m[0] * v[0];
+	Result[1] = m[1] * v[1];
+	Result[2] = m[2] * v[2];
+	Result[3] = m[3];
+	return Result;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> translate_slow
+(
+	detail::tmat4x4<T> const & m,
+	detail::tvec3<T> const & v
+)
+{
+    detail::tmat4x4<T> Result(T(1));
+    Result[3] = detail::tvec4<T>(v, T(1));
+    return m * Result;
+
+	//detail::tmat4x4<valType> Result(m);
+	Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
+	//Result[3][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0];
+	//Result[3][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1];
+	//Result[3][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
+	//Result[3][3] = m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3];
+	//return Result;
+}
 		
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate_slow
-	(
-		detail::tmat4x4<T> const & m,
-		T const & angle, 
-		detail::tvec3<T> const & v
-	)
-    {
-        T a = radians(angle);
-        T c = cos(a);
-        T s = sin(a);
-        detail::tmat4x4<T> Result;
-
-        detail::tvec3<T> axis = normalize(v);
-
-        Result[0][0] = c + (1 - c)      * axis.x     * axis.x;
-	    Result[0][1] = (1 - c) * axis.x * axis.y + s * axis.z;
-	    Result[0][2] = (1 - c) * axis.x * axis.z - s * axis.y;
-	    Result[0][3] = 0;
-
-	    Result[1][0] = (1 - c) * axis.y * axis.x - s * axis.z;
-	    Result[1][1] = c + (1 - c) * axis.y * axis.y;
-	    Result[1][2] = (1 - c) * axis.y * axis.z + s * axis.x;
-	    Result[1][3] = 0;
-
-	    Result[2][0] = (1 - c) * axis.z * axis.x + s * axis.y;
-	    Result[2][1] = (1 - c) * axis.z * axis.y - s * axis.x;
-	    Result[2][2] = c + (1 - c) * axis.z * axis.z;
-	    Result[2][3] = 0;
-
-        Result[3] = detail::tvec4<T>(0, 0, 0, 1);
-        return m * Result;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale_slow
-	(
-		detail::tmat4x4<T> const & m,
-		detail::tvec3<T> const & v
-	)
-    {
-        detail::tmat4x4<T> Result(T(1));
-        Result[0][0] = v.x;
-        Result[1][1] = v.y;
-        Result[2][2] = v.z;
-        return m * Result;
-    }
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho
-	(
-		valType const & left, 
-		valType const & right, 
-		valType const & bottom, 
-		valType const & top, 
-		valType const & zNear, 
-		valType const & zFar
-	)
-	{
-		detail::tmat4x4<valType> Result(1);
-		Result[0][0] = valType(2) / (right - left);
-		Result[1][1] = valType(2) / (top - bottom);
-		Result[2][2] = - valType(2) / (zFar - zNear);
-		Result[3][0] = - (right + left) / (right - left);
-		Result[3][1] = - (top + bottom) / (top - bottom);
-		Result[3][2] = - (zFar + zNear) / (zFar - zNear);
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho(
-		valType const & left, 
-		valType const & right, 
-		valType const & bottom, 
-		valType const & top)
-	{
-		detail::tmat4x4<valType> Result(1);
-		Result[0][0] = valType(2) / (right - left);
-		Result[1][1] = valType(2) / (top - bottom);
-		Result[2][2] = - valType(1);
-		Result[3][0] = - (right + left) / (right - left);
-		Result[3][1] = - (top + bottom) / (top - bottom);
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> frustum
-	(
-		valType const & left, 
-		valType const & right, 
-		valType const & bottom, 
-		valType const & top, 
-		valType const & nearVal, 
-		valType const & farVal
-	)
-	{
-		detail::tmat4x4<valType> Result(0);
-		Result[0][0] = (valType(2) * nearVal) / (right - left);
-		Result[1][1] = (valType(2) * nearVal) / (top - bottom);
-		Result[2][0] = (right + left) / (right - left);
-		Result[2][1] = (top + bottom) / (top - bottom);
-		Result[2][2] = -(farVal + nearVal) / (farVal - nearVal);
-		Result[2][3] = valType(-1);
-		Result[3][2] = -(valType(2) * farVal * nearVal) / (farVal - nearVal);
-		return Result;
-	}
-
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspective
-	(
-		valType const & fovy, 
-		valType const & aspect, 
-		valType const & zNear, 
-		valType const & zFar
-	)
-	{
-		valType range = tan(radians(fovy / valType(2))) * zNear;	
-		valType left = -range * aspect;
-		valType right = range * aspect;
-		valType bottom = -range;
-		valType top = range;
-
-		detail::tmat4x4<valType> Result(valType(0));
-		Result[0][0] = (valType(2) * zNear) / (right - left);
-		Result[1][1] = (valType(2) * zNear) / (top - bottom);
-		Result[2][2] = - (zFar + zNear) / (zFar - zNear);
-		Result[2][3] = - valType(1);
-		Result[3][2] = - (valType(2) * zFar * zNear) / (zFar - zNear);
-		return Result;
-	}
-
-	template <typename valType>
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspectiveFov
-	(
-		valType const & fov, 
-		valType const & width, 
-		valType const & height, 
-		valType const & zNear, 
-		valType const & zFar
-	)
-	{
-		valType rad = glm::radians(fov);
-		valType h = glm::cos(valType(0.5) * rad) / glm::sin(valType(0.5) * rad);
-		valType w = h * height / width;
-
-		detail::tmat4x4<valType> Result(valType(0));
-		Result[0][0] = w;
-		Result[1][1] = h;
-		Result[2][2] = (zFar + zNear) / (zFar - zNear);
-		Result[2][3] = valType(1);
-		Result[3][2] = -(valType(2) * zFar * zNear) / (zFar - zNear);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> infinitePerspective
-	(
-		T fovy, 
-		T aspect, 
-		T zNear
-	)
-	{
-		T range = tan(radians(fovy / T(2))) * zNear;	
-		T left = -range * aspect;
-		T right = range * aspect;
-		T bottom = -range;
-		T top = range;
-
-		detail::tmat4x4<T> Result(T(0));
-		Result[0][0] = (T(2) * zNear) / (right - left);
-		Result[1][1] = (T(2) * zNear) / (top - bottom);
-		Result[2][2] = - T(1);
-		Result[2][3] = - T(1);
-		Result[3][2] = - T(2) * zNear;
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> tweakedInfinitePerspective
-	(
-		T fovy, 
-		T aspect, 
-		T zNear
-	)
-	{
-		T range = tan(radians(fovy / T(2))) * zNear;	
-		T left = -range * aspect;
-		T right = range * aspect;
-		T bottom = -range;
-		T top = range;
-
-		detail::tmat4x4<T> Result(T(0));
-		Result[0][0] = (T(2) * zNear) / (right - left);
-		Result[1][1] = (T(2) * zNear) / (top - bottom);
-		Result[2][2] = T(0.0001) - T(1);
-		Result[2][3] = T(-1);
-		Result[3][2] = - (T(0.0001) - T(2)) * zNear;
-		return Result;
-	}
-
-	template <typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> project
-	(
-		detail::tvec3<T> const & obj, 
-		detail::tmat4x4<T> const & model, 
-		detail::tmat4x4<T> const & proj, 
-		detail::tvec4<U> const & viewport
-	)
-	{
-		detail::tvec4<T> tmp = detail::tvec4<T>(obj, T(1));
-		tmp = model * tmp;
-		tmp = proj * tmp;
-
-		tmp /= tmp.w;
-		tmp = tmp * T(0.5) + T(0.5);
-		tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
-		tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
-
-		return detail::tvec3<T>(tmp);
-	}
-
-	template <typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<T> unProject
-	(
-		detail::tvec3<T> const & win, 
-		detail::tmat4x4<T> const & model, 
-		detail::tmat4x4<T> const & proj, 
-		detail::tvec4<U> const & viewport
-	)
-	{
-		detail::tmat4x4<T> inverse = glm::inverse(proj * model);
-
-		detail::tvec4<T> tmp = detail::tvec4<T>(win, T(1));
-		tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
-		tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
-		tmp = tmp * T(2) - T(1);
-
-		detail::tvec4<T> obj = inverse * tmp;
-		obj /= obj.w;
-
-		return detail::tvec3<T>(obj);
-	}
-
-	template <typename T, typename U> 
-	detail::tmat4x4<T> pickMatrix
-	(
-		detail::tvec2<T> const & center, 
-		detail::tvec2<T> const & delta, 
-		detail::tvec4<U> const & viewport
-	)
-	{
-		assert(delta.x > T(0) && delta.y > T(0));
-		detail::tmat4x4<T> Result(1.0f);
-
-		if(!(delta.x > T(0) && delta.y > T(0))) 
-			return Result; // Error
-
-		detail::tvec3<T> Temp(
-			(T(viewport[2]) - T(2) * (center.x - T(viewport[0]))) / delta.x,
-			(T(viewport[3]) - T(2) * (center.y - T(viewport[1]))) / delta.y,
-			T(0));
-
-		// Translate and scale the picked region to the entire window
-		Result = translate(Result, Temp);
-		return scale(Result, detail::tvec3<T>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
-	}
-
-    template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> lookAt
-	(
-		detail::tvec3<T> const & eye,
-		detail::tvec3<T> const & center,
-		detail::tvec3<T> const & up
-	)
-    {
-        detail::tvec3<T> f = normalize(center - eye);
-        detail::tvec3<T> u = normalize(up);
-        detail::tvec3<T> s = normalize(cross(f, u));
-        u = cross(s, f);
-
-        detail::tmat4x4<T> Result(1);
-        Result[0][0] = s.x;
-        Result[1][0] = s.y;
-        Result[2][0] = s.z;
-        Result[0][1] = u.x;
-        Result[1][1] = u.y;
-        Result[2][1] = u.z;
-        Result[0][2] =-f.x;
-        Result[1][2] =-f.y;
-        Result[2][2] =-f.z;
-    /*  Test this instead of translate3D
-        Result[3][0] =-dot(s, eye);
-        Result[3][1] =-dot(y, eye);
-        Result[3][2] = dot(f, eye);
-    */  
-		return gtc::translate(Result, -eye);
-    }
-
-}//namespace gtc
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> rotate_slow
+(
+	detail::tmat4x4<T> const & m,
+	T const & angle, 
+	detail::tvec3<T> const & v
+)
+{
+    T a = radians(angle);
+    T c = cos(a);
+    T s = sin(a);
+    detail::tmat4x4<T> Result;
+
+    detail::tvec3<T> axis = normalize(v);
+
+    Result[0][0] = c + (1 - c)      * axis.x     * axis.x;
+	Result[0][1] = (1 - c) * axis.x * axis.y + s * axis.z;
+	Result[0][2] = (1 - c) * axis.x * axis.z - s * axis.y;
+	Result[0][3] = 0;
+
+	Result[1][0] = (1 - c) * axis.y * axis.x - s * axis.z;
+	Result[1][1] = c + (1 - c) * axis.y * axis.y;
+	Result[1][2] = (1 - c) * axis.y * axis.z + s * axis.x;
+	Result[1][3] = 0;
+
+	Result[2][0] = (1 - c) * axis.z * axis.x + s * axis.y;
+	Result[2][1] = (1 - c) * axis.z * axis.y - s * axis.x;
+	Result[2][2] = c + (1 - c) * axis.z * axis.z;
+	Result[2][3] = 0;
+
+    Result[3] = detail::tvec4<T>(0, 0, 0, 1);
+    return m * Result;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> scale_slow
+(
+	detail::tmat4x4<T> const & m,
+	detail::tvec3<T> const & v
+)
+{
+    detail::tmat4x4<T> Result(T(1));
+    Result[0][0] = v.x;
+    Result[1][1] = v.y;
+    Result[2][2] = v.z;
+    return m * Result;
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho
+(
+	valType const & left, 
+	valType const & right, 
+	valType const & bottom, 
+	valType const & top, 
+	valType const & zNear, 
+	valType const & zFar
+)
+{
+	detail::tmat4x4<valType> Result(1);
+	Result[0][0] = valType(2) / (right - left);
+	Result[1][1] = valType(2) / (top - bottom);
+	Result[2][2] = - valType(2) / (zFar - zNear);
+	Result[3][0] = - (right + left) / (right - left);
+	Result[3][1] = - (top + bottom) / (top - bottom);
+	Result[3][2] = - (zFar + zNear) / (zFar - zNear);
+	return Result;
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> ortho(
+	valType const & left, 
+	valType const & right, 
+	valType const & bottom, 
+	valType const & top)
+{
+	detail::tmat4x4<valType> Result(1);
+	Result[0][0] = valType(2) / (right - left);
+	Result[1][1] = valType(2) / (top - bottom);
+	Result[2][2] = - valType(1);
+	Result[3][0] = - (right + left) / (right - left);
+	Result[3][1] = - (top + bottom) / (top - bottom);
+	return Result;
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> frustum
+(
+	valType const & left, 
+	valType const & right, 
+	valType const & bottom, 
+	valType const & top, 
+	valType const & nearVal, 
+	valType const & farVal
+)
+{
+	detail::tmat4x4<valType> Result(0);
+	Result[0][0] = (valType(2) * nearVal) / (right - left);
+	Result[1][1] = (valType(2) * nearVal) / (top - bottom);
+	Result[2][0] = (right + left) / (right - left);
+	Result[2][1] = (top + bottom) / (top - bottom);
+	Result[2][2] = -(farVal + nearVal) / (farVal - nearVal);
+	Result[2][3] = valType(-1);
+	Result[3][2] = -(valType(2) * farVal * nearVal) / (farVal - nearVal);
+	return Result;
+}
+
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspective
+(
+	valType const & fovy, 
+	valType const & aspect, 
+	valType const & zNear, 
+	valType const & zFar
+)
+{
+	valType range = tan(radians(fovy / valType(2))) * zNear;	
+	valType left = -range * aspect;
+	valType right = range * aspect;
+	valType bottom = -range;
+	valType top = range;
+
+	detail::tmat4x4<valType> Result(valType(0));
+	Result[0][0] = (valType(2) * zNear) / (right - left);
+	Result[1][1] = (valType(2) * zNear) / (top - bottom);
+	Result[2][2] = - (zFar + zNear) / (zFar - zNear);
+	Result[2][3] = - valType(1);
+	Result[3][2] = - (valType(2) * zFar * zNear) / (zFar - zNear);
+	return Result;
+}
+
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> perspectiveFov
+(
+	valType const & fov, 
+	valType const & width, 
+	valType const & height, 
+	valType const & zNear, 
+	valType const & zFar
+)
+{
+	valType rad = glm::radians(fov);
+	valType h = glm::cos(valType(0.5) * rad) / glm::sin(valType(0.5) * rad);
+	valType w = h * height / width;
+
+	detail::tmat4x4<valType> Result(valType(0));
+	Result[0][0] = w;
+	Result[1][1] = h;
+	Result[2][2] = (zFar + zNear) / (zFar - zNear);
+	Result[2][3] = valType(1);
+	Result[3][2] = -(valType(2) * zFar * zNear) / (zFar - zNear);
+	return Result;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> infinitePerspective
+(
+	T fovy, 
+	T aspect, 
+	T zNear
+)
+{
+	T range = tan(radians(fovy / T(2))) * zNear;	
+	T left = -range * aspect;
+	T right = range * aspect;
+	T bottom = -range;
+	T top = range;
+
+	detail::tmat4x4<T> Result(T(0));
+	Result[0][0] = (T(2) * zNear) / (right - left);
+	Result[1][1] = (T(2) * zNear) / (top - bottom);
+	Result[2][2] = - T(1);
+	Result[2][3] = - T(1);
+	Result[3][2] = - T(2) * zNear;
+	return Result;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> tweakedInfinitePerspective
+(
+	T fovy, 
+	T aspect, 
+	T zNear
+)
+{
+	T range = tan(radians(fovy / T(2))) * zNear;	
+	T left = -range * aspect;
+	T right = range * aspect;
+	T bottom = -range;
+	T top = range;
+
+	detail::tmat4x4<T> Result(T(0));
+	Result[0][0] = (T(2) * zNear) / (right - left);
+	Result[1][1] = (T(2) * zNear) / (top - bottom);
+	Result[2][2] = T(0.0001) - T(1);
+	Result[2][3] = T(-1);
+	Result[3][2] = - (T(0.0001) - T(2)) * zNear;
+	return Result;
+}
+
+template <typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<T> project
+(
+	detail::tvec3<T> const & obj, 
+	detail::tmat4x4<T> const & model, 
+	detail::tmat4x4<T> const & proj, 
+	detail::tvec4<U> const & viewport
+)
+{
+	detail::tvec4<T> tmp = detail::tvec4<T>(obj, T(1));
+	tmp = model * tmp;
+	tmp = proj * tmp;
+
+	tmp /= tmp.w;
+	tmp = tmp * T(0.5) + T(0.5);
+	tmp[0] = tmp[0] * T(viewport[2]) + T(viewport[0]);
+	tmp[1] = tmp[1] * T(viewport[3]) + T(viewport[1]);
+
+	return detail::tvec3<T>(tmp);
+}
+
+template <typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<T> unProject
+(
+	detail::tvec3<T> const & win, 
+	detail::tmat4x4<T> const & model, 
+	detail::tmat4x4<T> const & proj, 
+	detail::tvec4<U> const & viewport
+)
+{
+	detail::tmat4x4<T> inverse = glm::inverse(proj * model);
+
+	detail::tvec4<T> tmp = detail::tvec4<T>(win, T(1));
+	tmp.x = (tmp.x - T(viewport[0])) / T(viewport[2]);
+	tmp.y = (tmp.y - T(viewport[1])) / T(viewport[3]);
+	tmp = tmp * T(2) - T(1);
+
+	detail::tvec4<T> obj = inverse * tmp;
+	obj /= obj.w;
+
+	return detail::tvec3<T>(obj);
+}
+
+template <typename T, typename U> 
+detail::tmat4x4<T> pickMatrix
+(
+	detail::tvec2<T> const & center, 
+	detail::tvec2<T> const & delta, 
+	detail::tvec4<U> const & viewport
+)
+{
+	assert(delta.x > T(0) && delta.y > T(0));
+	detail::tmat4x4<T> Result(1.0f);
+
+	if(!(delta.x > T(0) && delta.y > T(0))) 
+		return Result; // Error
+
+	detail::tvec3<T> Temp(
+		(T(viewport[2]) - T(2) * (center.x - T(viewport[0]))) / delta.x,
+		(T(viewport[3]) - T(2) * (center.y - T(viewport[1]))) / delta.y,
+		T(0));
+
+	// Translate and scale the picked region to the entire window
+	Result = translate(Result, Temp);
+	return scale(Result, detail::tvec3<T>(T(viewport[2]) / delta.x, T(viewport[3]) / delta.y, T(1)));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> lookAt
+(
+	detail::tvec3<T> const & eye,
+	detail::tvec3<T> const & center,
+	detail::tvec3<T> const & up
+)
+{
+    detail::tvec3<T> f = normalize(center - eye);
+    detail::tvec3<T> u = normalize(up);
+    detail::tvec3<T> s = normalize(cross(f, u));
+    u = cross(s, f);
+
+    detail::tmat4x4<T> Result(1);
+    Result[0][0] = s.x;
+    Result[1][0] = s.y;
+    Result[2][0] = s.z;
+    Result[0][1] = u.x;
+    Result[1][1] = u.y;
+    Result[2][1] = u.z;
+    Result[0][2] =-f.x;
+    Result[1][2] =-f.y;
+    Result[2][2] =-f.z;
+/*  Test this instead of translate3D
+    Result[3][0] =-dot(s, eye);
+    Result[3][1] =-dot(y, eye);
+    Result[3][2] = dot(f, eye);
+*/  
+	return translate(Result, -eye);
+}
+
 }//namespace glm

glm/gtc/quaternion.hpp

@@ -73,7 +73,7 @@ namespace detail
 		tquat();
 		explicit tquat(
 			value_type const & s, 
-			tvec3<T> const & v);
+			glm::detail::tvec3<T> const & v);
 		explicit tquat(
 			value_type const & w, 
 			value_type const & x, 
@@ -150,8 +150,6 @@ namespace detail
 
 } //namespace detail
 
-namespace gtc{
-
 	/// @addtogroup gtc_quaternion
 	/// @{
 
@@ -255,7 +253,6 @@ namespace gtc{
 	typedef detail::tquat<highp_float>		highp_quat;
     
 	/// @}
-} //namespace gtc
 } //namespace glm
 
 #include "quaternion.inl"

glm/gtc/quaternion.inl

@@ -211,7 +211,7 @@ namespace detail{
 		detail::tquat<T> const & q 
 	)
 	{
-		return gtc::inverse(q) * v;
+		return inverse(q) * v;
 	}
 
 	template <typename T>
@@ -231,7 +231,7 @@ namespace detail{
 		detail::tquat<T> const & q 
 	)
 	{
-		return gtc::inverse(q) * v;
+		return inverse(q) * v;
 	}
 
 	template <typename T> 
@@ -291,8 +291,6 @@ namespace detail{
 
 }//namespace detail
 
-namespace gtc{
-
 	////////////////////////////////////////////////////////
     template <typename T> 
 	GLM_FUNC_QUALIFIER T length
@@ -447,7 +445,7 @@ namespace gtc{
 		detail::tquat<T> const & q
 	)
     {
-        return gtc::conjugate(q) / gtc::dot(q, q);
+        return conjugate(q) / dot(q, q);
     }
 
     template <typename T> 
@@ -473,7 +471,7 @@ namespace gtc{
         typename detail::tquat<T>::value_type AngleRad = radians(angle);
         typename detail::tquat<T>::value_type fSin = sin(AngleRad * T(0.5));
 
-        return gtc::cross(q, detail::tquat<T>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
+        return cross(q, detail::tquat<T>(cos(AngleRad * T(0.5)), Tmp.x * fSin, Tmp.y * fSin, Tmp.z * fSin));
 	}
 
     template <typename T> 
@@ -578,5 +576,4 @@ namespace gtc{
 		return quat_cast(detail::tmat3x3<T>(m4));
     }
 
-}//namespace gtc
 }//namespace glm

glm/gtc/swizzle.hpp

@@ -46,8 +46,7 @@
 #	pragma message("GLM: GLM_GTC_swizzle extension included")
 #endif
 
-namespace glm{
-namespace gtc
+namespace glm
 {
 	/// @addtogroup gtc_swizzle
 	/// @{
@@ -369,7 +368,6 @@ namespace gtc
 	static_swizzle4_ref(glm::u64, 4)
 
 	/// @}
-}//namespace gtc
 }//namespace glm
 
 #include "swizzle.inl"

glm/gtc/swizzle.inl

@@ -11,7 +11,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtc{
 
 template <typename T, template <typename> class vecType>
 GLM_FUNC_QUALIFIER T swizzle
@@ -172,5 +171,4 @@ GLM_FUNC_QUALIFIER detail::tref4<int> swizzle
 }
 */
 
-}//namespace gtc
 }//namespace glm

glm/gtc/type_precision.hpp

@@ -52,9 +52,8 @@
 #	pragma message("GLM: GLM_GTC_type_precision extension included")
 #endif
 
-namespace glm{
-namespace gtc{
-
+namespace glm
+{
 	///////////////////////////
 	// Signed int vector types 
 
@@ -229,7 +228,6 @@ namespace gtc{
 	typedef detail::tquat<f64>					f64quat;    //!< \brief Double-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
 
 	/// @}
-}//namespace gtc
 }//namespace glm
 
 #include "type_precision.inl"

glm/gtc/type_ptr.hpp

@@ -69,8 +69,7 @@
 #	pragma message("GLM: GLM_GTC_type_ptr extension included")
 #endif
 
-namespace glm{
-namespace gtc
+namespace glm
 { 
 	/// @addtogroup gtc_type_ptr
 	/// @{
@@ -502,7 +501,6 @@ namespace gtc
 	}
     
 	/// @}
-}//namespace gtc
 }//namespace glm
 
 #include "type_ptr.inl"

glm/gtx/associated_min_max.hpp

@@ -45,8 +45,7 @@
 #	pragma message("GLM: GLM_GTX_associated_min_max extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_associated_min_max
 	/// @{
@@ -94,7 +93,6 @@ namespace gtx
 		const genTypeT& w, const genTypeU& d);
 
 	/// @}
-} //namespace gtx
 } //namespace glm
 
 #include "associated_min_max.inl"

glm/gtx/associated_min_max.inl

@@ -8,907 +8,905 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx
-{
-	// Min comparison between 2 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b)
-	{
-		return x < y ? a : b;
-	}
-
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-	(
-		const detail::tvec2<T>& x, const detail::tvec2<U>& a,
-		const detail::tvec2<T>& y, const detail::tvec2<U>& b
-	)
-	{
-		detail::tvec2<U> Result;
-		//Result.x = x[0] < y[0] ? a[0] : b[0];
-		//Result.y = x[1] < y[1] ? a[1] : b[1];
-		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-			Result[i] = x[i] < y[i] ? a[i] : b[i];
-		return Result;
-	}
-
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-	(
-		const detail::tvec3<T>& x, const detail::tvec3<U>& a,
-		const detail::tvec3<T>& y, const detail::tvec3<U>& b
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-			Result[i] = x[i] < y[i] ? a[i] : b[i];
-		return Result;
-	}
-
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-	(
-		const detail::tvec4<T>& x, const detail::tvec4<U>& a,
-		const detail::tvec4<T>& y, const detail::tvec4<U>& b
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-			Result[i] = x[i] < y[i] ? a[i] : b[i];
-		return Result;
-	}
-
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-	(
-		T x, const detail::tvec2<U>& a,
-		T y, const detail::tvec2<U>& b
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-			Result[i] = x < y ? a[i] : b[i];
-		return Result;
-	}
-
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-	(
-		T x, const detail::tvec3<U>& a,
-		T y, const detail::tvec3<U>& b
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-			Result[i] = x < y ? a[i] : b[i];
-		return Result;
-	}
-
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-	(
-		T x, const detail::tvec4<U>& a,
-		T y, const detail::tvec4<U>& b
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-			Result[i] = x < y ? a[i] : b[i];
-		return Result;
-	}
-
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-	(
-		const detail::tvec2<T>& x, U a,
-		const detail::tvec2<T>& y, U b
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-			Result[i] = x[i] < y[i] ? a : b;
-		return Result;
-	}
-
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-	(
-		const detail::tvec3<T>& x, U a,
-		const detail::tvec3<T>& y, U b
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-			Result[i] = x[i] < y[i] ? a : b;
-		return Result;
-	}
-
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-	(
-		const detail::tvec4<T>& x, U a,
-		const detail::tvec4<T>& y, U b
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-			Result[i] = x[i] < y[i] ? a : b;
-		return Result;
-	}
-
-	// Min comparison between 3 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER U associatedMin
-	(
-		T x, U a,
-		T y, U b,
-		T z, U c
-	)
-	{
-		U Result = x < y ? (x < z ? a : c) : (y < z ? b : c);
-		return Result;
-	}
-
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-	(
-		const detail::tvec2<T>& x, const detail::tvec2<U>& a,
-		const detail::tvec2<T>& y, const detail::tvec2<U>& b,
-		const detail::tvec2<T>& z, const detail::tvec2<U>& c
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-			Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
-		return Result;
-	}
-
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-	(
-		const detail::tvec3<T>& x, const detail::tvec3<U>& a,
-		const detail::tvec3<T>& y, const detail::tvec3<U>& b,
-		const detail::tvec3<T>& z, const detail::tvec3<U>& c
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-			Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
-		return Result;
-	}
-
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-	(
-		const detail::tvec4<T>& x, const detail::tvec4<U>& a,
-		const detail::tvec4<T>& y, const detail::tvec4<U>& b,
-		const detail::tvec4<T>& z, const detail::tvec4<U>& c
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-			Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
-		return Result;
-	}
-
-	// Min comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER U associatedMin
-	(
-		T x, U a,
-		T y, U b,
-		T z, U c,
-		T w, U d
-	)
-	{
-		T Test1 = min(x, y);
-		T Test2 = min(z, w);;
-		U Result1 = x < y ? a : b;
-		U Result2 = z < w ? c : d;
-		U Result = Test1 < Test2 ? Result1 : Result2;
-		return Result;
-	}
-
-	// Min comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-	(
-		const detail::tvec2<T>& x, const detail::tvec2<U>& a,
-		const detail::tvec2<T>& y, const detail::tvec2<U>& b,
-		const detail::tvec2<T>& z, const detail::tvec2<U>& c,
-		const detail::tvec2<T>& w, const detail::tvec2<U>& d
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-		{
-			T Test1 = min(x[i], y[i]);
-			T Test2 = min(z[i], w[i]);
-			U Result1 = x[i] < y[i] ? a[i] : b[i];
-			U Result2 = z[i] < w[i] ? c[i] : d[i];
-			Result[i] = Test1 < Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Min comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-	(
-		const detail::tvec3<T>& x, const detail::tvec3<U>& a,
-		const detail::tvec3<T>& y, const detail::tvec3<U>& b,
-		const detail::tvec3<T>& z, const detail::tvec3<U>& c,
-		const detail::tvec3<T>& w, const detail::tvec3<U>& d
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-		{
-			T Test1 = min(x[i], y[i]);
-			T Test2 = min(z[i], w[i]);
-			U Result1 = x[i] < y[i] ? a[i] : b[i];
-			U Result2 = z[i] < w[i] ? c[i] : d[i];
-			Result[i] = Test1 < Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Min comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-	(
-		const detail::tvec4<T>& x, const detail::tvec4<U>& a,
-		const detail::tvec4<T>& y, const detail::tvec4<U>& b,
-		const detail::tvec4<T>& z, const detail::tvec4<U>& c,
-		const detail::tvec4<T>& w, const detail::tvec4<U>& d
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-		{
-			T Test1 = min(x[i], y[i]);
-			T Test2 = min(z[i], w[i]);
-			U Result1 = x[i] < y[i] ? a[i] : b[i];
-			U Result2 = z[i] < w[i] ? c[i] : d[i];
-			Result[i] = Test1 < Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Min comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-	(
-		T x, const detail::tvec2<U>& a,
-		T y, const detail::tvec2<U>& b,
-		T z, const detail::tvec2<U>& c,
-		T w, const detail::tvec2<U>& d
-	)
-	{
-		T Test1 = min(x, y);
-		T Test2 = min(z, w);
-
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-		{
-			U Result1 = x < y ? a[i] : b[i];
-			U Result2 = z < w ? c[i] : d[i];
-			Result[i] = Test1 < Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Min comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-	(
-		T x, const detail::tvec3<U>& a,
-		T y, const detail::tvec3<U>& b,
-		T z, const detail::tvec3<U>& c,
-		T w, const detail::tvec3<U>& d
-	)
-	{
-		T Test1 = min(x, y);
-		T Test2 = min(z, w);
-
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-		{
-			U Result1 = x < y ? a[i] : b[i];
-			U Result2 = z < w ? c[i] : d[i];
-			Result[i] = Test1 < Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Min comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-	(
-		T x, const detail::tvec4<U>& a,
-		T y, const detail::tvec4<U>& b,
-		T z, const detail::tvec4<U>& c,
-		T w, const detail::tvec4<U>& d
-	)
-	{
-		T Test1 = min(x, y);
-		T Test2 = min(z, w);
-
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-		{
-			U Result1 = x < y ? a[i] : b[i];
-			U Result2 = z < w ? c[i] : d[i];
-			Result[i] = Test1 < Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Min comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
-	(
-		const detail::tvec2<T>& x, U a,
-		const detail::tvec2<T>& y, U b,
-		const detail::tvec2<T>& z, U c,
-		const detail::tvec2<T>& w, U d
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-		{
-			T Test1 = min(x[i], y[i]);
-			T Test2 = min(z[i], w[i]);;
-			U Result1 = x[i] < y[i] ? a : b;
-			U Result2 = z[i] < w[i] ? c : d;
-			Result[i] = Test1 < Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Min comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
-	(
-		const detail::tvec3<T>& x, U a,
-		const detail::tvec3<T>& y, U b,
-		const detail::tvec3<T>& z, U c,
-		const detail::tvec3<T>& w, U d
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-		{
-			T Test1 = min(x[i], y[i]);
-			T Test2 = min(z[i], w[i]);;
-			U Result1 = x[i] < y[i] ? a : b;
-			U Result2 = z[i] < w[i] ? c : d;
-			Result[i] = Test1 < Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Min comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
-	(
-		const detail::tvec4<T>& x, U a,
-		const detail::tvec4<T>& y, U b,
-		const detail::tvec4<T>& z, U c,
-		const detail::tvec4<T>& w, U d
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-		{
-			T Test1 = min(x[i], y[i]);
-			T Test2 = min(z[i], w[i]);;
-			U Result1 = x[i] < y[i] ? a : b;
-			U Result2 = z[i] < w[i] ? c : d;
-			Result[i] = Test1 < Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Max comparison between 2 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER U associatedMax(T x, U a, T y, U b)
-	{
-		return x > y ? a : b;
-	}
-
-	// Max comparison between 2 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-	(
-		const detail::tvec2<T>& x, const detail::tvec2<U>& a,
-		const detail::tvec2<T>& y, const detail::tvec2<U>& b
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-			Result[i] = x[i] > y[i] ? a[i] : b[i];
-		return Result;
-	}
-
-	// Max comparison between 2 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-	(
-		const detail::tvec3<T>& x, const detail::tvec3<U>& a,
-		const detail::tvec3<T>& y, const detail::tvec3<U>& b
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-			Result[i] = x[i] > y[i] ? a[i] : b[i];
-		return Result;
-	}
-
-	// Max comparison between 2 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-	(
-		const detail::tvec4<T>& x, const detail::tvec4<U>& a,
-		const detail::tvec4<T>& y, const detail::tvec4<U>& b
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-			Result[i] = x[i] > y[i] ? a[i] : b[i];
-		return Result;
-	}
-
-	// Max comparison between 2 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-	(
-		T x, const detail::tvec2<U>& a,
-		T y, const detail::tvec2<U>& b
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-			Result[i] = x > y ? a[i] : b[i];
-		return Result;
-	}
-
-	// Max comparison between 2 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-	(
-		T x, const detail::tvec3<U>& a,
-		T y, const detail::tvec3<U>& b
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-			Result[i] = x > y ? a[i] : b[i];
-		return Result;
-	}
-
-	// Max comparison between 2 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-	(
-		T x, const detail::tvec4<U>& a,
-		T y, const detail::tvec4<U>& b
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-			Result[i] = x > y ? a[i] : b[i];
-		return Result;
-	}
-
-	// Max comparison between 2 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-	(
-		const detail::tvec2<T>& x, U a,
-		const detail::tvec2<T>& y, U b
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-			Result[i] = x[i] > y[i] ? a : b;
-		return Result;
-	}
-
-	// Max comparison between 2 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-	(
-		const detail::tvec3<T>& x, U a,
-		const detail::tvec3<T>& y, U b
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-			Result[i] = x[i] > y[i] ? a : b;
-		return Result;
-	}
-
-	// Max comparison between 2 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-	(
-		const detail::tvec4<T>& x, U a,
-		const detail::tvec4<T>& y, U b
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-			Result[i] = x[i] > y[i] ? a : b;
-		return Result;
-	}
-
-	// Max comparison between 3 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER U associatedMax
-	(
-		T x, U a,
-		T y, U b,
-		T z, U c
-	)
-	{
-		U Result = x > y ? (x > z ? a : c) : (y > z ? b : c);
-		return Result;
-	}
 
-	// Max comparison between 3 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-	(
-		const detail::tvec2<T>& x, const detail::tvec2<U>& a,
-		const detail::tvec2<T>& y, const detail::tvec2<U>& b,
-		const detail::tvec2<T>& z, const detail::tvec2<U>& c
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-			Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
-		return Result;
-	}
-
-	// Max comparison between 3 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-	(
-		const detail::tvec3<T>& x, const detail::tvec3<U>& a,
-		const detail::tvec3<T>& y, const detail::tvec3<U>& b,
-		const detail::tvec3<T>& z, const detail::tvec3<U>& c
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-			Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
-		return Result;
-	}
-
-	// Max comparison between 3 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-	(
-		const detail::tvec4<T>& x, const detail::tvec4<U>& a,
-		const detail::tvec4<T>& y, const detail::tvec4<U>& b,
-		const detail::tvec4<T>& z, const detail::tvec4<U>& c
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-			Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
-		return Result;
-	}
-
-	// Max comparison between 3 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-	(
-		T x, const detail::tvec2<U>& a,
-		T y, const detail::tvec2<U>& b,
-		T z, const detail::tvec2<U>& c
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-			Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
-		return Result;
-	}
-
-	// Max comparison between 3 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-	(
-		T x, const detail::tvec3<U>& a,
-		T y, const detail::tvec3<U>& b,
-		T z, const detail::tvec3<U>& c
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-			Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
-		return Result;
-	}
-
-	// Max comparison between 3 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-	(
-		T x, const detail::tvec4<U>& a,
-		T y, const detail::tvec4<U>& b,
-		T z, const detail::tvec4<U>& c
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-			Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
-		return Result;
-	}
-
-	// Max comparison between 3 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-	(
-		const detail::tvec2<T>& x, U a,
-		const detail::tvec2<T>& y, U b,
-		const detail::tvec2<T>& z, U c
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-			Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
-		return Result;
-	}
-
-	// Max comparison between 3 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-	(
-		const detail::tvec3<T>& x, U a,
-		const detail::tvec3<T>& y, U b,
-		const detail::tvec3<T>& z, U c
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-			Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
-		return Result;
-	}
-
-	// Max comparison between 3 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-	(
-		const detail::tvec4<T>& x, U a,
-		const detail::tvec4<T>& y, U b,
-		const detail::tvec4<T>& z, U c
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-			Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
-		return Result;
-	}
-
-	// Max comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER U associatedMax
-	(
-		T x, U a,
-		T y, U b,
-		T z, U c,
-		T w, U d
-	)
-	{
-		T Test1 = max(x, y);
-		T Test2 = max(z, w);;
-		U Result1 = x > y ? a : b;
-		U Result2 = z > w ? c : d;
-		U Result = Test1 > Test2 ? Result1 : Result2;
-		return Result;
-	}
-
-	// Max comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-	(
-		const detail::tvec2<T>& x, const detail::tvec2<U>& a,
-		const detail::tvec2<T>& y, const detail::tvec2<U>& b,
-		const detail::tvec2<T>& z, const detail::tvec2<U>& c,
-		const detail::tvec2<T>& w, const detail::tvec2<U>& d
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-		{
-			T Test1 = max(x[i], y[i]);
-			T Test2 = max(z[i], w[i]);
-			U Result1 = x[i] > y[i] ? a[i] : b[i];
-			U Result2 = z[i] > w[i] ? c[i] : d[i];
-			Result[i] = Test1 > Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Max comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-	(
-		const detail::tvec3<T>& x, const detail::tvec3<U>& a,
-		const detail::tvec3<T>& y, const detail::tvec3<U>& b,
-		const detail::tvec3<T>& z, const detail::tvec3<U>& c,
-		const detail::tvec3<T>& w, const detail::tvec3<U>& d
-	)
-	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-		{
-			T Test1 = max(x[i], y[i]);
-			T Test2 = max(z[i], w[i]);
-			U Result1 = x[i] > y[i] ? a[i] : b[i];
-			U Result2 = z[i] > w[i] ? c[i] : d[i];
-			Result[i] = Test1 > Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Max comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-	(
-		const detail::tvec4<T>& x, const detail::tvec4<U>& a,
-		const detail::tvec4<T>& y, const detail::tvec4<U>& b,
-		const detail::tvec4<T>& z, const detail::tvec4<U>& c,
-		const detail::tvec4<T>& w, const detail::tvec4<U>& d
-	)
-	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-		{
-			T Test1 = max(x[i], y[i]);
-			T Test2 = max(z[i], w[i]);
-			U Result1 = x[i] > y[i] ? a[i] : b[i];
-			U Result2 = z[i] > w[i] ? c[i] : d[i];
-			Result[i] = Test1 > Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Max comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-	(
-		T x, const detail::tvec2<U>& a,
-		T y, const detail::tvec2<U>& b,
-		T z, const detail::tvec2<U>& c,
-		T w, const detail::tvec2<U>& d
-	)
-	{
-		T Test1 = max(x, y);
-		T Test2 = max(z, w);
-
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
-		{
-			U Result1 = x > y ? a[i] : b[i];
-			U Result2 = z > w ? c[i] : d[i];
-			Result[i] = Test1 > Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Max comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-	(
-		T x, const detail::tvec3<U>& a,
-		T y, const detail::tvec3<U>& b,
-		T z, const detail::tvec3<U>& c,
-		T w, const detail::tvec3<U>& d
-	)
-	{
-		T Test1 = max(x, y);
-		T Test2 = max(z, w);
-
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
-		{
-			U Result1 = x > y ? a[i] : b[i];
-			U Result2 = z > w ? c[i] : d[i];
-			Result[i] = Test1 > Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Max comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-	(
-		T x, const detail::tvec4<U>& a,
-		T y, const detail::tvec4<U>& b,
-		T z, const detail::tvec4<U>& c,
-		T w, const detail::tvec4<U>& d
-	)
-	{
-		T Test1 = max(x, y);
-		T Test2 = max(z, w);
-
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
-		{
-			U Result1 = x > y ? a[i] : b[i];
-			U Result2 = z > w ? c[i] : d[i];
-			Result[i] = Test1 > Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Max comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
-	(
-		const detail::tvec2<T>& x, U a,
-		const detail::tvec2<T>& y, U b,
-		const detail::tvec2<T>& z, U c,
-		const detail::tvec2<T>& w, U d
-	)
-	{
-		detail::tvec2<U> Result;
-		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-		{
-			T Test1 = max(x[i], y[i]);
-			T Test2 = max(z[i], w[i]);;
-			U Result1 = x[i] > y[i] ? a : b;
-			U Result2 = z[i] > w[i] ? c : d;
-			Result[i] = Test1 > Test2 ? Result1 : Result2;
-		}
-		return Result;
-	}
-
-	// Max comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
-	(
-		const detail::tvec3<T>& x, U a,
-		const detail::tvec3<T>& y, U b,
-		const detail::tvec3<T>& z, U c,
-		const detail::tvec3<T>& w, U d
-	)
+// Min comparison between 2 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER U associatedMin(T x, U a, T y, U b)
+{
+	return x < y ? a : b;
+}
+
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+(
+	const detail::tvec2<T>& x, const detail::tvec2<U>& a,
+	const detail::tvec2<T>& y, const detail::tvec2<U>& b
+)
+{
+	detail::tvec2<U> Result;
+	//Result.x = x[0] < y[0] ? a[0] : b[0];
+	//Result.y = x[1] < y[1] ? a[1] : b[1];
+	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+		Result[i] = x[i] < y[i] ? a[i] : b[i];
+	return Result;
+}
+
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+(
+	const detail::tvec3<T>& x, const detail::tvec3<U>& a,
+	const detail::tvec3<T>& y, const detail::tvec3<U>& b
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+		Result[i] = x[i] < y[i] ? a[i] : b[i];
+	return Result;
+}
+
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+(
+	const detail::tvec4<T>& x, const detail::tvec4<U>& a,
+	const detail::tvec4<T>& y, const detail::tvec4<U>& b
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+		Result[i] = x[i] < y[i] ? a[i] : b[i];
+	return Result;
+}
+
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+(
+	T x, const detail::tvec2<U>& a,
+	T y, const detail::tvec2<U>& b
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+		Result[i] = x < y ? a[i] : b[i];
+	return Result;
+}
+
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+(
+	T x, const detail::tvec3<U>& a,
+	T y, const detail::tvec3<U>& b
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+		Result[i] = x < y ? a[i] : b[i];
+	return Result;
+}
+
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+(
+	T x, const detail::tvec4<U>& a,
+	T y, const detail::tvec4<U>& b
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+		Result[i] = x < y ? a[i] : b[i];
+	return Result;
+}
+
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+(
+	const detail::tvec2<T>& x, U a,
+	const detail::tvec2<T>& y, U b
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+		Result[i] = x[i] < y[i] ? a : b;
+	return Result;
+}
+
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+(
+	const detail::tvec3<T>& x, U a,
+	const detail::tvec3<T>& y, U b
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+		Result[i] = x[i] < y[i] ? a : b;
+	return Result;
+}
+
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+(
+	const detail::tvec4<T>& x, U a,
+	const detail::tvec4<T>& y, U b
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+		Result[i] = x[i] < y[i] ? a : b;
+	return Result;
+}
+
+// Min comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER U associatedMin
+(
+	T x, U a,
+	T y, U b,
+	T z, U c
+)
+{
+	U Result = x < y ? (x < z ? a : c) : (y < z ? b : c);
+	return Result;
+}
+
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+(
+	const detail::tvec2<T>& x, const detail::tvec2<U>& a,
+	const detail::tvec2<T>& y, const detail::tvec2<U>& b,
+	const detail::tvec2<T>& z, const detail::tvec2<U>& c
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+		Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
+	return Result;
+}
+
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+(
+	const detail::tvec3<T>& x, const detail::tvec3<U>& a,
+	const detail::tvec3<T>& y, const detail::tvec3<U>& b,
+	const detail::tvec3<T>& z, const detail::tvec3<U>& c
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+		Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
+	return Result;
+}
+
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+(
+	const detail::tvec4<T>& x, const detail::tvec4<U>& a,
+	const detail::tvec4<T>& y, const detail::tvec4<U>& b,
+	const detail::tvec4<T>& z, const detail::tvec4<U>& c
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+		Result[i] = x[i] < y[i] ? (x[i] < z[i] ? a[i] : c[i]) : (y[i] < z[i] ? b[i] : c[i]);
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER U associatedMin
+(
+	T x, U a,
+	T y, U b,
+	T z, U c,
+	T w, U d
+)
+{
+	T Test1 = min(x, y);
+	T Test2 = min(z, w);;
+	U Result1 = x < y ? a : b;
+	U Result2 = z < w ? c : d;
+	U Result = Test1 < Test2 ? Result1 : Result2;
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+(
+	const detail::tvec2<T>& x, const detail::tvec2<U>& a,
+	const detail::tvec2<T>& y, const detail::tvec2<U>& b,
+	const detail::tvec2<T>& z, const detail::tvec2<U>& c,
+	const detail::tvec2<T>& w, const detail::tvec2<U>& d
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+	{
+		T Test1 = min(x[i], y[i]);
+		T Test2 = min(z[i], w[i]);
+		U Result1 = x[i] < y[i] ? a[i] : b[i];
+		U Result2 = z[i] < w[i] ? c[i] : d[i];
+		Result[i] = Test1 < Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+(
+	const detail::tvec3<T>& x, const detail::tvec3<U>& a,
+	const detail::tvec3<T>& y, const detail::tvec3<U>& b,
+	const detail::tvec3<T>& z, const detail::tvec3<U>& c,
+	const detail::tvec3<T>& w, const detail::tvec3<U>& d
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+	{
+		T Test1 = min(x[i], y[i]);
+		T Test2 = min(z[i], w[i]);
+		U Result1 = x[i] < y[i] ? a[i] : b[i];
+		U Result2 = z[i] < w[i] ? c[i] : d[i];
+		Result[i] = Test1 < Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+(
+	const detail::tvec4<T>& x, const detail::tvec4<U>& a,
+	const detail::tvec4<T>& y, const detail::tvec4<U>& b,
+	const detail::tvec4<T>& z, const detail::tvec4<U>& c,
+	const detail::tvec4<T>& w, const detail::tvec4<U>& d
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+	{
+		T Test1 = min(x[i], y[i]);
+		T Test2 = min(z[i], w[i]);
+		U Result1 = x[i] < y[i] ? a[i] : b[i];
+		U Result2 = z[i] < w[i] ? c[i] : d[i];
+		Result[i] = Test1 < Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+(
+	T x, const detail::tvec2<U>& a,
+	T y, const detail::tvec2<U>& b,
+	T z, const detail::tvec2<U>& c,
+	T w, const detail::tvec2<U>& d
+)
+{
+	T Test1 = min(x, y);
+	T Test2 = min(z, w);
+
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+	{
+		U Result1 = x < y ? a[i] : b[i];
+		U Result2 = z < w ? c[i] : d[i];
+		Result[i] = Test1 < Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+(
+	T x, const detail::tvec3<U>& a,
+	T y, const detail::tvec3<U>& b,
+	T z, const detail::tvec3<U>& c,
+	T w, const detail::tvec3<U>& d
+)
+{
+	T Test1 = min(x, y);
+	T Test2 = min(z, w);
+
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+	{
+		U Result1 = x < y ? a[i] : b[i];
+		U Result2 = z < w ? c[i] : d[i];
+		Result[i] = Test1 < Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+(
+	T x, const detail::tvec4<U>& a,
+	T y, const detail::tvec4<U>& b,
+	T z, const detail::tvec4<U>& c,
+	T w, const detail::tvec4<U>& d
+)
+{
+	T Test1 = min(x, y);
+	T Test2 = min(z, w);
+
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+	{
+		U Result1 = x < y ? a[i] : b[i];
+		U Result2 = z < w ? c[i] : d[i];
+		Result[i] = Test1 < Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMin
+(
+	const detail::tvec2<T>& x, U a,
+	const detail::tvec2<T>& y, U b,
+	const detail::tvec2<T>& z, U c,
+	const detail::tvec2<T>& w, U d
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+	{
+		T Test1 = min(x[i], y[i]);
+		T Test2 = min(z[i], w[i]);;
+		U Result1 = x[i] < y[i] ? a : b;
+		U Result2 = z[i] < w[i] ? c : d;
+		Result[i] = Test1 < Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMin
+(
+	const detail::tvec3<T>& x, U a,
+	const detail::tvec3<T>& y, U b,
+	const detail::tvec3<T>& z, U c,
+	const detail::tvec3<T>& w, U d
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+	{
+		T Test1 = min(x[i], y[i]);
+		T Test2 = min(z[i], w[i]);;
+		U Result1 = x[i] < y[i] ? a : b;
+		U Result2 = z[i] < w[i] ? c : d;
+		Result[i] = Test1 < Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Min comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMin
+(
+	const detail::tvec4<T>& x, U a,
+	const detail::tvec4<T>& y, U b,
+	const detail::tvec4<T>& z, U c,
+	const detail::tvec4<T>& w, U d
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
 	{
-		detail::tvec3<U> Result;
-		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-		{
-			T Test1 = max(x[i], y[i]);
-			T Test2 = max(z[i], w[i]);;
-			U Result1 = x[i] > y[i] ? a : b;
-			U Result2 = z[i] > w[i] ? c : d;
-			Result[i] = Test1 > Test2 ? Result1 : Result2;
-		}
-		return Result;
+		T Test1 = min(x[i], y[i]);
+		T Test2 = min(z[i], w[i]);;
+		U Result1 = x[i] < y[i] ? a : b;
+		U Result2 = z[i] < w[i] ? c : d;
+		Result[i] = Test1 < Test2 ? Result1 : Result2;
 	}
+	return Result;
+}
 
-	// Max comparison between 4 variables
-	template<typename T, typename U>
-	GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
-	(
-		const detail::tvec4<T>& x, U a,
-		const detail::tvec4<T>& y, U b,
-		const detail::tvec4<T>& z, U c,
-		const detail::tvec4<T>& w, U d
-	)
+// Max comparison between 2 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER U associatedMax(T x, U a, T y, U b)
+{
+	return x > y ? a : b;
+}
+
+// Max comparison between 2 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+(
+	const detail::tvec2<T>& x, const detail::tvec2<U>& a,
+	const detail::tvec2<T>& y, const detail::tvec2<U>& b
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+		Result[i] = x[i] > y[i] ? a[i] : b[i];
+	return Result;
+}
+
+// Max comparison between 2 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+(
+	const detail::tvec3<T>& x, const detail::tvec3<U>& a,
+	const detail::tvec3<T>& y, const detail::tvec3<U>& b
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+		Result[i] = x[i] > y[i] ? a[i] : b[i];
+	return Result;
+}
+
+// Max comparison between 2 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+(
+	const detail::tvec4<T>& x, const detail::tvec4<U>& a,
+	const detail::tvec4<T>& y, const detail::tvec4<U>& b
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+		Result[i] = x[i] > y[i] ? a[i] : b[i];
+	return Result;
+}
+
+// Max comparison between 2 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+(
+	T x, const detail::tvec2<U>& a,
+	T y, const detail::tvec2<U>& b
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+		Result[i] = x > y ? a[i] : b[i];
+	return Result;
+}
+
+// Max comparison between 2 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+(
+	T x, const detail::tvec3<U>& a,
+	T y, const detail::tvec3<U>& b
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+		Result[i] = x > y ? a[i] : b[i];
+	return Result;
+}
+
+// Max comparison between 2 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+(
+	T x, const detail::tvec4<U>& a,
+	T y, const detail::tvec4<U>& b
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+		Result[i] = x > y ? a[i] : b[i];
+	return Result;
+}
+
+// Max comparison between 2 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+(
+	const detail::tvec2<T>& x, U a,
+	const detail::tvec2<T>& y, U b
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+		Result[i] = x[i] > y[i] ? a : b;
+	return Result;
+}
+
+// Max comparison between 2 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+(
+	const detail::tvec3<T>& x, U a,
+	const detail::tvec3<T>& y, U b
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+		Result[i] = x[i] > y[i] ? a : b;
+	return Result;
+}
+
+// Max comparison between 2 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+(
+	const detail::tvec4<T>& x, U a,
+	const detail::tvec4<T>& y, U b
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+		Result[i] = x[i] > y[i] ? a : b;
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER U associatedMax
+(
+	T x, U a,
+	T y, U b,
+	T z, U c
+)
+{
+	U Result = x > y ? (x > z ? a : c) : (y > z ? b : c);
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+(
+	const detail::tvec2<T>& x, const detail::tvec2<U>& a,
+	const detail::tvec2<T>& y, const detail::tvec2<U>& b,
+	const detail::tvec2<T>& z, const detail::tvec2<U>& c
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+(
+	const detail::tvec3<T>& x, const detail::tvec3<U>& a,
+	const detail::tvec3<T>& y, const detail::tvec3<U>& b,
+	const detail::tvec3<T>& z, const detail::tvec3<U>& c
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+(
+	const detail::tvec4<T>& x, const detail::tvec4<U>& a,
+	const detail::tvec4<T>& y, const detail::tvec4<U>& b,
+	const detail::tvec4<T>& z, const detail::tvec4<U>& c
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a[i] : c[i]) : (y[i] > z[i] ? b[i] : c[i]);
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+(
+	T x, const detail::tvec2<U>& a,
+	T y, const detail::tvec2<U>& b,
+	T z, const detail::tvec2<U>& c
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+		Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+(
+	T x, const detail::tvec3<U>& a,
+	T y, const detail::tvec3<U>& b,
+	T z, const detail::tvec3<U>& c
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+		Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+(
+	T x, const detail::tvec4<U>& a,
+	T y, const detail::tvec4<U>& b,
+	T z, const detail::tvec4<U>& c
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+		Result[i] = x > y ? (x > z ? a[i] : c[i]) : (y > z ? b[i] : c[i]);
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+(
+	const detail::tvec2<T>& x, U a,
+	const detail::tvec2<T>& y, U b,
+	const detail::tvec2<T>& z, U c
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+(
+	const detail::tvec3<T>& x, U a,
+	const detail::tvec3<T>& y, U b,
+	const detail::tvec3<T>& z, U c
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
+	return Result;
+}
+
+// Max comparison between 3 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+(
+	const detail::tvec4<T>& x, U a,
+	const detail::tvec4<T>& y, U b,
+	const detail::tvec4<T>& z, U c
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+		Result[i] = x[i] > y[i] ? (x[i] > z[i] ? a : c) : (y[i] > z[i] ? b : c);
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER U associatedMax
+(
+	T x, U a,
+	T y, U b,
+	T z, U c,
+	T w, U d
+)
+{
+	T Test1 = max(x, y);
+	T Test2 = max(z, w);;
+	U Result1 = x > y ? a : b;
+	U Result2 = z > w ? c : d;
+	U Result = Test1 > Test2 ? Result1 : Result2;
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+(
+	const detail::tvec2<T>& x, const detail::tvec2<U>& a,
+	const detail::tvec2<T>& y, const detail::tvec2<U>& b,
+	const detail::tvec2<T>& z, const detail::tvec2<U>& c,
+	const detail::tvec2<T>& w, const detail::tvec2<U>& d
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+	{
+		T Test1 = max(x[i], y[i]);
+		T Test2 = max(z[i], w[i]);
+		U Result1 = x[i] > y[i] ? a[i] : b[i];
+		U Result2 = z[i] > w[i] ? c[i] : d[i];
+		Result[i] = Test1 > Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+(
+	const detail::tvec3<T>& x, const detail::tvec3<U>& a,
+	const detail::tvec3<T>& y, const detail::tvec3<U>& b,
+	const detail::tvec3<T>& z, const detail::tvec3<U>& c,
+	const detail::tvec3<T>& w, const detail::tvec3<U>& d
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+	{
+		T Test1 = max(x[i], y[i]);
+		T Test2 = max(z[i], w[i]);
+		U Result1 = x[i] > y[i] ? a[i] : b[i];
+		U Result2 = z[i] > w[i] ? c[i] : d[i];
+		Result[i] = Test1 > Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+(
+	const detail::tvec4<T>& x, const detail::tvec4<U>& a,
+	const detail::tvec4<T>& y, const detail::tvec4<U>& b,
+	const detail::tvec4<T>& z, const detail::tvec4<U>& c,
+	const detail::tvec4<T>& w, const detail::tvec4<U>& d
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+	{
+		T Test1 = max(x[i], y[i]);
+		T Test2 = max(z[i], w[i]);
+		U Result1 = x[i] > y[i] ? a[i] : b[i];
+		U Result2 = z[i] > w[i] ? c[i] : d[i];
+		Result[i] = Test1 > Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+(
+	T x, const detail::tvec2<U>& a,
+	T y, const detail::tvec2<U>& b,
+	T z, const detail::tvec2<U>& c,
+	T w, const detail::tvec2<U>& d
+)
+{
+	T Test1 = max(x, y);
+	T Test2 = max(z, w);
+
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<U>::size_type i = 0; i < detail::tvec2<U>::value_size; ++i)
+	{
+		U Result1 = x > y ? a[i] : b[i];
+		U Result2 = z > w ? c[i] : d[i];
+		Result[i] = Test1 > Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+(
+	T x, const detail::tvec3<U>& a,
+	T y, const detail::tvec3<U>& b,
+	T z, const detail::tvec3<U>& c,
+	T w, const detail::tvec3<U>& d
+)
+{
+	T Test1 = max(x, y);
+	T Test2 = max(z, w);
+
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<U>::size_type i = 0; i < detail::tvec3<U>::value_size; ++i)
+	{
+		U Result1 = x > y ? a[i] : b[i];
+		U Result2 = z > w ? c[i] : d[i];
+		Result[i] = Test1 > Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+(
+	T x, const detail::tvec4<U>& a,
+	T y, const detail::tvec4<U>& b,
+	T z, const detail::tvec4<U>& c,
+	T w, const detail::tvec4<U>& d
+)
+{
+	T Test1 = max(x, y);
+	T Test2 = max(z, w);
+
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<U>::size_type i = 0; i < detail::tvec4<U>::value_size; ++i)
+	{
+		U Result1 = x > y ? a[i] : b[i];
+		U Result2 = z > w ? c[i] : d[i];
+		Result[i] = Test1 > Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec2<U> associatedMax
+(
+	const detail::tvec2<T>& x, U a,
+	const detail::tvec2<T>& y, U b,
+	const detail::tvec2<T>& z, U c,
+	const detail::tvec2<T>& w, U d
+)
+{
+	detail::tvec2<U> Result;
+	for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+	{
+		T Test1 = max(x[i], y[i]);
+		T Test2 = max(z[i], w[i]);;
+		U Result1 = x[i] > y[i] ? a : b;
+		U Result2 = z[i] > w[i] ? c : d;
+		Result[i] = Test1 > Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec3<U> associatedMax
+(
+	const detail::tvec3<T>& x, U a,
+	const detail::tvec3<T>& y, U b,
+	const detail::tvec3<T>& z, U c,
+	const detail::tvec3<T>& w, U d
+)
+{
+	detail::tvec3<U> Result;
+	for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+	{
+		T Test1 = max(x[i], y[i]);
+		T Test2 = max(z[i], w[i]);;
+		U Result1 = x[i] > y[i] ? a : b;
+		U Result2 = z[i] > w[i] ? c : d;
+		Result[i] = Test1 > Test2 ? Result1 : Result2;
+	}
+	return Result;
+}
+
+// Max comparison between 4 variables
+template<typename T, typename U>
+GLM_FUNC_QUALIFIER detail::tvec4<U> associatedMax
+(
+	const detail::tvec4<T>& x, U a,
+	const detail::tvec4<T>& y, U b,
+	const detail::tvec4<T>& z, U c,
+	const detail::tvec4<T>& w, U d
+)
+{
+	detail::tvec4<U> Result;
+	for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
 	{
-		detail::tvec4<U> Result;
-		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-		{
-			T Test1 = max(x[i], y[i]);
-			T Test2 = max(z[i], w[i]);;
-			U Result1 = x[i] > y[i] ? a : b;
-			U Result2 = z[i] > w[i] ? c : d;
-			Result[i] = Test1 > Test2 ? Result1 : Result2;
-		}
-		return Result;
+		T Test1 = max(x[i], y[i]);
+		T Test2 = max(z[i], w[i]);;
+		U Result1 = x[i] > y[i] ? a : b;
+		U Result2 = z[i] > w[i] ? c : d;
+		Result[i] = Test1 > Test2 ? Result1 : Result2;
 	}
+	return Result;
+}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/bit.hpp

@@ -47,8 +47,7 @@
 #	pragma message("GLM: GLM_GTX_bit extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_bit
 	/// @{
@@ -134,7 +133,6 @@ namespace gtx
 		int const & ToBit);
 
 	/// @}
-}// namespace gtx
 }// namespace glm
 
 #include "bit.inl"

glm/gtx/bit.inl

@@ -10,7 +10,6 @@
 #include "../core/_detail.hpp"
 
 namespace glm{
-namespace gtx{
 
 template <typename genIType>
 GLM_FUNC_QUALIFIER genIType mask
@@ -61,13 +60,13 @@ GLM_FUNC_QUALIFIER detail::tvec4<valIType> mask
 template <typename genIType>
 GLM_FUNC_QUALIFIER genIType extractField
 (
-	gtc::half const & value, 
+	half const & value, 
 	genIType const & first, 
 	genIType const & count
 )
 {
-	assert(first + count < sizeof(gtc::half));
-	return (value._data() << first) >> ((sizeof(gtc::half) << 3) - count);
+	assert(first + count < sizeof(half));
+	return (value._data() << first) >> ((sizeof(half) << 3) - count);
 }
 
 template <typename genIType>
@@ -771,5 +770,4 @@ GLM_FUNC_QUALIFIER genIUType fillBitfieldWithZero
 	return Result;
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/closest_point.hpp

@@ -45,8 +45,7 @@
 #	pragma message("GLM: GLM_GTX_closest_point extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_closest_point
 	/// @{
@@ -60,7 +59,6 @@ namespace gtx
 		detail::tvec3<T> const & b);
 
 	/// @}
-}// namespace gtx
 }// namespace glm
 
 #include "closest_point.inl"

glm/gtx/closest_point.inl

@@ -11,7 +11,6 @@
 #define glm_gtx_closest_point
 
 namespace glm{
-namespace gtx{
 
 template <typename valType> 
 GLM_FUNC_QUALIFIER detail::tvec3<valType> closestPointOnLine
@@ -33,7 +32,6 @@ GLM_FUNC_QUALIFIER detail::tvec3<valType> closestPointOnLine
     return a + LineDirection * Distance;
 }
 
-}//namespace gtx
 }//namespace glm
 
 #endif//glm_gtx_closest_point

glm/gtx/color_cast.hpp

@@ -47,78 +47,76 @@
 #	pragma message("GLM: GLM_GTX_color_cast extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_color_cast
 	/// @{
 
 	//! Conversion of a floating value into a 8bit unsigned int value. 
 	//! From GLM_GTX_color_cast extension.
-	template <typename valType> gtc::uint8 u8channel_cast(valType a);
+	template <typename valType> uint8 u8channel_cast(valType a);
 
 	//! Conversion of a floating value into a 16bit unsigned int value. 
 	//! From GLM_GTX_color_cast extension.
-	template <typename valType>	gtc::uint16 u16channel_cast(valType a);
+	template <typename valType>	uint16 u16channel_cast(valType a);
 
-	template <typename T> gtc::uint32 u32_rgbx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::uint32 u32_xrgb_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::uint32 u32_bgrx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::uint32 u32_xbgr_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint32 u32_rgbx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint32 u32_xrgb_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint32 u32_bgrx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint32 u32_xbgr_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtc::uint32 u32_rgba_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::uint32 u32_argb_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::uint32 u32_bgra_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::uint32 u32_abgr_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint32 u32_rgba_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint32 u32_argb_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint32 u32_bgra_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint32 u32_abgr_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtc::uint64 u64_rgbx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::uint64 u64_xrgb_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::uint64 u64_bgrx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::uint64 u64_xbgr_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint64 u64_rgbx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint64 u64_xrgb_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint64 u64_bgrx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint64 u64_xbgr_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtc::uint64 u64_rgba_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::uint64 u64_argb_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::uint64 u64_bgra_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::uint64 u64_abgr_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint64 u64_rgba_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint64 u64_argb_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint64 u64_bgra_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
+	template <typename T> uint64 u64_abgr_cast(const detail::tvec4<T>& c);		//!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtx::f16vec1 f16_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
+	template <typename T> f16 f16_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtc::f16vec3 f16_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f16vec3 f16_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f16vec3 f16_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f16vec3 f16_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f16vec3 f16_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f16vec3 f16_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f16vec3 f16_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f16vec3 f16_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtc::f16vec4 f16_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f16vec4 f16_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f16vec4 f16_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f16vec4 f16_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f16vec4 f16_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f16vec4 f16_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f16vec4 f16_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f16vec4 f16_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtx::f32vec1 f32_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
+	template <typename T> f32 f32_channel_cast(T a);		//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtc::f32vec3 f32_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f32vec3 f32_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f32vec3 f32_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f32vec3 f32_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f32vec3 f32_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f32vec3 f32_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f32vec3 f32_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f32vec3 f32_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtc::f32vec4 f32_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f32vec4 f32_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f32vec4 f32_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f32vec4 f32_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f32vec4 f32_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f32vec4 f32_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f32vec4 f32_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f32vec4 f32_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtx::f64vec1 f64_channel_cast(T a);	//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
+	template <typename T> f64 f64_channel_cast(T a);		//!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtc::f64vec3 f64_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f64vec3 f64_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f64vec3 f64_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f64vec3 f64_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f64vec3 f64_rgbx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f64vec3 f64_xrgb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f64vec3 f64_bgrx_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f64vec3 f64_xbgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
 
-	template <typename T> gtc::f64vec4 f64_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f64vec4 f64_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f64vec4 f64_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
-	template <typename T> gtc::f64vec4 f64_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f64vec4 f64_rgba_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f64vec4 f64_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f64vec4 f64_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+	template <typename T> f64vec4 f64_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "color_cast.inl"

glm/gtx/color_cast.inl

@@ -8,213 +8,212 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
 template <typename T> 
-GLM_FUNC_QUALIFIER gtc::uint8 u8channel_cast(T a)
+GLM_FUNC_QUALIFIER uint8 u8channel_cast(T a)
 {
-	return static_cast<gtc::uint8>(a * T(255));
+	return static_cast<uint8>(a * T(255));
 }
 
 template <typename T> 
-GLM_FUNC_QUALIFIER gtc::uint16 u16channel_cast(T a)
+GLM_FUNC_QUALIFIER uint16 u16channel_cast(T a)
 {
-	return static_cast<gtc::uint16>(a * T(65535));
+	return static_cast<uint16>(a * T(65535));
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint32 u32_rgbx_cast(const detail::tvec3<T>& c)
+GLM_FUNC_QUALIFIER uint32 u32_rgbx_cast(const detail::tvec3<T>& c)
 {
-	gtc::uint32 result = 0;
-	result += static_cast<gtc::uint32>(c.x * detail::tvec3<T>::value_type(255)) <<  0;
-	result += static_cast<gtc::uint32>(c.y * detail::tvec3<T>::value_type(255)) <<  8;
-	result += static_cast<gtc::uint32>(c.z * detail::tvec3<T>::value_type(255)) << 16;
+	uint32 result = 0;
+	result += static_cast<uint32>(c.x * detail::tvec3<T>::value_type(255)) <<  0;
+	result += static_cast<uint32>(c.y * detail::tvec3<T>::value_type(255)) <<  8;
+	result += static_cast<uint32>(c.z * detail::tvec3<T>::value_type(255)) << 16;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint32 u32_xrgb_cast(const detail::tvec3<T>& c)
+GLM_FUNC_QUALIFIER uint32 u32_xrgb_cast(const detail::tvec3<T>& c)
 {
-	gtc::uint32 result = 0;
-    result += static_cast<gtc::uint32>(c.x * detail::tvec3<T>::value_type(255)) <<  8;
-	result += static_cast<gtc::uint32>(c.y * detail::tvec3<T>::value_type(255)) << 16;
-	result += static_cast<gtc::uint32>(c.z * detail::tvec3<T>::value_type(255)) << 24;
+	uint32 result = 0;
+    result += static_cast<uint32>(c.x * detail::tvec3<T>::value_type(255)) <<  8;
+	result += static_cast<uint32>(c.y * detail::tvec3<T>::value_type(255)) << 16;
+	result += static_cast<uint32>(c.z * detail::tvec3<T>::value_type(255)) << 24;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint32 u32_bgrx_cast(const detail::tvec3<T>& c)
+GLM_FUNC_QUALIFIER uint32 u32_bgrx_cast(const detail::tvec3<T>& c)
 {
-	gtc::uint32 result = 0;
-	result += static_cast<gtc::uint32>(c.x * detail::tvec3<T>::value_type(255)) << 16;
-	result += static_cast<gtc::uint32>(c.y * detail::tvec3<T>::value_type(255)) <<  8;
-	result += static_cast<gtc::uint32>(c.z * detail::tvec3<T>::value_type(255)) <<  0;
+	uint32 result = 0;
+	result += static_cast<uint32>(c.x * detail::tvec3<T>::value_type(255)) << 16;
+	result += static_cast<uint32>(c.y * detail::tvec3<T>::value_type(255)) <<  8;
+	result += static_cast<uint32>(c.z * detail::tvec3<T>::value_type(255)) <<  0;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint32 u32_xbgr_cast(const detail::tvec3<T>& c)
+GLM_FUNC_QUALIFIER uint32 u32_xbgr_cast(const detail::tvec3<T>& c)
 {
-	gtc::uint32 result = 0;
-	result += static_cast<gtc::uint32>(c.x * detail::tvec3<T>::value_type(255)) << 24;
-	result += static_cast<gtc::uint32>(c.y * detail::tvec3<T>::value_type(255)) << 16;
-	result += static_cast<gtc::uint32>(c.z * detail::tvec3<T>::value_type(255)) <<  8;
-	result += static_cast<gtc::uint32>(c.w * detail::tvec3<T>::value_type(255)) <<  0;
+	uint32 result = 0;
+	result += static_cast<uint32>(c.x * detail::tvec3<T>::value_type(255)) << 24;
+	result += static_cast<uint32>(c.y * detail::tvec3<T>::value_type(255)) << 16;
+	result += static_cast<uint32>(c.z * detail::tvec3<T>::value_type(255)) <<  8;
+	result += static_cast<uint32>(c.w * detail::tvec3<T>::value_type(255)) <<  0;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint32 u32_rgba_cast(const detail::tvec4<T>& c)
+GLM_FUNC_QUALIFIER uint32 u32_rgba_cast(const detail::tvec4<T>& c)
 {
-	gtc::uint32 result = 0;
-	result += static_cast<gtc::uint32>(c.x * detail::tvec4<T>::value_type(255)) <<  0;
-	result += static_cast<gtc::uint32>(c.y * detail::tvec4<T>::value_type(255)) <<  8;
-	result += static_cast<gtc::uint32>(c.z * detail::tvec4<T>::value_type(255)) << 16;
-	result += static_cast<gtc::uint32>(c.w * detail::tvec4<T>::value_type(255)) << 24;
+	uint32 result = 0;
+	result += static_cast<uint32>(c.x * detail::tvec4<T>::value_type(255)) <<  0;
+	result += static_cast<uint32>(c.y * detail::tvec4<T>::value_type(255)) <<  8;
+	result += static_cast<uint32>(c.z * detail::tvec4<T>::value_type(255)) << 16;
+	result += static_cast<uint32>(c.w * detail::tvec4<T>::value_type(255)) << 24;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint32 u32_argb_cast(const detail::tvec4<T>& c)
+GLM_FUNC_QUALIFIER uint32 u32_argb_cast(const detail::tvec4<T>& c)
 {
-	gtc::uint32 result = 0;
-	result += static_cast<gtc::uint32>(c.x * detail::tvec4<T>::value_type(255)) <<  8;
-	result += static_cast<gtc::uint32>(c.y * detail::tvec4<T>::value_type(255)) << 16;
-	result += static_cast<gtc::uint32>(c.z * detail::tvec4<T>::value_type(255)) << 24;
-	result += static_cast<gtc::uint32>(c.w * detail::tvec4<T>::value_type(255)) <<  0;
+	uint32 result = 0;
+	result += static_cast<uint32>(c.x * detail::tvec4<T>::value_type(255)) <<  8;
+	result += static_cast<uint32>(c.y * detail::tvec4<T>::value_type(255)) << 16;
+	result += static_cast<uint32>(c.z * detail::tvec4<T>::value_type(255)) << 24;
+	result += static_cast<uint32>(c.w * detail::tvec4<T>::value_type(255)) <<  0;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint32 u32_bgra_cast(const detail::tvec4<T>& c)
+GLM_FUNC_QUALIFIER uint32 u32_bgra_cast(const detail::tvec4<T>& c)
 {
-	gtc::uint32 result = 0;
-	result += static_cast<gtc::uint32>(c.x * detail::tvec4<T>::value_type(255)) << 16;
-	result += static_cast<gtc::uint32>(c.y * detail::tvec4<T>::value_type(255)) <<  8;
-	result += static_cast<gtc::uint32>(c.z * detail::tvec4<T>::value_type(255)) <<  0;
-	result += static_cast<gtc::uint32>(c.w * detail::tvec4<T>::value_type(255)) << 24;
+	uint32 result = 0;
+	result += static_cast<uint32>(c.x * detail::tvec4<T>::value_type(255)) << 16;
+	result += static_cast<uint32>(c.y * detail::tvec4<T>::value_type(255)) <<  8;
+	result += static_cast<uint32>(c.z * detail::tvec4<T>::value_type(255)) <<  0;
+	result += static_cast<uint32>(c.w * detail::tvec4<T>::value_type(255)) << 24;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint32 u32_abgr_cast(const detail::tvec4<T>& c)
+GLM_FUNC_QUALIFIER uint32 u32_abgr_cast(const detail::tvec4<T>& c)
 {
-	gtc::uint32 result = 0;
-	result += static_cast<gtc::uint32>(c.x * detail::tvec4<T>::value_type(255)) << 24;
-	result += static_cast<gtc::uint32>(c.y * detail::tvec4<T>::value_type(255)) << 16;
-	result += static_cast<gtc::uint32>(c.z * detail::tvec4<T>::value_type(255)) <<  8;
-	result += static_cast<gtc::uint32>(c.w * detail::tvec4<T>::value_type(255)) <<  0;
+	uint32 result = 0;
+	result += static_cast<uint32>(c.x * detail::tvec4<T>::value_type(255)) << 24;
+	result += static_cast<uint32>(c.y * detail::tvec4<T>::value_type(255)) << 16;
+	result += static_cast<uint32>(c.z * detail::tvec4<T>::value_type(255)) <<  8;
+	result += static_cast<uint32>(c.w * detail::tvec4<T>::value_type(255)) <<  0;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint64 u64_rgbx_cast(const detail::tvec3<T>& c)
+GLM_FUNC_QUALIFIER uint64 u64_rgbx_cast(const detail::tvec3<T>& c)
 {
-	gtc::uint64 result = 0;
-	result += static_cast<gtc::uint64>(c.x * detail::tvec3<T>::value_type(65535)) <<  0;
-	result += static_cast<gtc::uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 16;
-	result += static_cast<gtc::uint64>(c.z * detail::tvec3<T>::value_type(65535)) << 32;
+	uint64 result = 0;
+	result += static_cast<uint64>(c.x * detail::tvec3<T>::value_type(65535)) <<  0;
+	result += static_cast<uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 16;
+	result += static_cast<uint64>(c.z * detail::tvec3<T>::value_type(65535)) << 32;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint64 u32_xrgb_cast(const detail::tvec3<T>& c)
+GLM_FUNC_QUALIFIER uint64 u32_xrgb_cast(const detail::tvec3<T>& c)
 {
-	gtc::uint64 result = 0;
-	result += static_cast<gtc::uint64>(c.x * detail::tvec3<T>::value_type(65535)) << 16;
-	result += static_cast<gtc::uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 32;
-	result += static_cast<gtc::uint64>(c.z * detail::tvec3<T>::value_type(65535)) << 48;
+	uint64 result = 0;
+	result += static_cast<uint64>(c.x * detail::tvec3<T>::value_type(65535)) << 16;
+	result += static_cast<uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 32;
+	result += static_cast<uint64>(c.z * detail::tvec3<T>::value_type(65535)) << 48;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint64 u32_bgrx_cast(const detail::tvec3<T>& c)
+GLM_FUNC_QUALIFIER uint64 u32_bgrx_cast(const detail::tvec3<T>& c)
 {
-	gtc::uint64 result = 0;
-	result += static_cast<gtc::uint64>(c.x * detail::tvec3<T>::value_type(65535)) << 32;
-	result += static_cast<gtc::uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 16;
-	result += static_cast<gtc::uint64>(c.z * detail::tvec3<T>::value_type(65535)) <<  0;
+	uint64 result = 0;
+	result += static_cast<uint64>(c.x * detail::tvec3<T>::value_type(65535)) << 32;
+	result += static_cast<uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 16;
+	result += static_cast<uint64>(c.z * detail::tvec3<T>::value_type(65535)) <<  0;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint64 u32_xbgr_cast(const detail::tvec3<T>& c)
+GLM_FUNC_QUALIFIER uint64 u32_xbgr_cast(const detail::tvec3<T>& c)
 {
-	gtc::uint64 result = 0;
-	result += static_cast<gtc::uint64>(c.x * detail::tvec3<T>::value_type(65535)) << 48;
-	result += static_cast<gtc::uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 32;
-	result += static_cast<gtc::uint64>(c.z * detail::tvec3<T>::value_type(65535)) << 16;
-	result += static_cast<gtc::uint64>(c.w * detail::tvec3<T>::value_type(65535)) <<  0;
+	uint64 result = 0;
+	result += static_cast<uint64>(c.x * detail::tvec3<T>::value_type(65535)) << 48;
+	result += static_cast<uint64>(c.y * detail::tvec3<T>::value_type(65535)) << 32;
+	result += static_cast<uint64>(c.z * detail::tvec3<T>::value_type(65535)) << 16;
+	result += static_cast<uint64>(c.w * detail::tvec3<T>::value_type(65535)) <<  0;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint64 u64_rgba_cast(const detail::tvec4<T>& c)
+GLM_FUNC_QUALIFIER uint64 u64_rgba_cast(const detail::tvec4<T>& c)
 {
-	gtc::uint64 result = 0;
-	result += static_cast<gtc::uint64>(c.x * detail::tvec4<T>::value_type(65535)) <<  0;
-	result += static_cast<gtc::uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 16;
-	result += static_cast<gtc::uint64>(c.z * detail::tvec4<T>::value_type(65535)) << 32;
-	result += static_cast<gtc::uint64>(c.w * detail::tvec4<T>::value_type(65535)) << 48;
+	uint64 result = 0;
+	result += static_cast<uint64>(c.x * detail::tvec4<T>::value_type(65535)) <<  0;
+	result += static_cast<uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 16;
+	result += static_cast<uint64>(c.z * detail::tvec4<T>::value_type(65535)) << 32;
+	result += static_cast<uint64>(c.w * detail::tvec4<T>::value_type(65535)) << 48;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint64 u64_argb_cast(const detail::tvec4<T>& c)
+GLM_FUNC_QUALIFIER uint64 u64_argb_cast(const detail::tvec4<T>& c)
 {
-	gtc::uint64 result = 0;
-	result += static_cast<gtc::uint64>(c.x * detail::tvec4<T>::value_type(65535)) << 16;
-	result += static_cast<gtc::uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 32;
-	result += static_cast<gtc::uint64>(c.z * detail::tvec4<T>::value_type(65535)) << 48;
-	result += static_cast<gtc::uint64>(c.w * detail::tvec4<T>::value_type(65535)) <<  0;
+	uint64 result = 0;
+	result += static_cast<uint64>(c.x * detail::tvec4<T>::value_type(65535)) << 16;
+	result += static_cast<uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 32;
+	result += static_cast<uint64>(c.z * detail::tvec4<T>::value_type(65535)) << 48;
+	result += static_cast<uint64>(c.w * detail::tvec4<T>::value_type(65535)) <<  0;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint64 u64_bgra_cast(const detail::tvec4<T>& c)
+GLM_FUNC_QUALIFIER uint64 u64_bgra_cast(const detail::tvec4<T>& c)
 {
-	gtc::uint64 result = 0;
-	result += static_cast<gtc::uint64>(c.x * detail::tvec4<T>::value_type(65535)) << 32;
-	result += static_cast<gtc::uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 16;
-	result += static_cast<gtc::uint64>(c.z * detail::tvec4<T>::value_type(65535)) <<  0;
-	result += static_cast<gtc::uint64>(c.w * detail::tvec4<T>::value_type(65535)) << 48;
+	uint64 result = 0;
+	result += static_cast<uint64>(c.x * detail::tvec4<T>::value_type(65535)) << 32;
+	result += static_cast<uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 16;
+	result += static_cast<uint64>(c.z * detail::tvec4<T>::value_type(65535)) <<  0;
+	result += static_cast<uint64>(c.w * detail::tvec4<T>::value_type(65535)) << 48;
 	return result;
 }
 
 template <typename T>
-GLM_FUNC_QUALIFIER gtc::uint64 u64_abgr_cast(const detail::tvec4<T>& c)
+GLM_FUNC_QUALIFIER uint64 u64_abgr_cast(const detail::tvec4<T>& c)
 {
-	gtc::uint64 result = 0;
-	result += static_cast<gtc::uint64>(c.x * detail::tvec4<T>::value_type(65535)) << 48;
-	result += static_cast<gtc::uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 32;
-	result += static_cast<gtc::uint64>(c.z * detail::tvec4<T>::value_type(65535)) << 16;
-	result += static_cast<gtc::uint64>(c.w * detail::tvec4<T>::value_type(65535)) <<  0;
+	uint64 result = 0;
+	result += static_cast<uint64>(c.x * detail::tvec4<T>::value_type(65535)) << 48;
+	result += static_cast<uint64>(c.y * detail::tvec4<T>::value_type(65535)) << 32;
+	result += static_cast<uint64>(c.z * detail::tvec4<T>::value_type(65535)) << 16;
+	result += static_cast<uint64>(c.w * detail::tvec4<T>::value_type(65535)) <<  0;
 	return result;
 }
 
 template <>
-GLM_FUNC_QUALIFIER f16vec1 f16_channel_cast<gtc::uint32>(gtc::uint32 color)
+GLM_FUNC_QUALIFIER f16 f16_channel_cast<uint32>(uint32 color)
 {
-	return gtc::f16(static_cast<float>(color >>  0) / static_cast<float>(255));
+	return f16(static_cast<float>(color >>  0) / static_cast<float>(255));
 }
 
 template <>
-GLM_FUNC_QUALIFIER gtc::f16vec3 f16_rgbx_cast<gtc::uint32>(gtc::uint32 color)
+GLM_FUNC_QUALIFIER f16vec3 f16_rgbx_cast<uint32>(uint32 color)
 {
-	gtc::f16vec3 result;
-	result.x = gtc::f16(static_cast<float>(color >>  0) / static_cast<float>(255));
-	result.y = gtc::f16(static_cast<float>(color >>  8) / static_cast<float>(255));
-	result.z = gtc::f16(static_cast<float>(color >> 16) / static_cast<float>(255));
+	f16vec3 result;
+	result.x = f16(static_cast<float>(color >>  0) / static_cast<float>(255));
+	result.y = f16(static_cast<float>(color >>  8) / static_cast<float>(255));
+	result.z = f16(static_cast<float>(color >> 16) / static_cast<float>(255));
 	return result;
 }
 
 template <>
-GLM_FUNC_QUALIFIER gtc::f16vec3 f16_xrgb_cast<gtc::uint32>(gtc::uint32 color)
+GLM_FUNC_QUALIFIER f16vec3 f16_xrgb_cast<uint32>(uint32 color)
 {
-	gtc::f16vec3 result;
-	result.x = gtc::f16(static_cast<float>(color >>  8) / static_cast<float>(255));
-	result.y = gtc::f16(static_cast<float>(color >> 16) / static_cast<float>(255));
-	result.z = gtc::f16(static_cast<float>(color >> 24) / static_cast<float>(255));
+	f16vec3 result;
+	result.x = f16(static_cast<float>(color >>  8) / static_cast<float>(255));
+	result.y = f16(static_cast<float>(color >> 16) / static_cast<float>(255));
+	result.z = f16(static_cast<float>(color >> 24) / static_cast<float>(255));
 	return result;
 }
 
@@ -732,5 +731,4 @@ GLM_FUNC_QUALIFIER detail::tvec4<double> f64_abgr_cast<uint64>(uint64 color)
 	return result;
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/color_space.hpp

@@ -45,8 +45,7 @@
 #	pragma message("GLM: GLM_GTX_color_space extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_color_space
 	/// @{
@@ -90,7 +89,6 @@ namespace gtx
 		detail::tvec3<valType> const & color);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "color_space.inl"

glm/gtx/color_space.inl

@@ -8,145 +8,143 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> rgbColor(const detail::tvec3<T>& hsvColor)
 {
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> rgbColor(const detail::tvec3<T>& hsvColor)
-    {
-		detail::tvec3<T> hsv = hsvColor;
-        detail::tvec3<T> rgbColor;
-
-	    if(hsv.y == T(0))
-		    // achromatic (grey)
-            rgbColor = detail::tvec3<T>(hsv.z);
-	    else
-	    {
-            T sector = floor(hsv.x / T(60));
-			T frac = (hsv.x / T(60)) - sector;
-            // factorial part of h
-            T o = hsv.z * (T(1) - hsv.y);
-            T p = hsv.z * (T(1) - hsv.y * frac);
-            T q = hsv.z * (T(1) - hsv.y * (T(1) - frac));
-
-            switch(int(sector))
-            {
-            default:
-            case 0:
-                rgbColor.r = hsv.z;
-                rgbColor.g = q;
-                rgbColor.b = o;
-                break;
-            case 1:
-                rgbColor.r = p;
-                rgbColor.g = hsv.z;
-                rgbColor.b = o;
-                break;
-            case 2:
-                rgbColor.r = o;
-                rgbColor.g = hsv.z;
-                rgbColor.b = q;
-                break;
-            case 3:
-                rgbColor.r = o;
-                rgbColor.g = p;
-                rgbColor.b = hsv.z;
-                break;
-            case 4:
-                rgbColor.r = q; 
-                rgbColor.g = o; 
-                rgbColor.b = hsv.z;
-                break;
-			case 5:
-                rgbColor.r = hsv.z; 
-                rgbColor.g = o; 
-                rgbColor.b = p;
-                break;
-            }
-	    }
-
-		return rgbColor;
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> hsvColor(const detail::tvec3<T>& rgbColor)
-    {
-        detail::tvec3<T> hsv = rgbColor;
-	    float Min   = min(min(rgbColor.r, rgbColor.g), rgbColor.b);
-	    float Max   = max(max(rgbColor.r, rgbColor.g), rgbColor.b);
-	    float Delta = Max - Min;
-
-	    hsv.z = Max;                               
-    	
-	    if(Max != T(0))
-	    {
-		    hsv.y = Delta / hsv.z;    
-			T h = T(0);
-
-		    if(rgbColor.r == Max)
-			    // between yellow & magenta
-			    h = T(0) + T(60) * (rgbColor.g - rgbColor.b) / Delta;
-		    else if(rgbColor.g == Max)
-			    // between cyan & yellow
-			    h = T(120) + T(60) * (rgbColor.b - rgbColor.r) / Delta;
-		    else
-			    // between magenta & cyan
-			    h = T(240) + T(60) * (rgbColor.r - rgbColor.g) / Delta;
-            
-		    if(h < T(0)) 
-                hsv.x = h + T(360);
-			else
-				hsv.x = h;
-	    }
-	    else
-	    {
-		    // If r = g = b = 0 then s = 0, h is undefined
-		    hsv.y = T(0);
-		    hsv.x = T(0);
-	    }
-
-		return hsv;
-    }
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<T> saturation(const T s)
-	{
-		detail::tvec3<T> rgbw = detail::tvec3<T>(T(0.2126), T(0.7152), T(0.0722));
-
-		T col0 = (T(1) - s) * rgbw.r;
-		T col1 = (T(1) - s) * rgbw.g;
-		T col2 = (T(1) - s) * rgbw.b;
-
-		detail::tmat4x4<T> result(T(1));
-		result[0][0] = col0 + s;
-		result[0][1] = col0;
-		result[0][2] = col0;
-		result[1][0] = col1;
-		result[1][1] = col1 + s;
-		result[1][2] = col1;
-		result[2][0] = col2;
-		result[2][1] = col2;
-		result[2][2] = col2 + s;
-		return result;
-	}
+	detail::tvec3<T> hsv = hsvColor;
+    detail::tvec3<T> rgbColor;
 
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> saturation(const T s, const detail::tvec3<T>& color)
+	if(hsv.y == T(0))
+		// achromatic (grey)
+        rgbColor = detail::tvec3<T>(hsv.z);
+	else
 	{
-		return detail::tvec3<T>(saturation(s) * detail::tvec4<T>(color, T(0)));
+        T sector = floor(hsv.x / T(60));
+		T frac = (hsv.x / T(60)) - sector;
+        // factorial part of h
+        T o = hsv.z * (T(1) - hsv.y);
+        T p = hsv.z * (T(1) - hsv.y * frac);
+        T q = hsv.z * (T(1) - hsv.y * (T(1) - frac));
+
+        switch(int(sector))
+        {
+        default:
+        case 0:
+            rgbColor.r = hsv.z;
+            rgbColor.g = q;
+            rgbColor.b = o;
+            break;
+        case 1:
+            rgbColor.r = p;
+            rgbColor.g = hsv.z;
+            rgbColor.b = o;
+            break;
+        case 2:
+            rgbColor.r = o;
+            rgbColor.g = hsv.z;
+            rgbColor.b = q;
+            break;
+        case 3:
+            rgbColor.r = o;
+            rgbColor.g = p;
+            rgbColor.b = hsv.z;
+            break;
+        case 4:
+            rgbColor.r = q; 
+            rgbColor.g = o; 
+            rgbColor.b = hsv.z;
+            break;
+		case 5:
+            rgbColor.r = hsv.z; 
+            rgbColor.g = o; 
+            rgbColor.b = p;
+            break;
+        }
 	}
 
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec4<T> saturation(const T s, const detail::tvec4<T>& color)
+	return rgbColor;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> hsvColor(const detail::tvec3<T>& rgbColor)
+{
+    detail::tvec3<T> hsv = rgbColor;
+	float Min   = min(min(rgbColor.r, rgbColor.g), rgbColor.b);
+	float Max   = max(max(rgbColor.r, rgbColor.g), rgbColor.b);
+	float Delta = Max - Min;
+
+	hsv.z = Max;                               
+    	
+	if(Max != T(0))
 	{
-		return saturation(s) * color;
-	}
+		hsv.y = Delta / hsv.z;    
+		T h = T(0);
 
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T luminosity(const detail::tvec3<T>& color)
+		if(rgbColor.r == Max)
+			// between yellow & magenta
+			h = T(0) + T(60) * (rgbColor.g - rgbColor.b) / Delta;
+		else if(rgbColor.g == Max)
+			// between cyan & yellow
+			h = T(120) + T(60) * (rgbColor.b - rgbColor.r) / Delta;
+		else
+			// between magenta & cyan
+			h = T(240) + T(60) * (rgbColor.r - rgbColor.g) / Delta;
+            
+		if(h < T(0)) 
+            hsv.x = h + T(360);
+		else
+			hsv.x = h;
+	}
+	else
 	{
-		const detail::tvec3<T> tmp = detail::tvec3<T>(0.33, 0.59, 0.11);
-		return dot(color, tmp);
+		// If r = g = b = 0 then s = 0, h is undefined
+		hsv.y = T(0);
+		hsv.x = T(0);
 	}
 
-}//namespace gtx
+	return hsv;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> saturation(const T s)
+{
+	detail::tvec3<T> rgbw = detail::tvec3<T>(T(0.2126), T(0.7152), T(0.0722));
+
+	T col0 = (T(1) - s) * rgbw.r;
+	T col1 = (T(1) - s) * rgbw.g;
+	T col2 = (T(1) - s) * rgbw.b;
+
+	detail::tmat4x4<T> result(T(1));
+	result[0][0] = col0 + s;
+	result[0][1] = col0;
+	result[0][2] = col0;
+	result[1][0] = col1;
+	result[1][1] = col1 + s;
+	result[1][2] = col1;
+	result[2][0] = col2;
+	result[2][1] = col2;
+	result[2][2] = col2 + s;
+	return result;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> saturation(const T s, const detail::tvec3<T>& color)
+{
+	return detail::tvec3<T>(saturation(s) * detail::tvec4<T>(color, T(0)));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> saturation(const T s, const detail::tvec4<T>& color)
+{
+	return saturation(s) * color;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER T luminosity(const detail::tvec3<T>& color)
+{
+	const detail::tvec3<T> tmp = detail::tvec3<T>(0.33, 0.59, 0.11);
+	return dot(color, tmp);
+}
+
 }//namespace glm

glm/gtx/color_space_YCoCg.hpp

@@ -45,8 +45,7 @@
 #	pragma message("GLM: GLM_GTX_color_space_YCoCg extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_color_space_YCoCg
 	/// @{
@@ -78,7 +77,6 @@ namespace gtx
 		detail::tvec3<valType> const & YCoCgColor);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "color_space_YCoCg.inl"

glm/gtx/color_space_YCoCg.inl

@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
 template <typename valType> 
 GLM_FUNC_QUALIFIER detail::tvec3<valType> rgb2YCoCg
@@ -63,5 +62,4 @@ GLM_FUNC_QUALIFIER detail::tvec3<valType> YCoCgR2rgb
 	return result;
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/compatibility.hpp

@@ -53,8 +53,7 @@
 #include <cmath>
 #endif//GLM_COMPILER
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_compatibility
 	/// @{
@@ -124,21 +123,21 @@ namespace gtx
 	typedef detail::tmat4x3<int>		int4x3;			//!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
 	typedef detail::tmat4x4<int>		int4x4;			//!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
-	typedef gtc::half						half1;			//!< \brief half-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec2<gtc::half>		half2;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec3<gtc::half>		half3;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tvec4<gtc::half>		half4;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-
-	typedef gtc::half						half1x1;		//!< \brief half-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x2<gtc::half>		half2x2;		//!< \brief half-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x3<gtc::half>		half2x3;		//!< \brief half-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat2x4<gtc::half>		half2x4;		//!< \brief half-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x2<gtc::half>		half3x2;		//!< \brief half-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x3<gtc::half>		half3x3;		//!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat3x4<gtc::half>		half3x4;		//!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x2<gtc::half>		half4x2;		//!< \brief half-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x3<gtc::half>		half4x3;		//!< \brief half-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-	typedef detail::tmat4x4<gtc::half>		half4x4;		//!< \brief half-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::thalf					half1;			//!< \brief half-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec2<detail::thalf>	half2;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec3<detail::thalf>	half3;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec4<detail::thalf>	half4;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+
+	typedef detail::thalf					half1x1;		//!< \brief half-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x2<detail::thalf>	half2x2;		//!< \brief half-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x3<detail::thalf>	half2x3;		//!< \brief half-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x4<detail::thalf>	half2x4;		//!< \brief half-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x2<detail::thalf>	half3x2;		//!< \brief half-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x3<detail::thalf>	half3x3;		//!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x4<detail::thalf>	half3x4;		//!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x2<detail::thalf>	half4x2;		//!< \brief half-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x3<detail::thalf>	half4x3;		//!< \brief half-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x4<detail::thalf>	half4x4;		//!< \brief half-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
 	typedef float						float1;			//!< \brief single-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
 	typedef detail::tvec2<float>		float2;			//!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
@@ -173,7 +172,6 @@ namespace gtx
 	typedef detail::tmat4x4<double>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "compatibility.inl"

glm/gtx/compatibility.inl

@@ -8,8 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-namespace compatibility{
 
 // isfinite
 template <typename genType> 
@@ -136,6 +134,4 @@ GLM_FUNC_QUALIFIER detail::tvec4<bool> isnan(
 		isnan(x.w));
 }
 
-}//namespace compatibility
-}//namespace gtx
 }//namespace glm

glm/gtx/component_wise.hpp

@@ -45,8 +45,7 @@
 #	pragma message("GLM: GLM_GTX_component_wise extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_component_wise
 	/// @{
@@ -76,7 +75,6 @@ namespace gtx
 		genType const & v);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "component_wise.inl"

glm/gtx/component_wise.inl

@@ -8,43 +8,41 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx
+
+template <typename genType>
+GLM_FUNC_QUALIFIER typename genType::value_type compAdd(genType const & v)
 {
-	template <typename genType>
-	GLM_FUNC_QUALIFIER typename genType::value_type compAdd(genType const & v)
-	{
-        typename genType::size_type result = typename genType::value_type(0);
-		for(typename genType::size_type i = 0; i < genType::value_size(); ++i)
-			result += v[i];
-		return result;
-	}
+    typename genType::size_type result = typename genType::value_type(0);
+	for(typename genType::size_type i = 0; i < genType::value_size(); ++i)
+		result += v[i];
+	return result;
+}
 
-	template <typename genType>
-	GLM_FUNC_QUALIFIER typename genType::value_type compMul(genType const & v)
-	{
-        typename genType::value_type result = typename genType::value_type(1);
-		for(typename genType::size_type i = 0; i < genType::value_size(); ++i)
-			result *= v[i];
-		return result;
-	}
+template <typename genType>
+GLM_FUNC_QUALIFIER typename genType::value_type compMul(genType const & v)
+{
+    typename genType::value_type result = typename genType::value_type(1);
+	for(typename genType::size_type i = 0; i < genType::value_size(); ++i)
+		result *= v[i];
+	return result;
+}
 
-	template <typename genType>
-	GLM_FUNC_QUALIFIER typename genType::value_type compMin(genType const & v)
-	{
-        typename genType::value_type result = typename genType::value_type(v[0]);
-		for(typename genType::size_type i = 1; i < genType::value_size(); ++i)
-			result = min(result, v[i]);
-		return result;
-	}
+template <typename genType>
+GLM_FUNC_QUALIFIER typename genType::value_type compMin(genType const & v)
+{
+    typename genType::value_type result = typename genType::value_type(v[0]);
+	for(typename genType::size_type i = 1; i < genType::value_size(); ++i)
+		result = min(result, v[i]);
+	return result;
+}
 
-	template <typename genType>
-	GLM_FUNC_QUALIFIER typename genType::value_type compMax(genType const & v)
-	{
-        typename genType::value_type result = typename genType::value_type(v[0]);
-		for(typename genType::size_type i = 1; i < genType::value_size(); ++i)
-			result = max(result, v[i]);
-		return result;
-	}
+template <typename genType>
+GLM_FUNC_QUALIFIER typename genType::value_type compMax(genType const & v)
+{
+    typename genType::value_type result = typename genType::value_type(v[0]);
+	for(typename genType::size_type i = 1; i < genType::value_size(); ++i)
+		result = max(result, v[i]);
+	return result;
+}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/epsilon.hpp

@@ -49,8 +49,7 @@
 #	pragma message("GLM: GLM_GTX_epsilon extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_epsilon
 	/// @{
@@ -72,7 +71,6 @@ namespace gtx
 		genTypeU const & epsilon);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "epsilon.inl"

glm/gtx/epsilon.inl

@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
 template <typename genType>
 GLM_FUNC_QUALIFIER bool equalEpsilon
@@ -228,5 +227,4 @@ GLM_FUNC_QUALIFIER detail::tvec4<bool> notEqualEpsilon
         abs(x.w - y.w) >= epsilon.w);
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/euler_angles.hpp

@@ -50,8 +50,7 @@
 #	pragma message("GLM: GLM_GTX_euler_angles extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_euler_angles
 	/// @{
@@ -153,7 +152,6 @@ namespace gtx
 	detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "euler_angles.inl"

glm/gtx/euler_angles.inl

@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
 template <typename valType> 
 GLM_FUNC_QUALIFIER detail::tmat4x4<valType> eulerAngleX
@@ -243,5 +242,4 @@ GLM_FUNC_QUALIFIER detail::tmat4x4<valType> orientate4
     return yawPitchRoll(angles.z, angles.x, angles.y);
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/extend.hpp

@@ -45,8 +45,7 @@
 #	pragma message("GLM: GLM_GTX_extend extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_extend
 	/// @{
@@ -60,7 +59,6 @@ namespace gtx
 		typename genType::value_type const Length);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "extend.inl"

glm/gtx/extend.inl

@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
 template <typename genType>
 genType extend
@@ -54,5 +53,4 @@ detail::tvec4<valType> extend
     return Origin + (Source - Origin) * Distance;
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/extented_min_max.hpp

@@ -47,8 +47,7 @@
 #	pragma message("GLM: GLM_GTX_extented_min_max extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_extented_min_max
 	/// @{
@@ -188,7 +187,6 @@ namespace gtx
 		C<T> const & w);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "extented_min_max.inl"

glm/gtx/extented_min_max.inl

@@ -7,8 +7,7 @@
 // File    : gtx_extented_min_max.inl
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	template <typename T>
 	GLM_FUNC_QUALIFIER T min(
@@ -176,5 +175,4 @@ namespace gtx
 		return glm::max(glm::max(x, y), glm::max(z, w));
 	}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/fast_exponential.hpp

@@ -47,8 +47,7 @@
 #	pragma message("GLM: GLM_GTX_fast_exponential extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_fast_exponential
 	/// @{
@@ -93,7 +92,6 @@ namespace gtx
 	T fastLn(const T& x);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "fast_exponential.inl"

glm/gtx/fast_exponential.inl

@@ -8,285 +8,283 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx
+
+// fastPow:
+template <typename T>
+GLM_FUNC_QUALIFIER T fastPow(const T x, const T y)
 {
-    // fastPow:
-	template <typename T>
-    GLM_FUNC_QUALIFIER T fastPow(const T x, const T y)
-    {
-        return exp(y * log(x));
-    }
+    return exp(y * log(x));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> fastPow(
-		const detail::tvec2<T>& x, 
-		const detail::tvec2<T>& y)
-    {
-        return detail::tvec2<T>(
-            fastPow(x.x, y.x),
-            fastPow(x.y, y.y));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> fastPow(
+	const detail::tvec2<T>& x, 
+	const detail::tvec2<T>& y)
+{
+    return detail::tvec2<T>(
+        fastPow(x.x, y.x),
+        fastPow(x.y, y.y));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> fastPow(
-		const detail::tvec3<T>& x, 
-		const detail::tvec3<T>& y)
-    {
-        return detail::tvec3<T>(
-            fastPow(x.x, y.x),
-            fastPow(x.y, y.y),
-            fastPow(x.z, y.z));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> fastPow(
+	const detail::tvec3<T>& x, 
+	const detail::tvec3<T>& y)
+{
+    return detail::tvec3<T>(
+        fastPow(x.x, y.x),
+        fastPow(x.y, y.y),
+        fastPow(x.z, y.z));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> fastPow(
-		const detail::tvec4<T>& x, 
-		const detail::tvec4<T>& y)
-    {
-        return detail::tvec4<T>(
-            fastPow(x.x, y.x),
-            fastPow(x.y, y.y),
-            fastPow(x.z, y.z),
-            fastPow(x.w, y.w));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> fastPow(
+	const detail::tvec4<T>& x, 
+	const detail::tvec4<T>& y)
+{
+    return detail::tvec4<T>(
+        fastPow(x.x, y.x),
+        fastPow(x.y, y.y),
+        fastPow(x.z, y.z),
+        fastPow(x.w, y.w));
+}
 
-	template <typename T>
-	GLM_FUNC_QUALIFIER T fastPow(const T x, int y)
-    {
-        T f = T(1);
-        for(int i = 0; i < y; ++i)
-            f *= x;
-        return f;
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER T fastPow(const T x, int y)
+{
+    T f = T(1);
+    for(int i = 0; i < y; ++i)
+        f *= x;
+    return f;
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> fastPow(
-		const detail::tvec2<T>& x, 
-		const detail::tvec2<int>& y)
-    {
-        return detail::tvec2<T>(
-            fastPow(x.x, y.x),
-            fastPow(x.y, y.y));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> fastPow(
+	const detail::tvec2<T>& x, 
+	const detail::tvec2<int>& y)
+{
+    return detail::tvec2<T>(
+        fastPow(x.x, y.x),
+        fastPow(x.y, y.y));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> fastPow(
-		const detail::tvec3<T>& x, 
-		const detail::tvec3<int>& y)
-    {
-        return detail::tvec3<T>(
-            fastPow(x.x, y.x),
-            fastPow(x.y, y.y),
-            fastPow(x.z, y.z));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> fastPow(
+	const detail::tvec3<T>& x, 
+	const detail::tvec3<int>& y)
+{
+    return detail::tvec3<T>(
+        fastPow(x.x, y.x),
+        fastPow(x.y, y.y),
+        fastPow(x.z, y.z));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> fastPow(
-		const detail::tvec4<T>& x, 
-		const detail::tvec4<int>& y)
-    {
-        return detail::tvec4<T>(
-            fastPow(x.x, y.x),
-            fastPow(x.y, y.y),
-            fastPow(x.z, y.z),
-            fastPow(x.w, y.w));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> fastPow(
+	const detail::tvec4<T>& x, 
+	const detail::tvec4<int>& y)
+{
+    return detail::tvec4<T>(
+        fastPow(x.x, y.x),
+        fastPow(x.y, y.y),
+        fastPow(x.z, y.z),
+        fastPow(x.w, y.w));
+}
 
-    // fastExp
-    // Note: This function provides accurate results only for value between -1 and 1, else avoid it.
-	template <typename T>
-    GLM_FUNC_QUALIFIER T fastExp(const T x)
-    {
-        // This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
-        // return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
-        T x2 = x * x;
-        T x3 = x2 * x;
-        T x4 = x3 * x;
-        T x5 = x4 * x;
-        return T(1) + x + (x2 * T(0.5)) + (x3 * T(0.1666666667)) + (x4 * T(0.041666667)) + (x5 * T(0.008333333333));
-    }
+// fastExp
+// Note: This function provides accurate results only for value between -1 and 1, else avoid it.
+template <typename T>
+GLM_FUNC_QUALIFIER T fastExp(const T x)
+{
+    // This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
+    // return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
+    T x2 = x * x;
+    T x3 = x2 * x;
+    T x4 = x3 * x;
+    T x5 = x4 * x;
+    return T(1) + x + (x2 * T(0.5)) + (x3 * T(0.1666666667)) + (x4 * T(0.041666667)) + (x5 * T(0.008333333333));
+}
 /*  // Try to handle all values of float... but often shower than std::exp, glm::floor and the loop kill the performance
-    GLM_FUNC_QUALIFIER float fastExp(float x)
-    {
-        const float e = 2.718281828f;
-        const float IntegerPart = floor(x);
-        const float FloatPart = x - IntegerPart;
-        float z = 1.f;
+GLM_FUNC_QUALIFIER float fastExp(float x)
+{
+    const float e = 2.718281828f;
+    const float IntegerPart = floor(x);
+    const float FloatPart = x - IntegerPart;
+    float z = 1.f;
 
-        for(int i = 0; i < int(IntegerPart); ++i)
-            z *= e;
+    for(int i = 0; i < int(IntegerPart); ++i)
+        z *= e;
 
-        const float x2 = FloatPart * FloatPart;
-        const float x3 = x2 * FloatPart;
-        const float x4 = x3 * FloatPart;
-        const float x5 = x4 * FloatPart;
-        return z * (1.0f + FloatPart + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f));
-    }
+    const float x2 = FloatPart * FloatPart;
+    const float x3 = x2 * FloatPart;
+    const float x4 = x3 * FloatPart;
+    const float x5 = x4 * FloatPart;
+    return z * (1.0f + FloatPart + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f));
+}
 
-    // Increase accuracy on number bigger that 1 and smaller than -1 but it's not enough for high and negative numbers
-    GLM_FUNC_QUALIFIER float fastExp(float x)
-    {
-        // This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
-        // return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
-        float x2 = x * x;
-        float x3 = x2 * x;
-        float x4 = x3 * x;
-        float x5 = x4 * x;
-        float x6 = x5 * x;
-        float x7 = x6 * x;
-        float x8 = x7 * x;
-        return 1.0f + x + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f)+ (x6 * 0.00138888888888f) + (x7 * 0.000198412698f) + (x8 * 0.0000248015873f);;
-    }
+// Increase accuracy on number bigger that 1 and smaller than -1 but it's not enough for high and negative numbers
+GLM_FUNC_QUALIFIER float fastExp(float x)
+{
+    // This has a better looking and same performance in release mode than the following code. However, in debug mode it's slower.
+    // return 1.0f + x * (1.0f + x * 0.5f * (1.0f + x * 0.3333333333f * (1.0f + x * 0.25 * (1.0f + x * 0.2f))));
+    float x2 = x * x;
+    float x3 = x2 * x;
+    float x4 = x3 * x;
+    float x5 = x4 * x;
+    float x6 = x5 * x;
+    float x7 = x6 * x;
+    float x8 = x7 * x;
+    return 1.0f + x + (x2 * 0.5f) + (x3 * 0.1666666667f) + (x4 * 0.041666667f) + (x5 * 0.008333333333f)+ (x6 * 0.00138888888888f) + (x7 * 0.000198412698f) + (x8 * 0.0000248015873f);;
+}
 */
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> fastExp(
-		const detail::tvec2<T>& x)
-    {
-        return detail::tvec2<T>(
-            fastExp(x.x),
-            fastExp(x.y));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> fastExp(
+	const detail::tvec2<T>& x)
+{
+    return detail::tvec2<T>(
+        fastExp(x.x),
+        fastExp(x.y));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> fastExp(
-		const detail::tvec3<T>& x)
-    {
-        return detail::tvec3<T>(
-            fastExp(x.x),
-            fastExp(x.y),
-            fastExp(x.z));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> fastExp(
+	const detail::tvec3<T>& x)
+{
+    return detail::tvec3<T>(
+        fastExp(x.x),
+        fastExp(x.y),
+        fastExp(x.z));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> fastExp(
-		const detail::tvec4<T>& x)
-    {
-        return detail::tvec4<T>(
-            fastExp(x.x),
-            fastExp(x.y),
-            fastExp(x.z),
-            fastExp(x.w));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> fastExp(
+	const detail::tvec4<T>& x)
+{
+    return detail::tvec4<T>(
+        fastExp(x.x),
+        fastExp(x.y),
+        fastExp(x.z),
+        fastExp(x.w));
+}
 
-    // fastLog
-	template <typename T>
-    GLM_FUNC_QUALIFIER T fastLog(const T x)
-    {
-        return std::log(x);
-    }
+// fastLog
+template <typename T>
+GLM_FUNC_QUALIFIER T fastLog(const T x)
+{
+    return std::log(x);
+}
 
-    /* Slower than the VC7.1 function...
-    GLM_FUNC_QUALIFIER float fastLog(float x)
-    {
-        float y1 = (x - 1.0f) / (x + 1.0f);
-        float y2 = y1 * y1;
-        return 2.0f * y1 * (1.0f + y2 * (0.3333333333f + y2 * (0.2f + y2 * 0.1428571429f)));
-    }
-    */
+/* Slower than the VC7.1 function...
+GLM_FUNC_QUALIFIER float fastLog(float x)
+{
+    float y1 = (x - 1.0f) / (x + 1.0f);
+    float y2 = y1 * y1;
+    return 2.0f * y1 * (1.0f + y2 * (0.3333333333f + y2 * (0.2f + y2 * 0.1428571429f)));
+}
+*/
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> fastLog(
-		const detail::tvec2<T>& x)
-    {
-        return detail::tvec2<T>(
-            fastLog(x.x),
-            fastLog(x.y));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> fastLog(
+	const detail::tvec2<T>& x)
+{
+    return detail::tvec2<T>(
+        fastLog(x.x),
+        fastLog(x.y));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> fastLog(
-		const detail::tvec3<T>& x)
-    {
-        return detail::tvec3<T>(
-            fastLog(x.x),
-            fastLog(x.y),
-            fastLog(x.z));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> fastLog(
+	const detail::tvec3<T>& x)
+{
+    return detail::tvec3<T>(
+        fastLog(x.x),
+        fastLog(x.y),
+        fastLog(x.z));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> fastLog(
-		const detail::tvec4<T>& x)
-    {
-        return detail::tvec4<T>(
-            fastLog(x.x),
-            fastLog(x.y),
-            fastLog(x.z),
-            fastLog(x.w));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> fastLog(
+	const detail::tvec4<T>& x)
+{
+    return detail::tvec4<T>(
+        fastLog(x.x),
+        fastLog(x.y),
+        fastLog(x.z),
+        fastLog(x.w));
+}
 
-    //fastExp2, ln2 = 0.69314718055994530941723212145818f
-	template <typename T>
-    GLM_FUNC_QUALIFIER T fastExp2(const T x)
-    {
-        return fastExp(0.69314718055994530941723212145818f * x);
-    }
+//fastExp2, ln2 = 0.69314718055994530941723212145818f
+template <typename T>
+GLM_FUNC_QUALIFIER T fastExp2(const T x)
+{
+    return fastExp(0.69314718055994530941723212145818f * x);
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> fastExp2(
-		const detail::tvec2<T>& x)
-    {
-        return detail::tvec2<T>(
-            fastExp2(x.x),
-            fastExp2(x.y));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> fastExp2(
+	const detail::tvec2<T>& x)
+{
+    return detail::tvec2<T>(
+        fastExp2(x.x),
+        fastExp2(x.y));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> fastExp2(
-		const detail::tvec3<T>& x)
-    {
-        return detail::tvec3<T>(
-            fastExp2(x.x),
-            fastExp2(x.y),
-            fastExp2(x.z));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> fastExp2(
+	const detail::tvec3<T>& x)
+{
+    return detail::tvec3<T>(
+        fastExp2(x.x),
+        fastExp2(x.y),
+        fastExp2(x.z));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> fastExp2(
-		const detail::tvec4<T>& x)
-    {
-        return detail::tvec4<T>(
-            fastExp2(x.x),
-            fastExp2(x.y),
-            fastExp2(x.z),
-            fastExp2(x.w));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> fastExp2(
+	const detail::tvec4<T>& x)
+{
+    return detail::tvec4<T>(
+        fastExp2(x.x),
+        fastExp2(x.y),
+        fastExp2(x.z),
+        fastExp2(x.w));
+}
 
-    // fastLog2, ln2 = 0.69314718055994530941723212145818f
-	template <typename T>
-    GLM_FUNC_QUALIFIER T fastLog2(const T x)
-    {
-        return fastLog(x) / 0.69314718055994530941723212145818f;
-    }
+// fastLog2, ln2 = 0.69314718055994530941723212145818f
+template <typename T>
+GLM_FUNC_QUALIFIER T fastLog2(const T x)
+{
+    return fastLog(x) / 0.69314718055994530941723212145818f;
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec2<T> fastLog2(
-		const detail::tvec2<T>& x)
-    {
-        return detail::tvec2<T>(
-            fastLog2(x.x),
-            fastLog2(x.y));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec2<T> fastLog2(
+	const detail::tvec2<T>& x)
+{
+    return detail::tvec2<T>(
+        fastLog2(x.x),
+        fastLog2(x.y));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec3<T> fastLog2(
-		const detail::tvec3<T>& x)
-    {
-        return detail::tvec3<T>(
-            fastLog2(x.x),
-            fastLog2(x.y),
-            fastLog2(x.z));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec3<T> fastLog2(
+	const detail::tvec3<T>& x)
+{
+    return detail::tvec3<T>(
+        fastLog2(x.x),
+        fastLog2(x.y),
+        fastLog2(x.z));
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tvec4<T> fastLog2(
-		const detail::tvec4<T>& x)
-    {
-        return detail::tvec4<T>(
-            fastLog2(x.x),
-            fastLog2(x.y),
-            fastLog2(x.z),
-            fastLog2(x.w));
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> fastLog2(
+	const detail::tvec4<T>& x)
+{
+    return detail::tvec4<T>(
+        fastLog2(x.x),
+        fastLog2(x.y),
+        fastLog2(x.z),
+        fastLog2(x.w));
+}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/fast_square_root.hpp

@@ -47,8 +47,7 @@
 #	pragma message("GLM: GLM_GTX_fast_square_root extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_fast_square_root
 	/// @{
@@ -79,7 +78,6 @@ namespace gtx
 	genType fastNormalize(genType const & x);
 
 	/// @}
-}// namespace gtx
 }// namespace glm
 
 #include "fast_square_root.inl"

glm/gtx/fast_square_root.inl

@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
 // fastSqrt
 template <typename genType>
@@ -231,5 +230,4 @@ GLM_FUNC_QUALIFIER detail::tvec4<valType> fastNormalize
     return x * fastInverseSqrt(sqr);
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/fast_trigonometry.hpp

@@ -45,8 +45,7 @@
 #	pragma message("GLM: GLM_GTX_fast_trigonometry extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_fast_trigonometry
 	/// @{
@@ -94,7 +93,6 @@ namespace gtx
 	T fastAtan(const T& angle);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "fast_trigonometry.inl"

glm/gtx/fast_trigonometry.inl

@@ -8,263 +8,261 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx
+
+// sin
+template <typename T> 
+GLM_FUNC_QUALIFIER T fastSin(const T x)
 {
-    // sin
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T fastSin(const T x)
-    {
-        return x - ((x * x * x) / T(6)) + ((x * x * x * x * x) / T(120)) - ((x * x * x * x * x * x * x) / T(5040));
-    }
+    return x - ((x * x * x) / T(6)) + ((x * x * x * x * x) / T(120)) - ((x * x * x * x * x * x * x) / T(5040));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec2<T> fastSin(
-		const detail::tvec2<T>& x)
-    {
-        return detail::tvec2<T>(
-            fastSin(x.x),
-            fastSin(x.y));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> fastSin(
+	const detail::tvec2<T>& x)
+{
+    return detail::tvec2<T>(
+        fastSin(x.x),
+        fastSin(x.y));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> fastSin(
-		const detail::tvec3<T>& x)
-    {
-        return detail::tvec3<T>(
-            fastSin(x.x),
-            fastSin(x.y),
-            fastSin(x.z));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> fastSin(
+	const detail::tvec3<T>& x)
+{
+    return detail::tvec3<T>(
+        fastSin(x.x),
+        fastSin(x.y),
+        fastSin(x.z));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec4<T> fastSin(
-		const detail::tvec4<T>& x)
-    {
-        return detail::tvec4<T>(
-            fastSin(x.x),
-            fastSin(x.y),
-            fastSin(x.z),
-            fastSin(x.w));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> fastSin(
+	const detail::tvec4<T>& x)
+{
+    return detail::tvec4<T>(
+        fastSin(x.x),
+        fastSin(x.y),
+        fastSin(x.z),
+        fastSin(x.w));
+}
 
-    // cos
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T fastCos(const T x)
-    {
-        return T(1) - (x * x * T(0.5)) + (x * x * x * x * T(0.041666666666)) - (x * x * x * x * x * x * T(0.00138888888888));
-    }
+// cos
+template <typename T> 
+GLM_FUNC_QUALIFIER T fastCos(const T x)
+{
+    return T(1) - (x * x * T(0.5)) + (x * x * x * x * T(0.041666666666)) - (x * x * x * x * x * x * T(0.00138888888888));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec2<T> fastCos(
-		const detail::tvec2<T>& x)
-    {
-        return detail::tvec2<T>(
-            fastCos(x.x),
-            fastCos(x.y));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> fastCos(
+	const detail::tvec2<T>& x)
+{
+    return detail::tvec2<T>(
+        fastCos(x.x),
+        fastCos(x.y));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> fastCos(
-		const detail::tvec3<T>& x)
-    {
-        return detail::tvec3<T>(
-            fastCos(x.x),
-            fastCos(x.y),
-            fastCos(x.z));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> fastCos(
+	const detail::tvec3<T>& x)
+{
+    return detail::tvec3<T>(
+        fastCos(x.x),
+        fastCos(x.y),
+        fastCos(x.z));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec4<T> fastCos(
-		const detail::tvec4<T>& x)
-    {
-        return detail::tvec4<T>(
-            fastCos(x.x),
-            fastCos(x.y),
-            fastCos(x.z),
-            fastCos(x.w));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> fastCos(
+	const detail::tvec4<T>& x)
+{
+    return detail::tvec4<T>(
+        fastCos(x.x),
+        fastCos(x.y),
+        fastCos(x.z),
+        fastCos(x.w));
+}
 
-    // tan
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T fastTan(const T x)
-    {
-        return x + (x * x * x * T(0.3333333333)) + (x * x * x * x * x * T(0.1333333333333)) + (x * x * x * x * x * x * x * T(0.0539682539));
-    }
+// tan
+template <typename T> 
+GLM_FUNC_QUALIFIER T fastTan(const T x)
+{
+    return x + (x * x * x * T(0.3333333333)) + (x * x * x * x * x * T(0.1333333333333)) + (x * x * x * x * x * x * x * T(0.0539682539));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec2<T> fastTan(
-		const detail::tvec2<T>& x)
-    {
-        return detail::tvec2<T>(
-            fastTan(x.x),
-            fastTan(x.y));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> fastTan(
+	const detail::tvec2<T>& x)
+{
+    return detail::tvec2<T>(
+        fastTan(x.x),
+        fastTan(x.y));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> fastTan(
-		const detail::tvec3<T>& x)
-    {
-        return detail::tvec3<T>(
-            fastTan(x.x),
-            fastTan(x.y),
-            fastTan(x.z));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> fastTan(
+	const detail::tvec3<T>& x)
+{
+    return detail::tvec3<T>(
+        fastTan(x.x),
+        fastTan(x.y),
+        fastTan(x.z));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec4<T> fastTan(
-		const detail::tvec4<T>& x)
-    {
-        return detail::tvec4<T>(
-            fastTan(x.x),
-            fastTan(x.y),
-            fastTan(x.z),
-            fastTan(x.w));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> fastTan(
+	const detail::tvec4<T>& x)
+{
+    return detail::tvec4<T>(
+        fastTan(x.x),
+        fastTan(x.y),
+        fastTan(x.z),
+        fastTan(x.w));
+}
 
-    // asin
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T fastAsin(const T x)
-    {
-        return x + (x * x * x * T(0.166666667)) + (x * x * x * x * x * T(0.075)) + (x * x * x * x * x * x * x * T(0.0446428571)) + (x * x * x * x * x * x * x * x * x * T(0.0303819444));// + (x * x * x * x * x * x * x * x * x * x * x * T(0.022372159));
-    }
+// asin
+template <typename T> 
+GLM_FUNC_QUALIFIER T fastAsin(const T x)
+{
+    return x + (x * x * x * T(0.166666667)) + (x * x * x * x * x * T(0.075)) + (x * x * x * x * x * x * x * T(0.0446428571)) + (x * x * x * x * x * x * x * x * x * T(0.0303819444));// + (x * x * x * x * x * x * x * x * x * x * x * T(0.022372159));
+}
 
-    template <typename T> detail::tvec2<T> fastAsin(
-		const detail::tvec2<T>& x)
-    {
-        return detail::tvec2<T>(
-            fastAsin(x.x),
-            fastAsin(x.y));
-    }
+template <typename T> detail::tvec2<T> fastAsin(
+	const detail::tvec2<T>& x)
+{
+    return detail::tvec2<T>(
+        fastAsin(x.x),
+        fastAsin(x.y));
+}
 
-    template <typename T> detail::tvec3<T> fastAsin(
-		const detail::tvec3<T>& x)
-    {
-        return detail::tvec3<T>(
-            fastAsin(x.x),
-            fastAsin(x.y),
-            fastAsin(x.z));
-    }
+template <typename T> detail::tvec3<T> fastAsin(
+	const detail::tvec3<T>& x)
+{
+    return detail::tvec3<T>(
+        fastAsin(x.x),
+        fastAsin(x.y),
+        fastAsin(x.z));
+}
 
-    template <typename T> detail::tvec4<T> fastAsin(
-		const detail::tvec4<T>& x)
-    {
-        return detail::tvec4<T>(
-            fastAsin(x.x),
-            fastAsin(x.y),
-            fastAsin(x.z),
-            fastAsin(x.w));
-    }
+template <typename T> detail::tvec4<T> fastAsin(
+	const detail::tvec4<T>& x)
+{
+    return detail::tvec4<T>(
+        fastAsin(x.x),
+        fastAsin(x.y),
+        fastAsin(x.z),
+        fastAsin(x.w));
+}
 
-    // acos
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T fastAcos(const T x)
-    {
-        return T(1.5707963267948966192313216916398) - fastAsin(x); //(PI / 2)
-    }
+// acos
+template <typename T> 
+GLM_FUNC_QUALIFIER T fastAcos(const T x)
+{
+    return T(1.5707963267948966192313216916398) - fastAsin(x); //(PI / 2)
+}
 
-    template <typename T> detail::tvec2<T> fastAcos(
-		const detail::tvec2<T>& x)
-    {
-        return detail::tvec2<T>(
-            fastAcos(x.x),
-            fastAcos(x.y));
-    }
+template <typename T> detail::tvec2<T> fastAcos(
+	const detail::tvec2<T>& x)
+{
+    return detail::tvec2<T>(
+        fastAcos(x.x),
+        fastAcos(x.y));
+}
 
-    template <typename T> detail::tvec3<T> fastAcos(
-		const detail::tvec3<T>& x)
-    {
-        return detail::tvec3<T>(
-            fastAcos(x.x),
-            fastAcos(x.y),
-            fastAcos(x.z));
-    }
+template <typename T> detail::tvec3<T> fastAcos(
+	const detail::tvec3<T>& x)
+{
+    return detail::tvec3<T>(
+        fastAcos(x.x),
+        fastAcos(x.y),
+        fastAcos(x.z));
+}
 
-    template <typename T> detail::tvec4<T> fastAcos(
-		const detail::tvec4<T>& x)
-    {
-        return detail::tvec4<T>(
-            fastAcos(x.x),
-            fastAcos(x.y),
-            fastAcos(x.z),
-            fastAcos(x.w));
-    }
+template <typename T> detail::tvec4<T> fastAcos(
+	const detail::tvec4<T>& x)
+{
+    return detail::tvec4<T>(
+        fastAcos(x.x),
+        fastAcos(x.y),
+        fastAcos(x.z),
+        fastAcos(x.w));
+}
 
-    // atan
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T fastAtan(const T y, const T x)
-    {
-        T sgn = sign(y) * sign(x);
-        return abs(fastAtan(y / x)) * sgn;
-    }
+// atan
+template <typename T> 
+GLM_FUNC_QUALIFIER T fastAtan(const T y, const T x)
+{
+    T sgn = sign(y) * sign(x);
+    return abs(fastAtan(y / x)) * sgn;
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec2<T> fastAtan(
-		const detail::tvec2<T>& y, 
-		const detail::tvec2<T>& x)
-    {
-        return detail::tvec2<T>(
-            fastAtan(y.x, x.x),
-            fastAtan(y.y, x.y));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> fastAtan(
+	const detail::tvec2<T>& y, 
+	const detail::tvec2<T>& x)
+{
+    return detail::tvec2<T>(
+        fastAtan(y.x, x.x),
+        fastAtan(y.y, x.y));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> fastAtan(
-		const detail::tvec3<T>& y, 
-		const detail::tvec3<T>& x)
-    {
-        return detail::tvec3<T>(
-            fastAtan(y.x, x.x),
-            fastAtan(y.y, x.y),
-            fastAtan(y.z, x.z));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> fastAtan(
+	const detail::tvec3<T>& y, 
+	const detail::tvec3<T>& x)
+{
+    return detail::tvec3<T>(
+        fastAtan(y.x, x.x),
+        fastAtan(y.y, x.y),
+        fastAtan(y.z, x.z));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec4<T> fastAtan(
-		const detail::tvec4<T>& y, 
-		const detail::tvec4<T>& x)
-    {
-        return detail::tvec4<T>(
-            fastAtan(y.x, x.x),
-            fastAtan(y.y, x.y),
-            fastAtan(y.z, x.z),
-            fastAtan(y.w, x.w));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> fastAtan(
+	const detail::tvec4<T>& y, 
+	const detail::tvec4<T>& x)
+{
+    return detail::tvec4<T>(
+        fastAtan(y.x, x.x),
+        fastAtan(y.y, x.y),
+        fastAtan(y.z, x.z),
+        fastAtan(y.w, x.w));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T fastAtan(const T x)
-    {
-        return x - (x * x * x * T(0.333333333333)) + (x * x * x * x * x * T(0.2)) - (x * x * x * x * x * x * x * T(0.1428571429)) + (x * x * x * x * x * x * x * x * x * T(0.111111111111)) - (x * x * x * x * x * x * x * x * x * x * x * T(0.0909090909));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER T fastAtan(const T x)
+{
+    return x - (x * x * x * T(0.333333333333)) + (x * x * x * x * x * T(0.2)) - (x * x * x * x * x * x * x * T(0.1428571429)) + (x * x * x * x * x * x * x * x * x * T(0.111111111111)) - (x * x * x * x * x * x * x * x * x * x * x * T(0.0909090909));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec2<T> fastAtan(
-		const detail::tvec2<T>& x)
-    {
-        return detail::tvec2<T>(
-            fastAtan(x.x),
-            fastAtan(x.y));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> fastAtan(
+	const detail::tvec2<T>& x)
+{
+    return detail::tvec2<T>(
+        fastAtan(x.x),
+        fastAtan(x.y));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec3<T> fastAtan(
-		const detail::tvec3<T>& x)
-    {
-        return detail::tvec3<T>(
-            fastAtan(x.x),
-            fastAtan(x.y),
-            fastAtan(x.z));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> fastAtan(
+	const detail::tvec3<T>& x)
+{
+    return detail::tvec3<T>(
+        fastAtan(x.x),
+        fastAtan(x.y),
+        fastAtan(x.z));
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tvec4<T> fastAtan(
-		const detail::tvec4<T>& x)
-    {
-        return detail::tvec4<T>(
-            fastAtan(x.x),
-            fastAtan(x.y),
-            fastAtan(x.z),
-            fastAtan(x.w));
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> fastAtan(
+	const detail::tvec4<T>& x)
+{
+    return detail::tvec4<T>(
+        fastAtan(x.x),
+        fastAtan(x.y),
+        fastAtan(x.z),
+        fastAtan(x.w));
+}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/gradient_paint.hpp

@@ -46,8 +46,7 @@
 #	pragma message("GLM: GLM_GTX_gradient_paint extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_gradient_paint
 	/// @{
@@ -70,7 +69,6 @@ namespace gtx
 		glm::detail::tvec2<valType> const & Position);
 
 	/// @}
-}// namespace gtx
 }// namespace glm
 
 #include "gradient_paint.inl"

glm/gtx/gradient_paint.inl

@@ -8,35 +8,33 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
-	template <typename valType>
-	valType radialGradient(
-		glm::detail::tvec2<valType> const & Center,
-		valType const & Radius,
-		glm::detail::tvec2<valType> const & Focal,
-		glm::detail::tvec2<valType> const & Position)
-	{
-		glm::detail::tvec2<valType> F = Focal - Center;
-		glm::detail::tvec2<valType> D = Position - Focal;
-		valType Radius2 = gtx::pow2(Radius);
-		valType Fx2 = gtx::pow2(F.x);
-		valType Fy2 = gtx::pow2(F.y);
+template <typename valType>
+valType radialGradient(
+	glm::detail::tvec2<valType> const & Center,
+	valType const & Radius,
+	glm::detail::tvec2<valType> const & Focal,
+	glm::detail::tvec2<valType> const & Position)
+{
+	glm::detail::tvec2<valType> F = Focal - Center;
+	glm::detail::tvec2<valType> D = Position - Focal;
+	valType Radius2 = gtx::pow2(Radius);
+	valType Fx2 = gtx::pow2(F.x);
+	valType Fy2 = gtx::pow2(F.y);
 
-		valType Numerator = (D.x * F.x + D.y * F.y) + glm::sqrt(Radius2 * (gtx::pow2(D.x) + gtx::pow2(D.y)) - gtx::pow2(D.x * F.y - D.y * F.x));
-		valType Denominator = Radius2 - (Fx2 + Fy2);
-		return Numerator / Denominator;
-	}
+	valType Numerator = (D.x * F.x + D.y * F.y) + glm::sqrt(Radius2 * (gtx::pow2(D.x) + gtx::pow2(D.y)) - gtx::pow2(D.x * F.y - D.y * F.x));
+	valType Denominator = Radius2 - (Fx2 + Fy2);
+	return Numerator / Denominator;
+}
 
-	template <typename valType>
-	valType linearGradient(
-		glm::detail::tvec2<valType> const & Point0,
-		glm::detail::tvec2<valType> const & Point1,
-		glm::detail::tvec2<valType> const & Position)
-	{
-		glm::detail::tvec2<valType> Dist = Point1 - Point0;
-		return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
-	}
+template <typename valType>
+valType linearGradient(
+	glm::detail::tvec2<valType> const & Point0,
+	glm::detail::tvec2<valType> const & Point1,
+	glm::detail::tvec2<valType> const & Position)
+{
+	glm::detail::tvec2<valType> Dist = Point1 - Point0;
+	return (Dist.x * (Position.x - Point0.x) + Dist.y * (Position.y - Point0.y)) / glm::dot(Dist, Dist);
+}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/handed_coordinate_space.hpp

@@ -45,8 +45,7 @@
 #	pragma message("GLM: GLM_GTX_handed_coordinate_space extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_handed_coordinate_space
 	/// @{
@@ -68,7 +67,6 @@ namespace gtx
 		detail::tvec3<T> const & normal);
 
 	/// @}
-}// namespace gtx
 }// namespace glm
 
 #include "handed_coordinate_space.inl"

glm/gtx/handed_coordinate_space.inl

@@ -8,25 +8,23 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx
+
+template <typename T> 
+GLM_FUNC_QUALIFIER bool rightHanded(
+	detail::tvec3<T> const & tangent, 
+	detail::tvec3<T> const & binormal,
+	detail::tvec3<T> const & normal)
 {
-    template <typename T> 
-    GLM_FUNC_QUALIFIER bool rightHanded(
-		detail::tvec3<T> const & tangent, 
-		detail::tvec3<T> const & binormal,
-		detail::tvec3<T> const & normal)
-    {
-        return dot(cross(normal, tangent), binormal) > T(0);
-    }
+    return dot(cross(normal, tangent), binormal) > T(0);
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER bool leftHanded(
-		detail::tvec3<T> const & tangent, 
-		detail::tvec3<T> const & binormal, 
-		detail::tvec3<T> const & normal)
-    {
-        return dot(cross(normal, tangent), binormal) < T(0);
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER bool leftHanded(
+	detail::tvec3<T> const & tangent, 
+	detail::tvec3<T> const & binormal, 
+	detail::tvec3<T> const & normal)
+{
+    return dot(cross(normal, tangent), binormal) < T(0);
+}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/inertia.hpp

@@ -46,8 +46,7 @@
 #	pragma message("GLM: GLM_GTX_inertia extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_inertia
 	/// @{
@@ -109,7 +108,6 @@ namespace gtx
 		const T Radius);
 
 	/// @}
-}// namespace gtx
 }// namespace glm
 
 #include "inertia.inl"

glm/gtx/inertia.inl

@@ -8,94 +8,92 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat3x3<T> boxInertia3(
-		const T Mass, 
-		const detail::tvec3<T>& Scale)
-    {
-	    detail::tmat3x3<T> Result(T(1));
-	    Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
-	    Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
-	    Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
-        return Result;
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat3x3<T> boxInertia3(
+	const T Mass, 
+	const detail::tvec3<T>& Scale)
+{
+	detail::tmat3x3<T> Result(T(1));
+	Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
+	Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
+	Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
+    return Result;
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> boxInertia4(
-		const T Mass, 
-		const detail::tvec3<T>& Scale)
-    {
-	    detail::tmat4x4<T> Result(T(1));
-	    Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
-	    Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
-	    Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
-        return Result;
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> boxInertia4(
+	const T Mass, 
+	const detail::tvec3<T>& Scale)
+{
+	detail::tmat4x4<T> Result(T(1));
+	Result[0][0] = (Scale.y * Scale.y + Scale.z * Scale.z) * Mass / T(12);
+	Result[1][1] = (Scale.x * Scale.x + Scale.z * Scale.z) * Mass / T(12);
+	Result[2][2] = (Scale.x * Scale.x + Scale.y * Scale.y) * Mass / T(12);
+    return Result;
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat3x3<T> diskInertia3(
-		const T Mass, 
-		const T Radius)
-    {
-        T a = Mass * Radius * Radius / T(2);
-        detail::tmat3x3<T> Result(a);
-        Result[2][2] *= T(2);
-        return Result;
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat3x3<T> diskInertia3(
+	const T Mass, 
+	const T Radius)
+{
+    T a = Mass * Radius * Radius / T(2);
+    detail::tmat3x3<T> Result(a);
+    Result[2][2] *= T(2);
+    return Result;
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> diskInertia4(
-		const T Mass, 
-		const T Radius)
-    {
-        T a = Mass * Radius * Radius / T(2);
-        detail::tmat4x4<T> Result(a);
-        Result[2][2] *= T(2);
-        Result[3][3] = T(1);
-        return Result;
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> diskInertia4(
+	const T Mass, 
+	const T Radius)
+{
+    T a = Mass * Radius * Radius / T(2);
+    detail::tmat4x4<T> Result(a);
+    Result[2][2] *= T(2);
+    Result[3][3] = T(1);
+    return Result;
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat3x3<T> ballInertia3(
-		const T Mass, 
-		const T Radius)
-    {
-        T a = T(2) * Mass * Radius * Radius / T(5);
-        return detail::tmat3x3<T>(a);
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat3x3<T> ballInertia3(
+	const T Mass, 
+	const T Radius)
+{
+    T a = T(2) * Mass * Radius * Radius / T(5);
+    return detail::tmat3x3<T>(a);
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> ballInertia4(
-		const T Mass, 
-		const T Radius)
-    {
-        T a = T(2) * Mass * Radius * Radius / T(5);
-        detail::tmat4x4<T> Result(a);
-        Result[3][3] = T(1);
-        return Result;
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> ballInertia4(
+	const T Mass, 
+	const T Radius)
+{
+    T a = T(2) * Mass * Radius * Radius / T(5);
+    detail::tmat4x4<T> Result(a);
+    Result[3][3] = T(1);
+    return Result;
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat3x3<T> sphereInertia3(
-		const T Mass, 
-		const T Radius)
-    {
-        T a = T(2) * Mass * Radius * Radius / T(3);
-        return detail::tmat3x3<T>(a);
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat3x3<T> sphereInertia3(
+	const T Mass, 
+	const T Radius)
+{
+    T a = T(2) * Mass * Radius * Radius / T(3);
+    return detail::tmat3x3<T>(a);
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> sphereInertia4(
-		const T Mass, 
-		const T Radius)
-    {
-        T a = T(2) * Mass * Radius * Radius / T(3);
-        detail::tmat4x4<T> Result(a);
-        Result[3][3] = T(1);
-        return Result;
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> sphereInertia4(
+	const T Mass, 
+	const T Radius)
+{
+    T a = T(2) * Mass * Radius * Radius / T(3);
+    detail::tmat4x4<T> Result(a);
+    Result[3][3] = T(1);
+    return Result;
+}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/int_10_10_10_2.hpp

@@ -47,8 +47,7 @@
 #	pragma message("GLM: GLM_GTX_int_10_10_10_2 extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_int_10_10_10_2
 	/// @{
@@ -58,7 +57,6 @@ namespace gtx
 	dword uint10_10_10_2_cast(glm::vec4 const & v);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "int_10_10_10_2.inl"

glm/gtx/int_10_10_10_2.inl

@@ -8,12 +8,10 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
 GLM_FUNC_QUALIFIER dword uint10_10_10_2_cast(glm::vec4 const & v)
 {
     return dword(uint(v.x * 2047.f) << 0 | uint(v.y * 2047.f) << 10 | uint(v.z * 2047.f) << 20 | uint(v.w * 3.f) << 30);
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/integer.hpp

@@ -45,8 +45,7 @@
 #	pragma message("GLM: GLM_GTX_integer extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_integer
 	/// @{
@@ -69,7 +68,6 @@ namespace gtx
 	genType factorial(genType const & x);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "integer.inl"

glm/gtx/integer.inl

@@ -8,82 +8,80 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
-    // pow
-    GLM_FUNC_QUALIFIER int pow(int x, int y)
-    {
-		if(y == 0)
-			return 1;
-        int result = x;
-        for(int i = 1; i < y; ++i)
-            result *= x;
-        return result;
-    }
+// pow
+GLM_FUNC_QUALIFIER int pow(int x, int y)
+{
+	if(y == 0)
+		return 1;
+    int result = x;
+    for(int i = 1; i < y; ++i)
+        result *= x;
+    return result;
+}
 
-    // sqrt: From Christopher J. Musial, An integer square root, Graphics Gems, 1990, page 387
-    GLM_FUNC_QUALIFIER int sqrt(int x)
-    {
-        if(x <= 1) return x;
+// sqrt: From Christopher J. Musial, An integer square root, Graphics Gems, 1990, page 387
+GLM_FUNC_QUALIFIER int sqrt(int x)
+{
+    if(x <= 1) return x;
 
-        int NextTrial = x >> 1;
-        int CurrentAnswer;
+    int NextTrial = x >> 1;
+    int CurrentAnswer;
 
-        do
-        {
-            CurrentAnswer = NextTrial;
-            NextTrial = (NextTrial + x / NextTrial) >> 1;
-        } while(NextTrial < CurrentAnswer);
+    do
+    {
+        CurrentAnswer = NextTrial;
+        NextTrial = (NextTrial + x / NextTrial) >> 1;
+    } while(NextTrial < CurrentAnswer);
 
-        return CurrentAnswer;
-    }
+    return CurrentAnswer;
+}
 
-    // mod
-	GLM_FUNC_QUALIFIER int mod(int x, int y)
-	{
-		return x - y * (x / y);
-	}
+// mod
+GLM_FUNC_QUALIFIER int mod(int x, int y)
+{
+	return x - y * (x / y);
+}
 
-    // factorial (!12 max, integer only)
-	template <typename genType>
-    GLM_FUNC_QUALIFIER genType factorial(genType const & x)
-    {
-		genType Temp = x;
-        genType Result;
-        for(Result = 1; Temp > 1; --Temp)
-            Result *= Temp;
-        return Result;
-    }
+// factorial (!12 max, integer only)
+template <typename genType>
+GLM_FUNC_QUALIFIER genType factorial(genType const & x)
+{
+	genType Temp = x;
+    genType Result;
+    for(Result = 1; Temp > 1; --Temp)
+        Result *= Temp;
+    return Result;
+}
 
-	template <typename valType>
-    GLM_FUNC_QUALIFIER detail::tvec2<valType> factorial(
-		detail::tvec2<valType> const & x)
-    {
-        return detail::tvec2<valType>(
-            factorial(x.x),
-            factorial(x.y));
-    }
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec2<valType> factorial(
+	detail::tvec2<valType> const & x)
+{
+    return detail::tvec2<valType>(
+        factorial(x.x),
+        factorial(x.y));
+}
 
-	template <typename valType>
-    GLM_FUNC_QUALIFIER detail::tvec3<valType> factorial(
-		detail::tvec3<valType> const & x)
-    {
-        return detail::tvec3<valType>(
-            factorial(x.x),
-            factorial(x.y),
-            factorial(x.z));
-    }
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec3<valType> factorial(
+	detail::tvec3<valType> const & x)
+{
+    return detail::tvec3<valType>(
+        factorial(x.x),
+        factorial(x.y),
+        factorial(x.z));
+}
 
-	template <typename valType>
-    GLM_FUNC_QUALIFIER detail::tvec4<valType> factorial(
-		detail::tvec4<valType> const & x)
-    {
-        return detail::tvec4<valType>(
-            factorial(x.x),
-            factorial(x.y),
-            factorial(x.z),
-            factorial(x.w));
-    }
+template <typename valType>
+GLM_FUNC_QUALIFIER detail::tvec4<valType> factorial(
+	detail::tvec4<valType> const & x)
+{
+    return detail::tvec4<valType>(
+        factorial(x.x),
+        factorial(x.y),
+        factorial(x.z),
+        factorial(x.w));
+}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/intersect.hpp

@@ -47,8 +47,7 @@
 #	pragma message("GLM: GLM_GTX_closest_point extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_intersect
 	/// @{
@@ -86,7 +85,6 @@ namespace gtx
 		genType & position, genType & normal);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "intersect.inl"

glm/gtx/intersect.inl

@@ -11,7 +11,6 @@
 #include <limits>
 
 namespace glm{
-namespace gtx{
 
 template <typename genType>
 GLM_FUNC_QUALIFIER bool intersectRayTriangle
@@ -195,5 +194,4 @@ GLM_FUNC_QUALIFIER bool intersectLineSphere
 	return false;
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/log_base.hpp

@@ -45,8 +45,7 @@
 #	pragma message("GLM: GLM_GTX_log_base extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_log_base
 	/// @{
@@ -59,7 +58,6 @@ namespace gtx
 		genType const & base);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "log_base.inl"

glm/gtx/log_base.inl

@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
 template <typename genType> 
 GLM_FUNC_QUALIFIER genType log(
@@ -86,5 +85,4 @@ GLM_FUNC_QUALIFIER detail::tvec4<valType> log(
 		log(v.w, base.w));
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/matrix_cross_product.hpp

@@ -46,8 +46,7 @@
 #	pragma message("GLM: GLM_GTX_matrix_cross_product extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_matrix_cross_product
 	/// @{
@@ -65,7 +64,6 @@ namespace gtx
 		detail::tvec3<T> const & x);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "matrix_cross_product.inl"

glm/gtx/matrix_cross_product.inl

@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
 template <typename T> 
 GLM_FUNC_QUALIFIER detail::tmat3x3<T> matrixCross3(
@@ -38,5 +37,4 @@ GLM_FUNC_QUALIFIER detail::tmat4x4<T> matrixCross4(
     return Result;
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/matrix_interpolation.hpp

@@ -45,8 +45,7 @@
 #	pragma message("GLM: GLM_GTX_matrix_interpolation extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_matrix_interpolation
 	/// @{
@@ -76,7 +75,6 @@ namespace gtx
         T const delta);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "matrix_interpolation.inl"

glm/gtx/matrix_interpolation.inl

@@ -8,108 +8,106 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER void axisAngle(
-        detail::tmat4x4<T> const & mat,
-        detail::tvec3<T> & axis,
-        T & angle)
-    {
-        T epsilon = (T)0.01;
-        T epsilon2 = (T)0.1;
+template <typename T>
+GLM_FUNC_QUALIFIER void axisAngle(
+    detail::tmat4x4<T> const & mat,
+    detail::tvec3<T> & axis,
+    T & angle)
+{
+    T epsilon = (T)0.01;
+    T epsilon2 = (T)0.1;
 
-        if ((fabs(mat[1][0] - mat[0][1]) < epsilon) && (fabs(mat[2][0] - mat[0][2]) < epsilon) && (fabs(mat[2][1] - mat[1][2]) < epsilon)) {
-            if ((fabs(mat[1][0] + mat[0][1]) < epsilon2) && (fabs(mat[2][0] + mat[0][2]) < epsilon2) && (fabs(mat[2][1] + mat[1][2]) < epsilon2) && (fabs(mat[0][0] + mat[1][1] + mat[2][2] - (T)3.0) < epsilon2)) {
-                angle = (T)0.0;
-                axis.x = (T)1.0;
+    if ((fabs(mat[1][0] - mat[0][1]) < epsilon) && (fabs(mat[2][0] - mat[0][2]) < epsilon) && (fabs(mat[2][1] - mat[1][2]) < epsilon)) {
+        if ((fabs(mat[1][0] + mat[0][1]) < epsilon2) && (fabs(mat[2][0] + mat[0][2]) < epsilon2) && (fabs(mat[2][1] + mat[1][2]) < epsilon2) && (fabs(mat[0][0] + mat[1][1] + mat[2][2] - (T)3.0) < epsilon2)) {
+            angle = (T)0.0;
+            axis.x = (T)1.0;
+            axis.y = (T)0.0;
+            axis.z = (T)0.0;
+            return;
+        }
+        angle = M_1_PI;
+        T xx = (mat[0][0] + (T)1.0) / (T)2.0;
+        T yy = (mat[1][1] + (T)1.0) / (T)2.0;
+        T zz = (mat[2][2] + (T)1.0) / (T)2.0;
+        T xy = (mat[1][0] + mat[0][1]) / (T)4.0;
+        T xz = (mat[2][0] + mat[0][2]) / (T)4.0;
+        T yz = (mat[2][1] + mat[1][2]) / (T)4.0;
+        if ((xx > yy) && (xx > zz)) {
+            if (xx < epsilon) {
+                axis.x = (T)0.0;
+                axis.y = (T)0.7071;
+                axis.z = (T)0.7071;
+            } else {
+                axis.x = sqrt(xx);
+                axis.y = xy / axis.x;
+                axis.z = xz / axis.x;
+            }
+        } else if (yy > zz) {
+            if (yy < epsilon) {
+                axis.x = (T)0.7071;
                 axis.y = (T)0.0;
-                axis.z = (T)0.0;
-                return;
+                axis.z = (T)0.7071;
+            } else {
+                axis.y = sqrt(yy);
+                axis.x = xy / axis.y;
+                axis.z = yz / axis.y;
             }
-            angle = M_1_PI;
-            T xx = (mat[0][0] + (T)1.0) / (T)2.0;
-            T yy = (mat[1][1] + (T)1.0) / (T)2.0;
-            T zz = (mat[2][2] + (T)1.0) / (T)2.0;
-            T xy = (mat[1][0] + mat[0][1]) / (T)4.0;
-            T xz = (mat[2][0] + mat[0][2]) / (T)4.0;
-            T yz = (mat[2][1] + mat[1][2]) / (T)4.0;
-            if ((xx > yy) && (xx > zz)) {
-                if (xx < epsilon) {
-                    axis.x = (T)0.0;
-                    axis.y = (T)0.7071;
-                    axis.z = (T)0.7071;
-                } else {
-                    axis.x = sqrt(xx);
-                    axis.y = xy / axis.x;
-                    axis.z = xz / axis.x;
-                }
-            } else if (yy > zz) {
-                if (yy < epsilon) {
-                    axis.x = (T)0.7071;
-                    axis.y = (T)0.0;
-                    axis.z = (T)0.7071;
-                } else {
-                    axis.y = sqrt(yy);
-                    axis.x = xy / axis.y;
-                    axis.z = yz / axis.y;
-                }
+        } else {
+            if (zz < epsilon) {
+                axis.x = (T)0.7071;
+                axis.y = (T)0.7071;
+                axis.z = (T)0.0;
             } else {
-                if (zz < epsilon) {
-                    axis.x = (T)0.7071;
-                    axis.y = (T)0.7071;
-                    axis.z = (T)0.0;
-                } else {
-                    axis.z = sqrt(zz);
-                    axis.x = xz / axis.z;
-                    axis.y = yz / axis.z;
-                }
+                axis.z = sqrt(zz);
+                axis.x = xz / axis.z;
+                axis.y = yz / axis.z;
             }
-            return;
         }
-        T s = sqrt((mat[2][1] - mat[1][2]) * (mat[2][1] - mat[1][2]) + (mat[2][0] - mat[0][2]) * (mat[2][0] - mat[0][2]) + (mat[1][0] - mat[0][1]) * (mat[1][0] - mat[0][1]));
-        if (glm::abs(s) < T(0.001))
-            s = (T)1.0;
-        angle = acos((mat[0][0] + mat[1][1] + mat[2][2] - (T)1.0) / (T)2.0);
-        axis.x = (mat[1][2] - mat[2][1]) / s;
-        axis.y = (mat[2][0] - mat[0][2]) / s;
-        axis.z = (mat[0][1] - mat[1][0]) / s;
+        return;
     }
+    T s = sqrt((mat[2][1] - mat[1][2]) * (mat[2][1] - mat[1][2]) + (mat[2][0] - mat[0][2]) * (mat[2][0] - mat[0][2]) + (mat[1][0] - mat[0][1]) * (mat[1][0] - mat[0][1]));
+    if (glm::abs(s) < T(0.001))
+        s = (T)1.0;
+    angle = acos((mat[0][0] + mat[1][1] + mat[2][2] - (T)1.0) / (T)2.0);
+    axis.x = (mat[1][2] - mat[2][1]) / s;
+    axis.y = (mat[2][0] - mat[0][2]) / s;
+    axis.z = (mat[0][1] - mat[1][0]) / s;
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> axisAngleMatrix(
-		detail::tvec3<T> const & axis,
-		T const angle)
-    {
-        T c = cos(angle);
-        T s = sin(angle);
-        T t = T(1) - c;
-        detail::tvec3<T> n = normalize(axis);
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> axisAngleMatrix(
+	detail::tvec3<T> const & axis,
+	T const angle)
+{
+    T c = cos(angle);
+    T s = sin(angle);
+    T t = T(1) - c;
+    detail::tvec3<T> n = normalize(axis);
 
-        return detail::tmat4x4<T>(
-            t * n.x * n.x + c,          t * n.x * n.y + n.z * s,    t * n.x * n.z - n.y * s,    T(0),
-            t * n.x * n.y - n.z * s,    t * n.y * n.y + c,          t * n.y * n.z + n.x * s,    T(0),
-            t * n.x * n.z + n.y * s,    t * n.y * n.z - n.x * s,    t * n.z * n.z + c,          T(0),
-            T(0),                        T(0),                        T(0),                     T(1)
-        );
-    }
+    return detail::tmat4x4<T>(
+        t * n.x * n.x + c,          t * n.x * n.y + n.z * s,    t * n.x * n.z - n.y * s,    T(0),
+        t * n.x * n.y - n.z * s,    t * n.y * n.y + c,          t * n.y * n.z + n.x * s,    T(0),
+        t * n.x * n.z + n.y * s,    t * n.y * n.z - n.x * s,    t * n.z * n.z + c,          T(0),
+        T(0),                        T(0),                        T(0),                     T(1)
+    );
+}
 
-    template <typename T>
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> interpolate(
-		detail::tmat4x4<T> const & m1,
-		detail::tmat4x4<T> const & m2,
-		T const delta)
-    {
-		detail::tmat4x4<T> dltRotation = m2 * transpose(m1);
-		detail::tvec3<T> dltAxis;
-		T dltAngle;
-		axisAngle(dltRotation, dltAxis, dltAngle);
-		detail::tmat4x4<T> out = axisAngleMatrix(dltAxis, dltAngle * delta) * rotationMatrix(m1);
-		out[3][0] = m1[3][0] + delta * (m2[3][0] - m1[3][0]);
-		out[3][1] = m1[3][1] + delta * (m2[3][1] - m1[3][1]);
-		out[3][2] = m1[3][2] + delta * (m2[3][2] - m1[3][2]);
-		return out;
-    }
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> interpolate(
+	detail::tmat4x4<T> const & m1,
+	detail::tmat4x4<T> const & m2,
+	T const delta)
+{
+	detail::tmat4x4<T> dltRotation = m2 * transpose(m1);
+	detail::tvec3<T> dltAxis;
+	T dltAngle;
+	axisAngle(dltRotation, dltAxis, dltAngle);
+	detail::tmat4x4<T> out = axisAngleMatrix(dltAxis, dltAngle * delta) * rotationMatrix(m1);
+	out[3][0] = m1[3][0] + delta * (m2[3][0] - m1[3][0]);
+	out[3][1] = m1[3][1] + delta * (m2[3][1] - m1[3][1]);
+	out[3][2] = m1[3][2] + delta * (m2[3][2] - m1[3][2]);
+	return out;
+}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/matrix_major_storage.hpp

@@ -46,10 +46,9 @@
 #	pragma message("GLM: GLM_GTX_matrix_major_storage extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
-	/// \addtogroup gtx_matrix_major_storage
+	/// @addtogroup gtx_matrix_major_storage
 	/// @{
 
 	//! Build a row major matrix from row vectors.
@@ -137,7 +136,6 @@ namespace gtx
 		const detail::tmat4x4<T>& m);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "matrix_major_storage.inl"

glm/gtx/matrix_major_storage.inl

@@ -8,167 +8,165 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat2x2<T> rowMajor2(
-		const detail::tvec2<T>& v1, 
-		const detail::tvec2<T>& v2)
-    {
-        detail::tmat2x2<T> Result;
-        Result[0][0] = v1.x;
-        Result[1][0] = v1.y;
-        Result[0][1] = v2.x;
-        Result[1][1] = v2.y;
-        return Result;
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat2x2<T> rowMajor2(
+	const detail::tvec2<T>& v1, 
+	const detail::tvec2<T>& v2)
+{
+    detail::tmat2x2<T> Result;
+    Result[0][0] = v1.x;
+    Result[1][0] = v1.y;
+    Result[0][1] = v2.x;
+    Result[1][1] = v2.y;
+    return Result;
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat2x2<T> rowMajor2(
-		const detail::tmat2x2<T>& m)
-    {
-        detail::tmat2x2<T> Result;
-        Result[0][0] = m[0][0];
-        Result[0][1] = m[1][0];
-        Result[1][0] = m[0][1];
-        Result[1][1] = m[1][1];
-        return Result;
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat2x2<T> rowMajor2(
+	const detail::tmat2x2<T>& m)
+{
+    detail::tmat2x2<T> Result;
+    Result[0][0] = m[0][0];
+    Result[0][1] = m[1][0];
+    Result[1][0] = m[0][1];
+    Result[1][1] = m[1][1];
+    return Result;
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat3x3<T> rowMajor3(
-		const detail::tvec3<T>& v1, 
-		const detail::tvec3<T>& v2, 
-		const detail::tvec3<T>& v3)
-    {
-        detail::tmat3x3<T> Result;
-        Result[0][0] = v1.x;
-        Result[1][0] = v1.y;
-        Result[2][0] = v1.z;
-        Result[0][1] = v2.x;
-        Result[1][1] = v2.y;
-        Result[2][1] = v2.z;
-        Result[0][2] = v3.x;
-        Result[1][2] = v3.y;
-        Result[2][2] = v3.z;
-        return Result;
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat3x3<T> rowMajor3(
+	const detail::tvec3<T>& v1, 
+	const detail::tvec3<T>& v2, 
+	const detail::tvec3<T>& v3)
+{
+    detail::tmat3x3<T> Result;
+    Result[0][0] = v1.x;
+    Result[1][0] = v1.y;
+    Result[2][0] = v1.z;
+    Result[0][1] = v2.x;
+    Result[1][1] = v2.y;
+    Result[2][1] = v2.z;
+    Result[0][2] = v3.x;
+    Result[1][2] = v3.y;
+    Result[2][2] = v3.z;
+    return Result;
+}
 
-    template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<T> rowMajor3(
-		const detail::tmat3x3<T>& m)
-    {
-        detail::tmat3x3<T> Result;
-        Result[0][0] = m[0][0];
-        Result[0][1] = m[1][0];
-        Result[0][2] = m[2][0];
-        Result[1][0] = m[0][1];
-        Result[1][1] = m[1][1];
-        Result[1][2] = m[2][1];
-        Result[2][0] = m[0][2];
-        Result[2][1] = m[1][2];
-        Result[2][2] = m[2][2];
-        return Result;
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat3x3<T> rowMajor3(
+	const detail::tmat3x3<T>& m)
+{
+    detail::tmat3x3<T> Result;
+    Result[0][0] = m[0][0];
+    Result[0][1] = m[1][0];
+    Result[0][2] = m[2][0];
+    Result[1][0] = m[0][1];
+    Result[1][1] = m[1][1];
+    Result[1][2] = m[2][1];
+    Result[2][0] = m[0][2];
+    Result[2][1] = m[1][2];
+    Result[2][2] = m[2][2];
+    return Result;
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rowMajor4(
-		const detail::tvec4<T>& v1, 
-		const detail::tvec4<T>& v2, 
-		const detail::tvec4<T>& v3, 
-		const detail::tvec4<T>& v4)
-    {
-        detail::tmat4x4<T> Result;
-        Result[0][0] = v1.x;
-        Result[1][0] = v1.y;
-        Result[2][0] = v1.z;
-        Result[3][0] = v1.w;
-        Result[0][1] = v2.x;
-        Result[1][1] = v2.y;
-        Result[2][1] = v2.z;
-        Result[3][1] = v2.w;
-        Result[0][2] = v3.x;
-        Result[1][2] = v3.y;
-        Result[2][2] = v3.z;
-        Result[3][2] = v3.w;
-        Result[0][3] = v4.x;
-        Result[1][3] = v4.y;
-        Result[2][3] = v4.z;
-        Result[3][3] = v4.w;
-        return Result;
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> rowMajor4(
+	const detail::tvec4<T>& v1, 
+	const detail::tvec4<T>& v2, 
+	const detail::tvec4<T>& v3, 
+	const detail::tvec4<T>& v4)
+{
+    detail::tmat4x4<T> Result;
+    Result[0][0] = v1.x;
+    Result[1][0] = v1.y;
+    Result[2][0] = v1.z;
+    Result[3][0] = v1.w;
+    Result[0][1] = v2.x;
+    Result[1][1] = v2.y;
+    Result[2][1] = v2.z;
+    Result[3][1] = v2.w;
+    Result[0][2] = v3.x;
+    Result[1][2] = v3.y;
+    Result[2][2] = v3.z;
+    Result[3][2] = v3.w;
+    Result[0][3] = v4.x;
+    Result[1][3] = v4.y;
+    Result[2][3] = v4.z;
+    Result[3][3] = v4.w;
+    return Result;
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> rowMajor4(
-		const detail::tmat4x4<T>& m)
-    {
-        detail::tmat4x4<T> Result;
-        Result[0][0] = m[0][0];
-        Result[0][1] = m[1][0];
-        Result[0][2] = m[2][0];
-        Result[0][3] = m[3][0];
-        Result[1][0] = m[0][1];
-        Result[1][1] = m[1][1];
-        Result[1][2] = m[2][1];
-        Result[1][3] = m[3][1];
-        Result[2][0] = m[0][2];
-        Result[2][1] = m[1][2];
-        Result[2][2] = m[2][2];
-        Result[2][3] = m[3][2];
-        Result[3][0] = m[0][3];
-        Result[3][1] = m[1][3];
-        Result[3][2] = m[2][3];
-        Result[3][3] = m[3][3];
-        return Result;
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> rowMajor4(
+	const detail::tmat4x4<T>& m)
+{
+    detail::tmat4x4<T> Result;
+    Result[0][0] = m[0][0];
+    Result[0][1] = m[1][0];
+    Result[0][2] = m[2][0];
+    Result[0][3] = m[3][0];
+    Result[1][0] = m[0][1];
+    Result[1][1] = m[1][1];
+    Result[1][2] = m[2][1];
+    Result[1][3] = m[3][1];
+    Result[2][0] = m[0][2];
+    Result[2][1] = m[1][2];
+    Result[2][2] = m[2][2];
+    Result[2][3] = m[3][2];
+    Result[3][0] = m[0][3];
+    Result[3][1] = m[1][3];
+    Result[3][2] = m[2][3];
+    Result[3][3] = m[3][3];
+    return Result;
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat2x2<T> colMajor2(
-		const detail::tvec2<T>& v1, 
-		const detail::tvec2<T>& v2)
-    {
-        return detail::tmat2x2<T>(v1, v2);
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat2x2<T> colMajor2(
+	const detail::tvec2<T>& v1, 
+	const detail::tvec2<T>& v2)
+{
+    return detail::tmat2x2<T>(v1, v2);
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat2x2<T> colMajor2(
-		const detail::tmat2x2<T>& m)
-    {
-        return detail::tmat2x2<T>(m);
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat2x2<T> colMajor2(
+	const detail::tmat2x2<T>& m)
+{
+    return detail::tmat2x2<T>(m);
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat3x3<T> colMajor3(
-		const detail::tvec3<T>& v1, 
-		const detail::tvec3<T>& v2, 
-		const detail::tvec3<T>& v3)
-    {
-        return detail::tmat3x3<T>(v1, v2, v3);
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat3x3<T> colMajor3(
+	const detail::tvec3<T>& v1, 
+	const detail::tvec3<T>& v2, 
+	const detail::tvec3<T>& v3)
+{
+    return detail::tmat3x3<T>(v1, v2, v3);
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat3x3<T> colMajor3(
-		const detail::tmat3x3<T>& m)
-    {
-        return detail::tmat3x3<T>(m);
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat3x3<T> colMajor3(
+	const detail::tmat3x3<T>& m)
+{
+    return detail::tmat3x3<T>(m);
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> colMajor4(
-		const detail::tvec4<T>& v1, 
-		const detail::tvec4<T>& v2, 
-		const detail::tvec4<T>& v3, 
-		const detail::tvec4<T>& v4)
-    {
-        return detail::tmat4x4<T>(v1, v2, v3, v4);
-    }
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> colMajor4(
+	const detail::tvec4<T>& v1, 
+	const detail::tvec4<T>& v2, 
+	const detail::tvec4<T>& v3, 
+	const detail::tvec4<T>& v4)
+{
+    return detail::tmat4x4<T>(v1, v2, v3, v4);
+}
 
-    template <typename T> 
-    GLM_FUNC_QUALIFIER detail::tmat4x4<T> colMajor4(
-		const detail::tmat4x4<T>& m)
-    {
-        return detail::tmat4x4<T>(m);
-	}
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<T> colMajor4(
+	const detail::tmat4x4<T>& m)
+{
+    return detail::tmat4x4<T>(m);
+}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/matrix_operation.hpp

@@ -45,10 +45,9 @@
 #	pragma message("GLM: GLM_GTX_matrix_operation extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
-	/// \addtogroup gtx_matrix_operation
+	/// @addtogroup gtx_matrix_operation
 	/// @{
 
 	//! Build a diagonal matrix.
@@ -106,7 +105,6 @@ namespace gtx
 		detail::tvec4<valType> const & v);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "matrix_operation.inl"

glm/gtx/matrix_operation.inl

@@ -8,120 +8,118 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat2x2<valType> diagonal2x2
-	(
-		detail::tvec2<valType> const & v
-	)
-	{
-		detail::tmat2x2<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		return Result;
-	}
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat2x2<valType> diagonal2x2
+(
+	detail::tvec2<valType> const & v
+)
+{
+	detail::tmat2x2<valType> Result(valType(1));
+	Result[0][0] = v[0];
+	Result[1][1] = v[1];
+	return Result;
+}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat2x3<valType> diagonal2x3
-	(
-		detail::tvec2<valType> const & v
-	)
-	{
-		detail::tmat2x3<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		return Result;
-	}
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat2x3<valType> diagonal2x3
+(
+	detail::tvec2<valType> const & v
+)
+{
+	detail::tmat2x3<valType> Result(valType(1));
+	Result[0][0] = v[0];
+	Result[1][1] = v[1];
+	return Result;
+}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat2x4<valType> diagonal2x4
-	(
-		detail::tvec2<valType> const & v
-	)
-	{
-		detail::tmat2x4<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		return Result;
-	}
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat2x4<valType> diagonal2x4
+(
+	detail::tvec2<valType> const & v
+)
+{
+	detail::tmat2x4<valType> Result(valType(1));
+	Result[0][0] = v[0];
+	Result[1][1] = v[1];
+	return Result;
+}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat3x2<valType> diagonal3x2
-	(
-		detail::tvec2<valType> const & v
-	)
-	{
-		detail::tmat3x2<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		return Result;
-	}
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat3x2<valType> diagonal3x2
+(
+	detail::tvec2<valType> const & v
+)
+{
+	detail::tmat3x2<valType> Result(valType(1));
+	Result[0][0] = v[0];
+	Result[1][1] = v[1];
+	return Result;
+}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat3x3<valType> diagonal3x3
-	(
-		detail::tvec3<valType> const & v
-	)
-	{
-		detail::tmat3x3<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		Result[2][2] = v[2];
-		return Result;
-	}
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat3x3<valType> diagonal3x3
+(
+	detail::tvec3<valType> const & v
+)
+{
+	detail::tmat3x3<valType> Result(valType(1));
+	Result[0][0] = v[0];
+	Result[1][1] = v[1];
+	Result[2][2] = v[2];
+	return Result;
+}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat3x4<valType> diagonal3x4
-	(
-		detail::tvec3<valType> const & v
-	)
-	{
-		detail::tmat3x4<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		Result[2][2] = v[2];
-		return Result;
-	}
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat3x4<valType> diagonal3x4
+(
+	detail::tvec3<valType> const & v
+)
+{
+	detail::tmat3x4<valType> Result(valType(1));
+	Result[0][0] = v[0];
+	Result[1][1] = v[1];
+	Result[2][2] = v[2];
+	return Result;
+}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x4<valType> diagonal4x4
-	(
-		detail::tvec4<valType> const & v
-	)
-	{
-		detail::tmat4x4<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		Result[2][2] = v[2];
-		Result[3][3] = v[3];
-		return Result;		
-	}
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x4<valType> diagonal4x4
+(
+	detail::tvec4<valType> const & v
+)
+{
+	detail::tmat4x4<valType> Result(valType(1));
+	Result[0][0] = v[0];
+	Result[1][1] = v[1];
+	Result[2][2] = v[2];
+	Result[3][3] = v[3];
+	return Result;		
+}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x3<valType> diagonal4x3
-	(
-		detail::tvec3<valType> const & v
-	)
-	{
-		detail::tmat4x3<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		Result[2][2] = v[2];
-		return Result;		
-	}
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x3<valType> diagonal4x3
+(
+	detail::tvec3<valType> const & v
+)
+{
+	detail::tmat4x3<valType> Result(valType(1));
+	Result[0][0] = v[0];
+	Result[1][1] = v[1];
+	Result[2][2] = v[2];
+	return Result;		
+}
 
-	template <typename valType> 
-	GLM_FUNC_QUALIFIER detail::tmat4x2<valType> diagonal4x2
-	(
-		detail::tvec2<valType> const & v
-	)
-	{
-		detail::tmat4x2<valType> Result(valType(1));
-		Result[0][0] = v[0];
-		Result[1][1] = v[1];
-		return Result;		
-	}
+template <typename valType> 
+GLM_FUNC_QUALIFIER detail::tmat4x2<valType> diagonal4x2
+(
+	detail::tvec2<valType> const & v
+)
+{
+	detail::tmat4x2<valType> Result(valType(1));
+	Result[0][0] = v[0];
+	Result[1][1] = v[1];
+	return Result;		
+}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/matrix_query.hpp

@@ -46,8 +46,7 @@
 #	pragma message("GLM: GLM_GTX_matrix_query extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_matrix_query
 	/// @{
@@ -109,7 +108,6 @@ namespace gtx
 		const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "matrix_query.inl"

glm/gtx/matrix_query.inl

@@ -11,132 +11,130 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx
+
+template<typename T> 
+GLM_FUNC_QUALIFIER bool isNull(
+	const detail::tmat2x2<T>& m, 
+	const T epsilon)
 {
-	template<typename T> 
-	GLM_FUNC_QUALIFIER bool isNull(
-		const detail::tmat2x2<T>& m, 
-		const T epsilon)
-	{
-		bool result = true;
-		for(int i = 0; result && i < 2 ; ++i)
-			result = isNull(m[i], epsilon);
-		return result;
-	}
+	bool result = true;
+	for(int i = 0; result && i < 2 ; ++i)
+		result = isNull(m[i], epsilon);
+	return result;
+}
 
-	template<typename T> 
-	GLM_FUNC_QUALIFIER bool isNull(
-		const detail::tmat3x3<T>& m, 
-		const T epsilon)
-	{
-		bool result = true;
-		for(int i = 0; result && i < 3 ; ++i)
-			result = isNull(m[i], epsilon);
-		return result;
-	}
+template<typename T> 
+GLM_FUNC_QUALIFIER bool isNull(
+	const detail::tmat3x3<T>& m, 
+	const T epsilon)
+{
+	bool result = true;
+	for(int i = 0; result && i < 3 ; ++i)
+		result = isNull(m[i], epsilon);
+	return result;
+}
 
-	template<typename T> 
-	GLM_FUNC_QUALIFIER bool isNull(
-		const detail::tmat4x4<T>& m, 
-		const T epsilon)
-	{
-		bool result = true;
-		for(int i = 0; result && i < 4 ; ++i)
-			result = isNull(m[i], epsilon);
-		return result;
-	}
+template<typename T> 
+GLM_FUNC_QUALIFIER bool isNull(
+	const detail::tmat4x4<T>& m, 
+	const T epsilon)
+{
+	bool result = true;
+	for(int i = 0; result && i < 4 ; ++i)
+		result = isNull(m[i], epsilon);
+	return result;
+}
 
-	template<typename genType> 
-	GLM_FUNC_QUALIFIER bool isIdentity(
-		const genType& m, 
-		const typename genType::value_type epsilon)
+template<typename genType> 
+GLM_FUNC_QUALIFIER bool isIdentity(
+	const genType& m, 
+	const typename genType::value_type epsilon)
+{
+	bool result = true;
+	for(typename genType::value_type i = typename genType::value_type(0); result && i < genType::col_size(); ++i)
 	{
-		bool result = true;
-		for(typename genType::value_type i = typename genType::value_type(0); result && i < genType::col_size(); ++i)
-		{
-			for(typename genType::value_type j = typename genType::value_type(0); result && j < i ; ++j)
-				result = abs(m[i][j]) <= epsilon;
-			if(result)
-				result = abs(m[i][i] - typename genType::value_type(1)) <= epsilon;
-			for(typename genType::value_type j = i + typename genType::value_type(1); result && j < genType::row_size(); ++j)
-				result = abs(m[i][j]) <= epsilon;
-		}
-		return result;
+		for(typename genType::value_type j = typename genType::value_type(0); result && j < i ; ++j)
+			result = abs(m[i][j]) <= epsilon;
+		if(result)
+			result = abs(m[i][i] - typename genType::value_type(1)) <= epsilon;
+		for(typename genType::value_type j = i + typename genType::value_type(1); result && j < genType::row_size(); ++j)
+			result = abs(m[i][j]) <= epsilon;
 	}
+	return result;
+}
 
-	template<typename T> 
-	GLM_FUNC_QUALIFIER bool isNormalized(
-		const detail::tmat2x2<T>& m, 
-		const T epsilon)
+template<typename T> 
+GLM_FUNC_QUALIFIER bool isNormalized(
+	const detail::tmat2x2<T>& m, 
+	const T epsilon)
+{
+	bool result = true;
+	for(int i = 0; result && i < 2; ++i)
+		result = isNormalized(m[i], epsilon);
+	for(int i = 0; result && i < 2; ++i)
 	{
-		bool result = true;
-		for(int i = 0; result && i < 2; ++i)
-			result = isNormalized(m[i], epsilon);
-		for(int i = 0; result && i < 2; ++i)
-		{
-			detail::tvec2<T> v;
-			for(int j = 0; j < 2; ++j)
-				v[j] = m[j][i];
-			result = isNormalized(v, epsilon);
-		}
-		return result;
+		detail::tvec2<T> v;
+		for(int j = 0; j < 2; ++j)
+			v[j] = m[j][i];
+		result = isNormalized(v, epsilon);
 	}
+	return result;
+}
 
-	template<typename T> 
-	GLM_FUNC_QUALIFIER bool isNormalized(
-		const detail::tmat3x3<T>& m, 
-		const T epsilon)
+template<typename T> 
+GLM_FUNC_QUALIFIER bool isNormalized(
+	const detail::tmat3x3<T>& m, 
+	const T epsilon)
+{
+	bool result = true;
+	for(int i = 0; result && i < 3; ++i)
+		result = isNormalized(m[i], epsilon);
+	for(int i = 0; result && i < 3; ++i)
 	{
-		bool result = true;
-		for(int i = 0; result && i < 3; ++i)
-			result = isNormalized(m[i], epsilon);
-		for(int i = 0; result && i < 3; ++i)
-		{
-			detail::tvec3<T> v;
-			for(int j = 0; j < 3; ++j)
-				v[j] = m[j][i];
-			result = isNormalized(v, epsilon);
-		}
-		return result;
+		detail::tvec3<T> v;
+		for(int j = 0; j < 3; ++j)
+			v[j] = m[j][i];
+		result = isNormalized(v, epsilon);
 	}
+	return result;
+}
 
-	template<typename T> 
-	GLM_FUNC_QUALIFIER bool isNormalized(
-		const detail::tmat4x4<T>& m, 
-		const T epsilon)
+template<typename T> 
+GLM_FUNC_QUALIFIER bool isNormalized(
+	const detail::tmat4x4<T>& m, 
+	const T epsilon)
+{
+	bool result = true;
+	for(int i = 0; result && i < 4; ++i)
+		result = isNormalized(m[i], epsilon);
+	for(int i = 0; result && i < 4; ++i)
 	{
-		bool result = true;
-		for(int i = 0; result && i < 4; ++i)
-			result = isNormalized(m[i], epsilon);
-		for(int i = 0; result && i < 4; ++i)
-		{
-			detail::tvec4<T> v;
-			for(int j = 0; j < 4; ++j)
-				v[j] = m[j][i];
-			result = isNormalized(v, epsilon);
-		}
-		return result;
+		detail::tvec4<T> v;
+		for(int j = 0; j < 4; ++j)
+			v[j] = m[j][i];
+		result = isNormalized(v, epsilon);
 	}
+	return result;
+}
 
-	template<typename genType> 
-	GLM_FUNC_QUALIFIER bool isOrthogonal(
-		const genType& m, 
-		const typename genType::value_type epsilon)
-	{
-		bool result = true;
-		for(int i = 0; result && i < genType::col_size() - 1; ++i)
-		for(int j= i + 1; result && j < genType::col_size(); ++j)
-			result = areOrthogonal(m[i], m[j], epsilon);
+template<typename genType> 
+GLM_FUNC_QUALIFIER bool isOrthogonal(
+	const genType& m, 
+	const typename genType::value_type epsilon)
+{
+	bool result = true;
+	for(int i = 0; result && i < genType::col_size() - 1; ++i)
+	for(int j= i + 1; result && j < genType::col_size(); ++j)
+		result = areOrthogonal(m[i], m[j], epsilon);
 
-		if(result)
-		{
-			genType tmp = transpose(m);
-			for(int i = 0; result && i < genType::col_size() - 1 ; ++i)
-			for(int j = i + 1; result && j < genType::col_size(); ++j)
-				result = areOrthogonal(tmp[i], tmp[j], epsilon);
-		}
-		return result;
+	if(result)
+	{
+		genType tmp = transpose(m);
+		for(int i = 0; result && i < genType::col_size() - 1 ; ++i)
+		for(int j = i + 1; result && j < genType::col_size(); ++j)
+			result = areOrthogonal(tmp[i], tmp[j], epsilon);
 	}
+	return result;
+}
 
-}//namespace gtx
 }//namespace glm

glm/gtx/mixed_product.hpp

@@ -45,8 +45,7 @@
 #	pragma message("GLM: GLM_GTX_mixed_product extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_mixed_product
 	/// @{
@@ -59,7 +58,6 @@ namespace gtx
 		detail::tvec3<valType> const & v3);
 
 	/// @}
-}// namespace gtx
 }// namespace glm
 
 #include "mixed_product.inl"

glm/gtx/mixed_product.inl

@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
 template <typename valType> 
 GLM_FUNC_QUALIFIER valType mixedProduct(
@@ -19,14 +18,4 @@ GLM_FUNC_QUALIFIER valType mixedProduct(
     return dot(cross(v1, v2), v3);
 }
 
-}//namespace gtx
 }//namespace glm
-
-
-
-
-
-
-
-
-

glm/gtx/multiple.hpp

@@ -46,8 +46,7 @@
 #	pragma message("GLM: GLM_GTX_multiple extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_multiple
 	/// @{
@@ -67,7 +66,6 @@ namespace gtx
 		genType const & Multiple);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "multiple.inl"

glm/gtx/multiple.inl

@@ -11,179 +11,177 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx
+
+//////////////////////
+// higherMultiple
+
+template <typename genType> 
+GLM_FUNC_QUALIFIER genType higherMultiple
+(
+	genType const & Source, 
+	genType const & Multiple
+)
+{
+	genType Tmp = Source % Multiple;
+	return Tmp ? Source + Multiple - Tmp : Source;
+}
+
+template <> 
+GLM_FUNC_QUALIFIER detail::thalf higherMultiple
+(
+	detail::thalf const & Source, 
+	detail::thalf const & Multiple
+)
+{
+	int Tmp = int(float(Source)) % int(float(Multiple));
+	return Tmp ? Source + Multiple - detail::thalf(float(Tmp)) : Source;
+}
+
+template <> 
+GLM_FUNC_QUALIFIER float higherMultiple
+(	
+	float const & Source, 
+	float const & Multiple
+)
+{
+	int Tmp = int(Source) % int(Multiple);
+	return Tmp ? Source + Multiple - float(Tmp) : Source;
+}
+
+template <> 
+GLM_FUNC_QUALIFIER double higherMultiple
+(
+	double const & Source, 
+	double const & Multiple
+)
+{
+	long Tmp = long(Source) % long(Multiple);
+	return Tmp ? Source + Multiple - double(Tmp) : Source;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> higherMultiple
+(
+	detail::tvec2<T> const & Source, 
+	detail::tvec2<T> const & Multiple
+)
+{
+	detail::tvec2<T> Result;
+	for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+		Result[i] = higherMultiple(Source[i], Multiple[i]);
+	return Result;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> higherMultiple
+(
+	detail::tvec3<T> const & Source, 
+	detail::tvec3<T> const & Multiple
+)
+{
+	detail::tvec3<T> Result;
+	for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+		Result[i] = higherMultiple(Source[i], Multiple[i]);
+	return Result;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> higherMultiple
+(
+	detail::tvec4<T> const & Source, 
+	detail::tvec4<T> const & Multiple
+)
 {
-	//////////////////////
-	// higherMultiple
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType higherMultiple
-	(
-		genType const & Source, 
-		genType const & Multiple
-	)
-	{
-		genType Tmp = Source % Multiple;
-		return Tmp ? Source + Multiple - Tmp : Source;
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER detail::thalf higherMultiple
-	(
-		detail::thalf const & Source, 
-		detail::thalf const & Multiple
-	)
-	{
-		int Tmp = int(float(Source)) % int(float(Multiple));
-		return Tmp ? Source + Multiple - detail::thalf(float(Tmp)) : Source;
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER float higherMultiple
-	(	
-		float const & Source, 
-		float const & Multiple
-	)
-	{
-		int Tmp = int(Source) % int(Multiple);
-		return Tmp ? Source + Multiple - float(Tmp) : Source;
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER double higherMultiple
-	(
-		double const & Source, 
-		double const & Multiple
-	)
-	{
-		long Tmp = long(Source) % long(Multiple);
-		return Tmp ? Source + Multiple - double(Tmp) : Source;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec2<T> higherMultiple
-	(
-		detail::tvec2<T> const & Source, 
-		detail::tvec2<T> const & Multiple
-	)
-	{
-		detail::tvec2<T> Result;
-		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-			Result[i] = higherMultiple(Source[i], Multiple[i]);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> higherMultiple
-	(
-		detail::tvec3<T> const & Source, 
-		detail::tvec3<T> const & Multiple
-	)
-	{
-		detail::tvec3<T> Result;
-		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-			Result[i] = higherMultiple(Source[i], Multiple[i]);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec4<T> higherMultiple
-	(
-		detail::tvec4<T> const & Source, 
-		detail::tvec4<T> const & Multiple
-	)
-	{
-		detail::tvec4<T> Result;
-		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-			Result[i] = higherMultiple(Source[i], Multiple[i]);
-		return Result;
-	}
-
-	//////////////////////
-	// lowerMultiple
-
-	template <typename genType> 
-	GLM_FUNC_QUALIFIER genType lowerMultiple
-	(
-		genType const & Source, 
-		genType const & Multiple
-	)
-	{
-		genType Tmp = Source % Multiple;
-		return Tmp ? Source - Tmp : Source;
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER detail::thalf lowerMultiple
-	(
-		detail::thalf const & Source, 
-		detail::thalf const & Multiple
-	)
-	{
-		int Tmp = int(float(Source)) % int(float(Multiple));
-		return Tmp ? Source - detail::thalf(float(Tmp)) : Source;
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER float lowerMultiple
-	(
-		float const & Source, 
-		float const & Multiple
-	)
-	{
-		int Tmp = int(Source) % int(Multiple);
-		return Tmp ? Source - float(Tmp) : Source;
-	}
-
-	template <> 
-	GLM_FUNC_QUALIFIER double lowerMultiple
-	(
-		double const & Source, 
-		double const & Multiple
-	)
-	{
-		long Tmp = long(Source) % long(Multiple);
-		return Tmp ? Source - double(Tmp) : Source;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec2<T> lowerMultiple
-	(
-		detail::tvec2<T> const & Source, 
-		detail::tvec2<T> const & Multiple
-	)
-	{
-		detail::tvec2<T> Result;
-		for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
-			Result[i] = lowerMultiple(Source[i], Multiple[i]);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec3<T> lowerMultiple
-	(
-		detail::tvec3<T> const & Source, 
-		detail::tvec3<T> const & Multiple
-	)
-	{
-		detail::tvec3<T> Result;
-		for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
-			Result[i] = lowerMultiple(Source[i], Multiple[i]);
-		return Result;
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER detail::tvec4<T> lowerMultiple
-	(
-		detail::tvec4<T> const & Source, 
-		detail::tvec4<T> const & Multiple
-	)
-	{
-		detail::tvec4<T> Result;
-		for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
-			Result[i] = lowerMultiple(Source[i], Multiple[i]);
-		return Result;
-	}
-
-}//namespace gtx
+	detail::tvec4<T> Result;
+	for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+		Result[i] = higherMultiple(Source[i], Multiple[i]);
+	return Result;
+}
+
+//////////////////////
+// lowerMultiple
+
+template <typename genType> 
+GLM_FUNC_QUALIFIER genType lowerMultiple
+(
+	genType const & Source, 
+	genType const & Multiple
+)
+{
+	genType Tmp = Source % Multiple;
+	return Tmp ? Source - Tmp : Source;
+}
+
+template <> 
+GLM_FUNC_QUALIFIER detail::thalf lowerMultiple
+(
+	detail::thalf const & Source, 
+	detail::thalf const & Multiple
+)
+{
+	int Tmp = int(float(Source)) % int(float(Multiple));
+	return Tmp ? Source - detail::thalf(float(Tmp)) : Source;
+}
+
+template <> 
+GLM_FUNC_QUALIFIER float lowerMultiple
+(
+	float const & Source, 
+	float const & Multiple
+)
+{
+	int Tmp = int(Source) % int(Multiple);
+	return Tmp ? Source - float(Tmp) : Source;
+}
+
+template <> 
+GLM_FUNC_QUALIFIER double lowerMultiple
+(
+	double const & Source, 
+	double const & Multiple
+)
+{
+	long Tmp = long(Source) % long(Multiple);
+	return Tmp ? Source - double(Tmp) : Source;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec2<T> lowerMultiple
+(
+	detail::tvec2<T> const & Source, 
+	detail::tvec2<T> const & Multiple
+)
+{
+	detail::tvec2<T> Result;
+	for(typename detail::tvec2<T>::size_type i = 0; i < detail::tvec2<T>::value_size(); ++i)
+		Result[i] = lowerMultiple(Source[i], Multiple[i]);
+	return Result;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec3<T> lowerMultiple
+(
+	detail::tvec3<T> const & Source, 
+	detail::tvec3<T> const & Multiple
+)
+{
+	detail::tvec3<T> Result;
+	for(typename detail::tvec3<T>::size_type i = 0; i < detail::tvec3<T>::value_size(); ++i)
+		Result[i] = lowerMultiple(Source[i], Multiple[i]);
+	return Result;
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER detail::tvec4<T> lowerMultiple
+(
+	detail::tvec4<T> const & Source, 
+	detail::tvec4<T> const & Multiple
+)
+{
+	detail::tvec4<T> Result;
+	for(typename detail::tvec4<T>::size_type i = 0; i < detail::tvec4<T>::value_size(); ++i)
+		Result[i] = lowerMultiple(Source[i], Multiple[i]);
+	return Result;
+}
+
 }//namespace glm

glm/gtx/noise.hpp

@@ -49,8 +49,7 @@
 #	pragma message("GLM: GLM_GTX_noise extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_noise
 	/// @{
@@ -75,7 +74,6 @@ namespace gtx
 		vecType<T> const & p);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "noise.inl"

glm/gtx/noise.inl

@@ -16,774 +16,772 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T permute(T const & x)
-	{
-		return mod(((x * T(34)) + T(1)) * x, T(289));
-	}
-
-	template <typename T, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T> permute(vecType<T> const & x)
-	{
-		return mod(((x * T(34)) + T(1)) * x, T(289));
-	}
+
+template <typename T>
+GLM_FUNC_QUALIFIER T permute(T const & x)
+{
+	return mod(((x * T(34)) + T(1)) * x, T(289));
+}
+
+template <typename T, template<typename> class vecType>
+GLM_FUNC_QUALIFIER vecType<T> permute(vecType<T> const & x)
+{
+	return mod(((x * T(34)) + T(1)) * x, T(289));
+}
   
-	template <typename T>
-	GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-
-	template <typename T, template<typename> class vecType>
-	GLM_FUNC_QUALIFIER vecType<T> taylorInvSqrt(vecType<T> const & r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-
-	template <typename T, template <typename> class vecType> 
-	GLM_FUNC_QUALIFIER vecType<T> fade(vecType<T> const & t) 
-	{
-		return t * t * t * (t * (t * T(6) - T(15)) + T(10));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER detail::tvec4<T> grad4(T const & j, detail::tvec4<T> const & ip)
-	{
-		detail::tvec3<T> pXYZ = floor(fract(detail::tvec3<T>(j) * detail::tvec3<T>(ip)) * T(7)) * ip[2] - T(1);
-		T pW = T(1.5) - dot(abs(pXYZ), detail::tvec3<T>(1));
-		detail::tvec4<T> s = detail::tvec4<T>(lessThan(detail::tvec4<T>(pXYZ, pW), detail::tvec4<T>(0.0)));
-		pXYZ = pXYZ + (detail::tvec3<T>(s) * T(2) - T(1)) * s.w; 
-		return detail::tvec4<T>(pXYZ, pW);
-	}
-
-	// Classic Perlin noise
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P)
-	{
-		detail::tvec4<T> Pi = floor(detail::tvec4<T>(P.x, P.y, P.x, P.y)) + detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
-		detail::tvec4<T> Pf = fract(detail::tvec4<T>(P.x, P.y, P.x, P.y)) - detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
-		Pi = mod(Pi, T(289)); // To avoid truncation effects in permutation
-		detail::tvec4<T> ix(Pi.x, Pi.z, Pi.x, Pi.z);
-		detail::tvec4<T> iy(Pi.y, Pi.y, Pi.w, Pi.w);
-		detail::tvec4<T> fx(Pf.x, Pf.z, Pf.x, Pf.z);
-		detail::tvec4<T> fy(Pf.y, Pf.y, Pf.w, Pf.w);
-
-		detail::tvec4<T> i = permute(permute(ix) + iy);
-
-		detail::tvec4<T> gx = T(2) * fract(i / T(41)) - T(1);
-		detail::tvec4<T> gy = abs(gx) - T(0.5);
-		detail::tvec4<T> tx = floor(gx + T(0.5));
-		gx = gx - tx;
-
-		detail::tvec2<T> g00(gx.x, gy.x);
-		detail::tvec2<T> g10(gx.y, gy.y);
-		detail::tvec2<T> g01(gx.z, gy.z);
-		detail::tvec2<T> g11(gx.w, gy.w);
-
-		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
-		g00 *= norm.x;  
-		g01 *= norm.y;  
-		g10 *= norm.z;  
-		g11 *= norm.w;  
-
-		T n00 = dot(g00, detail::tvec2<T>(fx.x, fy.x));
-		T n10 = dot(g10, detail::tvec2<T>(fx.y, fy.y));
-		T n01 = dot(g01, detail::tvec2<T>(fx.z, fy.z));
-		T n11 = dot(g11, detail::tvec2<T>(fx.w, fy.w));
-
-		detail::tvec2<T> fade_xy = fade(detail::tvec2<T>(Pf.x, Pf.y));
-		detail::tvec2<T> n_x = mix(detail::tvec2<T>(n00, n01), detail::tvec2<T>(n10, n11), fade_xy.x);
-		T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
-		return T(2.3) * n_xy;
-	}
-
-	// Classic Perlin noise
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P)
-	{
-		detail::tvec3<T> Pi0 = floor(P); // Integer part for indexing
-		detail::tvec3<T> Pi1 = Pi0 + T(1); // Integer part + 1
-		Pi0 = mod(Pi0, T(289));
-		Pi1 = mod(Pi1, T(289));
-		detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
-		detail::tvec3<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
-		detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		detail::tvec4<T> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
-		detail::tvec4<T> iz0(Pi0.z);
-		detail::tvec4<T> iz1(Pi1.z);
-
-		detail::tvec4<T> ixy = permute(permute(ix) + iy);
-		detail::tvec4<T> ixy0 = permute(ixy + iz0);
-		detail::tvec4<T> ixy1 = permute(ixy + iz1);
-
-		detail::tvec4<T> gx0 = ixy0 / T(7);
-		detail::tvec4<T> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
-		gx0 = fract(gx0);
-		detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
-		detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0.0));
-		gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
-		gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
-
-		detail::tvec4<T> gx1 = ixy1 / T(7);
-		detail::tvec4<T> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
-		gx1 = fract(gx1);
-		detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
-		detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
-		gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
-		gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
-
-		detail::tvec3<T> g000(gx0.x, gy0.x, gz0.x);
-		detail::tvec3<T> g100(gx0.y, gy0.y, gz0.y);
-		detail::tvec3<T> g010(gx0.z, gy0.z, gz0.z);
-		detail::tvec3<T> g110(gx0.w, gy0.w, gz0.w);
-		detail::tvec3<T> g001(gx1.x, gy1.x, gz1.x);
-		detail::tvec3<T> g101(gx1.y, gy1.y, gz1.y);
-		detail::tvec3<T> g011(gx1.z, gy1.z, gz1.z);
-		detail::tvec3<T> g111(gx1.w, gy1.w, gz1.w);
-
-		detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
-		g000 *= norm0.x;
-		g010 *= norm0.y;
-		g100 *= norm0.z;
-		g110 *= norm0.w;
-		detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
-		g001 *= norm1.x;
-		g011 *= norm1.y;
-		g101 *= norm1.z;
-		g111 *= norm1.w;
-
-		T n000 = dot(g000, Pf0);
-		T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
-		T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
-		T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
-		T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
-		T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
-		T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
-		T n111 = dot(g111, Pf1);
-
-		detail::tvec3<T> fade_xyz = fade(Pf0);
-		detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
-		detail::tvec2<T> n_yz = mix(
-            detail::tvec2<T>(n_z.x, n_z.y), 
-            detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
-		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
-		return T(2.2) * n_xyz;
-	}
-
-	// Classic Perlin noise
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec4<T> const & P)
-	{
-		detail::tvec4<T> Pi0 = floor(P); // Integer part for indexing
-		detail::tvec4<T> Pi1 = Pi0 + T(1); // Integer part + 1
-		Pi0 = mod(Pi0, T(289));
-		Pi1 = mod(Pi1, T(289));
-		detail::tvec4<T> Pf0 = fract(P); // Fractional part for interpolation
-		detail::tvec4<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
-		detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		detail::tvec4<T> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
-		detail::tvec4<T> iz0(Pi0.z);
-		detail::tvec4<T> iz1(Pi1.z);
-		detail::tvec4<T> iw0(Pi0.w);
-		detail::tvec4<T> iw1(Pi1.w);
-
-		detail::tvec4<T> ixy = permute(permute(ix) + iy);
-		detail::tvec4<T> ixy0 = permute(ixy + iz0);
-		detail::tvec4<T> ixy1 = permute(ixy + iz1);
-		detail::tvec4<T> ixy00 = permute(ixy0 + iw0);
-		detail::tvec4<T> ixy01 = permute(ixy0 + iw1);
-		detail::tvec4<T> ixy10 = permute(ixy1 + iw0);
-		detail::tvec4<T> ixy11 = permute(ixy1 + iw1);
-
-		detail::tvec4<T> gx00 = ixy00 / T(7);
-		detail::tvec4<T> gy00 = floor(gx00) / T(7);
-		detail::tvec4<T> gz00 = floor(gy00) / T(6);
-		gx00 = fract(gx00) - T(0.5);
-		gy00 = fract(gy00) - T(0.5);
-		gz00 = fract(gz00) - T(0.5);
-		detail::tvec4<T> gw00 = detail::tvec4<T>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
-		detail::tvec4<T> sw00 = step(gw00, detail::tvec4<T>(0.0));
-		gx00 -= sw00 * (step(T(0), gx00) - T(0.5));
-		gy00 -= sw00 * (step(T(0), gy00) - T(0.5));
-
-		detail::tvec4<T> gx01 = ixy01 / T(7);
-		detail::tvec4<T> gy01 = floor(gx01) / T(7);
-		detail::tvec4<T> gz01 = floor(gy01) / T(6);
-		gx01 = fract(gx01) - T(0.5);
-		gy01 = fract(gy01) - T(0.5);
-		gz01 = fract(gz01) - T(0.5);
-		detail::tvec4<T> gw01 = detail::tvec4<T>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
-		detail::tvec4<T> sw01 = step(gw01, detail::tvec4<T>(0.0));
-		gx01 -= sw01 * (step(T(0), gx01) - T(0.5));
-		gy01 -= sw01 * (step(T(0), gy01) - T(0.5));
-
-		detail::tvec4<T> gx10 = ixy10 / T(7);
-		detail::tvec4<T> gy10 = floor(gx10) / T(7);
-		detail::tvec4<T> gz10 = floor(gy10) / T(6);
-		gx10 = fract(gx10) - T(0.5);
-		gy10 = fract(gy10) - T(0.5);
-		gz10 = fract(gz10) - T(0.5);
-		detail::tvec4<T> gw10 = detail::tvec4<T>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
-		detail::tvec4<T> sw10 = step(gw10, detail::tvec4<T>(0));
-		gx10 -= sw10 * (step(T(0), gx10) - T(0.5));
-		gy10 -= sw10 * (step(T(0), gy10) - T(0.5));
-
-		detail::tvec4<T> gx11 = ixy11 / T(7);
-		detail::tvec4<T> gy11 = floor(gx11) / T(7);
-		detail::tvec4<T> gz11 = floor(gy11) / T(6);
-		gx11 = fract(gx11) - T(0.5);
-		gy11 = fract(gy11) - T(0.5);
-		gz11 = fract(gz11) - T(0.5);
-		detail::tvec4<T> gw11 = detail::tvec4<T>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
-		detail::tvec4<T> sw11 = step(gw11, detail::tvec4<T>(0.0));
-		gx11 -= sw11 * (step(T(0), gx11) - T(0.5));
-		gy11 -= sw11 * (step(T(0), gy11) - T(0.5));
-
-		detail::tvec4<T> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
-		detail::tvec4<T> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
-		detail::tvec4<T> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
-		detail::tvec4<T> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
-		detail::tvec4<T> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
-		detail::tvec4<T> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
-		detail::tvec4<T> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
-		detail::tvec4<T> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
-		detail::tvec4<T> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
-		detail::tvec4<T> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
-		detail::tvec4<T> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
-		detail::tvec4<T> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
-		detail::tvec4<T> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
-		detail::tvec4<T> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
-		detail::tvec4<T> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
-		detail::tvec4<T> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
-
-		detail::tvec4<T> norm00 = taylorInvSqrt(detail::tvec4<T>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
-		g0000 *= norm00.x;
-		g0100 *= norm00.y;
-		g1000 *= norm00.z;
-		g1100 *= norm00.w;
-
-		detail::tvec4<T> norm01 = taylorInvSqrt(detail::tvec4<T>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
-		g0001 *= norm01.x;
-		g0101 *= norm01.y;
-		g1001 *= norm01.z;
-		g1101 *= norm01.w;
-
-		detail::tvec4<T> norm10 = taylorInvSqrt(detail::tvec4<T>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
-		g0010 *= norm10.x;
-		g0110 *= norm10.y;
-		g1010 *= norm10.z;
-		g1110 *= norm10.w;
-
-		detail::tvec4<T> norm11 = taylorInvSqrt(detail::tvec4<T>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
-		g0011 *= norm11.x;
-		g0111 *= norm11.y;
-		g1011 *= norm11.z;
-		g1111 *= norm11.w;
-
-		T n0000 = dot(g0000, Pf0);
-		T n1000 = dot(g1000, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
-		T n0100 = dot(g0100, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
-		T n1100 = dot(g1100, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
-		T n0010 = dot(g0010, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
-		T n1010 = dot(g1010, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
-		T n0110 = dot(g0110, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
-		T n1110 = dot(g1110, detail::tvec4<T>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
-		T n0001 = dot(g0001, detail::tvec4<T>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
-		T n1001 = dot(g1001, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
-		T n0101 = dot(g0101, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
-		T n1101 = dot(g1101, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
-		T n0011 = dot(g0011, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
-		T n1011 = dot(g1011, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
-		T n0111 = dot(g0111, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
-		T n1111 = dot(g1111, Pf1);
-
-		detail::tvec4<T> fade_xyzw = fade(Pf0);
-		detail::tvec4<T> n_0w = mix(detail::tvec4<T>(n0000, n1000, n0100, n1100), detail::tvec4<T>(n0001, n1001, n0101, n1101), fade_xyzw.w);
-		detail::tvec4<T> n_1w = mix(detail::tvec4<T>(n0010, n1010, n0110, n1110), detail::tvec4<T>(n0011, n1011, n0111, n1111), fade_xyzw.w);
-		detail::tvec4<T> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
-		detail::tvec2<T> n_yzw = mix(detail::tvec2<T>(n_zw.x, n_zw.y), detail::tvec2<T>(n_zw.z, n_zw.w), fade_xyzw.y);
-		T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
-		return T(2.2) * n_xyzw;
-	}
-
-	// Classic Perlin noise, periodic variant
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P, detail::tvec2<T> const & rep)
-	{
-		detail::tvec4<T> Pi = floor(detail::tvec4<T>(P.x, P.y, P.x, P.y)) + detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
-		detail::tvec4<T> Pf = fract(detail::tvec4<T>(P.x, P.y, P.x, P.y)) - detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
-		Pi = mod(Pi, detail::tvec4<T>(rep.x, rep.y, rep.x, rep.y)); // To create noise with explicit period
-		Pi = mod(Pi, T(289)); // To avoid truncation effects in permutation
-		detail::tvec4<T> ix(Pi.x, Pi.z, Pi.x, Pi.z);
-		detail::tvec4<T> iy(Pi.y, Pi.y, Pi.w, Pi.w);
-		detail::tvec4<T> fx(Pf.x, Pf.z, Pf.x, Pf.z);
-		detail::tvec4<T> fy(Pf.y, Pf.y, Pf.w, Pf.w);
-
-		detail::tvec4<T> i = permute(permute(ix) + iy);
-
-		detail::tvec4<T> gx = T(2) * fract(i / T(41)) - T(1);
-		detail::tvec4<T> gy = abs(gx) - T(0.5);
-		detail::tvec4<T> tx = floor(gx + T(0.5));
-		gx = gx - tx;
-
-		detail::tvec2<T> g00(gx.x, gy.x);
-		detail::tvec2<T> g10(gx.y, gy.y);
-		detail::tvec2<T> g01(gx.z, gy.z);
-		detail::tvec2<T> g11(gx.w, gy.w);
-
-		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
-		g00 *= norm.x;  
-		g01 *= norm.y;  
-		g10 *= norm.z;  
-		g11 *= norm.w;  
-
-		T n00 = dot(g00, detail::tvec2<T>(fx.x, fy.x));
-		T n10 = dot(g10, detail::tvec2<T>(fx.y, fy.y));
-		T n01 = dot(g01, detail::tvec2<T>(fx.z, fy.z));
-		T n11 = dot(g11, detail::tvec2<T>(fx.w, fy.w));
-
-		detail::tvec2<T> fade_xy = fade(detail::tvec2<T>(Pf.x, Pf.y));
-		detail::tvec2<T> n_x = mix(detail::tvec2<T>(n00, n01), detail::tvec2<T>(n10, n11), fade_xy.x);
-		T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
-		return T(2.3) * n_xy;
-	}
-
-	// Classic Perlin noise, periodic variant
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P, detail::tvec3<T> const & rep)
-	{
-		detail::tvec3<T> Pi0 = mod(floor(P), rep); // Integer part, modulo period
-		detail::tvec3<T> Pi1 = mod(Pi0 + detail::tvec3<T>(1.0), rep); // Integer part + 1, mod period
-		Pi0 = mod(Pi0, T(289));
-		Pi1 = mod(Pi1, T(289));
-		detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
-		detail::tvec3<T> Pf1 = Pf0 - detail::tvec3<T>(1.0); // Fractional part - 1.0
-		detail::tvec4<T> ix = detail::tvec4<T>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		detail::tvec4<T> iy = detail::tvec4<T>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
-		detail::tvec4<T> iz0(Pi0.z);
-		detail::tvec4<T> iz1(Pi1.z);
-
-		detail::tvec4<T> ixy = permute(permute(ix) + iy);
-		detail::tvec4<T> ixy0 = permute(ixy + iz0);
-		detail::tvec4<T> ixy1 = permute(ixy + iz1);
-
-		detail::tvec4<T> gx0 = ixy0 / T(7);
-		detail::tvec4<T> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
-		gx0 = fract(gx0);
-		detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
-		detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0));
-		gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
-		gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
-
-		detail::tvec4<T> gx1 = ixy1 / T(7);
-		detail::tvec4<T> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
-		gx1 = fract(gx1);
-		detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
-		detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
-		gx1 -= sz1 * (step(0.0, gx1) - T(0.5));
-		gy1 -= sz1 * (step(0.0, gy1) - T(0.5));
-
-		detail::tvec3<T> g000 = detail::tvec3<T>(gx0.x, gy0.x, gz0.x);
-		detail::tvec3<T> g100 = detail::tvec3<T>(gx0.y, gy0.y, gz0.y);
-		detail::tvec3<T> g010 = detail::tvec3<T>(gx0.z, gy0.z, gz0.z);
-		detail::tvec3<T> g110 = detail::tvec3<T>(gx0.w, gy0.w, gz0.w);
-		detail::tvec3<T> g001 = detail::tvec3<T>(gx1.x, gy1.x, gz1.x);
-		detail::tvec3<T> g101 = detail::tvec3<T>(gx1.y, gy1.y, gz1.y);
-		detail::tvec3<T> g011 = detail::tvec3<T>(gx1.z, gy1.z, gz1.z);
-		detail::tvec3<T> g111 = detail::tvec3<T>(gx1.w, gy1.w, gz1.w);
-
-		detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
-		g000 *= norm0.x;
-		g010 *= norm0.y;
-		g100 *= norm0.z;
-		g110 *= norm0.w;
-		detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
-		g001 *= norm1.x;
-		g011 *= norm1.y;
-		g101 *= norm1.z;
-		g111 *= norm1.w;
-
-		T n000 = dot(g000, Pf0);
-		T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
-		T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
-		T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
-		T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
-		T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
-		T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
-		T n111 = dot(g111, Pf1);
-
-		detail::tvec3<T> fade_xyz = fade(Pf0);
-		detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
-		detail::tvec2<T> n_yz = mix(detail::tvec2<T>(n_z.x, n_z.y), detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
-		T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
-		return T(2.2) * n_xyz;
-	}
-
-	// Classic Perlin noise, periodic version
-	template <typename T>
-	GLM_FUNC_QUALIFIER T perlin(detail::tvec4<T> const & P, detail::tvec4<T> const & rep)
-	{
-		detail::tvec4<T> Pi0 = mod(floor(P), rep); // Integer part modulo rep
-		detail::tvec4<T> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep
-		detail::tvec4<T> Pf0 = fract(P); // Fractional part for interpolation
-		detail::tvec4<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
-		detail::tvec4<T> ix = detail::tvec4<T>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
-		detail::tvec4<T> iy = detail::tvec4<T>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
-		detail::tvec4<T> iz0(Pi0.z);
-		detail::tvec4<T> iz1(Pi1.z);
-		detail::tvec4<T> iw0(Pi0.w);
-		detail::tvec4<T> iw1(Pi1.w);
-
-		detail::tvec4<T> ixy = permute(permute(ix) + iy);
-		detail::tvec4<T> ixy0 = permute(ixy + iz0);
-		detail::tvec4<T> ixy1 = permute(ixy + iz1);
-		detail::tvec4<T> ixy00 = permute(ixy0 + iw0);
-		detail::tvec4<T> ixy01 = permute(ixy0 + iw1);
-		detail::tvec4<T> ixy10 = permute(ixy1 + iw0);
-		detail::tvec4<T> ixy11 = permute(ixy1 + iw1);
-
-		detail::tvec4<T> gx00 = ixy00 / T(7);
-		detail::tvec4<T> gy00 = floor(gx00) / T(7);
-		detail::tvec4<T> gz00 = floor(gy00) / T(6);
-		gx00 = fract(gx00) - T(0.5);
-		gy00 = fract(gy00) - T(0.5);
-		gz00 = fract(gz00) - T(0.5);
-		detail::tvec4<T> gw00 = detail::tvec4<T>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
-		detail::tvec4<T> sw00 = step(gw00, detail::tvec4<T>(0));
-		gx00 -= sw00 * (step(0.0, gx00) - T(0.5));
-		gy00 -= sw00 * (step(0.0, gy00) - T(0.5));
-
-		detail::tvec4<T> gx01 = ixy01 / T(7);
-		detail::tvec4<T> gy01 = floor(gx01) / T(7);
-		detail::tvec4<T> gz01 = floor(gy01) / T(6);
-		gx01 = fract(gx01) - T(0.5);
-		gy01 = fract(gy01) - T(0.5);
-		gz01 = fract(gz01) - T(0.5);
-		detail::tvec4<T> gw01 = detail::tvec4<T>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
-		detail::tvec4<T> sw01 = step(gw01, detail::tvec4<T>(0.0));
-		gx01 -= sw01 * (step(0.0, gx01) - T(0.5));
-		gy01 -= sw01 * (step(0.0, gy01) - T(0.5));
-
-		detail::tvec4<T> gx10 = ixy10 / T(7);
-		detail::tvec4<T> gy10 = floor(gx10) / T(7);
-		detail::tvec4<T> gz10 = floor(gy10) / T(6);
-		gx10 = fract(gx10) - T(0.5);
-		gy10 = fract(gy10) - T(0.5);
-		gz10 = fract(gz10) - T(0.5);
-		detail::tvec4<T> gw10 = detail::tvec4<T>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
-		detail::tvec4<T> sw10 = step(gw10, detail::tvec4<T>(0.0));
-		gx10 -= sw10 * (step(0.0, gx10) - T(0.5));
-		gy10 -= sw10 * (step(0.0, gy10) - T(0.5));
-
-		detail::tvec4<T> gx11 = ixy11 / T(7);
-		detail::tvec4<T> gy11 = floor(gx11) / T(7);
-		detail::tvec4<T> gz11 = floor(gy11) / T(6);
-		gx11 = fract(gx11) - T(0.5);
-		gy11 = fract(gy11) - T(0.5);
-		gz11 = fract(gz11) - T(0.5);
-		detail::tvec4<T> gw11 = detail::tvec4<T>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
-		detail::tvec4<T> sw11 = step(gw11, detail::tvec4<T>(0.0));
-		gx11 -= sw11 * (step(0.0, gx11) - T(0.5));
-		gy11 -= sw11 * (step(0.0, gy11) - T(0.5));
-
-		detail::tvec4<T> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
-		detail::tvec4<T> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
-		detail::tvec4<T> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
-		detail::tvec4<T> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
-		detail::tvec4<T> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
-		detail::tvec4<T> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
-		detail::tvec4<T> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
-		detail::tvec4<T> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
-		detail::tvec4<T> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
-		detail::tvec4<T> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
-		detail::tvec4<T> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
-		detail::tvec4<T> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
-		detail::tvec4<T> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
-		detail::tvec4<T> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
-		detail::tvec4<T> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
-		detail::tvec4<T> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
-
-		detail::tvec4<T> norm00 = taylorInvSqrt(detail::tvec4<T>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
-		g0000 *= norm00.x;
-		g0100 *= norm00.y;
-		g1000 *= norm00.z;
-		g1100 *= norm00.w;
-
-		detail::tvec4<T> norm01 = taylorInvSqrt(detail::tvec4<T>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
-		g0001 *= norm01.x;
-		g0101 *= norm01.y;
-		g1001 *= norm01.z;
-		g1101 *= norm01.w;
-
-		detail::tvec4<T> norm10 = taylorInvSqrt(detail::tvec4<T>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
-		g0010 *= norm10.x;
-		g0110 *= norm10.y;
-		g1010 *= norm10.z;
-		g1110 *= norm10.w;
-
-		detail::tvec4<T> norm11 = taylorInvSqrt(detail::tvec4<T>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
-		g0011 *= norm11.x;
-		g0111 *= norm11.y;
-		g1011 *= norm11.z;
-		g1111 *= norm11.w;
-
-		T n0000 = dot(g0000, Pf0);
-		T n1000 = dot(g1000, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
-		T n0100 = dot(g0100, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
-		T n1100 = dot(g1100, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
-		T n0010 = dot(g0010, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
-		T n1010 = dot(g1010, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
-		T n0110 = dot(g0110, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
-		T n1110 = dot(g1110, detail::tvec4<T>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
-		T n0001 = dot(g0001, detail::tvec4<T>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
-		T n1001 = dot(g1001, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
-		T n0101 = dot(g0101, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
-		T n1101 = dot(g1101, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
-		T n0011 = dot(g0011, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
-		T n1011 = dot(g1011, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
-		T n0111 = dot(g0111, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
-		T n1111 = dot(g1111, Pf1);
-
-		detail::tvec4<T> fade_xyzw = fade(Pf0);
-		detail::tvec4<T> n_0w = mix(detail::tvec4<T>(n0000, n1000, n0100, n1100), detail::tvec4<T>(n0001, n1001, n0101, n1101), fade_xyzw.w);
-		detail::tvec4<T> n_1w = mix(detail::tvec4<T>(n0010, n1010, n0110, n1110), detail::tvec4<T>(n0011, n1011, n0111, n1111), fade_xyzw.w);
-		detail::tvec4<T> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
-		detail::tvec2<T> n_yzw = mix(detail::tvec2<T>(n_zw.x, n_zw.y), detail::tvec2<T>(n_zw.z, n_zw.w), fade_xyzw.y);
-		T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
-		return T(2.2) * n_xyzw;
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T simplex(glm::detail::tvec2<T> const & v)
-	{
-		detail::tvec4<T> const C = detail::tvec4<T>(
-			T( 0.211324865405187),  // (3.0 -  sqrt(3.0)) / 6.0
-			T( 0.366025403784439),  //  0.5 * (sqrt(3.0)  - 1.0)
-			T(-0.577350269189626),	// -1.0 + 2.0 * C.x
-			T( 0.024390243902439)); //  1.0 / 41.0
-
-		// First corner
-		detail::tvec2<T> i  = floor(v + dot(v, detail::tvec2<T>(C[1])));
-		detail::tvec2<T> x0 = v -   i + dot(i, detail::tvec2<T>(C[0]));
-
-		// Other corners
-		//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
-		//i1.y = 1.0 - i1.x;
-		detail::tvec2<T> i1 = (x0.x > x0.y) ? detail::tvec2<T>(1, 0) : detail::tvec2<T>(0, 1);
-		// x0 = x0 - 0.0 + 0.0 * C.xx ;
-		// x1 = x0 - i1 + 1.0 * C.xx ;
-		// x2 = x0 - 1.0 + 2.0 * C.xx ;
-		detail::tvec4<T> x12 = detail::tvec4<T>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T>(C.x, C.x, C.z, C.z);
-		x12 = detail::tvec4<T>(detail::tvec2<T>(x12) - i1, x12.z, x12.w);
-
-		// Permutations
-		i = mod(i, T(289)); // Avoid truncation effects in permutation
-		detail::tvec3<T> p = permute(
-			permute(i.y + detail::tvec3<T>(T(0), i1.y, T(1)))
-			+ i.x + detail::tvec3<T>(T(0), i1.x, T(1)));
-
-		detail::tvec3<T> m = max(T(0.5) - detail::tvec3<T>(
-			dot(x0, x0), 
-			dot(detail::tvec2<T>(x12.x, x12.y), detail::tvec2<T>(x12.x, x12.y)), 
-			dot(detail::tvec2<T>(x12.z, x12.w), detail::tvec2<T>(x12.z, x12.w))), T(0));
-		m = m * m ;
-		m = m * m ;
-
-		// Gradients: 41 points uniformly over a line, mapped onto a diamond.
-		// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
-
-		detail::tvec3<T> x = T(2) * fract(p * C.w) - T(1);
-		detail::tvec3<T> h = abs(x) - T(0.5);
-		detail::tvec3<T> ox = floor(x + T(0.5));
-		detail::tvec3<T> a0 = x - ox;
-
-		// Normalise gradients implicitly by scaling m
-		// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
-		m *= T(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
-
-		// Compute final noise value at P
-		detail::tvec3<T> g;
-		g.x  = a0.x  * x0.x  + h.x  * x0.y;
-		//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
-		g.y = a0.y * x12.x + h.y * x12.y;
-		g.z = a0.z * x12.z + h.z * x12.w;
-		return T(130) * dot(m, g);
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T simplex(detail::tvec3<T> const & v)
-	{ 
-		detail::tvec2<T> const C = detail::tvec2<T>(1.0 / 6.0, 1.0 / 3.0);
-		detail::tvec4<T> const D = detail::tvec4<T>(0.0, 0.5, 1.0, 2.0);
-
-		// First corner
-		detail::tvec3<T> i  = floor(v + dot(v, detail::tvec3<T>(C.y)));
-		detail::tvec3<T> x0 = v - i + dot(i, detail::tvec3<T>(C.x));
-
-		// Other corners
-		detail::tvec3<T> g = step(detail::tvec3<T>(x0.y, x0.z, x0.x), detail::tvec3<T>(x0.x, x0.y, x0.z));
-		detail::tvec3<T> l = T(1) - g;
-		detail::tvec3<T> i1 = min(detail::tvec3<T>(g.x, g.y, g.z), detail::tvec3<T>(l.z, l.x, l.y));
-		detail::tvec3<T> i2 = max(detail::tvec3<T>(g.x, g.y, g.z), detail::tvec3<T>(l.z, l.x, l.y));
-
-		//   x0 = x0 - 0.0 + 0.0 * C.xxx;
-		//   x1 = x0 - i1  + 1.0 * C.xxx;
-		//   x2 = x0 - i2  + 2.0 * C.xxx;
-		//   x3 = x0 - 1.0 + 3.0 * C.xxx;
-		detail::tvec3<T> x1 = x0 - i1 + C.x;
-		detail::tvec3<T> x2 = x0 - i2 + C.y; // 2.0*C.x = 1/3 = C.y
-		detail::tvec3<T> x3 = x0 - D.y;      // -1.0+3.0*C.x = -0.5 = -D.y
-
-		// Permutations
-		i = mod(i, T(289)); 
-		detail::tvec4<T> p = permute(permute(permute( 
-			i.z + detail::tvec4<T>(0.0, i1.z, i2.z, 1.0)) + 
-			i.y + detail::tvec4<T>(0.0, i1.y, i2.y, 1.0)) + 
-			i.x + detail::tvec4<T>(0.0, i1.x, i2.x, 1.0));
-
-		// Gradients: 7x7 points over a square, mapped onto an octahedron.
-		// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
-		T n_ = T(0.142857142857); // 1.0/7.0
-		detail::tvec3<T> ns = n_ * detail::tvec3<T>(D.w, D.y, D.z) - detail::tvec3<T>(D.x, D.z, D.x);
-
-		detail::tvec4<T> j = p - T(49) * floor(p * ns.z * ns.z);  //  mod(p,7*7)
-
-		detail::tvec4<T> x_ = floor(j * ns.z);
-		detail::tvec4<T> y_ = floor(j - T(7) * x_);    // mod(j,N)
-
-		detail::tvec4<T> x = x_ * ns.x + ns.y;
-		detail::tvec4<T> y = y_ * ns.x + ns.y;
-		detail::tvec4<T> h = T(1) - abs(x) - abs(y);
-
-		detail::tvec4<T> b0 = detail::tvec4<T>(x.x, x.y, y.x, y.y);
-		detail::tvec4<T> b1 = detail::tvec4<T>(x.z, x.w, y.z, y.w);
-
-		//vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
-		//vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
-		detail::tvec4<T> s0 = floor(b0) * T(2) + T(1);
-		detail::tvec4<T> s1 = floor(b1) * T(2) + T(1);
-		detail::tvec4<T> sh = -step(h, detail::tvec4<T>(0));
-
-		detail::tvec4<T> a0 = b0 + s0 * detail::tvec4<T>(sh.x, sh.x, sh.y, sh.y);
-		detail::tvec4<T> a1 = b1 + s1 * detail::tvec4<T>(sh.z, sh.z, sh.w, sh.w);
-
-		detail::tvec3<T> p0 = vec3(a0.x, a0.y, h.x);
-		detail::tvec3<T> p1 = vec3(a0.z, a0.w, h.y);
-		detail::tvec3<T> p2 = vec3(a1.x, a1.y, h.z);
-		detail::tvec3<T> p3 = vec3(a1.z, a1.w, h.w);
-
-		//Normalise gradients
-		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(
-			dot(p0, p0), 
-			dot(p1, p1), 
-			dot(p2, p2), 
-			dot(p3, p3)));
-		p0 *= norm.x;
-		p1 *= norm.y;
-		p2 *= norm.z;
-		p3 *= norm.w;
-
-		// Mix final noise value
-		vec4 m = max(T(0.6) - detail::tvec4<T>(
-			dot(x0, x0), 
-			dot(x1, x1), 
-			dot(x2, x2), 
-			dot(x3, x3)), T(0));
-		m = m * m;
-		return T(42) * dot(m * m, detail::tvec4<T>(
-			dot(p0, x0), 
-			dot(p1, x1), 
-			dot(p2, x2), 
-			dot(p3, x3)));
-	}
-
-	template <typename T>
-	GLM_FUNC_QUALIFIER T simplex(detail::tvec4<T> const & v)
-	{
-		detail::tvec4<T> const C(
-			0.138196601125011,  // (5 - sqrt(5))/20  G4
-			0.276393202250021,  // 2 * G4
-			0.414589803375032,  // 3 * G4
-			-0.447213595499958); // -1 + 4 * G4
-
-		// (sqrt(5) - 1)/4 = F4, used once below
-		T const F4 = T(0.309016994374947451);
-
-		// First corner
-		detail::tvec4<T> i  = floor(v + dot(v, vec4(F4)));
-		detail::tvec4<T> x0 = v -   i + dot(i, vec4(C.x));
-
-		// Other corners
-
-		// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
-		detail::tvec4<T> i0;
-		detail::tvec3<T> isX = step(detail::tvec3<T>(x0.y, x0.z, x0.w), detail::tvec3<T>(x0.x));
-		detail::tvec3<T> isYZ = step(detail::tvec3<T>(x0.z, x0.w, x0.w), detail::tvec3<T>(x0.y, x0.y, x0.z));
-		//  i0.x = dot(isX, vec3(1.0));
-		//i0.x = isX.x + isX.y + isX.z;
-		//i0.yzw = T(1) - isX;
-        i0 = detail::tvec4<T>(isX.x + isX.y + isX.z, T(1) - isX);
-		//  i0.y += dot(isYZ.xy, vec2(1.0));
-		i0.y += isYZ.x + isYZ.y;
-		//i0.zw += 1.0 - detail::tvec2<T>(isYZ.x, isYZ.y);
-        i0.z += T(1) - isYZ.x;
-        i0.w += T(1) - isYZ.y;
-		i0.z += isYZ.z;
-		i0.w += T(1) - isYZ.z;
-
-		// i0 now contains the unique values 0,1,2,3 in each channel
-		detail::tvec4<T> i3 = clamp(i0, 0.0, 1.0);
-		detail::tvec4<T> i2 = clamp(i0 - 1.0, 0.0, 1.0);
-		detail::tvec4<T> i1 = clamp(i0 - 2.0, 0.0, 1.0);
-
-		//  x0 = x0 - 0.0 + 0.0 * C.xxxx
-		//  x1 = x0 - i1  + 0.0 * C.xxxx
-		//  x2 = x0 - i2  + 0.0 * C.xxxx
-		//  x3 = x0 - i3  + 0.0 * C.xxxx
-		//  x4 = x0 - 1.0 + 4.0 * C.xxxx
-		detail::tvec4<T> x1 = x0 - i1 + C.x;
-		detail::tvec4<T> x2 = x0 - i2 + C.y;
-		detail::tvec4<T> x3 = x0 - i3 + C.z;
-		detail::tvec4<T> x4 = x0 + C.w;
-
-		// Permutations
-		i = mod(i, T(289)); 
-		T j0 = permute(permute(permute(permute(i.w) + i.z) + i.y) + i.x);
-		detail::tvec4<T> j1 = permute(permute(permute(permute(
-				 i.w + detail::tvec4<T>(i1.w, i2.w, i3.w, T(1)))
-			   + i.z + detail::tvec4<T>(i1.z, i2.z, i3.z, T(1)))
-			   + i.y + detail::tvec4<T>(i1.y, i2.y, i3.y, T(1)))
-			   + i.x + detail::tvec4<T>(i1.x, i2.x, i3.x, T(1)));
-
-		// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
-		// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
-		detail::tvec4<T> ip = detail::tvec4<T>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
-
-		detail::tvec4<T> p0 = grad4(j0,   ip);
-		detail::tvec4<T> p1 = grad4(j1.x, ip);
-		detail::tvec4<T> p2 = grad4(j1.y, ip);
-		detail::tvec4<T> p3 = grad4(j1.z, ip);
-		detail::tvec4<T> p4 = grad4(j1.w, ip);
-
-		// Normalise gradients
-		detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
-		p0 *= norm.x;
-		p1 *= norm.y;
-		p2 *= norm.z;
-		p3 *= norm.w;
-		p4 *= taylorInvSqrt(dot(p4, p4));
-
-		// Mix contributions from the five corners
-		detail::tvec3<T> m0 = max(T(0.6) - detail::tvec3<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
-		detail::tvec2<T> m1 = max(T(0.6) - detail::tvec2<T>(dot(x3, x3), dot(x4, x4)             ), T(0));
-		m0 = m0 * m0;
-		m1 = m1 * m1;
-		return T(49) * 
-			(dot(m0 * m0, detail::tvec3<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + 
-			dot(m1 * m1, detail::tvec2<T>(dot(p3, x3), dot(p4, x4))));
-	}
-
-}//namespace gtx
+template <typename T>
+GLM_FUNC_QUALIFIER T taylorInvSqrt(T const & r)
+{
+	return T(1.79284291400159) - T(0.85373472095314) * r;
+}
+
+template <typename T, template<typename> class vecType>
+GLM_FUNC_QUALIFIER vecType<T> taylorInvSqrt(vecType<T> const & r)
+{
+	return T(1.79284291400159) - T(0.85373472095314) * r;
+}
+
+template <typename T, template <typename> class vecType> 
+GLM_FUNC_QUALIFIER vecType<T> fade(vecType<T> const & t) 
+{
+	return t * t * t * (t * (t * T(6) - T(15)) + T(10));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER detail::tvec4<T> grad4(T const & j, detail::tvec4<T> const & ip)
+{
+	detail::tvec3<T> pXYZ = floor(fract(detail::tvec3<T>(j) * detail::tvec3<T>(ip)) * T(7)) * ip[2] - T(1);
+	T pW = T(1.5) - dot(abs(pXYZ), detail::tvec3<T>(1));
+	detail::tvec4<T> s = detail::tvec4<T>(lessThan(detail::tvec4<T>(pXYZ, pW), detail::tvec4<T>(0.0)));
+	pXYZ = pXYZ + (detail::tvec3<T>(s) * T(2) - T(1)) * s.w; 
+	return detail::tvec4<T>(pXYZ, pW);
+}
+
+// Classic Perlin noise
+template <typename T>
+GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P)
+{
+	detail::tvec4<T> Pi = glm::floor(detail::tvec4<T>(P.x, P.y, P.x, P.y)) + detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
+	detail::tvec4<T> Pf = glm::fract(detail::tvec4<T>(P.x, P.y, P.x, P.y)) - detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
+	Pi = mod(Pi, T(289)); // To avoid truncation effects in permutation
+	detail::tvec4<T> ix(Pi.x, Pi.z, Pi.x, Pi.z);
+	detail::tvec4<T> iy(Pi.y, Pi.y, Pi.w, Pi.w);
+	detail::tvec4<T> fx(Pf.x, Pf.z, Pf.x, Pf.z);
+	detail::tvec4<T> fy(Pf.y, Pf.y, Pf.w, Pf.w);
+
+	detail::tvec4<T> i = glm::permute(glm::permute(ix) + iy);
+
+	detail::tvec4<T> gx = T(2) * glm::fract(i / T(41)) - T(1);
+	detail::tvec4<T> gy = glm::abs(gx) - T(0.5);
+	detail::tvec4<T> tx = glm::floor(gx + T(0.5));
+	gx = gx - tx;
+
+	detail::tvec2<T> g00(gx.x, gy.x);
+	detail::tvec2<T> g10(gx.y, gy.y);
+	detail::tvec2<T> g01(gx.z, gy.z);
+	detail::tvec2<T> g11(gx.w, gy.w);
+
+	detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
+	g00 *= norm.x;  
+	g01 *= norm.y;  
+	g10 *= norm.z;  
+	g11 *= norm.w;  
+
+	T n00 = dot(g00, detail::tvec2<T>(fx.x, fy.x));
+	T n10 = dot(g10, detail::tvec2<T>(fx.y, fy.y));
+	T n01 = dot(g01, detail::tvec2<T>(fx.z, fy.z));
+	T n11 = dot(g11, detail::tvec2<T>(fx.w, fy.w));
+
+	detail::tvec2<T> fade_xy = fade(detail::tvec2<T>(Pf.x, Pf.y));
+	detail::tvec2<T> n_x = mix(detail::tvec2<T>(n00, n01), detail::tvec2<T>(n10, n11), fade_xy.x);
+	T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
+	return T(2.3) * n_xy;
+}
+
+// Classic Perlin noise
+template <typename T>
+GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P)
+{
+	detail::tvec3<T> Pi0 = floor(P); // Integer part for indexing
+	detail::tvec3<T> Pi1 = Pi0 + T(1); // Integer part + 1
+	Pi0 = mod(Pi0, T(289));
+	Pi1 = mod(Pi1, T(289));
+	detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
+	detail::tvec3<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
+	detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+	detail::tvec4<T> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+	detail::tvec4<T> iz0(Pi0.z);
+	detail::tvec4<T> iz1(Pi1.z);
+
+	detail::tvec4<T> ixy = permute(permute(ix) + iy);
+	detail::tvec4<T> ixy0 = permute(ixy + iz0);
+	detail::tvec4<T> ixy1 = permute(ixy + iz1);
+
+	detail::tvec4<T> gx0 = ixy0 / T(7);
+	detail::tvec4<T> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
+	gx0 = fract(gx0);
+	detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
+	detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0.0));
+	gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
+	gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
+
+	detail::tvec4<T> gx1 = ixy1 / T(7);
+	detail::tvec4<T> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
+	gx1 = fract(gx1);
+	detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
+	detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
+	gx1 -= sz1 * (step(T(0), gx1) - T(0.5));
+	gy1 -= sz1 * (step(T(0), gy1) - T(0.5));
+
+	detail::tvec3<T> g000(gx0.x, gy0.x, gz0.x);
+	detail::tvec3<T> g100(gx0.y, gy0.y, gz0.y);
+	detail::tvec3<T> g010(gx0.z, gy0.z, gz0.z);
+	detail::tvec3<T> g110(gx0.w, gy0.w, gz0.w);
+	detail::tvec3<T> g001(gx1.x, gy1.x, gz1.x);
+	detail::tvec3<T> g101(gx1.y, gy1.y, gz1.y);
+	detail::tvec3<T> g011(gx1.z, gy1.z, gz1.z);
+	detail::tvec3<T> g111(gx1.w, gy1.w, gz1.w);
+
+	detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+	g000 *= norm0.x;
+	g010 *= norm0.y;
+	g100 *= norm0.z;
+	g110 *= norm0.w;
+	detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+	g001 *= norm1.x;
+	g011 *= norm1.y;
+	g101 *= norm1.z;
+	g111 *= norm1.w;
+
+	T n000 = dot(g000, Pf0);
+	T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
+	T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
+	T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
+	T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
+	T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
+	T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
+	T n111 = dot(g111, Pf1);
+
+	detail::tvec3<T> fade_xyz = fade(Pf0);
+	detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
+	detail::tvec2<T> n_yz = mix(
+        detail::tvec2<T>(n_z.x, n_z.y), 
+        detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
+	T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
+	return T(2.2) * n_xyz;
+}
+
+// Classic Perlin noise
+template <typename T>
+GLM_FUNC_QUALIFIER T perlin(detail::tvec4<T> const & P)
+{
+	detail::tvec4<T> Pi0 = floor(P); // Integer part for indexing
+	detail::tvec4<T> Pi1 = Pi0 + T(1); // Integer part + 1
+	Pi0 = mod(Pi0, T(289));
+	Pi1 = mod(Pi1, T(289));
+	detail::tvec4<T> Pf0 = fract(P); // Fractional part for interpolation
+	detail::tvec4<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
+	detail::tvec4<T> ix(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+	detail::tvec4<T> iy(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+	detail::tvec4<T> iz0(Pi0.z);
+	detail::tvec4<T> iz1(Pi1.z);
+	detail::tvec4<T> iw0(Pi0.w);
+	detail::tvec4<T> iw1(Pi1.w);
+
+	detail::tvec4<T> ixy = permute(permute(ix) + iy);
+	detail::tvec4<T> ixy0 = permute(ixy + iz0);
+	detail::tvec4<T> ixy1 = permute(ixy + iz1);
+	detail::tvec4<T> ixy00 = permute(ixy0 + iw0);
+	detail::tvec4<T> ixy01 = permute(ixy0 + iw1);
+	detail::tvec4<T> ixy10 = permute(ixy1 + iw0);
+	detail::tvec4<T> ixy11 = permute(ixy1 + iw1);
+
+	detail::tvec4<T> gx00 = ixy00 / T(7);
+	detail::tvec4<T> gy00 = floor(gx00) / T(7);
+	detail::tvec4<T> gz00 = floor(gy00) / T(6);
+	gx00 = fract(gx00) - T(0.5);
+	gy00 = fract(gy00) - T(0.5);
+	gz00 = fract(gz00) - T(0.5);
+	detail::tvec4<T> gw00 = detail::tvec4<T>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
+	detail::tvec4<T> sw00 = step(gw00, detail::tvec4<T>(0.0));
+	gx00 -= sw00 * (step(T(0), gx00) - T(0.5));
+	gy00 -= sw00 * (step(T(0), gy00) - T(0.5));
+
+	detail::tvec4<T> gx01 = ixy01 / T(7);
+	detail::tvec4<T> gy01 = floor(gx01) / T(7);
+	detail::tvec4<T> gz01 = floor(gy01) / T(6);
+	gx01 = fract(gx01) - T(0.5);
+	gy01 = fract(gy01) - T(0.5);
+	gz01 = fract(gz01) - T(0.5);
+	detail::tvec4<T> gw01 = detail::tvec4<T>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
+	detail::tvec4<T> sw01 = step(gw01, detail::tvec4<T>(0.0));
+	gx01 -= sw01 * (step(T(0), gx01) - T(0.5));
+	gy01 -= sw01 * (step(T(0), gy01) - T(0.5));
+
+	detail::tvec4<T> gx10 = ixy10 / T(7);
+	detail::tvec4<T> gy10 = floor(gx10) / T(7);
+	detail::tvec4<T> gz10 = floor(gy10) / T(6);
+	gx10 = fract(gx10) - T(0.5);
+	gy10 = fract(gy10) - T(0.5);
+	gz10 = fract(gz10) - T(0.5);
+	detail::tvec4<T> gw10 = detail::tvec4<T>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
+	detail::tvec4<T> sw10 = step(gw10, detail::tvec4<T>(0));
+	gx10 -= sw10 * (step(T(0), gx10) - T(0.5));
+	gy10 -= sw10 * (step(T(0), gy10) - T(0.5));
+
+	detail::tvec4<T> gx11 = ixy11 / T(7);
+	detail::tvec4<T> gy11 = floor(gx11) / T(7);
+	detail::tvec4<T> gz11 = floor(gy11) / T(6);
+	gx11 = fract(gx11) - T(0.5);
+	gy11 = fract(gy11) - T(0.5);
+	gz11 = fract(gz11) - T(0.5);
+	detail::tvec4<T> gw11 = detail::tvec4<T>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
+	detail::tvec4<T> sw11 = step(gw11, detail::tvec4<T>(0.0));
+	gx11 -= sw11 * (step(T(0), gx11) - T(0.5));
+	gy11 -= sw11 * (step(T(0), gy11) - T(0.5));
+
+	detail::tvec4<T> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
+	detail::tvec4<T> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
+	detail::tvec4<T> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
+	detail::tvec4<T> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
+	detail::tvec4<T> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
+	detail::tvec4<T> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
+	detail::tvec4<T> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
+	detail::tvec4<T> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
+	detail::tvec4<T> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
+	detail::tvec4<T> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
+	detail::tvec4<T> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
+	detail::tvec4<T> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
+	detail::tvec4<T> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
+	detail::tvec4<T> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
+	detail::tvec4<T> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
+	detail::tvec4<T> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
+
+	detail::tvec4<T> norm00 = taylorInvSqrt(detail::tvec4<T>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
+	g0000 *= norm00.x;
+	g0100 *= norm00.y;
+	g1000 *= norm00.z;
+	g1100 *= norm00.w;
+
+	detail::tvec4<T> norm01 = taylorInvSqrt(detail::tvec4<T>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
+	g0001 *= norm01.x;
+	g0101 *= norm01.y;
+	g1001 *= norm01.z;
+	g1101 *= norm01.w;
+
+	detail::tvec4<T> norm10 = taylorInvSqrt(detail::tvec4<T>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
+	g0010 *= norm10.x;
+	g0110 *= norm10.y;
+	g1010 *= norm10.z;
+	g1110 *= norm10.w;
+
+	detail::tvec4<T> norm11 = taylorInvSqrt(detail::tvec4<T>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
+	g0011 *= norm11.x;
+	g0111 *= norm11.y;
+	g1011 *= norm11.z;
+	g1111 *= norm11.w;
+
+	T n0000 = dot(g0000, Pf0);
+	T n1000 = dot(g1000, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
+	T n0100 = dot(g0100, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
+	T n1100 = dot(g1100, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
+	T n0010 = dot(g0010, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
+	T n1010 = dot(g1010, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
+	T n0110 = dot(g0110, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
+	T n1110 = dot(g1110, detail::tvec4<T>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
+	T n0001 = dot(g0001, detail::tvec4<T>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
+	T n1001 = dot(g1001, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
+	T n0101 = dot(g0101, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
+	T n1101 = dot(g1101, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
+	T n0011 = dot(g0011, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
+	T n1011 = dot(g1011, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
+	T n0111 = dot(g0111, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
+	T n1111 = dot(g1111, Pf1);
+
+	detail::tvec4<T> fade_xyzw = fade(Pf0);
+	detail::tvec4<T> n_0w = mix(detail::tvec4<T>(n0000, n1000, n0100, n1100), detail::tvec4<T>(n0001, n1001, n0101, n1101), fade_xyzw.w);
+	detail::tvec4<T> n_1w = mix(detail::tvec4<T>(n0010, n1010, n0110, n1110), detail::tvec4<T>(n0011, n1011, n0111, n1111), fade_xyzw.w);
+	detail::tvec4<T> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
+	detail::tvec2<T> n_yzw = mix(detail::tvec2<T>(n_zw.x, n_zw.y), detail::tvec2<T>(n_zw.z, n_zw.w), fade_xyzw.y);
+	T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
+	return T(2.2) * n_xyzw;
+}
+
+// Classic Perlin noise, periodic variant
+template <typename T>
+GLM_FUNC_QUALIFIER T perlin(detail::tvec2<T> const & P, detail::tvec2<T> const & rep)
+{
+	detail::tvec4<T> Pi = floor(detail::tvec4<T>(P.x, P.y, P.x, P.y)) + detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
+	detail::tvec4<T> Pf = fract(detail::tvec4<T>(P.x, P.y, P.x, P.y)) - detail::tvec4<T>(0.0, 0.0, 1.0, 1.0);
+	Pi = mod(Pi, detail::tvec4<T>(rep.x, rep.y, rep.x, rep.y)); // To create noise with explicit period
+	Pi = mod(Pi, T(289)); // To avoid truncation effects in permutation
+	detail::tvec4<T> ix(Pi.x, Pi.z, Pi.x, Pi.z);
+	detail::tvec4<T> iy(Pi.y, Pi.y, Pi.w, Pi.w);
+	detail::tvec4<T> fx(Pf.x, Pf.z, Pf.x, Pf.z);
+	detail::tvec4<T> fy(Pf.y, Pf.y, Pf.w, Pf.w);
+
+	detail::tvec4<T> i = permute(permute(ix) + iy);
+
+	detail::tvec4<T> gx = T(2) * fract(i / T(41)) - T(1);
+	detail::tvec4<T> gy = abs(gx) - T(0.5);
+	detail::tvec4<T> tx = floor(gx + T(0.5));
+	gx = gx - tx;
+
+	detail::tvec2<T> g00(gx.x, gy.x);
+	detail::tvec2<T> g10(gx.y, gy.y);
+	detail::tvec2<T> g01(gx.z, gy.z);
+	detail::tvec2<T> g11(gx.w, gy.w);
+
+	detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11)));
+	g00 *= norm.x;  
+	g01 *= norm.y;  
+	g10 *= norm.z;  
+	g11 *= norm.w;  
+
+	T n00 = dot(g00, detail::tvec2<T>(fx.x, fy.x));
+	T n10 = dot(g10, detail::tvec2<T>(fx.y, fy.y));
+	T n01 = dot(g01, detail::tvec2<T>(fx.z, fy.z));
+	T n11 = dot(g11, detail::tvec2<T>(fx.w, fy.w));
+
+	detail::tvec2<T> fade_xy = fade(detail::tvec2<T>(Pf.x, Pf.y));
+	detail::tvec2<T> n_x = mix(detail::tvec2<T>(n00, n01), detail::tvec2<T>(n10, n11), fade_xy.x);
+	T n_xy = mix(n_x.x, n_x.y, fade_xy.y);
+	return T(2.3) * n_xy;
+}
+
+// Classic Perlin noise, periodic variant
+template <typename T>
+GLM_FUNC_QUALIFIER T perlin(detail::tvec3<T> const & P, detail::tvec3<T> const & rep)
+{
+	detail::tvec3<T> Pi0 = mod(floor(P), rep); // Integer part, modulo period
+	detail::tvec3<T> Pi1 = mod(Pi0 + detail::tvec3<T>(1.0), rep); // Integer part + 1, mod period
+	Pi0 = mod(Pi0, T(289));
+	Pi1 = mod(Pi1, T(289));
+	detail::tvec3<T> Pf0 = fract(P); // Fractional part for interpolation
+	detail::tvec3<T> Pf1 = Pf0 - detail::tvec3<T>(1.0); // Fractional part - 1.0
+	detail::tvec4<T> ix = detail::tvec4<T>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+	detail::tvec4<T> iy = detail::tvec4<T>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+	detail::tvec4<T> iz0(Pi0.z);
+	detail::tvec4<T> iz1(Pi1.z);
+
+	detail::tvec4<T> ixy = permute(permute(ix) + iy);
+	detail::tvec4<T> ixy0 = permute(ixy + iz0);
+	detail::tvec4<T> ixy1 = permute(ixy + iz1);
+
+	detail::tvec4<T> gx0 = ixy0 / T(7);
+	detail::tvec4<T> gy0 = fract(floor(gx0) / T(7)) - T(0.5);
+	gx0 = fract(gx0);
+	detail::tvec4<T> gz0 = detail::tvec4<T>(0.5) - abs(gx0) - abs(gy0);
+	detail::tvec4<T> sz0 = step(gz0, detail::tvec4<T>(0));
+	gx0 -= sz0 * (step(0.0, gx0) - T(0.5));
+	gy0 -= sz0 * (step(0.0, gy0) - T(0.5));
+
+	detail::tvec4<T> gx1 = ixy1 / T(7);
+	detail::tvec4<T> gy1 = fract(floor(gx1) / T(7)) - T(0.5);
+	gx1 = fract(gx1);
+	detail::tvec4<T> gz1 = detail::tvec4<T>(0.5) - abs(gx1) - abs(gy1);
+	detail::tvec4<T> sz1 = step(gz1, detail::tvec4<T>(0.0));
+	gx1 -= sz1 * (step(0.0, gx1) - T(0.5));
+	gy1 -= sz1 * (step(0.0, gy1) - T(0.5));
+
+	detail::tvec3<T> g000 = detail::tvec3<T>(gx0.x, gy0.x, gz0.x);
+	detail::tvec3<T> g100 = detail::tvec3<T>(gx0.y, gy0.y, gz0.y);
+	detail::tvec3<T> g010 = detail::tvec3<T>(gx0.z, gy0.z, gz0.z);
+	detail::tvec3<T> g110 = detail::tvec3<T>(gx0.w, gy0.w, gz0.w);
+	detail::tvec3<T> g001 = detail::tvec3<T>(gx1.x, gy1.x, gz1.x);
+	detail::tvec3<T> g101 = detail::tvec3<T>(gx1.y, gy1.y, gz1.y);
+	detail::tvec3<T> g011 = detail::tvec3<T>(gx1.z, gy1.z, gz1.z);
+	detail::tvec3<T> g111 = detail::tvec3<T>(gx1.w, gy1.w, gz1.w);
+
+	detail::tvec4<T> norm0 = taylorInvSqrt(detail::tvec4<T>(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110)));
+	g000 *= norm0.x;
+	g010 *= norm0.y;
+	g100 *= norm0.z;
+	g110 *= norm0.w;
+	detail::tvec4<T> norm1 = taylorInvSqrt(detail::tvec4<T>(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111)));
+	g001 *= norm1.x;
+	g011 *= norm1.y;
+	g101 *= norm1.z;
+	g111 *= norm1.w;
+
+	T n000 = dot(g000, Pf0);
+	T n100 = dot(g100, detail::tvec3<T>(Pf1.x, Pf0.y, Pf0.z));
+	T n010 = dot(g010, detail::tvec3<T>(Pf0.x, Pf1.y, Pf0.z));
+	T n110 = dot(g110, detail::tvec3<T>(Pf1.x, Pf1.y, Pf0.z));
+	T n001 = dot(g001, detail::tvec3<T>(Pf0.x, Pf0.y, Pf1.z));
+	T n101 = dot(g101, detail::tvec3<T>(Pf1.x, Pf0.y, Pf1.z));
+	T n011 = dot(g011, detail::tvec3<T>(Pf0.x, Pf1.y, Pf1.z));
+	T n111 = dot(g111, Pf1);
+
+	detail::tvec3<T> fade_xyz = fade(Pf0);
+	detail::tvec4<T> n_z = mix(detail::tvec4<T>(n000, n100, n010, n110), detail::tvec4<T>(n001, n101, n011, n111), fade_xyz.z);
+	detail::tvec2<T> n_yz = mix(detail::tvec2<T>(n_z.x, n_z.y), detail::tvec2<T>(n_z.z, n_z.w), fade_xyz.y);
+	T n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); 
+	return T(2.2) * n_xyz;
+}
+
+// Classic Perlin noise, periodic version
+template <typename T>
+GLM_FUNC_QUALIFIER T perlin(detail::tvec4<T> const & P, detail::tvec4<T> const & rep)
+{
+	detail::tvec4<T> Pi0 = mod(floor(P), rep); // Integer part modulo rep
+	detail::tvec4<T> Pi1 = mod(Pi0 + T(1), rep); // Integer part + 1 mod rep
+	detail::tvec4<T> Pf0 = fract(P); // Fractional part for interpolation
+	detail::tvec4<T> Pf1 = Pf0 - T(1); // Fractional part - 1.0
+	detail::tvec4<T> ix = detail::tvec4<T>(Pi0.x, Pi1.x, Pi0.x, Pi1.x);
+	detail::tvec4<T> iy = detail::tvec4<T>(Pi0.y, Pi0.y, Pi1.y, Pi1.y);
+	detail::tvec4<T> iz0(Pi0.z);
+	detail::tvec4<T> iz1(Pi1.z);
+	detail::tvec4<T> iw0(Pi0.w);
+	detail::tvec4<T> iw1(Pi1.w);
+
+	detail::tvec4<T> ixy = permute(permute(ix) + iy);
+	detail::tvec4<T> ixy0 = permute(ixy + iz0);
+	detail::tvec4<T> ixy1 = permute(ixy + iz1);
+	detail::tvec4<T> ixy00 = permute(ixy0 + iw0);
+	detail::tvec4<T> ixy01 = permute(ixy0 + iw1);
+	detail::tvec4<T> ixy10 = permute(ixy1 + iw0);
+	detail::tvec4<T> ixy11 = permute(ixy1 + iw1);
+
+	detail::tvec4<T> gx00 = ixy00 / T(7);
+	detail::tvec4<T> gy00 = floor(gx00) / T(7);
+	detail::tvec4<T> gz00 = floor(gy00) / T(6);
+	gx00 = fract(gx00) - T(0.5);
+	gy00 = fract(gy00) - T(0.5);
+	gz00 = fract(gz00) - T(0.5);
+	detail::tvec4<T> gw00 = detail::tvec4<T>(0.75) - abs(gx00) - abs(gy00) - abs(gz00);
+	detail::tvec4<T> sw00 = step(gw00, detail::tvec4<T>(0));
+	gx00 -= sw00 * (step(0.0, gx00) - T(0.5));
+	gy00 -= sw00 * (step(0.0, gy00) - T(0.5));
+
+	detail::tvec4<T> gx01 = ixy01 / T(7);
+	detail::tvec4<T> gy01 = floor(gx01) / T(7);
+	detail::tvec4<T> gz01 = floor(gy01) / T(6);
+	gx01 = fract(gx01) - T(0.5);
+	gy01 = fract(gy01) - T(0.5);
+	gz01 = fract(gz01) - T(0.5);
+	detail::tvec4<T> gw01 = detail::tvec4<T>(0.75) - abs(gx01) - abs(gy01) - abs(gz01);
+	detail::tvec4<T> sw01 = step(gw01, detail::tvec4<T>(0.0));
+	gx01 -= sw01 * (step(0.0, gx01) - T(0.5));
+	gy01 -= sw01 * (step(0.0, gy01) - T(0.5));
+
+	detail::tvec4<T> gx10 = ixy10 / T(7);
+	detail::tvec4<T> gy10 = floor(gx10) / T(7);
+	detail::tvec4<T> gz10 = floor(gy10) / T(6);
+	gx10 = fract(gx10) - T(0.5);
+	gy10 = fract(gy10) - T(0.5);
+	gz10 = fract(gz10) - T(0.5);
+	detail::tvec4<T> gw10 = detail::tvec4<T>(0.75) - abs(gx10) - abs(gy10) - abs(gz10);
+	detail::tvec4<T> sw10 = step(gw10, detail::tvec4<T>(0.0));
+	gx10 -= sw10 * (step(0.0, gx10) - T(0.5));
+	gy10 -= sw10 * (step(0.0, gy10) - T(0.5));
+
+	detail::tvec4<T> gx11 = ixy11 / T(7);
+	detail::tvec4<T> gy11 = floor(gx11) / T(7);
+	detail::tvec4<T> gz11 = floor(gy11) / T(6);
+	gx11 = fract(gx11) - T(0.5);
+	gy11 = fract(gy11) - T(0.5);
+	gz11 = fract(gz11) - T(0.5);
+	detail::tvec4<T> gw11 = detail::tvec4<T>(0.75) - abs(gx11) - abs(gy11) - abs(gz11);
+	detail::tvec4<T> sw11 = step(gw11, detail::tvec4<T>(0.0));
+	gx11 -= sw11 * (step(0.0, gx11) - T(0.5));
+	gy11 -= sw11 * (step(0.0, gy11) - T(0.5));
+
+	detail::tvec4<T> g0000(gx00.x, gy00.x, gz00.x, gw00.x);
+	detail::tvec4<T> g1000(gx00.y, gy00.y, gz00.y, gw00.y);
+	detail::tvec4<T> g0100(gx00.z, gy00.z, gz00.z, gw00.z);
+	detail::tvec4<T> g1100(gx00.w, gy00.w, gz00.w, gw00.w);
+	detail::tvec4<T> g0010(gx10.x, gy10.x, gz10.x, gw10.x);
+	detail::tvec4<T> g1010(gx10.y, gy10.y, gz10.y, gw10.y);
+	detail::tvec4<T> g0110(gx10.z, gy10.z, gz10.z, gw10.z);
+	detail::tvec4<T> g1110(gx10.w, gy10.w, gz10.w, gw10.w);
+	detail::tvec4<T> g0001(gx01.x, gy01.x, gz01.x, gw01.x);
+	detail::tvec4<T> g1001(gx01.y, gy01.y, gz01.y, gw01.y);
+	detail::tvec4<T> g0101(gx01.z, gy01.z, gz01.z, gw01.z);
+	detail::tvec4<T> g1101(gx01.w, gy01.w, gz01.w, gw01.w);
+	detail::tvec4<T> g0011(gx11.x, gy11.x, gz11.x, gw11.x);
+	detail::tvec4<T> g1011(gx11.y, gy11.y, gz11.y, gw11.y);
+	detail::tvec4<T> g0111(gx11.z, gy11.z, gz11.z, gw11.z);
+	detail::tvec4<T> g1111(gx11.w, gy11.w, gz11.w, gw11.w);
+
+	detail::tvec4<T> norm00 = taylorInvSqrt(detail::tvec4<T>(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100)));
+	g0000 *= norm00.x;
+	g0100 *= norm00.y;
+	g1000 *= norm00.z;
+	g1100 *= norm00.w;
+
+	detail::tvec4<T> norm01 = taylorInvSqrt(detail::tvec4<T>(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101)));
+	g0001 *= norm01.x;
+	g0101 *= norm01.y;
+	g1001 *= norm01.z;
+	g1101 *= norm01.w;
+
+	detail::tvec4<T> norm10 = taylorInvSqrt(detail::tvec4<T>(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110)));
+	g0010 *= norm10.x;
+	g0110 *= norm10.y;
+	g1010 *= norm10.z;
+	g1110 *= norm10.w;
+
+	detail::tvec4<T> norm11 = taylorInvSqrt(detail::tvec4<T>(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111)));
+	g0011 *= norm11.x;
+	g0111 *= norm11.y;
+	g1011 *= norm11.z;
+	g1111 *= norm11.w;
+
+	T n0000 = dot(g0000, Pf0);
+	T n1000 = dot(g1000, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf0.w));
+	T n0100 = dot(g0100, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf0.w));
+	T n1100 = dot(g1100, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf0.w));
+	T n0010 = dot(g0010, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf0.w));
+	T n1010 = dot(g1010, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf0.w));
+	T n0110 = dot(g0110, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf0.w));
+	T n1110 = dot(g1110, detail::tvec4<T>(Pf1.x, Pf1.y, Pf1.z, Pf0.w));
+	T n0001 = dot(g0001, detail::tvec4<T>(Pf0.x, Pf0.y, Pf0.z, Pf1.w));
+	T n1001 = dot(g1001, detail::tvec4<T>(Pf1.x, Pf0.y, Pf0.z, Pf1.w));
+	T n0101 = dot(g0101, detail::tvec4<T>(Pf0.x, Pf1.y, Pf0.z, Pf1.w));
+	T n1101 = dot(g1101, detail::tvec4<T>(Pf1.x, Pf1.y, Pf0.z, Pf1.w));
+	T n0011 = dot(g0011, detail::tvec4<T>(Pf0.x, Pf0.y, Pf1.z, Pf1.w));
+	T n1011 = dot(g1011, detail::tvec4<T>(Pf1.x, Pf0.y, Pf1.z, Pf1.w));
+	T n0111 = dot(g0111, detail::tvec4<T>(Pf0.x, Pf1.y, Pf1.z, Pf1.w));
+	T n1111 = dot(g1111, Pf1);
+
+	detail::tvec4<T> fade_xyzw = fade(Pf0);
+	detail::tvec4<T> n_0w = mix(detail::tvec4<T>(n0000, n1000, n0100, n1100), detail::tvec4<T>(n0001, n1001, n0101, n1101), fade_xyzw.w);
+	detail::tvec4<T> n_1w = mix(detail::tvec4<T>(n0010, n1010, n0110, n1110), detail::tvec4<T>(n0011, n1011, n0111, n1111), fade_xyzw.w);
+	detail::tvec4<T> n_zw = mix(n_0w, n_1w, fade_xyzw.z);
+	detail::tvec2<T> n_yzw = mix(detail::tvec2<T>(n_zw.x, n_zw.y), detail::tvec2<T>(n_zw.z, n_zw.w), fade_xyzw.y);
+	T n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x);
+	return T(2.2) * n_xyzw;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER T simplex(glm::detail::tvec2<T> const & v)
+{
+	detail::tvec4<T> const C = detail::tvec4<T>(
+		T( 0.211324865405187),  // (3.0 -  sqrt(3.0)) / 6.0
+		T( 0.366025403784439),  //  0.5 * (sqrt(3.0)  - 1.0)
+		T(-0.577350269189626),	// -1.0 + 2.0 * C.x
+		T( 0.024390243902439)); //  1.0 / 41.0
+
+	// First corner
+	detail::tvec2<T> i  = floor(v + dot(v, detail::tvec2<T>(C[1])));
+	detail::tvec2<T> x0 = v -   i + dot(i, detail::tvec2<T>(C[0]));
+
+	// Other corners
+	//i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
+	//i1.y = 1.0 - i1.x;
+	detail::tvec2<T> i1 = (x0.x > x0.y) ? detail::tvec2<T>(1, 0) : detail::tvec2<T>(0, 1);
+	// x0 = x0 - 0.0 + 0.0 * C.xx ;
+	// x1 = x0 - i1 + 1.0 * C.xx ;
+	// x2 = x0 - 1.0 + 2.0 * C.xx ;
+	detail::tvec4<T> x12 = detail::tvec4<T>(x0.x, x0.y, x0.x, x0.y) + detail::tvec4<T>(C.x, C.x, C.z, C.z);
+	x12 = detail::tvec4<T>(detail::tvec2<T>(x12) - i1, x12.z, x12.w);
+
+	// Permutations
+	i = mod(i, T(289)); // Avoid truncation effects in permutation
+	detail::tvec3<T> p = permute(
+		permute(i.y + detail::tvec3<T>(T(0), i1.y, T(1)))
+		+ i.x + detail::tvec3<T>(T(0), i1.x, T(1)));
+
+	detail::tvec3<T> m = max(T(0.5) - detail::tvec3<T>(
+		dot(x0, x0), 
+		dot(detail::tvec2<T>(x12.x, x12.y), detail::tvec2<T>(x12.x, x12.y)), 
+		dot(detail::tvec2<T>(x12.z, x12.w), detail::tvec2<T>(x12.z, x12.w))), T(0));
+	m = m * m ;
+	m = m * m ;
+
+	// Gradients: 41 points uniformly over a line, mapped onto a diamond.
+	// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)
+
+	detail::tvec3<T> x = T(2) * fract(p * C.w) - T(1);
+	detail::tvec3<T> h = abs(x) - T(0.5);
+	detail::tvec3<T> ox = floor(x + T(0.5));
+	detail::tvec3<T> a0 = x - ox;
+
+	// Normalise gradients implicitly by scaling m
+	// Inlined for speed: m *= taylorInvSqrt( a0*a0 + h*h );
+	m *= T(1.79284291400159) - T(0.85373472095314) * (a0 * a0 + h * h);
+
+	// Compute final noise value at P
+	detail::tvec3<T> g;
+	g.x  = a0.x  * x0.x  + h.x  * x0.y;
+	//g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+	g.y = a0.y * x12.x + h.y * x12.y;
+	g.z = a0.z * x12.z + h.z * x12.w;
+	return T(130) * dot(m, g);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER T simplex(detail::tvec3<T> const & v)
+{ 
+	detail::tvec2<T> const C = detail::tvec2<T>(1.0 / 6.0, 1.0 / 3.0);
+	detail::tvec4<T> const D = detail::tvec4<T>(0.0, 0.5, 1.0, 2.0);
+
+	// First corner
+	detail::tvec3<T> i  = floor(v + dot(v, detail::tvec3<T>(C.y)));
+	detail::tvec3<T> x0 = v - i + dot(i, detail::tvec3<T>(C.x));
+
+	// Other corners
+	detail::tvec3<T> g = step(detail::tvec3<T>(x0.y, x0.z, x0.x), detail::tvec3<T>(x0.x, x0.y, x0.z));
+	detail::tvec3<T> l = T(1) - g;
+	detail::tvec3<T> i1 = min(detail::tvec3<T>(g.x, g.y, g.z), detail::tvec3<T>(l.z, l.x, l.y));
+	detail::tvec3<T> i2 = max(detail::tvec3<T>(g.x, g.y, g.z), detail::tvec3<T>(l.z, l.x, l.y));
+
+	//   x0 = x0 - 0.0 + 0.0 * C.xxx;
+	//   x1 = x0 - i1  + 1.0 * C.xxx;
+	//   x2 = x0 - i2  + 2.0 * C.xxx;
+	//   x3 = x0 - 1.0 + 3.0 * C.xxx;
+	detail::tvec3<T> x1 = x0 - i1 + C.x;
+	detail::tvec3<T> x2 = x0 - i2 + C.y; // 2.0*C.x = 1/3 = C.y
+	detail::tvec3<T> x3 = x0 - D.y;      // -1.0+3.0*C.x = -0.5 = -D.y
+
+	// Permutations
+	i = mod(i, T(289)); 
+	detail::tvec4<T> p = permute(permute(permute( 
+		i.z + detail::tvec4<T>(0.0, i1.z, i2.z, 1.0)) + 
+		i.y + detail::tvec4<T>(0.0, i1.y, i2.y, 1.0)) + 
+		i.x + detail::tvec4<T>(0.0, i1.x, i2.x, 1.0));
+
+	// Gradients: 7x7 points over a square, mapped onto an octahedron.
+	// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
+	T n_ = T(0.142857142857); // 1.0/7.0
+	detail::tvec3<T> ns = n_ * detail::tvec3<T>(D.w, D.y, D.z) - detail::tvec3<T>(D.x, D.z, D.x);
+
+	detail::tvec4<T> j = p - T(49) * floor(p * ns.z * ns.z);  //  mod(p,7*7)
+
+	detail::tvec4<T> x_ = floor(j * ns.z);
+	detail::tvec4<T> y_ = floor(j - T(7) * x_);    // mod(j,N)
+
+	detail::tvec4<T> x = x_ * ns.x + ns.y;
+	detail::tvec4<T> y = y_ * ns.x + ns.y;
+	detail::tvec4<T> h = T(1) - abs(x) - abs(y);
+
+	detail::tvec4<T> b0 = detail::tvec4<T>(x.x, x.y, y.x, y.y);
+	detail::tvec4<T> b1 = detail::tvec4<T>(x.z, x.w, y.z, y.w);
+
+	//vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
+	//vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
+	detail::tvec4<T> s0 = floor(b0) * T(2) + T(1);
+	detail::tvec4<T> s1 = floor(b1) * T(2) + T(1);
+	detail::tvec4<T> sh = -step(h, detail::tvec4<T>(0));
+
+	detail::tvec4<T> a0 = b0 + s0 * detail::tvec4<T>(sh.x, sh.x, sh.y, sh.y);
+	detail::tvec4<T> a1 = b1 + s1 * detail::tvec4<T>(sh.z, sh.z, sh.w, sh.w);
+
+	detail::tvec3<T> p0 = vec3(a0.x, a0.y, h.x);
+	detail::tvec3<T> p1 = vec3(a0.z, a0.w, h.y);
+	detail::tvec3<T> p2 = vec3(a1.x, a1.y, h.z);
+	detail::tvec3<T> p3 = vec3(a1.z, a1.w, h.w);
+
+	//Normalise gradients
+	detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(
+		dot(p0, p0), 
+		dot(p1, p1), 
+		dot(p2, p2), 
+		dot(p3, p3)));
+	p0 *= norm.x;
+	p1 *= norm.y;
+	p2 *= norm.z;
+	p3 *= norm.w;
+
+	// Mix final noise value
+	vec4 m = max(T(0.6) - detail::tvec4<T>(
+		dot(x0, x0), 
+		dot(x1, x1), 
+		dot(x2, x2), 
+		dot(x3, x3)), T(0));
+	m = m * m;
+	return T(42) * dot(m * m, detail::tvec4<T>(
+		dot(p0, x0), 
+		dot(p1, x1), 
+		dot(p2, x2), 
+		dot(p3, x3)));
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER T simplex(detail::tvec4<T> const & v)
+{
+	detail::tvec4<T> const C(
+		0.138196601125011,  // (5 - sqrt(5))/20  G4
+		0.276393202250021,  // 2 * G4
+		0.414589803375032,  // 3 * G4
+		-0.447213595499958); // -1 + 4 * G4
+
+	// (sqrt(5) - 1)/4 = F4, used once below
+	T const F4 = T(0.309016994374947451);
+
+	// First corner
+	detail::tvec4<T> i  = floor(v + dot(v, vec4(F4)));
+	detail::tvec4<T> x0 = v -   i + dot(i, vec4(C.x));
+
+	// Other corners
+
+	// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI)
+	detail::tvec4<T> i0;
+	detail::tvec3<T> isX = step(detail::tvec3<T>(x0.y, x0.z, x0.w), detail::tvec3<T>(x0.x));
+	detail::tvec3<T> isYZ = step(detail::tvec3<T>(x0.z, x0.w, x0.w), detail::tvec3<T>(x0.y, x0.y, x0.z));
+	//  i0.x = dot(isX, vec3(1.0));
+	//i0.x = isX.x + isX.y + isX.z;
+	//i0.yzw = T(1) - isX;
+    i0 = detail::tvec4<T>(isX.x + isX.y + isX.z, T(1) - isX);
+	//  i0.y += dot(isYZ.xy, vec2(1.0));
+	i0.y += isYZ.x + isYZ.y;
+	//i0.zw += 1.0 - detail::tvec2<T>(isYZ.x, isYZ.y);
+    i0.z += T(1) - isYZ.x;
+    i0.w += T(1) - isYZ.y;
+	i0.z += isYZ.z;
+	i0.w += T(1) - isYZ.z;
+
+	// i0 now contains the unique values 0,1,2,3 in each channel
+	detail::tvec4<T> i3 = clamp(i0, 0.0, 1.0);
+	detail::tvec4<T> i2 = clamp(i0 - 1.0, 0.0, 1.0);
+	detail::tvec4<T> i1 = clamp(i0 - 2.0, 0.0, 1.0);
+
+	//  x0 = x0 - 0.0 + 0.0 * C.xxxx
+	//  x1 = x0 - i1  + 0.0 * C.xxxx
+	//  x2 = x0 - i2  + 0.0 * C.xxxx
+	//  x3 = x0 - i3  + 0.0 * C.xxxx
+	//  x4 = x0 - 1.0 + 4.0 * C.xxxx
+	detail::tvec4<T> x1 = x0 - i1 + C.x;
+	detail::tvec4<T> x2 = x0 - i2 + C.y;
+	detail::tvec4<T> x3 = x0 - i3 + C.z;
+	detail::tvec4<T> x4 = x0 + C.w;
+
+	// Permutations
+	i = mod(i, T(289)); 
+	T j0 = permute(permute(permute(permute(i.w) + i.z) + i.y) + i.x);
+	detail::tvec4<T> j1 = permute(permute(permute(permute(
+				i.w + detail::tvec4<T>(i1.w, i2.w, i3.w, T(1)))
+			+ i.z + detail::tvec4<T>(i1.z, i2.z, i3.z, T(1)))
+			+ i.y + detail::tvec4<T>(i1.y, i2.y, i3.y, T(1)))
+			+ i.x + detail::tvec4<T>(i1.x, i2.x, i3.x, T(1)));
+
+	// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope
+	// 7*7*6 = 294, which is close to the ring size 17*17 = 289.
+	detail::tvec4<T> ip = detail::tvec4<T>(T(1) / T(294), T(1) / T(49), T(1) / T(7), T(0));
+
+	detail::tvec4<T> p0 = grad4(j0,   ip);
+	detail::tvec4<T> p1 = grad4(j1.x, ip);
+	detail::tvec4<T> p2 = grad4(j1.y, ip);
+	detail::tvec4<T> p3 = grad4(j1.z, ip);
+	detail::tvec4<T> p4 = grad4(j1.w, ip);
+
+	// Normalise gradients
+	detail::tvec4<T> norm = taylorInvSqrt(detail::tvec4<T>(dot(p0, p0), dot(p1, p1), dot(p2, p2), dot(p3, p3)));
+	p0 *= norm.x;
+	p1 *= norm.y;
+	p2 *= norm.z;
+	p3 *= norm.w;
+	p4 *= taylorInvSqrt(dot(p4, p4));
+
+	// Mix contributions from the five corners
+	detail::tvec3<T> m0 = max(T(0.6) - detail::tvec3<T>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), T(0));
+	detail::tvec2<T> m1 = max(T(0.6) - detail::tvec2<T>(dot(x3, x3), dot(x4, x4)             ), T(0));
+	m0 = m0 * m0;
+	m1 = m1 * m1;
+	return T(49) * 
+		(dot(m0 * m0, detail::tvec3<T>(dot(p0, x0), dot(p1, x1), dot(p2, x2))) + 
+		dot(m1 * m1, detail::tvec2<T>(dot(p3, x3), dot(p4, x4))));
+}
+
 }//namespace glm

glm/gtx/norm.hpp

@@ -49,8 +49,7 @@
 #	pragma message("GLM: GLM_GTX_norm extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_norm
 	/// @{
@@ -155,7 +154,6 @@ namespace gtx
 		unsigned int Depth);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "norm.inl"

glm/gtx/norm.inl

@@ -8,121 +8,119 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx
+
+template <typename T>
+GLM_FUNC_QUALIFIER T length2(
+	const T x)
+{
+    return x * x;
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER T length2(
+	const detail::tvec2<T>& x)
+{
+    return dot(x, x);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER T length2(
+	const detail::tvec3<T>& x)
+{
+    return dot(x, x);
+}
+
+template <typename T>
+GLM_FUNC_QUALIFIER T length2(
+	const detail::tvec4<T>& x)
+{
+    return dot(x, x);
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER T length2(
+	const detail::tquat<T>& q)
+{
+    return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
+}
+
+template <typename T> 
+T distance2(
+	const T p0, 
+	const T p1)
+{
+	return length2(p1 - p0);
+}
+
+template <typename T> 
+T distance2(
+	const detail::tvec2<T>& p0, 
+	const detail::tvec2<T>& p1)
+{
+	return length2(p1 - p0);
+}
+
+template <typename T> 
+T distance2(
+	const detail::tvec3<T>& p0, 
+	const detail::tvec3<T>& p1)
 {
-	template <typename T>
-    GLM_FUNC_QUALIFIER T length2(
-		const T x)
-    {
-        return x * x;
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER T length2(
-		const detail::tvec2<T>& x)
-    {
-        return dot(x, x);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER T length2(
-		const detail::tvec3<T>& x)
-    {
-        return dot(x, x);
-    }
-
-    template <typename T>
-    GLM_FUNC_QUALIFIER T length2(
-		const detail::tvec4<T>& x)
-    {
-        return dot(x, x);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T length2(
-		const detail::tquat<T>& q)
-    {
-        return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w;
-    }
-
-    template <typename T> 
-	T distance2(
-		const T p0, 
-		const T p1)
-	{
-		return length2(p1 - p0);
-	}
-
-    template <typename T> 
-	T distance2(
-		const detail::tvec2<T>& p0, 
-		const detail::tvec2<T>& p1)
-	{
-		return length2(p1 - p0);
-	}
-
-    template <typename T> 
-	T distance2(
-		const detail::tvec3<T>& p0, 
-		const detail::tvec3<T>& p1)
-	{
-		return length2(p1 - p0);
-	}
-
-    template <typename T>
-	T distance2(
-		const detail::tvec4<T>& p0, 
-		const detail::tvec4<T>& p1)
-	{
-		return length2(p1 - p0);
-	}
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T l1Norm(
-		const detail::tvec3<T>& a, 
-		const detail::tvec3<T>& b)
-    {
-        return abs(b.x - a.x) + abs(b.y - a.y) + abs(b.z - a.z);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T l1Norm(
-		const detail::tvec3<T>& v)
-    {
-        return abs(v.x) + abs(v.y) + abs(v.z);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T l2Norm(
-		const detail::tvec3<T>& a, 
-		const detail::tvec3<T>& b)
-    {
-        return length(b - a);
-    }
-
-    template <typename T> 
-    GLM_FUNC_QUALIFIER T l2Norm(
-		const detail::tvec3<T>& v)
-    {
-        return length(v);
-    }
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T lxNorm(
-		const detail::tvec3<T>& x, 
-		const detail::tvec3<T>& y, 
-		unsigned int Depth)
-	{
-		return pow(pow(y.x - x.x, T(Depth)) + pow(y.y - x.y, T(Depth)) + pow(y.z - x.z, T(Depth)), T(1) / T(Depth));
-	}
-
-	template <typename T> 
-	GLM_FUNC_QUALIFIER T lxNorm(
-		const detail::tvec3<T>& v, 
-		unsigned int Depth)
-	{
-		return pow(pow(v.x, T(Depth)) + pow(v.y, T(Depth)) + pow(v.z, T(Depth)), T(1) / T(Depth));
-	}
-
-}//namespace gtx
+	return length2(p1 - p0);
+}
+
+template <typename T>
+T distance2(
+	const detail::tvec4<T>& p0, 
+	const detail::tvec4<T>& p1)
+{
+	return length2(p1 - p0);
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER T l1Norm(
+	const detail::tvec3<T>& a, 
+	const detail::tvec3<T>& b)
+{
+    return abs(b.x - a.x) + abs(b.y - a.y) + abs(b.z - a.z);
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER T l1Norm(
+	const detail::tvec3<T>& v)
+{
+    return abs(v.x) + abs(v.y) + abs(v.z);
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER T l2Norm(
+	const detail::tvec3<T>& a, 
+	const detail::tvec3<T>& b)
+{
+    return length(b - a);
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER T l2Norm(
+	const detail::tvec3<T>& v)
+{
+    return length(v);
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER T lxNorm(
+	const detail::tvec3<T>& x, 
+	const detail::tvec3<T>& y, 
+	unsigned int Depth)
+{
+	return pow(pow(y.x - x.x, T(Depth)) + pow(y.y - x.y, T(Depth)) + pow(y.z - x.z, T(Depth)), T(1) / T(Depth));
+}
+
+template <typename T> 
+GLM_FUNC_QUALIFIER T lxNorm(
+	const detail::tvec3<T>& v, 
+	unsigned int Depth)
+{
+	return pow(pow(v.x, T(Depth)) + pow(v.y, T(Depth)) + pow(v.z, T(Depth)), T(1) / T(Depth));
+}
+
 }//namespace glm

glm/gtx/normal.hpp

@@ -46,8 +46,7 @@
 #	pragma message("GLM: GLM_GTX_normal extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_normal
 	/// @{
@@ -61,7 +60,6 @@ namespace gtx
 		detail::tvec3<T> const & p3);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "normal.inl"

glm/gtx/normal.inl

@@ -8,7 +8,6 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
 template <typename T> 
 GLM_FUNC_QUALIFIER detail::tvec3<T> triangleNormal
@@ -21,5 +20,4 @@ GLM_FUNC_QUALIFIER detail::tvec3<T> triangleNormal
     return normalize(cross(p1 - p2, p1 - p3));
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/normalize_dot.hpp

@@ -47,8 +47,7 @@
 #	pragma message("GLM: GLM_GTX_normalize_dot extension included")
 #endif
 
-namespace glm{
-namespace gtx
+namespace glm
 {
 	/// @addtogroup gtx_normalize_dot
 	/// @{
@@ -70,7 +69,6 @@ namespace gtx
 		genType const & y);
 
 	/// @}
-}//namespace gtx
 }//namespace glm
 
 #include "normalize_dot.inl"

glm/gtx/normalize_dot.inl

@@ -8,7 +8,6 @@
 //////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
 
 template <typename genType> 
 GLM_FUNC_QUALIFIER genType normalizeDot
@@ -71,7 +70,7 @@ GLM_FUNC_QUALIFIER genType fastNormalizeDot
 {
 	return 
 		glm::dot(x, y) * 
-		glm::gtx::fastInverseSqrt(glm::dot(x, x) * 
+		fastInverseSqrt(glm::dot(x, x) * 
 		glm::dot(y, y));
 }
 
@@ -84,7 +83,7 @@ GLM_FUNC_QUALIFIER valType fastNormalizeDot
 {
 	return 
 		glm::dot(x, y) * 
-		glm::gtx::fastInverseSqrt(glm::dot(x, x) * 
+		fastInverseSqrt(glm::dot(x, x) * 
 		glm::dot(y, y));
 }
 
@@ -97,7 +96,7 @@ GLM_FUNC_QUALIFIER valType fastNormalizeDot
 {
 	return 
 		glm::dot(x, y) * 
-		glm::gtx::fastInverseSqrt(glm::dot(x, x) * 
+		fastInverseSqrt(glm::dot(x, x) * 
 		glm::dot(y, y));
 }
 
@@ -110,9 +109,8 @@ GLM_FUNC_QUALIFIER valType fastNormalizeDot
 {
 	return 
 		glm::dot(x, y) * 
-		glm::gtx::fastInverseSqrt(glm::dot(x, x) * 
+		fastInverseSqrt(glm::dot(x, x) * 
 		glm::dot(y, y));
 }
 
-}//namespace gtx
 }//namespace glm

glm/gtx/optimum_pow.inl

@@ -8,54 +8,52 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 namespace glm{
-namespace gtx{
-
-    template <typename genType> 
-    GLM_FUNC_QUALIFIER genType pow2(const genType& x)
-    {
-        return x * x;
-    }
-
-    template <typename genType> 
-    GLM_FUNC_QUALIFIER genType pow3(const genType& x)
-    {
-        return x * x * x;
-    }
-
-    template <typename genType> 
-    GLM_FUNC_QUALIFIER genType pow4(const genType& x)
-    {
-        return x * x * x * x;
-    }
-
-    GLM_FUNC_QUALIFIER bool powOfTwo(int x)
-    {
-        return !(x & (x - 1));
-    }
-
-    GLM_FUNC_QUALIFIER detail::tvec2<bool> powOfTwo(const detail::tvec2<int>& x)
-    {
-        return detail::tvec2<bool>(
-            powOfTwo(x.x),
-            powOfTwo(x.y));
-    }
-
-    GLM_FUNC_QUALIFIER detail::tvec3<bool> powOfTwo(const detail::tvec3<int>& x)
-    {
-        return detail::tvec3<bool>(
-            powOfTwo(x.x),
-            powOfTwo(x.y),
-            powOfTwo(x.z));
-    }
-
-    GLM_FUNC_QUALIFIER detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x)
-    {
-        return detail::tvec4<bool>(
-            powOfTwo(x.x),
-            powOfTwo(x.y),
-            powOfTwo(x.z),
-            powOfTwo(x.w));
-    }
-
-}//namespace gtx
+
+template <typename genType> 
+GLM_FUNC_QUALIFIER genType pow2(const genType& x)
+{
+    return x * x;
+}
+
+template <typename genType> 
+GLM_FUNC_QUALIFIER genType pow3(const genType& x)
+{
+    return x * x * x;
+}
+
+template <typename genType> 
+GLM_FUNC_QUALIFIER genType pow4(const genType& x)
+{
+    return x * x * x * x;
+}
+
+GLM_FUNC_QUALIFIER bool powOfTwo(int x)
+{
+    return !(x & (x - 1));
+}
+
+GLM_FUNC_QUALIFIER detail::tvec2<bool> powOfTwo(const detail::tvec2<int>& x)
+{
+    return detail::tvec2<bool>(
+        powOfTwo(x.x),
+        powOfTwo(x.y));
+}
+
+GLM_FUNC_QUALIFIER detail::tvec3<bool> powOfTwo(const detail::tvec3<int>& x)
+{
+    return detail::tvec3<bool>(
+        powOfTwo(x.x),
+        powOfTwo(x.y),
+        powOfTwo(x.z));
+}
+
+GLM_FUNC_QUALIFIER detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x)
+{
+    return detail::tvec4<bool>(
+        powOfTwo(x.x),
+        powOfTwo(x.y),
+        powOfTwo(x.z),
+        powOfTwo(x.w));
+}
+
 }//namespace glm