Fixed merge

doc/pages.doxy

@@ -10,7 +10,7 @@
 	This library works perfectly with OpenGL but it also ensures interoperability with other third party libraries and SDK. It is a good candidate for software rendering (Raytracing / Rasterisation), image processing, physic simulations and any context that requires a simple and convenient mathematics library.
 	
 	GLM is written as a platform independent library with no dependence and officially supports the following compilers:
-	1. Clang 2.0  and higher
+	1. Clang 2.0 and higher
 	2. CUDA 3.0 and higher
 	3. GCC 3.4 and higher
 	4. LLVM 2.3 through GCC 4.2 front-end and higher

doc/src/data.xml

@@ -1535,7 +1535,11 @@
 			This library works perfectly with OpenGL but it also ensures interoperability with other third party libraries and SDKs. It is a good candidate for software rendering (Raytracing / Rasterisation), image processing, physic simulations and any context that requires a simple and convenient mathematics library.
 		</paragraph>
 		<list name="GLM is written as a platform independent library with no dependence and officially supports the following compilers:">
-			<list-element><link href="http://http://gcc.gnu.org/">GCC</link> 3.4 and higher</list-element>
+			<list-element><link href="http://clang.llvm.org">Clang</link> 2.0 and higher</list-element>
+			<list-element>
+				<link href="http://developer.nvidia.com/category/zone/cuda-zone">CUDA</link> 3.0 and higher
+			</list-element>
+			<list-element><link href="http://gcc.gnu.org/">GCC</link> 3.4 and higher</list-element>
 			<list-element><link href="http://llvm.org/">LLVM</link> 2.3 through GCC 4.2 front-end and higher</list-element>
 			<list-element><link href="http://msdn.microsoft.com/en-us/visualc/default">Visual C++</link> 2005 and higher</list-element>
 			<list-element>Any C++ compiler following C++98 norm</list-element>

glm/core/setup.hpp

@@ -24,6 +24,7 @@
 // Compiler
 
 // User defines: GLM_FORCE_COMPILER_UNKNOWN
+// TODO ? __llvm__ 
 
 #define GLM_COMPILER_UNKNOWN		0x00000000
 
@@ -81,6 +82,16 @@
 #define GLM_COMPILER_CUDA32			0x10000030
 #define GLM_COMPILER_CUDA40			0x10000040
 
+// Clang
+#define GLM_COMPILER_CLANG          0x20000000
+#define GLM_COMPILER_CLANG26		0x20000010
+#define GLM_COMPILER_CLANG27		0x20000020
+#define GLM_COMPILER_CLANG28		0x20000030
+#define GLM_COMPILER_CLANG29		0x20000040
+
+// LLVM GCC
+#define GLM_COMPILER_LLVM_GCC		0x40000000
+
 // Build model
 #define GLM_MODEL_32				0x00000010
 #define GLM_MODEL_64				0x00000020
@@ -91,6 +102,8 @@
 
 // CUDA
 #elif defined(__CUDACC__)
+#	define GLM_COMPILER GLM_COMPILER_CUDA
+/*
 #	if CUDA_VERSION < 3000
 #		error "GLM requires CUDA 3.0 or higher"
 #	elif CUDA_VERSION == 3000
@@ -104,6 +117,7 @@
 #	else
 #		define GLM_COMPILER GLM_COMPILER_CUDA
 #	endif
+*/
 
 // Visual C++
 #elif defined(_MSC_VER)
@@ -131,6 +145,20 @@
 #		define GLM_COMPILER GLM_COMPILER_VC
 #	endif//_MSC_VER
 
+#elif defined(__clang__)
+#	if   (__clang_major__ == 2) && (__clang_minor__ == 6)
+#		define GLM_COMPILER GLM_COMPILER_CLANG26
+#	elif (__clang_major__ == 2) && (__clang_minor__ == 7)
+#		define GLM_COMPILER GLM_COMPILER_CLANG27
+#	elif (__clang_major__ == 2) && (__clang_minor__ == 8)
+#		define GLM_COMPILER GLM_COMPILER_CLANG28
+#	elif (__clang_major__ == 2) && (__clang_minor__ == 9)
+#		define GLM_COMPILER GLM_COMPILER_CLANG29
+#	endif
+
+#elif defined(__llvm__)
+#	define GLM_COMPILER GLM_COMPILER_LLVM_GCC
+
 // G++
 #elif defined(__GNUC__)
 #	if   (__GNUC__ == 3) && (__GNUC_MINOR__ == 2)
@@ -196,8 +224,14 @@
 // Report compiler detection
 #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPILER_DISPLAYED))
 #	define GLM_MESSAGE_COMPILER_DISPLAYED
-#	if(GLM_COMPILER & GLM_COMPILER_VC)
+#	if(GLM_COMPILER & GLM_COMPILER_CUDA)
+#		pragma message("GLM: CUDA compiler detected")
+#	elif(GLM_COMPILER & GLM_COMPILER_VC)
 #		pragma message("GLM: Visual C++ compiler detected")
+#	elif(GLM_COMPILER & GLM_COMPILER_CLANG)
+#		pragma message("GLM: Clang compiler detected")
+#	elif(GLM_COMPILER & GLM_COMPILER_LLVM_GCC)
+#		pragma message("GLM: LLVM GCC compiler detected")
 #	elif(GLM_COMPILER & GLM_COMPILER_GCC)
 #		pragma message("GLM: GCC compiler detected")
 #	elif(GLM_COMPILER & GLM_COMPILER_BC)
@@ -402,7 +436,7 @@
 
 // User defines: GLM_FORCE_INLINE GLM_FORCE_CUDA
 
-#if(defined(GLM_FORCE_CUDA) || (defined(__CUDACC__)))
+#if(defined(GLM_FORCE_CUDA) || (GLM_COMPILER & GLM_COMPILER_CUDA))
 #   define GLM_CUDA_FUNC_DEF __device__ __host__ 
 #	define GLM_CUDA_FUNC_DECL __device__ __host__ 
 #else

glm/gtc/half_float.hpp

@@ -17,351 +17,346 @@
 #	pragma message("GLM: GLM_GTC_half_float extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test{
-		bool main_gtc_half_float();
-	}//namespace 
-	namespace detail
-	{
 #ifndef _MSC_EXTENSIONS
-		template <>
-		struct tvec2<thalf>
-		{
-			enum ctor{null};
-			typedef thalf value_type;
-			typedef std::size_t size_type;
-			static size_type value_size();
-
-			typedef tvec2<thalf> type;
-			typedef tvec2<bool> bool_type;
-
-			//////////////////////////////////////
-			// Data
-
-			thalf x, y;
-
-			//////////////////////////////////////
-			// Accesses
-
-			thalf & operator[](size_type i);
-			thalf const & operator[](size_type i) const;
-
-			//////////////////////////////////////
-			// Implicit basic constructors
-
-			tvec2();
-			tvec2(tvec2<thalf> const & v);
-
-			//////////////////////////////////////
-			// Explicit basic constructors
-
-			explicit tvec2(ctor);
-			explicit tvec2(
-				thalf const & s);
-			explicit tvec2(
-				thalf const & s1, 
-				thalf const & s2);
-
-			//////////////////////////////////////
-			// Swizzle constructors
-
-			tvec2(tref2<thalf> const & r);
-
-			//////////////////////////////////////
-			// Convertion scalar constructors
-
-			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			explicit tvec2(U const & x);
-			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U, typename V> 
-			explicit tvec2(U const & x, V const & y);			
-
-			//////////////////////////////////////
-			// Convertion vector constructors
-
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			explicit tvec2(tvec2<U> const & v);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			explicit tvec2(tvec3<U> const & v);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			explicit tvec2(tvec4<U> const & v);
-
-			//////////////////////////////////////
-			// Unary arithmetic operators
-
-			tvec2<thalf>& operator= (tvec2<thalf> const & v);
-
-			tvec2<thalf>& operator+=(thalf const & s);
-			tvec2<thalf>& operator+=(tvec2<thalf> const & v);
-			tvec2<thalf>& operator-=(thalf const & s);
-			tvec2<thalf>& operator-=(tvec2<thalf> const & v);
-			tvec2<thalf>& operator*=(thalf const & s);
-			tvec2<thalf>& operator*=(tvec2<thalf> const & v);
-			tvec2<thalf>& operator/=(thalf const & s);
-			tvec2<thalf>& operator/=(tvec2<thalf> const & v);
-			tvec2<thalf>& operator++();
-			tvec2<thalf>& operator--();
-
-			//////////////////////////////////////
-			// Swizzle operators
-
-			thalf swizzle(comp X) const;
-			tvec2<thalf> swizzle(comp X, comp Y) const;
-			tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
-			tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
-			tref2<thalf> swizzle(comp X, comp Y);
-		};
-
-		template <>
-		struct tvec3<thalf>
-		{
-			enum ctor{null};
-			typedef thalf value_type;
-			typedef std::size_t size_type;
-			static size_type value_size();
-
-			typedef tvec3<thalf> type;
-			typedef tvec3<bool> bool_type;
-
-			//////////////////////////////////////
-			// Data
-
-			thalf x, y, z;
-
-			//////////////////////////////////////
-			// Accesses
-
-			thalf & operator[](size_type i);
-			thalf const & operator[](size_type i) const;
-
-			//////////////////////////////////////
-			// Implicit basic constructors
-
-			tvec3();
-			tvec3(tvec3<thalf> const & v);
-
-			//////////////////////////////////////
-			// Explicit basic constructors
-
-			explicit tvec3(ctor);
-			explicit tvec3(
-				thalf const & s);
-			explicit tvec3(
-				thalf const & s1, 
-				thalf const & s2, 
-				thalf const & s3);
-
-			//////////////////////////////////////
-			// Swizzle constructors
-
-			tvec3(tref3<thalf> const & r);
-
-			//////////////////////////////////////
-			// Convertion scalar constructors
-
-			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			explicit tvec3(U const & x);
-			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U, typename V, typename W> 
-			explicit tvec3(U const & x, V const & y, W const & z);			
-
-			//////////////////////////////////////
-			// Convertion vector constructors
-
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename A, typename B> 
-			explicit tvec3(tvec2<A> const & v, B const & s);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename A, typename B> 
-			explicit tvec3(A const & s, tvec2<B> const & v);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			explicit tvec3(tvec3<U> const & v);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			explicit tvec3(tvec4<U> const & v);
-
-			//////////////////////////////////////
-			// Unary arithmetic operators
-
-			tvec3<thalf>& operator= (tvec3<thalf> const & v);
-
-			tvec3<thalf>& operator+=(thalf const & s);
-			tvec3<thalf>& operator+=(tvec3<thalf> const & v);
-			tvec3<thalf>& operator-=(thalf const & s);
-			tvec3<thalf>& operator-=(tvec3<thalf> const & v);
-			tvec3<thalf>& operator*=(thalf const & s);
-			tvec3<thalf>& operator*=(tvec3<thalf> const & v);
-			tvec3<thalf>& operator/=(thalf const & s);
-			tvec3<thalf>& operator/=(tvec3<thalf> const & v);
-			tvec3<thalf>& operator++();
-			tvec3<thalf>& operator--();
-
-			//////////////////////////////////////
-			// Swizzle operators
-
-			thalf swizzle(comp X) const;
-			tvec2<thalf> swizzle(comp X, comp Y) const;
-			tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
-			tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
-			tref3<thalf> swizzle(comp X, comp Y, comp Z);
-		};
-
-		template <>
-		struct tvec4<thalf>
-		{
-			enum ctor{null};
-			typedef thalf value_type;
-			typedef std::size_t size_type;
-			static size_type value_size();
-
-			typedef tvec4<thalf> type;
-			typedef tvec4<bool> bool_type;
-
-			//////////////////////////////////////
-			// Data
-
-			thalf x, y, z, w;
-
-			//////////////////////////////////////
-			// Accesses
-
-			thalf & operator[](size_type i);
-			thalf const & operator[](size_type i) const;
-
-			//////////////////////////////////////
-			// Implicit basic constructors
-
-			tvec4();
-			tvec4(tvec4<thalf> const & v);
-
-			//////////////////////////////////////
-			// Explicit basic constructors
-
-			explicit tvec4(ctor);
-			explicit tvec4(
-				thalf const & s);
-			explicit tvec4(
-				thalf const & s0, 
-				thalf const & s1, 
-				thalf const & s2, 
-				thalf const & s3);
-
-			//////////////////////////////////////
-			// Swizzle constructors
-
-			tvec4(tref4<thalf> const & r);
-
-			//////////////////////////////////////
-			// Convertion scalar constructors
-
-			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			explicit tvec4(U const & x);
-			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename A, typename B, typename C, typename D> 
-			explicit tvec4(A const & x, B const & y, C const & z, D const & w);			
-
-			//////////////////////////////////////
-			// Convertion vector constructors
-
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename A, typename B, typename C> 
-			explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename A, typename B, typename C> 
-			explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename A, typename B, typename C> 
-			explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename A, typename B> 
-			explicit tvec4(tvec3<A> const & v, B const & s);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename A, typename B> 
-			explicit tvec4(A const & s, tvec3<B> const & v);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename A, typename B> 
-			explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			explicit tvec4(tvec4<U> const & v);
-
-			//////////////////////////////////////
-			// Unary arithmetic operators
-
-			tvec4<thalf>& operator= (tvec4<thalf> const & v);
-
-			tvec4<thalf>& operator+=(thalf const & s);
-			tvec4<thalf>& operator+=(tvec4<thalf> const & v);
-			tvec4<thalf>& operator-=(thalf const & s);
-			tvec4<thalf>& operator-=(tvec4<thalf> const & v);
-			tvec4<thalf>& operator*=(thalf const & s);
-			tvec4<thalf>& operator*=(tvec4<thalf> const & v);
-			tvec4<thalf>& operator/=(thalf const & s);
-			tvec4<thalf>& operator/=(tvec4<thalf> const & v);
-			tvec4<thalf>& operator++();
-			tvec4<thalf>& operator--();
-
-			//////////////////////////////////////
-			// Swizzle operators
-
-			thalf swizzle(comp X) const;
-			tvec2<thalf> swizzle(comp X, comp Y) const;
-			tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
-			tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
-			tref4<thalf> swizzle(comp X, comp Y, comp Z, comp W);
-		};
+	template <>
+	struct tvec2<thalf>
+	{
+		enum ctor{null};
+		typedef thalf value_type;
+		typedef std::size_t size_type;
+		static size_type value_size();
+
+		typedef tvec2<thalf> type;
+		typedef tvec2<bool> bool_type;
+
+		//////////////////////////////////////
+		// Data
+
+		thalf x, y;
+
+		//////////////////////////////////////
+		// Accesses
+
+		thalf & operator[](size_type i);
+		thalf const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		tvec2();
+		tvec2(tvec2<thalf> const & v);
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		explicit tvec2(ctor);
+		explicit tvec2(
+			thalf const & s);
+		explicit tvec2(
+			thalf const & s1, 
+			thalf const & s2);
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		tvec2(tref2<thalf> const & r);
+
+		//////////////////////////////////////
+		// Convertion scalar constructors
+
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec2(U const & x);
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U, typename V> 
+		explicit tvec2(U const & x, V const & y);			
+
+		//////////////////////////////////////
+		// Convertion vector constructors
+
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec2(tvec2<U> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec2(tvec3<U> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec2(tvec4<U> const & v);
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		tvec2<thalf>& operator= (tvec2<thalf> const & v);
+
+		tvec2<thalf>& operator+=(thalf const & s);
+		tvec2<thalf>& operator+=(tvec2<thalf> const & v);
+		tvec2<thalf>& operator-=(thalf const & s);
+		tvec2<thalf>& operator-=(tvec2<thalf> const & v);
+		tvec2<thalf>& operator*=(thalf const & s);
+		tvec2<thalf>& operator*=(tvec2<thalf> const & v);
+		tvec2<thalf>& operator/=(thalf const & s);
+		tvec2<thalf>& operator/=(tvec2<thalf> const & v);
+		tvec2<thalf>& operator++();
+		tvec2<thalf>& operator--();
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		thalf swizzle(comp X) const;
+		tvec2<thalf> swizzle(comp X, comp Y) const;
+		tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
+		tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
+		tref2<thalf> swizzle(comp X, comp Y);
+	};
+
+	template <>
+	struct tvec3<thalf>
+	{
+		enum ctor{null};
+		typedef thalf value_type;
+		typedef std::size_t size_type;
+		static size_type value_size();
+
+		typedef tvec3<thalf> type;
+		typedef tvec3<bool> bool_type;
+
+		//////////////////////////////////////
+		// Data
+
+		thalf x, y, z;
+
+		//////////////////////////////////////
+		// Accesses
+
+		thalf & operator[](size_type i);
+		thalf const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		tvec3();
+		tvec3(tvec3<thalf> const & v);
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		explicit tvec3(ctor);
+		explicit tvec3(
+			thalf const & s);
+		explicit tvec3(
+			thalf const & s1, 
+			thalf const & s2, 
+			thalf const & s3);
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		tvec3(tref3<thalf> const & r);
+
+		//////////////////////////////////////
+		// Convertion scalar constructors
+
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec3(U const & x);
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U, typename V, typename W> 
+		explicit tvec3(U const & x, V const & y, W const & z);			
+
+		//////////////////////////////////////
+		// Convertion vector constructors
+
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B> 
+		explicit tvec3(tvec2<A> const & v, B const & s);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B> 
+		explicit tvec3(A const & s, tvec2<B> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec3(tvec3<U> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec3(tvec4<U> const & v);
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		tvec3<thalf>& operator= (tvec3<thalf> const & v);
+
+		tvec3<thalf>& operator+=(thalf const & s);
+		tvec3<thalf>& operator+=(tvec3<thalf> const & v);
+		tvec3<thalf>& operator-=(thalf const & s);
+		tvec3<thalf>& operator-=(tvec3<thalf> const & v);
+		tvec3<thalf>& operator*=(thalf const & s);
+		tvec3<thalf>& operator*=(tvec3<thalf> const & v);
+		tvec3<thalf>& operator/=(thalf const & s);
+		tvec3<thalf>& operator/=(tvec3<thalf> const & v);
+		tvec3<thalf>& operator++();
+		tvec3<thalf>& operator--();
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		thalf swizzle(comp X) const;
+		tvec2<thalf> swizzle(comp X, comp Y) const;
+		tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
+		tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
+		tref3<thalf> swizzle(comp X, comp Y, comp Z);
+	};
+
+	template <>
+	struct tvec4<thalf>
+	{
+		enum ctor{null};
+		typedef thalf value_type;
+		typedef std::size_t size_type;
+		static size_type value_size();
+
+		typedef tvec4<thalf> type;
+		typedef tvec4<bool> bool_type;
+
+		//////////////////////////////////////
+		// Data
+
+		thalf x, y, z, w;
+
+		//////////////////////////////////////
+		// Accesses
+
+		thalf & operator[](size_type i);
+		thalf const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		tvec4();
+		tvec4(tvec4<thalf> const & v);
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		explicit tvec4(ctor);
+		explicit tvec4(
+			thalf const & s);
+		explicit tvec4(
+			thalf const & s0, 
+			thalf const & s1, 
+			thalf const & s2, 
+			thalf const & s3);
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		tvec4(tref4<thalf> const & r);
+
+		//////////////////////////////////////
+		// Convertion scalar constructors
+
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec4(U const & x);
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B, typename C, typename D> 
+		explicit tvec4(A const & x, B const & y, C const & z, D const & w);			
+
+		//////////////////////////////////////
+		// Convertion vector constructors
+
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B, typename C> 
+		explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B, typename C> 
+		explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B, typename C> 
+		explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B> 
+		explicit tvec4(tvec3<A> const & v, B const & s);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B> 
+		explicit tvec4(A const & s, tvec3<B> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename A, typename B> 
+		explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		explicit tvec4(tvec4<U> const & v);
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		tvec4<thalf>& operator= (tvec4<thalf> const & v);
+
+		tvec4<thalf>& operator+=(thalf const & s);
+		tvec4<thalf>& operator+=(tvec4<thalf> const & v);
+		tvec4<thalf>& operator-=(thalf const & s);
+		tvec4<thalf>& operator-=(tvec4<thalf> const & v);
+		tvec4<thalf>& operator*=(thalf const & s);
+		tvec4<thalf>& operator*=(tvec4<thalf> const & v);
+		tvec4<thalf>& operator/=(thalf const & s);
+		tvec4<thalf>& operator/=(tvec4<thalf> const & v);
+		tvec4<thalf>& operator++();
+		tvec4<thalf>& operator--();
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		thalf swizzle(comp X) const;
+		tvec2<thalf> swizzle(comp X, comp Y) const;
+		tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
+		tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
+		tref4<thalf> swizzle(comp X, comp Y, comp Z, comp W);
+	};
 #endif//_MSC_EXTENSIONS
-	}
-	//namespace detail
+}
+//namespace detail
 
-	namespace gtc{
-	//! GLM_GTC_half_float extension: Add support for half precision floating-point types
-	namespace half_float
-	{
-		/// \addtogroup gtc_half_float
-		///@{
+namespace gtc{
+namespace half_float ///< GLM_GTC_half_float extension: Add support for half precision floating-point types
+{
+	/// \addtogroup gtc_half_float
+	///@{
 
-		//! Type for half-precision floating-point numbers. 
-		//! From GLM_GTC_half_float extension.
-		typedef detail::thalf					half;
+	/// Type for half-precision floating-point numbers. 
+	/// From GLM_GTC_half_float extension.
+	typedef detail::thalf					half;
 
-		//! Vector of 2 half-precision floating-point numbers. 
-		//! From GLM_GTC_half_float extension.
-		typedef detail::tvec2<detail::thalf>	hvec2;
+	/// Vector of 2 half-precision floating-point numbers. 
+	/// From GLM_GTC_half_float extension.
+	typedef detail::tvec2<detail::thalf>	hvec2;
 
-		//! Vector of 3 half-precision floating-point numbers.
-		//! From GLM_GTC_half_float extension.
-		typedef detail::tvec3<detail::thalf>	hvec3;
+	/// Vector of 3 half-precision floating-point numbers.
+	/// From GLM_GTC_half_float extension.
+	typedef detail::tvec3<detail::thalf>	hvec3;
 
-		//! Vector of 4 half-precision floating-point numbers. 
-		//! From GLM_GTC_half_float extension.
-		typedef detail::tvec4<detail::thalf>	hvec4;
+	/// Vector of 4 half-precision floating-point numbers. 
+	/// From GLM_GTC_half_float extension.
+	typedef detail::tvec4<detail::thalf>	hvec4;
 
-		//! 2 * 2 matrix of half-precision floating-point numbers.
-		//! From GLM_GTC_half_float extension.
-		typedef detail::tmat2x2<detail::thalf>	hmat2;
+	/// 2 * 2 matrix of half-precision floating-point numbers.
+	/// From GLM_GTC_half_float extension.
+	typedef detail::tmat2x2<detail::thalf>	hmat2;
 
-		//! 3 * 3 matrix of half-precision floating-point numbers.
-		//! From GLM_GTC_half_float extension.
-		typedef detail::tmat3x3<detail::thalf>	hmat3;
+	/// 3 * 3 matrix of half-precision floating-point numbers.
+	/// From GLM_GTC_half_float extension.
+	typedef detail::tmat3x3<detail::thalf>	hmat3;
 
-		//! 4 * 4 matrix of half-precision floating-point numbers.
-		//! From GLM_GTC_half_float extension.
-		typedef detail::tmat4x4<detail::thalf>	hmat4;
+	/// 4 * 4 matrix of half-precision floating-point numbers.
+	/// From GLM_GTC_half_float extension.
+	typedef detail::tmat4x4<detail::thalf>	hmat4;
 
-		///@}
+	/// @}
 
-	}//namespace half_float
-	}//namespace gtc
-}//namespace glm
+}// namespace half_float
+}// namespace gtc
+}// namespace glm
 
 #include "half_float.inl"
 

glm/gtc/matrix_access.hpp

@@ -22,8 +22,7 @@
 
 namespace glm{
 namespace gtc{
-//! GLM_GTC_matrix_access extension: Set a column or a row of a matrix
-namespace matrix_access
+namespace matrix_access ///< GLM_GTC_matrix_access extension: Set a column or a row of a matrix
 {
 	/// \addtogroup gtc_matrix_access
 	///@{

glm/gtc/matrix_integer.hpp

@@ -20,189 +20,183 @@
 #	pragma message("GLM: GLM_GTC_matrix_integer extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtc{
+namespace matrix_integer ///< GLM_GTC_matrix_integer extension: Add integer matrices
 {
-	namespace test{
-		bool main_gtc_matrix_integer();
-	}//namespace test
-
-	namespace gtc{
-	//! GLM_GTC_matrix_integer extension: Add integer matrices
-	namespace matrix_integer
-	{
-		/// \addtogroup gtc_matrix_integer
-		///@{
-
-		typedef detail::tmat2x2<highp_int>				highp_imat2;	//!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x3<highp_int>				highp_imat3;	//!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x4<highp_int>				highp_imat4;	//!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-		typedef detail::tmat2x2<highp_int>				highp_imat2x2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat2x3<highp_int>				highp_imat2x3; //!< \brief High-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat2x4<highp_int>				highp_imat2x4; //!< \brief High-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x2<highp_int>				highp_imat3x2; //!< \brief High-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x3<highp_int>				highp_imat3x3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x4<highp_int>				highp_imat3x4; //!< \brief High-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x2<highp_int>				highp_imat4x2; //!< \brief High-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x3<highp_int>				highp_imat4x3; //!< \brief High-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x4<highp_int>				highp_imat4x4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-		typedef detail::tmat2x2<mediump_int>			mediump_imat2;	//!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x3<mediump_int>			mediump_imat3;	//!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x4<mediump_int>			mediump_imat4;	//!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-		typedef detail::tmat2x2<mediump_int>			mediump_imat2x2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat2x3<mediump_int>			mediump_imat2x3; //!< \brief Medium-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat2x4<mediump_int>			mediump_imat2x4; //!< \brief Medium-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x2<mediump_int>			mediump_imat3x2; //!< \brief Medium-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x3<mediump_int>			mediump_imat3x3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x4<mediump_int>			mediump_imat3x4; //!< \brief Medium-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x2<mediump_int>			mediump_imat4x2; //!< \brief Medium-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x3<mediump_int>			mediump_imat4x3; //!< \brief Medium-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x4<mediump_int>			mediump_imat4x4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-		typedef detail::tmat2x2<lowp_int>				lowp_imat2;	//!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x3<lowp_int>				lowp_imat3;	//!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x4<lowp_int>				lowp_imat4;	//!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-		typedef detail::tmat2x2<lowp_int>				lowp_imat2x2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat2x3<lowp_int>				lowp_imat2x3; //!< \brief Low-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat2x4<lowp_int>				lowp_imat2x4; //!< \brief Low-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x2<lowp_int>				lowp_imat3x2; //!< \brief Low-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x3<lowp_int>				lowp_imat3x3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x4<lowp_int>				lowp_imat3x4; //!< \brief Low-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x2<lowp_int>				lowp_imat4x2; //!< \brief Low-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x3<lowp_int>				lowp_imat4x3; //!< \brief Low-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x4<lowp_int>				lowp_imat4x4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-		typedef detail::tmat2x2<highp_uint>				highp_umat2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x3<highp_uint>				highp_umat3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x4<highp_uint>				highp_umat4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-		typedef detail::tmat2x2<highp_uint>				highp_umat2x2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat2x3<highp_uint>				highp_umat2x3; //!< \brief High-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat2x4<highp_uint>				highp_umat2x4; //!< \brief High-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x2<highp_uint>				highp_umat3x2; //!< \brief High-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x3<highp_uint>				highp_umat3x3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x4<highp_uint>				highp_umat3x4; //!< \brief High-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x2<highp_uint>				highp_umat4x2; //!< \brief High-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x3<highp_uint>				highp_umat4x3; //!< \brief High-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x4<highp_uint>				highp_umat4x4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-		typedef detail::tmat2x2<mediump_uint>			mediump_umat2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x3<mediump_uint>			mediump_umat3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x4<mediump_uint>			mediump_umat4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-		typedef detail::tmat2x2<mediump_uint>			mediump_umat2x2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat2x3<mediump_uint>			mediump_umat2x3; //!< \brief Medium-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat2x4<mediump_uint>			mediump_umat2x4; //!< \brief Medium-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x2<mediump_uint>			mediump_umat3x2; //!< \brief Medium-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x3<mediump_uint>			mediump_umat3x3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x4<mediump_uint>			mediump_umat3x4; //!< \brief Medium-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x2<mediump_uint>			mediump_umat4x2; //!< \brief Medium-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x3<mediump_uint>			mediump_umat4x3; //!< \brief Medium-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x4<mediump_uint>			mediump_umat4x4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-		typedef detail::tmat2x2<lowp_uint>				lowp_umat2;	//!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x3<lowp_uint>				lowp_umat3;	//!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x4<lowp_uint>				lowp_umat4;	//!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-
-		typedef detail::tmat2x2<lowp_uint>				lowp_umat2x2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat2x3<lowp_uint>				lowp_umat2x3; //!< \brief Low-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat2x4<lowp_uint>				lowp_umat2x4; //!< \brief Low-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x2<lowp_uint>				lowp_umat3x2; //!< \brief Low-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x3<lowp_uint>				lowp_umat3x3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat3x4<lowp_uint>				lowp_umat3x4; //!< \brief Low-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x2<lowp_uint>				lowp_umat4x2; //!< \brief Low-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x3<lowp_uint>				lowp_umat4x3; //!< \brief Low-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef detail::tmat4x4<lowp_uint>				lowp_umat4x4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	/// \addtogroup gtc_matrix_integer
+	///@{
+
+	typedef detail::tmat2x2<highp_int>				highp_imat2;	//!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<highp_int>				highp_imat3;	//!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<highp_int>				highp_imat4;	//!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<highp_int>				highp_imat2x2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x3<highp_int>				highp_imat2x3; //!< \brief High-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x4<highp_int>				highp_imat2x4; //!< \brief High-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x2<highp_int>				highp_imat3x2; //!< \brief High-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<highp_int>				highp_imat3x3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x4<highp_int>				highp_imat3x4; //!< \brief High-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x2<highp_int>				highp_imat4x2; //!< \brief High-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x3<highp_int>				highp_imat4x3; //!< \brief High-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<highp_int>				highp_imat4x4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<mediump_int>			mediump_imat2;	//!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<mediump_int>			mediump_imat3;	//!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<mediump_int>			mediump_imat4;	//!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<mediump_int>			mediump_imat2x2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x3<mediump_int>			mediump_imat2x3; //!< \brief Medium-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x4<mediump_int>			mediump_imat2x4; //!< \brief Medium-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x2<mediump_int>			mediump_imat3x2; //!< \brief Medium-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<mediump_int>			mediump_imat3x3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x4<mediump_int>			mediump_imat3x4; //!< \brief Medium-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x2<mediump_int>			mediump_imat4x2; //!< \brief Medium-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x3<mediump_int>			mediump_imat4x3; //!< \brief Medium-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<mediump_int>			mediump_imat4x4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<lowp_int>				lowp_imat2;	//!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<lowp_int>				lowp_imat3;	//!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<lowp_int>				lowp_imat4;	//!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<lowp_int>				lowp_imat2x2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x3<lowp_int>				lowp_imat2x3; //!< \brief Low-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x4<lowp_int>				lowp_imat2x4; //!< \brief Low-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x2<lowp_int>				lowp_imat3x2; //!< \brief Low-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<lowp_int>				lowp_imat3x3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x4<lowp_int>				lowp_imat3x4; //!< \brief Low-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x2<lowp_int>				lowp_imat4x2; //!< \brief Low-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x3<lowp_int>				lowp_imat4x3; //!< \brief Low-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<lowp_int>				lowp_imat4x4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<highp_uint>				highp_umat2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<highp_uint>				highp_umat3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<highp_uint>				highp_umat4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<highp_uint>				highp_umat2x2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x3<highp_uint>				highp_umat2x3; //!< \brief High-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x4<highp_uint>				highp_umat2x4; //!< \brief High-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x2<highp_uint>				highp_umat3x2; //!< \brief High-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<highp_uint>				highp_umat3x3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x4<highp_uint>				highp_umat3x4; //!< \brief High-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x2<highp_uint>				highp_umat4x2; //!< \brief High-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x3<highp_uint>				highp_umat4x3; //!< \brief High-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<highp_uint>				highp_umat4x4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<mediump_uint>			mediump_umat2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<mediump_uint>			mediump_umat3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<mediump_uint>			mediump_umat4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<mediump_uint>			mediump_umat2x2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x3<mediump_uint>			mediump_umat2x3; //!< \brief Medium-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x4<mediump_uint>			mediump_umat2x4; //!< \brief Medium-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x2<mediump_uint>			mediump_umat3x2; //!< \brief Medium-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<mediump_uint>			mediump_umat3x3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x4<mediump_uint>			mediump_umat3x4; //!< \brief Medium-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x2<mediump_uint>			mediump_umat4x2; //!< \brief Medium-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x3<mediump_uint>			mediump_umat4x3; //!< \brief Medium-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<mediump_uint>			mediump_umat4x4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<lowp_uint>				lowp_umat2;	//!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<lowp_uint>				lowp_umat3;	//!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<lowp_uint>				lowp_umat4;	//!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+
+	typedef detail::tmat2x2<lowp_uint>				lowp_umat2x2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x3<lowp_uint>				lowp_umat2x3; //!< \brief Low-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat2x4<lowp_uint>				lowp_umat2x4; //!< \brief Low-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x2<lowp_uint>				lowp_umat3x2; //!< \brief Low-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x3<lowp_uint>				lowp_umat3x3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat3x4<lowp_uint>				lowp_umat3x4; //!< \brief Low-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x2<lowp_uint>				lowp_umat4x2; //!< \brief Low-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x3<lowp_uint>				lowp_umat4x3; //!< \brief Low-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef detail::tmat4x4<lowp_uint>				lowp_umat4x4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
 
 #if(defined(GLM_PRECISION_HIGHP_INT))
-		typedef highp_imat2								imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_imat3								imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_imat4								imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_imat2x2							imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_imat2x3							imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_imat2x4							imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_imat3x2							imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_imat3x3							imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_imat3x4							imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_imat4x2							imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_imat4x3							imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_imat4x4							imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat2								imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat3								imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat4								imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat2x2							imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat2x3							imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat2x4							imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat3x2							imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat3x3							imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat3x4							imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat4x2							imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat4x3							imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_imat4x4							imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
 #elif(defined(GLM_PRECISION_LOWP_INT))
-		typedef lowp_imat2								imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_imat3								imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_imat4								imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_imat2x2							imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_imat2x3							imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_imat2x4							imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_imat3x2							imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_imat3x3							imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_imat3x4							imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_imat4x2							imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_imat4x3							imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_imat4x4							imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat2								imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat3								imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat4								imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat2x2							imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat2x3							imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat2x4							imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat3x2							imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat3x3							imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat3x4							imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat4x2							imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat4x3							imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_imat4x4							imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
 #else //if(defined(GLM_PRECISION_MEDIUMP_INT))
-		typedef mediump_imat2							imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_imat3							imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_imat4							imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_imat2x2							imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_imat2x3							imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_imat2x4							imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_imat3x2							imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_imat3x3							imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_imat3x4							imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_imat4x2							imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_imat4x3							imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_imat4x4							imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat2							imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat3							imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat4							imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat2x2							imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat2x3							imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat2x4							imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat3x2							imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat3x3							imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat3x4							imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat4x2							imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat4x3							imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_imat4x4							imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
 #endif//GLM_PRECISION
 
 #if(defined(GLM_PRECISION_HIGHP_UINT))
-		typedef highp_umat2								umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_umat3								umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_umat4								umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_umat2x2							umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_umat2x3							umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_umat2x4							umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_umat3x2							umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_umat3x3							umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_umat3x4							umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_umat4x2							umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_umat4x3							umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef highp_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat2								umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat3								umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat4								umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat2x2							umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat2x3							umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat2x4							umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat3x2							umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat3x3							umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat3x4							umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat4x2							umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat4x3							umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef highp_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
 #elif(defined(GLM_PRECISION_LOWP_UINT))
-		typedef lowp_umat2								umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_umat3								umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_umat4								umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_umat2x2							umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_umat2x3							umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_umat2x4							umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_umat3x2							umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_umat3x3							umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_umat3x4							umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_umat4x2							umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_umat4x3							umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef lowp_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat2								umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat3								umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat4								umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat2x2							umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat2x3							umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat2x4							umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat3x2							umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat3x3							umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat3x4							umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat4x2							umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat4x3							umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef lowp_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
 #else //if(defined(GLM_PRECISION_MEDIUMP_UINT))
-		typedef mediump_umat2							umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_umat3							umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_umat4							umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_umat2x2							umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_umat2x3							umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_umat2x4							umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_umat3x2							umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_umat3x3							umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_umat3x4							umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_umat4x2							umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_umat4x3							umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
-		typedef mediump_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat2							umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat3							umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat4							umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat2x2							umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat2x3							umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat2x4							umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat3x2							umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat3x3							umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat3x4							umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat4x2							umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat4x3							umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
+	typedef mediump_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
 #endif//GLM_PRECISION
 
-		///@}
+	///@}
 
-	}//namespace matrix_integer
-	}//namespace gtc
+}//namespace matrix_integer
+}//namespace gtc
 }//namespace glm
 
 namespace glm{using namespace gtc::matrix_integer;}

glm/gtc/matrix_inverse.hpp

@@ -22,8 +22,7 @@
 
 namespace glm{
 namespace gtc{
-//! GLM_GTC_matrix_inverse extension: Inverse matrix functions
-namespace matrix_inverse
+namespace matrix_inverse ///< GLM_GTC_matrix_inverse extension: Inverse matrix functions
 {
 	/// \addtogroup gtc_matrix_inverse
 	///@{

glm/gtc/matrix_transform.hpp

@@ -41,13 +41,8 @@
 #endif
 
 namespace glm{
-namespace test{
-	bool main_gtc_matrix_transform();
-}//namespace test
-
 namespace gtc{
-/// GLM_GTC_matrix_transform extension: Add transformation matrices
-namespace matrix_transform
+namespace matrix_transform ///< GLM_GTC_matrix_transform extension: Add transformation matrices
 {
 	/// @addtogroup gtc_matrix_transform
 	/// @{

glm/gtc/quaternion.hpp

@@ -26,206 +26,200 @@
 #	pragma message("GLM: GLM_GTC_quaternion extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test{
-		bool main_gtc_quaternion();
-	}//namespace test
-
-	namespace detail
+	//! \brief Template for quaternion. 
+	//! From GLM_GTC_quaternion extension.
+	/// \ingroup gtc_quaternion
+	template <typename T> 
+	struct tquat// : public genType<T, tquat>
 	{
-		//! \brief Template for quaternion. 
-		//! From GLM_GTC_quaternion extension.
-		/// \ingroup gtc_quaternion
-		template <typename T> 
-		struct tquat// : public genType<T, tquat>
-		{
-			typedef T value_type;
-
-		public:
-			value_type x, y, z, w;
-
-			// Constructors
-			tquat();
-			explicit tquat(
-				value_type const & s, 
-				tvec3<T> const & v);
-			explicit tquat(
-				value_type const & w, 
-				value_type const & x, 
-				value_type const & y, 
-				value_type const & z);
-
-			// Convertions
-			//explicit tquat(valType const & pitch, valType const & yaw, valType const & roll);
-			//! pitch, yaw, roll
-			explicit tquat(
-				tvec3<T> const & eulerAngles);
-			explicit tquat(
-				tmat3x3<T> const & m);
-			explicit tquat(
-				tmat4x4<T> const & m);
-
-			// Accesses
-			value_type & operator[](int i);
-			value_type const & operator[](int i) const;
-
-			// Operators
-			tquat<T> & operator*=(value_type const & s);
-			tquat<T> & operator/=(value_type const & s);
-		};
-
-		template <typename T> 
-		detail::tquat<T> operator- (
-			detail::tquat<T> const & q);
-
-		template <typename T> 
-		detail::tquat<T> operator* ( 
-			detail::tquat<T> const & q, 
-			detail::tquat<T> const & p); 
-
-		template <typename T> 
-		detail::tvec3<T> operator* (
-			detail::tquat<T> const & q, 
-			detail::tvec3<T> const & v);
-
-		template <typename T> 
-		detail::tvec3<T> operator* (
-			detail::tvec3<T> const & v,
-			detail::tquat<T> const & q);
-
-		template <typename T> 
-		detail::tvec4<T> operator* (
-			detail::tquat<T> const & q, 
-			detail::tvec4<T> const & v);
-
-		template <typename T> 
-		detail::tvec4<T> operator* (
-			detail::tvec4<T> const & v,
-			detail::tquat<T> const & q);
-
-		template <typename T> 
-		detail::tquat<T> operator* (
-			detail::tquat<T> const & q, 
-			typename detail::tquat<T>::value_type const & s);
-
-		template <typename T> 
-		detail::tquat<T> operator* (
-			typename detail::tquat<T>::value_type const & s,
-			detail::tquat<T> const & q);
-
-		template <typename T> 
-		detail::tquat<T> operator/ (
-			detail::tquat<T> const & q, 
-			typename detail::tquat<T>::value_type const & s);
-
-	} //namespace detail
-
-	namespace gtc{
-	//! GLM_GTC_quaternion extension: Quaternion types and functions
-    namespace quaternion
-    {
-		/// \addtogroup gtc_quaternion
-		///@{
-
-		//! Returns the length of the quaternion x. 
-		//! From GLM_GTC_quaternion extension.
-        template <typename T> 
-		typename detail::tquat<T>::value_type length(
-			detail::tquat<T> const & q);
-
-        //! Returns the normalized quaternion of from x. 
-		//! From GLM_GTC_quaternion extension.
-		template <typename T> 
-		detail::tquat<T> normalize(
-			detail::tquat<T> const & q);
+		typedef T value_type;
+
+	public:
+		value_type x, y, z, w;
+
+		// Constructors
+		tquat();
+		explicit tquat(
+			value_type const & s, 
+			tvec3<T> const & v);
+		explicit tquat(
+			value_type const & w, 
+			value_type const & x, 
+			value_type const & y, 
+			value_type const & z);
+
+		// Convertions
+		//explicit tquat(valType const & pitch, valType const & yaw, valType const & roll);
+		//! pitch, yaw, roll
+		explicit tquat(
+			tvec3<T> const & eulerAngles);
+		explicit tquat(
+			tmat3x3<T> const & m);
+		explicit tquat(
+			tmat4x4<T> const & m);
+
+		// Accesses
+		value_type & operator[](int i);
+		value_type const & operator[](int i) const;
+
+		// Operators
+		tquat<T> & operator*=(value_type const & s);
+		tquat<T> & operator/=(value_type const & s);
+	};
+
+	template <typename T> 
+	detail::tquat<T> operator- (
+		detail::tquat<T> const & q);
+
+	template <typename T> 
+	detail::tquat<T> operator* ( 
+		detail::tquat<T> const & q, 
+		detail::tquat<T> const & p); 
+
+	template <typename T> 
+	detail::tvec3<T> operator* (
+		detail::tquat<T> const & q, 
+		detail::tvec3<T> const & v);
+
+	template <typename T> 
+	detail::tvec3<T> operator* (
+		detail::tvec3<T> const & v,
+		detail::tquat<T> const & q);
+
+	template <typename T> 
+	detail::tvec4<T> operator* (
+		detail::tquat<T> const & q, 
+		detail::tvec4<T> const & v);
+
+	template <typename T> 
+	detail::tvec4<T> operator* (
+		detail::tvec4<T> const & v,
+		detail::tquat<T> const & q);
+
+	template <typename T> 
+	detail::tquat<T> operator* (
+		detail::tquat<T> const & q, 
+		typename detail::tquat<T>::value_type const & s);
+
+	template <typename T> 
+	detail::tquat<T> operator* (
+		typename detail::tquat<T>::value_type const & s,
+		detail::tquat<T> const & q);
+
+	template <typename T> 
+	detail::tquat<T> operator/ (
+		detail::tquat<T> const & q, 
+		typename detail::tquat<T>::value_type const & s);
+
+} //namespace detail
+
+namespace gtc{
+namespace quaternion ///< GLM_GTC_quaternion extension: Quaternion types and functions
+{
+	/// \addtogroup gtc_quaternion
+	///@{
+
+	//! Returns the length of the quaternion x. 
+	//! From GLM_GTC_quaternion extension.
+    template <typename T> 
+	typename detail::tquat<T>::value_type length(
+		detail::tquat<T> const & q);
+
+    //! Returns the normalized quaternion of from x. 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	detail::tquat<T> normalize(
+		detail::tquat<T> const & q);
 		
-        //! Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ... 
-		//! From GLM_GTC_quaternion extension.
-		template <typename T> 
-		typename detail::tquat<T>::value_type dot(
-			detail::tquat<T> const & q1, 
-			detail::tquat<T> const & q2);
-
-        //! Returns the cross product of q1 and q2. 
-		//! From GLM_GTC_quaternion extension.
-		template <typename T> 
-		GLM_DEPRECATED detail::tquat<T> cross(
-			detail::tquat<T> const & q1, 
-			detail::tquat<T> const & q2);
+    //! Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ... 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	typename detail::tquat<T>::value_type dot(
+		detail::tquat<T> const & q1, 
+		detail::tquat<T> const & q2);
+
+    //! Returns the cross product of q1 and q2. 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	GLM_DEPRECATED detail::tquat<T> cross(
+		detail::tquat<T> const & q1, 
+		detail::tquat<T> const & q2);
 		
-		//! Returns a SLERP interpolated quaternion of x and y according a. 
-		//! From GLM_GTC_quaternion extension.
-		template <typename T> 
-		detail::tquat<T> mix(
-			detail::tquat<T> const & x, 
-			detail::tquat<T> const & y, 
-			typename detail::tquat<T>::value_type const & a);
+	//! Returns a SLERP interpolated quaternion of x and y according a. 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	detail::tquat<T> mix(
+		detail::tquat<T> const & x, 
+		detail::tquat<T> const & y, 
+		typename detail::tquat<T>::value_type const & a);
 		
-		//! Returns the q conjugate. 
-		//! From GLM_GTC_quaternion extension.
-        template <typename T> 
-		detail::tquat<T> conjugate(
-			detail::tquat<T> const & q);
-
-		//! Returns the q inverse. 
-		//! From GLM_GTC_quaternion extension.
-        template <typename T> 
-		detail::tquat<T> inverse(
-			detail::tquat<T> const & q);
-
-		//! Rotates a quaternion from an vector of 3 components axis and an angle expressed in degrees.
-		//! From GLM_GTC_quaternion extension.
-		template <typename T> 
-		detail::tquat<T> rotate(
-			detail::tquat<T> const & q, 
-			typename detail::tquat<T>::value_type const & angle, 
-			detail::tvec3<T> const & v);
-
-		//! Converts a quaternion to a 3 * 3 matrix. 
-		//! From GLM_GTC_quaternion extension.
-        template <typename T> 
-		detail::tmat3x3<T> mat3_cast(
-			detail::tquat<T> const & x);
-
-		//! Converts a quaternion to a 4 * 4 matrix. 
-		//! From GLM_GTC_quaternion extension.
-		template <typename T> 
-		detail::tmat4x4<T> mat4_cast(
-			detail::tquat<T> const & x);
-
-		//! Converts a 3 * 3 matrix to a quaternion. 
-		//! From GLM_GTC_quaternion extension.
-		template <typename T> 
-		detail::tquat<T> quat_cast(
-			detail::tmat3x3<T> const & x);
-
-		//! Converts a 4 * 4 matrix to a quaternion. 
-		//! From GLM_GTC_quaternion extension.
-		template <typename T> 
-		detail::tquat<T> quat_cast(
-			detail::tmat4x4<T> const & x);
-
-		//! Quaternion of floating-point numbers. 
-		//! From GLM_GTC_quaternion extension.
-        typedef detail::tquat<float> quat;
-
-		//! Quaternion of half-precision floating-point numbers.
-		//! From GLM_GTC_quaternion extension.
-		typedef detail::tquat<detail::thalf>	hquat;
-
-		//! Quaternion of single-precision floating-point numbers. 
-		//! From GLM_GTC_quaternion extension.
-		typedef detail::tquat<float>	fquat;
-
-		//! Quaternion of double-precision floating-point numbers. 
-		//! From GLM_GTC_quaternion extension.
-		typedef detail::tquat<double>	dquat;
-
-		///@}
-
-    }//namespace quaternion
-    }//namespace gtc
+	//! Returns the q conjugate. 
+	//! From GLM_GTC_quaternion extension.
+    template <typename T> 
+	detail::tquat<T> conjugate(
+		detail::tquat<T> const & q);
+
+	//! Returns the q inverse. 
+	//! From GLM_GTC_quaternion extension.
+    template <typename T> 
+	detail::tquat<T> inverse(
+		detail::tquat<T> const & q);
+
+	//! Rotates a quaternion from an vector of 3 components axis and an angle expressed in degrees.
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	detail::tquat<T> rotate(
+		detail::tquat<T> const & q, 
+		typename detail::tquat<T>::value_type const & angle, 
+		detail::tvec3<T> const & v);
+
+	//! Converts a quaternion to a 3 * 3 matrix. 
+	//! From GLM_GTC_quaternion extension.
+    template <typename T> 
+	detail::tmat3x3<T> mat3_cast(
+		detail::tquat<T> const & x);
+
+	//! Converts a quaternion to a 4 * 4 matrix. 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	detail::tmat4x4<T> mat4_cast(
+		detail::tquat<T> const & x);
+
+	//! Converts a 3 * 3 matrix to a quaternion. 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	detail::tquat<T> quat_cast(
+		detail::tmat3x3<T> const & x);
+
+	//! Converts a 4 * 4 matrix to a quaternion. 
+	//! From GLM_GTC_quaternion extension.
+	template <typename T> 
+	detail::tquat<T> quat_cast(
+		detail::tmat4x4<T> const & x);
+
+	//! Quaternion of floating-point numbers. 
+	//! From GLM_GTC_quaternion extension.
+    typedef detail::tquat<float> quat;
+
+	//! Quaternion of half-precision floating-point numbers.
+	//! From GLM_GTC_quaternion extension.
+	typedef detail::tquat<detail::thalf>	hquat;
+
+	//! Quaternion of single-precision floating-point numbers. 
+	//! From GLM_GTC_quaternion extension.
+	typedef detail::tquat<float>	fquat;
+
+	//! Quaternion of double-precision floating-point numbers. 
+	//! From GLM_GTC_quaternion extension.
+	typedef detail::tquat<double>	dquat;
+
+	///@}
+
+} //namespace quaternion
+} //namespace gtc
 } //namespace glm
 
 #include "quaternion.inl"

glm/gtc/swizzle.hpp

@@ -21,333 +21,327 @@
 #	pragma message("GLM: GLM_GTC_swizzle extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtc{
+namespace swizzle ///< GLM_GTC_swizzle extension
 {
-	namespace test{
-		void main_gtc_swizzle();
-	}//namespace test
-
-	namespace gtc{
-	//! GLM_GTC_swizzle extension
-	namespace swizzle
-	{
-		using namespace gtc::half_float;
-
-		template <typename T, template <typename> class vecType>
-		T const & swizzle(	
-			vecType<T> const & v,
-			comp x);
-
-		template <typename T, template <typename> class vecType>
-		detail::tvec2<T> const & swizzle(
-			vecType<T> const & v,
-			comp x, comp y);
-
-		template <typename T, template <typename> class vecType>
-		detail::tvec3<T> const & swizzle(
-			vecType<T> const & v,
-			comp x, comp y, comp z);
-
-		template <typename T, template <typename> class vecType>
-		detail::tvec4<T> const & swizzle(
-			vecType<T> const & v,
-			comp x, comp y, comp z, comp w);
-
-		template <typename T, template <typename> class vecType>
-		T & swizzle(
-			vecType<T> & v,
-			comp x);
-
-		template <typename T, template <typename> class vecType>
-		detail::tref2<T> swizzle(
-			vecType<T> & v,
-			comp x, comp y);
-
-		template <typename T, template <typename> class vecType>
-		detail::tref3<T> swizzle(
-			vecType<T> & v,
-			comp x, comp y, comp z);
-
-		template <typename T, template <typename> class vecType>
-		detail::tref4<T> swizzle(
-			vecType<T> & v,
-			comp x, comp y, comp z, comp w);
+	using namespace gtc::half_float;
+
+	template <typename T, template <typename> class vecType>
+	T const & swizzle(	
+		vecType<T> const & v,
+		comp x);
+
+	template <typename T, template <typename> class vecType>
+	detail::tvec2<T> const & swizzle(
+		vecType<T> const & v,
+		comp x, comp y);
+
+	template <typename T, template <typename> class vecType>
+	detail::tvec3<T> const & swizzle(
+		vecType<T> const & v,
+		comp x, comp y, comp z);
+
+	template <typename T, template <typename> class vecType>
+	detail::tvec4<T> const & swizzle(
+		vecType<T> const & v,
+		comp x, comp y, comp z, comp w);
+
+	template <typename T, template <typename> class vecType>
+	T & swizzle(
+		vecType<T> & v,
+		comp x);
+
+	template <typename T, template <typename> class vecType>
+	detail::tref2<T> swizzle(
+		vecType<T> & v,
+		comp x, comp y);
+
+	template <typename T, template <typename> class vecType>
+	detail::tref3<T> swizzle(
+		vecType<T> & v,
+		comp x, comp y, comp z);
+
+	template <typename T, template <typename> class vecType>
+	detail::tref4<T> swizzle(
+		vecType<T> & v,
+		comp x, comp y, comp z, comp w);
 
 #		define static_swizzle1(TYPE, SIZE)							\
-			template <comp x>										\
-			GLM_FUNC_QUALIFIER TYPE swizzle(detail::tvec##SIZE<TYPE> const & v)	\
-			{return v[x];}											\
-																	\
-			template <comp x>										\
-			GLM_FUNC_QUALIFIER TYPE& swizzle(detail::tvec##SIZE<TYPE> & v)		\
-			{return v[x];}
-
-		static_swizzle1(detail::float16, 2)
-		static_swizzle1(detail::float16, 3)
-		static_swizzle1(detail::float16, 4)
-		static_swizzle1(detail::float32, 2)
-		static_swizzle1(detail::float32, 3)
-		static_swizzle1(detail::float32, 4)
-		static_swizzle1(detail::float64, 2)
-		static_swizzle1(detail::float64, 3)
-		static_swizzle1(detail::float64, 4)
-
-		static_swizzle1(detail::int8,  2)
-		static_swizzle1(detail::int8,  3)
-		static_swizzle1(detail::int8,  4)
-		static_swizzle1(detail::int16, 2)
-		static_swizzle1(detail::int16, 3)
-		static_swizzle1(detail::int16, 4)
-		static_swizzle1(detail::int32, 2)
-		static_swizzle1(detail::int32, 3)
-		static_swizzle1(detail::int32, 4)
-		static_swizzle1(detail::int64, 2)
-		static_swizzle1(detail::int64, 3)
-		static_swizzle1(detail::int64, 4)
-
-		static_swizzle1(detail::uint8,  2)
-		static_swizzle1(detail::uint8,  3)
-		static_swizzle1(detail::uint8,  4)
-		static_swizzle1(detail::uint16, 2)
-		static_swizzle1(detail::uint16, 3)
-		static_swizzle1(detail::uint16, 4)
-		static_swizzle1(detail::uint32, 2)
-		static_swizzle1(detail::uint32, 3)
-		static_swizzle1(detail::uint32, 4)
-		static_swizzle1(detail::uint64, 2)
-		static_swizzle1(detail::uint64, 3)
-		static_swizzle1(detail::uint64, 4)
+		template <comp x>										\
+		GLM_FUNC_QUALIFIER TYPE swizzle(detail::tvec##SIZE<TYPE> const & v)	\
+		{return v[x];}											\
+																\
+		template <comp x>										\
+		GLM_FUNC_QUALIFIER TYPE& swizzle(detail::tvec##SIZE<TYPE> & v)		\
+		{return v[x];}
+
+	static_swizzle1(detail::float16, 2)
+	static_swizzle1(detail::float16, 3)
+	static_swizzle1(detail::float16, 4)
+	static_swizzle1(detail::float32, 2)
+	static_swizzle1(detail::float32, 3)
+	static_swizzle1(detail::float32, 4)
+	static_swizzle1(detail::float64, 2)
+	static_swizzle1(detail::float64, 3)
+	static_swizzle1(detail::float64, 4)
+
+	static_swizzle1(detail::int8,  2)
+	static_swizzle1(detail::int8,  3)
+	static_swizzle1(detail::int8,  4)
+	static_swizzle1(detail::int16, 2)
+	static_swizzle1(detail::int16, 3)
+	static_swizzle1(detail::int16, 4)
+	static_swizzle1(detail::int32, 2)
+	static_swizzle1(detail::int32, 3)
+	static_swizzle1(detail::int32, 4)
+	static_swizzle1(detail::int64, 2)
+	static_swizzle1(detail::int64, 3)
+	static_swizzle1(detail::int64, 4)
+
+	static_swizzle1(detail::uint8,  2)
+	static_swizzle1(detail::uint8,  3)
+	static_swizzle1(detail::uint8,  4)
+	static_swizzle1(detail::uint16, 2)
+	static_swizzle1(detail::uint16, 3)
+	static_swizzle1(detail::uint16, 4)
+	static_swizzle1(detail::uint32, 2)
+	static_swizzle1(detail::uint32, 3)
+	static_swizzle1(detail::uint32, 4)
+	static_swizzle1(detail::uint64, 2)
+	static_swizzle1(detail::uint64, 3)
+	static_swizzle1(detail::uint64, 4)
 
 #		define static_swizzle2_const(TYPE) \
-			template <comp x, comp y> \
-			GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
-			{return TYPE(v[x], v[y]);}
+		template <comp x, comp y> \
+		GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
+		{return TYPE(v[x], v[y]);}
 
 #		define static_swizzle3_const(TYPE) \
-			template <comp x, comp y, comp z> \
-			GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
-			{return TYPE(v[x], v[y], v[z]);}
+		template <comp x, comp y, comp z> \
+		GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
+		{return TYPE(v[x], v[y], v[z]);}
 
 #		define static_swizzle4_const(TYPE) \
-			template <comp x, comp y, comp z, comp w> \
-			GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
-			{return TYPE(v[x], v[y], v[z], v[w]);}
+		template <comp x, comp y, comp z, comp w> \
+		GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
+		{return TYPE(v[x], v[y], v[z], v[w]);}
 /*
 #		define static_swizzle2_const(TYPE, SIZE)									\
-			template <comp x, comp y>												\
-			GLM_FUNC_QUALIFIER detail::tvec2<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
-			{return detail::tvec2<TYPE>(v[x], v[y]);}
+		template <comp x, comp y>												\
+		GLM_FUNC_QUALIFIER detail::tvec2<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
+		{return detail::tvec2<TYPE>(v[x], v[y]);}
 
 #		define static_swizzle3_const(TYPE, SIZE)									\
-			template <comp x, comp y, comp z>										\
-			GLM_FUNC_QUALIFIER detail::tvec3<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
-			{return detail::tvec3<TYPE>(v[x], v[y], v[z]);}
+		template <comp x, comp y, comp z>										\
+		GLM_FUNC_QUALIFIER detail::tvec3<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
+		{return detail::tvec3<TYPE>(v[x], v[y], v[z]);}
 
 #		define static_swizzle4_const(TYPE, SIZE)									\
-			template <comp x, comp y, comp z, comp w>								\
-			GLM_FUNC_QUALIFIER detail::tvec4<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
-			{return detail::tvec4<TYPE>(v[x], v[y], v[z], v[w]);}
+		template <comp x, comp y, comp z, comp w>								\
+		GLM_FUNC_QUALIFIER detail::tvec4<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v)	\
+		{return detail::tvec4<TYPE>(v[x], v[y], v[z], v[w]);}
 */
-		static_swizzle2_const(glm::f16vec2)
-		static_swizzle2_const(glm::f16vec3)
-		static_swizzle2_const(glm::f16vec4)
-		static_swizzle2_const(glm::f32vec2)
-		static_swizzle2_const(glm::f32vec3)
-		static_swizzle2_const(glm::f32vec4)
-		static_swizzle2_const(glm::f64vec2)
-		static_swizzle2_const(glm::f64vec3)
-		static_swizzle2_const(glm::f64vec4)
-
-		static_swizzle2_const(glm::i8vec2)
-		static_swizzle2_const(glm::i8vec3)
-		static_swizzle2_const(glm::i8vec4)
-		static_swizzle2_const(glm::i16vec2)
-		static_swizzle2_const(glm::i16vec3)
-		static_swizzle2_const(glm::i16vec4)
-		static_swizzle2_const(glm::i32vec2)
-		static_swizzle2_const(glm::i32vec3)
-		static_swizzle2_const(glm::i32vec4)
-		static_swizzle2_const(glm::i64vec2)
-		static_swizzle2_const(glm::i64vec3)
-		static_swizzle2_const(glm::i64vec4)
-
-		static_swizzle2_const(glm::u8vec2)
-		static_swizzle2_const(glm::u8vec3)
-		static_swizzle2_const(glm::u8vec4)
-		static_swizzle2_const(glm::u16vec2)
-		static_swizzle2_const(glm::u16vec3)
-		static_swizzle2_const(glm::u16vec4)
-		static_swizzle2_const(glm::u32vec2)
-		static_swizzle2_const(glm::u32vec3)
-		static_swizzle2_const(glm::u32vec4)
-		static_swizzle2_const(glm::u64vec2)
-		static_swizzle2_const(glm::u64vec3)
-		static_swizzle2_const(glm::u64vec4)
-
-		static_swizzle3_const(glm::f16vec2)
-		static_swizzle3_const(glm::f16vec3)
-		static_swizzle3_const(glm::f16vec4)
-		static_swizzle3_const(glm::f32vec2)
-		static_swizzle3_const(glm::f32vec3)
-		static_swizzle3_const(glm::f32vec4)
-		static_swizzle3_const(glm::f64vec2)
-		static_swizzle3_const(glm::f64vec3)
-		static_swizzle3_const(glm::f64vec4)
-
-		static_swizzle3_const(glm::i8vec2)
-		static_swizzle3_const(glm::i8vec3)
-		static_swizzle3_const(glm::i8vec4)
-		static_swizzle3_const(glm::i16vec2)
-		static_swizzle3_const(glm::i16vec3)
-		static_swizzle3_const(glm::i16vec4)
-		static_swizzle3_const(glm::i32vec2)
-		static_swizzle3_const(glm::i32vec3)
-		static_swizzle3_const(glm::i32vec4)
-		static_swizzle3_const(glm::i64vec2)
-		static_swizzle3_const(glm::i64vec3)
-		static_swizzle3_const(glm::i64vec4)
-
-		static_swizzle3_const(glm::u8vec2)
-		static_swizzle3_const(glm::u8vec3)
-		static_swizzle3_const(glm::u8vec4)
-		static_swizzle3_const(glm::u16vec2)
-		static_swizzle3_const(glm::u16vec3)
-		static_swizzle3_const(glm::u16vec4)
-		static_swizzle3_const(glm::u32vec2)
-		static_swizzle3_const(glm::u32vec3)
-		static_swizzle3_const(glm::u32vec4)
-		static_swizzle3_const(glm::u64vec2)
-		static_swizzle3_const(glm::u64vec3)
-		static_swizzle3_const(glm::u64vec4)
-
-		static_swizzle4_const(glm::f16vec2)
-		static_swizzle4_const(glm::f16vec3)
-		static_swizzle4_const(glm::f16vec4)
-		static_swizzle4_const(glm::f32vec2)
-		static_swizzle4_const(glm::f32vec3)
-		static_swizzle4_const(glm::f32vec4)
-		static_swizzle4_const(glm::f64vec2)
-		static_swizzle4_const(glm::f64vec3)
-		static_swizzle4_const(glm::f64vec4)
-
-		static_swizzle4_const(glm::i8vec2)
-		static_swizzle4_const(glm::i8vec3)
-		static_swizzle4_const(glm::i8vec4)
-		static_swizzle4_const(glm::i16vec2)
-		static_swizzle4_const(glm::i16vec3)
-		static_swizzle4_const(glm::i16vec4)
-		static_swizzle4_const(glm::i32vec2)
-		static_swizzle4_const(glm::i32vec3)
-		static_swizzle4_const(glm::i32vec4)
-		static_swizzle4_const(glm::i64vec2)
-		static_swizzle4_const(glm::i64vec3)
-		static_swizzle4_const(glm::i64vec4)
-
-		static_swizzle4_const(glm::u8vec2)
-		static_swizzle4_const(glm::u8vec3)
-		static_swizzle4_const(glm::u8vec4)
-		static_swizzle4_const(glm::u16vec2)
-		static_swizzle4_const(glm::u16vec3)
-		static_swizzle4_const(glm::u16vec4)
-		static_swizzle4_const(glm::u32vec2)
-		static_swizzle4_const(glm::u32vec3)
-		static_swizzle4_const(glm::u32vec4)
-		static_swizzle4_const(glm::u64vec2)
-		static_swizzle4_const(glm::u64vec3)
-		static_swizzle4_const(glm::u64vec4)
+	static_swizzle2_const(glm::f16vec2)
+	static_swizzle2_const(glm::f16vec3)
+	static_swizzle2_const(glm::f16vec4)
+	static_swizzle2_const(glm::f32vec2)
+	static_swizzle2_const(glm::f32vec3)
+	static_swizzle2_const(glm::f32vec4)
+	static_swizzle2_const(glm::f64vec2)
+	static_swizzle2_const(glm::f64vec3)
+	static_swizzle2_const(glm::f64vec4)
+
+	static_swizzle2_const(glm::i8vec2)
+	static_swizzle2_const(glm::i8vec3)
+	static_swizzle2_const(glm::i8vec4)
+	static_swizzle2_const(glm::i16vec2)
+	static_swizzle2_const(glm::i16vec3)
+	static_swizzle2_const(glm::i16vec4)
+	static_swizzle2_const(glm::i32vec2)
+	static_swizzle2_const(glm::i32vec3)
+	static_swizzle2_const(glm::i32vec4)
+	static_swizzle2_const(glm::i64vec2)
+	static_swizzle2_const(glm::i64vec3)
+	static_swizzle2_const(glm::i64vec4)
+
+	static_swizzle2_const(glm::u8vec2)
+	static_swizzle2_const(glm::u8vec3)
+	static_swizzle2_const(glm::u8vec4)
+	static_swizzle2_const(glm::u16vec2)
+	static_swizzle2_const(glm::u16vec3)
+	static_swizzle2_const(glm::u16vec4)
+	static_swizzle2_const(glm::u32vec2)
+	static_swizzle2_const(glm::u32vec3)
+	static_swizzle2_const(glm::u32vec4)
+	static_swizzle2_const(glm::u64vec2)
+	static_swizzle2_const(glm::u64vec3)
+	static_swizzle2_const(glm::u64vec4)
+
+	static_swizzle3_const(glm::f16vec2)
+	static_swizzle3_const(glm::f16vec3)
+	static_swizzle3_const(glm::f16vec4)
+	static_swizzle3_const(glm::f32vec2)
+	static_swizzle3_const(glm::f32vec3)
+	static_swizzle3_const(glm::f32vec4)
+	static_swizzle3_const(glm::f64vec2)
+	static_swizzle3_const(glm::f64vec3)
+	static_swizzle3_const(glm::f64vec4)
+
+	static_swizzle3_const(glm::i8vec2)
+	static_swizzle3_const(glm::i8vec3)
+	static_swizzle3_const(glm::i8vec4)
+	static_swizzle3_const(glm::i16vec2)
+	static_swizzle3_const(glm::i16vec3)
+	static_swizzle3_const(glm::i16vec4)
+	static_swizzle3_const(glm::i32vec2)
+	static_swizzle3_const(glm::i32vec3)
+	static_swizzle3_const(glm::i32vec4)
+	static_swizzle3_const(glm::i64vec2)
+	static_swizzle3_const(glm::i64vec3)
+	static_swizzle3_const(glm::i64vec4)
+
+	static_swizzle3_const(glm::u8vec2)
+	static_swizzle3_const(glm::u8vec3)
+	static_swizzle3_const(glm::u8vec4)
+	static_swizzle3_const(glm::u16vec2)
+	static_swizzle3_const(glm::u16vec3)
+	static_swizzle3_const(glm::u16vec4)
+	static_swizzle3_const(glm::u32vec2)
+	static_swizzle3_const(glm::u32vec3)
+	static_swizzle3_const(glm::u32vec4)
+	static_swizzle3_const(glm::u64vec2)
+	static_swizzle3_const(glm::u64vec3)
+	static_swizzle3_const(glm::u64vec4)
+
+	static_swizzle4_const(glm::f16vec2)
+	static_swizzle4_const(glm::f16vec3)
+	static_swizzle4_const(glm::f16vec4)
+	static_swizzle4_const(glm::f32vec2)
+	static_swizzle4_const(glm::f32vec3)
+	static_swizzle4_const(glm::f32vec4)
+	static_swizzle4_const(glm::f64vec2)
+	static_swizzle4_const(glm::f64vec3)
+	static_swizzle4_const(glm::f64vec4)
+
+	static_swizzle4_const(glm::i8vec2)
+	static_swizzle4_const(glm::i8vec3)
+	static_swizzle4_const(glm::i8vec4)
+	static_swizzle4_const(glm::i16vec2)
+	static_swizzle4_const(glm::i16vec3)
+	static_swizzle4_const(glm::i16vec4)
+	static_swizzle4_const(glm::i32vec2)
+	static_swizzle4_const(glm::i32vec3)
+	static_swizzle4_const(glm::i32vec4)
+	static_swizzle4_const(glm::i64vec2)
+	static_swizzle4_const(glm::i64vec3)
+	static_swizzle4_const(glm::i64vec4)
+
+	static_swizzle4_const(glm::u8vec2)
+	static_swizzle4_const(glm::u8vec3)
+	static_swizzle4_const(glm::u8vec4)
+	static_swizzle4_const(glm::u16vec2)
+	static_swizzle4_const(glm::u16vec3)
+	static_swizzle4_const(glm::u16vec4)
+	static_swizzle4_const(glm::u32vec2)
+	static_swizzle4_const(glm::u32vec3)
+	static_swizzle4_const(glm::u32vec4)
+	static_swizzle4_const(glm::u64vec2)
+	static_swizzle4_const(glm::u64vec3)
+	static_swizzle4_const(glm::u64vec4)
 
 #		define static_swizzle2_ref(TYPE) \
-			template <glm::comp x, glm::comp y> \
-			GLM_FUNC_QUALIFIER glm::detail::tref2<typename TYPE::value_type> swizzle(TYPE & v) \
-			{return glm::detail::tref2<typename TYPE::value_type>(v[x], v[y]);}	
+		template <glm::comp x, glm::comp y> \
+		GLM_FUNC_QUALIFIER glm::detail::tref2<typename TYPE::value_type> swizzle(TYPE & v) \
+		{return glm::detail::tref2<typename TYPE::value_type>(v[x], v[y]);}	
 
 #		define static_swizzle3_ref(TYPE) \
-			template <glm::comp x, glm::comp y, glm::comp z> \
-			GLM_FUNC_QUALIFIER glm::detail::tref3<typename TYPE::value_type> swizzle(TYPE & v) \
-			{return glm::detail::tref3<typename TYPE::value_type>(v[x], v[y], v[z]);}	
+		template <glm::comp x, glm::comp y, glm::comp z> \
+		GLM_FUNC_QUALIFIER glm::detail::tref3<typename TYPE::value_type> swizzle(TYPE & v) \
+		{return glm::detail::tref3<typename TYPE::value_type>(v[x], v[y], v[z]);}	
 
 #		define static_swizzle4_ref(TYPE) \
-			template <glm::comp x, glm::comp y, glm::comp z, glm::comp w> \
-			GLM_FUNC_QUALIFIER glm::detail::tref4<typename TYPE::value_type> swizzle(TYPE & v) \
-			{return glm::detail::tref4<typename TYPE::value_type>(v[x], v[y], v[z], v[w]);}	
-
-		static_swizzle2_ref(glm::f16vec2)
-		static_swizzle2_ref(glm::f16vec3)
-		static_swizzle2_ref(glm::f16vec4)
-		static_swizzle2_ref(glm::f32vec2)
-		static_swizzle2_ref(glm::f32vec3)
-		static_swizzle2_ref(glm::f32vec4)
-		static_swizzle2_ref(glm::f64vec2)
-		static_swizzle2_ref(glm::f64vec3)
-		static_swizzle2_ref(glm::f64vec4)
-
-		static_swizzle2_ref(glm::i8vec2)
-		static_swizzle2_ref(glm::i8vec3)
-		static_swizzle2_ref(glm::i8vec4)
-		static_swizzle2_ref(glm::i16vec2)
-		static_swizzle2_ref(glm::i16vec3)
-		static_swizzle2_ref(glm::i16vec4)
-		static_swizzle2_ref(glm::i32vec2)
-		static_swizzle2_ref(glm::i32vec3)
-		static_swizzle2_ref(glm::i32vec4)
-		static_swizzle2_ref(glm::i64vec2)
-		static_swizzle2_ref(glm::i64vec3)
-		static_swizzle2_ref(glm::i64vec4)
-
-		static_swizzle2_ref(glm::u8vec2)
-		static_swizzle2_ref(glm::u8vec3)
-		static_swizzle2_ref(glm::u8vec4)
-		static_swizzle2_ref(glm::u16vec2)
-		static_swizzle2_ref(glm::u16vec3)
-		static_swizzle2_ref(glm::u16vec4)
-		static_swizzle2_ref(glm::u32vec2)
-		static_swizzle2_ref(glm::u32vec3)
-		static_swizzle2_ref(glm::u32vec4)
-		static_swizzle2_ref(glm::u64vec2)
-		static_swizzle2_ref(glm::u64vec3)
-		static_swizzle2_ref(glm::u64vec4)
-
-		static_swizzle3_ref(glm::f16vec3)
-		static_swizzle3_ref(glm::f16vec4)
-		static_swizzle3_ref(glm::f32vec3)
-		static_swizzle3_ref(glm::f32vec4)
-		static_swizzle3_ref(glm::f64vec3)
-		static_swizzle3_ref(glm::f64vec4)
-
-		static_swizzle3_ref(glm::i8vec3)
-		static_swizzle3_ref(glm::i8vec4)
-		static_swizzle3_ref(glm::i16vec3)
-		static_swizzle3_ref(glm::i16vec4)
-		static_swizzle3_ref(glm::i32vec3)
-		static_swizzle3_ref(glm::i32vec4)
-		static_swizzle3_ref(glm::i64vec3)
-		static_swizzle3_ref(glm::i64vec4)
-
-		static_swizzle3_ref(glm::u8vec3)
-		static_swizzle3_ref(glm::u8vec4)
-		static_swizzle3_ref(glm::u16vec3)
-		static_swizzle3_ref(glm::u16vec4)
-		static_swizzle3_ref(glm::u32vec3)
-		static_swizzle3_ref(glm::u32vec4)
-		static_swizzle3_ref(glm::u64vec3)
-		static_swizzle3_ref(glm::u64vec4)
-
-		static_swizzle4_ref(glm::f16vec4)
-		static_swizzle4_ref(glm::f32vec4)
-		static_swizzle4_ref(glm::f64vec4)
-
-		static_swizzle4_ref(glm::i8vec4)
-		static_swizzle4_ref(glm::i16vec4)
-		static_swizzle4_ref(glm::i32vec4)
-		static_swizzle4_ref(glm::i64vec4)
-
-		static_swizzle4_ref(glm::u8vec4)
-		static_swizzle4_ref(glm::u16vec4)
-		static_swizzle4_ref(glm::u32vec4)
-		static_swizzle4_ref(glm::u64vec4)
-
-	}//namespace swizzle
-	}//namespace gtc
+		template <glm::comp x, glm::comp y, glm::comp z, glm::comp w> \
+		GLM_FUNC_QUALIFIER glm::detail::tref4<typename TYPE::value_type> swizzle(TYPE & v) \
+		{return glm::detail::tref4<typename TYPE::value_type>(v[x], v[y], v[z], v[w]);}	
+
+	static_swizzle2_ref(glm::f16vec2)
+	static_swizzle2_ref(glm::f16vec3)
+	static_swizzle2_ref(glm::f16vec4)
+	static_swizzle2_ref(glm::f32vec2)
+	static_swizzle2_ref(glm::f32vec3)
+	static_swizzle2_ref(glm::f32vec4)
+	static_swizzle2_ref(glm::f64vec2)
+	static_swizzle2_ref(glm::f64vec3)
+	static_swizzle2_ref(glm::f64vec4)
+
+	static_swizzle2_ref(glm::i8vec2)
+	static_swizzle2_ref(glm::i8vec3)
+	static_swizzle2_ref(glm::i8vec4)
+	static_swizzle2_ref(glm::i16vec2)
+	static_swizzle2_ref(glm::i16vec3)
+	static_swizzle2_ref(glm::i16vec4)
+	static_swizzle2_ref(glm::i32vec2)
+	static_swizzle2_ref(glm::i32vec3)
+	static_swizzle2_ref(glm::i32vec4)
+	static_swizzle2_ref(glm::i64vec2)
+	static_swizzle2_ref(glm::i64vec3)
+	static_swizzle2_ref(glm::i64vec4)
+
+	static_swizzle2_ref(glm::u8vec2)
+	static_swizzle2_ref(glm::u8vec3)
+	static_swizzle2_ref(glm::u8vec4)
+	static_swizzle2_ref(glm::u16vec2)
+	static_swizzle2_ref(glm::u16vec3)
+	static_swizzle2_ref(glm::u16vec4)
+	static_swizzle2_ref(glm::u32vec2)
+	static_swizzle2_ref(glm::u32vec3)
+	static_swizzle2_ref(glm::u32vec4)
+	static_swizzle2_ref(glm::u64vec2)
+	static_swizzle2_ref(glm::u64vec3)
+	static_swizzle2_ref(glm::u64vec4)
+
+	static_swizzle3_ref(glm::f16vec3)
+	static_swizzle3_ref(glm::f16vec4)
+	static_swizzle3_ref(glm::f32vec3)
+	static_swizzle3_ref(glm::f32vec4)
+	static_swizzle3_ref(glm::f64vec3)
+	static_swizzle3_ref(glm::f64vec4)
+
+	static_swizzle3_ref(glm::i8vec3)
+	static_swizzle3_ref(glm::i8vec4)
+	static_swizzle3_ref(glm::i16vec3)
+	static_swizzle3_ref(glm::i16vec4)
+	static_swizzle3_ref(glm::i32vec3)
+	static_swizzle3_ref(glm::i32vec4)
+	static_swizzle3_ref(glm::i64vec3)
+	static_swizzle3_ref(glm::i64vec4)
+
+	static_swizzle3_ref(glm::u8vec3)
+	static_swizzle3_ref(glm::u8vec4)
+	static_swizzle3_ref(glm::u16vec3)
+	static_swizzle3_ref(glm::u16vec4)
+	static_swizzle3_ref(glm::u32vec3)
+	static_swizzle3_ref(glm::u32vec4)
+	static_swizzle3_ref(glm::u64vec3)
+	static_swizzle3_ref(glm::u64vec4)
+
+	static_swizzle4_ref(glm::f16vec4)
+	static_swizzle4_ref(glm::f32vec4)
+	static_swizzle4_ref(glm::f64vec4)
+
+	static_swizzle4_ref(glm::i8vec4)
+	static_swizzle4_ref(glm::i16vec4)
+	static_swizzle4_ref(glm::i32vec4)
+	static_swizzle4_ref(glm::i64vec4)
+
+	static_swizzle4_ref(glm::u8vec4)
+	static_swizzle4_ref(glm::u16vec4)
+	static_swizzle4_ref(glm::u32vec4)
+	static_swizzle4_ref(glm::u64vec4)
+
+}//namespace swizzle
+}//namespace gtc
 }//namespace glm
 
 #include "swizzle.inl"

glm/gtc/type_precision.hpp

@@ -24,199 +24,193 @@
 #	pragma message("GLM: GLM_GTC_type_precision extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtc{
+namespace type_precision ///< GLM_GTC_type_precision extension: Defined types with specific size.
 {
-	namespace test{
-		bool main_gtc_type_precision();
-	}//namespace test
-
-	namespace gtc{
-	//! GLM_GTC_type_precision extension: Defined types with specific size.
-	namespace type_precision
-	{
-		///////////////////////////
-		// Dependences
-
-		using namespace gtc::half_float;
-		using namespace gtc::quaternion;
-
-		///////////////////////////
-		// Signed int vector types 
-
-		/// \addtogroup gtc_type_precision
-		///@{
-
-		typedef detail::int8						int8;         //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
-		typedef detail::int16						int16;        //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
-		typedef detail::int32						int32;        //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
-		typedef detail::int64						int64;        //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension)
-
-		typedef int8								i8;         //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
-		typedef int16								i16;        //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
-		typedef int32								i32;        //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
-		typedef int64								i64;        //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension)
-
-		//typedef i8									i8vec1;		//!< \brief 8bit signed integer scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec2<i8>					i8vec2;     //!< \brief 8bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec3<i8>					i8vec3;     //!< \brief 8bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec4<i8>					i8vec4;     //!< \brief 8bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
-
-		//typedef i16									i16vec1;	//!< \brief 16bit signed integer scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec2<i16>					i16vec2;    //!< \brief 16bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec3<i16>					i16vec3;    //!< \brief 16bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec4<i16>					i16vec4;    //!< \brief 16bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
-
-		//typedef i32									i32vec1;	//!< \brief 32bit signed integer scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec2<i32>					i32vec2;    //!< \brief 32bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec3<i32>					i32vec3;    //!< \brief 32bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec4<i32>					i32vec4;    //!< \brief 32bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
-
-		//typedef i64									i64vec1;	//!< \brief 32bit signed integer scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec2<i64>					i64vec2;    //!< \brief 64bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec3<i64>					i64vec3;    //!< \brief 64bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec4<i64>					i64vec4;    //!< \brief 64bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
-
-		/////////////////////////////
-		// Unsigned int vector types 
-
-		typedef detail::uint8						uint8;         //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension)
-		typedef detail::uint16						uint16;        //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
-		typedef detail::uint32						uint32;        //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension)
-		typedef detail::uint64						uint64;        //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension)
-
-		typedef uint8								u8;         //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension)
-		typedef uint16								u16;        //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
-		typedef uint32								u32;        //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension)
-		typedef uint64								u64;        //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension)
-
-		//typedef u8									u8vec1;		//!< \brief 8bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec2<u8>					u8vec2;     //!< \brief 8bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec3<u8>					u8vec3;     //!< \brief 8bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec4<u8>					u8vec4;     //!< \brief 8bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
-
-		//typedef u16									u16vec1;    //!< \brief 16bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec2<u16>					u16vec2;    //!< \brief 16bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec3<u16>					u16vec3;    //!< \brief 16bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec4<u16>					u16vec4;    //!< \brief 16bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
-
-		//typedef u32									u32vec1;    //!< \brief 32bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec2<u32>					u32vec2;    //!< \brief 32bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec3<u32>					u32vec3;    //!< \brief 32bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec4<u32>					u32vec4;    //!< \brief 32bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
-
-		//typedef u64									u64vec1;    //!< \brief 64bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec2<u64>					u64vec2;    //!< \brief 64bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec3<u64>					u64vec3;    //!< \brief 64bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec4<u64>					u64vec4;    //!< \brief 64bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
-
-		//////////////////////
-		// Float vector types 
-
-		typedef detail::float16						float16;	//!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::float32						float32;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::float64						float64;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-
-		typedef float16								f16;        //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef float32								f32;        //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef float64								f64;        //!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-
-		typedef detail::tvec2<float>				fvec2;		//!<  Vector of 2 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec3<float>				fvec3;		//!<  Vector of 3 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec4<float>				fvec4;		//!<  Vector of 4 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
-
-		//typedef f16									f16vec1;    //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec2<f16>					f16vec2;    //!< \brief Half-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec3<f16>					f16vec3;    //!< \brief Half-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec4<f16>					f16vec4;    //!< \brief Half-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
-
-		//typedef f32									f32vec1;    //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec2<f32>					f32vec2;    //!< \brief Single-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec3<f32>					f32vec3;    //!< \brief Single-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec4<f32>					f32vec4;    //!< \brief Single-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
-
-		//typedef f64									f64vec1;    //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec2<f64>					f64vec2;    //!< \brief Double-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec3<f64>					f64vec3;    //!< \brief Double-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
-		typedef detail::tvec4<f64>					f64vec4;    //!< \brief Double-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
-
-		//////////////////////
-		// Float matrix types 
-
-		//typedef f32									fmat1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x2<f32>				fmat2;	//!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x3<f32>				fmat3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x4<f32>				fmat4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
-
-		//typedef f32									fmat1x1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x2<f32>				fmat2x2;  //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x3<f32>				fmat2x3;	//!< \brief Single-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x4<f32>				fmat2x4;	//!< \brief Single-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x2<f32>				fmat3x2;	//!< \brief Single-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x3<f32>				fmat3x3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x4<f32>				fmat3x4;	//!< \brief Single-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x2<f32>				fmat4x2;	//!< \brief Single-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x3<f32>				fmat4x3;	//!< \brief Single-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x4<f32>				fmat4x4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
-
-		//typedef f16									f16mat1;    //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x2<f16>				f16mat2;	//!< \brief Half-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x3<f16>				f16mat3;	//!< \brief Half-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x4<f16>				f16mat4;	//!< \brief Half-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
-
-		//typedef f16									f16mat1x1;	//!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x2<f16>				f16mat2x2;	//!< \brief Half-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x3<f16>				f16mat2x3;	//!< \brief Half-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x4<f16>				f16mat2x4;	//!< \brief Half-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x2<f16>				f16mat3x2;	//!< \brief Half-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x3<f16>				f16mat3x3;	//!< \brief Half-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x4<f16>				f16mat3x4;	//!< \brief Half-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x2<f16>				f16mat4x2;	//!< \brief Half-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x3<f16>				f16mat4x3;	//!< \brief Half-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x4<f16>				f16mat4x4;	//!< \brief Half-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
-
-		//typedef f32									f32mat1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x2<f32>				f32mat2;	//!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x3<f32>				f32mat3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x4<f32>				f32mat4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
-
-		//typedef f32									f32mat1x1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x2<f32>				f32mat2x2;  //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x3<f32>				f32mat2x3;	//!< \brief Single-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x4<f32>				f32mat2x4;	//!< \brief Single-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x2<f32>				f32mat3x2;	//!< \brief Single-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x3<f32>				f32mat3x3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x4<f32>				f32mat3x4;	//!< \brief Single-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x2<f32>				f32mat4x2;	//!< \brief Single-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x3<f32>				f32mat4x3;	//!< \brief Single-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x4<f32>				f32mat4x4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
-
-		//typedef f64									f64mat1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x2<f64>				f64mat2;	//!< \brief Double-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x3<f64>				f64mat3;	//!< \brief Double-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x4<f64>				f64mat4;	//!< \brief Double-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
-
-		//typedef f64									f64mat1x1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x2<f64>				f64mat2x2;	//!< \brief Double-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x3<f64>				f64mat2x3;	//!< \brief Double-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat2x4<f64>				f64mat2x4;	//!< \brief Double-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x2<f64>				f64mat3x2;	//!< \brief Double-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x3<f64>				f64mat3x3;	//!< \brief Double-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat3x4<f64>				f64mat3x4;	//!< \brief Double-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x2<f64>				f64mat4x2;	//!< \brief Double-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x3<f64>				f64mat4x3;	//!< \brief Double-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
-		typedef detail::tmat4x4<f64>				f64mat4x4;	//!< \brief Double-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
-
-		//////////////////////////
-		// Float quaternion types 
-
-		typedef detail::tquat<f16>					f16quat;    //!< \brief Half-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
-		typedef detail::tquat<f32>					f32quat;    //!< \brief Single-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
-		typedef detail::tquat<f64>					f64quat;    //!< \brief Double-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
-
-		///@}
-
-	}//namespace type_precision
-	}//namespace gtc
+	///////////////////////////
+	// Dependences
+
+	using namespace gtc::half_float;
+	using namespace gtc::quaternion;
+
+	///////////////////////////
+	// Signed int vector types 
+
+	/// \addtogroup gtc_type_precision
+	///@{
+
+	typedef detail::int8						int8;         //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef detail::int16						int16;        //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef detail::int32						int32;        //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef detail::int64						int64;        //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension)
+
+	typedef int8								i8;         //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef int16								i16;        //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef int32								i32;        //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef int64								i64;        //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension)
+
+	//typedef i8									i8vec1;		//!< \brief 8bit signed integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<i8>					i8vec2;     //!< \brief 8bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<i8>					i8vec3;     //!< \brief 8bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<i8>					i8vec4;     //!< \brief 8bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef i16									i16vec1;	//!< \brief 16bit signed integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<i16>					i16vec2;    //!< \brief 16bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<i16>					i16vec3;    //!< \brief 16bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<i16>					i16vec4;    //!< \brief 16bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef i32									i32vec1;	//!< \brief 32bit signed integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<i32>					i32vec2;    //!< \brief 32bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<i32>					i32vec3;    //!< \brief 32bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<i32>					i32vec4;    //!< \brief 32bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef i64									i64vec1;	//!< \brief 32bit signed integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<i64>					i64vec2;    //!< \brief 64bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<i64>					i64vec3;    //!< \brief 64bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<i64>					i64vec4;    //!< \brief 64bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	/////////////////////////////
+	// Unsigned int vector types 
+
+	typedef detail::uint8						uint8;         //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef detail::uint16						uint16;        //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef detail::uint32						uint32;        //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef detail::uint64						uint64;        //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension)
+
+	typedef uint8								u8;         //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef uint16								u16;        //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef uint32								u32;        //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef uint64								u64;        //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension)
+
+	//typedef u8									u8vec1;		//!< \brief 8bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<u8>					u8vec2;     //!< \brief 8bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<u8>					u8vec3;     //!< \brief 8bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<u8>					u8vec4;     //!< \brief 8bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef u16									u16vec1;    //!< \brief 16bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<u16>					u16vec2;    //!< \brief 16bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<u16>					u16vec3;    //!< \brief 16bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<u16>					u16vec4;    //!< \brief 16bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef u32									u32vec1;    //!< \brief 32bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<u32>					u32vec2;    //!< \brief 32bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<u32>					u32vec3;    //!< \brief 32bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<u32>					u32vec4;    //!< \brief 32bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef u64									u64vec1;    //!< \brief 64bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<u64>					u64vec2;    //!< \brief 64bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<u64>					u64vec3;    //!< \brief 64bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<u64>					u64vec4;    //!< \brief 64bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//////////////////////
+	// Float vector types 
+
+	typedef detail::float16						float16;	//!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::float32						float32;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::float64						float64;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+
+	typedef float16								f16;        //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef float32								f32;        //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef float64								f64;        //!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+
+	typedef detail::tvec2<float>				fvec2;		//!<  Vector of 2 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<float>				fvec3;		//!<  Vector of 3 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<float>				fvec4;		//!<  Vector of 4 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
+
+	//typedef f16									f16vec1;    //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<f16>					f16vec2;    //!< \brief Half-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<f16>					f16vec3;    //!< \brief Half-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<f16>					f16vec4;    //!< \brief Half-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef f32									f32vec1;    //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<f32>					f32vec2;    //!< \brief Single-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<f32>					f32vec3;    //!< \brief Single-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<f32>					f32vec4;    //!< \brief Single-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//typedef f64									f64vec1;    //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec2<f64>					f64vec2;    //!< \brief Double-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec3<f64>					f64vec3;    //!< \brief Double-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::tvec4<f64>					f64vec4;    //!< \brief Double-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	//////////////////////
+	// Float matrix types 
+
+	//typedef f32									fmat1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f32>				fmat2;	//!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f32>				fmat3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f32>				fmat4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f32									fmat1x1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f32>				fmat2x2;  //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x3<f32>				fmat2x3;	//!< \brief Single-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x4<f32>				fmat2x4;	//!< \brief Single-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x2<f32>				fmat3x2;	//!< \brief Single-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f32>				fmat3x3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x4<f32>				fmat3x4;	//!< \brief Single-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x2<f32>				fmat4x2;	//!< \brief Single-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x3<f32>				fmat4x3;	//!< \brief Single-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f32>				fmat4x4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f16									f16mat1;    //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f16>				f16mat2;	//!< \brief Half-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f16>				f16mat3;	//!< \brief Half-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f16>				f16mat4;	//!< \brief Half-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f16									f16mat1x1;	//!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f16>				f16mat2x2;	//!< \brief Half-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x3<f16>				f16mat2x3;	//!< \brief Half-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x4<f16>				f16mat2x4;	//!< \brief Half-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x2<f16>				f16mat3x2;	//!< \brief Half-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f16>				f16mat3x3;	//!< \brief Half-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x4<f16>				f16mat3x4;	//!< \brief Half-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x2<f16>				f16mat4x2;	//!< \brief Half-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x3<f16>				f16mat4x3;	//!< \brief Half-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f16>				f16mat4x4;	//!< \brief Half-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f32									f32mat1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f32>				f32mat2;	//!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f32>				f32mat3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f32>				f32mat4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f32									f32mat1x1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f32>				f32mat2x2;  //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x3<f32>				f32mat2x3;	//!< \brief Single-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x4<f32>				f32mat2x4;	//!< \brief Single-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x2<f32>				f32mat3x2;	//!< \brief Single-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f32>				f32mat3x3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x4<f32>				f32mat3x4;	//!< \brief Single-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x2<f32>				f32mat4x2;	//!< \brief Single-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x3<f32>				f32mat4x3;	//!< \brief Single-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f32>				f32mat4x4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f64									f64mat1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f64>				f64mat2;	//!< \brief Double-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f64>				f64mat3;	//!< \brief Double-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f64>				f64mat4;	//!< \brief Double-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//typedef f64									f64mat1x1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f64>				f64mat2x2;	//!< \brief Double-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x3<f64>				f64mat2x3;	//!< \brief Double-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x4<f64>				f64mat2x4;	//!< \brief Double-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x2<f64>				f64mat3x2;	//!< \brief Double-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f64>				f64mat3x3;	//!< \brief Double-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x4<f64>				f64mat3x4;	//!< \brief Double-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x2<f64>				f64mat4x2;	//!< \brief Double-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x3<f64>				f64mat4x3;	//!< \brief Double-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f64>				f64mat4x4;	//!< \brief Double-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	//////////////////////////
+	// Float quaternion types 
+
+	typedef detail::tquat<f16>					f16quat;    //!< \brief Half-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
+	typedef detail::tquat<f32>					f32quat;    //!< \brief Single-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
+	typedef detail::tquat<f64>					f64quat;    //!< \brief Double-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
+
+	///@}
+
+}//namespace type_precision
+}//namespace gtc
 }//namespace glm
 
 #include "type_precision.inl"

glm/gtc/type_ptr.hpp

@@ -21,429 +21,424 @@
 #	pragma message("GLM: GLM_GTC_type_ptr extension included")
 #endif
 
-namespace glm
-{
-	namespace test{
-		void main_gtc_type_ptr();
-	}//namespace test
-
-	namespace gtc{
-	//! GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
-	namespace type_ptr{
-
-		/// \addtogroup gtc_type_ptr
-		///@{
-
-		//! Get the const address of the vector content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T const * value_ptr
-		(
-			detail::tvec2<T> const & vec
-		)
-		{
-			return &(vec.x);
-		}
-
-		//! Get the address of the vector content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T * value_ptr
-		(
-			detail::tvec2<T> & vec
-		)
-		{
-			return &(vec.x);
-		}
-
-		//! Get the const address of the vector content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T const * value_ptr
-		(
-			detail::tvec3<T> const & vec
-		)
-		{
-			return &(vec.x);
-		}
-
-		//! Get the address of the vector content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T * value_ptr
-		(
-			detail::tvec3<T> & vec
-		)
-		{
-			return &(vec.x);
-		}
+namespace glm{
+namespace gtc{
+namespace type_ptr ///< GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
+{ 
+
+	/// \addtogroup gtc_type_ptr
+	///@{
+
+	//! Get the const address of the vector content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tvec2<T> const & vec
+	)
+	{
+		return &(vec.x);
+	}
+
+	//! Get the address of the vector content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tvec2<T> & vec
+	)
+	{
+		return &(vec.x);
+	}
+
+	//! Get the const address of the vector content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tvec3<T> const & vec
+	)
+	{
+		return &(vec.x);
+	}
+
+	//! Get the address of the vector content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tvec3<T> & vec
+	)
+	{
+		return &(vec.x);
+	}
 		
-		//! Get the const address of the vector content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T const * value_ptr
-		(	
-			detail::tvec4<T> const & vec
-		)
-		{
-			return &(vec.x);
-		}
-
-		//! Get the address of the vector content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T * value_ptr
-		(	
-			detail::tvec4<T> & vec
-		)
-		{
-			return &(vec.x);
-		}
-
-		//! Get the const address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T const * value_ptr
-		(
-			detail::tmat2x2<T> const & mat
-		)
-		{
-			return &(mat[0].x);
-		}
-
-		//! Get the address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T * value_ptr
-		(
-			detail::tmat2x2<T> & mat
-		)
-		{
-			return &(mat[0].x);
-		}
+	//! Get the const address of the vector content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(	
+		detail::tvec4<T> const & vec
+	)
+	{
+		return &(vec.x);
+	}
+
+	//! Get the address of the vector content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(	
+		detail::tvec4<T> & vec
+	)
+	{
+		return &(vec.x);
+	}
+
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat2x2<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat2x2<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
 		
-		//! Get the const address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T const * value_ptr
-		(
-			detail::tmat3x3<T> const & mat
-		)
-		{
-			return &(mat[0].x);
-		}
-
-		//! Get the address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T * value_ptr
-		(
-			detail::tmat3x3<T> & mat
-		)
-		{
-			return &(mat[0].x);
-		}
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat3x3<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat3x3<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
 		
-		//! Get the const address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T const * value_ptr
-		(
-			detail::tmat4x4<T> const & mat
-		)
-		{
-			return &(mat[0].x);
-		}
-
-		//! Get the address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T * value_ptr
-		(
-			detail::tmat4x4<T> & mat
-		)
-		{
-			return &(mat[0].x);
-		}
-
-		//! Get the const address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T const * value_ptr
-		(
-			detail::tmat2x3<T> const & mat
-		)
-		{
-			return &(mat[0].x);
-		}
-
-		//! Get the address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T * value_ptr
-		(
-			detail::tmat2x3<T> & mat
-		)
-		{
-			return &(mat[0].x);
-		}
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat4x4<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat4x4<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat2x3<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat2x3<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
 		
-		//! Get the const address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T const * value_ptr
-		(
-			detail::tmat3x2<T> const & mat
-		)
-		{
-			return &(mat[0].x);
-		}
-
-		//! Get the address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T * value_ptr
-		(
-			detail::tmat3x2<T> & mat
-		)
-		{
-			return &(mat[0].x);
-		}
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat3x2<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat3x2<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
 		
-		//! Get the const address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T const * value_ptr
-		(
-			detail::tmat2x4<T> const & mat
-		)
-		{
-			return &(mat[0].x);
-		}
-
-		//! Get the address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T * value_ptr
-		(
-			detail::tmat2x4<T> & mat
-		)
-		{
-			return &(mat[0].x);
-		}
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat2x4<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat2x4<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
 		
-		//! Get the const address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T const * value_ptr
-		(
-			detail::tmat4x2<T> const & mat
-		)
-		{
-			return &(mat[0].x);
-		}
-
-		//! Get the address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T * value_ptr
-		(	
-			detail::tmat4x2<T> & mat
-		)
-		{
-			return &(mat[0].x);
-		}
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat4x2<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(	
+		detail::tmat4x2<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
 		
-		//! Get the const address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T const * value_ptr
-		(
-			detail::tmat3x4<T> const & mat
-		)
-		{
-			return &(mat[0].x);
-		}
-
-		//! Get the address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T * value_ptr
-		(
-			detail::tmat3x4<T> & mat
-		)
-		{
-			return &(mat[0].x);
-		}
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat3x4<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr
+	(
+		detail::tmat3x4<T> & mat
+	)
+	{
+		return &(mat[0].x);
+	}
 		
-		//! Get the const address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T const * value_ptr
-		(
-			detail::tmat4x3<T> const & mat
-		)
-		{
-			return &(mat[0].x);
-		}
-
-		//! Get the address of the matrix content.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat)
-		{
-			return &(mat[0].x);
-		}
-
-		//! Build a vector from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr)
-		{
-			detail::tvec2<T> Result;
-			memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>));
-			return Result;
-		}
-
-		//! Build a vector from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr)
-		{
-			detail::tvec3<T> Result;
-			memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>));
-			return Result;
-		}
-
-		//! Build a vector from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr)
-		{
-			detail::tvec4<T> Result;
-			memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>));
-			return Result;
-		}
-
-		//! Build a matrix from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr)
-		{
-			detail::tmat2x2<T> Result;
-			memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>));
-			return Result;
-		}
+	//! Get the const address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T const * value_ptr
+	(
+		detail::tmat4x3<T> const & mat
+	)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Get the address of the matrix content.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat)
+	{
+		return &(mat[0].x);
+	}
+
+	//! Build a vector from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr)
+	{
+		detail::tvec2<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>));
+		return Result;
+	}
+
+	//! Build a vector from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr)
+	{
+		detail::tvec3<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>));
+		return Result;
+	}
+
+	//! Build a vector from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr)
+	{
+		detail::tvec4<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>));
+		return Result;
+	}
+
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr)
+	{
+		detail::tmat2x2<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>));
+		return Result;
+	}
         
-		//! Build a matrix from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr)
-		{
-			detail::tmat2x3<T> Result;
-			memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>));
-			return Result;
-		}
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr)
+	{
+		detail::tmat2x3<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>));
+		return Result;
+	}
         
-		//! Build a matrix from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr)
-		{
-			detail::tmat2x4<T> Result;
-			memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>));
-			return Result;
-		}
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr)
+	{
+		detail::tmat2x4<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>));
+		return Result;
+	}
         
-		//! Build a matrix from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr)
-		{
-			detail::tmat3x2<T> Result;
-			memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>));
-			return Result;
-		}
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr)
+	{
+		detail::tmat3x2<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>));
+		return Result;
+	}
         
-		//! Build a matrix from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr)
-		{
-			detail::tmat3x3<T> Result;
-			memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>));
-			return Result;
-		}
-
-		//! Build a matrix from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr)
-		{
-			detail::tmat3x4<T> Result;
-			memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>));
-			return Result;
-		}
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr)
+	{
+		detail::tmat3x3<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>));
+		return Result;
+	}
+
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr)
+	{
+		detail::tmat3x4<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>));
+		return Result;
+	}
 
         
-		//! Build a matrix from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr)
-		{
-			detail::tmat4x2<T> Result;
-			memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>));
-			return Result;
-		}
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr)
+	{
+		detail::tmat4x2<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>));
+		return Result;
+	}
         
-		//! Build a matrix from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr)
-		{
-			detail::tmat4x3<T> Result;
-			memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>));
-			return Result;
-		}
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr)
+	{
+		detail::tmat4x3<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>));
+		return Result;
+	}
         
-		//! Build a matrix from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr)
-		{
-			detail::tmat4x4<T> Result;
-			memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>));
-			return Result;
-		}
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr)
+	{
+		detail::tmat4x4<T> Result;
+		memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>));
+		return Result;
+	}
         
-		//! Build a matrix from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr)
-		{
-			return make_mat2x2(ptr);
-		}
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr)
+	{
+		return make_mat2x2(ptr);
+	}
         
-		//! Build a matrix from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr)
-		{
-			return make_mat3x3(ptr);
-		}
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr)
+	{
+		return make_mat3x3(ptr);
+	}
 		
-		//! Build a matrix from a pointer.
-		//! From GLM_GTC_type_ptr extension.
-		template<typename T>
-		GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr)
-		{
-			return make_mat4x4(ptr);
-		}
+	//! Build a matrix from a pointer.
+	//! From GLM_GTC_type_ptr extension.
+	template<typename T>
+	GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr)
+	{
+		return make_mat4x4(ptr);
+	}
         
-		///@}
+	///@}
 
-	}//namespace type_ptr
-	}//namespace gtc
+}//namespace type_ptr
+}//namespace gtc
 }//namespace glm
 
 #include "type_ptr.inl"

glm/gtx/associated_min_max.hpp

@@ -21,68 +21,59 @@
 #	pragma message("GLM: GLM_GTX_associated_min_max extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace associated_min_max ///< GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
 {
-	namespace test{
-		void main_gtx_associated_min_max();
-	}//namespace test
-
-	namespace gtx
-	{
-		//! GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
-		namespace associated_min_max
-		{
-			/// \addtogroup gtx_associated_min_max
-			///@{
-
-			//! \brief Min comparison between 2 variables
-			template<typename genTypeT, typename genTypeU>
-			genTypeU associatedMin(
-				const genTypeT& x, const genTypeU& a, 
-				const genTypeT& y, const genTypeU& b);
-
-			//! \brief Min comparison between 3 variables
-			template<typename genTypeT, typename genTypeU>
-			genTypeU associatedMin(
-				const genTypeT& x, const genTypeU& a, 
-				const genTypeT& y, const genTypeU& b, 
-				const genTypeT& z, const genTypeU& c);
-
-			//! \brief Min comparison between 4 variables
-			template<typename genTypeT, typename genTypeU>
-			genTypeU associatedMin(
-				const genTypeT& x, const genTypeU& a, 
-				const genTypeT& y, const genTypeU& b, 
-				const genTypeT& z, const genTypeU& c, 
-				const genTypeT& w, const genTypeU& d);
-
-			//! \brief Max comparison between 2 variables
-			template<typename genTypeT, typename genTypeU>
-			genTypeU associatedMax(
-				const genTypeT& x, const genTypeU& a, 
-				const genTypeT& y, const genTypeU& b);
-
-			//! \brief Max comparison between 3 variables
-			template<typename genTypeT, typename genTypeU>
-			genTypeU associatedMax(
-				const genTypeT& x, const genTypeU& a, 
-				const genTypeT& y, const genTypeU& b, 
-				const genTypeT& z, const genTypeU& c);
-
-			//! \brief Max comparison between 4 variables
-			template<typename genTypeT, typename genTypeU>
-			genTypeU associatedMax(
-				const genTypeT& x, const genTypeU& a, 
-				const genTypeT& y, const genTypeU& b, 
-				const genTypeT& z, const genTypeU& c, 
-				const genTypeT& w, const genTypeU& d);
-			///@}
-
-		}//namespace associated_min_max
-
-		bool test();
-	}//namespace gtx
-}//namespace glm
+	/// \addtogroup gtx_associated_min_max
+	///@{
+
+	//! \brief Min comparison between 2 variables
+	template<typename genTypeT, typename genTypeU>
+	genTypeU associatedMin(
+		const genTypeT& x, const genTypeU& a, 
+		const genTypeT& y, const genTypeU& b);
+
+	//! \brief Min comparison between 3 variables
+	template<typename genTypeT, typename genTypeU>
+	genTypeU associatedMin(
+		const genTypeT& x, const genTypeU& a, 
+		const genTypeT& y, const genTypeU& b, 
+		const genTypeT& z, const genTypeU& c);
+
+	//! \brief Min comparison between 4 variables
+	template<typename genTypeT, typename genTypeU>
+	genTypeU associatedMin(
+		const genTypeT& x, const genTypeU& a, 
+		const genTypeT& y, const genTypeU& b, 
+		const genTypeT& z, const genTypeU& c, 
+		const genTypeT& w, const genTypeU& d);
+
+	//! \brief Max comparison between 2 variables
+	template<typename genTypeT, typename genTypeU>
+	genTypeU associatedMax(
+		const genTypeT& x, const genTypeU& a, 
+		const genTypeT& y, const genTypeU& b);
+
+	//! \brief Max comparison between 3 variables
+	template<typename genTypeT, typename genTypeU>
+	genTypeU associatedMax(
+		const genTypeT& x, const genTypeU& a, 
+		const genTypeT& y, const genTypeU& b, 
+		const genTypeT& z, const genTypeU& c);
+
+	//! \brief Max comparison between 4 variables
+	template<typename genTypeT, typename genTypeU>
+	genTypeU associatedMax(
+		const genTypeT& x, const genTypeU& a, 
+		const genTypeT& y, const genTypeU& b, 
+		const genTypeT& z, const genTypeU& c, 
+		const genTypeT& w, const genTypeU& d);
+
+	///@}
+} //namespace associated_min_max
+} //namespace gtx
+} //namespace glm
 
 #include "associated_min_max.inl"
 

glm/gtx/bit.hpp

@@ -22,106 +22,99 @@
 #	pragma message("GLM: GLM_GTX_bit extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace bit ///< GLM_GTX_bit extension: Allow to perform bit operations on integer values
 {
-	namespace test{
-		void main_gtx_bit();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_bit extension: Allow to perform bit operations on integer values
-	namespace bit
-	{
-		using namespace gtc::half_float;
-
-		/// \addtogroup gtx_bit
-		///@{
-
-		//! Build a mask of 'count' bits
-		//! From GLM_GTX_bit extension.
-		template <typename genIType>
-		genIType mask(genIType const & count);
-
-		//! Component wise extraction of bit fields.
-		//! genType and genIType could be a scalar or a vector.
-		//! From GLM_GTX_bit extension.
-		template <typename genIUType, typename sizeType>
-		genIUType extractField(
-			genIUType const & v, 
-			sizeType const & first, 
-			sizeType const & count);
-
-		//! Find the lowest bit set to 1 in a integer variable.
-		//! From GLM_GTX_bit extension.
-		template <typename genType> 
-		int lowestBit(genType const & value);
-
-		//! Find the highest bit set to 1 in a integer variable.
-		//! From GLM_GTX_bit extension.
-		template <typename genType> 
-		int highestBit(genType const & value);
-
-		//! Find the highest bit set to 1 in a integer variable and return its value. 
-		//! From GLM_GTX_bit extension.
-		template <typename genType> 
-		genType highestBitValue(genType const & value);
-
-		//! Return true if the value is a power of two number. 
-		//! From GLM_GTX_bit extension. 
-		template <typename genType> 
-		bool isPowerOfTwo(genType const & value);
-
-		//! Return the power of two number which value is just higher the input value.
-		//! From GLM_GTX_bit extension.
-		template <typename genType> 
-		genType powerOfTwoAbove(genType const & value);
-
-		//! Return the power of two number which value is just lower the input value. 
-		//! From GLM_GTX_bit extension.
-		template <typename genType> 
-		genType powerOfTwoBelow(genType const & value);
-
-		//! Return the power of two number which value is the closet to the input value. 
-		//! From GLM_GTX_bit extension.
-		template <typename genType> 
-		genType powerOfTwoNearest(genType const & value);
-
-		//! Revert all bits of any integer based type. 
-		//! From GLM_GTX_bit extension.
-		template <typename genType> 
-		genType bitRevert(genType const & value);
-
-		//! Rotate all bits to the right.
-		//! From GLM_GTX_bit extension.
-		template <typename genType>
-		genType bitRotateRight(genType const & In, std::size_t Shift);
-
-		//! Rotate all bits to the left.
-		//! From GLM_GTX_bit extension.
-		template <typename genType>
-		genType bitRotateLeft(genType const & In, std::size_t Shift);
-
-		//! Set to 1 a range of bits.
-		//! From GLM_GTX_bit extension.
-		template <typename genIUType>
-		genIUType fillBitfieldWithOne(
-			genIUType const & Value,
-			int const & FromBit, 
-			int const & ToBit);
-
-		//! Set to 0 a range of bits.
-		//! From GLM_GTX_bit extension.
-		template <typename genIUType>
-		genIUType fillBitfieldWithZero(
-			genIUType const & Value,
-			int const & FromBit, 
-			int const & ToBit);
-
-		///@}
-
-	}//namespace bit
-	}//namespace gtx
-}//namespace glm
+	using namespace gtc::half_float;
+
+	/// \addtogroup gtx_bit
+	///@{
+
+	//! Build a mask of 'count' bits
+	//! From GLM_GTX_bit extension.
+	template <typename genIType>
+	genIType mask(genIType const & count);
+
+	//! Component wise extraction of bit fields.
+	//! genType and genIType could be a scalar or a vector.
+	//! From GLM_GTX_bit extension.
+	template <typename genIUType, typename sizeType>
+	genIUType extractField(
+		genIUType const & v, 
+		sizeType const & first, 
+		sizeType const & count);
+
+	//! Find the lowest bit set to 1 in a integer variable.
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	int lowestBit(genType const & value);
+
+	//! Find the highest bit set to 1 in a integer variable.
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	int highestBit(genType const & value);
+
+	//! Find the highest bit set to 1 in a integer variable and return its value. 
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	genType highestBitValue(genType const & value);
+
+	//! Return true if the value is a power of two number. 
+	//! From GLM_GTX_bit extension. 
+	template <typename genType> 
+	bool isPowerOfTwo(genType const & value);
+
+	//! Return the power of two number which value is just higher the input value.
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	genType powerOfTwoAbove(genType const & value);
+
+	//! Return the power of two number which value is just lower the input value. 
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	genType powerOfTwoBelow(genType const & value);
+
+	//! Return the power of two number which value is the closet to the input value. 
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	genType powerOfTwoNearest(genType const & value);
+
+	//! Revert all bits of any integer based type. 
+	//! From GLM_GTX_bit extension.
+	template <typename genType> 
+	genType bitRevert(genType const & value);
+
+	//! Rotate all bits to the right.
+	//! From GLM_GTX_bit extension.
+	template <typename genType>
+	genType bitRotateRight(genType const & In, std::size_t Shift);
+
+	//! Rotate all bits to the left.
+	//! From GLM_GTX_bit extension.
+	template <typename genType>
+	genType bitRotateLeft(genType const & In, std::size_t Shift);
+
+	//! Set to 1 a range of bits.
+	//! From GLM_GTX_bit extension.
+	template <typename genIUType>
+	genIUType fillBitfieldWithOne(
+		genIUType const & Value,
+		int const & FromBit, 
+		int const & ToBit);
+
+	//! Set to 0 a range of bits.
+	//! From GLM_GTX_bit extension.
+	template <typename genIUType>
+	genIUType fillBitfieldWithZero(
+		genIUType const & Value,
+		int const & FromBit, 
+		int const & ToBit);
+
+	/// @}
+}// namespace bit
+}// namespace gtx
+}// namespace glm
 
 #include "bit.inl"
 

glm/gtx/closest_point.hpp

@@ -20,31 +20,25 @@
 #	pragma message("GLM: GLM_GTX_closest_point extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace closest_point ///< GLM_GTX_closest_point extension: Find the point on a straight line which is the closet of a point.
 {
-	namespace test{
-		void main_gtx_closest_point();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_closest_point extension: Find the point on a straight line which is the closet of a point.
-	namespace closest_point{
-
 	/// \addtogroup gtx_closest_point
-	///@{
+	/// @{
 
-	//! Find the point on a straight line which is the closet of a point. 
-	//! From GLM_GTX_closest_point extension.
+	/// Find the point on a straight line which is the closet of a point. 
+	/// From GLM_GTX_closest_point extension.
 	template <typename T> 
 	detail::tvec3<T> closestPointOnLine(
 		detail::tvec3<T> const & point, 
 		detail::tvec3<T> const & a, 
 		detail::tvec3<T> const & b);
-	///@}
 
-	}//namespace closest_point
-	}//namespace gtx
-}//namespace glm
+	/// @}
+}// namespace closest_point
+}// namespace gtx
+}// namespace glm
 
 #include "closest_point.inl"
 

glm/gtx/color_cast.hpp

@@ -22,88 +22,82 @@
 #	pragma message("GLM: GLM_GTX_color_cast extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace color_cast ///< GLM_GTX_color_cast extension: Conversion between two color types
 {
-	namespace test{
-		void main_ext_gtx_color_cast();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_color_cast extension: Conversion between two color types
-	namespace color_cast
-	{
-		using namespace gtx::number_precision;
-
-		/// \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::type_precision::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::type_precision::uint16 u16channel_cast(valType a);
-
-		template <typename T> gtc::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::number_precision::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> gtc::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::number_precision::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> gtc::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::number_precision::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> gtc::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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 color_space
-	}//namespace gtx
+	using namespace gtx::number_precision;
+
+	/// \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::type_precision::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::type_precision::uint16 u16channel_cast(valType a);
+
+	template <typename T> gtc::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::number_precision::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> gtc::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::number_precision::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> gtc::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::number_precision::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> gtc::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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::type_precision::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 color_space
+}//namespace gtx
 }//namespace glm
 
 #include "color_cast.inl"

glm/gtx/color_space.hpp

@@ -20,61 +20,54 @@
 #	pragma message("GLM: GLM_GTX_color_space extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace color_space ///< GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
 {
-	namespace test{
-		void main_gtx_color_space();
-	}//namespace test
+	/// \addtogroup gtx_color_space
+	/// @{
 
-    namespace gtx{
-	//! GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
-    namespace color_space
-    {
-		/// \addtogroup gtx_color_space
-		///@{
+	//! Converts a color from HSV color space to its color in RGB color space.
+	//! From GLM_GTX_color_space extension.
+    template <typename valType> 
+	detail::tvec3<valType> rgbColor(
+		detail::tvec3<valType> const & hsvValue);
 
-		//! Converts a color from HSV color space to its color in RGB color space.
-		//! From GLM_GTX_color_space extension.
-        template <typename valType> 
-		detail::tvec3<valType> rgbColor(
-			detail::tvec3<valType> const & hsvValue);
-
-		//! Converts a color from RGB color space to its color in HSV color space.
-		//! From GLM_GTX_color_space extension.
-        template <typename valType> 
-		detail::tvec3<valType> hsvColor(
-			detail::tvec3<valType> const & rgbValue);
+	//! Converts a color from RGB color space to its color in HSV color space.
+	//! From GLM_GTX_color_space extension.
+    template <typename valType> 
+	detail::tvec3<valType> hsvColor(
+		detail::tvec3<valType> const & rgbValue);
 		
-		//! Build a saturation matrix.
-		//! From GLM_GTX_color_space extension
-        template <typename valType> 
-		detail::tmat4x4<valType> saturation(
-			valType const s);
+	//! Build a saturation matrix.
+	//! From GLM_GTX_color_space extension
+    template <typename valType> 
+	detail::tmat4x4<valType> saturation(
+		valType const s);
 
-        //! Modify the saturation of a color.
-		//! From GLM_GTX_color_space extension.
-		template <typename valType> 
-		detail::tvec3<valType> saturation(
-			valType const s, 
-			detail::tvec3<valType> const & color);
+    //! Modify the saturation of a color.
+	//! From GLM_GTX_color_space extension.
+	template <typename valType> 
+	detail::tvec3<valType> saturation(
+		valType const s, 
+		detail::tvec3<valType> const & color);
 		
-		//! Modify the saturation of a color.
-		//! From GLM_GTX_color_space extension.
-        template <typename valType> 
-		detail::tvec4<valType> saturation(
-			valType const s, 
-			detail::tvec4<valType> const & color);
+	//! Modify the saturation of a color.
+	//! From GLM_GTX_color_space extension.
+    template <typename valType> 
+	detail::tvec4<valType> saturation(
+		valType const s, 
+		detail::tvec4<valType> const & color);
 		
-		//! Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
-		//! From GLM_GTX_color_space extension.
-		template <typename valType> 
-		valType luminosity(
-			detail::tvec3<valType> const & color);
+	//! Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
+	//! From GLM_GTX_color_space extension.
+	template <typename valType> 
+	valType luminosity(
+		detail::tvec3<valType> const & color);
 
-		///@}
-		
-	}//namespace color_space
-	}//namespace gtx
+	/// @}
+}//namespace color_space
+}//namespace gtx
 }//namespace glm
 
 #include "color_space.inl"

glm/gtx/color_space_YCoCg.hpp

@@ -20,48 +20,42 @@
 #	pragma message("GLM: GLM_GTX_color_space_YCoCg extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace color_space_YCoCg ///< GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
 {
-	namespace test{
-		void main_gtx_color_space_YCoCg();
-	}//namespace test
+	/// \addtogroup gtx_color_space_YCoCg
+	///@{
 
-    namespace gtx{
-	//! GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
-    namespace color_space_YCoCg
-    {
-		/// \addtogroup gtx_color_space_YCoCg
-		///@{
+    //! Convert a color from RGB color space to YCoCg color space.
+	//! From GLM_GTX_color_space_YCoCg extension.
+	template <typename valType> 
+	detail::tvec3<valType> rgb2YCoCg(
+		detail::tvec3<valType> const & rgbColor);
 
-        //! Convert a color from RGB color space to YCoCg color space.
-		//! From GLM_GTX_color_space_YCoCg extension.
-		template <typename valType> 
-		detail::tvec3<valType> rgb2YCoCg(
-			detail::tvec3<valType> const & rgbColor);
+    //! Convert a color from YCoCg color space to RGB color space.
+	//! From GLM_GTX_color_space_YCoCg extension.
+    template <typename valType> 
+	detail::tvec3<valType> YCoCg2rgb(
+		detail::tvec3<valType> const & YCoCgColor);
 
-        //! Convert a color from YCoCg color space to RGB color space.
-		//! From GLM_GTX_color_space_YCoCg extension.
-        template <typename valType> 
-		detail::tvec3<valType> YCoCg2rgb(
-			detail::tvec3<valType> const & YCoCgColor);
+    //! Convert a color from RGB color space to YCoCgR color space.
+	//! \see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
+	//! From GLM_GTX_color_space_YCoCg extension.
+	template <typename valType> 
+	detail::tvec3<valType> rgb2YCoCgR(
+		detail::tvec3<valType> const & rgbColor);
 
-        //! Convert a color from RGB color space to YCoCgR color space.
-		//! \see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
-		//! From GLM_GTX_color_space_YCoCg extension.
-		template <typename valType> 
-		detail::tvec3<valType> rgb2YCoCgR(
-			detail::tvec3<valType> const & rgbColor);
+    //! Convert a color from YCoCgR color space to RGB color space.
+	//! \see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
+	//! From GLM_GTX_color_space_YCoCg extension.
+    template <typename valType> 
+	detail::tvec3<valType> YCoCgR2rgb(
+		detail::tvec3<valType> const & YCoCgColor);
 
-        //! Convert a color from YCoCgR color space to RGB color space.
-		//! \see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
-		//! From GLM_GTX_color_space_YCoCg extension.
-        template <typename valType> 
-		detail::tvec3<valType> YCoCgR2rgb(
-			detail::tvec3<valType> const & YCoCgColor);
-
-		///@}
-	}//namespace color_space_YCoCg
-	}//namespace gtx
+	/// @}
+}//namespace color_space_YCoCg
+}//namespace gtx
 }//namespace glm
 
 #include "color_space_YCoCg.inl"

glm/gtx/compatibility.hpp

@@ -28,136 +28,129 @@
 #include <cmath>
 #endif//GLM_COMPILER
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace compatibility ///< GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
 {
-	namespace test{
-		void main_gtx_compatibility();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
-	namespace compatibility
-	{
-		/// \addtogroup gtx_compatibility
-		///@{
-
-		template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}																					//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-		template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-		template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-		template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-		template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, const detail::tvec2<T>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-		template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, const detail::tvec3<T>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-		template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, const detail::tvec4<T>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
-
-		template <typename T> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}														//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-		template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> saturate(const detail::tvec2<T>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-		template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> saturate(const detail::tvec3<T>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-		template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> saturate(const detail::tvec4<T>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
-
-		template <typename T> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}																//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-		template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> atan2(const detail::tvec2<T>& x, const detail::tvec2<T>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-		template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> atan2(const detail::tvec3<T>& x, const detail::tvec3<T>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-		template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> atan2(const detail::tvec4<T>& x, const detail::tvec4<T>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
-
-		template <typename genType> bool isfinite(genType const & x);											//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-		template <typename valType> detail::tvec2<bool> isfinite(const detail::tvec2<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-		template <typename valType> detail::tvec3<bool> isfinite(const detail::tvec3<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-		template <typename valType> detail::tvec4<bool> isfinite(const detail::tvec4<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
-
-		template <typename genType> bool isinf(genType const & x);														//!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension) 
-		template <typename genType> detail::tvec2<bool> isinf(const detail::tvec2<genType>& x);					//!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension) 
-		template <typename genType> detail::tvec3<bool> isinf(const detail::tvec3<genType>& x);					//!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension) 
-		template <typename genType> detail::tvec4<bool> isinf(const detail::tvec4<genType>& x);					//!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension) 
-
-		template <typename genType> bool isnan(genType const & x);														//!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
-		template <typename genType> detail::tvec2<bool> isnan(const detail::tvec2<genType>& x);					//!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
-		template <typename genType> detail::tvec3<bool> isnan(const detail::tvec3<genType>& x);					//!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
-		template <typename genType> detail::tvec4<bool> isnan(const detail::tvec4<genType>& x);					//!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
-
-		typedef bool						bool1;			//!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec2<bool>			bool2;			//!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec3<bool>			bool3;			//!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec4<bool>			bool4;			//!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
-
-		typedef bool						bool1x1;		//!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x2<bool>		bool2x2;		//!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x3<bool>		bool2x3;		//!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x4<bool>		bool2x4;		//!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x2<bool>		bool3x2;		//!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x3<bool>		bool3x3;		//!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x4<bool>		bool3x4;		//!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x2<bool>		bool4x2;		//!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x3<bool>		bool4x3;		//!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x4<bool>		bool4x4;		//!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
-
-		typedef int							int1;			//!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec2<int>			int2;			//!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec3<int>			int3;			//!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec4<int>			int4;			//!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
-
-		typedef int							int1x1;			//!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x2<int>		int2x2;			//!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x3<int>		int2x3;			//!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x4<int>		int2x4;			//!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x2<int>		int3x2;			//!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x3<int>		int3x3;			//!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x4<int>		int3x4;			//!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x2<int>		int4x2;			//!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-		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_float::half						half1;			//!< \brief half-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec2<gtc::half_float::half>		half2;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec3<gtc::half_float::half>		half3;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec4<gtc::half_float::half>		half4;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-
-		typedef gtc::half_float::half						half1x1;		//!< \brief half-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x2<gtc::half_float::half>		half2x2;		//!< \brief half-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x3<gtc::half_float::half>		half2x3;		//!< \brief half-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x4<gtc::half_float::half>		half2x4;		//!< \brief half-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x2<gtc::half_float::half>		half3x2;		//!< \brief half-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x3<gtc::half_float::half>		half3x3;		//!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x4<gtc::half_float::half>		half3x4;		//!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x2<gtc::half_float::half>		half4x2;		//!< \brief half-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x3<gtc::half_float::half>		half4x3;		//!< \brief half-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x4<gtc::half_float::half>		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)
-		typedef detail::tvec3<float>		float3;			//!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec4<float>		float4;			//!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
-
-		typedef float						float1x1;		//!< \brief single-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x2<float>		float2x2;		//!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x3<float>		float2x3;		//!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x4<float>		float2x4;		//!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x2<float>		float3x2;		//!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x3<float>		float3x3;		//!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x4<float>		float3x4;		//!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x2<float>		float4x2;		//!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x3<float>		float4x3;		//!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x4<float>		float4x4;		//!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
-
-		typedef double						double1;		//!< \brief double-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec2<double>		double2;		//!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec3<double>		double3;		//!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tvec4<double>		double4;		//!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
-
-		typedef double						double1x1;		//!< \brief double-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x2<double>		double2x2;		//!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x3<double>		double2x3;		//!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat2x4<double>		double2x4;		//!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x2<double>		double3x2;		//!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x3<double>		double3x3;		//!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat3x4<double>		double3x4;		//!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x2<double>		double4x2;		//!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x3<double>		double4x3;		//!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
-		typedef detail::tmat4x4<double>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
-
-		///@}
-
-	}//namespace compatibility
-	}//namespace gtx
+	/// \addtogroup gtx_compatibility
+	///@{
+
+	template <typename T> GLM_FUNC_QUALIFIER T lerp(T x, T y, T a){return mix(x, y, a);}																					//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, const detail::tvec2<T>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, const detail::tvec3<T>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, const detail::tvec4<T>& a){return mix(x, y, a);}	//!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
+
+	template <typename T> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));}														//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> saturate(const detail::tvec2<T>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> saturate(const detail::tvec3<T>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> saturate(const detail::tvec4<T>& x){return clamp(x, T(0), T(1));}					//!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
+
+	template <typename T> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);}																//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> atan2(const detail::tvec2<T>& x, const detail::tvec2<T>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> atan2(const detail::tvec3<T>& x, const detail::tvec3<T>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+	template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> atan2(const detail::tvec4<T>& x, const detail::tvec4<T>& y){return atan(x, y);}	//!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
+
+	template <typename genType> bool isfinite(genType const & x);											//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template <typename valType> detail::tvec2<bool> isfinite(const detail::tvec2<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template <typename valType> detail::tvec3<bool> isfinite(const detail::tvec3<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+	template <typename valType> detail::tvec4<bool> isfinite(const detail::tvec4<valType>& x);				//!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
+
+	template <typename genType> bool isinf(genType const & x);														//!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension) 
+	template <typename genType> detail::tvec2<bool> isinf(const detail::tvec2<genType>& x);					//!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension) 
+	template <typename genType> detail::tvec3<bool> isinf(const detail::tvec3<genType>& x);					//!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension) 
+	template <typename genType> detail::tvec4<bool> isinf(const detail::tvec4<genType>& x);					//!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension) 
+
+	template <typename genType> bool isnan(genType const & x);														//!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
+	template <typename genType> detail::tvec2<bool> isnan(const detail::tvec2<genType>& x);					//!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
+	template <typename genType> detail::tvec3<bool> isnan(const detail::tvec3<genType>& x);					//!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
+	template <typename genType> detail::tvec4<bool> isnan(const detail::tvec4<genType>& x);					//!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
+
+	typedef bool						bool1;			//!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec2<bool>			bool2;			//!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec3<bool>			bool3;			//!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec4<bool>			bool4;			//!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef bool						bool1x1;		//!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x2<bool>		bool2x2;		//!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x3<bool>		bool2x3;		//!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x4<bool>		bool2x4;		//!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x2<bool>		bool3x2;		//!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x3<bool>		bool3x3;		//!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x4<bool>		bool3x4;		//!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x2<bool>		bool4x2;		//!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x3<bool>		bool4x3;		//!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x4<bool>		bool4x4;		//!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef int							int1;			//!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec2<int>			int2;			//!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec3<int>			int3;			//!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec4<int>			int4;			//!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef int							int1x1;			//!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x2<int>		int2x2;			//!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x3<int>		int2x3;			//!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x4<int>		int2x4;			//!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x2<int>		int3x2;			//!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x3<int>		int3x3;			//!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x4<int>		int3x4;			//!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x2<int>		int4x2;			//!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	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_float::half						half1;			//!< \brief half-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec2<gtc::half_float::half>		half2;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec3<gtc::half_float::half>		half3;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec4<gtc::half_float::half>		half4;			//!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+
+	typedef gtc::half_float::half						half1x1;		//!< \brief half-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x2<gtc::half_float::half>		half2x2;		//!< \brief half-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x3<gtc::half_float::half>		half2x3;		//!< \brief half-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x4<gtc::half_float::half>		half2x4;		//!< \brief half-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x2<gtc::half_float::half>		half3x2;		//!< \brief half-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x3<gtc::half_float::half>		half3x3;		//!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x4<gtc::half_float::half>		half3x4;		//!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x2<gtc::half_float::half>		half4x2;		//!< \brief half-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x3<gtc::half_float::half>		half4x3;		//!< \brief half-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x4<gtc::half_float::half>		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)
+	typedef detail::tvec3<float>		float3;			//!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec4<float>		float4;			//!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef float						float1x1;		//!< \brief single-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x2<float>		float2x2;		//!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x3<float>		float2x3;		//!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x4<float>		float2x4;		//!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x2<float>		float3x2;		//!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x3<float>		float3x3;		//!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x4<float>		float3x4;		//!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x2<float>		float4x2;		//!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x3<float>		float4x3;		//!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x4<float>		float4x4;		//!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef double						double1;		//!< \brief double-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec2<double>		double2;		//!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec3<double>		double3;		//!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tvec4<double>		double4;		//!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
+
+	typedef double						double1x1;		//!< \brief double-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x2<double>		double2x2;		//!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x3<double>		double2x3;		//!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat2x4<double>		double2x4;		//!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x2<double>		double3x2;		//!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x3<double>		double3x3;		//!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat3x4<double>		double3x4;		//!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x2<double>		double4x2;		//!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x3<double>		double4x3;		//!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
+	typedef detail::tmat4x4<double>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
+
+	/// @}
+}//namespace compatibility
+}//namespace gtx
 }//namespace glm
 
 #include "compatibility.inl"

glm/gtx/component_wise.hpp

@@ -20,47 +20,40 @@
 #	pragma message("GLM: GLM_GTX_component_wise extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace component_wise ///< GLM_GTX_component_wise extension: Operations between components of a type
 {
-	namespace test{
-		void main_gtx_component_wise();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_component_wise extension: Operations between components of a type
-	namespace component_wise
-	{
-		/// \addtogroup gtx_component_wise
-		///@{
-
-		//! Add all vector components together. 
-		//! From GLM_GTX_component_wise extension.
-		template <typename genType> 
-		typename genType::value_type compAdd(
-			genType const & v);
-
-		//! Multiply all vector components together. 
-		//! From GLM_GTX_component_wise extension.
-		template <typename genType> 
-		typename genType::value_type compMul(
-			genType const & v);
-
-		//! Find the minimum value between single vector components.
-		//! From GLM_GTX_component_wise extension.
-		template <typename genType> 
-		typename genType::value_type compMin(
-			genType const & v);
-
-		//! Find the maximum value between single vector components.
-		//! From GLM_GTX_component_wise extension.
-		template <typename genType> 
-		typename genType::value_type compMax(
-			genType const & v);
-
-		///@}
-
-	}//namespace component_wise
-	}//namespace gtx
+	/// \addtogroup gtx_component_wise
+	/// @{
+
+	//! Add all vector components together. 
+	//! From GLM_GTX_component_wise extension.
+	template <typename genType> 
+	typename genType::value_type compAdd(
+		genType const & v);
+
+	//! Multiply all vector components together. 
+	//! From GLM_GTX_component_wise extension.
+	template <typename genType> 
+	typename genType::value_type compMul(
+		genType const & v);
+
+	//! Find the minimum value between single vector components.
+	//! From GLM_GTX_component_wise extension.
+	template <typename genType> 
+	typename genType::value_type compMin(
+		genType const & v);
+
+	//! Find the maximum value between single vector components.
+	//! From GLM_GTX_component_wise extension.
+	template <typename genType> 
+	typename genType::value_type compMax(
+		genType const & v);
+
+	/// @}
+}//namespace component_wise
+}//namespace gtx
 }//namespace glm
 
 #include "component_wise.inl"

glm/gtx/epsilon.hpp

@@ -22,39 +22,32 @@
 #	pragma message("GLM: GLM_GTX_epsilon extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace epsilon ///< GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
 {
-	namespace test{
-		void main_gtx_epsilon();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
-	namespace epsilon
-	{
-		/// \addtogroup gtx_epsilon
-		///@{
-
-		//! Returns the component-wise compare of |x - y| < epsilon.
-		//! From GLM_GTX_epsilon extension.
-		template <typename genTypeT, typename genTypeU> 
-		bool equalEpsilon(
-			genTypeT const & x, 
-			genTypeT const & y, 
-			genTypeU const & epsilon);
+	/// \addtogroup gtx_epsilon
+	///@{
+
+	//! Returns the component-wise compare of |x - y| < epsilon.
+	//! From GLM_GTX_epsilon extension.
+	template <typename genTypeT, typename genTypeU> 
+	bool equalEpsilon(
+		genTypeT const & x, 
+		genTypeT const & y, 
+		genTypeU const & epsilon);
 		
-		//! Returns the component-wise compare of |x - y| >= epsilon.
-		//! From GLM_GTX_epsilon extension.
-		template <typename genTypeT, typename genTypeU>
-		bool notEqualEpsilon(
-			genTypeT const & x, 
-			genTypeT const & y, 
-			genTypeU const & epsilon);
-
-		///@}
-
-	}//namespace epsilon
-	}//namespace gtx
+	//! Returns the component-wise compare of |x - y| >= epsilon.
+	//! From GLM_GTX_epsilon extension.
+	template <typename genTypeT, typename genTypeU>
+	bool notEqualEpsilon(
+		genTypeT const & x, 
+		genTypeT const & y, 
+		genTypeU const & epsilon);
+
+	///@}
+}//namespace epsilon
+}//namespace gtx
 }//namespace glm
 
 #include "epsilon.inl"

glm/gtx/euler_angles.hpp

@@ -26,114 +26,112 @@
 #	pragma message("GLM: GLM_GTX_euler_angles extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace euler_angles ///< GLM_GTX_euler_angles extension: Build matrices from Euler angles.
 {
-    namespace gtx{
-	//! GLM_GTX_euler_angles extension: Build matrices from Euler angles.
-	namespace euler_angles
-	{
-		/// \addtogroup gtx_euler_angles
-		///@{
-
-		//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
-		//! From GLM_GTX_euler_angles extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> eulerAngleX(
-			valType const & angleX);
-
-		//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
-		//! From GLM_GTX_euler_angles extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> eulerAngleY(
-			valType const & angleY);
-
-		//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
-		//! From GLM_GTX_euler_angles extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> eulerAngleZ(
-			valType const & angleZ);
-
-		//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
-		//! From GLM_GTX_euler_angles extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> eulerAngleXY(
-			valType const & angleX, 
-			valType const & angleY);
-
-		//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
-		//! From GLM_GTX_euler_angles extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> eulerAngleYX(
-			valType const & angleY, 
-			valType const & angleX);
-
-		//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
-		//! From GLM_GTX_euler_angles extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> eulerAngleXZ(
-			valType const & angleX, 
-			valType const & angleZ);
-
-		//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
-		//! From GLM_GTX_euler_angles extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> eulerAngleZX(
-			valType const & angleZ, 
-			valType const & angleX);
-
-		//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
-		//! From GLM_GTX_euler_angles extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> eulerAngleYZ(
-			valType const & angleY, 
-			valType const & angleZ);
-
-		//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
-		//! From GLM_GTX_euler_angles extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> eulerAngleZY(
-			valType const & angleZ, 
-			valType const & angleY);
-
-		//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
-		//! From GLM_GTX_euler_angles extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> eulerAngleYXZ(
-			valType const & yaw, 
-			valType const & pitch, 
-			valType const & roll);
-
-		//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
-		//! From GLM_GTX_euler_angles extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> yawPitchRoll(
-			valType const & yaw, 
-			valType const & pitch, 
-			valType const & roll);
-
-		//! Creates a 2D 2 * 2 rotation matrix from an euler angle.
-		//! From GLM_GTX_euler_angles extension.
-		template <typename T> 
-		detail::tmat2x2<T> orientate2(T const & angle);
-
-		//! Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.
-		//! From GLM_GTX_euler_angles extension.
-		template <typename T> 
-		detail::tmat3x3<T> orientate3(T const & angle);
-
-		//! Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z). 
-		//! From GLM_GTX_euler_angles extension.
-		template <typename T> 
-		detail::tmat3x3<T> orientate3(detail::tvec3<T> const & angles);
+	/// \addtogroup gtx_euler_angles
+	/// @{
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleX(
+		valType const & angleX);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleY(
+		valType const & angleY);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleZ(
+		valType const & angleZ);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleXY(
+		valType const & angleX, 
+		valType const & angleY);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleYX(
+		valType const & angleY, 
+		valType const & angleX);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleXZ(
+		valType const & angleX, 
+		valType const & angleZ);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleZX(
+		valType const & angleZ, 
+		valType const & angleX);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleYZ(
+		valType const & angleY, 
+		valType const & angleZ);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleZY(
+		valType const & angleZ, 
+		valType const & angleY);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> eulerAngleYXZ(
+		valType const & yaw, 
+		valType const & pitch, 
+		valType const & roll);
+
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> yawPitchRoll(
+		valType const & yaw, 
+		valType const & pitch, 
+		valType const & roll);
+
+	//! Creates a 2D 2 * 2 rotation matrix from an euler angle.
+	//! From GLM_GTX_euler_angles extension.
+	template <typename T> 
+	detail::tmat2x2<T> orientate2(T const & angle);
+
+	//! Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.
+	//! From GLM_GTX_euler_angles extension.
+	template <typename T> 
+	detail::tmat3x3<T> orientate3(T const & angle);
+
+	//! Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z). 
+	//! From GLM_GTX_euler_angles extension.
+	template <typename T> 
+	detail::tmat3x3<T> orientate3(detail::tvec3<T> const & angles);
 		
-		//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
-		//! From GLM_GTX_euler_angles extension.
-		template <typename T> 
-		detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
-
-		///@}
-	}//namespace euler_angles
-    }//namespace gtx
+	//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
+	//! From GLM_GTX_euler_angles extension.
+	template <typename T> 
+	detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
+
+	/// @}
+}//namespace euler_angles
+}//namespace gtx
 }//namespace glm
 
 #include "euler_angles.inl"

glm/gtx/extend.hpp

@@ -20,31 +20,24 @@
 #	pragma message("GLM: GLM_GTX_extend extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace extend ///< GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
 {
-   	namespace test{
-		void main_gtx_extend();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
-	namespace extend
-	{
-		/// \addtogroup gtx_extend
-		///@{
-
-		//! Extends of Length the Origin position using the (Source - Origin) direction.
-		//! From GLM_GTX_extend extension.
-		template <typename genType> 
-		genType extend(
-			genType const & Origin, 
-			genType const & Source, 
-			typename genType::value_type const Length);
-
-		///@}
-
-	}//namespace extend
-	}//namespace gtx
+	/// \addtogroup gtx_extend
+	/// @{
+
+	//! Extends of Length the Origin position using the (Source - Origin) direction.
+	//! From GLM_GTX_extend extension.
+	template <typename genType> 
+	genType extend(
+		genType const & Origin, 
+		genType const & Source, 
+		typename genType::value_type const Length);
+
+	/// @}
+}//namespace extend
+}//namespace gtx
 }//namespace glm
 
 #include "extend.inl"

glm/gtx/extented_min_max.hpp

@@ -22,157 +22,150 @@
 #	pragma message("GLM: GLM_GTX_extented_min_max extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace extented_min_max ///< GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
 {
-   	namespace test{
-		void main_ext_gtx_extented_min_max();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
-	namespace extented_min_max
-	{
-		/// \addtogroup gtx_extented_min_max
-		///@{
-
-		//< Return the minimum component-wise values of 3 inputs 
-		//< From GLM_GTX_extented_min_max extension
-		template <typename T>
-		T min(
-			T const & x, 
-			T const & y, 
-			T const & z);
-
-		//< Return the minimum component-wise values of 3 inputs
-		//< From GLM_GTX_extented_min_max extension
-		template 
-		<
-			typename T, 
-			template <typename> class C
-		>
-		C<T> min(
-			C<T> const & x, 
-			typename C<T>::value_type const & y, 
-			typename C<T>::value_type const & z);
-
-		//< Return the minimum component-wise values of 3 inputs 
-		//< From GLM_GTX_extented_min_max extension
-		template 
-		<
-			typename T, 
-			template <typename> class C
-		>
-		C<T> min(
-			C<T> const & x, 
-			C<T> const & y, 
-			C<T> const & z);
-
-		//< Return the minimum component-wise values of 4 inputs 
-		//< From GLM_GTX_extented_min_max extension
-		template <typename T>
-		T min(
-			T const & x, 
-			T const & y, 
-			T const & z, 
-			T const & w);
-
-		//< Return the minimum component-wise values of 4 inputs 
-		//< From GLM_GTX_extented_min_max extension
-		template 
-		<
-			typename T, 
-			template <typename> class C
-		>
-		C<T> min(
-			C<T> const & x, 
-			typename C<T>::value_type const & y, 
-			typename C<T>::value_type const & z, 
-			typename C<T>::value_type const & w);
-
-		//< Return the minimum component-wise values of 4 inputs
-		//< From GLM_GTX_extented_min_max extension
-		template 
-		<
-			typename T, 
-			template <typename> class C
-		>
-		C<T> min(
-			C<T> const & x, 
-			C<T> const & y, 
-			C<T> const & z,
-			C<T> const & w);
-
-		//< Return the maximum component-wise values of 3 inputs 
-		//< From GLM_GTX_extented_min_max extension
-		template <typename T>
-		T max(
-			T const & x, 
-			T const & y, 
-			T const & z);
-
-		//< Return the maximum component-wise values of 3 inputs
-		//< From GLM_GTX_extented_min_max extension
-		template 
-		<
-			typename T, 
-			template <typename> class C
-		>
-		C<T> max(
-			C<T> const & x, 
-			typename C<T>::value_type const & y, 
-			typename C<T>::value_type const & z);
-
-		//< Return the maximum component-wise values of 3 inputs 
-		//< From GLM_GTX_extented_min_max extension
-		template 
-		<
-			typename T, 
-			template <typename> class C
-		>
-		C<T> max(
-			C<T> const & x, 
-			C<T> const & y, 
-			C<T> const & z);
-
-		//< Return the maximum component-wise values of 4 inputs
-		//< From GLM_GTX_extented_min_max extension
-		template <typename T>
-		T max(
-			T const & x, 
-			T const & y, 
-			T const & z, 
-			T const & w);
-
-		//< Return the maximum component-wise values of 4 inputs 
-		//< From GLM_GTX_extented_min_max extension
-		template 
-		<
-			typename T, 
-			template <typename> class C
-		>
-		C<T> max(
-			C<T> const & x, 
-			typename C<T>::value_type const & y, 
-			typename C<T>::value_type const & z, 
-			typename C<T>::value_type const & w);
-
-		//< Return the maximum component-wise values of 4 inputs 
-		//< From GLM_GTX_extented_min_max extension
-		template 
-		<
-			typename T, 
-			template <typename> class C
-		>
-		C<T> max(
-			C<T> const & x, 
-			C<T> const & y, 
-			C<T> const & z, 
-			C<T> const & w);
-
-		///@}
-
-	}//namespace extented_min_max
-	}//namespace gtx
+	/// \addtogroup gtx_extented_min_max
+	///@{
+
+	//< Return the minimum component-wise values of 3 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template <typename T>
+	T min(
+		T const & x, 
+		T const & y, 
+		T const & z);
+
+	//< Return the minimum component-wise values of 3 inputs
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> min(
+		C<T> const & x, 
+		typename C<T>::value_type const & y, 
+		typename C<T>::value_type const & z);
+
+	//< Return the minimum component-wise values of 3 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> min(
+		C<T> const & x, 
+		C<T> const & y, 
+		C<T> const & z);
+
+	//< Return the minimum component-wise values of 4 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template <typename T>
+	T min(
+		T const & x, 
+		T const & y, 
+		T const & z, 
+		T const & w);
+
+	//< Return the minimum component-wise values of 4 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> min(
+		C<T> const & x, 
+		typename C<T>::value_type const & y, 
+		typename C<T>::value_type const & z, 
+		typename C<T>::value_type const & w);
+
+	//< Return the minimum component-wise values of 4 inputs
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> min(
+		C<T> const & x, 
+		C<T> const & y, 
+		C<T> const & z,
+		C<T> const & w);
+
+	//< Return the maximum component-wise values of 3 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template <typename T>
+	T max(
+		T const & x, 
+		T const & y, 
+		T const & z);
+
+	//< Return the maximum component-wise values of 3 inputs
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> max(
+		C<T> const & x, 
+		typename C<T>::value_type const & y, 
+		typename C<T>::value_type const & z);
+
+	//< Return the maximum component-wise values of 3 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> max(
+		C<T> const & x, 
+		C<T> const & y, 
+		C<T> const & z);
+
+	//< Return the maximum component-wise values of 4 inputs
+	//< From GLM_GTX_extented_min_max extension
+	template <typename T>
+	T max(
+		T const & x, 
+		T const & y, 
+		T const & z, 
+		T const & w);
+
+	//< Return the maximum component-wise values of 4 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> max(
+		C<T> const & x, 
+		typename C<T>::value_type const & y, 
+		typename C<T>::value_type const & z, 
+		typename C<T>::value_type const & w);
+
+	//< Return the maximum component-wise values of 4 inputs 
+	//< From GLM_GTX_extented_min_max extension
+	template 
+	<
+		typename T, 
+		template <typename> class C
+	>
+	C<T> max(
+		C<T> const & x, 
+		C<T> const & y, 
+		C<T> const & z, 
+		C<T> const & w);
+
+	/// @}
+}//namespace extented_min_max
+}//namespace gtx
 }//namespace glm
 
 #include "extented_min_max.inl"

glm/gtx/fast_exponential.hpp

@@ -22,63 +22,56 @@
 #	pragma message("GLM: GLM_GTX_fast_exponential extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace fast_exponential ///< GLM_GTX_fast_exponential extension: Fast but less accurate implementations of exponential based functions.
 {
-   	namespace test{
-		void main_gtx_fast_exponential();
-	}//namespace test
+	using namespace gtc::half_float;
+	/// \addtogroup gtx_fast_exponential
+	/// @{
 
-	namespace gtx{
-	//! GLM_GTX_fast_exponential extension: Fast but less accurate implementations of exponential based functions.
-	namespace fast_exponential
-	{
-		using namespace gtc::half_float;
-		/// \addtogroup gtx_fast_exponential
-		///@{
+	//! Faster than the common pow function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename valType> 
+	valType fastPow(
+		valType const & x, 
+		valType const & y);
 
-		//! Faster than the common pow function but less accurate.
-		//! From GLM_GTX_fast_exponential extension.
-		template <typename valType> 
-		valType fastPow(
-			valType const & x, 
-			valType const & y);
-
-		//! Faster than the common pow function but less accurate.
-		//! From GLM_GTX_fast_exponential extension.
-		template <typename T, typename U> 
-		T fastPow(
-			const T& x, 
-			const U& y);
+	//! Faster than the common pow function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename T, typename U> 
+	T fastPow(
+		const T& x, 
+		const U& y);
 		
-		//! Faster than the common exp function but less accurate.
-		//! From GLM_GTX_fast_exponential extension.
-		template <typename T> 
-		T fastExp(const T& x);
+	//! Faster than the common exp function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename T> 
+	T fastExp(const T& x);
 		
-		//! Faster than the common log function but less accurate.
-		//! From GLM_GTX_fast_exponential extension.
-		template <typename T> 
-		T fastLog(const T& x);
+	//! Faster than the common log function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename T> 
+	T fastLog(const T& x);
 
-		//! Faster than the common exp2 function but less accurate.
-		//! From GLM_GTX_fast_exponential extension.
-		template <typename T> 
-		T fastExp2(const T& x);
+	//! Faster than the common exp2 function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename T> 
+	T fastExp2(const T& x);
 		
-		//! Faster than the common log2 function but less accurate.
-		//! From GLM_GTX_fast_exponential extension.
-		template <typename T> 
-		T fastLog2(const T& x);
-
-		//! Faster than the common ln function but less accurate.
-		//! From GLM_GTX_fast_exponential extension.
-		template <typename T> 
-		T fastLn(const T& x);
+	//! Faster than the common log2 function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename T> 
+	T fastLog2(const T& x);
 
-		///@}
+	//! Faster than the common ln function but less accurate.
+	//! From GLM_GTX_fast_exponential extension.
+	template <typename T> 
+	T fastLn(const T& x);
 
-	}//namespace fast_exponential
-	}//namespace gtx
+	/// @}
+}//namespace fast_exponential
+}//namespace gtx
 }//namespace glm
 
 #include "fast_exponential.inl"

glm/gtx/fast_square_root.hpp

@@ -24,49 +24,42 @@
 #	pragma message("GLM: GLM_GTX_fast_square_root extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace fast_square_root 	///< GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
 {
-   	namespace test{
-		void main_gtx_fast_square_root();
-	}//namespace test
+	/// \addtogroup gtx_fast_square_root
+	/// @{
 
-	namespace gtx{
-	//! GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
-	namespace fast_square_root
-	{
-		/// \addtogroup gtx_fast_square_root
-		///@{
+	//! Faster than the common sqrt function but less accurate.
+	//! From GLM_GTX_fast_square_root extension.
+	template <typename genType> 
+	genType fastSqrt(genType const & x);
 
-		//! Faster than the common sqrt function but less accurate.
-		//! From GLM_GTX_fast_square_root extension.
-		template <typename genType> 
-		genType fastSqrt(genType const & x);
-
-		//! Faster than the common inversesqrt function but less accurate.
-		//! From GLM_GTX_fast_square_root extension.
-		template <typename genType> 
-		genType fastInverseSqrt(genType const & x);
+	//! Faster than the common inversesqrt function but less accurate.
+	//! From GLM_GTX_fast_square_root extension.
+	template <typename genType> 
+	genType fastInverseSqrt(genType const & x);
 		
-		//! Faster than the common length function but less accurate.
-		//! From GLM_GTX_fast_square_root extension.
-		template <typename genType> 
-		typename genType::value_type fastLength(genType const & x);
-
-		//! Faster than the common distance function but less accurate.
-		//! From GLM_GTX_fast_square_root extension.
-		template <typename genType> 
-		typename genType::value_type fastDistance(genType const & x, genType const & y);
+	//! Faster than the common length function but less accurate.
+	//! From GLM_GTX_fast_square_root extension.
+	template <typename genType> 
+	typename genType::value_type fastLength(genType const & x);
 
-		//! Faster than the common normalize function but less accurate.
-		//! From GLM_GTX_fast_square_root extension.
-		template <typename genType> 
-		genType fastNormalize(genType const & x);
+	//! Faster than the common distance function but less accurate.
+	//! From GLM_GTX_fast_square_root extension.
+	template <typename genType> 
+	typename genType::value_type fastDistance(genType const & x, genType const & y);
 
-		///@}
+	//! Faster than the common normalize function but less accurate.
+	//! From GLM_GTX_fast_square_root extension.
+	template <typename genType> 
+	genType fastNormalize(genType const & x);
 
-	}//namespace fast_square_root
-	}//	namespace gtx
-}//namespace glm
+	/// @}
+}// namespace fast_square_root
+}// namespace gtx
+}// namespace glm
 
 #include "fast_square_root.inl"
 

glm/gtx/fast_trigonometry.hpp

@@ -20,65 +20,58 @@
 #	pragma message("GLM: GLM_GTX_fast_trigonometry extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace fast_trigonometry	///< GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
 {
-   	namespace test{
-		void main_gtx_fast_trigonometry();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
-    namespace fast_trigonometry
-    {
-		/// \addtogroup gtx_fast_trigonometry
-		///@{
-
-		//! Faster than the common sin function but less accurate. 
-		//! Defined between -2pi and 2pi. 
-		//! From GLM_GTX_fast_trigonometry extension.
-        template <typename T> 
-		T fastSin(const T& angle);
-
-        //! Faster than the common cos function but less accurate.
-		//! Defined between -2pi and 2pi.
-		//! From GLM_GTX_fast_trigonometry extension.
-		template <typename T> 
-		T fastCos(const T& angle);
-
-        //! Faster than the common tan function but less accurate. 
-		//! Defined between -2pi and 2pi. 
-		//! From GLM_GTX_fast_trigonometry extension.
-		template <typename T> 
-		T fastTan(const T& angle);
-
-        //! Faster than the common asin function but less accurate. 
-		//! Defined between -2pi and 2pi.
-		//! From GLM_GTX_fast_trigonometry extension.
-		template <typename T> 
-		T fastAsin(const T& angle);
-
-		//! Faster than the common acos function but less accurate. 
-		//! Defined between -2pi and 2pi. 
-		//! From GLM_GTX_fast_trigonometry extension.
-        template <typename T> 
-		T fastAcos(const T& angle);
-
-		//! Faster than the common atan function but less accurate.
-		//! Defined between -2pi and 2pi. 
-		//! From GLM_GTX_fast_trigonometry extension.
-		template <typename T> 
-		T fastAtan(const T& y, const T& x);
-
-		//! Faster than the common atan function but less accurate. 
-		//! Defined between -2pi and 2pi.
-		//! From GLM_GTX_fast_trigonometry extension.
-        template <typename T> 
-		T fastAtan(const T& angle);
-
-		///@}
-
-    }//namespace fast_trigonometry
-    }//namespace gtx
+	/// \addtogroup gtx_fast_trigonometry
+	/// @{
+
+	//! Faster than the common sin function but less accurate. 
+	//! Defined between -2pi and 2pi. 
+	//! From GLM_GTX_fast_trigonometry extension.
+    template <typename T> 
+	T fastSin(const T& angle);
+
+    //! Faster than the common cos function but less accurate.
+	//! Defined between -2pi and 2pi.
+	//! From GLM_GTX_fast_trigonometry extension.
+	template <typename T> 
+	T fastCos(const T& angle);
+
+    //! Faster than the common tan function but less accurate. 
+	//! Defined between -2pi and 2pi. 
+	//! From GLM_GTX_fast_trigonometry extension.
+	template <typename T> 
+	T fastTan(const T& angle);
+
+    //! Faster than the common asin function but less accurate. 
+	//! Defined between -2pi and 2pi.
+	//! From GLM_GTX_fast_trigonometry extension.
+	template <typename T> 
+	T fastAsin(const T& angle);
+
+	//! Faster than the common acos function but less accurate. 
+	//! Defined between -2pi and 2pi. 
+	//! From GLM_GTX_fast_trigonometry extension.
+    template <typename T> 
+	T fastAcos(const T& angle);
+
+	//! Faster than the common atan function but less accurate.
+	//! Defined between -2pi and 2pi. 
+	//! From GLM_GTX_fast_trigonometry extension.
+	template <typename T> 
+	T fastAtan(const T& y, const T& x);
+
+	//! Faster than the common atan function but less accurate. 
+	//! Defined between -2pi and 2pi.
+	//! From GLM_GTX_fast_trigonometry extension.
+    template <typename T> 
+	T fastAtan(const T& angle);
+
+	/// @}
+}//namespace fast_trigonometry
+}//namespace gtx
 }//namespace glm
 
 #include "fast_trigonometry.inl"

glm/gtx/gradient_paint.hpp

@@ -21,34 +21,32 @@
 #	pragma message("GLM: GLM_GTX_gradient_paint extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace gradient_paint ///< GLM_GTX_gradient_paint extension: Compute a radient gradient according section OpenVG 1.1 specifications, 9.3.2 Radial Gradients
 {
-	namespace test{
-		void main_gtx_gradient_paint();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_gradient_paint extension: Compute a radient gradient according section OpenVG 1.1 specifications, 9.3.2 Radial Gradients
-	namespace gradient_paint
-	{
-		using namespace gtx::optimum_pow;
-
-		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);
-
-		template <typename valType>
-		valType linearGradient(
-			glm::detail::tvec2<valType> const & Point0,
-			glm::detail::tvec2<valType> const & Point1,
-			glm::detail::tvec2<valType> const & Position);
-
-	}//namespace gradient_paint
-    }//namespace gtx
-}//namespace glm
+	using namespace gtx::optimum_pow;
+
+	/// \addtogroup gtx_gradient_paint
+	/// @{
+
+	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);
+
+	template <typename valType>
+	valType linearGradient(
+		glm::detail::tvec2<valType> const & Point0,
+		glm::detail::tvec2<valType> const & Point1,
+		glm::detail::tvec2<valType> const & Position);
+
+	/// @}
+}// namespace gradient_paint
+}// namespace gtx
+}// namespace glm
 
 #include "gradient_paint.inl"
 

glm/gtx/handed_coordinate_space.hpp

@@ -20,36 +20,33 @@
 #	pragma message("GLM: GLM_GTX_handed_coordinate_space extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace handed_coordinate_space ///< GLM_GTX_handed_coordinate_space extension: To know if a set of three basis vectors defines a right or left-handed coordinate system.
 {
-	namespace gtx{
-	//! GLM_GTX_handed_coordinate_space extension: To know if a set of three basis vectors defines a right or left-handed coordinate system.
-	namespace handed_coordinate_space
-	{
-		/// \addtogroup gtx_handed_coordinate_space
-		///@{
-
-		//! Return if a trihedron right handed or not.
-		//! From GLM_GTX_handed_coordinate_space extension.
-		template <typename T> 
-		bool rightHanded(
-			detail::tvec3<T> const & tangent, 
-			detail::tvec3<T> const & binormal, 
-			detail::tvec3<T> const & normal);
-
-		//! Return if a trihedron left handed or not.
-		//! From GLM_GTX_handed_coordinate_space extension.
-		template <typename T> 
-		bool leftHanded(
-			detail::tvec3<T> const & tangent, 
-			detail::tvec3<T> const & binormal, 
-			detail::tvec3<T> const & normal);
-
-		///@}
-
-	}//namespace handed_coordinate_space
-	}//namespace gtx
-}//namespace glm
+	/// \addtogroup gtx_handed_coordinate_space
+	/// @{
+
+	//! Return if a trihedron right handed or not.
+	//! From GLM_GTX_handed_coordinate_space extension.
+	template <typename T> 
+	bool rightHanded(
+		detail::tvec3<T> const & tangent, 
+		detail::tvec3<T> const & binormal, 
+		detail::tvec3<T> const & normal);
+
+	//! Return if a trihedron left handed or not.
+	//! From GLM_GTX_handed_coordinate_space extension.
+	template <typename T> 
+	bool leftHanded(
+		detail::tvec3<T> const & tangent, 
+		detail::tvec3<T> const & binormal, 
+		detail::tvec3<T> const & normal);
+
+	/// @}
+}// namespace handed_coordinate_space
+}// namespace gtx
+}// namespace glm
 
 #include "handed_coordinate_space.inl"
 

glm/gtx/inertia.hpp

@@ -20,76 +20,73 @@
 #	pragma message("GLM: GLM_GTX_inertia extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace inertia ///< GLM_GTX_inertia extension: Create inertia matrices
 {
-	namespace gtx{
-	//! GLM_GTX_inertia extension: Create inertia matrices
-	namespace inertia
-	{
-		/// \addtogroup gtx_inertia
-		///@{
+	/// \addtogroup gtx_inertia
+	/// @{
 
-		//! Build an inertia matrix for a box.
-		//! From GLM_GTX_inertia extension.
-		template <typename T> 
-		detail::tmat3x3<T> boxInertia3(
-			const T Mass, 
-			const detail::tvec3<T>& Scale);
+	//! Build an inertia matrix for a box.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat3x3<T> boxInertia3(
+		const T Mass, 
+		const detail::tvec3<T>& Scale);
 		
-		//! Build an inertia matrix for a box.
-		//! From GLM_GTX_inertia extension.
-		template <typename T> 
-		detail::tmat4x4<T> boxInertia4(
-			const T Mass, 
-			const detail::tvec3<T>& Scale);
+	//! Build an inertia matrix for a box.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat4x4<T> boxInertia4(
+		const T Mass, 
+		const detail::tvec3<T>& Scale);
 		
-		//! Build an inertia matrix for a disk.
-		//! From GLM_GTX_inertia extension.
-		template <typename T> 
-		detail::tmat3x3<T> diskInertia3(
-			const T Mass, 
-			const T Radius);
+	//! Build an inertia matrix for a disk.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat3x3<T> diskInertia3(
+		const T Mass, 
+		const T Radius);
 
-		//! Build an inertia matrix for a disk.
-		//! From GLM_GTX_inertia extension.
-		template <typename T> 
-		detail::tmat4x4<T> diskInertia4(
-			const T Mass, 
-			const T Radius);
+	//! Build an inertia matrix for a disk.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat4x4<T> diskInertia4(
+		const T Mass, 
+		const T Radius);
 
-		//! Build an inertia matrix for a ball.
-		//! From GLM_GTX_inertia extension.
-		template <typename T> 
-		detail::tmat3x3<T> ballInertia3(
-			const T Mass, 
-			const T Radius);
+	//! Build an inertia matrix for a ball.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat3x3<T> ballInertia3(
+		const T Mass, 
+		const T Radius);
 		
-		//! Build an inertia matrix for a ball.
-		//! From GLM_GTX_inertia extension.
-		template <typename T> 
-		detail::tmat4x4<T> ballInertia4(
-			const T Mass, 
-			const T Radius);
+	//! Build an inertia matrix for a ball.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat4x4<T> ballInertia4(
+		const T Mass, 
+		const T Radius);
 
-		//! Build an inertia matrix for a sphere.
-		//! From GLM_GTX_inertia extension.
-		template <typename T> 
-		detail::tmat3x3<T> sphereInertia3(
-			const T Mass, 
-			const T Radius);
+	//! Build an inertia matrix for a sphere.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat3x3<T> sphereInertia3(
+		const T Mass, 
+		const T Radius);
 
-		//! Build an inertia matrix for a sphere.
-		//! From GLM_GTX_inertia extension.
-		template <typename T> 
-		detail::tmat4x4<T> sphereInertia4(
-			const T Mass, 
-			const T Radius);
+	//! Build an inertia matrix for a sphere.
+	//! From GLM_GTX_inertia extension.
+	template <typename T> 
+	detail::tmat4x4<T> sphereInertia4(
+		const T Mass, 
+		const T Radius);
 
-		///@}
-
-	}//namespace inertia
-	}//namespace gtx
-}//namespace glm
+	/// @}
+}// namespace inertia
+}// namespace gtx
+}// namespace glm
 
 #include "inertia.inl"
 

glm/gtx/int_10_10_10_2.hpp

@@ -21,25 +21,23 @@
 #	pragma message("GLM: GLM_GTX_int_10_10_10_2 extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace int_10_10_10_2 ///< GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
 {
-	namespace gtx{
-	//! GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
-	namespace int_10_10_10_2
-	{
-		using namespace gtx::raw_data;
+	using namespace gtx::raw_data;
 
-		/// \addtogroup gtx_int_10_10_10_2
-		///@{
+	/// \addtogroup gtx_int_10_10_10_2
+	///@{
 
-		//! From GLM_GTX_int_10_10_10_2 extension.
-		//! Cast a vec4 to an u_10_10_10_2.
-		dword uint10_10_10_2_cast(glm::vec4 const & v);
+	//! From GLM_GTX_int_10_10_10_2 extension.
+	//! Cast a vec4 to an u_10_10_10_2.
+	dword uint10_10_10_2_cast(glm::vec4 const & v);
 
-		///@}
+	///@}
 
-	}//namespace integer
-	}//namespace gtx
+}//namespace integer
+}//namespace gtx
 }//namespace glm
 
 #include "int_10_10_10_2.inl"

glm/gtx/integer.hpp

@@ -20,36 +20,33 @@
 #	pragma message("GLM: GLM_GTX_integer extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace integer ///< GLM_GTX_integer extension: Add support for integer for core functions
 {
-	namespace gtx{
-	//! GLM_GTX_integer extension: Add support for integer for core functions
-	namespace integer
-	{
-		/// \addtogroup gtx_integer
-		///@{
-
-		//! Returns x raised to the y power. 
-		//! From GLM_GTX_integer extension.
-		int pow(int x, int y);
-
-		//! Returns the positive square root of x.
-		//! From GLM_GTX_integer extension.
-		int sqrt(int x);
-
-		//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
-		//! From GLM_GTX_integer extension.
-		int mod(int x, int y);
-
-		//! Return the factorial value of a number (!12 max, integer only)
-		//! From GLM_GTX_integer extension.
-		template <typename genType> 
-		genType factorial(genType const & x);
-
-		///@}
-
-	}//namespace integer
-	}//namespace gtx
+	/// \addtogroup gtx_integer
+	/// @{
+
+	//! Returns x raised to the y power. 
+	//! From GLM_GTX_integer extension.
+	int pow(int x, int y);
+
+	//! Returns the positive square root of x.
+	//! From GLM_GTX_integer extension.
+	int sqrt(int x);
+
+	//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
+	//! From GLM_GTX_integer extension.
+	int mod(int x, int y);
+
+	//! Return the factorial value of a number (!12 max, integer only)
+	//! From GLM_GTX_integer extension.
+	template <typename genType> 
+	genType factorial(genType const & x);
+
+	/// @}
+}//namespace integer
+}//namespace gtx
 }//namespace glm
 
 #include "integer.inl"

glm/gtx/intersect.hpp

@@ -22,54 +22,47 @@
 #	pragma message("GLM: GLM_GTX_closest_point extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace intersect	///< GLM_GTX_intersect extension: Add intersection functions
 {
-	namespace test{
-		void main_gtx_intesect();
-	}//namespace test
+	/// \addtogroup gtx_intersect
+	/// @{
 
-	namespace gtx{
-	//! GLM_GTX_intersect extension: Add intersection functions
-	namespace intersect
-	{
-		/// \addtogroup gtx_intersect
-		///@{
+	//! Compute the intersection of a ray and a triangle.
+	//! From GLM_GTX_intersect extension.
+	template <typename genType>
+	bool intersectRayTriangle(
+		genType const & orig, genType const & dir,
+		genType const & vert0, genType const & vert1, genType const & vert2,
+		genType & baryPosition);
 
-		//! Compute the intersection of a ray and a triangle.
-		//! From GLM_GTX_intersect extension.
-		template <typename genType>
-		bool intersectRayTriangle(
-			genType const & orig, genType const & dir,
-			genType const & vert0, genType const & vert1, genType const & vert2,
-			genType & baryPosition);
+    //! Compute the intersection of a line and a triangle.
+	//! From GLM_GTX_intersect extension.
+	template <typename genType>
+	bool intersectLineTriangle(
+		genType const & orig, genType const & dir,
+		genType const & vert0, genType const & vert1, genType const & vert2,
+		genType & position);
 
-        //! Compute the intersection of a line and a triangle.
-		//! From GLM_GTX_intersect extension.
-		template <typename genType>
-		bool intersectLineTriangle(
-			genType const & orig, genType const & dir,
-			genType const & vert0, genType const & vert1, genType const & vert2,
-			genType & position);
+    //! Compute the intersection of a ray and a sphere.
+	//! From GLM_GTX_intersect extension.
+	template <typename genType>
+	bool intersectRaySphere(
+		genType const & orig, genType const & dir,
+		genType const & center, typename genType::value_type radius,
+		genType & position, genType & normal);
 
-        //! Compute the intersection of a ray and a sphere.
-		//! From GLM_GTX_intersect extension.
-		template <typename genType>
-		bool intersectRaySphere(
-			genType const & orig, genType const & dir,
-			genType const & center, typename genType::value_type radius,
-			genType & position, genType & normal);
+    //! Compute the intersection of a line and a sphere.
+	//! From GLM_GTX_intersect extension
+	template <typename genType>
+	bool intersectLineSphere(
+		genType const & point0, genType const & point1,
+		genType const & center, typename genType::value_type radius,
+		genType & position, genType & normal);
 
-        //! Compute the intersection of a line and a sphere.
-		//! From GLM_GTX_intersect extension
-		template <typename genType>
-		bool intersectLineSphere(
-			genType const & point0, genType const & point1,
-			genType const & center, typename genType::value_type radius,
-			genType & position, genType & normal);
-
-		///@}
-
-	}//namespace intersect
+	/// @}
+}//namespace intersect
 }//namespace gtx
 }//namespace glm
 

glm/gtx/log_base.hpp

@@ -20,30 +20,24 @@
 #	pragma message("GLM: GLM_GTX_log_base extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace log_base ///< GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
 {
-   	namespace test{
-		void main_ext_gtx_log_base();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
-	namespace log_base
-	{
-		/// \addtogroup gtx_log_base
-		///@{
-
-		//! Logarithm for any base.
-		//! From GLM_GTX_log_base.
-		template <typename genType> 
-		genType log(
-			genType const & x, 
-			genType const & base);
-
-		///@}
-
-	}//namespace extend
-	}//namespace gtx
+	/// \addtogroup gtx_log_base
+	/// @{
+
+	//! Logarithm for any base.
+	//! From GLM_GTX_log_base.
+	template <typename genType> 
+	genType log(
+		genType const & x, 
+		genType const & base);
+
+	/// @}
+
+}//namespace extend
+}//namespace gtx
 }//namespace glm
 
 #include "log_base.inl"

glm/gtx/matrix_cross_product.hpp

@@ -20,35 +20,28 @@
 #	pragma message("GLM: GLM_GTX_matrix_cross_product extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace matrix_cross_product ///< GLM_GTX_matrix_cross_product: Build cross product matrices
 {
-   	namespace test{
-		void main_gtx_matrix_cross_product();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_matrix_cross_product: Build cross product matrices
-	namespace matrix_cross_product
-	{
-		/// \addtogroup gtx_matrix_cross_product
-		///@{
-
-		//! Build a cross product matrix.
-		//! From GLM_GTX_matrix_cross_product extension.
-		template <typename T> 
-		detail::tmat3x3<T> matrixCross3(
-			detail::tvec3<T> const & x);
+	/// \addtogroup gtx_matrix_cross_product
+	/// @{
+
+	//! Build a cross product matrix.
+	//! From GLM_GTX_matrix_cross_product extension.
+	template <typename T> 
+	detail::tmat3x3<T> matrixCross3(
+		detail::tvec3<T> const & x);
 		
-		//! Build a cross product matrix.
-		//! From GLM_GTX_matrix_cross_product extension.
-		template <typename T> 
-		detail::tmat4x4<T> matrixCross4(
-			detail::tvec3<T> const & x);
-
-		///@}
-
-	}//namespace matrix_cross_product
-	}//namespace gtx
+	//! Build a cross product matrix.
+	//! From GLM_GTX_matrix_cross_product extension.
+	template <typename T> 
+	detail::tmat4x4<T> matrixCross4(
+		detail::tvec3<T> const & x);
+
+	/// @}
+}//namespace matrix_cross_product
+}//namespace gtx
 }//namespace glm
 
 #include "matrix_cross_product.inl"

glm/gtx/matrix_interpolation.hpp

@@ -23,47 +23,40 @@
 #	pragma message("GLM: GLM_GTX_matrix_interpolation extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace matrix_interpolation ///< GLM_GTX_matrix_interpolation extension: Add transformation matrices
 {
-	namespace test{
-		void main_gtx_transform();
-	}//namespace test
+	/// \addtogroup gtx_matrix_interpolation
+	/// @{
 
-	namespace gtx{
-	//! GLM_GTX_matrix_interpolation extension: Add transformation matrices
-	namespace matrix_interpolation
-	{
-		/// \addtogroup gtx_matrix_interpolation
-		///@{
+	//! Get the axis and angle of the rotation from a matrix.
+    //! From GLM_GTX_matrix_interpolation extension.
+	template <typename T>
+    void axisAngle(
+        detail::tmat4x4<T> const & mat,
+        detail::tvec3<T> & axis,
+        T & angle);
 
-		//! Get the axis and angle of the rotation from a matrix.
-        //! From GLM_GTX_matrix_interpolation extension.
-		template <typename T>
-        void axisAngle(
-            detail::tmat4x4<T> const & mat,
-            detail::tvec3<T> & axis,
-            T & angle);
+    //! Build a matrix from axis and angle.
+    //! From GLM_GTX_matrix_interpolation extension.
+	template <typename T>
+    detail::tmat4x4<T> axisAngleMatrix(
+        detail::tvec3<T> const & axis,
+        T const angle);
 
-        //! Build a matrix from axis and angle.
-        //! From GLM_GTX_matrix_interpolation extension.
-		template <typename T>
-        detail::tmat4x4<T> axisAngleMatrix(
-            detail::tvec3<T> const & axis,
-            T const angle);
+	//! Build a interpolation of 4 * 4 matrixes.
+    //! From GLM_GTX_matrix_interpolation extension.
+    //! Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.
+	template <typename T>
+    detail::tmat4x4<T> interpolate(
+        detail::tmat4x4<T> const & m1,
+        detail::tmat4x4<T> const & m2,
+        T const delta);
 
-		//! Build a interpolation of 4 * 4 matrixes.
-        //! From GLM_GTX_matrix_interpolation extension.
-        //! Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.
-		template <typename T>
-        detail::tmat4x4<T> interpolate(
-            detail::tmat4x4<T> const & m1,
-            detail::tmat4x4<T> const & m2,
-            T const delta);
-
-		///@}
-
-	}//namespace matrix_interpolation
-	}//namespace gtx
+	/// @}
+}//namespace matrix_interpolation
+}//namespace gtx
 }//namespace glm
 
 #include "matrix_interpolation.inl"

glm/gtx/matrix_major_storage.hpp

@@ -20,103 +20,100 @@
 #	pragma message("GLM: GLM_GTX_matrix_major_storage extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace matrix_major_storage ///< GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
 {
-	namespace gtx{
-	//! GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
-	namespace matrix_major_storage
-	{
-		/// \addtogroup gtx_matrix_major_storage
-		///@{
+	/// \addtogroup gtx_matrix_major_storage
+	/// @{
 
-		//! Build a row major matrix from row vectors.
-		//! From GLM_GTX_matrix_major_storage extension.
-		template <typename T> 
-		detail::tmat2x2<T> rowMajor2(
-			const detail::tvec2<T>& v1, 
-			const detail::tvec2<T>& v2);
+	//! Build a row major matrix from row vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat2x2<T> rowMajor2(
+		const detail::tvec2<T>& v1, 
+		const detail::tvec2<T>& v2);
 		
-		//! Build a row major matrix from other matrix.
-		//! From GLM_GTX_matrix_major_storage extension.
-		template <typename T> 
-		detail::tmat2x2<T> rowMajor2(
-			const detail::tmat2x2<T>& m);
+	//! Build a row major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat2x2<T> rowMajor2(
+		const detail::tmat2x2<T>& m);
 
-		//! Build a row major matrix from row vectors.
-		//! From GLM_GTX_matrix_major_storage extension.
-		template <typename T> 
-		detail::tmat3x3<T> rowMajor3(
-			const detail::tvec3<T>& v1, 
-			const detail::tvec3<T>& v2, 
-			const detail::tvec3<T>& v3);
+	//! Build a row major matrix from row vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat3x3<T> rowMajor3(
+		const detail::tvec3<T>& v1, 
+		const detail::tvec3<T>& v2, 
+		const detail::tvec3<T>& v3);
 
-		//! Build a row major matrix from other matrix.
-		//! From GLM_GTX_matrix_major_storage extension.
-		template <typename T> 
-		detail::tmat3x3<T> rowMajor3(
-			const detail::tmat3x3<T>& m);
+	//! Build a row major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat3x3<T> rowMajor3(
+		const detail::tmat3x3<T>& m);
 
-		//! Build a row major matrix from row vectors.
-		//! From GLM_GTX_matrix_major_storage extension.
-		template <typename T> 
-		detail::tmat4x4<T> rowMajor4(
-			const detail::tvec4<T>& v1, 
-			const detail::tvec4<T>& v2,
-			const detail::tvec4<T>& v3, 
-			const detail::tvec4<T>& v4);
+	//! Build a row major matrix from row vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat4x4<T> rowMajor4(
+		const detail::tvec4<T>& v1, 
+		const detail::tvec4<T>& v2,
+		const detail::tvec4<T>& v3, 
+		const detail::tvec4<T>& v4);
 
-		//! Build a row major matrix from other matrix.
-		//! From GLM_GTX_matrix_major_storage extension.
-		template <typename T> 
-		detail::tmat4x4<T> rowMajor4(
-			const detail::tmat4x4<T>& m);
+	//! Build a row major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat4x4<T> rowMajor4(
+		const detail::tmat4x4<T>& m);
 
-		//! Build a column major matrix from column vectors.
-		//! From GLM_GTX_matrix_major_storage extension.
-		template <typename T> 
-		detail::tmat2x2<T> colMajor2(
-			const detail::tvec2<T>& v1, 
-			const detail::tvec2<T>& v2);
+	//! Build a column major matrix from column vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat2x2<T> colMajor2(
+		const detail::tvec2<T>& v1, 
+		const detail::tvec2<T>& v2);
 		
-		//! Build a column major matrix from other matrix.
-		//! From GLM_GTX_matrix_major_storage extension.
-		template <typename T> 
-		detail::tmat2x2<T> colMajor2(
-			const detail::tmat2x2<T>& m);
+	//! Build a column major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat2x2<T> colMajor2(
+		const detail::tmat2x2<T>& m);
 
-		//! Build a column major matrix from column vectors.
-		//! From GLM_GTX_matrix_major_storage extension.
-		template <typename T> 
-		detail::tmat3x3<T> colMajor3(
-			const detail::tvec3<T>& v1, 
-			const detail::tvec3<T>& v2, 
-			const detail::tvec3<T>& v3);
+	//! Build a column major matrix from column vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat3x3<T> colMajor3(
+		const detail::tvec3<T>& v1, 
+		const detail::tvec3<T>& v2, 
+		const detail::tvec3<T>& v3);
 		
-		//! Build a column major matrix from other matrix.
-		//! From GLM_GTX_matrix_major_storage extension.
-		template <typename T> 
-		detail::tmat3x3<T> colMajor3(
-			const detail::tmat3x3<T>& m);
+	//! Build a column major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat3x3<T> colMajor3(
+		const detail::tmat3x3<T>& m);
 		
-		//! Build a column major matrix from column vectors.
-		//! From GLM_GTX_matrix_major_storage extension.
-		template <typename T> 
-		detail::tmat4x4<T> colMajor4(
-			const detail::tvec4<T>& v1, 
-			const detail::tvec4<T>& v2, 
-			const detail::tvec4<T>& v3, 
-			const detail::tvec4<T>& v4);
+	//! Build a column major matrix from column vectors.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat4x4<T> colMajor4(
+		const detail::tvec4<T>& v1, 
+		const detail::tvec4<T>& v2, 
+		const detail::tvec4<T>& v3, 
+		const detail::tvec4<T>& v4);
 				
-		//! Build a column major matrix from other matrix.
-		//! From GLM_GTX_matrix_major_storage extension.
-		template <typename T> 
-		detail::tmat4x4<T> colMajor4(
-			const detail::tmat4x4<T>& m);
+	//! Build a column major matrix from other matrix.
+	//! From GLM_GTX_matrix_major_storage extension.
+	template <typename T> 
+	detail::tmat4x4<T> colMajor4(
+		const detail::tmat4x4<T>& m);
 
-		///@}
-		
-	}//namespace matrix_major_storage
-	}//namespace gtx
+	/// @}
+}//namespace matrix_major_storage
+}//namespace gtx
 }//namespace glm
 
 #include "matrix_major_storage.inl"

glm/gtx/matrix_operation.hpp

@@ -20,77 +20,70 @@
 #	pragma message("GLM: GLM_GTX_matrix_operation extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace matrix_operation ///< GLM_GTX_matrix_operation: Build diagonal matrices
 {
-   	namespace test{
-		void main_gtx_matrix_operation();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_matrix_operation: Build diagonal matrices
-	namespace matrix_operation
-	{
-		/// \addtogroup gtx_matrix_operation
-		///@{
-
-		//! Build a diagonal matrix.
-		//! From GLM_GTX_matrix_operation extension.
-		template <typename valType> 
-		detail::tmat2x2<valType> diagonal2x2(
-			detail::tvec2<valType> const & v);
-
-		//! Build a diagonal matrix.
-		//! From GLM_GTX_matrix_operation extension.
-		template <typename valType> 
-		detail::tmat2x3<valType> diagonal2x3(
-			detail::tvec2<valType> const & v);
-
-		//! Build a diagonal matrix.
-		//! From GLM_GTX_matrix_operation extension.
-		template <typename valType> 
-		detail::tmat2x4<valType> diagonal2x4(
-			detail::tvec2<valType> const & v);
-
-		//! Build a diagonal matrix.
-		//! From GLM_GTX_matrix_operation extension.
-		template <typename valType> 
-		detail::tmat3x2<valType> diagonal3x2(
-			detail::tvec2<valType> const & v);
-
-		//! Build a diagonal matrix.
-		//! From GLM_GTX_matrix_operation extension.
-		template <typename valType> 
-		detail::tmat3x3<valType> diagonal3x3(
-			detail::tvec3<valType> const & v);
-
-		//! Build a diagonal matrix.
-		//! From GLM_GTX_matrix_operation extension.
-		template <typename valType> 
-		detail::tmat3x4<valType> diagonal3x4(
-			detail::tvec3<valType> const & v);
-
-		//! Build a diagonal matrix.
-		//! From GLM_GTX_matrix_operation extension.
-		template <typename valType> 
-		detail::tmat4x2<valType> diagonal4x2(
-			detail::tvec2<valType> const & v);
-
-		//! Build a diagonal matrix.
-		//! From GLM_GTX_matrix_operation extension.
-		template <typename valType> 
-		detail::tmat4x3<valType> diagonal4x3(
-			detail::tvec3<valType> const & v);
-
-		//! Build a diagonal matrix.
-		//! From GLM_GTX_matrix_operation extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> diagonal4x4(
-			detail::tvec4<valType> const & v);
-
-		///@}
-
-	}//namespace matrix_operation
-	}//namespace gtx
+	/// \addtogroup gtx_matrix_operation
+	/// @{
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat2x2<valType> diagonal2x2(
+		detail::tvec2<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat2x3<valType> diagonal2x3(
+		detail::tvec2<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat2x4<valType> diagonal2x4(
+		detail::tvec2<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat3x2<valType> diagonal3x2(
+		detail::tvec2<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat3x3<valType> diagonal3x3(
+		detail::tvec3<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat3x4<valType> diagonal3x4(
+		detail::tvec3<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat4x2<valType> diagonal4x2(
+		detail::tvec2<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat4x3<valType> diagonal4x3(
+		detail::tvec3<valType> const & v);
+
+	//! Build a diagonal matrix.
+	//! From GLM_GTX_matrix_operation extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> diagonal4x4(
+		detail::tvec4<valType> const & v);
+
+	/// @}
+}//namespace matrix_operation
+}//namespace gtx
 }//namespace glm
 
 #include "matrix_operation.inl"

glm/gtx/matrix_query.hpp

@@ -20,78 +20,72 @@
 #	pragma message("GLM: GLM_GTX_matrix_query extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace matrix_query ///< GLM_GTX_matrix_query: Query to evaluate matrix properties
 {
-   	namespace test{
-		void main_gtx_matrix_query();
-	}//namespace test
+	/// \addtogroup gtx_matrix_query
+	/// @{
 
-	namespace gtx{
-	//! GLM_GTX_matrix_query: Query to evaluate matrix properties
-	namespace matrix_query
-	{
-		/// \addtogroup gtx_matrix_query
-		///@{
-
-		//! Return if a matrix a null matrix.
-		//! From GLM_GTX_matrix_query extension.
-		template<typename T> 
-		bool isNull(
-			const detail::tmat2x2<T>& m, 
-			const T epsilon = std::numeric_limits<T>::epsilon());
+	//! Return if a matrix a null matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename T> 
+	bool isNull(
+		const detail::tmat2x2<T>& m, 
+		const T epsilon = std::numeric_limits<T>::epsilon());
 		
-		//! Return if a matrix a null matrix.
-		//! From GLM_GTX_matrix_query extension.
-		template<typename T> 
-		bool isNull(
-			const detail::tmat3x3<T>& m, 
-			const T epsilon = std::numeric_limits<T>::epsilon());
+	//! Return if a matrix a null matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename T> 
+	bool isNull(
+		const detail::tmat3x3<T>& m, 
+		const T epsilon = std::numeric_limits<T>::epsilon());
 		
-		//! Return if a matrix a null matrix.
-		//! From GLM_GTX_matrix_query extension.
-		template<typename T> 
-		bool isNull(
-			const detail::tmat4x4<T>& m, 
-			const T epsilon = std::numeric_limits<T>::epsilon());
+	//! Return if a matrix a null matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename T> 
+	bool isNull(
+		const detail::tmat4x4<T>& m, 
+		const T epsilon = std::numeric_limits<T>::epsilon());
 			
-		//! Return if a matrix an identity matrix. 
-		//! From GLM_GTX_matrix_query extension.
-		template<typename genType> 
-		bool isIdentity(
-			const genType& m, 
-			const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+	//! Return if a matrix an identity matrix. 
+	//! From GLM_GTX_matrix_query extension.
+	template<typename genType> 
+	bool isIdentity(
+		const genType& m, 
+		const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
-		//! Return if a matrix a normalized matrix.
-		//! From GLM_GTX_matrix_query extension.
-		template<typename T> 
-		bool isNormalized(
-			const detail::tmat2x2<T>& m, 
-			const T epsilon = std::numeric_limits<T>::epsilon());
+	//! Return if a matrix a normalized matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename T> 
+	bool isNormalized(
+		const detail::tmat2x2<T>& m, 
+		const T epsilon = std::numeric_limits<T>::epsilon());
 		
-		//! Return if a matrix a normalized matrix.
-		//! From GLM_GTX_matrix_query extension.
-		template<typename T> 
-		bool isNormalized(
-			const detail::tmat3x3<T>& m, 
-			const T epsilon = std::numeric_limits<T>::epsilon());
+	//! Return if a matrix a normalized matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename T> 
+	bool isNormalized(
+		const detail::tmat3x3<T>& m, 
+		const T epsilon = std::numeric_limits<T>::epsilon());
 		
-		//! Return if a matrix a normalized matrix.
-		//! From GLM_GTX_matrix_query extension.
-		template<typename T> 
-		bool isNormalized(
-			const detail::tmat4x4<T>& m, 
-			const T epsilon = std::numeric_limits<T>::epsilon());
+	//! Return if a matrix a normalized matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename T> 
+	bool isNormalized(
+		const detail::tmat4x4<T>& m, 
+		const T epsilon = std::numeric_limits<T>::epsilon());
 
-		//! Return if a matrix an orthonormalized matrix.
-		//! From GLM_GTX_matrix_query extension.
-		template<typename genType> 
-		bool isOrthogonal(
-			const genType& m, 
-			const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+	//! Return if a matrix an orthonormalized matrix.
+	//! From GLM_GTX_matrix_query extension.
+	template<typename genType> 
+	bool isOrthogonal(
+		const genType& m, 
+		const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
-		///@}
-	}//namespace matrix_query
-	}//namespace gtx
+	/// @}
+}//namespace matrix_query
+}//namespace gtx
 }//namespace glm
 
 #include "matrix_query.inl"

glm/gtx/mixed_product.hpp

@@ -20,30 +20,24 @@
 #	pragma message("GLM: GLM_GTX_mixed_product extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace mixed_product ///< GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
 {
-	namespace test{
-		void main_gtx_matrix_selection();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
-	namespace mixed_product
-	{
-		/// \addtogroup gtx_mixed_product
-		///@{
-
-		//! \brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
-		template <typename valType> 
-		valType mixedProduct(
-			detail::tvec3<valType> const & v1, 
-			detail::tvec3<valType> const & v2, 
-			detail::tvec3<valType> const & v3);
-
-		///@}
-	}//namespace mixed_product
-	}//namespace gtx
-}//namespace glm
+	/// \addtogroup gtx_mixed_product
+	/// @{
+
+	//! \brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
+	template <typename valType> 
+	valType mixedProduct(
+		detail::tvec3<valType> const & v1, 
+		detail::tvec3<valType> const & v2, 
+		detail::tvec3<valType> const & v3);
+
+	/// @}
+}// namespace mixed_product
+}// namespace gtx
+}// namespace glm
 
 #include "mixed_product.inl"
 

glm/gtx/multiple.hpp

@@ -20,37 +20,30 @@
 #	pragma message("GLM: GLM_GTX_multiple extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace multiple ///< GLM_GTX_multiple: Find the closest number of a number multiple of other number.
 {
-	namespace test{
-		bool main_img_multiple();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_multiple: Find the closest number of a number multiple of other number.
-	namespace multiple
-	{
-		/// \addtogroup gtx_multiple
-		///@{
-
-		//! Higher Multiple number of Source.
-		//! From GLM_GTX_multiple extension.
-		template <typename genType> 
-		genType higherMultiple(
-			genType const & Source, 
-			genType const & Multiple);
-
-		//! Lower Multiple number of Source.
-		//! From GLM_GTX_multiple extension.
-		template <typename genType> 
-		genType lowerMultiple(
-			genType const & Source, 
-			genType const & Multiple);
-
-		///@}
-
-	}//namespace multiple
-	}//namespace gtx
+	/// \addtogroup gtx_multiple
+	/// @{
+
+	//! Higher Multiple number of Source.
+	//! From GLM_GTX_multiple extension.
+	template <typename genType> 
+	genType higherMultiple(
+		genType const & Source, 
+		genType const & Multiple);
+
+	//! Lower Multiple number of Source.
+	//! From GLM_GTX_multiple extension.
+	template <typename genType> 
+	genType lowerMultiple(
+		genType const & Source, 
+		genType const & Multiple);
+
+	/// @}
+}//namespace multiple
+}//namespace gtx
 }//namespace glm
 
 #include "multiple.inl"

glm/gtx/noise.hpp

@@ -25,42 +25,35 @@
 #	pragma message("GLM: GLM_GTX_noise extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace noise	///< GLM_GTX_noise extension: Comparison functions for a user defined epsilon values.
 {
-	namespace test{
-		void main_gtx_noise();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_noise extension: Comparison functions for a user defined epsilon values.
-	namespace noise
-	{
-		/// \addtogroup gtx_noise
-		///@{
-
-		//! Classic perlin noise.
-		//! From GLM_GTX_noise extension.
-		template <typename T, template<typename> class vecType> 
-        T perlin(
-			vecType<T> const & p);
+	/// \addtogroup gtx_noise
+	/// @{
+
+	//! Classic perlin noise.
+	//! From GLM_GTX_noise extension.
+	template <typename T, template<typename> class vecType> 
+    T perlin(
+		vecType<T> const & p);
 		
-		//! Periodic perlin noise.
-		//! From GLM_GTX_noise extension.
-		template <typename T, template<typename> class vecType> 
-        T perlin(
-			vecType<T> const & p, 
-			vecType<T> const & rep);
-
-		//! Simplex noise.
-		//! From GLM_GTX_noise extension.
-		template <typename T, template<typename> class vecType> 
-        T simplex(
-			vecType<T> const & p);
-
-		///@}
-
-	}//namespace noise
-	}//namespace gtx
+	//! Periodic perlin noise.
+	//! From GLM_GTX_noise extension.
+	template <typename T, template<typename> class vecType> 
+    T perlin(
+		vecType<T> const & p, 
+		vecType<T> const & rep);
+
+	//! Simplex noise.
+	//! From GLM_GTX_noise extension.
+	template <typename T, template<typename> class vecType> 
+    T simplex(
+		vecType<T> const & p);
+
+	/// @}
+}//namespace noise
+}//namespace gtx
 }//namespace glm
 
 #include "noise.inl"

glm/gtx/norm.hpp

@@ -25,122 +25,115 @@
 #	pragma message("GLM: GLM_GTX_norm extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace norm ///< GLM_GTX_norm extension: Various way to compute vector norms.
 {
-   	namespace test{
-		void main_gtx_norm();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_norm extension: Various way to compute vector norms.
-	namespace norm
-	{
-		/// \addtogroup gtx_norm
-		///@{
-
-		//! Returns the squared length of x.
-		//! From GLM_GTX_norm extension.
-		template <typename T> 
-		T length2(
-			const T x);
-
-		//! Returns the squared length of x.
-		//! From GLM_GTX_norm extension.
-		template <typename T> 
-		T length2(
-			const detail::tvec2<T> & x);
-
-		//! Returns the squared length of x.
-		//! From GLM_GTX_norm extension.
-		template <typename T>
-		T length2(
-			const detail::tvec3<T>& x);
+	/// \addtogroup gtx_norm
+	/// @{
+
+	//! Returns the squared length of x.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T length2(
+		const T x);
+
+	//! Returns the squared length of x.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T length2(
+		const detail::tvec2<T> & x);
+
+	//! Returns the squared length of x.
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T length2(
+		const detail::tvec3<T>& x);
 		
-		//! Returns the squared length of x.
-		//! From GLM_GTX_norm extension.
-		template <typename T> 
-		T length2(
-			const detail::tvec4<T>& x);
+	//! Returns the squared length of x.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T length2(
+		const detail::tvec4<T>& x);
 		
-		//! Returns the squared length of x.
-		//! From GLM_GTX_norm extension.
-		template <typename T>
-		T length2(
-			const detail::tquat<T>& q);
-
-		//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
-		//! From GLM_GTX_norm extension.
-		template <typename T>
-		T distance2(
-			const T p0, 
-			const T p1);
+	//! Returns the squared length of x.
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T length2(
+		const detail::tquat<T>& q);
+
+	//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T distance2(
+		const T p0, 
+		const T p1);
 		
-		//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
-		//! From GLM_GTX_norm extension.
-		template <typename T> 
-		T distance2(
-			const detail::tvec2<T>& p0, 
-			const detail::tvec2<T>& p1);
-
-		//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
-		//! From GLM_GTX_norm extension.
-		template <typename T>
-		T distance2(
-			const detail::tvec3<T>& p0,
-			const detail::tvec3<T>& p1);
-
-		//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
-		//! From GLM_GTX_norm extension.
-		template <typename T>
-		T distance2(
-			const detail::tvec4<T>& p0, 
-			const detail::tvec4<T>& p1);
-
-		//! Returns the L1 norm between x and y.
-		//! From GLM_GTX_norm extension.
-		template <typename T>
-		T l1Norm(
-			const detail::tvec3<T>& x,
-			const detail::tvec3<T>& y);
+	//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T distance2(
+		const detail::tvec2<T>& p0, 
+		const detail::tvec2<T>& p1);
+
+	//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T distance2(
+		const detail::tvec3<T>& p0,
+		const detail::tvec3<T>& p1);
+
+	//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T distance2(
+		const detail::tvec4<T>& p0, 
+		const detail::tvec4<T>& p1);
+
+	//! Returns the L1 norm between x and y.
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T l1Norm(
+		const detail::tvec3<T>& x,
+		const detail::tvec3<T>& y);
 		
-		//! Returns the L1 norm of v.
-		//! From GLM_GTX_norm extension.
-		template <typename T> 
-		T l1Norm(
-			const detail::tvec3<T>& v);
+	//! Returns the L1 norm of v.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T l1Norm(
+		const detail::tvec3<T>& v);
 		
-		//! Returns the L2 norm between x and y.
-		//! From GLM_GTX_norm extension.
-		template <typename T> 
-		T l2Norm(
-			const detail::tvec3<T>& x, 
-			const detail::tvec3<T>& y);
+	//! Returns the L2 norm between x and y.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T l2Norm(
+		const detail::tvec3<T>& x, 
+		const detail::tvec3<T>& y);
 		
-		//! Returns the L2 norm of v.
-		//! From GLM_GTX_norm extension.
-		template <typename T> 
-		T l2Norm(
-			const detail::tvec3<T>& x);
+	//! Returns the L2 norm of v.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T l2Norm(
+		const detail::tvec3<T>& x);
 		
-		//! Returns the L norm between x and y.
-		//! From GLM_GTX_norm extension.
-		template <typename T> 
-		T lxNorm(
-			const detail::tvec3<T>& x,
-			const detail::tvec3<T>& y,
-			unsigned int Depth);
-
-		//! Returns the L norm of v.
-		//! From GLM_GTX_norm extension.
-		template <typename T>
-		T lxNorm(
-			const detail::tvec3<T>& x,
-			unsigned int Depth);
-
-		///@}
-
-	}//namespace norm
-	}//namespace gtx
+	//! Returns the L norm between x and y.
+	//! From GLM_GTX_norm extension.
+	template <typename T> 
+	T lxNorm(
+		const detail::tvec3<T>& x,
+		const detail::tvec3<T>& y,
+		unsigned int Depth);
+
+	//! Returns the L norm of v.
+	//! From GLM_GTX_norm extension.
+	template <typename T>
+	T lxNorm(
+		const detail::tvec3<T>& x,
+		unsigned int Depth);
+
+	/// @}
+}//namespace norm
+}//namespace gtx
 }//namespace glm
 
 #include "norm.inl"

glm/gtx/normal.hpp

@@ -20,31 +20,24 @@
 #	pragma message("GLM: GLM_GTX_normal extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace normal ///< GLM_GTX_normal extension: Compute the normal of a triangle.
 {
-   	namespace test{
-		void main_gtx_normal();
-	}//namespace test
-	
-	namespace gtx{
-	//! GLM_GTX_normal extension: Compute the normal of a triangle.
-    namespace normal
-    {
-		/// \addtogroup gtx_normal
-		///@{
-
-		//! Computes triangle normal from triangle points. 
-		//! From GLM_GTX_normal extension.
-        template <typename T> 
-		detail::tvec3<T> triangleNormal(
-			detail::tvec3<T> const & p1, 
-			detail::tvec3<T> const & p2, 
-			detail::tvec3<T> const & p3);
-
-		///@}
-
-    }//namespace normal
-    }//namespace gtx
+	/// \addtogroup gtx_normal
+	/// @{
+
+	//! Computes triangle normal from triangle points. 
+	//! From GLM_GTX_normal extension.
+    template <typename T> 
+	detail::tvec3<T> triangleNormal(
+		detail::tvec3<T> const & p1, 
+		detail::tvec3<T> const & p2, 
+		detail::tvec3<T> const & p3);
+
+	/// @}
+}//namespace normal
+}//namespace gtx
 }//namespace glm
 
 #include "normal.inl"

glm/gtx/normalize_dot.hpp

@@ -22,37 +22,34 @@
 #	pragma message("GLM: GLM_GTX_normalize_dot extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace normalize_dot	///< GLM_GTX_normalize_dot extension: Dot product of vectors that need to be normalize with a single square root.
 {
-	namespace gtx{
-	//! GLM_GTX_normalize_dot extension: Dot product of vectors that need to be normalize with a single square root.
-	namespace normalize_dot
-	{
-		using namespace gtx::fast_square_root;
-
-		/// \addtogroup gtx_normalize_dot
-		///@{
-
-		//! Normalize parameters and returns the dot product of x and y.
-		//! It's faster that dot(normalize(x), normalize(y)).
-		//! From GLM_GTX_normalize_dot extension.
-		template <typename genType> 
-		typename genType::value_type normalizeDot(
-			genType const & x, 
-			genType const & y);
-
-		//! Normalize parameters and returns the dot product of x and y.
-		//! Faster that dot(fastNormalize(x), fastNormalize(y)).
-		//! From GLM_GTX_normalize_dot extension.
-		template <typename genType> 
-		typename genType::value_type fastNormalizeDot(
-			genType const & x, 
-			genType const & y);
-
-		///@}
-
-	}//namespace normalize_dot
-	}//namespace gtx
+	using namespace gtx::fast_square_root;
+
+	/// \addtogroup gtx_normalize_dot
+	/// @{
+
+	//! Normalize parameters and returns the dot product of x and y.
+	//! It's faster that dot(normalize(x), normalize(y)).
+	//! From GLM_GTX_normalize_dot extension.
+	template <typename genType> 
+	typename genType::value_type normalizeDot(
+		genType const & x, 
+		genType const & y);
+
+	//! Normalize parameters and returns the dot product of x and y.
+	//! Faster that dot(fastNormalize(x), fastNormalize(y)).
+	//! From GLM_GTX_normalize_dot extension.
+	template <typename genType> 
+	typename genType::value_type fastNormalizeDot(
+		genType const & x, 
+		genType const & y);
+
+	/// @}
+}//namespace normalize_dot
+}//namespace gtx
 }//namespace glm
 
 #include "normalize_dot.inl"

glm/gtx/number_precision.hpp

@@ -25,8 +25,7 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_number_precision extension: Defined size types.
-namespace number_precision
+namespace number_precision ///< GLM_GTX_number_precision extension: Defined size types.
 {
 	using namespace gtc::type_precision;
 
@@ -34,7 +33,7 @@ namespace number_precision
 	// Unsigned int vector types 
 
 	/// \addtogroup gtx_number_precision
-	///@{
+	/// @{
 
 	typedef u8			u8vec1;		//!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
 	typedef u16			u16vec1;    //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
@@ -58,7 +57,7 @@ namespace number_precision
 	typedef f64			f64mat1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
 	typedef f64			f64mat1x1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
 
-	///@}
+	/// @}
 }//namespace number_precision
 }//namespace gtx
 }//namespace glm

glm/gtx/ocl_type.hpp

@@ -22,14 +22,13 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_ocl_type extension: OpenCL types.
-namespace ocl_type
+namespace ocl_type ///< GLM_GTX_ocl_type extension: OpenCL types.
 {
 	///////////////////////////
 	// Scalar types 
 
 	/// \addtogroup gtx_ocl_type
-	///@{
+	/// @{
 
 	typedef detail::int8						cl_char;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
 	typedef detail::int16						cl_short;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
@@ -99,8 +98,7 @@ namespace ocl_type
 	//typedef detail::tvec4<detail::float16>		cl_half4;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
 	typedef detail::tvec4<detail::float32>		cl_float4;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
 
-	///@}
-
+	/// @}
 }//namespace ocl_type
 }//namespace gtx
 }//namespace glm

glm/gtx/optimum_pow.hpp

@@ -20,54 +20,47 @@
 #	pragma message("GLM: GLM_GTX_optimum_pow extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace optimum_pow ///< GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
 {
-	namespace test{
-		void main_gtx_optimum_pow();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
-    namespace optimum_pow
-    {
-		/// \addtogroup gtx_optimum_pow
-		///@{
-
-		//! Returns x raised to the power of 2.
-		//! From GLM_GTX_optimum_pow extension.
-        template <typename genType> 
-		genType pow2(const genType& x);
-
-		//! Returns x raised to the power of 3.
-		//! From GLM_GTX_optimum_pow extension.
-        template <typename genType> 
-		genType pow3(const genType& x);
-
-		//! Returns x raised to the power of 4.
-		//! From GLM_GTX_optimum_pow extension.
-		template <typename genType> 
-		genType pow4(const genType& x);
+	/// \addtogroup gtx_optimum_pow
+	/// @{
+
+	//! Returns x raised to the power of 2.
+	//! From GLM_GTX_optimum_pow extension.
+    template <typename genType> 
+	genType pow2(const genType& x);
+
+	//! Returns x raised to the power of 3.
+	//! From GLM_GTX_optimum_pow extension.
+    template <typename genType> 
+	genType pow3(const genType& x);
+
+	//! Returns x raised to the power of 4.
+	//! From GLM_GTX_optimum_pow extension.
+	template <typename genType> 
+	genType pow4(const genType& x);
         
-		//! Checks if the parameter is a power of 2 number. 
-		//! From GLM_GTX_optimum_pow extension.
-        bool powOfTwo(int num);
-
-		//! Checks to determine if the parameter component are power of 2 numbers.
-		//! From GLM_GTX_optimum_pow extension.
-        detail::tvec2<bool> powOfTwo(const detail::tvec2<int>& x);
+	//! Checks if the parameter is a power of 2 number. 
+	//! From GLM_GTX_optimum_pow extension.
+    bool powOfTwo(int num);
 
-		//! Checks to determine if the parameter component are power of 2 numbers. 
-		//! From GLM_GTX_optimum_pow extension.
-        detail::tvec3<bool> powOfTwo(const detail::tvec3<int>& x);
+	//! Checks to determine if the parameter component are power of 2 numbers.
+	//! From GLM_GTX_optimum_pow extension.
+    detail::tvec2<bool> powOfTwo(const detail::tvec2<int>& x);
 
-		//! Checks to determine if the parameter component are power of 2 numbers. 
-		//! From GLM_GTX_optimum_pow extension.
-        detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
+	//! Checks to determine if the parameter component are power of 2 numbers. 
+	//! From GLM_GTX_optimum_pow extension.
+    detail::tvec3<bool> powOfTwo(const detail::tvec3<int>& x);
 
-		///@}
+	//! Checks to determine if the parameter component are power of 2 numbers. 
+	//! From GLM_GTX_optimum_pow extension.
+    detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
 
-    }//namespace optimum_pow
-    }//namespace gtx
+	/// @}
+}//namespace optimum_pow
+}//namespace gtx
 }//namespace glm
 
 #include "optimum_pow.inl"

glm/gtx/orthonormalize.hpp

@@ -20,36 +20,29 @@
 #	pragma message("GLM: GLM_GTX_orthonormalize extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace orthonormalize ///< GLM_GTX_orthonormalize extension: Orthonormalize matrices.
 {
-	namespace test{
-		void main_gtx_orthonormalize();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_orthonormalize extension: Orthonormalize matrices.
-    namespace orthonormalize
-    {
-		/// \addtogroup gtx_orthonormalize
-		///@{
-
-		//! Returns the orthonormalized matrix of m.
-		//! From GLM_GTX_orthonormalize extension.
-		template <typename T> 
-		detail::tmat3x3<T> orthonormalize(
-			const detail::tmat3x3<T>& m);
+	/// \addtogroup gtx_orthonormalize
+	/// @{
+
+	//! Returns the orthonormalized matrix of m.
+	//! From GLM_GTX_orthonormalize extension.
+	template <typename T> 
+	detail::tmat3x3<T> orthonormalize(
+		const detail::tmat3x3<T>& m);
 		
-        //! Orthonormalizes x according y.
-		//! From GLM_GTX_orthonormalize extension.
-		template <typename T> 
-		detail::tvec3<T> orthonormalize(
-			const detail::tvec3<T>& x, 
-			const detail::tvec3<T>& y);
-
-		///@}
-
-    }//namespace orthonormalize
-    }//namespace gtx
+    //! Orthonormalizes x according y.
+	//! From GLM_GTX_orthonormalize extension.
+	template <typename T> 
+	detail::tvec3<T> orthonormalize(
+		const detail::tvec3<T>& x, 
+		const detail::tvec3<T>& y);
+
+	/// @}
+}//namespace orthonormalize
+}//namespace gtx
 }//namespace glm
 
 #include "orthonormalize.inl"

glm/gtx/perpendicular.hpp

@@ -22,45 +22,37 @@
 #	pragma message("GLM: GLM_GTX_perpendicular extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace perpendicular ///< GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
 {
-	namespace test{
-		void main_gtx_perpendicular();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
-    namespace perpendicular
-    {
-		/// \addtogroup gtx_perpendicular
-		///@{
-
-		//! Projects x a perpendicular axis of Normal.
-		//! From GLM_GTX_perpendicular extension.
-		template <typename T> 
-		detail::tvec2<T> perp(
-			detail::tvec2<T> const & x, 
-			detail::tvec2<T> const & Normal);
-
-        //! Projects x a perpendicular axis of Normal.
-		//! From GLM_GTX_perpendicular extension.
-		template <typename T> 
-		detail::tvec3<T> perp(
-			detail::tvec3<T> const & x, 
-			detail::tvec3<T> const & Normal);
-
-        //! Projects x a perpendicular axis of Normal.
-		//! From GLM_GTX_perpendicular extension.
-		template <typename T> 
-		detail::tvec4<T> perp(
-			detail::tvec4<T> const & x, 
-			detail::tvec4<T> const & Normal);
-
-
-		///@}
-		
-    }//namespace perpendicular
-    }//namespace gtx
+	/// \addtogroup gtx_perpendicular
+	/// @{
+
+	//! Projects x a perpendicular axis of Normal.
+	//! From GLM_GTX_perpendicular extension.
+	template <typename T> 
+	detail::tvec2<T> perp(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & Normal);
+
+    //! Projects x a perpendicular axis of Normal.
+	//! From GLM_GTX_perpendicular extension.
+	template <typename T> 
+	detail::tvec3<T> perp(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & Normal);
+
+    //! Projects x a perpendicular axis of Normal.
+	//! From GLM_GTX_perpendicular extension.
+	template <typename T> 
+	detail::tvec4<T> perp(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & Normal);
+
+	/// @}
+}//namespace perpendicular
+}//namespace gtx
 }//namespace glm
 
 #include "perpendicular.inl"

glm/gtx/polar_coordinates.hpp

@@ -20,29 +20,26 @@
 #	pragma message("GLM: GLM_GTX_polar_coordinates extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace polar_coordinates ///< GLM_GTX_polar_coordinates extension: Conversion from Euclidean space to polar space and revert.
 {
-	namespace gtx{
-	//! GLM_GTX_polar_coordinates extension: Conversion from Euclidean space to polar space and revert.
-	namespace polar_coordinates
-	{
-		/// \addtogroup gtx_polar_coordinates
-		///@{
-
-		//! Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude.
-		//! From GLM_GTX_polar_coordinates extension.
-		template <typename T> 
-		detail::tvec3<T> polar(const detail::tvec3<T>& euclidean);
-
-		//! Convert Polar to Euclidean coordinates.
-		//! From GLM_GTX_polar_coordinates extension.
-		template <typename T> 
-		detail::tvec3<T> euclidean(const detail::tvec3<T>& polar);
-
-		///@}
-
-	}//namespace polar_coordinates
-	}//namespace gtx
+	/// \addtogroup gtx_polar_coordinates
+	/// @{
+
+	//! Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude.
+	//! From GLM_GTX_polar_coordinates extension.
+	template <typename T> 
+	detail::tvec3<T> polar(const detail::tvec3<T>& euclidean);
+
+	//! Convert Polar to Euclidean coordinates.
+	//! From GLM_GTX_polar_coordinates extension.
+	template <typename T> 
+	detail::tvec3<T> euclidean(const detail::tvec3<T>& polar);
+
+	/// @}
+}//namespace polar_coordinates
+}//namespace gtx
 }//namespace glm
 
 #include "polar_coordinates.inl"

glm/gtx/projection.hpp

@@ -20,44 +20,37 @@
 #	pragma message("GLM: GLM_GTX_projection extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace projection ///< GLM_GTX_projection extension: Projection of a vector to other one
 {
-	namespace test{
-		void main_gtx_projection();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_projection extension: Projection of a vector to other one
-	namespace projection
-	{
-		/// \addtogroup gtx_projection
-		///@{
-
-		//! Projects x on Normal.
-		//! From GLM_GTX_projection extension.
-		template <typename T> 
-		detail::tvec2<T> proj(
-			detail::tvec2<T> const & x, 
-			detail::tvec2<T> const & Normal);
-		
-		//! Projects x on Normal.
-		//! From GLM_GTX_projection extension.
-		template <typename T> 
-		detail::tvec3<T> proj(
-			detail::tvec3<T> const & x, 
-			detail::tvec3<T> const & Normal);
-
-		//! Projects x on Normal.
-		//! From GLM_GTX_projection extension.
-		template <typename T> 
-		detail::tvec4<T> proj(
-			detail::tvec4<T> const & x, 
-			detail::tvec4<T> const & Normal);
-
-		///@}
+	/// \addtogroup gtx_projection
+	/// @{
+
+	//! Projects x on Normal.
+	//! From GLM_GTX_projection extension.
+	template <typename T> 
+	detail::tvec2<T> proj(
+		detail::tvec2<T> const & x, 
+		detail::tvec2<T> const & Normal);
 		
-	}//namespace projection
-    }//namespace gtx
+	//! Projects x on Normal.
+	//! From GLM_GTX_projection extension.
+	template <typename T> 
+	detail::tvec3<T> proj(
+		detail::tvec3<T> const & x, 
+		detail::tvec3<T> const & Normal);
+
+	//! Projects x on Normal.
+	//! From GLM_GTX_projection extension.
+	template <typename T> 
+	detail::tvec4<T> proj(
+		detail::tvec4<T> const & x, 
+		detail::tvec4<T> const & Normal);
+
+	/// @}
+}//namespace projection
+}//namespace gtx
 }//namespace glm
 
 #include "projection.inl"

glm/gtx/quaternion.hpp

@@ -25,192 +25,189 @@
 #	pragma message("GLM: GLM_GTX_quaternion extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace quaternion ///< GLM_GTX_quaternion extension: Quaternion types and functions
 {
-	namespace gtx{
-	//! GLM_GTX_quaternion extension: Quaternion types and functions
-    namespace quaternion
-    {
-		using namespace gtc::quaternion;
-
-		/// \addtogroup gtx_quaternion
-		///@{
-
-		//! Compute a cross product between a quaternion and a vector. 
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		detail::tvec3<valType> cross(
-			detail::tquat<valType> const & q, 
-			detail::tvec3<valType> const & v);
-
-		//! Compute a cross product between a vector and a quaternion.
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		detail::tvec3<valType> cross(
-			detail::tvec3<valType> const & v, 
-			detail::tquat<valType> const & q);
-
-		//! Compute a point on a path according squad equation. 
-		//! q1 and q2 are control points; s1 and s2 are intermediate control points.
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		detail::tquat<valType> squad(
-			detail::tquat<valType> const & q1, 
-			detail::tquat<valType> const & q2, 
-			detail::tquat<valType> const & s1, 
-			detail::tquat<valType> const & s2, 
-			valType const & h);
-
-		//! Returns an intermediate control point for squad interpolation.
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		detail::tquat<valType> intermediate(
-			detail::tquat<valType> const & prev, 
-			detail::tquat<valType> const & curr, 
-			detail::tquat<valType> const & next);
-
-		//! Returns a exp of a quaternion. 
-		//! From GLM_GTX_quaternion extension.
-        template <typename valType> 
-		detail::tquat<valType> exp(
-			detail::tquat<valType> const & q, 
-			valType const & exponent);
-
-		//! Returns a log of a quaternion. 
-		//! From GLM_GTX_quaternion extension.
-        template <typename valType> 
-		detail::tquat<valType> log(
-			detail::tquat<valType> const & q);
-
-		//! Returns x raised to the y power.
-		//! From GLM_GTX_quaternion extension.
-        template <typename valType> 
-		detail::tquat<valType> pow(
-			detail::tquat<valType> const & x, 
-			valType const & y);
-
-		//! Returns quarternion square root.
-		//! From GLM_GTX_quaternion extension.
-		//template <typename valType> 
-		//detail::tquat<valType> sqrt(
-		//	detail::tquat<valType> const & q);
-
-		//! Rotates a 3 components vector by a quaternion. 
-		//! From GLM_GTX_transform extension.
-		template <typename valType> 
-		detail::tvec3<valType> rotate(
-			detail::tquat<valType> const & q, 
-			detail::tvec3<valType> const & v);
-
-        //! Rotates a 4 components vector by a quaternion.
-		//! From GLM_GTX_transform extension.
-		template <typename valType> 
-		detail::tvec4<valType> rotate(
-			detail::tquat<valType> const & q, 
-			detail::tvec4<valType> const & v);
+	using namespace gtc::quaternion;
+
+	/// \addtogroup gtx_quaternion
+	///@{
+
+	//! Compute a cross product between a quaternion and a vector. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tvec3<valType> cross(
+		detail::tquat<valType> const & q, 
+		detail::tvec3<valType> const & v);
+
+	//! Compute a cross product between a vector and a quaternion.
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tvec3<valType> cross(
+		detail::tvec3<valType> const & v, 
+		detail::tquat<valType> const & q);
+
+	//! Compute a point on a path according squad equation. 
+	//! q1 and q2 are control points; s1 and s2 are intermediate control points.
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tquat<valType> squad(
+		detail::tquat<valType> const & q1, 
+		detail::tquat<valType> const & q2, 
+		detail::tquat<valType> const & s1, 
+		detail::tquat<valType> const & s2, 
+		valType const & h);
+
+	//! Returns an intermediate control point for squad interpolation.
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tquat<valType> intermediate(
+		detail::tquat<valType> const & prev, 
+		detail::tquat<valType> const & curr, 
+		detail::tquat<valType> const & next);
+
+	//! Returns a exp of a quaternion. 
+	//! From GLM_GTX_quaternion extension.
+    template <typename valType> 
+	detail::tquat<valType> exp(
+		detail::tquat<valType> const & q, 
+		valType const & exponent);
+
+	//! Returns a log of a quaternion. 
+	//! From GLM_GTX_quaternion extension.
+    template <typename valType> 
+	detail::tquat<valType> log(
+		detail::tquat<valType> const & q);
+
+	//! Returns x raised to the y power.
+	//! From GLM_GTX_quaternion extension.
+    template <typename valType> 
+	detail::tquat<valType> pow(
+		detail::tquat<valType> const & x, 
+		valType const & y);
+
+	//! Returns quarternion square root.
+	//! From GLM_GTX_quaternion extension.
+	//template <typename valType> 
+	//detail::tquat<valType> sqrt(
+	//	detail::tquat<valType> const & q);
+
+	//! Rotates a 3 components vector by a quaternion. 
+	//! From GLM_GTX_transform extension.
+	template <typename valType> 
+	detail::tvec3<valType> rotate(
+		detail::tquat<valType> const & q, 
+		detail::tvec3<valType> const & v);
+
+    //! Rotates a 4 components vector by a quaternion.
+	//! From GLM_GTX_transform extension.
+	template <typename valType> 
+	detail::tvec4<valType> rotate(
+		detail::tquat<valType> const & q, 
+		detail::tvec4<valType> const & v);
 		
-        //! Returns the quaternion rotation angle. 
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		valType angle(
-			detail::tquat<valType> const & x);
-
-		//! Returns the q rotation axis. 
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		detail::tvec3<valType> axis(
-			detail::tquat<valType> const & x);
-
-		//! Build a quaternion from an angle and a normalized axis. 
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		detail::tquat<valType> angleAxis(
-			valType const & angle, 
-			valType const & x, 
-			valType const & y, 
-			valType const & z);
-
-        //! Build a quaternion from an angle and a normalized axis.
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		detail::tquat<valType> angleAxis(
-			valType const & angle, 
-			detail::tvec3<valType> const & axis);
-
-		//! Extract the real component of a quaternion.
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		valType extractRealComponent(
-			detail::tquat<valType> const & q);
-
-        //! Returns roll value of euler angles. 
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		valType roll(
-			detail::tquat<valType> const & x);
-
-		//! Returns pitch value of euler angles. 
-		//! From GLM_GTX_quaternion extension.
-        template <typename valType> 
-		valType pitch(
-			detail::tquat<valType> const & x);
-
-        //! Returns yaw value of euler angles. 
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		valType yaw(
-			detail::tquat<valType> const & x);
+    //! Returns the quaternion rotation angle. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	valType angle(
+		detail::tquat<valType> const & x);
+
+	//! Returns the q rotation axis. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tvec3<valType> axis(
+		detail::tquat<valType> const & x);
+
+	//! Build a quaternion from an angle and a normalized axis. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tquat<valType> angleAxis(
+		valType const & angle, 
+		valType const & x, 
+		valType const & y, 
+		valType const & z);
+
+    //! Build a quaternion from an angle and a normalized axis.
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tquat<valType> angleAxis(
+		valType const & angle, 
+		detail::tvec3<valType> const & axis);
+
+	//! Extract the real component of a quaternion.
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	valType extractRealComponent(
+		detail::tquat<valType> const & q);
+
+    //! Returns roll value of euler angles. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	valType roll(
+		detail::tquat<valType> const & x);
+
+	//! Returns pitch value of euler angles. 
+	//! From GLM_GTX_quaternion extension.
+    template <typename valType> 
+	valType pitch(
+		detail::tquat<valType> const & x);
+
+    //! Returns yaw value of euler angles. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	valType yaw(
+		detail::tquat<valType> const & x);
 		
-		//! Returns euler angles, yitch as x, yaw as y, roll as z. 
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		detail::tvec3<valType> eularAngles(
-			detail::tquat<valType> const & x);
-
-		//! Converts a quaternion to a 3 * 3 matrix. 
-		//! From GLM_GTX_quaternion extension.
-        template <typename valType> 
-		detail::tmat3x3<valType> toMat3(
-			detail::tquat<valType> const & x){return gtc::quaternion::mat3_cast(x);}
-
-		//! Converts a quaternion to a 4 * 4 matrix. 
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> toMat4(
-			detail::tquat<valType> const & x){return gtc::quaternion::mat4_cast(x);}
-
-		//! Converts a 3 * 3 matrix to a quaternion. 
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		detail::tquat<valType> toQuat(
-			detail::tmat3x3<valType> const & x){return gtc::quaternion::quat_cast(x);}
-
-		//! Converts a 4 * 4 matrix to a quaternion. 
-		//! From GLM_GTX_quaternion extension.
-		template <typename valType> 
-		detail::tquat<valType> toQuat(
-			detail::tmat4x4<valType> const & x){return gtc::quaternion::quat_cast(x);}
-
-		//! Quaternion interpolation using the rotation short path. 
-		//! From GLM_GTX_quaternion extension.
-		template <typename T>
-		detail::tquat<T> shortMix(
-			detail::tquat<T> const & x, 
-			detail::tquat<T> const & y, 
-			T const & a);
-
-		//! Quaternion normalized linear interpolation. 
-		//! From GLM_GTX_quaternion extension.
-		template <typename T>
-		detail::tquat<T> fastMix(
-			detail::tquat<T> const & x, 
-			detail::tquat<T> const & y, 
-			T const & a);
-
-		///@}
-
-    }//namespace quaternion
-    }//namespace gtx
+	//! Returns euler angles, yitch as x, yaw as y, roll as z. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tvec3<valType> eularAngles(
+		detail::tquat<valType> const & x);
+
+	//! Converts a quaternion to a 3 * 3 matrix. 
+	//! From GLM_GTX_quaternion extension.
+    template <typename valType> 
+	detail::tmat3x3<valType> toMat3(
+		detail::tquat<valType> const & x){return gtc::quaternion::mat3_cast(x);}
+
+	//! Converts a quaternion to a 4 * 4 matrix. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> toMat4(
+		detail::tquat<valType> const & x){return gtc::quaternion::mat4_cast(x);}
+
+	//! Converts a 3 * 3 matrix to a quaternion. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tquat<valType> toQuat(
+		detail::tmat3x3<valType> const & x){return gtc::quaternion::quat_cast(x);}
+
+	//! Converts a 4 * 4 matrix to a quaternion. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename valType> 
+	detail::tquat<valType> toQuat(
+		detail::tmat4x4<valType> const & x){return gtc::quaternion::quat_cast(x);}
+
+	//! Quaternion interpolation using the rotation short path. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename T>
+	detail::tquat<T> shortMix(
+		detail::tquat<T> const & x, 
+		detail::tquat<T> const & y, 
+		T const & a);
+
+	//! Quaternion normalized linear interpolation. 
+	//! From GLM_GTX_quaternion extension.
+	template <typename T>
+	detail::tquat<T> fastMix(
+		detail::tquat<T> const & x, 
+		detail::tquat<T> const & y, 
+		T const & a);
+
+	/// @}
+}//namespace quaternion
+}//namespace gtx
 } //namespace glm
 
 #include "quaternion.inl"

glm/gtx/random.hpp

@@ -25,11 +25,10 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_random extension: Generate random number from various distribution methods
-namespace random
+namespace random ///< GLM_GTX_random extension: Generate random number from various distribution methods
 {
 	/// \addtogroup gtx_random
-	///@{
+	/// @{
 
 	//! Generate a random number in the interval [-1, 1], according a linear distribution.
 	//! From GLM_GTX_random extension.

glm/gtx/raw_data.hpp

@@ -22,36 +22,34 @@
 #endif
 
 namespace glm{
-namespace gtx
+namespace gtx{
+namespace raw_data ///< GLM_GTX_raw_data extension: Projection of a vector to other one
 {
-	//! GLM_GTX_raw_data extension: Projection of a vector to other one
-    namespace raw_data
-    {
-		using namespace gtc::type_precision;
-
-		/// \addtogroup gtx_raw_data
-		///@{
-
-		//! Type for byte numbers. 
-		//! From GLM_GTX_raw_data extension.
-		typedef uint8		byte;
-
-		//! Type for word numbers. 
-		//! From GLM_GTX_raw_data extension.
-		typedef uint16		word;
-
-		//! Type for dword numbers. 
-		//! From GLM_GTX_raw_data extension.
-		typedef uint32		dword;
-
-		//! Type for qword numbers. 
-		//! From GLM_GTX_raw_data extension.
-		typedef uint64		qword;
-
-		///@}
-	}
-}//namespace gtx
-}//namespace glm
+	using namespace gtc::type_precision;
+
+	/// \addtogroup gtx_raw_data
+	///@{
+
+	//! Type for byte numbers. 
+	//! From GLM_GTX_raw_data extension.
+	typedef uint8		byte;
+
+	//! Type for word numbers. 
+	//! From GLM_GTX_raw_data extension.
+	typedef uint16		word;
+
+	//! Type for dword numbers. 
+	//! From GLM_GTX_raw_data extension.
+	typedef uint32		dword;
+
+	//! Type for qword numbers. 
+	//! From GLM_GTX_raw_data extension.
+	typedef uint64		qword;
+
+	///@}
+}// namespace raw_data
+}// namespace gtx
+}// namespace glm
 
 #include "raw_data.inl"
 

glm/gtx/reciprocal.hpp

@@ -17,86 +17,79 @@
 #	pragma message("GLM: GLM_GTX_reciprocal extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace reciprocal ///< GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
 {
-   	namespace test{
-		void main_gtx_reciprocal();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
-	namespace reciprocal
-	{
-		/// \addtogroup gtx_reciprocal
-		///@{
-
-		//! Secant function. 
-		//! hypotenuse / adjacent or 1 / cos(x)
-		//! From GLM_GTX_reciprocal extension.
-		template <typename genType> 
-		genType sec(genType const & angle);
-
-		//! Cosecant function. 
-		//! hypotenuse / opposite or 1 / sin(x)
-		//! From GLM_GTX_reciprocal extension.
-		template <typename genType> 
-		genType csc(genType const & angle);
+	/// \addtogroup gtx_reciprocal
+	/// @{
+
+	//! Secant function. 
+	//! hypotenuse / adjacent or 1 / cos(x)
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType sec(genType const & angle);
+
+	//! Cosecant function. 
+	//! hypotenuse / opposite or 1 / sin(x)
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType csc(genType const & angle);
 		
-		//! Cotangent function. 
-		//! adjacent / opposite or 1 / tan(x)
-		//! From GLM_GTX_reciprocal extension.
-		template <typename genType> 
-		genType cot(genType const & angle);
-
-		//! Inverse secant function. 
-		//! From GLM_GTX_reciprocal extension.
-		template <typename genType> 
-		genType asec(genType const & x);
-
-		//! Inverse cosecant function. 
-		//! From GLM_GTX_reciprocal extension.
-		template <typename genType> 
-		genType acsc(genType const & x);
+	//! Cotangent function. 
+	//! adjacent / opposite or 1 / tan(x)
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType cot(genType const & angle);
+
+	//! Inverse secant function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType asec(genType const & x);
+
+	//! Inverse cosecant function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType acsc(genType const & x);
 		
-		//! Inverse cotangent function. 
-		//! From GLM_GTX_reciprocal extension.
-		template <typename genType> 
-		genType acot(genType const & x);
-
-		//! Secant hyperbolic function. 
-		//! From GLM_GTX_reciprocal extension.
-		template <typename genType> 
-		genType sech(genType const & angle);
-
-		//! Cosecant hyperbolic function. 
-		//! From GLM_GTX_reciprocal extension.
-		template <typename genType> 
-		genType csch(genType const & angle);
+	//! Inverse cotangent function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType acot(genType const & x);
+
+	//! Secant hyperbolic function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType sech(genType const & angle);
+
+	//! Cosecant hyperbolic function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType csch(genType const & angle);
 		
-		//! Cotangent hyperbolic function. 
-		//! From GLM_GTX_reciprocal extension.
-		template <typename genType> 
-		genType coth(genType const & angle);
-
-		//! Inverse secant hyperbolic function. 
-		//! From GLM_GTX_reciprocal extension.
-		template <typename genType> 
-		genType asech(genType const & x);
-
-		//! Inverse cosecant hyperbolic function. 
-		//! From GLM_GTX_reciprocal extension.
-		template <typename genType> 
-		genType acsch(genType const & x);
+	//! Cotangent hyperbolic function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType coth(genType const & angle);
+
+	//! Inverse secant hyperbolic function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType asech(genType const & x);
+
+	//! Inverse cosecant hyperbolic function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType acsch(genType const & x);
 		
-		//! Inverse cotangent hyperbolic function. 
-		//! From GLM_GTX_reciprocal extension.
-		template <typename genType> 
-		genType acoth(genType const & x);
-
-		///@}
-
-	}//namespace reciprocal
-	}//namespace gtx
+	//! Inverse cotangent hyperbolic function. 
+	//! From GLM_GTX_reciprocal extension.
+	template <typename genType> 
+	genType acoth(genType const & x);
+
+	/// @}
+}//namespace reciprocal
+}//namespace gtx
 }//namespace glm
 
 #include "reciprocal.inl"

glm/gtx/rotate_vector.hpp

@@ -23,88 +23,86 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_rotate_vector extension: Function to directly rotate a vector
-namespace rotate_vector
+namespace rotate_vector ///< GLM_GTX_rotate_vector extension: Function to directly rotate a vector
 {
-		using namespace transform;
+	using namespace transform;
 
-		/// \addtogroup gtx_rotate_vector
-		///@{
+	/// \addtogroup gtx_rotate_vector
+	/// @{
 
-		//! Rotate a two dimensional vector.
-		//! From GLM_GTX_rotate_vector extension.
-		template <typename T> 
-		detail::tvec2<T> rotate(
-            detail::tvec2<T> const & v, 
-			T const & angle);
+	//! Rotate a two dimensional vector.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec2<T> rotate(
+        detail::tvec2<T> const & v, 
+		T const & angle);
 		
-		//! Rotate a three dimensional vector around an axis.
-		//! From GLM_GTX_rotate_vector extension.
-		template <typename T> 
-		detail::tvec3<T> rotate(
-            detail::tvec3<T> const & v, 
-			T const & angle, 
-            detail::tvec3<T> const & normal);
+	//! Rotate a three dimensional vector around an axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec3<T> rotate(
+        detail::tvec3<T> const & v, 
+		T const & angle, 
+        detail::tvec3<T> const & normal);
 		
-		//! Rotate a four dimensional vector around an axis.
-		//! From GLM_GTX_rotate_vector extension.
-		template <typename T> 
-		detail::tvec4<T> rotate(
-            detail::tvec4<T> const & v, 
-            T const & angle, 
-			detail::tvec3<T> const & normal);
+	//! Rotate a four dimensional vector around an axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec4<T> rotate(
+        detail::tvec4<T> const & v, 
+        T const & angle, 
+		detail::tvec3<T> const & normal);
 		
-		//! Rotate a three dimensional vector around the X axis.
-		//! From GLM_GTX_rotate_vector extension.
-		template <typename T> 
-		detail::tvec3<T> rotateX(
-            detail::tvec3<T> const & v, 
-			T const & angle);
+	//! Rotate a three dimensional vector around the X axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec3<T> rotateX(
+        detail::tvec3<T> const & v, 
+		T const & angle);
 
-		//! Rotate a three dimensional vector around the Y axis.
-		//! From GLM_GTX_rotate_vector extension.
-		template <typename T> 
-		detail::tvec3<T> rotateY(
-			detail::tvec3<T> const & v, 
-			T const & angle);
+	//! Rotate a three dimensional vector around the Y axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec3<T> rotateY(
+		detail::tvec3<T> const & v, 
+		T const & angle);
 		
-		//! Rotate a three dimensional vector around the Z axis.
-		//! From GLM_GTX_rotate_vector extension.
-		template <typename T> 
-		detail::tvec3<T> rotateZ(
-            detail::tvec3<T> const & v, 
-			T const & angle);
+	//! Rotate a three dimensional vector around the Z axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec3<T> rotateZ(
+        detail::tvec3<T> const & v, 
+		T const & angle);
 		
-		//! Rotate a four dimentionnals vector around the X axis.
-		//! From GLM_GTX_rotate_vector extension.
-		template <typename T> 
-		detail::tvec4<T> rotateX(
-            detail::tvec4<T> const & v, 
-			T const & angle);
+	//! Rotate a four dimentionnals vector around the X axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec4<T> rotateX(
+        detail::tvec4<T> const & v, 
+		T const & angle);
 		
-		//! Rotate a four dimensional vector around the X axis.
-		//! From GLM_GTX_rotate_vector extension.
-		template <typename T> 
-		detail::tvec4<T> rotateY(
-            detail::tvec4<T> const & v, 
-			T const & angle);
+	//! Rotate a four dimensional vector around the X axis.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec4<T> rotateY(
+        detail::tvec4<T> const & v, 
+		T const & angle);
 		
-		//! Rotate a four dimensional vector around the X axis. 
-		//! From GLM_GTX_rotate_vector extension.
-		template <typename T> 
-		detail::tvec4<T> rotateZ(
-            detail::tvec4<T> const & v, 
-			T const & angle);
+	//! Rotate a four dimensional vector around the X axis. 
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tvec4<T> rotateZ(
+        detail::tvec4<T> const & v, 
+		T const & angle);
 		
-		//! Build a rotation matrix from a normal and a up vector.
-		//! From GLM_GTX_rotate_vector extension.
-		template <typename T> 
-		detail::tmat4x4<T> orientation(
-            detail::tvec3<T> const & Normal, 
-            detail::tvec3<T> const & Up);
+	//! Build a rotation matrix from a normal and a up vector.
+	//! From GLM_GTX_rotate_vector extension.
+	template <typename T> 
+	detail::tmat4x4<T> orientation(
+        detail::tvec3<T> const & Normal, 
+        detail::tvec3<T> const & Up);
 
-		///@}
-		
+	/// @}
 }//namespace rotate_vector
 }//namespace gtx
 }//namespace glm

glm/gtx/simd_mat4.hpp

@@ -28,157 +28,153 @@
 #	pragma message("GLM: GLM_GTX_simd_mat4 extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace detail
+	/// 4x4 Matrix implemented using SIMD SEE intrinsics.
+	/// \ingroup gtx_simd_mat4
+	GLM_ALIGNED_STRUCT(16) fmat4x4SIMD
 	{
-		/// 4x4 Matrix implemented using SIMD SEE intrinsics.
-		/// \ingroup gtx_simd_mat4
-		GLM_ALIGNED_STRUCT(16) fmat4x4SIMD
-		{
-			enum ctor{null};
-
-			typedef float value_type;
-			typedef fvec4SIMD col_type;
-			typedef fvec4SIMD row_type;
-			typedef std::size_t size_type;
-			static size_type value_size();
-			static size_type col_size();
-			static size_type row_size();
-			static bool is_matrix();
-
-			fvec4SIMD Data[4];
-
-			//////////////////////////////////////
-			// Constructors
-
-			fmat4x4SIMD();
-			explicit fmat4x4SIMD(float const & s);
-			explicit fmat4x4SIMD(
-				float const & x0, float const & y0, float const & z0, float const & w0,
-				float const & x1, float const & y1, float const & z1, float const & w1,
-				float const & x2, float const & y2, float const & z2, float const & w2,
-				float const & x3, float const & y3, float const & z3, float const & w3);
-			explicit fmat4x4SIMD(
-				fvec4SIMD const & v0,
-				fvec4SIMD const & v1,
-				fvec4SIMD const & v2,
-				fvec4SIMD const & v3);
-			explicit fmat4x4SIMD(
-				tmat4x4<float> const & m);
-
-			// Conversions
-			//template <typename U> 
-			//explicit tmat4x4(tmat4x4<U> const & m);
-
-			//explicit tmat4x4(tmat2x2<T> const & x);
-			//explicit tmat4x4(tmat3x3<T> const & x);
-			//explicit tmat4x4(tmat2x3<T> const & x);
-			//explicit tmat4x4(tmat3x2<T> const & x);
-			//explicit tmat4x4(tmat2x4<T> const & x);
-			//explicit tmat4x4(tmat4x2<T> const & x);
-			//explicit tmat4x4(tmat3x4<T> const & x);
-			//explicit tmat4x4(tmat4x3<T> const & x);
-
-			// Accesses
-			fvec4SIMD & operator[](size_type i);
-			fvec4SIMD const & operator[](size_type i) const;
-
-			// Unary updatable operators
-			fmat4x4SIMD & operator= (fmat4x4SIMD const & m);
-			fmat4x4SIMD & operator+= (float const & s);
-			fmat4x4SIMD & operator+= (fmat4x4SIMD const & m);
-			fmat4x4SIMD & operator-= (float const & s);
-			fmat4x4SIMD & operator-= (fmat4x4SIMD const & m);
-			fmat4x4SIMD & operator*= (float const & s);
-			fmat4x4SIMD & operator*= (fmat4x4SIMD const & m);
-			fmat4x4SIMD & operator/= (float const & s);
-			fmat4x4SIMD & operator/= (fmat4x4SIMD const & m);
-			fmat4x4SIMD & operator++ ();
-			fmat4x4SIMD & operator-- ();
-		};
-
-		// Binary operators
-		fmat4x4SIMD operator+ (fmat4x4SIMD const & m, float const & s);
-		fmat4x4SIMD operator+ (float const & s, fmat4x4SIMD const & m);
-		fmat4x4SIMD operator+ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+		enum ctor{null};
+
+		typedef float value_type;
+		typedef fvec4SIMD col_type;
+		typedef fvec4SIMD row_type;
+		typedef std::size_t size_type;
+		static size_type value_size();
+		static size_type col_size();
+		static size_type row_size();
+		static bool is_matrix();
+
+		fvec4SIMD Data[4];
+
+		//////////////////////////////////////
+		// Constructors
+
+		fmat4x4SIMD();
+		explicit fmat4x4SIMD(float const & s);
+		explicit fmat4x4SIMD(
+			float const & x0, float const & y0, float const & z0, float const & w0,
+			float const & x1, float const & y1, float const & z1, float const & w1,
+			float const & x2, float const & y2, float const & z2, float const & w2,
+			float const & x3, float const & y3, float const & z3, float const & w3);
+		explicit fmat4x4SIMD(
+			fvec4SIMD const & v0,
+			fvec4SIMD const & v1,
+			fvec4SIMD const & v2,
+			fvec4SIMD const & v3);
+		explicit fmat4x4SIMD(
+			tmat4x4<float> const & m);
+
+		// Conversions
+		//template <typename U> 
+		//explicit tmat4x4(tmat4x4<U> const & m);
+
+		//explicit tmat4x4(tmat2x2<T> const & x);
+		//explicit tmat4x4(tmat3x3<T> const & x);
+		//explicit tmat4x4(tmat2x3<T> const & x);
+		//explicit tmat4x4(tmat3x2<T> const & x);
+		//explicit tmat4x4(tmat2x4<T> const & x);
+		//explicit tmat4x4(tmat4x2<T> const & x);
+		//explicit tmat4x4(tmat3x4<T> const & x);
+		//explicit tmat4x4(tmat4x3<T> const & x);
+
+		// Accesses
+		fvec4SIMD & operator[](size_type i);
+		fvec4SIMD const & operator[](size_type i) const;
+
+		// Unary updatable operators
+		fmat4x4SIMD & operator= (fmat4x4SIMD const & m);
+		fmat4x4SIMD & operator+= (float const & s);
+		fmat4x4SIMD & operator+= (fmat4x4SIMD const & m);
+		fmat4x4SIMD & operator-= (float const & s);
+		fmat4x4SIMD & operator-= (fmat4x4SIMD const & m);
+		fmat4x4SIMD & operator*= (float const & s);
+		fmat4x4SIMD & operator*= (fmat4x4SIMD const & m);
+		fmat4x4SIMD & operator/= (float const & s);
+		fmat4x4SIMD & operator/= (fmat4x4SIMD const & m);
+		fmat4x4SIMD & operator++ ();
+		fmat4x4SIMD & operator-- ();
+	};
+
+	// Binary operators
+	fmat4x4SIMD operator+ (fmat4x4SIMD const & m, float const & s);
+	fmat4x4SIMD operator+ (float const & s, fmat4x4SIMD const & m);
+	fmat4x4SIMD operator+ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
 	    
-		fmat4x4SIMD operator- (fmat4x4SIMD const & m, float const & s);
-		fmat4x4SIMD operator- (float const & s, fmat4x4SIMD const & m);
-		fmat4x4SIMD operator- (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+	fmat4x4SIMD operator- (fmat4x4SIMD const & m, float const & s);
+	fmat4x4SIMD operator- (float const & s, fmat4x4SIMD const & m);
+	fmat4x4SIMD operator- (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
 
-		fmat4x4SIMD operator* (fmat4x4SIMD const & m, float const & s);
-		fmat4x4SIMD operator* (float const & s, fmat4x4SIMD const & m);
+	fmat4x4SIMD operator* (fmat4x4SIMD const & m, float const & s);
+	fmat4x4SIMD operator* (float const & s, fmat4x4SIMD const & m);
 
-		fvec4SIMD operator* (fmat4x4SIMD const & m, fvec4SIMD const & v);
-		fvec4SIMD operator* (fvec4SIMD const & v, fmat4x4SIMD const & m);
+	fvec4SIMD operator* (fmat4x4SIMD const & m, fvec4SIMD const & v);
+	fvec4SIMD operator* (fvec4SIMD const & v, fmat4x4SIMD const & m);
 
-		fmat4x4SIMD operator* (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+	fmat4x4SIMD operator* (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
 
-		fmat4x4SIMD operator/ (fmat4x4SIMD const & m, float const & s);
-		fmat4x4SIMD operator/ (float const & s, fmat4x4SIMD const & m);
+	fmat4x4SIMD operator/ (fmat4x4SIMD const & m, float const & s);
+	fmat4x4SIMD operator/ (float const & s, fmat4x4SIMD const & m);
 
-		fvec4SIMD operator/ (fmat4x4SIMD const & m, fvec4SIMD const & v);
-		fvec4SIMD operator/ (fvec4SIMD const & v, fmat4x4SIMD const & m);
+	fvec4SIMD operator/ (fmat4x4SIMD const & m, fvec4SIMD const & v);
+	fvec4SIMD operator/ (fvec4SIMD const & v, fmat4x4SIMD const & m);
 
-		fmat4x4SIMD operator/ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
+	fmat4x4SIMD operator/ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
 
-		// Unary constant operators
-		fmat4x4SIMD const operator-  (fmat4x4SIMD const & m);
-		fmat4x4SIMD const operator-- (fmat4x4SIMD const & m, int);
-		fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
+	// Unary constant operators
+	fmat4x4SIMD const operator-  (fmat4x4SIMD const & m);
+	fmat4x4SIMD const operator-- (fmat4x4SIMD const & m, int);
+	fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
+}//namespace detail
 
-	}//namespace detail
-
-	namespace gtx{
-	//! GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
-	namespace simd_mat4
-	{
-		typedef detail::fmat4x4SIMD simdMat4;
-
-		/// \addtogroup gtx_simd_mat4
-		///@{
-
-		//! Convert a simdMat4 to a mat4.
-		//! (From GLM_GTX_simd_mat4 extension)
-		detail::tmat4x4<float> mat4_cast(
-			detail::fmat4x4SIMD const & x);
-
-		//! Multiply matrix x by matrix y component-wise, i.e.,
-		//! result[i][j] is the scalar product of x[i][j] and y[i][j].
-		//! (From GLM_GTX_simd_mat4 extension).
-		detail::fmat4x4SIMD matrixCompMult(
-			detail::fmat4x4SIMD const & x,
-			detail::fmat4x4SIMD const & y);
-
-		//! Treats the first parameter c as a column vector
-		//! and the second parameter r as a row vector
-		//! and does a linear algebraic matrix multiply c * r.
-		//! (From GLM_GTX_simd_mat4 extension).
-		detail::fmat4x4SIMD outerProduct(
-			detail::fvec4SIMD const & c,
-			detail::fvec4SIMD const & r);
-
-		//! Returns the transposed matrix of x
-		//! (From GLM_GTX_simd_mat4 extension).
-		detail::fmat4x4SIMD transpose(
-			detail::fmat4x4SIMD const & x);
-
-		//! Return the determinant of a mat4 matrix.
-		//! (From GLM_GTX_simd_mat4 extension).
-		float determinant(
-			detail::fmat4x4SIMD const & m);
-
-		//! Return the inverse of a mat4 matrix.
-		//! (From GLM_GTX_simd_mat4 extension).
-		detail::fmat4x4SIMD inverse(
-			detail::fmat4x4SIMD const & m);
-
-		///@}
-
-	}//namespace simd_mat4
-	}//namespace gtx
-}//namespace glm
+namespace gtx{
+namespace simd_mat4 ///< GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
+{
+	typedef detail::fmat4x4SIMD simdMat4;
+
+	/// \addtogroup gtx_simd_mat4
+	///@{
+
+	//! Convert a simdMat4 to a mat4.
+	//! (From GLM_GTX_simd_mat4 extension)
+	detail::tmat4x4<float> mat4_cast(
+		detail::fmat4x4SIMD const & x);
+
+	//! Multiply matrix x by matrix y component-wise, i.e.,
+	//! result[i][j] is the scalar product of x[i][j] and y[i][j].
+	//! (From GLM_GTX_simd_mat4 extension).
+	detail::fmat4x4SIMD matrixCompMult(
+		detail::fmat4x4SIMD const & x,
+		detail::fmat4x4SIMD const & y);
+
+	//! Treats the first parameter c as a column vector
+	//! and the second parameter r as a row vector
+	//! and does a linear algebraic matrix multiply c * r.
+	//! (From GLM_GTX_simd_mat4 extension).
+	detail::fmat4x4SIMD outerProduct(
+		detail::fvec4SIMD const & c,
+		detail::fvec4SIMD const & r);
+
+	//! Returns the transposed matrix of x
+	//! (From GLM_GTX_simd_mat4 extension).
+	detail::fmat4x4SIMD transpose(
+		detail::fmat4x4SIMD const & x);
+
+	//! Return the determinant of a mat4 matrix.
+	//! (From GLM_GTX_simd_mat4 extension).
+	float determinant(
+		detail::fmat4x4SIMD const & m);
+
+	//! Return the inverse of a mat4 matrix.
+	//! (From GLM_GTX_simd_mat4 extension).
+	detail::fmat4x4SIMD inverse(
+		detail::fmat4x4SIMD const & m);
+
+	/// @}
+}// namespace simd_mat4
+}// namespace gtx
+}// namespace glm
 
 #include "simd_mat4.inl"
 

glm/gtx/simd_vec4.hpp

@@ -28,446 +28,443 @@
 #	pragma message("GLM: GLM_GTX_simd_vec4 extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace detail
+	/// 4-dimensional vector implemented using SIMD SEE intrinsics.
+	/// \ingroup gtx_simd_vec4
+	GLM_ALIGNED_STRUCT(4) fvec4SIMD
 	{
-		/// 4-dimensional vector implemented using SIMD SEE intrinsics.
-		/// \ingroup gtx_simd_vec4
-		GLM_ALIGNED_STRUCT(4) fvec4SIMD
-		{
-			enum ctor{null};
-			typedef __m128 value_type;
-			typedef std::size_t size_type;
-			static size_type value_size();
-
-			typedef fvec4SIMD type;
-			typedef tvec4<bool> bool_type;
-
-			__m128 Data;
-
-			//////////////////////////////////////
-			// Implicit basic constructors
-
-			fvec4SIMD();
-			fvec4SIMD(__m128 const & Data);
-			fvec4SIMD(fvec4SIMD const & v);
-
-			//////////////////////////////////////
-			// Explicit basic constructors
-
-			explicit fvec4SIMD(
-				ctor);
-			explicit fvec4SIMD(
-				float const & s);
-			explicit fvec4SIMD(
-				float const & x, 
-				float const & y, 
-				float const & z, 
-				float const & w);
-			explicit fvec4SIMD(
-				tvec4<float> const & v);
-
-			////////////////////////////////////////
-			//// Convertion vector constructors
-
-			fvec4SIMD(vec2 const & v, float const & s1, float const & s2);
-			fvec4SIMD(float const & s1, vec2 const & v, float const & s2);
-			fvec4SIMD(float const & s1, float const & s2, vec2 const & v);
-			fvec4SIMD(vec3 const & v, float const & s);
-			fvec4SIMD(float const & s, vec3 const & v);
-			fvec4SIMD(vec2 const & v1, vec2 const & v2);
-			//fvec4SIMD(ivec4SIMD const & v);
-
-			//////////////////////////////////////
-			// Unary arithmetic operators
-
-			fvec4SIMD& operator= (fvec4SIMD const & v);
-			fvec4SIMD& operator+=(fvec4SIMD const & v);
-			fvec4SIMD& operator-=(fvec4SIMD const & v);
-			fvec4SIMD& operator*=(fvec4SIMD const & v);
-			fvec4SIMD& operator/=(fvec4SIMD const & v);
-
-			fvec4SIMD& operator+=(float const & s);
-			fvec4SIMD& operator-=(float const & s);
-			fvec4SIMD& operator*=(float const & s);
-			fvec4SIMD& operator/=(float const & s);
-
-			fvec4SIMD& operator++();
-			fvec4SIMD& operator--();
-
-			//////////////////////////////////////
-			// Swizzle operators
-
-			template <comp X, comp Y, comp Z, comp W>
-			fvec4SIMD& swizzle();
-			template <comp X, comp Y, comp Z, comp W>
-			fvec4SIMD swizzle() const;
-			template <comp X, comp Y, comp Z>
-			fvec4SIMD swizzle() const;
-			template <comp X, comp Y>
-			fvec4SIMD swizzle() const;
-			template <comp X>
-			fvec4SIMD swizzle() const;
-		};
-
-	}//namespace detail
-
-	namespace gtx{
-	//! GLM_GTX_simd_vec4 extension: SIMD implementation of vec4 type.
-	namespace simd_vec4
-	{
-		typedef detail::fvec4SIMD simdVec4;
-
-		/// \addtogroup gtx_simd_vec4
-		///@{
-
-		//! Convert a simdVec4 to a vec4.
-		//! (From GLM_GTX_simd_vec4 extension)
-		detail::tvec4<float> vec4_cast(
-			detail::fvec4SIMD const & x);
-
-		//! Returns x if x >= 0; otherwise, it returns -x. 
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD abs(detail::fvec4SIMD const & x);
-
-		//! Returns 1.0 if x > 0, 0.0 if x = 0, or -1.0 if x < 0. 
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD sign(detail::fvec4SIMD const & x);
-
-		//! Returns a value equal to the nearest integer that is less then or equal to x. 
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD floor(detail::fvec4SIMD const & x);
-
-		//! Returns a value equal to the nearest integer to x 
-		//! whose absolute value is not larger than the absolute value of x. 
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD trunc(detail::fvec4SIMD const & x);
-
-		//! Returns a value equal to the nearest integer to x. 
-		//! The fraction 0.5 will round in a direction chosen by the 
-		//! implementation, presumably the direction that is fastest. 
-		//! This includes the possibility that round(x) returns the 
-		//! same value as roundEven(x) for all values of x. 
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD round(detail::fvec4SIMD const & x);
-
-		//! Returns a value equal to the nearest integer to x.
-		//! A fractional part of 0.5 will round toward the nearest even
-		//! integer. (Both 3.5 and 4.5 for x will return 4.0.) 
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		//detail::fvec4SIMD roundEven(detail::fvec4SIMD const & x);
-
-		//! Returns a value equal to the nearest integer 
-		//! that is greater than or equal to x. 
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD ceil(detail::fvec4SIMD const & x);
-
-		//! Return x - floor(x).
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD fract(detail::fvec4SIMD const & x);
-
-		//! Modulus. Returns x - y * floor(x / y) 
-		//! for each component in x using the floating point value y.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD mod(
-			detail::fvec4SIMD const & x, 
-			detail::fvec4SIMD const & y);
-
-		//! Modulus. Returns x - y * floor(x / y) 
-		//! for each component in x using the floating point value y.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD mod(
-			detail::fvec4SIMD const & x, 
-			float const & y);
-
-		//! Returns the fractional part of x and sets i to the integer
-		//! part (as a whole number floating point value). Both the
-		//! return value and the output parameter will have the same
-		//! sign as x.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		//detail::fvec4SIMD modf(
-		//	detail::fvec4SIMD const & x, 
-		//	detail::fvec4SIMD & i);
-
-		//! Returns y if y < x; otherwise, it returns x.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD min(
-			detail::fvec4SIMD const & x, 
-			detail::fvec4SIMD const & y);
-
-		detail::fvec4SIMD min(
-			detail::fvec4SIMD const & x, 
-			float const & y);
-
-		//! Returns y if x < y; otherwise, it returns x.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD max(
-			detail::fvec4SIMD const & x, 
-			detail::fvec4SIMD const & y);
-
-		detail::fvec4SIMD max(
-			detail::fvec4SIMD const & x, 
-			float const & y);
-
-		//! Returns min(max(x, minVal), maxVal) for each component in x 
-		//! using the floating-point values minVal and maxVal.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD clamp(
-			detail::fvec4SIMD const & x, 
-			detail::fvec4SIMD const & minVal, 
-			detail::fvec4SIMD const & maxVal); 
-
-		detail::fvec4SIMD clamp(
-			detail::fvec4SIMD const & x, 
-			float const & minVal, 
-			float const & maxVal); 
-
-		//! \return If genTypeU is a floating scalar or vector: 
-		//! Returns x * (1.0 - a) + y * a, i.e., the linear blend of 
-		//! x and y using the floating-point value a. 
-		//! The value for a is not restricted to the range [0, 1].
-		//!
-		//! \return If genTypeU is a boolean scalar or vector: 
-		//! Selects which vector each returned component comes
-		//! from. For a component of a that is false, the
-		//! corresponding component of x is returned. For a
-		//! component of a that is true, the corresponding
-		//! component of y is returned. Components of x and y that
-		//! are not selected are allowed to be invalid floating point
-		//! values and will have no effect on the results. Thus, this
-		//! provides different functionality than
-		//! genType mix(genType x, genType y, genType(a))
-		//! where a is a Boolean vector.
-		//! 
-		//! From GLSL 1.30.08 specification, section 8.3
-		//! 
-		//! \param[in]  x Floating point scalar or vector.
-		//! \param[in]  y Floating point scalar or vector.
-		//! \param[in]  a Floating point or boolean scalar or vector.
-		//!
-		// \todo Test when 'a' is a boolean.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD mix(
-			detail::fvec4SIMD const & x, 
-			detail::fvec4SIMD const & y, 
-			detail::fvec4SIMD const & a);
-
-		//! Returns 0.0 if x < edge, otherwise it returns 1.0.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD step(
-			detail::fvec4SIMD const & edge, 
-			detail::fvec4SIMD const & x);
-
-		detail::fvec4SIMD step(
-			float const & edge, 
-			detail::fvec4SIMD const & x);
-
-		//! Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
-		//! performs smooth Hermite interpolation between 0 and 1
-		//! when edge0 < x < edge1. This is useful in cases where
-		//! you would want a threshold function with a smooth
-		//! transition. This is equivalent to:
-		//! genType t;
-		//! t = clamp ((x – edge0) / (edge1 – edge0), 0, 1);
-		//! return t * t * (3 – 2 * t);
-		//! Results are undefined if edge0 >= edge1.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD smoothstep(
-			detail::fvec4SIMD const & edge0, 
-			detail::fvec4SIMD const & edge1, 
-			detail::fvec4SIMD const & x);
-
-		detail::fvec4SIMD smoothstep(
-			float const & edge0, 
-			float const & edge1, 
-			detail::fvec4SIMD const & x);
-
-		//! Returns true if x holds a NaN (not a number)
-		//! representation in the underlying implementation's set of
-		//! floating point representations. Returns false otherwise,
-		//! including for implementations with no NaN
-		//! representations.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		//bvec4 isnan(detail::fvec4SIMD const & x);
-
-		//! Returns true if x holds a positive infinity or negative
-		//! infinity representation in the underlying implementation's
-		//! set of floating point representations. Returns false
-		//! otherwise, including for implementations with no infinity
-		//! representations.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		//bvec4 isinf(detail::fvec4SIMD const & x);
-
-		//! Returns a signed or unsigned integer value representing
-		//! the encoding of a floating-point value. The floatingpoint
-		//! value's bit-level representation is preserved.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		//detail::ivec4SIMD floatBitsToInt(detail::fvec4SIMD const & value);
-
-		//! Returns a floating-point value corresponding to a signed
-		//! or unsigned integer encoding of a floating-point value.
-		//! If an inf or NaN is passed in, it will not signal, and the
-		//! resulting floating point value is unspecified. Otherwise,
-		//! the bit-level representation is preserved.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		//detail::fvec4SIMD intBitsToFloat(detail::ivec4SIMD const & value);
-
-		//! Computes and returns a * b + c.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		detail::fvec4SIMD fma(
-			detail::fvec4SIMD const & a, 
-			detail::fvec4SIMD const & b, 
-			detail::fvec4SIMD const & c);
-
-		//! Splits x into a floating-point significand in the range
-		//! [0.5, 1.0) and an integral exponent of two, such that:
-		//! x = significand * exp(2, exponent)
-		//! The significand is returned by the function and the
-		//! exponent is returned in the parameter exp. For a
-		//! floating-point value of zero, the significant and exponent
-		//! are both zero. For a floating-point value that is an
-		//! infinity or is not a number, the results are undefined.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		//detail::fvec4SIMD frexp(detail::fvec4SIMD const & x, detail::ivec4SIMD & exp);
-
-		//! Builds a floating-point number from x and the
-		//! corresponding integral exponent of two in exp, returning:
-		//! significand * exp(2, exponent)
-		//! If this product is too large to be represented in the
-		//! floating-point type, the result is undefined.
-		//! (From GLM_GTX_simd_vec4 extension, common function)
-		//detail::fvec4SIMD ldexp(detail::fvec4SIMD const & x, detail::ivec4SIMD const & exp);
-
-		//! Returns the length of x, i.e., sqrt(x * x).
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		float length(
-			detail::fvec4SIMD const & x);
-
-		//! Returns the length of x, i.e., sqrt(x * x).
-		//! Less accurate but much faster than simdLength.
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		float fastLength(
-			detail::fvec4SIMD const & x);
-
-		//! Returns the length of x, i.e., sqrt(x * x).
-		//! Slightly more accurate but much slower than simdLength.
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		float niceLength(
-			detail::fvec4SIMD const & x);
-
-		//! Returns the length of x, i.e., sqrt(x * x).
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		detail::fvec4SIMD length4(
-			detail::fvec4SIMD const & x);
-
-		//! Returns the length of x, i.e., sqrt(x * x).
-		//! Less accurate but much faster than simdLength4.
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		detail::fvec4SIMD fastLength4(
-			detail::fvec4SIMD const & x);
-
-		//! Returns the length of x, i.e., sqrt(x * x).
-		//! Slightly more accurate but much slower than simdLength4.
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		detail::fvec4SIMD niceLength4(
-			detail::fvec4SIMD const & x);
-
-		//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		float distance(
-			detail::fvec4SIMD const & p0,
-			detail::fvec4SIMD const & p1);
-
-		//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		detail::fvec4SIMD distance4(
-			detail::fvec4SIMD const & p0,
-			detail::fvec4SIMD const & p1);
-
-		//! Returns the dot product of x and y, i.e., result = x * y.
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		float simdDot(
-			detail::fvec4SIMD const & x,
-			detail::fvec4SIMD const & y);
-
-		//! Returns the dot product of x and y, i.e., result = x * y.
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		detail::fvec4SIMD dot4(
-			detail::fvec4SIMD const & x,
-			detail::fvec4SIMD const & y);
-
-		//! Returns the cross product of x and y.
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		detail::fvec4SIMD cross(
-			detail::fvec4SIMD const & x,
-			detail::fvec4SIMD const & y);
-
-		//! Returns a vector in the same direction as x but with length of 1.
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		detail::fvec4SIMD normalize(
-			detail::fvec4SIMD const & x);
-
-		//! Returns a vector in the same direction as x but with length of 1.
-		//! Less accurate but much faster than simdNormalize.
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		detail::fvec4SIMD fastNormalize(
-			detail::fvec4SIMD const & x);
-
-		//! If dot(Nref, I) < 0.0, return N, otherwise, return -N.
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		detail::fvec4SIMD simdFaceforward(
-			detail::fvec4SIMD const & N,
-			detail::fvec4SIMD const & I,
-			detail::fvec4SIMD const & Nref);
-
-		//! For the incident vector I and surface orientation N,
-		//! returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		detail::fvec4SIMD reflect(
-			detail::fvec4SIMD const & I,
-			detail::fvec4SIMD const & N);
-
-		//! For the incident vector I and surface normal N,
-		//! and the ratio of indices of refraction eta,
-		//! return the refraction vector.
-		//! (From GLM_GTX_simd_vec4 extension, geometry functions)
-		detail::fvec4SIMD refract(
-			detail::fvec4SIMD const & I,
-			detail::fvec4SIMD const & N,
-			float const & eta);
-
-		//! Returns the positive square root of x.
-		//! (From GLM_GTX_simd_vec4 extension, exponential function)
-		detail::fvec4SIMD sqrt(
-			detail::fvec4SIMD const & x);
-
-		//! Returns the positive square root of x with the nicest quality but very slow.
-		//! Slightly more accurate but much slower than simdSqrt.
-		//! (From GLM_GTX_simd_vec4 extension, exponential function)
-		detail::fvec4SIMD niceSqrt(
-			detail::fvec4SIMD const & x);
-
-		//! Returns the positive square root of x
-		//! Less accurate but much faster than sqrt.
-		//! (From GLM_GTX_simd_vec4 extension, exponential function)
-		detail::fvec4SIMD fastSqrt(
-			detail::fvec4SIMD const & x);
-
-		//! Returns the reciprocal of the positive square root of x.
-		//! (From GLM_GTX_simd_vec4 extension, exponential function)
-		detail::fvec4SIMD inversesqrt(
-			detail::fvec4SIMD const & x);
-
-		//! Returns the reciprocal of the positive square root of x.
-		//! Faster than inversesqrt but less accurate.
-		//! (From GLM_GTX_simd_vec4 extension, exponential function)
-		detail::fvec4SIMD fastInversesqrt(
-			detail::fvec4SIMD const & x);
-
-		///@}
-	}//namespace simd_vec4
-	}//namespace gtx
+		enum ctor{null};
+		typedef __m128 value_type;
+		typedef std::size_t size_type;
+		static size_type value_size();
+
+		typedef fvec4SIMD type;
+		typedef tvec4<bool> bool_type;
+
+		__m128 Data;
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		fvec4SIMD();
+		fvec4SIMD(__m128 const & Data);
+		fvec4SIMD(fvec4SIMD const & v);
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		explicit fvec4SIMD(
+			ctor);
+		explicit fvec4SIMD(
+			float const & s);
+		explicit fvec4SIMD(
+			float const & x, 
+			float const & y, 
+			float const & z, 
+			float const & w);
+		explicit fvec4SIMD(
+			tvec4<float> const & v);
+
+		////////////////////////////////////////
+		//// Convertion vector constructors
+
+		fvec4SIMD(vec2 const & v, float const & s1, float const & s2);
+		fvec4SIMD(float const & s1, vec2 const & v, float const & s2);
+		fvec4SIMD(float const & s1, float const & s2, vec2 const & v);
+		fvec4SIMD(vec3 const & v, float const & s);
+		fvec4SIMD(float const & s, vec3 const & v);
+		fvec4SIMD(vec2 const & v1, vec2 const & v2);
+		//fvec4SIMD(ivec4SIMD const & v);
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		fvec4SIMD& operator= (fvec4SIMD const & v);
+		fvec4SIMD& operator+=(fvec4SIMD const & v);
+		fvec4SIMD& operator-=(fvec4SIMD const & v);
+		fvec4SIMD& operator*=(fvec4SIMD const & v);
+		fvec4SIMD& operator/=(fvec4SIMD const & v);
+
+		fvec4SIMD& operator+=(float const & s);
+		fvec4SIMD& operator-=(float const & s);
+		fvec4SIMD& operator*=(float const & s);
+		fvec4SIMD& operator/=(float const & s);
+
+		fvec4SIMD& operator++();
+		fvec4SIMD& operator--();
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		template <comp X, comp Y, comp Z, comp W>
+		fvec4SIMD& swizzle();
+		template <comp X, comp Y, comp Z, comp W>
+		fvec4SIMD swizzle() const;
+		template <comp X, comp Y, comp Z>
+		fvec4SIMD swizzle() const;
+		template <comp X, comp Y>
+		fvec4SIMD swizzle() const;
+		template <comp X>
+		fvec4SIMD swizzle() const;
+	};
+}//namespace detail
+
+namespace gtx{
+namespace simd_vec4 ///< GLM_GTX_simd_vec4 extension: SIMD implementation of vec4 type.
+{
+	typedef detail::fvec4SIMD simdVec4;
+
+	/// \addtogroup gtx_simd_vec4
+	///@{
+
+	//! Convert a simdVec4 to a vec4.
+	//! (From GLM_GTX_simd_vec4 extension)
+	detail::tvec4<float> vec4_cast(
+		detail::fvec4SIMD const & x);
+
+	//! Returns x if x >= 0; otherwise, it returns -x. 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD abs(detail::fvec4SIMD const & x);
+
+	//! Returns 1.0 if x > 0, 0.0 if x = 0, or -1.0 if x < 0. 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD sign(detail::fvec4SIMD const & x);
+
+	//! Returns a value equal to the nearest integer that is less then or equal to x. 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD floor(detail::fvec4SIMD const & x);
+
+	//! Returns a value equal to the nearest integer to x 
+	//! whose absolute value is not larger than the absolute value of x. 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD trunc(detail::fvec4SIMD const & x);
+
+	//! Returns a value equal to the nearest integer to x. 
+	//! The fraction 0.5 will round in a direction chosen by the 
+	//! implementation, presumably the direction that is fastest. 
+	//! This includes the possibility that round(x) returns the 
+	//! same value as roundEven(x) for all values of x. 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD round(detail::fvec4SIMD const & x);
+
+	//! Returns a value equal to the nearest integer to x.
+	//! A fractional part of 0.5 will round toward the nearest even
+	//! integer. (Both 3.5 and 4.5 for x will return 4.0.) 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//detail::fvec4SIMD roundEven(detail::fvec4SIMD const & x);
+
+	//! Returns a value equal to the nearest integer 
+	//! that is greater than or equal to x. 
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD ceil(detail::fvec4SIMD const & x);
+
+	//! Return x - floor(x).
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD fract(detail::fvec4SIMD const & x);
+
+	//! Modulus. Returns x - y * floor(x / y) 
+	//! for each component in x using the floating point value y.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD mod(
+		detail::fvec4SIMD const & x, 
+		detail::fvec4SIMD const & y);
+
+	//! Modulus. Returns x - y * floor(x / y) 
+	//! for each component in x using the floating point value y.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD mod(
+		detail::fvec4SIMD const & x, 
+		float const & y);
+
+	//! Returns the fractional part of x and sets i to the integer
+	//! part (as a whole number floating point value). Both the
+	//! return value and the output parameter will have the same
+	//! sign as x.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//detail::fvec4SIMD modf(
+	//	detail::fvec4SIMD const & x, 
+	//	detail::fvec4SIMD & i);
+
+	//! Returns y if y < x; otherwise, it returns x.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD min(
+		detail::fvec4SIMD const & x, 
+		detail::fvec4SIMD const & y);
+
+	detail::fvec4SIMD min(
+		detail::fvec4SIMD const & x, 
+		float const & y);
+
+	//! Returns y if x < y; otherwise, it returns x.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD max(
+		detail::fvec4SIMD const & x, 
+		detail::fvec4SIMD const & y);
+
+	detail::fvec4SIMD max(
+		detail::fvec4SIMD const & x, 
+		float const & y);
+
+	//! Returns min(max(x, minVal), maxVal) for each component in x 
+	//! using the floating-point values minVal and maxVal.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD clamp(
+		detail::fvec4SIMD const & x, 
+		detail::fvec4SIMD const & minVal, 
+		detail::fvec4SIMD const & maxVal); 
+
+	detail::fvec4SIMD clamp(
+		detail::fvec4SIMD const & x, 
+		float const & minVal, 
+		float const & maxVal); 
+
+	//! \return If genTypeU is a floating scalar or vector: 
+	//! Returns x * (1.0 - a) + y * a, i.e., the linear blend of 
+	//! x and y using the floating-point value a. 
+	//! The value for a is not restricted to the range [0, 1].
+	//!
+	//! \return If genTypeU is a boolean scalar or vector: 
+	//! Selects which vector each returned component comes
+	//! from. For a component of a that is false, the
+	//! corresponding component of x is returned. For a
+	//! component of a that is true, the corresponding
+	//! component of y is returned. Components of x and y that
+	//! are not selected are allowed to be invalid floating point
+	//! values and will have no effect on the results. Thus, this
+	//! provides different functionality than
+	//! genType mix(genType x, genType y, genType(a))
+	//! where a is a Boolean vector.
+	//! 
+	//! From GLSL 1.30.08 specification, section 8.3
+	//! 
+	//! \param[in]  x Floating point scalar or vector.
+	//! \param[in]  y Floating point scalar or vector.
+	//! \param[in]  a Floating point or boolean scalar or vector.
+	//!
+	// \todo Test when 'a' is a boolean.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD mix(
+		detail::fvec4SIMD const & x, 
+		detail::fvec4SIMD const & y, 
+		detail::fvec4SIMD const & a);
+
+	//! Returns 0.0 if x < edge, otherwise it returns 1.0.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD step(
+		detail::fvec4SIMD const & edge, 
+		detail::fvec4SIMD const & x);
+
+	detail::fvec4SIMD step(
+		float const & edge, 
+		detail::fvec4SIMD const & x);
+
+	//! Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
+	//! performs smooth Hermite interpolation between 0 and 1
+	//! when edge0 < x < edge1. This is useful in cases where
+	//! you would want a threshold function with a smooth
+	//! transition. This is equivalent to:
+	//! genType t;
+	//! t = clamp ((x – edge0) / (edge1 – edge0), 0, 1);
+	//! return t * t * (3 – 2 * t);
+	//! Results are undefined if edge0 >= edge1.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD smoothstep(
+		detail::fvec4SIMD const & edge0, 
+		detail::fvec4SIMD const & edge1, 
+		detail::fvec4SIMD const & x);
+
+	detail::fvec4SIMD smoothstep(
+		float const & edge0, 
+		float const & edge1, 
+		detail::fvec4SIMD const & x);
+
+	//! Returns true if x holds a NaN (not a number)
+	//! representation in the underlying implementation's set of
+	//! floating point representations. Returns false otherwise,
+	//! including for implementations with no NaN
+	//! representations.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//bvec4 isnan(detail::fvec4SIMD const & x);
+
+	//! Returns true if x holds a positive infinity or negative
+	//! infinity representation in the underlying implementation's
+	//! set of floating point representations. Returns false
+	//! otherwise, including for implementations with no infinity
+	//! representations.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//bvec4 isinf(detail::fvec4SIMD const & x);
+
+	//! Returns a signed or unsigned integer value representing
+	//! the encoding of a floating-point value. The floatingpoint
+	//! value's bit-level representation is preserved.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//detail::ivec4SIMD floatBitsToInt(detail::fvec4SIMD const & value);
+
+	//! Returns a floating-point value corresponding to a signed
+	//! or unsigned integer encoding of a floating-point value.
+	//! If an inf or NaN is passed in, it will not signal, and the
+	//! resulting floating point value is unspecified. Otherwise,
+	//! the bit-level representation is preserved.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//detail::fvec4SIMD intBitsToFloat(detail::ivec4SIMD const & value);
+
+	//! Computes and returns a * b + c.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	detail::fvec4SIMD fma(
+		detail::fvec4SIMD const & a, 
+		detail::fvec4SIMD const & b, 
+		detail::fvec4SIMD const & c);
+
+	//! Splits x into a floating-point significand in the range
+	//! [0.5, 1.0) and an integral exponent of two, such that:
+	//! x = significand * exp(2, exponent)
+	//! The significand is returned by the function and the
+	//! exponent is returned in the parameter exp. For a
+	//! floating-point value of zero, the significant and exponent
+	//! are both zero. For a floating-point value that is an
+	//! infinity or is not a number, the results are undefined.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//detail::fvec4SIMD frexp(detail::fvec4SIMD const & x, detail::ivec4SIMD & exp);
+
+	//! Builds a floating-point number from x and the
+	//! corresponding integral exponent of two in exp, returning:
+	//! significand * exp(2, exponent)
+	//! If this product is too large to be represented in the
+	//! floating-point type, the result is undefined.
+	//! (From GLM_GTX_simd_vec4 extension, common function)
+	//detail::fvec4SIMD ldexp(detail::fvec4SIMD const & x, detail::ivec4SIMD const & exp);
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	float length(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! Less accurate but much faster than simdLength.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	float fastLength(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! Slightly more accurate but much slower than simdLength.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	float niceLength(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD length4(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! Less accurate but much faster than simdLength4.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD fastLength4(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the length of x, i.e., sqrt(x * x).
+	//! Slightly more accurate but much slower than simdLength4.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD niceLength4(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	float distance(
+		detail::fvec4SIMD const & p0,
+		detail::fvec4SIMD const & p1);
+
+	//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD distance4(
+		detail::fvec4SIMD const & p0,
+		detail::fvec4SIMD const & p1);
+
+	//! Returns the dot product of x and y, i.e., result = x * y.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	float simdDot(
+		detail::fvec4SIMD const & x,
+		detail::fvec4SIMD const & y);
+
+	//! Returns the dot product of x and y, i.e., result = x * y.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD dot4(
+		detail::fvec4SIMD const & x,
+		detail::fvec4SIMD const & y);
+
+	//! Returns the cross product of x and y.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD cross(
+		detail::fvec4SIMD const & x,
+		detail::fvec4SIMD const & y);
+
+	//! Returns a vector in the same direction as x but with length of 1.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD normalize(
+		detail::fvec4SIMD const & x);
+
+	//! Returns a vector in the same direction as x but with length of 1.
+	//! Less accurate but much faster than simdNormalize.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD fastNormalize(
+		detail::fvec4SIMD const & x);
+
+	//! If dot(Nref, I) < 0.0, return N, otherwise, return -N.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD simdFaceforward(
+		detail::fvec4SIMD const & N,
+		detail::fvec4SIMD const & I,
+		detail::fvec4SIMD const & Nref);
+
+	//! For the incident vector I and surface orientation N,
+	//! returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD reflect(
+		detail::fvec4SIMD const & I,
+		detail::fvec4SIMD const & N);
+
+	//! For the incident vector I and surface normal N,
+	//! and the ratio of indices of refraction eta,
+	//! return the refraction vector.
+	//! (From GLM_GTX_simd_vec4 extension, geometry functions)
+	detail::fvec4SIMD refract(
+		detail::fvec4SIMD const & I,
+		detail::fvec4SIMD const & N,
+		float const & eta);
+
+	//! Returns the positive square root of x.
+	//! (From GLM_GTX_simd_vec4 extension, exponential function)
+	detail::fvec4SIMD sqrt(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the positive square root of x with the nicest quality but very slow.
+	//! Slightly more accurate but much slower than simdSqrt.
+	//! (From GLM_GTX_simd_vec4 extension, exponential function)
+	detail::fvec4SIMD niceSqrt(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the positive square root of x
+	//! Less accurate but much faster than sqrt.
+	//! (From GLM_GTX_simd_vec4 extension, exponential function)
+	detail::fvec4SIMD fastSqrt(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the reciprocal of the positive square root of x.
+	//! (From GLM_GTX_simd_vec4 extension, exponential function)
+	detail::fvec4SIMD inversesqrt(
+		detail::fvec4SIMD const & x);
+
+	//! Returns the reciprocal of the positive square root of x.
+	//! Faster than inversesqrt but less accurate.
+	//! (From GLM_GTX_simd_vec4 extension, exponential function)
+	detail::fvec4SIMD fastInversesqrt(
+		detail::fvec4SIMD const & x);
+
+	/// @}
+}//namespace simd_vec4
+}//namespace gtx
 }//namespace glm
 
 #include "simd_vec4.inl"

glm/gtx/simplex.hpp

@@ -20,50 +20,47 @@
 #	pragma message("GLM: GLM_GTX_simplex extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace spline ///< GLM_GTX_simplex extension: Spline functions
 {
-    namespace gtx{
-        //! GLM_GTX_simplex extension: Spline functions
-        namespace spline
-        {
-            /// \addtogroup gtx_spline
-            ///@{
+    /// \addtogroup gtx_spline
+    ///@{
             
-            //! Return a point from a catmull rom curve.
-            //! From GLM_GTX_spline extension.
-            template <typename genType> 
-            genType catmullRom(
-                               genType const & v1, 
-                               genType const & v2, 
-                               genType const & v3, 
-                               genType const & v4, 
-                               typename genType::value_type const & s);
+    //! Return a point from a catmull rom curve.
+    //! From GLM_GTX_spline extension.
+    template <typename genType> 
+    genType catmullRom(
+                        genType const & v1, 
+                        genType const & v2, 
+                        genType const & v3, 
+                        genType const & v4, 
+                        typename genType::value_type const & s);
             
-            //! Return a point from a hermite curve.
-            //! From GLM_GTX_spline extension.
-            template <typename genType> 
-            genType hermite(
-                            genType const & v1, 
-                            genType const & t1, 
-                            genType const & v2, 
-                            genType const & t2, 
-                            typename genType::value_type const & s);
+    //! Return a point from a hermite curve.
+    //! From GLM_GTX_spline extension.
+    template <typename genType> 
+    genType hermite(
+                    genType const & v1, 
+                    genType const & t1, 
+                    genType const & v2, 
+                    genType const & t2, 
+                    typename genType::value_type const & s);
             
-            //! Return a point from a cubic curve. 
-            //! From GLM_GTX_spline extension.
-            template <typename genType> 
-            genType cubic(
-                          genType const & v1, 
-                          genType const & v2, 
-                          genType const & v3, 
-                          genType const & v4, 
-                          typename genType::value_type const & s);
+    //! Return a point from a cubic curve. 
+    //! From GLM_GTX_spline extension.
+    template <typename genType> 
+    genType cubic(
+                    genType const & v1, 
+                    genType const & v2, 
+                    genType const & v3, 
+                    genType const & v4, 
+                    typename genType::value_type const & s);
             
-            ///@}
-            
-        }//namespace simplex
-    }//namespace gtx
-}//namespace glm
+    /// @}
+}// namespace simplex
+}// namespace gtx
+}// namespace glm
 
 #include "simplex.inl"
 

glm/gtx/spline.hpp

@@ -21,51 +21,48 @@
 #	pragma message("GLM: GLM_GTX_spline extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace spline ///< GLM_GTX_spline extension: Spline functions
 {
-    namespace gtx{
-	//! GLM_GTX_spline extension: Spline functions
-    namespace spline
-    {
-		using namespace gtx::optimum_pow;
+	using namespace gtx::optimum_pow;
 
-		/// \addtogroup gtx_spline
-		///@{
+	/// \addtogroup gtx_spline
+	/// @{
 
-		//! Return a point from a catmull rom curve.
-		//! From GLM_GTX_spline extension.
-		template <typename genType> 
-		genType catmullRom(
-			genType const & v1, 
-			genType const & v2, 
-			genType const & v3, 
-			genType const & v4, 
-			typename genType::value_type const & s);
+	//! Return a point from a catmull rom curve.
+	//! From GLM_GTX_spline extension.
+	template <typename genType> 
+	genType catmullRom(
+		genType const & v1, 
+		genType const & v2, 
+		genType const & v3, 
+		genType const & v4, 
+		typename genType::value_type const & s);
 		
-		//! Return a point from a hermite curve.
-		//! From GLM_GTX_spline extension.
-        template <typename genType> 
-		genType hermite(
-			genType const & v1, 
-			genType const & t1, 
-			genType const & v2, 
-			genType const & t2, 
-			typename genType::value_type const & s);
+	//! Return a point from a hermite curve.
+	//! From GLM_GTX_spline extension.
+    template <typename genType> 
+	genType hermite(
+		genType const & v1, 
+		genType const & t1, 
+		genType const & v2, 
+		genType const & t2, 
+		typename genType::value_type const & s);
 		
-        //! Return a point from a cubic curve. 
-		//! From GLM_GTX_spline extension.
-		template <typename genType> 
-		genType cubic(
-			genType const & v1, 
-			genType const & v2, 
-			genType const & v3, 
-			genType const & v4, 
-			typename genType::value_type const & s);
+    //! Return a point from a cubic curve. 
+	//! From GLM_GTX_spline extension.
+	template <typename genType> 
+	genType cubic(
+		genType const & v1, 
+		genType const & v2, 
+		genType const & v3, 
+		genType const & v4, 
+		typename genType::value_type const & s);
 
-		///@}
-
-	}//namespace spline
-    }//namespace gtx
+	/// @}
+}//namespace spline
+}//namespace gtx
 }//namespace glm
 
 #include "spline.inl"

glm/gtx/std_based_type.hpp

@@ -21,54 +21,48 @@
 #	pragma message("GLM: GLM_GTX_std_based_type extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace std_based_type ///< GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
 {
-	namespace test{
-		void main_gtx_std_based_type();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
-	namespace std_based_type
-	{
-		typedef detail::tvec2<std::size_t>		size2;
-		typedef detail::tvec3<std::size_t>		size3;
-		typedef detail::tvec4<std::size_t>		size4;
-
-		typedef detail::tvec2<signed char>		scvec2;
-		typedef detail::tvec3<signed char>		scvec3;
-		typedef detail::tvec4<signed char>		scvec4;
-
-		typedef detail::tvec2<unsigned char>	ucvec2;
-		typedef detail::tvec3<unsigned char>	ucvec3;
-		typedef detail::tvec4<unsigned char>	ucvec4;
-
-		typedef detail::tvec2<signed short>		ssvec2;
-		typedef detail::tvec3<signed short>		ssvec3;
-		typedef detail::tvec4<signed short>		ssvec4;
-
-		typedef detail::tvec2<unsigned short>	usvec2;
-		typedef detail::tvec3<unsigned short>	usvec3;
-		typedef detail::tvec4<unsigned short>	usvec4;
-
-		typedef detail::tvec2<signed int>		sivec2;
-		typedef detail::tvec3<signed int>		sivec3;
-		typedef detail::tvec4<signed int>		sivec4;
-
-		typedef detail::tvec2<unsigned int>		uivec2;
-		typedef detail::tvec3<unsigned int>		uivec3;
-		typedef detail::tvec4<unsigned int>		uivec4;
-
-		typedef detail::tvec2<signed long>		slvec2;
-		typedef detail::tvec3<signed long>		slvec3;
-		typedef detail::tvec4<signed long>		slvec4;
-
-		typedef detail::tvec2<unsigned long>	ulvec2;
-		typedef detail::tvec3<unsigned long>	ulvec3;
-		typedef detail::tvec4<unsigned long>	ulvec4;
-
-	}//namespace std_based_type
-	}//namespace gtx
+	typedef detail::tvec2<std::size_t>		size2;
+	typedef detail::tvec3<std::size_t>		size3;
+	typedef detail::tvec4<std::size_t>		size4;
+
+	typedef detail::tvec2<signed char>		scvec2;
+	typedef detail::tvec3<signed char>		scvec3;
+	typedef detail::tvec4<signed char>		scvec4;
+
+	typedef detail::tvec2<unsigned char>	ucvec2;
+	typedef detail::tvec3<unsigned char>	ucvec3;
+	typedef detail::tvec4<unsigned char>	ucvec4;
+
+	typedef detail::tvec2<signed short>		ssvec2;
+	typedef detail::tvec3<signed short>		ssvec3;
+	typedef detail::tvec4<signed short>		ssvec4;
+
+	typedef detail::tvec2<unsigned short>	usvec2;
+	typedef detail::tvec3<unsigned short>	usvec3;
+	typedef detail::tvec4<unsigned short>	usvec4;
+
+	typedef detail::tvec2<signed int>		sivec2;
+	typedef detail::tvec3<signed int>		sivec3;
+	typedef detail::tvec4<signed int>		sivec4;
+
+	typedef detail::tvec2<unsigned int>		uivec2;
+	typedef detail::tvec3<unsigned int>		uivec3;
+	typedef detail::tvec4<unsigned int>		uivec4;
+
+	typedef detail::tvec2<signed long>		slvec2;
+	typedef detail::tvec3<signed long>		slvec3;
+	typedef detail::tvec4<signed long>		slvec4;
+
+	typedef detail::tvec2<unsigned long>	ulvec2;
+	typedef detail::tvec3<unsigned long>	ulvec3;
+	typedef detail::tvec4<unsigned long>	ulvec4;
+
+}//namespace std_based_type
+}//namespace gtx
 }//namespace glm
 
 #include "std_based_type.inl"

glm/gtx/string_cast.hpp

@@ -28,33 +28,26 @@
 #	pragma message("GLM: GLM_GTX_string_cast extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace string_cast ///< GLM_GTX_string_cast extension: Setup strings for GLM type values
 {
-	namespace test{
-		void main_gtx_string_cast();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_string_cast extension: Setup strings for GLM type values
-	namespace string_cast
-	{
-		using namespace gtc::half_float; 
-		using namespace gtx::integer; 
-		using namespace gtx::unsigned_int; 
-		using namespace gtx::quaternion; 
-
-		/// \addtogroup gtx_string_cast
-		///@{
-
-		//! Create a string from a GLM type value.
-		//! From GLM_GTX_string_cast extension.
-		template <typename genType> 
-		std::string to_string(genType const & x);
-
-		///@}
-
-	}//namespace string_cast
-	}//namespace gtx
+	using namespace gtc::half_float; 
+	using namespace gtx::integer; 
+	using namespace gtx::unsigned_int; 
+	using namespace gtx::quaternion; 
+
+	/// \addtogroup gtx_string_cast
+	/// @{
+
+	//! Create a string from a GLM type value.
+	//! From GLM_GTX_string_cast extension.
+	template <typename genType> 
+	std::string to_string(genType const & x);
+
+	/// @}
+}//namespace string_cast
+}//namespace gtx
 }//namespace glm
 
 #include "string_cast.inl"

glm/gtx/transform.hpp

@@ -42,95 +42,88 @@
 #	pragma message("GLM: GLM_GTX_transform extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace transform ///< GLM_GTX_transform extension: Add transformation matrices
 {
-	namespace test{
-		void main_gtx_transform();
-	}//namespace test
+	using namespace gtc::matrix_transform; 
 
-	namespace gtx{
-	//! GLM_GTX_transform extension: Add transformation matrices
-	namespace transform
-	{
-		using namespace gtc::matrix_transform; 
+	/// \addtogroup gtx_transform
+	/// @{
 
-		/// \addtogroup gtx_transform
-		///@{
-
-		//! Builds a translation 4 * 4 matrix created from 3 scalars.
-		//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-		//! - See also: \link glm::gtc::matrix_transform::translate GLM_GTC_matrix_transform \endlink
-		template <typename T> 
-		detail::tmat4x4<T> translate(
-			T x, T y, T z);
+	//! Builds a translation 4 * 4 matrix created from 3 scalars.
+	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
+	//! - See also: \link glm::gtc::matrix_transform::translate GLM_GTC_matrix_transform \endlink
+	template <typename T> 
+	detail::tmat4x4<T> translate(
+		T x, T y, T z);
 		
-		//! Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. 
-		//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-		//! - See also: \link glm::gtc::matrix_transform::translate GLM_GTC_matrix_transform \endlink
-		template <typename T> 
-		detail::tmat4x4<T> translate(
-			detail::tmat4x4<T> const & m, 
-			T x, T y, T z);
+	//! Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. 
+	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
+	//! - See also: \link glm::gtc::matrix_transform::translate GLM_GTC_matrix_transform \endlink
+	template <typename T> 
+	detail::tmat4x4<T> translate(
+		detail::tmat4x4<T> const & m, 
+		T x, T y, T z);
 		
-		//! Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. 
-		//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-		//! - See also: \link glm::gtc::matrix_transform::translate GLM_GTC_matrix_transform \endlink
-		template <typename T> 
-		detail::tmat4x4<T> translate(
-			detail::tvec3<T> const & v);
-
-		//! Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
-		//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-		//! - See also: \link glm::gtc::matrix_transform::rotate GLM_GTC_matrix_transform \endlink
-		template <typename T> 
-		detail::tmat4x4<T> rotate(
-			T angle, 
-			T x, T y, T z);
-
-		//! Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
-		//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-		//! - See also: \link glm::gtc::matrix_transform::rotate GLM_GTC_matrix_transform \endlink
-		template <typename T> 
-		detail::tmat4x4<T> rotate(
-			T angle, 
-			detail::tvec3<T> const & v);
-
-		//! Transforms a matrix with a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
-		//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-		//! - See also: \link glm::gtc::matrix_transform::rotate GLM_GTC_matrix_transform \endlink
-		template <typename T> 
-		detail::tmat4x4<T> rotate(
-			detail::tmat4x4<T> const & m, 
-			T angle, 
-			T x, T y, T z);
+	//! Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars. 
+	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
+	//! - See also: \link glm::gtc::matrix_transform::translate GLM_GTC_matrix_transform \endlink
+	template <typename T> 
+	detail::tmat4x4<T> translate(
+		detail::tvec3<T> const & v);
+
+	//! Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
+	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
+	//! - See also: \link glm::gtc::matrix_transform::rotate GLM_GTC_matrix_transform \endlink
+	template <typename T> 
+	detail::tmat4x4<T> rotate(
+		T angle, 
+		T x, T y, T z);
+
+	//! Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
+	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
+	//! - See also: \link glm::gtc::matrix_transform::rotate GLM_GTC_matrix_transform \endlink
+	template <typename T> 
+	detail::tmat4x4<T> rotate(
+		T angle, 
+		detail::tvec3<T> const & v);
+
+	//! Transforms a matrix with a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
+	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
+	//! - See also: \link glm::gtc::matrix_transform::rotate GLM_GTC_matrix_transform \endlink
+	template <typename T> 
+	detail::tmat4x4<T> rotate(
+		detail::tmat4x4<T> const & m, 
+		T angle, 
+		T x, T y, T z);
 		
-		//! Builds a scale 4 * 4 matrix created from 3 scalars. 
-		//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-		//! - See also: \link glm::gtc::matrix_transform::scale GLM_GTC_matrix_transform \endlink
-		template <typename T> 
-		detail::tmat4x4<T> scale(
-			T x, T y, T z);
+	//! Builds a scale 4 * 4 matrix created from 3 scalars. 
+	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
+	//! - See also: \link glm::gtc::matrix_transform::scale GLM_GTC_matrix_transform \endlink
+	template <typename T> 
+	detail::tmat4x4<T> scale(
+		T x, T y, T z);
 		
-		//! Transforms a matrix with a scale 4 * 4 matrix created from 3 scalars.
-		//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-		//! - See also: \link glm::gtc::matrix_transform::scale GLM_GTC_matrix_transform \endlink
-		template <typename T> 
-		detail::tmat4x4<T> scale(
-			detail::tmat4x4<T> const & m, 
-			T x, T y, T z);
-
-		//! Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components.
-		//! - From \link gtx_transform GLM_GTX_transform \endlink extension
-		//! - See also: \link glm::gtc::matrix_transform::scale GLM_GTC_matrix_transform \endlink
-		template <typename T> 
-		detail::tmat4x4<T> scale(
-			detail::tvec3<T> const & v);
-
-		///@}
-
-	}//namespace transform
-	}//namespace gtx
-}//namespace glm
+	//! Transforms a matrix with a scale 4 * 4 matrix created from 3 scalars.
+	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
+	//! - See also: \link glm::gtc::matrix_transform::scale GLM_GTC_matrix_transform \endlink
+	template <typename T> 
+	detail::tmat4x4<T> scale(
+		detail::tmat4x4<T> const & m, 
+		T x, T y, T z);
+
+	//! Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components.
+	//! - From \link gtx_transform GLM_GTX_transform \endlink extension
+	//! - See also: \link glm::gtc::matrix_transform::scale GLM_GTC_matrix_transform \endlink
+	template <typename T> 
+	detail::tmat4x4<T> scale(
+		detail::tvec3<T> const & v);
+
+	/// @}
+}// namespace transform
+}// namespace gtx
+}// namespace glm
 
 #include "transform.inl"
 

glm/gtx/transform2.hpp

@@ -22,101 +22,94 @@
 #	pragma message("GLM: GLM_GTX_transform2 extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace transform2 ///< GLM_GTX_transform2 extension: Add extra transformation matrices
 {
-	namespace test{
-		void main_gtx_transform2();
-	}//namespace test
-
-    namespace gtx{
-	//! GLM_GTX_transform2 extension: Add extra transformation matrices
-	namespace transform2
-	{
-		using namespace gtx::transform;
-
-		/// \addtogroup gtx_transform2
-		///@{
-
-		//! Transforms a matrix with a shearing on X axis.
-		//! From GLM_GTX_transform2 extension.
-		template <typename T> 
-		detail::tmat3x3<T> shearX2D(
-			detail::tmat3x3<T> const & m, 
-			T y);
-
-		//! Transforms a matrix with a shearing on Y axis.
-		//! From GLM_GTX_transform2 extension.
-		template <typename T> 
-		detail::tmat3x3<T> shearY2D(
-			detail::tmat3x3<T> const & m, 
-			T x);
-
-		//! Transforms a matrix with a shearing on X axis
-		//! From GLM_GTX_transform2 extension.
-		template <typename T> 
-		detail::tmat4x4<T> shearX3D(
-			const detail::tmat4x4<T> & m,
-			T y, 
-			T z);
+	using namespace gtx::transform;
+
+	/// \addtogroup gtx_transform2
+	/// @{
+
+	//! Transforms a matrix with a shearing on X axis.
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat3x3<T> shearX2D(
+		detail::tmat3x3<T> const & m, 
+		T y);
+
+	//! Transforms a matrix with a shearing on Y axis.
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat3x3<T> shearY2D(
+		detail::tmat3x3<T> const & m, 
+		T x);
+
+	//! Transforms a matrix with a shearing on X axis
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat4x4<T> shearX3D(
+		const detail::tmat4x4<T> & m,
+		T y, 
+		T z);
 		
-		//! Transforms a matrix with a shearing on Y axis.
-		//! From GLM_GTX_transform2 extension.
-		template <typename T> 
-		detail::tmat4x4<T> shearY3D(
-			const detail::tmat4x4<T> & m, 
-			T x, 
-			T z);
+	//! Transforms a matrix with a shearing on Y axis.
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat4x4<T> shearY3D(
+		const detail::tmat4x4<T> & m, 
+		T x, 
+		T z);
 		
-		//! Transforms a matrix with a shearing on Z axis. 
-		//! From GLM_GTX_transform2 extension.
-		template <typename T> 
-		detail::tmat4x4<T> shearZ3D(
-			const detail::tmat4x4<T> & m, 
-			T x, 
-			T y);
-
-		//template <typename T> GLM_FUNC_QUALIFIER detail::tmat4x4<T> shear(const detail::tmat4x4<T> & m, shearPlane, planePoint, angle)
-		// Identity + tan(angle) * cross(Normal, OnPlaneVector)     0
-		// - dot(PointOnPlane, normal) * OnPlaneVector              1
-
-		// Reflect functions seem to don't work
-		//template <typename T> detail::tmat3x3<T> reflect2D(const detail::tmat3x3<T> & m, const detail::tvec3<T>& normal){return reflect2DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
-		//template <typename T> detail::tmat4x4<T> reflect3D(const detail::tmat4x4<T> & m, const detail::tvec3<T>& normal){return reflect3DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
+	//! Transforms a matrix with a shearing on Z axis. 
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat4x4<T> shearZ3D(
+		const detail::tmat4x4<T> & m, 
+		T x, 
+		T y);
+
+	//template <typename T> GLM_FUNC_QUALIFIER detail::tmat4x4<T> shear(const detail::tmat4x4<T> & m, shearPlane, planePoint, angle)
+	// Identity + tan(angle) * cross(Normal, OnPlaneVector)     0
+	// - dot(PointOnPlane, normal) * OnPlaneVector              1
+
+	// Reflect functions seem to don't work
+	//template <typename T> detail::tmat3x3<T> reflect2D(const detail::tmat3x3<T> & m, const detail::tvec3<T>& normal){return reflect2DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
+	//template <typename T> detail::tmat4x4<T> reflect3D(const detail::tmat4x4<T> & m, const detail::tvec3<T>& normal){return reflect3DGTX(m, normal);}									//!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
 		
-		//! Build planar projection matrix along normal axis.
-		//! From GLM_GTX_transform2 extension.
-		template <typename T> 
-		detail::tmat3x3<T> proj2D(
-			const detail::tmat3x3<T> & m, 
-			const detail::tvec3<T>& normal);
+	//! Build planar projection matrix along normal axis.
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat3x3<T> proj2D(
+		const detail::tmat3x3<T> & m, 
+		const detail::tvec3<T>& normal);
 				
-		//! Build planar projection matrix along normal axis.
-		//! From GLM_GTX_transform2 extension.
-		template <typename T> 
-		detail::tmat4x4<T> proj3D(
-			const detail::tmat4x4<T> & m, 
-			const detail::tvec3<T>& normal);
-
-		//! Build a scale bias matrix. 
-		//! From GLM_GTX_transform2 extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> scaleBias(
-			valType scale, 
-			valType bias);
-
-		//! Build a scale bias matrix.
-		//! From GLM_GTX_transform2 extension.
-		template <typename valType> 
-		detail::tmat4x4<valType> scaleBias(
-			detail::tmat4x4<valType> const & m, 
-			valType scale, 
-			valType bias);
-
-		///@}
-
-	}//namespace transform2
-    }//namespace gtx
-}//namespace glm
+	//! Build planar projection matrix along normal axis.
+	//! From GLM_GTX_transform2 extension.
+	template <typename T> 
+	detail::tmat4x4<T> proj3D(
+		const detail::tmat4x4<T> & m, 
+		const detail::tvec3<T>& normal);
+
+	//! Build a scale bias matrix. 
+	//! From GLM_GTX_transform2 extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> scaleBias(
+		valType scale, 
+		valType bias);
+
+	//! Build a scale bias matrix.
+	//! From GLM_GTX_transform2 extension.
+	template <typename valType> 
+	detail::tmat4x4<valType> scaleBias(
+		detail::tmat4x4<valType> const & m, 
+		valType scale, 
+		valType bias);
+
+	/// @}
+}// namespace transform2
+}// namespace gtx
+}// namespace glm
 
 #include "transform2.inl"
 

glm/gtx/ulp.hpp

@@ -20,50 +20,47 @@
 #	pragma message("GLM: GLM_GTX_ulp extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace ulp ///< GLM_GTX_ulp extension: Precision calculation functions
 {
-	namespace gtx{
-	//! GLM_GTX_ulp extension: Precision calculation functions
-	namespace ulp
-	{
-		/// \addtogroup gtx_ulp
-		///@{
+	/// \addtogroup gtx_ulp
+	/// @{
 
-		//! Return the next ULP value(s) after the input value(s).
-		//! From GLM_GTX_ulp extension.
-        template <typename genType>
-        genType next_float(genType const & x);
+	//! Return the next ULP value(s) after the input value(s).
+	//! From GLM_GTX_ulp extension.
+    template <typename genType>
+    genType next_float(genType const & x);
         
-		//! Return the previous ULP value(s) before the input value(s).
-		//! From GLM_GTX_ulp extension.
-        template <typename genType>
-        genType prev_float(genType const & x);
+	//! Return the previous ULP value(s) before the input value(s).
+	//! From GLM_GTX_ulp extension.
+    template <typename genType>
+    genType prev_float(genType const & x);
 
-		//! Return the value(s) ULP distance after the input value(s).
-		//! From GLM_GTX_ulp extension.
-        template <typename genType>
-        genType next_float(genType const & x, uint const & Distance);
+	//! Return the value(s) ULP distance after the input value(s).
+	//! From GLM_GTX_ulp extension.
+    template <typename genType>
+    genType next_float(genType const & x, uint const & Distance);
         
-        //! Return the value(s) ULP distance before the input value(s).
-		//! From GLM_GTX_ulp extension.
-        template <typename genType>
-        genType prev_float(genType const & x, uint const & Distance);
+    //! Return the value(s) ULP distance before the input value(s).
+	//! From GLM_GTX_ulp extension.
+    template <typename genType>
+    genType prev_float(genType const & x, uint const & Distance);
         
-        //! Return the distance in the number of ULP between 2 scalars.
-		//! From GLM_GTX_ulp extension.
-        template <typename T>
-        uint float_distance(T const & x, T const & y);
+    //! Return the distance in the number of ULP between 2 scalars.
+	//! From GLM_GTX_ulp extension.
+    template <typename T>
+    uint float_distance(T const & x, T const & y);
         
-        //! Return the distance in the number of ULP between 2 vectors.
-		//! From GLM_GTX_ulp extension.
-        template<typename T, template<typename> class vecType>
-        vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
+    //! Return the distance in the number of ULP between 2 vectors.
+	//! From GLM_GTX_ulp extension.
+    template<typename T, template<typename> class vecType>
+    vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
         
-		///@}
-
-	}//namespace ulp
-	}//namespace gtx
-}//namespace glm
+	///@}
+}// namespace ulp
+}// namespace gtx
+}// namespace glm
 
 #include "ulp.inl"
 

glm/gtx/unsigned_int.hpp

@@ -22,41 +22,34 @@
 #	pragma message("GLM: GLM_GTX_unsigned_int extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace unsigned_int ///< GLM_GTX_unsigned_int extension: Add support for unsigned integer for core functions
 {
-	namespace test{
-		void main_gtx_unsigned_int();
-	}//namespace test
+	using namespace gtx::integer;
 
-	namespace gtx{
-	//! GLM_GTX_unsigned_int extension: Add support for unsigned integer for core functions
-	namespace unsigned_int
-	{
-		using namespace gtx::integer;
+	/// \addtogroup gtx_unsigned_int
+	/// @{
 
-		/// \addtogroup gtx_unsigned_int
-		///@{
+	//! 32bit signed integer. 
+	//! From GLM_GTX_unsigned_int extension.
+	typedef signed int					sint;
 
-		//! 32bit signed integer. 
-		//! From GLM_GTX_unsigned_int extension.
-		typedef signed int					sint;
+	//! Returns x raised to the y power.
+	//! From GLM_GTX_unsigned_int extension.
+	uint pow(uint x, uint y);
 
-		//! Returns x raised to the y power.
-		//! From GLM_GTX_unsigned_int extension.
-		uint pow(uint x, uint y);
+	//! Returns the positive square root of x. 
+	//! From GLM_GTX_unsigned_int extension.
+	uint sqrt(uint x);
 
-		//! Returns the positive square root of x. 
-		//! From GLM_GTX_unsigned_int extension.
-		uint sqrt(uint x);
+	//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
+	//! From GLM_GTX_unsigned_int extension.
+	uint mod(uint x, uint y);
 
-		//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
-		//! From GLM_GTX_unsigned_int extension.
-		uint mod(uint x, uint y);
-
-		///@}
-
-	}//namespace unsigned_int
-	}//namespace gtx
+	/// @}
+}//namespace unsigned_int
+}//namespace gtx
 }//namespace glm
 
 #include "unsigned_int.inl"

glm/gtx/vec1.hpp

@@ -21,104 +21,97 @@
 #	pragma message("GLM: GLM_GTX_vec1 extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace vector1{ ///< GLM_GTX_vec1 extension: 1 component vector.
+namespace precision
 {
-	namespace test{
-		void main_gtx_vector1();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_vector1 extension: 1 component vector.
-	namespace vector1
-	{
-		namespace precision
-		{
-			//! 1 component vector of high precision floating-point numbers. 
-			//! There is no guarantee on the actual precision.
-			//! From GLM_GTX_vec1 extension.
-			typedef detail::highp_vec1_t			highp_vec1;
-			//! 1 component vector of medium precision floating-point numbers. 
-			//! There is no guarantee on the actual precision.
-			//! From GLM_GTX_vec1 extension.
-			typedef detail::mediump_vec1_t			mediump_vec1;
-			//! 1 component vector of low precision floating-point numbers. 
-			//! There is no guarantee on the actual precision.
-			//! From GLM_GTX_vec1 extension.
-			typedef detail::lowp_vec1_t				lowp_vec1;
-
-			//! 1 component vector of high precision signed integer numbers. 
-			//! There is no guarantee on the actual precision.
-			//! From GLM_GTX_vec1 extension.
-			typedef detail::highp_ivec1_t			highp_ivec1;
-			//! 1 component vector of medium precision signed integer numbers. 
-			//! There is no guarantee on the actual precision.
-			//! From GLM_GTX_vec1 extension.
-			typedef detail::mediump_ivec1_t			mediump_ivec1;
-			//! 1 component vector of low precision signed integer numbers. 
-			//! There is no guarantee on the actual precision.
-			//! From GLM_GTX_vec1 extension.
-			typedef detail::lowp_ivec1_t			lowp_ivec1;
-
-			//! 1 component vector of high precision unsigned integer numbers. 
-			//! There is no guarantee on the actual precision.
-			//! From GLM_GTX_vec1 extension.
-			typedef detail::highp_uvec1_t			highp_uvec1;
-			//! 1 component vector of medium precision unsigned integer numbers. 
-			//! There is no guarantee on the actual precision.
-			//! From GLM_GTX_vec1 extension.
-			typedef detail::mediump_uvec1_t			mediump_uvec1;
-			//! 1 component vector of low precision unsigned integer numbers. 
-			//! There is no guarantee on the actual precision.
-			//! From GLM_GTX_vec1 extension.
-			typedef detail::lowp_uvec1_t			lowp_uvec1;
-		}//namespace precision
-
-		//////////////////////////
-		// vec1 definition
-
-		//! 1 component vector of boolean.
-		//! From GLM_GTX_vec1 extension.
-		typedef detail::tvec1<bool>	bvec1;
+	//! 1 component vector of high precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::highp_vec1_t			highp_vec1;
+	//! 1 component vector of medium precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::mediump_vec1_t			mediump_vec1;
+	//! 1 component vector of low precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::lowp_vec1_t				lowp_vec1;
+
+	//! 1 component vector of high precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::highp_ivec1_t			highp_ivec1;
+	//! 1 component vector of medium precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::mediump_ivec1_t			mediump_ivec1;
+	//! 1 component vector of low precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::lowp_ivec1_t			lowp_ivec1;
+
+	//! 1 component vector of high precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::highp_uvec1_t			highp_uvec1;
+	//! 1 component vector of medium precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::mediump_uvec1_t			mediump_uvec1;
+	//! 1 component vector of low precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::lowp_uvec1_t			lowp_uvec1;
+}//namespace precision
+
+	//////////////////////////
+	// vec1 definition
+
+	//! 1 component vector of boolean.
+	//! From GLM_GTX_vec1 extension.
+	typedef detail::tvec1<bool>	bvec1;
 
 #if(defined(GLM_PRECISION_HIGHP_FLOAT))
-		typedef precision::highp_vec1			vec1;
+	typedef precision::highp_vec1			vec1;
 #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
-		typedef precision::mediump_vec1			vec1;
+	typedef precision::mediump_vec1			vec1;
 #elif(defined(GLM_PRECISION_LOWP_FLOAT))
-		typedef precision::lowp_vec1			vec1;
+	typedef precision::lowp_vec1			vec1;
 #else
-		//! 1 component vector of floating-point numbers.
-		//! From GLM_GTX_vec1 extension.
-		typedef precision::mediump_vec1			vec1;
+	//! 1 component vector of floating-point numbers.
+	//! From GLM_GTX_vec1 extension.
+	typedef precision::mediump_vec1			vec1;
 #endif//GLM_PRECISION
 
 #if(defined(GLM_PRECISION_HIGHP_INT))
-		typedef precision::highp_ivec1			ivec1;
+	typedef precision::highp_ivec1			ivec1;
 #elif(defined(GLM_PRECISION_MEDIUMP_INT))
-		typedef precision::mediump_ivec1		ivec1;
+	typedef precision::mediump_ivec1		ivec1;
 #elif(defined(GLM_PRECISION_LOWP_INT))
-		typedef precision::lowp_ivec1			ivec1;
+	typedef precision::lowp_ivec1			ivec1;
 #else
-		//! 1 component vector of signed integer numbers. 
-		//! From GLM_GTX_vec1 extension.
-		typedef precision::mediump_ivec1		ivec1;
+	//! 1 component vector of signed integer numbers. 
+	//! From GLM_GTX_vec1 extension.
+	typedef precision::mediump_ivec1		ivec1;
 #endif//GLM_PRECISION
 
 #if(defined(GLM_PRECISION_HIGHP_UINT))
-		typedef precision::highp_uvec1			uvec1;
+	typedef precision::highp_uvec1			uvec1;
 #elif(defined(GLM_PRECISION_MEDIUMP_UINT))
-		typedef precision::mediump_uvec1		uvec1;
+	typedef precision::mediump_uvec1		uvec1;
 #elif(defined(GLM_PRECISION_LOWP_UINT))
-		typedef precision::lowp_uvec1			uvec1;
+	typedef precision::lowp_uvec1			uvec1;
 #else
-		//! 1 component vector of unsigned integer numbers. 
-		//! From GLM_GTX_vec1 extension.
-		typedef precision::mediump_uvec1		uvec1;
+	//! 1 component vector of unsigned integer numbers. 
+	//! From GLM_GTX_vec1 extension.
+	typedef precision::mediump_uvec1		uvec1;
 #endif//GLM_PRECISION
 
-	}//namespace vec1
-	}//namespace gtx
-}//namespace glm
+}// namespace vec1
+}// namespace gtx
+}// namespace glm
 
 #include "vec1.inl"
 

glm/gtx/vector_access.hpp

@@ -20,50 +20,43 @@
 #	pragma message("GLM: GLM_GTX_vector_access extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace vector_access ///< GLM_GTX_vector_access extension: Function to set values to vectors
 {
-	namespace test{
-		void main_gtx_vector_access();
-	}//namespace test
+	/// \addtogroup gtx_vector_access
+	/// @{
 
-    namespace gtx{
-	//! GLM_GTX_vector_access extension: Function to set values to vectors
-    namespace vector_access
-    {
-		/// \addtogroup gtx_vector_access
-		///@{
+	//! Set values to a 2 components vector.
+	//! From GLM_GTX_vector_access extension.
+    template <typename valType> 
+	void set(
+		detail::tvec2<valType> & v, 
+		valType const & x, 
+		valType const & y);
 
-		//! Set values to a 2 components vector.
-		//! From GLM_GTX_vector_access extension.
-        template <typename valType> 
-		void set(
-			detail::tvec2<valType> & v, 
-			valType const & x, 
-			valType const & y);
+	//! Set values to a 3 components vector.
+	//! From GLM_GTX_vector_access extension.
+    template <typename valType> 
+	void set(
+		detail::tvec3<valType> & v, 
+		valType const & x, 
+		valType const & y, 
+		valType const & z);
 
-		//! Set values to a 3 components vector.
-		//! From GLM_GTX_vector_access extension.
-        template <typename valType> 
-		void set(
-			detail::tvec3<valType> & v, 
-			valType const & x, 
-			valType const & y, 
-			valType const & z);
+	//! Set values to a 4 components vector.
+	//! From GLM_GTX_vector_access extension.
+    template <typename valType> 
+	void set(
+		detail::tvec4<valType> & v, 
+		valType const & x, 
+		valType const & y, 
+		valType const & z, 
+		valType const & w);
 
-		//! Set values to a 4 components vector.
-		//! From GLM_GTX_vector_access extension.
-        template <typename valType> 
-		void set(
-			detail::tvec4<valType> & v, 
-			valType const & x, 
-			valType const & y, 
-			valType const & z, 
-			valType const & w);
-
-		///@}
-
-    }//namespace vector_access
-    }//namespace gtx
+	/// @}
+}//namespace vector_access
+}//namespace gtx
 }//namespace glm
 
 #include "vector_access.inl"

glm/gtx/vector_angle.hpp

@@ -27,8 +27,7 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_vector_angle extension: Compute angle between vectors
-namespace vector_angle
+namespace vector_angle ///< GLM_GTX_vector_angle extension: Compute angle between vectors
 {
 	using namespace quaternion;
 	using namespace epsilon;
@@ -40,7 +39,7 @@ namespace vector_angle
 	//! Parameters need to be normalized.
 	//! From GLM_GTX_vector_angle extension
 	template <typename vecType> 
-	typename vecType::value_type angle(
+	GLM_FUNC_QUALIFIER typename vecType::value_type angle(
 		vecType const & x, 
 		vecType const & y);
 
@@ -48,7 +47,7 @@ namespace vector_angle
 	//! Parameters need to be normalized.
 	//! From GLM_GTX_vector_angle extension.
 	template <typename T> 
-	typename T orientedAngle(
+	GLM_FUNC_QUALIFIER T orientedAngle(
 		detail::tvec2<T> const & x, 
 		detail::tvec2<T> const & y);
 
@@ -56,15 +55,15 @@ namespace vector_angle
 	//! Parameters need to be normalized.
 	//! From GLM_GTX_vector_angle extension.
 	template <typename T>
-	typename vecType<T> orientedAngle(
+	GLM_FUNC_QUALIFIER T orientedAngle(
 		detail::tvec3<T> const & x,
 		detail::tvec3<T> const & y,
 		detail::tvec3<T> const & ref);
 
-	///@}
-}//namespace vector_angle
-}//namespace gtx
-}//namespace glm
+	/// @}
+}// namespace vector_angle
+}// namespace gtx
+}// namespace glm
 
 #include "vector_angle.inl"
 

glm/gtx/vector_query.hpp

@@ -22,78 +22,71 @@
 #	pragma message("GLM: GLM_GTX_vector_query extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace vector_query ///< GLM_GTX_vector_query extension: Query informations of vector types
 {
-	namespace test{
-		void main_ext_gtx_vector_query();
-	}//namespace test
+	/// \addtogroup gtx_vector_query
+	/// @{
 
-    namespace gtx{
-	//! GLM_GTX_vector_query extension: Query informations of vector types
-    namespace vector_query
-    {
-		/// \addtogroup gtx_vector_query
-		///@{
-
-		//! Check if two vectors are collinears.
-		//! From GLM_GTX_vector_query extensions.
-		template <typename genType> 
-		bool areCollinear(
-			genType const & v0, 
-			genType const & v1, 
-			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+	//! Check if two vectors are collinears.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType> 
+	bool areCollinear(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 		
-        //! Check if two vectors are opposites.
-		//! From GLM_GTX_vector_query extensions.
-		template <typename genType> 
-		bool areOpposite(
-			genType const & v0, 
-			genType const & v1, 
-			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+    //! Check if two vectors are opposites.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType> 
+	bool areOpposite(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 		
-        //! Check if two vectors are orthogonals.
-		//! From GLM_GTX_vector_query extensions.
-		template <typename genType> 
-		bool areOrthogonal(
-			genType const & v0, 
-			genType const & v1, 
-			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+    //! Check if two vectors are orthogonals.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType> 
+	bool areOrthogonal(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
-		//! Check if a vector is normalized.
-		//! From GLM_GTX_vector_query extensions.
-		template <typename genType> 
-		bool isNormalized(
-			genType const & v, 
-			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+	//! Check if a vector is normalized.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType> 
+	bool isNormalized(
+		genType const & v, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 		
-		//! Check if a vector is null.
-		//! From GLM_GTX_vector_query extensions.
-		template <typename genType> 
-		bool isNull(
-			genType const & v, 
-			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
-
-		//! Check if two vectors are orthonormal.
-		//! From GLM_GTX_vector_query extensions.
-		template <typename genType>
-		bool areOrthonormal(
-			genType const & v0, 
-			genType const & v1, 
-			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+	//! Check if a vector is null.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType> 
+	bool isNull(
+		genType const & v, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
-		//! Check if two vectors are similar.
-		//! From GLM_GTX_vector_query extensions.
-		template <typename genType> 
-		bool areSimilar(
-			genType const & v0, 
-			genType const & v1, 
-			typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
+	//! Check if two vectors are orthonormal.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType>
+	bool areOrthonormal(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
-		///@}
+	//! Check if two vectors are similar.
+	//! From GLM_GTX_vector_query extensions.
+	template <typename genType> 
+	bool areSimilar(
+		genType const & v0, 
+		genType const & v1, 
+		typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
-    }//namespace vector_query
-    }//namespace gtx
-}//namespace glm
+	/// @}
+}// namespace vector_query
+}// namespace gtx
+}// namespace glm
 
 #include "vector_query.inl"
 

glm/gtx/verbose_operator.hpp

@@ -20,48 +20,42 @@
 #	pragma message("GLM: GLM_GTX_verbose_operator extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to replace operators
 {
-	namespace test{
-		void main_ext_gtx_verbose_operator();
-	}//namespace test
+	/// \addtogroup gtx_verbose_operator
+	/// @{
 
-	namespace gtx{
-	//! GLM_GTX_verbose_operator extension: Use words to replace operators
-	namespace verbose_operator
-	{
-		/// \addtogroup gtx_verbose_operator
-		///@{
+	//! Addition of two values
+	//! From GLM_GTX_verbose_operator extension.
+	template <typename genTypeT, typename genTypeU> 
+	genTypeT add(genTypeT const & a, genTypeU const & b);
 
-		//! Addition of two values
-		//! From GLM_GTX_verbose_operator extension.
-		template <typename genTypeT, typename genTypeU> 
-		genTypeT add(genTypeT const & a, genTypeU const & b);
+	//! Substration of two values
+	//! From GLM_GTX_verbose_operator extension.
+	template <typename genTypeT, typename genTypeU> 
+	genTypeT sub(genTypeT const & a, genTypeU const & b);
 
-		//! Substration of two values
-		//! From GLM_GTX_verbose_operator extension.
-		template <typename genTypeT, typename genTypeU> 
-		genTypeT sub(genTypeT const & a, genTypeU const & b);
+	//! Multiplication of two values
+	//! From GLM_GTX_verbose_operator extension.
+	template <typename genTypeT, typename genTypeU> 
+	genTypeT mul(genTypeT const & a, genTypeU const & b);
 
-		//! Multiplication of two values
-		//! From GLM_GTX_verbose_operator extension.
-		template <typename genTypeT, typename genTypeU> 
-		genTypeT mul(genTypeT const & a, genTypeU const & b);
+	//! Division of two values
+	//! From GLM_GTX_verbose_operator extension.
+	template <typename genTypeT, typename genTypeU> 
+	genTypeT div(genTypeT const & a, genTypeU const & b);
 
-		//! Division of two values
-		//! From GLM_GTX_verbose_operator extension.
-		template <typename genTypeT, typename genTypeU> 
-		genTypeT div(genTypeT const & a, genTypeU const & b);
+	//! Multiplication and addition of three values
+	//! From GLM_GTX_verbose_operator extension.
+	template <typename genTypeT, typename genTypeU, typename genTypeV> 
+	genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
 
-		//! Multiplication and addition of three values
-		//! From GLM_GTX_verbose_operator extension.
-		template <typename genTypeT, typename genTypeU, typename genTypeV> 
-		genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
-
-		///@}
-	}//namespace verbose_operator
-	}//namespace gtx
-}//namespace glm
+	/// @}
+}// namespace verbose_operator
+}// namespace gtx
+}// namespace glm
 
 #include "verbose_operator.inl"
 

glm/gtx/wrap.hpp

@@ -20,39 +20,32 @@
 #	pragma message("GLM: GLM_GTX_wrap extension included")
 #endif
 
-namespace glm
+namespace glm{
+namespace gtx{
+namespace wrap ///< GLM_GTX_wrap: Wrapping mode using my texture samping.
 {
-	namespace test{
-		bool main_gtx_wrap();
-	}//namespace test
-
-	namespace gtx{
-	//! GLM_GTX_wrap: Wrapping mode using my texture samping.
-	namespace wrap
-	{
-		/// \addtogroup gtx_wrap
-		///@{
-
-		//! Simulate GL_CLAMP OpenGL wrap mode
-		//! From GLM_GTX_wrap extension.
-		template <typename genType> 
-		genType clamp(genType const & Texcoord);
-
-		//! Simulate GL_REPEAT OpenGL wrap mode
-		//! From GLM_GTX_wrap extension.
-		template <typename genType> 
-		genType repeat(genType const & Texcoord);
-
-		//! Simulate GL_MIRROR_REPEAT OpenGL wrap mode
-		//! From GLM_GTX_wrap extension.
-		template <typename genType> 
-		genType mirrorRepeat(genType const & Texcoord);
-
-		///@}
-
-	}//namespace wrap
-	}//namespace gtx
-}//namespace glm
+	/// \addtogroup gtx_wrap
+	/// @{
+
+	//! Simulate GL_CLAMP OpenGL wrap mode
+	//! From GLM_GTX_wrap extension.
+	template <typename genType> 
+	genType clamp(genType const & Texcoord);
+
+	//! Simulate GL_REPEAT OpenGL wrap mode
+	//! From GLM_GTX_wrap extension.
+	template <typename genType> 
+	genType repeat(genType const & Texcoord);
+
+	//! Simulate GL_MIRROR_REPEAT OpenGL wrap mode
+	//! From GLM_GTX_wrap extension.
+	template <typename genType> 
+	genType mirrorRepeat(genType const & Texcoord);
+
+	/// @}
+}// namespace wrap
+}// namespace gtx
+}// namespace glm
 
 #include "wrap.inl"
 

readme.txt

@@ -17,6 +17,7 @@ http://glm.g-truc.net/glm-0.9.2.pdf
 GLM 0.9.2.1: 2010-05-20
 --------------------------------------------------------------------------------
 - Automatically detect CUDA support
+- Improved Clang detection
 - Fixed errors and warnings in VC with C++ extensions disabled
 - Fixed and tested GLM_GTX_vector_angle
 - Fixed and tested GLM_GTX_rotate_vector

test/gtx/gtx_vector_angle.cpp

@@ -12,16 +12,18 @@
 #include <iostream>
 #include <limits>
 
-int test_vector_angle_calls()
+int test_angle()
 {
-	int Error = 0;
-
-	float AngleA = glm::angle(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0));
-	float AngleB = glm::orientedAngle(glm::vec2(1, 0), glm::normalize(glm::vec2(1, 1)));
-	float AngleC = glm::orientedAngle(glm::vec2(0, 1), glm::normalize(glm::vec2(1, 1)));
-	float AngleD = glm::orientedAngle(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1));
-
-	return Error;
+    int Error = 0;
+    
+	float AngleA = glm::angle(glm::vec2(1, 0), glm::normalize(glm::vec2(1, 1)));
+    Error += glm::equalEpsilon(AngleA, 45.f, 0.01f) ? 0 : 1;
+	float AngleB = glm::angle(glm::vec3(1, 0, 0), glm::normalize(glm::vec3(1, 1, 0)));
+    Error += glm::equalEpsilon(AngleB, 45.f, 0.01f) ? 0 : 1;
+	float AngleC = glm::angle(glm::vec4(1, 0, 0, 0), glm::normalize(glm::vec4(1, 1, 0, 0)));
+    Error += glm::equalEpsilon(AngleC, 45.f, 0.01f) ? 0 : 1;
+ 
+    return Error;
 }
 
 int test_orientedAngle_vec2()
@@ -55,9 +57,9 @@ int test_orientedAngle_vec3()
 int main()
 {
 	int Error = 0;
+	Error += test_angle();
     Error += test_orientedAngle_vec2();
 	Error += test_orientedAngle_vec3();
-	Error += test_vector_angle_calls();
 
 	return Error;
 }