typos

glm/core/func_geometric.hpp

@@ -12,14 +12,9 @@
 
 namespace glm
 {
-	namespace test{
-		void main_core_func_geometric();
-	}//namespace test
-
 	namespace core{
 	namespace function{
-	//! Define all geometric functions from Section 8.4 of GLSL 1.30.8 specification. Included in glm namespace.
-	namespace geometric{
+	namespace geometric{ //!< Define all geometric functions from Section 8.4 of GLSL 1.30.8 specification. Included in glm namespace.
 
 	/// \addtogroup core_funcs
 	///@{

glm/core/func_integer.hpp

@@ -12,10 +12,6 @@
 
 namespace glm
 {
-	namespace test{
-		void main_core_func_integer();
-	}//namespace test
-
 	namespace core{
 	namespace function{
 	//! Define integer functions from Section 8.8 of GLSL 4.00.8 specification. 

glm/core/func_matrix.hpp

@@ -12,10 +12,6 @@
 
 namespace glm
 {
-	namespace test{
-		void main_core_func_matrix();
-	}//namespace test
-
 	namespace core{
 	namespace function{
 	//! Define all matrix functions from Section 8.5 of GLSL 1.30.8 specification. Included in glm namespace.

glm/core/func_noise.hpp

@@ -12,10 +12,6 @@
 
 namespace glm
 {
-	namespace test{
-		void main_core_func_noise();
-	}//namespace test
-
 	namespace core{
 	namespace function{
 	// Define all noise functions from Section 8.9 of GLSL 1.30.8 specification. Included in glm namespace.

glm/core/func_packing.hpp

@@ -12,10 +12,6 @@
 
 namespace glm
 {
-	namespace test{
-		void main_core_func_packing();
-	}//namespace test
-
 	namespace core{
 	namespace function{
 	//! Define packing functions from section 8.4 floating-point pack and unpack functions of GLSL 4.00.8 specification

glm/core/func_trigonometric.hpp

@@ -12,10 +12,6 @@
 
 namespace glm
 {
-	namespace test{
-		void main_core_func_trigonometric();
-	}//namespace test
-
 	namespace core{
 	namespace function{
 	//! Define Angle and trigonometry functions 

glm/core/func_vector_relational.hpp

@@ -14,10 +14,6 @@
 
 namespace glm
 {
-	namespace test{
-		void main_core_func_vector_relational();
-	}//namespace test
-
 	namespace core{
 	namespace function{
 	//! Define vector relational functions from Section 8.6 of GLSL 1.30.8 specification. 

glm/core/type_half.hpp

@@ -12,74 +12,65 @@
 
 #include <cstdlib>
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
-	{
-		bool main_type_half();
+	typedef short hdata;
 
-	}//namespace test
+	float toFloat32(hdata value);
+	hdata toFloat16(float const & value);
 
-	namespace detail
+	///16-bit floating point type.
+	/// \ingroup gtc_half_float
+	class thalf
 	{
-		typedef short hdata;
-
-		float toFloat32(hdata value);
-		hdata toFloat16(float const & value);
-
-		///16-bit floating point type.
-		/// \ingroup gtc_half_float
-		class thalf
-		{
-		public: 
-			// Constructors
-			GLM_FUNC_DECL thalf();
-			GLM_FUNC_DECL thalf(thalf const & s);
+	public: 
+		// Constructors
+		GLM_FUNC_DECL thalf();
+		GLM_FUNC_DECL thalf(thalf const & s);
 			
-			template <typename U>
-			GLM_FUNC_DECL explicit thalf(U const & s);
-
-			// Cast
-			//operator float();
-			GLM_FUNC_DECL operator float() const;
-			//operator double();
-			//operator double() const;
-
-			// Unary updatable operators
-			GLM_FUNC_DECL thalf& operator= (thalf const & s);
-			GLM_FUNC_DECL thalf& operator+=(thalf const & s);
-			GLM_FUNC_DECL thalf& operator-=(thalf const & s);
-			GLM_FUNC_DECL thalf& operator*=(thalf const & s);
-			GLM_FUNC_DECL thalf& operator/=(thalf const & s);
-			GLM_FUNC_DECL thalf& operator++();
-			GLM_FUNC_DECL thalf& operator--();
+		template <typename U>
+		GLM_FUNC_DECL explicit thalf(U const & s);
+
+		// Cast
+		//operator float();
+		GLM_FUNC_DECL operator float() const;
+		//operator double();
+		//operator double() const;
+
+		// Unary updatable operators
+		GLM_FUNC_DECL thalf& operator= (thalf const & s);
+		GLM_FUNC_DECL thalf& operator+=(thalf const & s);
+		GLM_FUNC_DECL thalf& operator-=(thalf const & s);
+		GLM_FUNC_DECL thalf& operator*=(thalf const & s);
+		GLM_FUNC_DECL thalf& operator/=(thalf const & s);
+		GLM_FUNC_DECL thalf& operator++();
+		GLM_FUNC_DECL thalf& operator--();
 	
-			GLM_FUNC_DECL float toFloat() const{return toFloat32(data);}
-
-			GLM_FUNC_DECL hdata _data() const{return data;}
-
-		private:
-			hdata data;
-		};
+		GLM_FUNC_DECL float toFloat() const{return toFloat32(data);}
 
-		thalf operator+ (thalf const & s1, thalf const & s2);
+		GLM_FUNC_DECL hdata _data() const{return data;}
 
-		thalf operator- (thalf const & s1, thalf const & s2);
+	private:
+		hdata data;
+	};
 
-		thalf operator* (thalf const & s1, thalf const & s2);
+	thalf operator+ (thalf const & s1, thalf const & s2);
 
-		thalf operator/ (thalf const & s1, thalf const & s2);
+	thalf operator- (thalf const & s1, thalf const & s2);
 
-		// Unary constant operators
-		thalf operator- (thalf const & s);
+	thalf operator* (thalf const & s1, thalf const & s2);
 
-		thalf operator-- (thalf const & s, int);
+	thalf operator/ (thalf const & s1, thalf const & s2);
 
-		thalf operator++ (thalf const & s, int);
+	// Unary constant operators
+	thalf operator- (thalf const & s);
 
-	}//namespace detail
+	thalf operator-- (thalf const & s, int);
 
+	thalf operator++ (thalf const & s, int);
 
+}//namespace detail
 }//namespace glm
 
 #include "type_half.inl"

glm/core/type_int.hpp

@@ -13,71 +13,66 @@
 #include "setup.hpp"
 #include "_detail.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace detail
-	{
-		typedef signed short			lowp_int_t;
-		typedef signed int				mediump_int_t;
-		typedef sint64					highp_int_t;
+	typedef signed short			lowp_int_t;
+	typedef signed int				mediump_int_t;
+	typedef sint64					highp_int_t;
 
-		typedef unsigned short			lowp_uint_t;
-		typedef unsigned int			mediump_uint_t;
-		typedef uint64					highp_uint_t;
+	typedef unsigned short			lowp_uint_t;
+	typedef unsigned int			mediump_uint_t;
+	typedef uint64					highp_uint_t;
 
-		GLM_DETAIL_IS_INT(signed char);
-		GLM_DETAIL_IS_INT(signed short);
-		GLM_DETAIL_IS_INT(signed int);
-		GLM_DETAIL_IS_INT(signed long);
-		GLM_DETAIL_IS_INT(highp_int_t);
+	GLM_DETAIL_IS_INT(signed char);
+	GLM_DETAIL_IS_INT(signed short);
+	GLM_DETAIL_IS_INT(signed int);
+	GLM_DETAIL_IS_INT(signed long);
+	GLM_DETAIL_IS_INT(highp_int_t);
 
-		GLM_DETAIL_IS_UINT(unsigned char);
-		GLM_DETAIL_IS_UINT(unsigned short);
-		GLM_DETAIL_IS_UINT(unsigned int);
-		GLM_DETAIL_IS_UINT(unsigned long);
-		GLM_DETAIL_IS_UINT(highp_uint_t);
-	}
-	//namespace detail
+	GLM_DETAIL_IS_UINT(unsigned char);
+	GLM_DETAIL_IS_UINT(unsigned short);
+	GLM_DETAIL_IS_UINT(unsigned int);
+	GLM_DETAIL_IS_UINT(unsigned long);
+	GLM_DETAIL_IS_UINT(highp_uint_t);
+}//namespace detail
 
-	namespace core{
-	namespace type{
-
-	///namespace for precision stuff.
-	namespace precision
-	{
-		//! Low precision signed integer. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification.
-		//! \ingroup core_precision
-		typedef detail::lowp_int_t				lowp_int;
-		//! Medium precision signed integer. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification.
-		//! \ingroup core_precision
-		typedef detail::mediump_int_t				mediump_int;
-		//! High precision signed integer.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification.
-		//! \ingroup core_precision
-		typedef detail::highp_int_t				highp_int;
+namespace core{
+namespace type{
+namespace precision //!< Namespace for precision stuff.
+{
+	//! Low precision signed integer. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification.
+	//! \ingroup core_precision
+	typedef detail::lowp_int_t				lowp_int;
+	//! Medium precision signed integer. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification.
+	//! \ingroup core_precision
+	typedef detail::mediump_int_t				mediump_int;
+	//! High precision signed integer.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification.
+	//! \ingroup core_precision
+	typedef detail::highp_int_t				highp_int;
 
-		//! Low precision unsigned integer. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification.
-		//! \ingroup core_precision
-		typedef detail::lowp_uint_t				lowp_uint;
-		//! Medium precision unsigned integer. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification.
-		//! \ingroup core_precision
-		typedef detail::mediump_uint_t			mediump_uint;
-		//! High precision unsigned integer. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification.
-		//! \ingroup core_precision
-		typedef detail::highp_uint_t				highp_uint;
-	}
-	//namespace precision
+	//! Low precision unsigned integer. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification.
+	//! \ingroup core_precision
+	typedef detail::lowp_uint_t				lowp_uint;
+	//! Medium precision unsigned integer. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification.
+	//! \ingroup core_precision
+	typedef detail::mediump_uint_t			mediump_uint;
+	//! High precision unsigned integer. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification.
+	//! \ingroup core_precision
+	typedef detail::highp_uint_t				highp_uint;
+}//namespace precision
 
 #if(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
 	typedef precision::mediump_int				int_t;
@@ -107,8 +102,8 @@ namespace glm
 	//! From GLSL 1.30.8 specification section 4.1.3 Integers.
 	typedef uint_t								uint;
 
-	}//namespace type
-	}//namespace core
+}//namespace type
+}//namespace core
 }//namespace glm
 
 #endif//glm_core_type_int

glm/core/type_mat2x2.hpp

@@ -12,276 +12,267 @@
 
 #include "type_mat.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
+	template <typename T> struct tvec1;
+	template <typename T> struct tvec2;
+	template <typename T> struct tvec3;
+	template <typename T> struct tvec4;
+	template <typename T> struct tmat2x2;
+	template <typename T> struct tmat2x3;
+	template <typename T> struct tmat2x4;
+	template <typename T> struct tmat3x2;
+	template <typename T> struct tmat3x3;
+	template <typename T> struct tmat3x4;
+	template <typename T> struct tmat4x2;
+	template <typename T> struct tmat4x3;
+	template <typename T> struct tmat4x4;
+
+	//! \brief Template for 2 * 2 matrix of floating-point numbers.
+	//! \ingroup core_template
+	template <typename T> 
+	struct tmat2x2
 	{
-		void main_mat2x2();
-	}//namespace test
-
-	namespace detail
-	{
-		template <typename T> struct tvec1;
-		template <typename T> struct tvec2;
-		template <typename T> struct tvec3;
-		template <typename T> struct tvec4;
-		template <typename T> struct tmat2x2;
-		template <typename T> struct tmat2x3;
-		template <typename T> struct tmat2x4;
-		template <typename T> struct tmat3x2;
-		template <typename T> struct tmat3x3;
-		template <typename T> struct tmat3x4;
-		template <typename T> struct tmat4x2;
-		template <typename T> struct tmat4x3;
-		template <typename T> struct tmat4x4;
-
-		//! \brief Template for 2 * 2 matrix of floating-point numbers.
-		//! \ingroup core_template
-		template <typename T> 
-		struct tmat2x2
-		{
-			enum ctor{null};
-			typedef T value_type;
-			typedef std::size_t size_type;
-			typedef tvec2<T> col_type;
-			typedef tvec2<T> row_type;
-			static GLM_FUNC_DECL size_type col_size();
-			static GLM_FUNC_DECL size_type row_size();
-
-			typedef tmat2x2<T> type;
-			typedef tmat2x2<T> transpose_type;
-
-		public:
-			// Implementation detail
-			GLM_FUNC_DECL tmat2x2<T> _inverse() const;
-
-		private:
-			//////////////////////////////////////
-			// Data 
-			col_type value[2];
-
-		public:
-			//////////////////////////////////////
-			// Constructors
-			GLM_FUNC_DECL tmat2x2();
-			GLM_FUNC_DECL tmat2x2(
-				tmat2x2 const & m);
-
-			GLM_FUNC_DECL explicit tmat2x2(
-				ctor Null);
-			GLM_FUNC_DECL explicit tmat2x2(
-				value_type const & x);
-			GLM_FUNC_DECL explicit tmat2x2(
-				value_type const & x1, value_type const & y1, 
-				value_type const & x2, value_type const & y2);
-			GLM_FUNC_DECL explicit tmat2x2(
-				col_type const & v1, 
-				col_type const & v2);
-
-			//////////////////////////////////////
-			// Conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat2x2(
-				U const & x);
+		enum ctor{null};
+		typedef T value_type;
+		typedef std::size_t size_type;
+		typedef tvec2<T> col_type;
+		typedef tvec2<T> row_type;
+		static GLM_FUNC_DECL size_type col_size();
+		static GLM_FUNC_DECL size_type row_size();
+
+		typedef tmat2x2<T> type;
+		typedef tmat2x2<T> transpose_type;
+
+	public:
+		// Implementation detail
+		GLM_FUNC_DECL tmat2x2<T> _inverse() const;
+
+	private:
+		//////////////////////////////////////
+		// Data 
+		col_type value[2];
+
+	public:
+		//////////////////////////////////////
+		// Constructors
+		GLM_FUNC_DECL tmat2x2();
+		GLM_FUNC_DECL tmat2x2(
+			tmat2x2 const & m);
+
+		GLM_FUNC_DECL explicit tmat2x2(
+			ctor Null);
+		GLM_FUNC_DECL explicit tmat2x2(
+			value_type const & x);
+		GLM_FUNC_DECL explicit tmat2x2(
+			value_type const & x1, value_type const & y1, 
+			value_type const & x2, value_type const & y2);
+		GLM_FUNC_DECL explicit tmat2x2(
+			col_type const & v1, 
+			col_type const & v2);
+
+		//////////////////////////////////////
+		// Conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat2x2(
+			U const & x);
 			
-			template <typename U, typename V, typename M, typename N> 
-			GLM_FUNC_DECL explicit tmat2x2(
-				U const & x1, V const & y1, 
-				M const & x2, N const & y2);
+		template <typename U, typename V, typename M, typename N> 
+		GLM_FUNC_DECL explicit tmat2x2(
+			U const & x1, V const & y1, 
+			M const & x2, N const & y2);
 			
-			template <typename U, typename V> 
-			GLM_FUNC_DECL explicit tmat2x2(
-				tvec2<U> const & v1, 
-				tvec2<V> const & v2);
-
-			//////////////////////////////////////
-			// Matrix conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U> const & m);
-
-			GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x2(tmat2x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x2(tmat3x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x2(tmat2x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x2(tmat4x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x2(tmat3x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x2(tmat4x3<T> const & x);
-
-			//////////////////////////////////////
-			// Accesses
-
-			GLM_FUNC_DECL col_type & operator[](size_type i);
-			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-			// Unary updatable operators
-			GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<T> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x2<T> & operator+=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x2<T> & operator+=(tmat2x2<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x2<T> & operator-=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x2<T> & operator-=(tmat2x2<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x2<T> & operator*=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x2<T> & operator*=(tmat2x2<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x2<T> & operator/=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x2<T> & operator/=(tmat2x2<U> const & m);
-			GLM_FUNC_DECL tmat2x2<T> & operator++();
-			GLM_FUNC_DECL tmat2x2<T> & operator--();
-		};
-
-		// Binary operators
-		template <typename T> 
-		tmat2x2<T> operator+ (
-			tmat2x2<T> const & m, 
-			typename tmat2x2<T>::value_type const & s);
-
-		template <typename T> 
-		tmat2x2<T> operator+ (
-			typename tmat2x2<T>::value_type const & s, 
-			tmat2x2<T> const & m);
-
-		template <typename T> 
-		tmat2x2<T> operator+ (
-			tmat2x2<T> const & m1, 
-			tmat2x2<T> const & m2);
+		template <typename U, typename V> 
+		GLM_FUNC_DECL explicit tmat2x2(
+			tvec2<U> const & v1, 
+			tvec2<V> const & v2);
+
+		//////////////////////////////////////
+		// Matrix conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U> const & m);
+
+		GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat2x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat3x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat2x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat4x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat3x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x2(tmat4x3<T> const & x);
+
+		//////////////////////////////////////
+		// Accesses
+
+		GLM_FUNC_DECL col_type & operator[](size_type i);
+		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+
+		// Unary updatable operators
+		GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<T> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T> & operator+=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T> & operator+=(tmat2x2<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T> & operator-=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T> & operator-=(tmat2x2<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T> & operator*=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T> & operator*=(tmat2x2<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T> & operator/=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x2<T> & operator/=(tmat2x2<U> const & m);
+		GLM_FUNC_DECL tmat2x2<T> & operator++();
+		GLM_FUNC_DECL tmat2x2<T> & operator--();
+	};
+
+	// Binary operators
+	template <typename T> 
+	tmat2x2<T> operator+ (
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::value_type const & s);
+
+	template <typename T> 
+	tmat2x2<T> operator+ (
+		typename tmat2x2<T>::value_type const & s, 
+		tmat2x2<T> const & m);
+
+	template <typename T> 
+	tmat2x2<T> operator+ (
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2);
 	    
-		template <typename T> 
-		tmat2x2<T> operator- (
-			tmat2x2<T> const & m, 
-			typename tmat2x2<T>::value_type const & s);
-
-		template <typename T> 
-		tmat2x2<T> operator- (
-			typename tmat2x2<T>::value_type const & s, 
-			tmat2x2<T> const & m);
-
-		template <typename T> 
-		tmat2x2<T> operator- (
-			tmat2x2<T> const & m1, 
-			tmat2x2<T> const & m2);
-
-		template <typename T> 
-		tmat2x2<T> operator* (
-			tmat2x2<T> const & m, 
-			typename tmat2x2<T>::value_type const & s);
-
-		template <typename T> 
-		tmat2x2<T> operator* (
-			typename tmat2x2<T>::value_type const & s, 
-			tmat2x2<T> const & m);
-
-		template <typename T> 
-		typename tmat2x2<T>::col_type operator* (
-			tmat2x2<T> const & m, 
-			typename tmat2x2<T>::row_type const & v);
-
-		template <typename T> 
-		typename tmat2x2<T>::row_type operator* (
-			typename tmat2x2<T>::col_type const & v, 
-			tmat2x2<T> const & m);
-
-		template <typename T> 
-		tmat2x2<T> operator* (
-			tmat2x2<T> const & m1, 
-			tmat2x2<T> const & m2);
-
-		template <typename T> 
-		tmat2x2<T> operator/ (
-			tmat2x2<T> const & m, 
-			typename tmat2x2<T>::value_type const & s);
-
-		template <typename T> 
-		tmat2x2<T> operator/ (
-			typename tmat2x2<T>::value_type const & s,
-			tmat2x2<T> const & m);
-
-		template <typename T> 
-		typename tmat2x2<T>::col_type operator/ (
-			tmat2x2<T> const & m, 
-			typename tmat2x2<T>::row_type const & v);
-
-		template <typename T> 
-		typename tmat2x2<T>::row_type operator/ (
-			typename tmat2x2<T>::col_type const & v, 
-			tmat2x2<T> const & m);
-
-		template <typename T> 
-		tmat2x2<T> operator/ (
-			tmat2x2<T> const & m1, 
-			tmat2x2<T> const & m2);
-
-		// Unary constant operators
-		template <typename T> 
-		tmat2x2<T> const operator-  (
-			tmat2x2<T> const & m);
-
-		template <typename T> 
-		tmat2x2<T> const operator-- (
-			tmat2x2<T> const & m, 
-			int);
-
-		template <typename T> 
-		tmat2x2<T> const operator++ (
-			tmat2x2<T> const & m, 
-			int);
-
-	} //namespace detail
-
-	namespace core{
-	namespace type{
-
-	namespace precision
-	{
-		//! 2 columns of 2 components matrix of low precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat2x2<lowp_float>		lowp_mat2;
-
-		//! 2 columns of 2 components matrix of medium precision floating-point numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat2x2<mediump_float>	mediump_mat2;
-
-		//! 2 columns of 2 components matrix of high precision floating-point numbers. 
-		//! There is no guarantee on the actual precision. 
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat2x2<highp_float>	highp_mat2;
-
-		//! 2 columns of 2 components matrix of low precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat2x2<lowp_float>		lowp_mat2x2;
-
-		//! 2 columns of 2 components matrix of medium precision floating-point numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat2x2<mediump_float>	mediump_mat2x2;
-
-		//! 2 columns of 2 components matrix of high precision floating-point numbers. 
-		//! There is no guarantee on the actual precision. 
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat2x2<highp_float>	highp_mat2x2;
-	}
-	//namespace precision
-
-	}//namespace type
-	}//namespace core
-} //namespace glm
+	template <typename T> 
+	tmat2x2<T> operator- (
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::value_type const & s);
+
+	template <typename T> 
+	tmat2x2<T> operator- (
+		typename tmat2x2<T>::value_type const & s, 
+		tmat2x2<T> const & m);
+
+	template <typename T> 
+	tmat2x2<T> operator- (
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2);
+
+	template <typename T> 
+	tmat2x2<T> operator* (
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::value_type const & s);
+
+	template <typename T> 
+	tmat2x2<T> operator* (
+		typename tmat2x2<T>::value_type const & s, 
+		tmat2x2<T> const & m);
+
+	template <typename T> 
+	typename tmat2x2<T>::col_type operator* (
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::row_type const & v);
+
+	template <typename T> 
+	typename tmat2x2<T>::row_type operator* (
+		typename tmat2x2<T>::col_type const & v, 
+		tmat2x2<T> const & m);
+
+	template <typename T> 
+	tmat2x2<T> operator* (
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2);
+
+	template <typename T> 
+	tmat2x2<T> operator/ (
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::value_type const & s);
+
+	template <typename T> 
+	tmat2x2<T> operator/ (
+		typename tmat2x2<T>::value_type const & s,
+		tmat2x2<T> const & m);
+
+	template <typename T> 
+	typename tmat2x2<T>::col_type operator/ (
+		tmat2x2<T> const & m, 
+		typename tmat2x2<T>::row_type const & v);
+
+	template <typename T> 
+	typename tmat2x2<T>::row_type operator/ (
+		typename tmat2x2<T>::col_type const & v, 
+		tmat2x2<T> const & m);
+
+	template <typename T> 
+	tmat2x2<T> operator/ (
+		tmat2x2<T> const & m1, 
+		tmat2x2<T> const & m2);
+
+	// Unary constant operators
+	template <typename T> 
+	tmat2x2<T> const operator-  (
+		tmat2x2<T> const & m);
+
+	template <typename T> 
+	tmat2x2<T> const operator-- (
+		tmat2x2<T> const & m, 
+		int);
+
+	template <typename T> 
+	tmat2x2<T> const operator++ (
+		tmat2x2<T> const & m, 
+		int);
+} //namespace detail
+
+namespace core{
+namespace type{
+namespace precision
+{
+	//! 2 columns of 2 components matrix of low precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat2x2<lowp_float>		lowp_mat2;
+
+	//! 2 columns of 2 components matrix of medium precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat2x2<mediump_float>	mediump_mat2;
+
+	//! 2 columns of 2 components matrix of high precision floating-point numbers. 
+	//! There is no guarantee on the actual precision. 
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat2x2<highp_float>	highp_mat2;
+
+	//! 2 columns of 2 components matrix of low precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat2x2<lowp_float>		lowp_mat2x2;
+
+	//! 2 columns of 2 components matrix of medium precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat2x2<mediump_float>	mediump_mat2x2;
+
+	//! 2 columns of 2 components matrix of high precision floating-point numbers. 
+	//! There is no guarantee on the actual precision. 
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat2x2<highp_float>	highp_mat2x2;
+
+}//namespace precision
+}//namespace type
+}//namespace core
+}//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat2x2.inl"

glm/core/type_mat2x3.hpp

@@ -12,222 +12,213 @@
 
 #include "type_mat.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
+	template <typename T> struct tvec1;
+	template <typename T> struct tvec2;
+	template <typename T> struct tvec3;
+	template <typename T> struct tvec4;
+	template <typename T> struct tmat2x2;
+	template <typename T> struct tmat2x3;
+	template <typename T> struct tmat2x4;
+	template <typename T> struct tmat3x2;
+	template <typename T> struct tmat3x3;
+	template <typename T> struct tmat3x4;
+	template <typename T> struct tmat4x2;
+	template <typename T> struct tmat4x3;
+	template <typename T> struct tmat4x4;
+
+	//! \brief Template for 2 columns and 3 rows matrix of floating-point numbers.
+	//! \ingroup core_template
+	template <typename T> 
+	struct tmat2x3
 	{
-		void main_mat2x3();
-	}//namespace test
-
-	namespace detail
-	{
-		template <typename T> struct tvec1;
-		template <typename T> struct tvec2;
-		template <typename T> struct tvec3;
-		template <typename T> struct tvec4;
-		template <typename T> struct tmat2x2;
-		template <typename T> struct tmat2x3;
-		template <typename T> struct tmat2x4;
-		template <typename T> struct tmat3x2;
-		template <typename T> struct tmat3x3;
-		template <typename T> struct tmat3x4;
-		template <typename T> struct tmat4x2;
-		template <typename T> struct tmat4x3;
-		template <typename T> struct tmat4x4;
-
-		//! \brief Template for 2 columns and 3 rows matrix of floating-point numbers.
-		//! \ingroup core_template
-		template <typename T> 
-		struct tmat2x3
-		{
-			enum ctor{null};
-			typedef T value_type;
-			typedef std::size_t size_type;
-			typedef tvec3<T> col_type;
-			typedef tvec2<T> row_type;
-			static GLM_FUNC_DECL size_type col_size();
-			static GLM_FUNC_DECL size_type row_size();
-
-			typedef tmat2x3<T> type;
-			typedef tmat3x2<T> transpose_type;
-
-		private:
-			// Data 
-			col_type value[2];
-
-		public:
-			// Constructors
-			GLM_FUNC_DECL tmat2x3();
-			GLM_FUNC_DECL tmat2x3(tmat2x3 const & m);
-
-			GLM_FUNC_DECL explicit tmat2x3(
-				ctor);
-			GLM_FUNC_DECL explicit tmat2x3(
-				value_type const & s);
-			GLM_FUNC_DECL explicit tmat2x3(
-				value_type const & x0, value_type const & y0, value_type const & z0,
-				value_type const & x1, value_type const & y1, value_type const & z1);
-			GLM_FUNC_DECL explicit tmat2x3(
-				col_type const & v0, 
-				col_type const & v1);
+		enum ctor{null};
+		typedef T value_type;
+		typedef std::size_t size_type;
+		typedef tvec3<T> col_type;
+		typedef tvec2<T> row_type;
+		static GLM_FUNC_DECL size_type col_size();
+		static GLM_FUNC_DECL size_type row_size();
+
+		typedef tmat2x3<T> type;
+		typedef tmat3x2<T> transpose_type;
+
+	private:
+		// Data 
+		col_type value[2];
+
+	public:
+		// Constructors
+		GLM_FUNC_DECL tmat2x3();
+		GLM_FUNC_DECL tmat2x3(tmat2x3 const & m);
+
+		GLM_FUNC_DECL explicit tmat2x3(
+			ctor);
+		GLM_FUNC_DECL explicit tmat2x3(
+			value_type const & s);
+		GLM_FUNC_DECL explicit tmat2x3(
+			value_type const & x0, value_type const & y0, value_type const & z0,
+			value_type const & x1, value_type const & y1, value_type const & z1);
+		GLM_FUNC_DECL explicit tmat2x3(
+			col_type const & v0, 
+			col_type const & v1);
 
             
-			//////////////////////////////////////
-			// Conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat2x3(
-                U const & x);
+		//////////////////////////////////////
+		// Conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat2x3(
+            U const & x);
 			
-			template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2> 
-			GLM_FUNC_DECL explicit tmat2x3(
-                X1 const & x1, Y1 const & y1, Z1 const & z1, 
-                X2 const & x2, Y2 const & y2, Z2 const & z2);
+		template <typename X1, typename Y1, typename Z1, typename X2, typename Y2, typename Z2> 
+		GLM_FUNC_DECL explicit tmat2x3(
+            X1 const & x1, Y1 const & y1, Z1 const & z1, 
+            X2 const & x2, Y2 const & y2, Z2 const & z2);
 			
-			template <typename U, typename V> 
-			GLM_FUNC_DECL explicit tmat2x3(
-                tvec3<U> const & v1, 
-                tvec3<V> const & v2);
+		template <typename U, typename V> 
+		GLM_FUNC_DECL explicit tmat2x3(
+            tvec3<U> const & v1, 
+            tvec3<V> const & v2);
             
-			//////////////////////////////////////
-            // Matrix conversion
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U> const & m);
-
-			GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x3(tmat4x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x3(tmat2x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x3(tmat3x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x3(tmat3x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x3(tmat4x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T> const & x);
-
-			// Accesses
-			col_type & operator[](size_type i);
-			col_type const & operator[](size_type i) const;
-
-			// Unary updatable operators
-			GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<T> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x3<T> & operator+= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x3<T> & operator+= (tmat2x3<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x3<T> & operator-= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x3<T> & operator-= (tmat2x3<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x3<T> & operator*= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x3<T> & operator*= (tmat2x3<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x3<T> & operator/= (U const & s);
-
-			GLM_FUNC_DECL tmat2x3<T> & operator++ ();
-			GLM_FUNC_DECL tmat2x3<T> & operator-- ();
-		};
-
-		// Binary operators
-		template <typename T> 
-		tmat2x3<T> operator+ (
-			tmat2x3<T> const & m, 
-			typename tmat2x3<T>::value_type const & s);
+		//////////////////////////////////////
+        // Matrix conversion
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U> const & m);
+
+		GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat4x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat2x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat3x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat3x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat4x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T> const & x);
+
+		// Accesses
+		col_type & operator[](size_type i);
+		col_type const & operator[](size_type i) const;
+
+		// Unary updatable operators
+		GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<T> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T> & operator=  (tmat2x3<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T> & operator+= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T> & operator+= (tmat2x3<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T> & operator-= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T> & operator-= (tmat2x3<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T> & operator*= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T> & operator*= (tmat2x3<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x3<T> & operator/= (U const & s);
+
+		GLM_FUNC_DECL tmat2x3<T> & operator++ ();
+		GLM_FUNC_DECL tmat2x3<T> & operator-- ();
+	};
+
+	// Binary operators
+	template <typename T> 
+	tmat2x3<T> operator+ (
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::value_type const & s);
 	    
-		template <typename T> 
-		tmat2x3<T> operator+ (
-			tmat2x3<T> const & m1, 
-			tmat2x3<T> const & m2);
+	template <typename T> 
+	tmat2x3<T> operator+ (
+		tmat2x3<T> const & m1, 
+		tmat2x3<T> const & m2);
 	    
-		template <typename T> 
-		tmat2x3<T> operator- (
-			tmat2x3<T> const & m, 
-			typename tmat2x3<T>::value_type const & s);
-
-		template <typename T> 
-		tmat2x3<T> operator- (
-			tmat2x3<T> const & m1, 
-			tmat2x3<T> const & m2);
-
-		template <typename T> 
-		tmat2x3<T> operator* (
-			tmat2x3<T> const & m, 
-			typename tmat2x3<T>::value_type const & s);
-
-		template <typename T> 
-		tmat2x3<T> operator* (
-			typename tmat2x3<T>::value_type const & s, 
-			tmat2x3<T> const & m);
-
-		template <typename T>
-		typename tmat2x3<T>::col_type operator* (
-			tmat2x3<T> const & m, 
-			typename tmat2x3<T>::row_type const & v);
-
-		template <typename T> 
-		typename tmat2x3<T>::row_type operator* (
-			typename tmat2x3<T>::col_type const & v, 
-			tmat2x3<T> const & m);
-
-		template <typename T>
-		tmat3x3<T> operator* (
-			tmat2x3<T> const & m1, 
-			tmat3x2<T> const & m2);
-
-		template <typename T> 
-		tmat2x3<T> operator/ (
-			tmat2x3<T> const & m, 
-			typename tmat2x3<T>::value_type const & s);
-
-		template <typename T> 
-		tmat2x3<T> operator/ (
-			typename tmat2x3<T>::value_type const & s,
-			tmat2x3<T> const & m);
-
-		// Unary constant operators
-		template <typename T> 
-		tmat2x3<T> const operator-  (
-			tmat2x3<T> const & m);
-
-		template <typename T> 
-		tmat2x3<T> const operator-- (
-			tmat2x3<T> const & m, 
-			int);
-
-		template <typename T> 
-		tmat2x3<T> const operator++ (
-			tmat2x3<T> const & m, 
-			int);
-
-	} //namespace detail
-
-	namespace core{
-	namespace type{
-
-	namespace precision
-	{
-		//! 2 columns of 3 components matrix of low precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		//! \ingroup core_precision
-		typedef detail::tmat2x3<lowp_float>		lowp_mat2x3;
-		//! 2 columns of 3 components matrix of medium precision floating-point numbers. 
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		//! \ingroup core_precision
-		typedef detail::tmat2x3<mediump_float>	mediump_mat2x3;
-		//! 2 columns of 3 components matrix of high precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		//! \ingroup core_precision
-		typedef detail::tmat2x3<highp_float>	highp_mat2x3;
-	}
-	//namespace precision
-
-	}//namespace type
-	}//namespace core
-} //namespace glm
+	template <typename T> 
+	tmat2x3<T> operator- (
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::value_type const & s);
+
+	template <typename T> 
+	tmat2x3<T> operator- (
+		tmat2x3<T> const & m1, 
+		tmat2x3<T> const & m2);
+
+	template <typename T> 
+	tmat2x3<T> operator* (
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::value_type const & s);
+
+	template <typename T> 
+	tmat2x3<T> operator* (
+		typename tmat2x3<T>::value_type const & s, 
+		tmat2x3<T> const & m);
+
+	template <typename T>
+	typename tmat2x3<T>::col_type operator* (
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::row_type const & v);
+
+	template <typename T> 
+	typename tmat2x3<T>::row_type operator* (
+		typename tmat2x3<T>::col_type const & v, 
+		tmat2x3<T> const & m);
+
+	template <typename T>
+	tmat3x3<T> operator* (
+		tmat2x3<T> const & m1, 
+		tmat3x2<T> const & m2);
+
+	template <typename T> 
+	tmat2x3<T> operator/ (
+		tmat2x3<T> const & m, 
+		typename tmat2x3<T>::value_type const & s);
+
+	template <typename T> 
+	tmat2x3<T> operator/ (
+		typename tmat2x3<T>::value_type const & s,
+		tmat2x3<T> const & m);
+
+	// Unary constant operators
+	template <typename T> 
+	tmat2x3<T> const operator-  (
+		tmat2x3<T> const & m);
+
+	template <typename T> 
+	tmat2x3<T> const operator-- (
+		tmat2x3<T> const & m, 
+		int);
+
+	template <typename T> 
+	tmat2x3<T> const operator++ (
+		tmat2x3<T> const & m, 
+		int);
+
+} //namespace detail
+
+namespace core{
+namespace type{
+namespace precision
+{
+	//! 2 columns of 3 components matrix of low precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	//! \ingroup core_precision
+	typedef detail::tmat2x3<lowp_float>		lowp_mat2x3;
+	//! 2 columns of 3 components matrix of medium precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	//! \ingroup core_precision
+	typedef detail::tmat2x3<mediump_float>	mediump_mat2x3;
+	//! 2 columns of 3 components matrix of high precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	//! \ingroup core_precision
+	typedef detail::tmat2x3<highp_float>	highp_mat2x3;
+}//namespace precision
+}//namespace type
+}//namespace core
+}//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat2x3.inl"

glm/core/type_mat2x4.hpp

@@ -12,220 +12,211 @@
 
 #include "type_mat.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
+	template <typename T> struct tvec1;
+	template <typename T> struct tvec2;
+	template <typename T> struct tvec3;
+	template <typename T> struct tvec4;
+	template <typename T> struct tmat2x2;
+	template <typename T> struct tmat2x3;
+	template <typename T> struct tmat2x4;
+	template <typename T> struct tmat3x2;
+	template <typename T> struct tmat3x3;
+	template <typename T> struct tmat3x4;
+	template <typename T> struct tmat4x2;
+	template <typename T> struct tmat4x3;
+	template <typename T> struct tmat4x4;
+
+	//! Template for 2 columns and 4 rows matrix of floating-point numbers.
+	//! \ingroup core_template
+	template <typename T> 
+	struct tmat2x4
 	{
-		void main_mat2x4();
-	}//namespace test
-
-	namespace detail
-	{
-		template <typename T> struct tvec1;
-		template <typename T> struct tvec2;
-		template <typename T> struct tvec3;
-		template <typename T> struct tvec4;
-		template <typename T> struct tmat2x2;
-		template <typename T> struct tmat2x3;
-		template <typename T> struct tmat2x4;
-		template <typename T> struct tmat3x2;
-		template <typename T> struct tmat3x3;
-		template <typename T> struct tmat3x4;
-		template <typename T> struct tmat4x2;
-		template <typename T> struct tmat4x3;
-		template <typename T> struct tmat4x4;
-
-		//! Template for 2 columns and 4 rows matrix of floating-point numbers.
-		//! \ingroup core_template
-		template <typename T> 
-		struct tmat2x4
-		{
-			enum ctor{null};
-			typedef T value_type;
-			typedef std::size_t size_type;
-			typedef tvec4<T> col_type;
-			typedef tvec2<T> row_type;
-			static GLM_FUNC_DECL size_type col_size();
-			static GLM_FUNC_DECL size_type row_size();
-
-			typedef tmat2x4<T> type;
-			typedef tmat4x2<T> transpose_type;
-
-		private:
-			// Data 
-			col_type value[2];
-
-		public:
-			// Constructors
-			GLM_FUNC_DECL tmat2x4();
-			GLM_FUNC_DECL tmat2x4(tmat2x4 const & m);
-
-			GLM_FUNC_DECL explicit tmat2x4(
-				ctor);
-			GLM_FUNC_DECL explicit tmat2x4(
-				value_type const & s);
-			GLM_FUNC_DECL explicit tmat2x4(
-				value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-				value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1);
-			GLM_FUNC_DECL explicit tmat2x4(
-				col_type const & v0, 
-				col_type const & v1);
+		enum ctor{null};
+		typedef T value_type;
+		typedef std::size_t size_type;
+		typedef tvec4<T> col_type;
+		typedef tvec2<T> row_type;
+		static GLM_FUNC_DECL size_type col_size();
+		static GLM_FUNC_DECL size_type row_size();
+
+		typedef tmat2x4<T> type;
+		typedef tmat4x2<T> transpose_type;
+
+	private:
+		// Data 
+		col_type value[2];
+
+	public:
+		// Constructors
+		GLM_FUNC_DECL tmat2x4();
+		GLM_FUNC_DECL tmat2x4(tmat2x4 const & m);
+
+		GLM_FUNC_DECL explicit tmat2x4(
+			ctor);
+		GLM_FUNC_DECL explicit tmat2x4(
+			value_type const & s);
+		GLM_FUNC_DECL explicit tmat2x4(
+			value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+			value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1);
+		GLM_FUNC_DECL explicit tmat2x4(
+			col_type const & v0, 
+			col_type const & v1);
             
-			//////////////////////////////////////
-			// Conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat2x4(
-                U const & x);
+		//////////////////////////////////////
+		// Conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat2x4(
+            U const & x);
 			
-			template <
-                typename X1, typename Y1, typename Z1, typename W1, 
-                typename X2, typename Y2, typename Z2, typename W2> 
-			GLM_FUNC_DECL explicit tmat2x4(
-                X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-                X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2);
+		template <
+            typename X1, typename Y1, typename Z1, typename W1, 
+            typename X2, typename Y2, typename Z2, typename W2> 
+		GLM_FUNC_DECL explicit tmat2x4(
+            X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
+            X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2);
 			
-			template <typename U, typename V> 
-			GLM_FUNC_DECL explicit tmat2x4(
-                tvec4<U> const & v1, 
-                tvec4<V> const & v2);
+		template <typename U, typename V> 
+		GLM_FUNC_DECL explicit tmat2x4(
+            tvec4<U> const & v1, 
+            tvec4<V> const & v2);
             
-            //////////////////////////////////////
-			// Matrix conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U> const & m);
-
-			GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x4(tmat4x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x4(tmat2x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x4(tmat3x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x4(tmat3x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x4(tmat4x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat2x4(tmat4x3<T> const & x);
-
-			// Accesses
-			GLM_FUNC_DECL col_type & operator[](size_type i);
-			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-			// Unary updatable operators
-			GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<T> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x4<T>& operator+= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x4<T>& operator+= (tmat2x4<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x4<T>& operator-= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x4<T>& operator-= (tmat2x4<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x4<T>& operator*= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x4<T>& operator*= (tmat2x4<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat2x4<T>& operator/= (U const & s);
-
-			GLM_FUNC_DECL tmat2x4<T>& operator++ ();
-			GLM_FUNC_DECL tmat2x4<T>& operator-- ();
-		};
-
-		// Binary operators
-		template <typename T> 
-		tmat2x4<T> operator+ (
-			tmat2x4<T> const & m, 
-			typename tmat2x4<T>::value_type const & s);
+        //////////////////////////////////////
+		// Matrix conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U> const & m);
+
+		GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x4(tmat4x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x4(tmat2x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x4(tmat3x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x4(tmat3x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x4(tmat4x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat2x4(tmat4x3<T> const & x);
+
+		// Accesses
+		GLM_FUNC_DECL col_type & operator[](size_type i);
+		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+
+		// Unary updatable operators
+		GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<T> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x4<T>& operator=  (tmat2x4<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x4<T>& operator+= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x4<T>& operator+= (tmat2x4<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x4<T>& operator-= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x4<T>& operator-= (tmat2x4<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x4<T>& operator*= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x4<T>& operator*= (tmat2x4<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat2x4<T>& operator/= (U const & s);
+
+		GLM_FUNC_DECL tmat2x4<T>& operator++ ();
+		GLM_FUNC_DECL tmat2x4<T>& operator-- ();
+	};
+
+	// Binary operators
+	template <typename T> 
+	tmat2x4<T> operator+ (
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::value_type const & s);
 	    
-		template <typename T> 
-		tmat2x4<T> operator+ (
-			tmat2x4<T> const & m1, 
-			tmat2x4<T> const & m2);
+	template <typename T> 
+	tmat2x4<T> operator+ (
+		tmat2x4<T> const & m1, 
+		tmat2x4<T> const & m2);
 	    
-		template <typename T> 
-		tmat2x4<T> operator- (
-			tmat2x4<T> const & m, 
-			typename tmat2x4<T>::value_type const & s);
-
-		template <typename T> 
-		tmat2x4<T> operator- (
-			tmat2x4<T> const & m1, 
-			tmat2x4<T> const & m2);
-
-		template <typename T> 
-		tmat2x4<T> operator* (
-			tmat2x4<T> const & m, 
-			typename tmat2x4<T>::value_type const & s);
-
-		template <typename T> 
-		tmat2x4<T> operator* (
-			typename tmat2x4<T>::value_type const & s, 
-			tmat2x4<T> const & m);
-
-		template <typename T>
-		typename tmat2x4<T>::col_type operator* (
-			tmat2x4<T> const & m, 
-			typename tmat2x4<T>::row_type const & v);
-
-		template <typename T> 
-		typename tmat2x4<T>::row_type operator* (
-			typename tmat2x4<T>::col_type const & v, 
-			tmat2x4<T> const & m);
-
-		template <typename T>
-		tmat2x4<T> operator* (
-			tmat2x4<T> const & m1, 
-			tmat2x4<T> const & m2);
-
-		template <typename T> 
-		tmat2x4<T> operator/ (
-			tmat2x4<T> const & m, 
-			typename tmat2x4<T>::value_type const & s);
-
-		template <typename T> 
-		tmat2x4<T> operator/ (
-			typename tmat2x4<T>::value_type const & s, 
-			tmat2x4<T> const & m);
-
-		// Unary constant operators
-		template <typename T> 
-		tmat2x4<T> const operator-  (
-			tmat2x4<T> const & m);
-
-		template <typename T> 
-		tmat2x4<T> const operator-- (
-			tmat2x4<T> const & m, 
-			int);
-
-		template <typename T> 
-		tmat2x4<T> const operator++ (
-			tmat2x4<T> const & m, 
-			int);
-
-	} //namespace detail
-
-	namespace core{
-	namespace type{
-
-	namespace precision
-	{
-		//! 2 columns of 4 components matrix of low precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		typedef detail::tmat2x4<lowp_float>		lowp_mat2x4;
-		//! 2 columns of 4 components matrix of medium precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		typedef detail::tmat2x4<mediump_float>	mediump_mat2x4;
-		//! 2 columns of 4 components matrix of high precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		typedef detail::tmat2x4<highp_float>	highp_mat2x4;
-	}
-	//namespace precision
-
-	}//namespace type
-	}//namespace core
-} //namespace glm
+	template <typename T> 
+	tmat2x4<T> operator- (
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::value_type const & s);
+
+	template <typename T> 
+	tmat2x4<T> operator- (
+		tmat2x4<T> const & m1, 
+		tmat2x4<T> const & m2);
+
+	template <typename T> 
+	tmat2x4<T> operator* (
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::value_type const & s);
+
+	template <typename T> 
+	tmat2x4<T> operator* (
+		typename tmat2x4<T>::value_type const & s, 
+		tmat2x4<T> const & m);
+
+	template <typename T>
+	typename tmat2x4<T>::col_type operator* (
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::row_type const & v);
+
+	template <typename T> 
+	typename tmat2x4<T>::row_type operator* (
+		typename tmat2x4<T>::col_type const & v, 
+		tmat2x4<T> const & m);
+
+	template <typename T>
+	tmat2x4<T> operator* (
+		tmat2x4<T> const & m1, 
+		tmat2x4<T> const & m2);
+
+	template <typename T> 
+	tmat2x4<T> operator/ (
+		tmat2x4<T> const & m, 
+		typename tmat2x4<T>::value_type const & s);
+
+	template <typename T> 
+	tmat2x4<T> operator/ (
+		typename tmat2x4<T>::value_type const & s, 
+		tmat2x4<T> const & m);
+
+	// Unary constant operators
+	template <typename T> 
+	tmat2x4<T> const operator-  (
+		tmat2x4<T> const & m);
+
+	template <typename T> 
+	tmat2x4<T> const operator-- (
+		tmat2x4<T> const & m, 
+		int);
+
+	template <typename T> 
+	tmat2x4<T> const operator++ (
+		tmat2x4<T> const & m, 
+		int);
+
+} //namespace detail
+
+namespace core{
+namespace type{
+namespace precision
+{
+	//! 2 columns of 4 components matrix of low precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	typedef detail::tmat2x4<lowp_float>		lowp_mat2x4;
+	//! 2 columns of 4 components matrix of medium precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	typedef detail::tmat2x4<mediump_float>	mediump_mat2x4;
+	//! 2 columns of 4 components matrix of high precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	typedef detail::tmat2x4<highp_float>	highp_mat2x4;
+}//namespace precision
+}//namespace type
+}//namespace core
+}//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat2x4.inl"

glm/core/type_mat3x2.hpp

@@ -12,226 +12,217 @@
 
 #include "type_mat.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
+	template <typename T> struct tvec1;
+	template <typename T> struct tvec2;
+	template <typename T> struct tvec3;
+	template <typename T> struct tvec4;
+	template <typename T> struct tmat2x2;
+	template <typename T> struct tmat2x3;
+	template <typename T> struct tmat2x4;
+	template <typename T> struct tmat3x2;
+	template <typename T> struct tmat3x3;
+	template <typename T> struct tmat3x4;
+	template <typename T> struct tmat4x2;
+	template <typename T> struct tmat4x3;
+	template <typename T> struct tmat4x4;
+
+	//! \brief Template for 3 columns and 2 rows matrix of floating-point numbers.
+	//! \ingroup core_template
+	template <typename T> 
+	struct tmat3x2
 	{
-		void main_mat3x2();
-	}//namespace test
-
-	namespace detail
-	{
-		template <typename T> struct tvec1;
-		template <typename T> struct tvec2;
-		template <typename T> struct tvec3;
-		template <typename T> struct tvec4;
-		template <typename T> struct tmat2x2;
-		template <typename T> struct tmat2x3;
-		template <typename T> struct tmat2x4;
-		template <typename T> struct tmat3x2;
-		template <typename T> struct tmat3x3;
-		template <typename T> struct tmat3x4;
-		template <typename T> struct tmat4x2;
-		template <typename T> struct tmat4x3;
-		template <typename T> struct tmat4x4;
-
-		//! \brief Template for 3 columns and 2 rows matrix of floating-point numbers.
-		//! \ingroup core_template
-		template <typename T> 
-		struct tmat3x2
-		{
-			enum ctor{null};
-			typedef T value_type;
-			typedef std::size_t size_type;
-			typedef tvec2<T> col_type;
-			typedef tvec3<T> row_type;
-			static GLM_FUNC_DECL size_type col_size();
-			static GLM_FUNC_DECL size_type row_size();
-
-			typedef tmat3x2<T> type;
-			typedef tmat2x3<T> transpose_type;
-
-		private:
-			// Data
-			col_type value[3];
-
-		public:
-			// Constructors
-			GLM_FUNC_DECL tmat3x2();
-			GLM_FUNC_DECL tmat3x2(tmat3x2 const & m);
-
-			GLM_FUNC_DECL explicit tmat3x2(
-				ctor);
-			GLM_FUNC_DECL explicit tmat3x2(
-				value_type const & s);
-			GLM_FUNC_DECL explicit tmat3x2(
-				value_type const & x0, value_type const & y0,
-				value_type const & x1, value_type const & y1,
-				value_type const & x2, value_type const & y2);
-			GLM_FUNC_DECL explicit tmat3x2(
-				col_type const & v0, 
-				col_type const & v1,
-				col_type const & v2);
-
-			//////////////////////////////////////
-			// Conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat3x2(
-                U const & x);
+		enum ctor{null};
+		typedef T value_type;
+		typedef std::size_t size_type;
+		typedef tvec2<T> col_type;
+		typedef tvec3<T> row_type;
+		static GLM_FUNC_DECL size_type col_size();
+		static GLM_FUNC_DECL size_type row_size();
+
+		typedef tmat3x2<T> type;
+		typedef tmat2x3<T> transpose_type;
+
+	private:
+		// Data
+		col_type value[3];
+
+	public:
+		// Constructors
+		GLM_FUNC_DECL tmat3x2();
+		GLM_FUNC_DECL tmat3x2(tmat3x2 const & m);
+
+		GLM_FUNC_DECL explicit tmat3x2(
+			ctor);
+		GLM_FUNC_DECL explicit tmat3x2(
+			value_type const & s);
+		GLM_FUNC_DECL explicit tmat3x2(
+			value_type const & x0, value_type const & y0,
+			value_type const & x1, value_type const & y1,
+			value_type const & x2, value_type const & y2);
+		GLM_FUNC_DECL explicit tmat3x2(
+			col_type const & v0, 
+			col_type const & v1,
+			col_type const & v2);
+
+		//////////////////////////////////////
+		// Conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat3x2(
+            U const & x);
 			
-			template 
-            <
-                typename X1, typename Y1, 
-                typename X2, typename Y2, 
-                typename X3, typename Y3
-            > 
-			GLM_FUNC_DECL explicit tmat3x2(
-                X1 const & x1, Y1 const & y1, 
-                X2 const & x2, Y2 const & y2,
-                X3 const & x3, Y3 const & y3);
+		template 
+        <
+            typename X1, typename Y1, 
+            typename X2, typename Y2, 
+            typename X3, typename Y3
+        > 
+		GLM_FUNC_DECL explicit tmat3x2(
+            X1 const & x1, Y1 const & y1, 
+            X2 const & x2, Y2 const & y2,
+            X3 const & x3, Y3 const & y3);
 			
-			template <typename V1, typename V2, typename V3> 
-			GLM_FUNC_DECL explicit tmat3x2(
-                tvec2<V1> const & v1, 
-                tvec2<V2> const & v2,
-                tvec2<V3> const & v3);
+		template <typename V1, typename V2, typename V3> 
+		GLM_FUNC_DECL explicit tmat3x2(
+            tvec2<V1> const & v1, 
+            tvec2<V2> const & v2,
+            tvec2<V3> const & v3);
             
-			// Matrix conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U> const & m);
-
-			GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x2(tmat4x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x2(tmat2x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x2(tmat2x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x2(tmat3x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x2(tmat4x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x2(tmat4x3<T> const & x);
-
-			// Accesses
-			GLM_FUNC_DECL col_type & operator[](size_type i);
-			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-			// Unary updatable operators
-			GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<T> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x2<T> & operator+= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x2<T> & operator+= (tmat3x2<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x2<T> & operator-= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x2<T> & operator-= (tmat3x2<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x2<T> & operator*= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x2<T> & operator*= (tmat3x2<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x2<T> & operator/= (U const & s);
-
-			GLM_FUNC_DECL tmat3x2<T> & operator++ ();
-			GLM_FUNC_DECL tmat3x2<T> & operator-- ();
-		};
-
-		// Binary operators
-		template <typename T> 
-		tmat3x2<T> operator+ (
-			tmat3x2<T> const & m, 
-			typename tmat3x2<T>::value_type const & s);
+		// Matrix conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U> const & m);
+
+		GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x2(tmat4x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x2(tmat2x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x2(tmat2x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x2(tmat3x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x2(tmat4x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x2(tmat4x3<T> const & x);
+
+		// Accesses
+		GLM_FUNC_DECL col_type & operator[](size_type i);
+		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+
+		// Unary updatable operators
+		GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<T> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x2<T> & operator=  (tmat3x2<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x2<T> & operator+= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x2<T> & operator+= (tmat3x2<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x2<T> & operator-= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x2<T> & operator-= (tmat3x2<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x2<T> & operator*= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x2<T> & operator*= (tmat3x2<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x2<T> & operator/= (U const & s);
+
+		GLM_FUNC_DECL tmat3x2<T> & operator++ ();
+		GLM_FUNC_DECL tmat3x2<T> & operator-- ();
+	};
+
+	// Binary operators
+	template <typename T> 
+	tmat3x2<T> operator+ (
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::value_type const & s);
 	    
-		template <typename T> 
-		tmat3x2<T> operator+ (
-			tmat3x2<T> const & m1, 
-			tmat3x2<T> const & m2);
+	template <typename T> 
+	tmat3x2<T> operator+ (
+		tmat3x2<T> const & m1, 
+		tmat3x2<T> const & m2);
 	    
-		template <typename T> 
-		tmat3x2<T> operator- (
-			tmat3x2<T> const & m, 
-			typename tmat3x2<T>::value_type const & s);
-
-		template <typename T> 
-		tmat3x2<T> operator- (
-			tmat3x2<T> const & m1, 
-			tmat3x2<T> const & m2);
-
-		template <typename T> 
-		tmat3x2<T> operator* (
-			tmat3x2<T> const & m, 
-			typename tmat3x2<T>::value_type const & s);
-
-		template <typename T> 
-		tmat3x2<T> operator* (
-			typename tmat3x2<T>::value_type const & s, 
-			tmat3x2<T> const & m);
-
-		template <typename T>
-		typename tmat3x2<T>::col_type operator* (
-			tmat3x2<T> const & m, 
-			typename tmat3x2<T>::row_type const & v);
-
-		template <typename T> 
-		typename tmat3x2<T>::row_type operator* (
-			typename tmat3x2<T>::col_type const & v,
-			tmat3x2<T> const & m);
-
-		template <typename T>
-		tmat2x2<T> operator* (
-			tmat3x2<T> const & m1, 
-			tmat2x3<T> const & m2);
-
-		template <typename T> 
-		tmat3x2<T> operator/ (
-			tmat3x2<T> const & m, 
-			typename tmat3x2<T>::value_type const & s);
-
-		template <typename T> 
-		tmat3x2<T> operator/ (
-			typename tmat3x2<T>::value_type const & s, 
-			tmat3x2<T> const & m);
-
-		// Unary constant operators
-		template <typename T> 
-		tmat3x2<T> const operator-  (
-			tmat3x2<T> const & m);
-
-		template <typename T> 
-		tmat3x2<T> const operator-- (
-			tmat3x2<T> const & m, 
-			int);
-
-		template <typename T> 
-		tmat3x2<T> const operator++ (
-			tmat3x2<T> const & m, 
-			int);
-
-	} //namespace detail
-
-	namespace core{
-	namespace type{
-
-	namespace precision
-	{
-		//! 3 columns of 2 components matrix of low precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		typedef detail::tmat3x2<lowp_float>		lowp_mat3x2;
-		//! 3 columns of 2 components matrix of medium precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		typedef detail::tmat3x2<mediump_float>	mediump_mat3x2;
-		//! 3 columns of 2 components matrix of high precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		typedef detail::tmat3x2<highp_float>	highp_mat3x2;
-	}
-	//namespace precision
-
-	}//namespace type
-	}//namespace core
-} //namespace glm
+	template <typename T> 
+	tmat3x2<T> operator- (
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::value_type const & s);
+
+	template <typename T> 
+	tmat3x2<T> operator- (
+		tmat3x2<T> const & m1, 
+		tmat3x2<T> const & m2);
+
+	template <typename T> 
+	tmat3x2<T> operator* (
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::value_type const & s);
+
+	template <typename T> 
+	tmat3x2<T> operator* (
+		typename tmat3x2<T>::value_type const & s, 
+		tmat3x2<T> const & m);
+
+	template <typename T>
+	typename tmat3x2<T>::col_type operator* (
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::row_type const & v);
+
+	template <typename T> 
+	typename tmat3x2<T>::row_type operator* (
+		typename tmat3x2<T>::col_type const & v,
+		tmat3x2<T> const & m);
+
+	template <typename T>
+	tmat2x2<T> operator* (
+		tmat3x2<T> const & m1, 
+		tmat2x3<T> const & m2);
+
+	template <typename T> 
+	tmat3x2<T> operator/ (
+		tmat3x2<T> const & m, 
+		typename tmat3x2<T>::value_type const & s);
+
+	template <typename T> 
+	tmat3x2<T> operator/ (
+		typename tmat3x2<T>::value_type const & s, 
+		tmat3x2<T> const & m);
+
+	// Unary constant operators
+	template <typename T> 
+	tmat3x2<T> const operator-  (
+		tmat3x2<T> const & m);
+
+	template <typename T> 
+	tmat3x2<T> const operator-- (
+		tmat3x2<T> const & m, 
+		int);
+
+	template <typename T> 
+	tmat3x2<T> const operator++ (
+		tmat3x2<T> const & m, 
+		int);
+
+} //namespace detail
+
+namespace core{
+namespace type{
+namespace precision
+{
+	//! 3 columns of 2 components matrix of low precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	typedef detail::tmat3x2<lowp_float>		lowp_mat3x2;
+	//! 3 columns of 2 components matrix of medium precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	typedef detail::tmat3x2<mediump_float>	mediump_mat3x2;
+	//! 3 columns of 2 components matrix of high precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	typedef detail::tmat3x2<highp_float>	highp_mat3x2;
+}//namespace precision
+}//namespace type
+}//namespace core
+}//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat3x2.inl"

glm/core/type_mat3x3.hpp

@@ -12,277 +12,269 @@
 
 #include "type_mat.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
+	template <typename T> struct tvec1;
+	template <typename T> struct tvec2;
+	template <typename T> struct tvec3;
+	template <typename T> struct tvec4;
+	template <typename T> struct tmat2x2;
+	template <typename T> struct tmat2x3;
+	template <typename T> struct tmat2x4;
+	template <typename T> struct tmat3x2;
+	template <typename T> struct tmat3x3;
+	template <typename T> struct tmat3x4;
+	template <typename T> struct tmat4x2;
+	template <typename T> struct tmat4x3;
+	template <typename T> struct tmat4x4;
+
+	//! \brief Template for 3 * 3 matrix of floating-point numbers.
+	//! \ingroup core_template
+	template <typename T> 
+	struct tmat3x3
 	{
-		void main_mat3x3();
-	}//namespace test
-
-	namespace detail
-	{
-		template <typename T> struct tvec1;
-		template <typename T> struct tvec2;
-		template <typename T> struct tvec3;
-		template <typename T> struct tvec4;
-		template <typename T> struct tmat2x2;
-		template <typename T> struct tmat2x3;
-		template <typename T> struct tmat2x4;
-		template <typename T> struct tmat3x2;
-		template <typename T> struct tmat3x3;
-		template <typename T> struct tmat3x4;
-		template <typename T> struct tmat4x2;
-		template <typename T> struct tmat4x3;
-		template <typename T> struct tmat4x4;
-
-		//! \brief Template for 3 * 3 matrix of floating-point numbers.
-		//! \ingroup core_template
-		template <typename T> 
-		struct tmat3x3
-		{
-			enum ctor{null};
-			typedef T value_type;
-			typedef std::size_t size_type;
-			typedef tvec3<T> col_type;
-			typedef tvec3<T> row_type;
-			static GLM_FUNC_DECL size_type col_size();
-			static GLM_FUNC_DECL size_type row_size();
-
-			typedef tmat3x3<T> type;
-			typedef tmat3x3<T> transpose_type;
-
-		public:
-			// Implementation detail
-			GLM_FUNC_DECL tmat3x3<T> _inverse() const;
-
-		private:
-			// Data
-			col_type value[3];
-
-		public:
-			// Constructors
-			GLM_FUNC_DECL tmat3x3();
-			GLM_FUNC_DECL tmat3x3(tmat3x3 const & m);
-
-			GLM_FUNC_DECL explicit tmat3x3(
-				ctor Null);
-			GLM_FUNC_DECL explicit tmat3x3(
-				value_type const & s);
-			GLM_FUNC_DECL explicit tmat3x3(
-				value_type const & x0, value_type const & y0, value_type const & z0,
-				value_type const & x1, value_type const & y1, value_type const & z1,
-				value_type const & x2, value_type const & y2, value_type const & z2);
-			GLM_FUNC_DECL explicit tmat3x3(
-				col_type const & v0, 
-				col_type const & v1,
-				col_type const & v2);
-
-			//////////////////////////////////////
-			// Conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat3x3(
-                U const & x);
+		enum ctor{null};
+		typedef T value_type;
+		typedef std::size_t size_type;
+		typedef tvec3<T> col_type;
+		typedef tvec3<T> row_type;
+		static GLM_FUNC_DECL size_type col_size();
+		static GLM_FUNC_DECL size_type row_size();
+
+		typedef tmat3x3<T> type;
+		typedef tmat3x3<T> transpose_type;
+
+	public:
+		// Implementation detail
+		GLM_FUNC_DECL tmat3x3<T> _inverse() const;
+
+	private:
+		// Data
+		col_type value[3];
+
+	public:
+		// Constructors
+		GLM_FUNC_DECL tmat3x3();
+		GLM_FUNC_DECL tmat3x3(tmat3x3 const & m);
+
+		GLM_FUNC_DECL explicit tmat3x3(
+			ctor Null);
+		GLM_FUNC_DECL explicit tmat3x3(
+			value_type const & s);
+		GLM_FUNC_DECL explicit tmat3x3(
+			value_type const & x0, value_type const & y0, value_type const & z0,
+			value_type const & x1, value_type const & y1, value_type const & z1,
+			value_type const & x2, value_type const & y2, value_type const & z2);
+		GLM_FUNC_DECL explicit tmat3x3(
+			col_type const & v0, 
+			col_type const & v1,
+			col_type const & v2);
+
+		//////////////////////////////////////
+		// Conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat3x3(
+            U const & x);
 			
-			template 
-            <
-                typename X1, typename Y1, typename Z1, 
-                typename X2, typename Y2, typename Z2, 
-                typename X3, typename Y3, typename Z3
-            > 
-			GLM_FUNC_DECL explicit tmat3x3(
-                X1 const & x1, Y1 const & y1, Z1 const & z1, 
-                X2 const & x2, Y2 const & y2, Z2 const & z2, 
-                X3 const & x3, Y3 const & y3, Z3 const & z3);
+		template 
+        <
+            typename X1, typename Y1, typename Z1, 
+            typename X2, typename Y2, typename Z2, 
+            typename X3, typename Y3, typename Z3
+        > 
+		GLM_FUNC_DECL explicit tmat3x3(
+            X1 const & x1, Y1 const & y1, Z1 const & z1, 
+            X2 const & x2, Y2 const & y2, Z2 const & z2, 
+            X3 const & x3, Y3 const & y3, Z3 const & z3);
 			
-			template <typename V1, typename V2, typename V3> 
-			GLM_FUNC_DECL explicit tmat3x3(
-                tvec3<V1> const & v1, 
-                tvec3<V2> const & v2,
-                tvec3<V3> const & v3);
+		template <typename V1, typename V2, typename V3> 
+		GLM_FUNC_DECL explicit tmat3x3(
+            tvec3<V1> const & v1, 
+            tvec3<V2> const & v2,
+            tvec3<V3> const & v3);
             
-			// Matrix conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U> const & m);
-
-			GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x3(tmat2x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x3(tmat3x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x3(tmat2x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x3(tmat4x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x3(tmat3x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x3(tmat4x3<T> const & x);
-
-			// Accesses
-			GLM_FUNC_DECL col_type & operator[](size_type i);
-			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-			// Unary updatable operators
-			GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<T> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x3<T>& operator+= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x3<T>& operator+= (tmat3x3<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x3<T>& operator-= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x3<T>& operator-= (tmat3x3<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x3<T>& operator*= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x3<T>& operator*= (tmat3x3<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x3<T>& operator/= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x3<T>& operator/= (tmat3x3<U> const & m);
-			GLM_FUNC_DECL tmat3x3<T>& operator++ ();
-			GLM_FUNC_DECL tmat3x3<T>& operator-- ();
-		};
-
-		// Binary operators
-		template <typename T> 
-		tmat3x3<T> operator+ (
-			tmat3x3<T> const & m, 
-			typename tmat3x3<T>::value_type const & s);
-
-		template <typename T> 
-		tmat3x3<T> operator+ (
-			typename tmat3x3<T>::value_type const & s, 
-			tmat3x3<T> const & m);
-
-		template <typename T> 
-		tmat3x3<T> operator+ (
-			tmat3x3<T> const & m1, 
-			tmat3x3<T> const & m2);
+		// Matrix conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U> const & m);
+
+		GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x3(tmat2x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x3(tmat3x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x3(tmat2x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x3(tmat4x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x3(tmat3x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x3(tmat4x3<T> const & x);
+
+		// Accesses
+		GLM_FUNC_DECL col_type & operator[](size_type i);
+		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+
+		// Unary updatable operators
+		GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<T> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x3<T>& operator=  (tmat3x3<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x3<T>& operator+= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x3<T>& operator+= (tmat3x3<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x3<T>& operator-= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x3<T>& operator-= (tmat3x3<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x3<T>& operator*= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x3<T>& operator*= (tmat3x3<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x3<T>& operator/= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x3<T>& operator/= (tmat3x3<U> const & m);
+		GLM_FUNC_DECL tmat3x3<T>& operator++ ();
+		GLM_FUNC_DECL tmat3x3<T>& operator-- ();
+	};
+
+	// Binary operators
+	template <typename T> 
+	tmat3x3<T> operator+ (
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::value_type const & s);
+
+	template <typename T> 
+	tmat3x3<T> operator+ (
+		typename tmat3x3<T>::value_type const & s, 
+		tmat3x3<T> const & m);
+
+	template <typename T> 
+	tmat3x3<T> operator+ (
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2);
 	    
-		template <typename T> 
-		tmat3x3<T> operator- (
-			tmat3x3<T> const & m, 
-			typename tmat3x3<T>::value_type const & s);
-
-		template <typename T> 
-		tmat3x3<T> operator- (
-			typename tmat3x3<T>::value_type const & s, 
-			tmat3x3<T> const & m);
-
-		template <typename T> 
-		tmat3x3<T> operator- (
-			tmat3x3<T> const & m1, 
-			tmat3x3<T> const & m2);
-
-		template <typename T> 
-		tmat3x3<T> operator* (
-			tmat3x3<T> const & m, 
-			typename tmat3x3<T>::value_type const & s);
-
-		template <typename T> 
-		tmat3x3<T> operator* (
-			typename tmat3x3<T>::value_type const & s, 
-			tmat3x3<T> const & m);
-
-		template <typename T> 
-		typename tmat3x3<T>::col_type operator* (
-			tmat3x3<T> const & m, 
-			typename tmat3x3<T>::row_type const & v);
-
-		template <typename T> 
-		typename tmat3x3<T>::row_type operator* (
-			typename tmat3x3<T>::col_type const & v, 
-			tmat3x3<T> const & m);
-
-		template <typename T> 
-		tmat3x3<T> operator* (
-			tmat3x3<T> const & m1, 
-			tmat3x3<T> const & m2);
-
-		template <typename T> 
-		tmat3x3<T> operator/ (
-			tmat3x3<T> const & m, 
-			typename tmat3x3<T>::value_type const & s);
-
-		template <typename T> 
-		tmat3x3<T> operator/ (
-			typename tmat3x3<T>::value_type const & s, 
-			tmat3x3<T> const & m);
-
-		template <typename T> 
-		typename tmat3x3<T>::col_type operator/ (
-			tmat3x3<T> const & m, 
-			typename tmat3x3<T>::row_type const & v);
-
-		template <typename T> 
-		typename tmat3x3<T>::row_type operator/ (
-			typename tmat3x3<T>::col_type const & v, 
-			tmat3x3<T> const & m);
-
-		template <typename T> 
-		tmat3x3<T> operator/ (
-			tmat3x3<T> const & m1, 
-			tmat3x3<T> const & m2);
-
-		// Unary constant operators
-		template <typename T> 
-		tmat3x3<T> const operator-  (
-			tmat3x3<T> const & m);
-
-		template <typename T> 
-		tmat3x3<T> const operator-- (
-			tmat3x3<T> const & m, 
-			int);
-
-		template <typename T> 
-		tmat3x3<T> const operator++ (
-			tmat3x3<T> const & m, 
-			int);
-
-	} //namespace detail
-
-	namespace core{
-	namespace type{
-
-	namespace precision
-	{
-		//! 3 columns of 3 components matrix of low precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat3x3<lowp_float>		lowp_mat3;
-		//! 3 columns of 3 components matrix of medium precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat3x3<mediump_float>	mediump_mat3;
-		//! 3 columns of 3 components matrix of high precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat3x3<highp_float>	highp_mat3;
-
-		//! 3 columns of 3 components matrix of low precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat3x3<lowp_float>		lowp_mat3x3;
-
-		//! 3 columns of 3 components matrix of medium precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat3x3<mediump_float>	mediump_mat3x3;
-
-		//! 3 columns of 3 components matrix of high precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat3x3<highp_float>	highp_mat3x3;
-	}
-	//namespace precision
-
-	}//namespace type
-	}//namespace core
-} //namespace glm
+	template <typename T> 
+	tmat3x3<T> operator- (
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::value_type const & s);
+
+	template <typename T> 
+	tmat3x3<T> operator- (
+		typename tmat3x3<T>::value_type const & s, 
+		tmat3x3<T> const & m);
+
+	template <typename T> 
+	tmat3x3<T> operator- (
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2);
+
+	template <typename T> 
+	tmat3x3<T> operator* (
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::value_type const & s);
+
+	template <typename T> 
+	tmat3x3<T> operator* (
+		typename tmat3x3<T>::value_type const & s, 
+		tmat3x3<T> const & m);
+
+	template <typename T> 
+	typename tmat3x3<T>::col_type operator* (
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::row_type const & v);
+
+	template <typename T> 
+	typename tmat3x3<T>::row_type operator* (
+		typename tmat3x3<T>::col_type const & v, 
+		tmat3x3<T> const & m);
+
+	template <typename T> 
+	tmat3x3<T> operator* (
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2);
+
+	template <typename T> 
+	tmat3x3<T> operator/ (
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::value_type const & s);
+
+	template <typename T> 
+	tmat3x3<T> operator/ (
+		typename tmat3x3<T>::value_type const & s, 
+		tmat3x3<T> const & m);
+
+	template <typename T> 
+	typename tmat3x3<T>::col_type operator/ (
+		tmat3x3<T> const & m, 
+		typename tmat3x3<T>::row_type const & v);
+
+	template <typename T> 
+	typename tmat3x3<T>::row_type operator/ (
+		typename tmat3x3<T>::col_type const & v, 
+		tmat3x3<T> const & m);
+
+	template <typename T> 
+	tmat3x3<T> operator/ (
+		tmat3x3<T> const & m1, 
+		tmat3x3<T> const & m2);
+
+	// Unary constant operators
+	template <typename T> 
+	tmat3x3<T> const operator-  (
+		tmat3x3<T> const & m);
+
+	template <typename T> 
+	tmat3x3<T> const operator-- (
+		tmat3x3<T> const & m, 
+		int);
+
+	template <typename T> 
+	tmat3x3<T> const operator++ (
+		tmat3x3<T> const & m, 
+		int);
+
+} //namespace detail
+
+namespace core{
+namespace type{
+namespace precision
+{
+	//! 3 columns of 3 components matrix of low precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat3x3<lowp_float>		lowp_mat3;
+	//! 3 columns of 3 components matrix of medium precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat3x3<mediump_float>	mediump_mat3;
+	//! 3 columns of 3 components matrix of high precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat3x3<highp_float>	highp_mat3;
+
+	//! 3 columns of 3 components matrix of low precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat3x3<lowp_float>		lowp_mat3x3;
+
+	//! 3 columns of 3 components matrix of medium precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat3x3<mediump_float>	mediump_mat3x3;
+
+	//! 3 columns of 3 components matrix of high precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat3x3<highp_float>	highp_mat3x3;
+
+}//namespace precision
+}//namespace type
+}//namespace core
+}//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat3x3.inl"

glm/core/type_mat3x4.hpp

@@ -12,226 +12,218 @@
 
 #include "type_mat.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
+	template <typename T> struct tvec1;
+	template <typename T> struct tvec2;
+	template <typename T> struct tvec3;
+	template <typename T> struct tvec4;
+	template <typename T> struct tmat2x2;
+	template <typename T> struct tmat2x3;
+	template <typename T> struct tmat2x4;
+	template <typename T> struct tmat3x2;
+	template <typename T> struct tmat3x3;
+	template <typename T> struct tmat3x4;
+	template <typename T> struct tmat4x2;
+	template <typename T> struct tmat4x3;
+	template <typename T> struct tmat4x4;
+
+	//! \brief Template for 3 columns and 4 rows matrix of floating-point numbers.
+	//! \ingroup core_template
+	template <typename T> 
+	struct tmat3x4
 	{
-		void main_mat3x4();
-	}//namespace test
-
-	namespace detail
-	{
-		template <typename T> struct tvec1;
-		template <typename T> struct tvec2;
-		template <typename T> struct tvec3;
-		template <typename T> struct tvec4;
-		template <typename T> struct tmat2x2;
-		template <typename T> struct tmat2x3;
-		template <typename T> struct tmat2x4;
-		template <typename T> struct tmat3x2;
-		template <typename T> struct tmat3x3;
-		template <typename T> struct tmat3x4;
-		template <typename T> struct tmat4x2;
-		template <typename T> struct tmat4x3;
-		template <typename T> struct tmat4x4;
-
-		//! \brief Template for 3 columns and 4 rows matrix of floating-point numbers.
-		//! \ingroup core_template
-		template <typename T> 
-		struct tmat3x4
-		{
-			enum ctor{null};
-			typedef T value_type;
-			typedef std::size_t size_type;
-			typedef tvec4<T> col_type;
-			typedef tvec3<T> row_type;
-			static GLM_FUNC_DECL size_type col_size();
-			static GLM_FUNC_DECL size_type row_size();
-
-			typedef tmat3x4<T> type;
-			typedef tmat4x3<T> transpose_type;
-
-		private:
-			// Data 
-			col_type value[3];
-
-		public:
-			// Constructors
-			GLM_FUNC_DECL tmat3x4();
-			GLM_FUNC_DECL tmat3x4(tmat3x4 const & m);
-
-			GLM_FUNC_DECL explicit tmat3x4(
-				ctor Null);
-			GLM_FUNC_DECL explicit tmat3x4(
-				value_type const & s);
-			GLM_FUNC_DECL explicit tmat3x4(
-				value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-				value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
-				value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2);
-			GLM_FUNC_DECL explicit tmat3x4(
-				col_type const & v0, 
-				col_type const & v1,
-				col_type const & v2);
-
-			//////////////////////////////////////
-			// Conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat3x4(
-                U const & x);
+		enum ctor{null};
+		typedef T value_type;
+		typedef std::size_t size_type;
+		typedef tvec4<T> col_type;
+		typedef tvec3<T> row_type;
+		static GLM_FUNC_DECL size_type col_size();
+		static GLM_FUNC_DECL size_type row_size();
+
+		typedef tmat3x4<T> type;
+		typedef tmat4x3<T> transpose_type;
+
+	private:
+		// Data 
+		col_type value[3];
+
+	public:
+		// Constructors
+		GLM_FUNC_DECL tmat3x4();
+		GLM_FUNC_DECL tmat3x4(tmat3x4 const & m);
+
+		GLM_FUNC_DECL explicit tmat3x4(
+			ctor Null);
+		GLM_FUNC_DECL explicit tmat3x4(
+			value_type const & s);
+		GLM_FUNC_DECL explicit tmat3x4(
+			value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+			value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
+			value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2);
+		GLM_FUNC_DECL explicit tmat3x4(
+			col_type const & v0, 
+			col_type const & v1,
+			col_type const & v2);
+
+		//////////////////////////////////////
+		// Conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat3x4(
+            U const & x);
 			
-			template 
-            <
-                typename X1, typename Y1, typename Z1, typename W1, 
-                typename X2, typename Y2, typename Z2, typename W2, 
-                typename X3, typename Y3, typename Z3, typename W3 
-            > 
-			GLM_FUNC_DECL explicit tmat3x4(
-                X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-                X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, 
-                X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3);
+		template 
+        <
+            typename X1, typename Y1, typename Z1, typename W1, 
+            typename X2, typename Y2, typename Z2, typename W2, 
+            typename X3, typename Y3, typename Z3, typename W3 
+        > 
+		GLM_FUNC_DECL explicit tmat3x4(
+            X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
+            X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, 
+            X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3);
 			
-			template <typename V1, typename V2, typename V3> 
-			GLM_FUNC_DECL explicit tmat3x4(
-                tvec4<V1> const & v1, 
-                tvec4<V2> const & v2,
-                tvec4<V3> const & v3);
+		template <typename V1, typename V2, typename V3> 
+		GLM_FUNC_DECL explicit tmat3x4(
+            tvec4<V1> const & v1, 
+            tvec4<V2> const & v2,
+            tvec4<V3> const & v3);
             
-			// Matrix conversion
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U> const & m);
-
-			GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x4(tmat4x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x4(tmat2x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x4(tmat3x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x4(tmat2x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x4(tmat4x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T> const & x);
-
-			// Accesses
-			col_type & operator[](size_type i);
-			col_type const & operator[](size_type i) const;
-
-			// Unary updatable operators
-			GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<T> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x4<T> & operator+= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x4<T> & operator+= (tmat3x4<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x4<T> & operator-= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x4<T> & operator-= (tmat3x4<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x4<T> & operator*= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x4<T> & operator*= (tmat3x4<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat3x4<T> & operator/= (U const & s);
-
-			GLM_FUNC_DECL tmat3x4<T> & operator++ ();
-			GLM_FUNC_DECL tmat3x4<T> & operator-- ();
-		};
-
-		// Binary operators
-		template <typename T> 
-		tmat3x4<T> operator+ (
-			tmat3x4<T> const & m, 
-			typename tmat3x4<T>::value_type const & s);
+		// Matrix conversion
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U> const & m);
+
+		GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x4(tmat4x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x4(tmat2x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x4(tmat3x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x4(tmat2x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x4(tmat4x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T> const & x);
+
+		// Accesses
+		col_type & operator[](size_type i);
+		col_type const & operator[](size_type i) const;
+
+		// Unary updatable operators
+		GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<T> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x4<T> & operator=  (tmat3x4<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x4<T> & operator+= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x4<T> & operator+= (tmat3x4<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x4<T> & operator-= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x4<T> & operator-= (tmat3x4<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x4<T> & operator*= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x4<T> & operator*= (tmat3x4<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat3x4<T> & operator/= (U const & s);
+
+		GLM_FUNC_DECL tmat3x4<T> & operator++ ();
+		GLM_FUNC_DECL tmat3x4<T> & operator-- ();
+	};
+
+	// Binary operators
+	template <typename T> 
+	tmat3x4<T> operator+ (
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::value_type const & s);
 	    
-		template <typename T> 
-		tmat3x4<T> operator+ (
-			tmat3x4<T> const & m1, 
-			tmat3x4<T> const & m2);
+	template <typename T> 
+	tmat3x4<T> operator+ (
+		tmat3x4<T> const & m1, 
+		tmat3x4<T> const & m2);
 	    
-		template <typename T> 
-		tmat3x4<T> operator- (
-			tmat3x4<T> const & m, 
-			typename tmat3x4<T>::value_type const & s);
-
-		template <typename T> 
-		tmat3x4<T> operator- (
-			tmat3x4<T> const & m1, 
-			tmat3x4<T> const & m2);
-
-		template <typename T> 
-		tmat3x4<T> operator* (
-			tmat3x4<T> const & m, 
-			typename tmat3x4<T>::value_type const & s);
-
-		template <typename T> 
-		tmat3x4<T> operator* (
-			typename tmat3x4<T>::value_type const & s, 
-			tmat3x4<T> const & m);
-
-		template <typename T>
-		typename tmat3x4<T>::col_type operator* (
-			tmat3x4<T> const & m, 
-			typename tmat3x4<T>::row_type const & v);
-
-		template <typename T> 
-		typename tmat3x4<T>::row_type operator* (
-			typename tmat3x4<T>::col_type const & v, 
-			tmat3x4<T> const & m);
-
-		template <typename T>
-		tmat4x4<T> operator* (
-			tmat3x4<T> const & m1, 
-			tmat4x3<T> const & m2);
-
-		template <typename T> 
-		tmat3x4<T> operator/ (
-			tmat3x4<T> const & m, 
-			typename tmat3x4<T>::value_type const & s);
-
-		template <typename T> 
-		tmat3x4<T> operator/ (
-			typename tmat3x4<T>::value_type const & s, 
-			tmat3x4<T> const & m);
-
-		// Unary constant operators
-		template <typename T> 
-		tmat3x4<T> const operator-  (
-			tmat3x4<T> const & m);
-
-		template <typename T> 
-		tmat3x4<T> const operator-- (
-			tmat3x4<T> const & m, 
-			int);
-
-		template <typename T> 
-		tmat3x4<T> const operator++ (
-			tmat3x4<T> const & m, 
-			int);
-
-	} //namespace detail
-
-	namespace core{
-	namespace type{
-
-	namespace precision
-	{
-		//! 3 columns of 4 components matrix of low precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		typedef detail::tmat3x4<lowp_float>		lowp_mat3x4;
-		//! 3 columns of 4 components matrix of medium precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		typedef detail::tmat3x4<mediump_float>	mediump_mat3x4;
-		//! 3 columns of 4 components matrix of high precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		typedef detail::tmat3x4<highp_float>	highp_mat3x4;
-	}
-	//namespace precision
-
-	}//namespace type
-	}//namespace core
-} //namespace glm
+	template <typename T> 
+	tmat3x4<T> operator- (
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::value_type const & s);
+
+	template <typename T> 
+	tmat3x4<T> operator- (
+		tmat3x4<T> const & m1, 
+		tmat3x4<T> const & m2);
+
+	template <typename T> 
+	tmat3x4<T> operator* (
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::value_type const & s);
+
+	template <typename T> 
+	tmat3x4<T> operator* (
+		typename tmat3x4<T>::value_type const & s, 
+		tmat3x4<T> const & m);
+
+	template <typename T>
+	typename tmat3x4<T>::col_type operator* (
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::row_type const & v);
+
+	template <typename T> 
+	typename tmat3x4<T>::row_type operator* (
+		typename tmat3x4<T>::col_type const & v, 
+		tmat3x4<T> const & m);
+
+	template <typename T>
+	tmat4x4<T> operator* (
+		tmat3x4<T> const & m1, 
+		tmat4x3<T> const & m2);
+
+	template <typename T> 
+	tmat3x4<T> operator/ (
+		tmat3x4<T> const & m, 
+		typename tmat3x4<T>::value_type const & s);
+
+	template <typename T> 
+	tmat3x4<T> operator/ (
+		typename tmat3x4<T>::value_type const & s, 
+		tmat3x4<T> const & m);
+
+	// Unary constant operators
+	template <typename T> 
+	tmat3x4<T> const operator-  (
+		tmat3x4<T> const & m);
+
+	template <typename T> 
+	tmat3x4<T> const operator-- (
+		tmat3x4<T> const & m, 
+		int);
+
+	template <typename T> 
+	tmat3x4<T> const operator++ (
+		tmat3x4<T> const & m, 
+		int);
+
+}//namespace detail
+
+namespace core{
+namespace type{
+namespace precision
+{
+	//! 3 columns of 4 components matrix of low precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	typedef detail::tmat3x4<lowp_float>		lowp_mat3x4;
+	//! 3 columns of 4 components matrix of medium precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	typedef detail::tmat3x4<mediump_float>	mediump_mat3x4;
+	//! 3 columns of 4 components matrix of high precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	typedef detail::tmat3x4<highp_float>	highp_mat3x4;
+
+}//namespace precision
+}//namespace type
+}//namespace core
+}//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat3x4.inl"

glm/core/type_mat4x2.hpp

@@ -12,234 +12,228 @@
 
 #include "type_mat.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
+	template <typename T> struct tvec1;
+	template <typename T> struct tvec2;
+	template <typename T> struct tvec3;
+	template <typename T> struct tvec4;
+	template <typename T> struct tmat2x2;
+	template <typename T> struct tmat2x3;
+	template <typename T> struct tmat2x4;
+	template <typename T> struct tmat3x2;
+	template <typename T> struct tmat3x3;
+	template <typename T> struct tmat3x4;
+	template <typename T> struct tmat4x2;
+	template <typename T> struct tmat4x3;
+	template <typename T> struct tmat4x4;
+
+	//! \brief Template for 4 columns and 2 rows matrix of floating-point numbers.
+	//! \ingroup core_template
+	template <typename T> 
+	struct tmat4x2
 	{
-		void main_mat4x2();
-	}//namespace test
-
-	namespace detail
-	{
-		template <typename T> struct tvec1;
-		template <typename T> struct tvec2;
-		template <typename T> struct tvec3;
-		template <typename T> struct tvec4;
-		template <typename T> struct tmat2x2;
-		template <typename T> struct tmat2x3;
-		template <typename T> struct tmat2x4;
-		template <typename T> struct tmat3x2;
-		template <typename T> struct tmat3x3;
-		template <typename T> struct tmat3x4;
-		template <typename T> struct tmat4x2;
-		template <typename T> struct tmat4x3;
-		template <typename T> struct tmat4x4;
-
-		//! \brief Template for 4 columns and 2 rows matrix of floating-point numbers.
-		//! \ingroup core_template
-		template <typename T> 
-		struct tmat4x2
-		{
-			enum ctor{null};
-			typedef T value_type;
-			typedef std::size_t size_type;
-			typedef tvec2<T> col_type;
-			typedef tvec4<T> row_type;
-			static GLM_FUNC_DECL size_type col_size();
-			static GLM_FUNC_DECL size_type row_size();
-
-			typedef tmat4x2<T> type;
-			typedef tmat2x4<T> transpose_type;
-
-		private:
-			// Data 
-			col_type value[4];
-
-		public:
-			// Constructors
-			GLM_FUNC_DECL tmat4x2();
-			GLM_FUNC_DECL tmat4x2(tmat4x2 const & m);
-
-			GLM_FUNC_DECL explicit tmat4x2(
-				ctor Null);
-			GLM_FUNC_DECL explicit tmat4x2(
-				value_type const & x);
-			GLM_FUNC_DECL explicit tmat4x2(
-				value_type const & x0, value_type const & y0,
-				value_type const & x1, value_type const & y1,
-				value_type const & x2, value_type const & y2,
-				value_type const & x3, value_type const & y3);
-			GLM_FUNC_DECL explicit tmat4x2(
-				col_type const & v0, 
-				col_type const & v1,
-				col_type const & v2,
-				col_type const & v3);
+		enum ctor{null};
+		typedef T value_type;
+		typedef std::size_t size_type;
+		typedef tvec2<T> col_type;
+		typedef tvec4<T> row_type;
+		static GLM_FUNC_DECL size_type col_size();
+		static GLM_FUNC_DECL size_type row_size();
+
+		typedef tmat4x2<T> type;
+		typedef tmat2x4<T> transpose_type;
+
+	private:
+		// Data 
+		col_type value[4];
+
+	public:
+		// Constructors
+		GLM_FUNC_DECL tmat4x2();
+		GLM_FUNC_DECL tmat4x2(tmat4x2 const & m);
+
+		GLM_FUNC_DECL explicit tmat4x2(
+			ctor Null);
+		GLM_FUNC_DECL explicit tmat4x2(
+			value_type const & x);
+		GLM_FUNC_DECL explicit tmat4x2(
+			value_type const & x0, value_type const & y0,
+			value_type const & x1, value_type const & y1,
+			value_type const & x2, value_type const & y2,
+			value_type const & x3, value_type const & y3);
+		GLM_FUNC_DECL explicit tmat4x2(
+			col_type const & v0, 
+			col_type const & v1,
+			col_type const & v2,
+			col_type const & v3);
             
-			//////////////////////////////////////
-			// Conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat4x2(
-                U const & x);
+		//////////////////////////////////////
+		// Conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat4x2(
+            U const & x);
 			
-			template 
-            <
-                typename X1, typename Y1, 
-                typename X2, typename Y2, 
-                typename X3, typename Y3,
-                typename X4, typename Y4
-            > 
-			GLM_FUNC_DECL explicit tmat4x2(
-                X1 const & x1, Y1 const & y1, 
-                X2 const & x2, Y2 const & y2,
-                X3 const & x3, Y3 const & y3,
-                X4 const & x4, Y4 const & y4);
+		template 
+        <
+            typename X1, typename Y1, 
+            typename X2, typename Y2, 
+            typename X3, typename Y3,
+            typename X4, typename Y4
+        > 
+		GLM_FUNC_DECL explicit tmat4x2(
+            X1 const & x1, Y1 const & y1, 
+            X2 const & x2, Y2 const & y2,
+            X3 const & x3, Y3 const & y3,
+            X4 const & x4, Y4 const & y4);
 			
-			template <typename V1, typename V2, typename V3, typename V4> 
-			GLM_FUNC_DECL explicit tmat4x2(
-                tvec2<V1> const & v1, 
-                tvec2<V2> const & v2,
-                tvec2<V3> const & v3,
-                tvec2<V4> const & v4);
+		template <typename V1, typename V2, typename V3, typename V4> 
+		GLM_FUNC_DECL explicit tmat4x2(
+            tvec2<V1> const & v1, 
+            tvec2<V2> const & v2,
+            tvec2<V3> const & v3,
+            tvec2<V4> const & v4);
             
-			// Matrix conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U> const & m);
+		// Matrix conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U> const & m);
 			
-			GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x2(tmat4x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x2(tmat2x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x2(tmat3x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x2(tmat2x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x2(tmat4x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x2(tmat3x4<T> const & x);
-
-			// Accesses
-			GLM_FUNC_DECL col_type & operator[](size_type i);
-			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-			// Unary updatable operators
-			GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<T> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x2<T>& operator+= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x2<T>& operator+= (tmat4x2<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x2<T>& operator-= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x2<T>& operator-= (tmat4x2<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x2<T>& operator*= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x2<T>& operator*= (tmat4x2<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x2<T>& operator/= (U const & s);
-
-			GLM_FUNC_DECL tmat4x2<T>& operator++ ();
-			GLM_FUNC_DECL tmat4x2<T>& operator-- ();
-		};
-
-		// Binary operators
-		template <typename T> 
-		tmat4x2<T> operator+ (
-			tmat4x2<T> const & m, 
-			typename tmat4x2<T>::value_type const & s);
+		GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x2(tmat4x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x2(tmat2x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x2(tmat3x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x2(tmat2x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x2(tmat4x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x2(tmat3x4<T> const & x);
+
+		// Accesses
+		GLM_FUNC_DECL col_type & operator[](size_type i);
+		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+
+		// Unary updatable operators
+		GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<T> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x2<T>& operator=  (tmat4x2<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x2<T>& operator+= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x2<T>& operator+= (tmat4x2<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x2<T>& operator-= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x2<T>& operator-= (tmat4x2<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x2<T>& operator*= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x2<T>& operator*= (tmat4x2<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x2<T>& operator/= (U const & s);
+
+		GLM_FUNC_DECL tmat4x2<T>& operator++ ();
+		GLM_FUNC_DECL tmat4x2<T>& operator-- ();
+	};
+
+	// Binary operators
+	template <typename T> 
+	tmat4x2<T> operator+ (
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::value_type const & s);
 	    
-		template <typename T> 
-		tmat4x2<T> operator+ (
-			tmat4x2<T> const & m1, 
-			tmat4x2<T> const & m2);
+	template <typename T> 
+	tmat4x2<T> operator+ (
+		tmat4x2<T> const & m1, 
+		tmat4x2<T> const & m2);
 	    
-		template <typename T> 
-		tmat4x2<T> operator- (
-			tmat4x2<T> const & m, 
-			typename tmat4x2<T>::value_type const & s);
-
-		template <typename T> 
-		tmat4x2<T> operator- (
-			tmat4x2<T> const & m1, 
-			tmat4x2<T> const & m2);
-
-		template <typename T> 
-		tmat4x2<T> operator* (
-			tmat4x2<T> const & m, 
-			typename tmat4x2<T>::value_type const & s);
-
-		template <typename T> 
-		tmat4x2<T> operator* (
-			typename tmat4x2<T>::value_type const & s, 
-			tmat4x2<T> const & m);
-
-		template <typename T>
-		typename tmat4x2<T>::col_type operator* (
-			tmat4x2<T> const & m, 
-			typename tmat4x2<T>::row_type const & v);
-
-		template <typename T> 
-		typename tmat4x2<T>::row_type operator* (
-			typename tmat4x2<T>::col_type const & v, 
-			tmat4x2<T> const & m);
-
-		template <typename T> 
-		tmat2x2<T> operator* (
-			tmat4x2<T> const & m1, 
-			tmat2x4<T> const & m2);
-
-		template <typename T> 
-		tmat4x2<T> operator/ (
-			tmat4x2<T> const & m, 
-			typename tmat4x2<T>::value_type const & s);
-
-		template <typename T> 
-		tmat4x2<T> operator/ (
-			typename tmat4x2<T>::value_type const & s, 
-			tmat4x2<T> const & m);
-
-		// Unary constant operators
-		template <typename T> 
-		tmat4x2<T> const operator-  (
-			tmat4x2<T> const & m);
-
-		template <typename T> 
-		tmat4x2<T> const operator-- (
-			tmat4x2<T> const & m, 
-			int);
-
-		template <typename T> 
-		tmat4x2<T> const operator++ (
-			tmat4x2<T> const & m, 
-			int);
-
-	} //namespace detail
-
-	namespace core{
-	namespace type{
-
-	namespace precision
-	{
-		//! 4 columns of 2 components matrix of low precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		//! \ingroup core_precision
-		typedef detail::tmat4x2<lowp_float>		lowp_mat4x2;
-		//! 4 columns of 2 components matrix of medium precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		//! \ingroup core_precision
-		typedef detail::tmat4x2<mediump_float>	mediump_mat4x2;
-		//! 4 columns of 2 components matrix of high precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		//! \ingroup core_precision
-		typedef detail::tmat4x2<highp_float>	highp_mat4x2;
-	}
-	//namespace precision
-
-	}//namespace type
-	}//namespace core
-} //namespace glm
+	template <typename T> 
+	tmat4x2<T> operator- (
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::value_type const & s);
+
+	template <typename T> 
+	tmat4x2<T> operator- (
+		tmat4x2<T> const & m1, 
+		tmat4x2<T> const & m2);
+
+	template <typename T> 
+	tmat4x2<T> operator* (
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::value_type const & s);
+
+	template <typename T> 
+	tmat4x2<T> operator* (
+		typename tmat4x2<T>::value_type const & s, 
+		tmat4x2<T> const & m);
+
+	template <typename T>
+	typename tmat4x2<T>::col_type operator* (
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::row_type const & v);
+
+	template <typename T> 
+	typename tmat4x2<T>::row_type operator* (
+		typename tmat4x2<T>::col_type const & v, 
+		tmat4x2<T> const & m);
+
+	template <typename T> 
+	tmat2x2<T> operator* (
+		tmat4x2<T> const & m1, 
+		tmat2x4<T> const & m2);
+
+	template <typename T> 
+	tmat4x2<T> operator/ (
+		tmat4x2<T> const & m, 
+		typename tmat4x2<T>::value_type const & s);
+
+	template <typename T> 
+	tmat4x2<T> operator/ (
+		typename tmat4x2<T>::value_type const & s, 
+		tmat4x2<T> const & m);
+
+	// Unary constant operators
+	template <typename T> 
+	tmat4x2<T> const operator-  (
+		tmat4x2<T> const & m);
+
+	template <typename T> 
+	tmat4x2<T> const operator-- (
+		tmat4x2<T> const & m, 
+		int);
+
+	template <typename T> 
+	tmat4x2<T> const operator++ (
+		tmat4x2<T> const & m, 
+		int);
+
+} //namespace detail
+
+namespace core{
+namespace type{
+namespace precision
+{
+	//! 4 columns of 2 components matrix of low precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	//! \ingroup core_precision
+	typedef detail::tmat4x2<lowp_float>		lowp_mat4x2;
+
+	//! 4 columns of 2 components matrix of medium precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	//! \ingroup core_precision
+	typedef detail::tmat4x2<mediump_float>	mediump_mat4x2;
+
+	//! 4 columns of 2 components matrix of high precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	//! \ingroup core_precision
+	typedef detail::tmat4x2<highp_float>	highp_mat4x2;
+
+}//namespace precision
+}//namespace type
+}//namespace core
+}//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat4x2.inl"

glm/core/type_mat4x3.hpp

@@ -12,235 +12,229 @@
 
 #include "type_mat.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
+	template <typename T> struct tvec1;
+	template <typename T> struct tvec2;
+	template <typename T> struct tvec3;
+	template <typename T> struct tvec4;
+	template <typename T> struct tmat2x2;
+	template <typename T> struct tmat2x3;
+	template <typename T> struct tmat2x4;
+	template <typename T> struct tmat3x2;
+	template <typename T> struct tmat3x3;
+	template <typename T> struct tmat3x4;
+	template <typename T> struct tmat4x2;
+	template <typename T> struct tmat4x3;
+	template <typename T> struct tmat4x4;
+
+	//! \brief Template for 4 columns and 3 rows matrix of floating-point numbers.
+	//! \ingroup core_template
+	template <typename T> 
+	struct tmat4x3
 	{
-		void main_mat4x3();
-	}//namespace test
-
-	namespace detail
-	{
-		template <typename T> struct tvec1;
-		template <typename T> struct tvec2;
-		template <typename T> struct tvec3;
-		template <typename T> struct tvec4;
-		template <typename T> struct tmat2x2;
-		template <typename T> struct tmat2x3;
-		template <typename T> struct tmat2x4;
-		template <typename T> struct tmat3x2;
-		template <typename T> struct tmat3x3;
-		template <typename T> struct tmat3x4;
-		template <typename T> struct tmat4x2;
-		template <typename T> struct tmat4x3;
-		template <typename T> struct tmat4x4;
-
-		//! \brief Template for 4 columns and 3 rows matrix of floating-point numbers.
-		//! \ingroup core_template
-		template <typename T> 
-		struct tmat4x3
-		{
-			enum ctor{null};
-			typedef T value_type;
-			typedef std::size_t size_type;
-			typedef tvec3<T> col_type;
-			typedef tvec4<T> row_type;
-			static GLM_FUNC_DECL size_type col_size();
-			static GLM_FUNC_DECL size_type row_size();
-
-			typedef tmat4x3<T> type;
-			typedef tmat3x4<T> transpose_type;
-
-		private:
-			// Data 
-			col_type value[4];
-
-		public:
-			// Constructors
-			GLM_FUNC_DECL tmat4x3();
-			GLM_FUNC_DECL tmat4x3(tmat4x3 const & m);
-
-			GLM_FUNC_DECL explicit tmat4x3(
-				ctor Null);
-			GLM_FUNC_DECL explicit tmat4x3(
-				value_type const & x);
-			GLM_FUNC_DECL explicit tmat4x3(
-				value_type const & x0, value_type const & y0, value_type const & z0,
-				value_type const & x1, value_type const & y1, value_type const & z1,
-				value_type const & x2, value_type const & y2, value_type const & z2,
-				value_type const & x3, value_type const & y3, value_type const & z3);
-			GLM_FUNC_DECL explicit tmat4x3(
-				col_type const & v0, 
-				col_type const & v1,
-				col_type const & v2,
-                col_type const & v3);
+		enum ctor{null};
+		typedef T value_type;
+		typedef std::size_t size_type;
+		typedef tvec3<T> col_type;
+		typedef tvec4<T> row_type;
+		static GLM_FUNC_DECL size_type col_size();
+		static GLM_FUNC_DECL size_type row_size();
+
+		typedef tmat4x3<T> type;
+		typedef tmat3x4<T> transpose_type;
+
+	private:
+		// Data 
+		col_type value[4];
+
+	public:
+		// Constructors
+		GLM_FUNC_DECL tmat4x3();
+		GLM_FUNC_DECL tmat4x3(tmat4x3 const & m);
+
+		GLM_FUNC_DECL explicit tmat4x3(
+			ctor Null);
+		GLM_FUNC_DECL explicit tmat4x3(
+			value_type const & x);
+		GLM_FUNC_DECL explicit tmat4x3(
+			value_type const & x0, value_type const & y0, value_type const & z0,
+			value_type const & x1, value_type const & y1, value_type const & z1,
+			value_type const & x2, value_type const & y2, value_type const & z2,
+			value_type const & x3, value_type const & y3, value_type const & z3);
+		GLM_FUNC_DECL explicit tmat4x3(
+			col_type const & v0, 
+			col_type const & v1,
+			col_type const & v2,
+            col_type const & v3);
             
-			//////////////////////////////////////
-			// Conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat4x3(
-                U const & x);
+		//////////////////////////////////////
+		// Conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat4x3(
+            U const & x);
 			
-			template <
-                typename X1, typename Y1, typename Z1, 
-                typename X2, typename Y2, typename Z2, 
-                typename X3, typename Y3, typename Z3, 
-                typename X4, typename Y4, typename Z4> 
-			GLM_FUNC_DECL explicit tmat4x3(
-                X1 const & x1, Y1 const & y1, Z1 const & z1, 
-                X2 const & x2, Y2 const & y2, Z2 const & z2, 
-                X3 const & x3, Y3 const & y3, Z3 const & z3, 
-                X4 const & x4, Y4 const & y4, Z4 const & z4);
+		template <
+            typename X1, typename Y1, typename Z1, 
+            typename X2, typename Y2, typename Z2, 
+            typename X3, typename Y3, typename Z3, 
+            typename X4, typename Y4, typename Z4> 
+		GLM_FUNC_DECL explicit tmat4x3(
+            X1 const & x1, Y1 const & y1, Z1 const & z1, 
+            X2 const & x2, Y2 const & y2, Z2 const & z2, 
+            X3 const & x3, Y3 const & y3, Z3 const & z3, 
+            X4 const & x4, Y4 const & y4, Z4 const & z4);
 			
-			template <typename V1, typename V2, typename V3, typename V4> 
-			GLM_FUNC_DECL explicit tmat4x3(
-                tvec3<V1> const & v1, 
-                tvec3<V2> const & v2,
-                tvec3<V3> const & v3,
-                tvec3<V4> const & v4);
+		template <typename V1, typename V2, typename V3, typename V4> 
+		GLM_FUNC_DECL explicit tmat4x3(
+            tvec3<V1> const & v1, 
+            tvec3<V2> const & v2,
+            tvec3<V3> const & v3,
+            tvec3<V4> const & v4);
             
-			// Matrix conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U> const & m);
+		// Matrix conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U> const & m);
 			
-			GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x3(tmat4x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x3(tmat2x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x3(tmat3x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x3(tmat2x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x3(tmat4x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T> const & x);
-
-			// Accesses
-			col_type & operator[](size_type i);
-			col_type const & operator[](size_type i) const;
-
-			// Unary updatable operators
-			GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<T> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x3<T> & operator+= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x3<T> & operator+= (tmat4x3<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x3<T> & operator-= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x3<T> & operator-= (tmat4x3<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x3<T> & operator*= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x3<T> & operator*= (tmat4x3<U> const & m);
-			template <typename U> 
-			GLM_FUNC_DECL tmat4x3<T> & operator/= (U const & s);
-
-			GLM_FUNC_DECL tmat4x3<T> & operator++ ();
-			GLM_FUNC_DECL tmat4x3<T> & operator-- ();
-		};
-
-		// Binary operators
-		template <typename T> 
-		tmat4x3<T> operator+ (
-			tmat4x3<T> const & m, 
-			typename tmat4x3<T>::value_type const & s);
+		GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x3(tmat4x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x3(tmat2x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x3(tmat3x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x3(tmat2x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x3(tmat4x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T> const & x);
+
+		// Accesses
+		col_type & operator[](size_type i);
+		col_type const & operator[](size_type i) const;
+
+		// Unary updatable operators
+		GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<T> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x3<T> & operator=  (tmat4x3<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x3<T> & operator+= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x3<T> & operator+= (tmat4x3<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x3<T> & operator-= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x3<T> & operator-= (tmat4x3<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x3<T> & operator*= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x3<T> & operator*= (tmat4x3<U> const & m);
+		template <typename U> 
+		GLM_FUNC_DECL tmat4x3<T> & operator/= (U const & s);
+
+		GLM_FUNC_DECL tmat4x3<T> & operator++ ();
+		GLM_FUNC_DECL tmat4x3<T> & operator-- ();
+	};
+
+	// Binary operators
+	template <typename T> 
+	tmat4x3<T> operator+ (
+		tmat4x3<T> const & m, 
+		typename tmat4x3<T>::value_type const & s);
 	    
-		template <typename T> 
-		tmat4x3<T> operator+ (
-			tmat4x3<T> const & m1, 
-			tmat4x3<T> const & m2);
+	template <typename T> 
+	tmat4x3<T> operator+ (
+		tmat4x3<T> const & m1, 
+		tmat4x3<T> const & m2);
 	    
-		template <typename T> 
-		tmat4x3<T> operator- (
-			tmat4x3<T> const & m, 
-			typename tmat4x3<T>::value_type const & s);
-
-		template <typename T> 
-		tmat4x3<T> operator- (
-			tmat4x3<T> const & m1, 
-			tmat4x3<T> const & m2);
-
-		template <typename T> 
-		tmat4x3<T> operator* (
-			tmat4x3<T> const & m, 
-			typename tmat4x3<T>::value_type const & s);
-
-		template <typename T> 
-		tmat4x3<T> operator* (
-			typename tmat4x3<T>::value_type const & s, 
-			tmat4x3<T> const & m);
-
-		template <typename T>
-		typename tmat4x3<T>::col_type operator* (
-			tmat4x3<T> const & m, 
-			typename tmat4x3<T>::row_type const & v);
-
-		template <typename T> 
-		typename tmat4x3<T>::row_type operator* (
-			typename tmat4x3<T>::col_type const & v, 
-			tmat4x3<T> const & m);
-
-		template <typename T> 
-		tmat3x3<T> operator* (
-			tmat4x3<T> const & m1, 
-			tmat3x4<T> const & m2);
-
-		template <typename T> 
-		tmat4x3<T> operator/ (
-			tmat4x3<T> const & m, 
-			typename tmat4x3<T>::value_type const & s);
-
-		template <typename T> 
-		tmat4x3<T> operator/ (
-			typename tmat4x3<T>::value_type const & s, 
-			tmat4x3<T> const & m);
-
-		// Unary constant operators
-		template <typename T> 
-		tmat4x3<T> const operator- (
-			tmat4x3<T> const & m);
-
-		template <typename T> 
-		tmat4x3<T> const operator-- (
-			tmat4x3<T> const & m, 
-			int);
-
-		template <typename T> 
-		tmat4x3<T> const operator++ (
-			tmat4x3<T> const & m, 
-			int);
-
-	} //namespace detail
-
-	namespace core{
-	namespace type{
-
-	namespace precision
-	{
-		//! 4 columns of 3 components matrix of low precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		//! \ingroup core_precision
-		typedef detail::tmat4x3<lowp_float>		lowp_mat4x3;
-		//! 4 columns of 3 components matrix of medium precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		//! \ingroup core_precision
-		typedef detail::tmat4x3<mediump_float>	mediump_mat4x3;
-		//! 4 columns of 3 components matrix of high precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
-		//! \ingroup core_precision
-		typedef detail::tmat4x3<highp_float>	highp_mat4x3;
-	}
-	//namespace precision
-
-	}//namespace type
-	}//namespace core
-} //namespace glm
+	template <typename T> 
+	tmat4x3<T> operator- (
+		tmat4x3<T> const & m, 
+		typename tmat4x3<T>::value_type const & s);
+
+	template <typename T> 
+	tmat4x3<T> operator- (
+		tmat4x3<T> const & m1, 
+		tmat4x3<T> const & m2);
+
+	template <typename T> 
+	tmat4x3<T> operator* (
+		tmat4x3<T> const & m, 
+		typename tmat4x3<T>::value_type const & s);
+
+	template <typename T> 
+	tmat4x3<T> operator* (
+		typename tmat4x3<T>::value_type const & s, 
+		tmat4x3<T> const & m);
+
+	template <typename T>
+	typename tmat4x3<T>::col_type operator* (
+		tmat4x3<T> const & m, 
+		typename tmat4x3<T>::row_type const & v);
+
+	template <typename T> 
+	typename tmat4x3<T>::row_type operator* (
+		typename tmat4x3<T>::col_type const & v, 
+		tmat4x3<T> const & m);
+
+	template <typename T> 
+	tmat3x3<T> operator* (
+		tmat4x3<T> const & m1, 
+		tmat3x4<T> const & m2);
+
+	template <typename T> 
+	tmat4x3<T> operator/ (
+		tmat4x3<T> const & m, 
+		typename tmat4x3<T>::value_type const & s);
+
+	template <typename T> 
+	tmat4x3<T> operator/ (
+		typename tmat4x3<T>::value_type const & s, 
+		tmat4x3<T> const & m);
+
+	// Unary constant operators
+	template <typename T> 
+	tmat4x3<T> const operator- (
+		tmat4x3<T> const & m);
+
+	template <typename T> 
+	tmat4x3<T> const operator-- (
+		tmat4x3<T> const & m, 
+		int);
+
+	template <typename T> 
+	tmat4x3<T> const operator++ (
+		tmat4x3<T> const & m, 
+		int);
+
+}//namespace detail
+
+namespace core{
+namespace type{
+namespace precision
+{
+	//! 4 columns of 3 components matrix of low precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	//! \ingroup core_precision
+	typedef detail::tmat4x3<lowp_float>		lowp_mat4x3;
+
+	//! 4 columns of 3 components matrix of medium precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	//! \ingroup core_precision
+	typedef detail::tmat4x3<mediump_float>	mediump_mat4x3;
+
+	//! 4 columns of 3 components matrix of high precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+	//! \ingroup core_precision
+	typedef detail::tmat4x3<highp_float>	highp_mat4x3;
+
+}//namespace precision
+}//namespace type
+}//namespace core
+}//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat4x3.inl"
-#endif
+#endif //GLM_EXTERNAL_TEMPLATE
 
 #endif//glm_core_type_mat4x3

glm/core/type_mat4x4.hpp

@@ -2,7 +2,7 @@
 // OpenGL Mathematics Copyright (c) 2005 - 2011 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2005-01-27
-// Updated : 2008-08-30
+// Updated : 2011-06-02
 // Licence : This source is under MIT License
 // File    : glm/core/type_mat4x4.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -12,283 +12,275 @@
 
 #include "type_mat.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
+	template <typename T> struct tvec1;
+	template <typename T> struct tvec2;
+	template <typename T> struct tvec3;
+	template <typename T> struct tvec4;
+	template <typename T> struct tmat2x2;
+	template <typename T> struct tmat2x3;
+	template <typename T> struct tmat2x4;
+	template <typename T> struct tmat3x2;
+	template <typename T> struct tmat3x3;
+	template <typename T> struct tmat3x4;
+	template <typename T> struct tmat4x2;
+	template <typename T> struct tmat4x3;
+	template <typename T> struct tmat4x4;
+
+	//! \brief Template for 4 * 4 matrix of floating-point numbers.
+	//! \ingroup core_template
+	template <typename T> 
+	struct tmat4x4
 	{
-		void main_mat4x4();
-	}//namespace test
-
-	namespace detail
-	{
-		template <typename T> struct tvec1;
-		template <typename T> struct tvec2;
-		template <typename T> struct tvec3;
-		template <typename T> struct tvec4;
-		template <typename T> struct tmat2x2;
-		template <typename T> struct tmat2x3;
-		template <typename T> struct tmat2x4;
-		template <typename T> struct tmat3x2;
-		template <typename T> struct tmat3x3;
-		template <typename T> struct tmat3x4;
-		template <typename T> struct tmat4x2;
-		template <typename T> struct tmat4x3;
-		template <typename T> struct tmat4x4;
-
-		//! \brief Template for 4 * 4 matrix of floating-point numbers.
-		//! \ingroup core_template
-		template <typename T> 
-		struct tmat4x4
-		{
-			enum ctor{null};
-			typedef T value_type;
-			typedef std::size_t size_type;
-			typedef tvec4<T> col_type;
-			typedef tvec4<T> row_type;
-			static GLM_FUNC_DECL size_type col_size();
-			static GLM_FUNC_DECL size_type row_size();
-
-			typedef tmat4x4<T> type;
-			typedef tmat4x4<T> transpose_type;
-
-		public:
-			// Implementation detail
-			GLM_FUNC_DECL tmat4x4<T> _inverse() const;
-
-		private:
-			// Data 
-			col_type value[4];
-
-		public:
-			// Constructors
-			GLM_FUNC_DECL tmat4x4();
-			GLM_FUNC_DECL tmat4x4(tmat4x4 const & m);
-
-			GLM_FUNC_DECL explicit tmat4x4(
-				ctor Null);
-			GLM_FUNC_DECL explicit tmat4x4(
-				value_type const & x);
-			GLM_FUNC_DECL explicit tmat4x4(
-				value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
-				value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
-				value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2,
-				value_type const & x3, value_type const & y3, value_type const & z3, value_type const & w3);
-			GLM_FUNC_DECL explicit tmat4x4(
-				col_type const & v0, 
-				col_type const & v1,
-				col_type const & v2,
-				col_type const & v3);
-
-			//////////////////////////////////////
-			// Conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat4x4(
-                U const & x);
+		enum ctor{null};
+		typedef T value_type;
+		typedef std::size_t size_type;
+		typedef tvec4<T> col_type;
+		typedef tvec4<T> row_type;
+		static GLM_FUNC_DECL size_type col_size();
+		static GLM_FUNC_DECL size_type row_size();
+
+		typedef tmat4x4<T> type;
+		typedef tmat4x4<T> transpose_type;
+
+	public:
+		// Implementation detail
+		GLM_FUNC_DECL tmat4x4<T> _inverse() const;
+
+	private:
+		// Data 
+		col_type value[4];
+
+	public:
+		// Constructors
+		GLM_FUNC_DECL tmat4x4();
+		GLM_FUNC_DECL tmat4x4(tmat4x4 const & m);
+
+		GLM_FUNC_DECL explicit tmat4x4(
+			ctor Null);
+		GLM_FUNC_DECL explicit tmat4x4(
+			value_type const & x);
+		GLM_FUNC_DECL explicit tmat4x4(
+			value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
+			value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
+			value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2,
+			value_type const & x3, value_type const & y3, value_type const & z3, value_type const & w3);
+		GLM_FUNC_DECL explicit tmat4x4(
+			col_type const & v0, 
+			col_type const & v1,
+			col_type const & v2,
+			col_type const & v3);
+
+		//////////////////////////////////////
+		// Conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat4x4(
+            U const & x);
 			
-			template <
-                typename X1, typename Y1, typename Z1, typename W1, 
-                typename X2, typename Y2, typename Z2, typename W2, 
-                typename X3, typename Y3, typename Z3, typename W3, 
-                typename X4, typename Y4, typename Z4, typename W4> 
-			GLM_FUNC_DECL explicit tmat4x4(
-                X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
-                X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, 
-                X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3, 
-                X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4);
+		template <
+            typename X1, typename Y1, typename Z1, typename W1, 
+            typename X2, typename Y2, typename Z2, typename W2, 
+            typename X3, typename Y3, typename Z3, typename W3, 
+            typename X4, typename Y4, typename Z4, typename W4> 
+		GLM_FUNC_DECL explicit tmat4x4(
+            X1 const & x1, Y1 const & y1, Z1 const & z1, W1 const & w1, 
+            X2 const & x2, Y2 const & y2, Z2 const & z2, W2 const & w2, 
+            X3 const & x3, Y3 const & y3, Z3 const & z3, W3 const & w3, 
+            X4 const & x4, Y4 const & y4, Z4 const & z4, W4 const & w4);
 			
-			template <typename V1, typename V2, typename V3, typename V4> 
-			GLM_FUNC_DECL explicit tmat4x4(
-                tvec4<V1> const & v1, 
-                tvec4<V2> const & v2,
-                tvec4<V3> const & v3,
-                tvec4<V4> const & v4);
+		template <typename V1, typename V2, typename V3, typename V4> 
+		GLM_FUNC_DECL explicit tmat4x4(
+            tvec4<V1> const & v1, 
+            tvec4<V2> const & v2,
+            tvec4<V3> const & v3,
+            tvec4<V4> const & v4);
             
-			// Matrix conversions
-			template <typename U> 
-			GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U> const & m);
-
-			GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x4(tmat2x3<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x4(tmat3x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x4(tmat2x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x4(tmat4x2<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x4(tmat3x4<T> const & x);
-			GLM_FUNC_DECL explicit tmat4x4(tmat4x3<T> const & x);
-
-			// Accesses
-			GLM_FUNC_DECL col_type & operator[](size_type i);
-			GLM_FUNC_DECL col_type const & operator[](size_type i) const;
-
-			// Unary updatable operators
-			GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<T> const & m);
-			template <typename U>
-			GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<U> const & m);
-			template <typename U>
-			GLM_FUNC_DECL tmat4x4<T> & operator+= (U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tmat4x4<T> & operator+= (tmat4x4<U> const & m);
-			template <typename U>
-			GLM_FUNC_DECL tmat4x4<T> & operator-= (U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tmat4x4<T> & operator-= (tmat4x4<U> const & m);
-			template <typename U>
-			GLM_FUNC_DECL tmat4x4<T> & operator*= (U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tmat4x4<T> & operator*= (tmat4x4<U> const & m);
-			template <typename U>
-			GLM_FUNC_DECL tmat4x4<T> & operator/= (U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tmat4x4<T> & operator/= (tmat4x4<U> const & m);
-			GLM_FUNC_DECL tmat4x4<T> & operator++ ();
-			GLM_FUNC_DECL tmat4x4<T> & operator-- ();
-		};
-
-		// Binary operators
-		template <typename T> 
-		tmat4x4<T> operator+ (
-			tmat4x4<T> const & m, 
-			typename tmat4x4<T>::value_type const & s);
-
-		template <typename T> 
-		tmat4x4<T> operator+ (
-			typename tmat4x4<T>::value_type const & s, 
-			tmat4x4<T> const & m);
-
-		template <typename T> 
-		tmat4x4<T> operator+ (
-			tmat4x4<T> const & m1, 
-			tmat4x4<T> const & m2);
+		// Matrix conversions
+		template <typename U> 
+		GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U> const & m);
+
+		GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x4(tmat2x3<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x4(tmat3x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x4(tmat2x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x4(tmat4x2<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x4(tmat3x4<T> const & x);
+		GLM_FUNC_DECL explicit tmat4x4(tmat4x3<T> const & x);
+
+		// Accesses
+		GLM_FUNC_DECL col_type & operator[](size_type i);
+		GLM_FUNC_DECL col_type const & operator[](size_type i) const;
+
+		// Unary updatable operators
+		GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<T> const & m);
+		template <typename U>
+		GLM_FUNC_DECL tmat4x4<T> & operator=  (tmat4x4<U> const & m);
+		template <typename U>
+		GLM_FUNC_DECL tmat4x4<T> & operator+= (U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tmat4x4<T> & operator+= (tmat4x4<U> const & m);
+		template <typename U>
+		GLM_FUNC_DECL tmat4x4<T> & operator-= (U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tmat4x4<T> & operator-= (tmat4x4<U> const & m);
+		template <typename U>
+		GLM_FUNC_DECL tmat4x4<T> & operator*= (U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tmat4x4<T> & operator*= (tmat4x4<U> const & m);
+		template <typename U>
+		GLM_FUNC_DECL tmat4x4<T> & operator/= (U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tmat4x4<T> & operator/= (tmat4x4<U> const & m);
+		GLM_FUNC_DECL tmat4x4<T> & operator++ ();
+		GLM_FUNC_DECL tmat4x4<T> & operator-- ();
+	};
+
+	// Binary operators
+	template <typename T> 
+	tmat4x4<T> operator+ (
+		tmat4x4<T> const & m, 
+		typename tmat4x4<T>::value_type const & s);
+
+	template <typename T> 
+	tmat4x4<T> operator+ (
+		typename tmat4x4<T>::value_type const & s, 
+		tmat4x4<T> const & m);
+
+	template <typename T> 
+	tmat4x4<T> operator+ (
+		tmat4x4<T> const & m1, 
+		tmat4x4<T> const & m2);
 	    
-		template <typename T> 
-		tmat4x4<T> operator- (
-			tmat4x4<T> const & m, 
-			typename tmat4x4<T>::value_type const & s);
-
-		template <typename T> 
-		tmat4x4<T> operator- (
-			typename tmat4x4<T>::value_type const & s, 
-			tmat4x4<T> const & m);
-
-		template <typename T> 
-		tmat4x4<T> operator- (
-			tmat4x4<T> const & m1, 
-			tmat4x4<T> const & m2);
-
-		template <typename T> 
-		tmat4x4<T> operator* (
-			tmat4x4<T> const & m, 
-			typename tmat4x4<T>::value_type const & s);
-
-		template <typename T> 
-		tmat4x4<T> operator* (
-			typename tmat4x4<T>::value_type const & s, 
-			tmat4x4<T> const & m);
-
-		template <typename T> 
-		typename tmat4x4<T>::col_type operator* (
-			tmat4x4<T> const & m, 
-			typename tmat4x4<T>::row_type const & v);
-
-		template <typename T> 
-		typename tmat4x4<T>::row_type operator* (
-			typename tmat4x4<T>::col_type const & v, 
-			tmat4x4<T> const & m);
-
-		template <typename T> 
-		tmat4x4<T> operator* (
-			tmat4x4<T> const & m1, 
-			tmat4x4<T> const & m2);
-
-		template <typename T> 
-		tmat4x4<T> operator/ (
-			tmat4x4<T> const & m, 
-			typename tmat4x4<T>::value_type const & s);
-
-		template <typename T> 
-		tmat4x4<T> operator/ (
-			typename tmat4x4<T>::value_type const & s, 
-			tmat4x4<T> const & m);
-
-		template <typename T> 
-		typename tmat4x4<T>::col_type operator/ (
-			tmat4x4<T> const & m, 
-			typename tmat4x4<T>::row_type const & v);
-
-		template <typename T> 
-		typename tmat4x4<T>::row_type operator/ (
-			typename tmat4x4<T>::col_type & v, 
-			tmat4x4<T> const & m);
-
-		template <typename T> 
-		tmat4x4<T> operator/ (
-			tmat4x4<T> const & m1, 
-			tmat4x4<T> const & m2);
-
-		// Unary constant operators
-		template <typename T> 
-		tmat4x4<T> const operator-  (
-			tmat4x4<T> const & m);
-
-		template <typename T> 
-		tmat4x4<T> const operator-- (
-			tmat4x4<T> const & m, int);
-
-		template <typename T> 
-		tmat4x4<T> const operator++ (
-			tmat4x4<T> const & m, int);
-
-	} //namespace detail
-
-	namespace core{
-	namespace type{
-
-	namespace precision
-	{
-		//! 4 columns of 4 components matrix of low precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat4x4<lowp_float>		lowp_mat4;
-
-		//! 4 columns of 4 components matrix of medium precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat4x4<mediump_float>	mediump_mat4;
-
-		//! 4 columns of 4 components matrix of high precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat4x4<highp_float>	highp_mat4;
-
-		//! 4 columns of 4 components matrix of low precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat4x4<lowp_float>		lowp_mat4x4;
-
-		//! 4 columns of 4 components matrix of medium precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat4x4<mediump_float>	mediump_mat4x4;
-
-		//! 4 columns of 4 components matrix of high precision floating-point numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
-		//! \ingroup core_precision
-		typedef detail::tmat4x4<highp_float>	highp_mat4x4;
-	}
-	//namespace precision
-
-	}//namespace type
-	}//namespace core
-} //namespace glm
+	template <typename T> 
+	tmat4x4<T> operator- (
+		tmat4x4<T> const & m, 
+		typename tmat4x4<T>::value_type const & s);
+
+	template <typename T> 
+	tmat4x4<T> operator- (
+		typename tmat4x4<T>::value_type const & s, 
+		tmat4x4<T> const & m);
+
+	template <typename T> 
+	tmat4x4<T> operator- (
+		tmat4x4<T> const & m1, 
+		tmat4x4<T> const & m2);
+
+	template <typename T> 
+	tmat4x4<T> operator* (
+		tmat4x4<T> const & m, 
+		typename tmat4x4<T>::value_type const & s);
+
+	template <typename T> 
+	tmat4x4<T> operator* (
+		typename tmat4x4<T>::value_type const & s, 
+		tmat4x4<T> const & m);
+
+	template <typename T> 
+	typename tmat4x4<T>::col_type operator* (
+		tmat4x4<T> const & m, 
+		typename tmat4x4<T>::row_type const & v);
+
+	template <typename T> 
+	typename tmat4x4<T>::row_type operator* (
+		typename tmat4x4<T>::col_type const & v, 
+		tmat4x4<T> const & m);
+
+	template <typename T> 
+	tmat4x4<T> operator* (
+		tmat4x4<T> const & m1, 
+		tmat4x4<T> const & m2);
+
+	template <typename T> 
+	tmat4x4<T> operator/ (
+		tmat4x4<T> const & m, 
+		typename tmat4x4<T>::value_type const & s);
+
+	template <typename T> 
+	tmat4x4<T> operator/ (
+		typename tmat4x4<T>::value_type const & s, 
+		tmat4x4<T> const & m);
+
+	template <typename T> 
+	typename tmat4x4<T>::col_type operator/ (
+		tmat4x4<T> const & m, 
+		typename tmat4x4<T>::row_type const & v);
+
+	template <typename T> 
+	typename tmat4x4<T>::row_type operator/ (
+		typename tmat4x4<T>::col_type & v, 
+		tmat4x4<T> const & m);
+
+	template <typename T> 
+	tmat4x4<T> operator/ (
+		tmat4x4<T> const & m1, 
+		tmat4x4<T> const & m2);
+
+	// Unary constant operators
+	template <typename T> 
+	tmat4x4<T> const operator-  (
+		tmat4x4<T> const & m);
+
+	template <typename T> 
+	tmat4x4<T> const operator-- (
+		tmat4x4<T> const & m, int);
+
+	template <typename T> 
+	tmat4x4<T> const operator++ (
+		tmat4x4<T> const & m, int);
+
+} //namespace detail
+
+namespace core{
+namespace type{
+namespace precision
+{
+	//! 4 columns of 4 components matrix of low precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat4x4<lowp_float>		lowp_mat4;
+
+	//! 4 columns of 4 components matrix of medium precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat4x4<mediump_float>	mediump_mat4;
+
+	//! 4 columns of 4 components matrix of high precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat4x4<highp_float>	highp_mat4;
+
+	//! 4 columns of 4 components matrix of low precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat4x4<lowp_float>		lowp_mat4x4;
+
+	//! 4 columns of 4 components matrix of medium precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat4x4<mediump_float>	mediump_mat4x4;
+
+	//! 4 columns of 4 components matrix of high precision floating-point numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers
+	//! \ingroup core_precision
+	typedef detail::tmat4x4<highp_float>	highp_mat4x4;
+
+}//namespace precision
+}//namespace type
+}//namespace core
+}//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_mat4x4.inl"
-#endif
+#endif//GLM_EXTERNAL_TEMPLATE
 
-#endif //glm_core_type_mat4x4
+#endif//glm_core_type_mat4x4

glm/core/type_vec1.hpp

@@ -16,39 +16,33 @@
 #include "type_size.hpp"
 #include "_swizzle.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
+	template <typename T> struct tref1;
+	template <typename T> struct tref2;
+	template <typename T> struct tref3;
+	template <typename T> struct tref4;
+	template <typename T> struct tvec1;
+	template <typename T> struct tvec2;
+	template <typename T> struct tvec3;
+	template <typename T> struct tvec4;
+
+	template <typename T>
+	struct tvec1
 	{
-		void main_vec1();
-	}//namespace test
+		enum ctor{null};
 
-	namespace detail
-	{
-		template <typename T> struct tref1;
-		template <typename T> struct tref2;
-		template <typename T> struct tref3;
-		template <typename T> struct tref4;
-		template <typename T> struct tvec1;
-		template <typename T> struct tvec2;
-		template <typename T> struct tvec3;
-		template <typename T> struct tvec4;
-
-		template <typename T>
-		struct tvec1
-		{
-			enum ctor{null};
-
-			typedef T value_type;
-			typedef std::size_t size_type;
-			GLM_FUNC_DECL size_type length() const;
-			static GLM_FUNC_DECL size_type value_size();
-
-			typedef tvec1<T> type;
-			typedef tvec1<bool> bool_type;
-
-			//////////////////////////////////////
-			// Data
+		typedef T value_type;
+		typedef std::size_t size_type;
+		GLM_FUNC_DECL size_type length() const;
+		static GLM_FUNC_DECL size_type value_size();
+
+		typedef tvec1<T> type;
+		typedef tvec1<bool> bool_type;
+
+		//////////////////////////////////////
+		// Data
 
 #		if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
 			value_type x;
@@ -56,123 +50,123 @@ namespace glm
 			union {value_type x, r, s;};
 #		endif//GLM_COMPONENT
 
-			//////////////////////////////////////
-			// Accesses
-
-			GLM_FUNC_DECL value_type & operator[](size_type i);
-			GLM_FUNC_DECL value_type const & operator[](size_type i) const;
-
-			//////////////////////////////////////
-			// Implicit basic constructors
-
-			GLM_FUNC_DECL tvec1();
-			GLM_FUNC_DECL tvec1(tvec1<T> const & v);
-
-			//////////////////////////////////////
-			// Explicit basic constructors
-
-			GLM_FUNC_DECL explicit tvec1(
-				ctor);
-			GLM_FUNC_DECL explicit tvec1(
-				value_type const & s);
-
-			//////////////////////////////////////
-			// Swizzle constructors
-
-			GLM_FUNC_DECL tvec1(tref1<T> 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> 
-			GLM_FUNC_DECL explicit tvec1(U const & s);
-
-			//////////////////////////////////////
-			// Convertion vector constructors
-
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			GLM_FUNC_DECL explicit tvec1(tvec2<U> const & v);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			GLM_FUNC_DECL explicit tvec1(tvec3<U> const & v);
-			//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			GLM_FUNC_DECL explicit tvec1(tvec4<U> const & v);
-
-			//////////////////////////////////////
-			// Unary arithmetic operators
-
-			GLM_FUNC_DECL tvec1<T> & operator= (tvec1<T> const & v);
-
-			GLM_FUNC_DECL tvec1<T> & operator+=(value_type const & s);
-			GLM_FUNC_DECL tvec1<T> & operator+=(tvec1<T> const & v);
-			GLM_FUNC_DECL tvec1<T> & operator-=(value_type const & s);
-			GLM_FUNC_DECL tvec1<T> & operator-=(tvec1<T> const & v);
-			GLM_FUNC_DECL tvec1<T> & operator*=(value_type const & s);
-			GLM_FUNC_DECL tvec1<T> & operator*=(tvec1<T> const & v);
-			GLM_FUNC_DECL tvec1<T> & operator/=(value_type const & s);
-			GLM_FUNC_DECL tvec1<T> & operator/=(tvec1<T> const & v);
-			GLM_FUNC_DECL tvec1<T> & operator++();
-			GLM_FUNC_DECL tvec1<T> & operator--();
-
-			//////////////////////////////////////
-			// Unary bit operators
-
-			GLM_FUNC_DECL tvec1<T> & operator%=(value_type const & s);
-			GLM_FUNC_DECL tvec1<T> & operator%=(tvec1<T> const & v);
-			GLM_FUNC_DECL tvec1<T> & operator&=(value_type const & s);
-			GLM_FUNC_DECL tvec1<T> & operator&=(tvec1<T> const & v);
-			GLM_FUNC_DECL tvec1<T> & operator|=(value_type const & s);
-			GLM_FUNC_DECL tvec1<T> & operator|=(tvec1<T> const & v);
-			GLM_FUNC_DECL tvec1<T> & operator^=(value_type const & s);
-			GLM_FUNC_DECL tvec1<T> & operator^=(tvec1<T> const & v);
-			GLM_FUNC_DECL tvec1<T> & operator<<=(value_type const & s);
-			GLM_FUNC_DECL tvec1<T> & operator<<=(tvec1<T> const & v);
-			GLM_FUNC_DECL tvec1<T> & operator>>=(value_type const & s);
-			GLM_FUNC_DECL tvec1<T> & operator>>=(tvec1<T> const & v);
-
-			//////////////////////////////////////
-			// Swizzle operators
-
-			GLM_FUNC_DECL value_type swizzle(comp X) const;
-			GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
-			GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-			GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-			GLM_FUNC_DECL tref1<T> swizzle(comp X);
-		};
-
-		template <typename T>
-		struct tref1
-		{
-			GLM_FUNC_DECL tref1(T & x);
-			GLM_FUNC_DECL tref1(tref1<T> const & r);
-			GLM_FUNC_DECL tref1(tvec1<T> const & v);
-
-			GLM_FUNC_DECL tref1<T> & operator= (tref1<T> const & r);
-			GLM_FUNC_DECL tref1<T> & operator= (tvec1<T> const & v);
-
-			T& x;
-		};
-
-		GLM_DETAIL_IS_VECTOR(tvec1);
-
-		typedef detail::tvec1<core::type::precision::highp_float>		highp_vec1_t;
-		typedef detail::tvec1<core::type::precision::mediump_float>		mediump_vec1_t;
-		typedef detail::tvec1<core::type::precision::lowp_float>		lowp_vec1_t;
-		typedef detail::tvec1<core::type::precision::highp_int>			highp_ivec1_t;
-		typedef detail::tvec1<core::type::precision::mediump_int>		mediump_ivec1_t;
-		typedef detail::tvec1<core::type::precision::lowp_int>			lowp_ivec1_t;
-		typedef detail::tvec1<core::type::precision::highp_uint>		highp_uvec1_t;
-		typedef detail::tvec1<core::type::precision::mediump_uint>		mediump_uvec1_t;
-		typedef detail::tvec1<core::type::precision::lowp_uint>			lowp_uvec1_t;
-
-	} //namespace detail
+		//////////////////////////////////////
+		// Accesses
+
+		GLM_FUNC_DECL value_type & operator[](size_type i);
+		GLM_FUNC_DECL value_type const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		GLM_FUNC_DECL tvec1();
+		GLM_FUNC_DECL tvec1(tvec1<T> const & v);
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		GLM_FUNC_DECL explicit tvec1(
+			ctor);
+		GLM_FUNC_DECL explicit tvec1(
+			value_type const & s);
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		GLM_FUNC_DECL tvec1(tref1<T> 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> 
+		GLM_FUNC_DECL explicit tvec1(U const & s);
+
+		//////////////////////////////////////
+		// Convertion vector constructors
+
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		GLM_FUNC_DECL explicit tvec1(tvec2<U> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		GLM_FUNC_DECL explicit tvec1(tvec3<U> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		GLM_FUNC_DECL explicit tvec1(tvec4<U> const & v);
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		GLM_FUNC_DECL tvec1<T> & operator= (tvec1<T> const & v);
+
+		GLM_FUNC_DECL tvec1<T> & operator+=(value_type const & s);
+		GLM_FUNC_DECL tvec1<T> & operator+=(tvec1<T> const & v);
+		GLM_FUNC_DECL tvec1<T> & operator-=(value_type const & s);
+		GLM_FUNC_DECL tvec1<T> & operator-=(tvec1<T> const & v);
+		GLM_FUNC_DECL tvec1<T> & operator*=(value_type const & s);
+		GLM_FUNC_DECL tvec1<T> & operator*=(tvec1<T> const & v);
+		GLM_FUNC_DECL tvec1<T> & operator/=(value_type const & s);
+		GLM_FUNC_DECL tvec1<T> & operator/=(tvec1<T> const & v);
+		GLM_FUNC_DECL tvec1<T> & operator++();
+		GLM_FUNC_DECL tvec1<T> & operator--();
+
+		//////////////////////////////////////
+		// Unary bit operators
+
+		GLM_FUNC_DECL tvec1<T> & operator%=(value_type const & s);
+		GLM_FUNC_DECL tvec1<T> & operator%=(tvec1<T> const & v);
+		GLM_FUNC_DECL tvec1<T> & operator&=(value_type const & s);
+		GLM_FUNC_DECL tvec1<T> & operator&=(tvec1<T> const & v);
+		GLM_FUNC_DECL tvec1<T> & operator|=(value_type const & s);
+		GLM_FUNC_DECL tvec1<T> & operator|=(tvec1<T> const & v);
+		GLM_FUNC_DECL tvec1<T> & operator^=(value_type const & s);
+		GLM_FUNC_DECL tvec1<T> & operator^=(tvec1<T> const & v);
+		GLM_FUNC_DECL tvec1<T> & operator<<=(value_type const & s);
+		GLM_FUNC_DECL tvec1<T> & operator<<=(tvec1<T> const & v);
+		GLM_FUNC_DECL tvec1<T> & operator>>=(value_type const & s);
+		GLM_FUNC_DECL tvec1<T> & operator>>=(tvec1<T> const & v);
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		GLM_FUNC_DECL value_type swizzle(comp X) const;
+		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
+		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
+		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
+		GLM_FUNC_DECL tref1<T> swizzle(comp X);
+	};
+
+	template <typename T>
+	struct tref1
+	{
+		GLM_FUNC_DECL tref1(T & x);
+		GLM_FUNC_DECL tref1(tref1<T> const & r);
+		GLM_FUNC_DECL tref1(tvec1<T> const & v);
+
+		GLM_FUNC_DECL tref1<T> & operator= (tref1<T> const & r);
+		GLM_FUNC_DECL tref1<T> & operator= (tvec1<T> const & v);
+
+		T& x;
+	};
+
+	GLM_DETAIL_IS_VECTOR(tvec1);
+
+	typedef detail::tvec1<core::type::precision::highp_float>		highp_vec1_t;
+	typedef detail::tvec1<core::type::precision::mediump_float>		mediump_vec1_t;
+	typedef detail::tvec1<core::type::precision::lowp_float>		lowp_vec1_t;
+	typedef detail::tvec1<core::type::precision::highp_int>			highp_ivec1_t;
+	typedef detail::tvec1<core::type::precision::mediump_int>		mediump_ivec1_t;
+	typedef detail::tvec1<core::type::precision::lowp_int>			lowp_ivec1_t;
+	typedef detail::tvec1<core::type::precision::highp_uint>		highp_uvec1_t;
+	typedef detail::tvec1<core::type::precision::mediump_uint>		mediump_uvec1_t;
+	typedef detail::tvec1<core::type::precision::lowp_uint>			lowp_uvec1_t;
+
+}//namespace detail
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_vec1.inl"
-#endif
+#endif//GLM_EXTERNAL_TEMPLATE
 
 #endif//glm_core_type_gentype1

glm/core/type_vec2.hpp

@@ -16,251 +16,248 @@
 #include "type_size.hpp"
 #include "_swizzle.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
+	template <typename T> struct tref2;
+	template <typename T> struct tref3;
+	template <typename T> struct tref4;
+	template <typename T> struct tvec3;
+	template <typename T> struct tvec4;
+
+	//! The basic 2D vector type.
+	//! \ingroup core_template
+	template <typename T>
+	struct tvec2
 	{
-		void main_vec2();
-	}
-	//namespace test
+		enum ctor{null};
 
-	namespace detail
-	{
-		template <typename T> struct tref2;
-		template <typename T> struct tref3;
-		template <typename T> struct tref4;
-		template <typename T> struct tvec3;
-		template <typename T> struct tvec4;
-
-		//! The basic 2D vector type.
-		//! \ingroup core_template
-		template <typename T>
-		struct tvec2
-		{
-			enum ctor{null};
+		typedef T value_type;
+		typedef std::size_t size_type;
+		GLM_FUNC_DECL size_type length() const;
+		static GLM_FUNC_DECL size_type value_size();
 
-			typedef T value_type;
-			typedef std::size_t size_type;
-			GLM_FUNC_DECL size_type length() const;
-			static GLM_FUNC_DECL size_type value_size();
+		typedef tvec2<T> type;
+		typedef tvec2<bool> bool_type;
 
-			typedef tvec2<T> type;
-			typedef tvec2<bool> bool_type;
-
-			//////////////////////////////////////
-			// Data
+		//////////////////////////////////////
+		// Data
 
 #		if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-			value_type x, y;
+		value_type x, y;
 #		elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT)
-			union 
-			{
-				struct{value_type x, y;};
-				struct{value_type r, g;};
-				struct{value_type s, t;};
-			};
+		union 
+		{
+			struct{value_type x, y;};
+			struct{value_type r, g;};
+			struct{value_type s, t;};
+		};
 #		else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
-			union {value_type x, r, s;};
-			union {value_type y, g, t;};
+		union {value_type x, r, s;};
+		union {value_type y, g, t;};
 #		endif//GLM_COMPONENT
 
-			//////////////////////////////////////
-			// Accesses
-
-			GLM_FUNC_DECL value_type & operator[](size_type i);
-			GLM_FUNC_DECL value_type const & operator[](size_type i) const;
-
-			//////////////////////////////////////
-			// Implicit basic constructors
-
-			GLM_FUNC_DECL tvec2();
-			GLM_FUNC_DECL tvec2(tvec2<T> const & v);
-
-			//////////////////////////////////////
-			// Explicit basic constructors
-
-			GLM_FUNC_DECL explicit tvec2(
-				ctor);
-			GLM_FUNC_DECL explicit tvec2(
-				value_type const & s);
-			GLM_FUNC_DECL explicit tvec2(
-				value_type const & s1, 
-				value_type const & s2);
-
-			//////////////////////////////////////
-			// Swizzle constructors
-
-			tvec2(tref2<T> const & r);
-
-			//////////////////////////////////////
-			// Convertion constructors
-
-			//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-			template <typename U> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
-
-			//////////////////////////////////////
-			// Unary arithmetic operators
-
-			GLM_FUNC_DECL tvec2<T> & operator= (tvec2<T> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator= (tvec2<U> const & v);
-
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator+=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator+=(tvec2<U> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator-=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator-=(tvec2<U> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator*=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator*=(tvec2<U> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator/=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator/=(tvec2<U> const & v);
-			GLM_FUNC_DECL tvec2<T> & operator++();
-			GLM_FUNC_DECL tvec2<T> & operator--();
-
-			//////////////////////////////////////
-			// Unary bit operators
-
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator%= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator%= (tvec2<U> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator&= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator&= (tvec2<U> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator|= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator|= (tvec2<U> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator^= (U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator^= (tvec2<U> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator<<=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator<<=(tvec2<U> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator>>=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec2<T> & operator>>=(tvec2<U> const & v);
-
-			//////////////////////////////////////
-			// Swizzle operators
-
-			GLM_FUNC_DECL value_type swizzle(comp X) const;
-			GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
-			GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-			GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-			GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
-		};
-
-		template <typename T>
-		struct tref2
-		{
-			GLM_FUNC_DECL tref2(T & x, T & y);
-			GLM_FUNC_DECL tref2(tref2<T> const & r);
-			GLM_FUNC_DECL tref2(tvec2<T> const & v);
-
-			GLM_FUNC_DECL tref2<T> & operator= (tref2<T> const & r);
-			GLM_FUNC_DECL tref2<T> & operator= (tvec2<T> const & v);
+		//////////////////////////////////////
+		// Accesses
+
+		GLM_FUNC_DECL value_type & operator[](size_type i);
+		GLM_FUNC_DECL value_type const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		GLM_FUNC_DECL tvec2();
+		GLM_FUNC_DECL tvec2(tvec2<T> const & v);
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		GLM_FUNC_DECL explicit tvec2(
+			ctor);
+		GLM_FUNC_DECL explicit tvec2(
+			value_type const & s);
+		GLM_FUNC_DECL explicit tvec2(
+			value_type const & s1, 
+			value_type const & s2);
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		tvec2(tref2<T> const & r);
+
+		//////////////////////////////////////
+		// Convertion constructors
+
+		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		GLM_FUNC_DECL tvec2<T> & operator= (tvec2<T> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator= (tvec2<U> const & v);
+
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator+=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator+=(tvec2<U> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator-=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator-=(tvec2<U> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator*=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator*=(tvec2<U> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator/=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator/=(tvec2<U> const & v);
+		GLM_FUNC_DECL tvec2<T> & operator++();
+		GLM_FUNC_DECL tvec2<T> & operator--();
+
+		//////////////////////////////////////
+		// Unary bit operators
+
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator%= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator%= (tvec2<U> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator&= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator&= (tvec2<U> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator|= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator|= (tvec2<U> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator^= (U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator^= (tvec2<U> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator<<=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator<<=(tvec2<U> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator>>=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec2<T> & operator>>=(tvec2<U> const & v);
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		GLM_FUNC_DECL value_type swizzle(comp X) const;
+		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
+		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
+		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
+		GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
+	};
+
+	template <typename T>
+	struct tref2
+	{
+		GLM_FUNC_DECL tref2(T & x, T & y);
+		GLM_FUNC_DECL tref2(tref2<T> const & r);
+		GLM_FUNC_DECL tref2(tvec2<T> const & v);
 
-			T& x;
-			T& y;
-		};
+		GLM_FUNC_DECL tref2<T> & operator= (tref2<T> const & r);
+		GLM_FUNC_DECL tref2<T> & operator= (tvec2<T> const & v);
 
-		GLM_DETAIL_IS_VECTOR(tvec2);
+		T& x;
+		T& y;
+	};
 
-	} //namespace detail
+	GLM_DETAIL_IS_VECTOR(tvec2);
 
-	namespace core{
-	namespace type{
+} //namespace detail
 
-	namespace precision
-	{
-		//! 2 components vector of high precision floating-point numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec2<highp_float>		highp_vec2;
-		//! 2 components vector of medium precision floating-point numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec2<mediump_float>	mediump_vec2;
-		//! 2 components vector of low precision floating-point numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec2<lowp_float>		lowp_vec2;
-
-		//! 2 components vector of high precision signed integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec2<highp_int>		highp_ivec2;
-		//! 2 components vector of medium precision signed integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec2<mediump_int>		mediump_ivec2;
-		//! 2 components vector of low precision signed integer numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec2<lowp_int>			lowp_ivec2;
+namespace core{
+namespace type{
+namespace precision
+{
+	//! 2 components vector of high precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec2<highp_float>		highp_vec2;
+
+	//! 2 components vector of medium precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec2<mediump_float>	mediump_vec2;
+
+	//! 2 components vector of low precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec2<lowp_float>		lowp_vec2;
+
+	//! 2 components vector of high precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec2<highp_int>		highp_ivec2;
+
+	//! 2 components vector of medium precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec2<mediump_int>		mediump_ivec2;
+
+	//! 2 components vector of low precision signed integer numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec2<lowp_int>			lowp_ivec2;
 	
-		//! 2 components vector of high precision unsigned integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec2<highp_uint>		highp_uvec2;
-		//! 2 components vector of medium precision unsigned integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec2<mediump_uint>		mediump_uvec2;
-		//! 2 components vector of low precision unsigned integer numbers.
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec2<lowp_uint>		lowp_uvec2;
-	}
-	//namespace precision
-
-	}//namespace type
-	}//namespace core
+	//! 2 components vector of high precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec2<highp_uint>		highp_uvec2;
+
+	//! 2 components vector of medium precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec2<mediump_uint>		mediump_uvec2;
+
+	//! 2 components vector of low precision unsigned integer numbers.
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec2<lowp_uint>		lowp_uvec2;
+
+}//namespace precision
+}//namespace type
+}//namespace core
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_vec2.inl"
-#endif
+#endif//GLM_EXTERNAL_TEMPLATE
 
 #endif//glm_core_type_gentype2

glm/core/type_vec3.hpp

@@ -16,256 +16,254 @@
 #include "type_size.hpp"
 #include "_swizzle.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
-	{
-		void main_vec3();
-	}//namespace test
-
-	namespace detail
-	{
-		template <typename T> struct tref2;
-		template <typename T> struct tref3;
-		template <typename T> struct tref4;
-		template <typename T> struct tvec2;
-		template <typename T> struct tvec4;
-
-		//! Basic 3D vector type.
-		//! \ingroup core_template
-		template <typename T>
-		struct tvec3
-		{	
-			enum ctor{null};
-
-			typedef T value_type;
-			typedef std::size_t size_type;
-			GLM_FUNC_DECL size_type length() const;
-			static GLM_FUNC_DECL size_type value_size();
-
-			typedef tvec3<T> type;
-			typedef tvec3<bool> bool_type;
-
-			//////////////////////////////////////
-			// Data
-
-#		if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-			value_type x, y, z;
-#		elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT)
-			union 
-			{
-				struct{value_type x, y, z;};
-				struct{value_type r, g, b;};
-				struct{value_type s, t, p;};
-			};
-#		else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
-			union {value_type x, r, s;};
-			union {value_type y, g, t;};
-			union {value_type z, b, p;};
-#		endif//GLM_COMPONENT
-
-			//////////////////////////////////////
-			// Accesses
-
-			GLM_FUNC_DECL value_type & operator[](size_type i);
-			GLM_FUNC_DECL value_type const & operator[](size_type i) const;
-
-			//////////////////////////////////////
-			// Implicit basic constructors
-
-			GLM_FUNC_DECL tvec3();
-			GLM_FUNC_DECL tvec3(tvec3<T> const & v);
-
-			//////////////////////////////////////
-			// Explicit basic constructors
-
-			GLM_FUNC_DECL explicit tvec3(
-				ctor);
-			GLM_FUNC_DECL explicit tvec3(
-				value_type const & s);
-			GLM_FUNC_DECL explicit tvec3(
-				value_type const & s1, 
-				value_type const & s2, 
-				value_type const & s3);
-
-			//////////////////////////////////////
-			// Swizzle constructors
-
-			GLM_FUNC_DECL tvec3(tref3<T> 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
-
-			//////////////////////////////////////
-			// Unary arithmetic operators
-
-			GLM_FUNC_DECL tvec3<T> & operator= (tvec3<T> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec3<T> & operator= (tvec3<U> const & v);
-
-			template <typename U> 
-			GLM_FUNC_DECL tvec3<T> & operator+=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec3<T> & operator+=(tvec3<U> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec3<T> & operator-=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec3<T> & operator-=(tvec3<U> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec3<T> & operator*=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec3<T> & operator*=(tvec3<U> const & v);
-			template <typename U> 
-			GLM_FUNC_DECL tvec3<T> & operator/=(U const & s);
-			template <typename U> 
-			GLM_FUNC_DECL tvec3<T> & operator/=(tvec3<U> const & v);
-			GLM_FUNC_DECL tvec3<T> & operator++();
-			GLM_FUNC_DECL tvec3<T> & operator--();
-
-			//////////////////////////////////////
-			// Unary bit operators
-
-			template <typename U>
-			GLM_FUNC_DECL tvec3<T> & operator%= (U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec3<T> & operator%= (tvec3<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec3<T> & operator&= (U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec3<T> & operator&= (tvec3<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec3<T> & operator|= (U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec3<T> & operator|= (tvec3<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec3<T> & operator^= (U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec3<T> & operator^= (tvec3<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec3<T> & operator<<=(U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec3<T> & operator<<=(tvec3<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec3<T> & operator>>=(U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec3<T> & operator>>=(tvec3<U> const & v);
-
-			//////////////////////////////////////
-			// Swizzle operators
-
-			GLM_FUNC_DECL value_type swizzle(comp X) const;
-			GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
-			GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-			GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-			GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
-		};
-
-		template <typename T>
-		struct tref3
+	template <typename T> struct tref2;
+	template <typename T> struct tref3;
+	template <typename T> struct tref4;
+	template <typename T> struct tvec2;
+	template <typename T> struct tvec4;
+
+	//! Basic 3D vector type.
+	//! \ingroup core_template
+	template <typename T>
+	struct tvec3
+	{	
+		enum ctor{null};
+
+		typedef T value_type;
+		typedef std::size_t size_type;
+		GLM_FUNC_DECL size_type length() const;
+		static GLM_FUNC_DECL size_type value_size();
+
+		typedef tvec3<T> type;
+		typedef tvec3<bool> bool_type;
+
+		//////////////////////////////////////
+		// Data
+
+#	if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
+		value_type x, y, z;
+#	elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT)
+		union 
 		{
-			GLM_FUNC_DECL tref3(T & x, T & y, T & z);
-			GLM_FUNC_DECL tref3(tref3<T> const & r);
-			GLM_FUNC_DECL tref3(tvec3<T> const & v);
-
-			GLM_FUNC_DECL tref3<T> & operator= (tref3<T> const & r);
-			GLM_FUNC_DECL tref3<T> & operator= (tvec3<T> const & v);
-
-			T & x;
-			T & y;
-			T & z;
+			struct{value_type x, y, z;};
+			struct{value_type r, g, b;};
+			struct{value_type s, t, p;};
 		};
+#	else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
+		union {value_type x, r, s;};
+		union {value_type y, g, t;};
+		union {value_type z, b, p;};
+#	endif//GLM_COMPONENT
+
+		//////////////////////////////////////
+		// Accesses
+
+		GLM_FUNC_DECL value_type & operator[](size_type i);
+		GLM_FUNC_DECL value_type const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		GLM_FUNC_DECL tvec3();
+		GLM_FUNC_DECL tvec3(tvec3<T> const & v);
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		GLM_FUNC_DECL explicit tvec3(
+			ctor);
+		GLM_FUNC_DECL explicit tvec3(
+			value_type const & s);
+		GLM_FUNC_DECL explicit tvec3(
+			value_type const & s1, 
+			value_type const & s2, 
+			value_type const & s3);
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		GLM_FUNC_DECL tvec3(tref3<T> 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		GLM_FUNC_DECL tvec3<T> & operator= (tvec3<T> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec3<T> & operator= (tvec3<U> const & v);
+
+		template <typename U> 
+		GLM_FUNC_DECL tvec3<T> & operator+=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec3<T> & operator+=(tvec3<U> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec3<T> & operator-=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec3<T> & operator-=(tvec3<U> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec3<T> & operator*=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec3<T> & operator*=(tvec3<U> const & v);
+		template <typename U> 
+		GLM_FUNC_DECL tvec3<T> & operator/=(U const & s);
+		template <typename U> 
+		GLM_FUNC_DECL tvec3<T> & operator/=(tvec3<U> const & v);
+		GLM_FUNC_DECL tvec3<T> & operator++();
+		GLM_FUNC_DECL tvec3<T> & operator--();
+
+		//////////////////////////////////////
+		// Unary bit operators
+
+		template <typename U>
+		GLM_FUNC_DECL tvec3<T> & operator%= (U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec3<T> & operator%= (tvec3<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec3<T> & operator&= (U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec3<T> & operator&= (tvec3<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec3<T> & operator|= (U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec3<T> & operator|= (tvec3<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec3<T> & operator^= (U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec3<T> & operator^= (tvec3<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec3<T> & operator<<=(U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec3<T> & operator<<=(tvec3<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec3<T> & operator>>=(U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec3<T> & operator>>=(tvec3<U> const & v);
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		GLM_FUNC_DECL value_type swizzle(comp X) const;
+		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
+		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
+		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
+		GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
+	};
+
+	template <typename T>
+	struct tref3
+	{
+		GLM_FUNC_DECL tref3(T & x, T & y, T & z);
+		GLM_FUNC_DECL tref3(tref3<T> const & r);
+		GLM_FUNC_DECL tref3(tvec3<T> const & v);
 
-		GLM_DETAIL_IS_VECTOR(tvec3);
-	} //namespace detail
+		GLM_FUNC_DECL tref3<T> & operator= (tref3<T> const & r);
+		GLM_FUNC_DECL tref3<T> & operator= (tvec3<T> const & v);
 
-	namespace core{
-	namespace type{
+		T & x;
+		T & y;
+		T & z;
+	};
 
-	namespace precision
-	{
-		//! 3 components vector of high precision floating-point numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec3<highp_float>		highp_vec3;
-		//! 3 components vector of medium precision floating-point numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec3<mediump_float>	mediump_vec3;
-		//! 3 components vector of low precision floating-point numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec3<lowp_float>		lowp_vec3;
-
-		//! 3 components vector of high precision signed integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec3<highp_int>		highp_ivec3;
-		//! 3 components vector of medium precision signed integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec3<mediump_int>		mediump_ivec3;
-		//! 3 components vector of low precision signed integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec3<lowp_int>			lowp_ivec3;
-
-		//! 3 components vector of high precision unsigned integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec3<highp_uint>		highp_uvec3;
-		//! 3 components vector of medium precision unsigned integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec3<mediump_uint>		mediump_uvec3;
-		//! 3 components vector of low precision unsigned integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec3<lowp_uint>		lowp_uvec3;
-	}
-	//namespace precision
-
-	}//namespace type
-	}//namespace core
+	GLM_DETAIL_IS_VECTOR(tvec3);
+} //namespace detail
+
+namespace core{
+namespace type{
+namespace precision
+{
+	//! 3 components vector of high precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec3<highp_float>		highp_vec3;
+
+	//! 3 components vector of medium precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec3<mediump_float>	mediump_vec3;
+
+	//! 3 components vector of low precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec3<lowp_float>		lowp_vec3;
+
+	//! 3 components vector of high precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec3<highp_int>		highp_ivec3;
+
+	//! 3 components vector of medium precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec3<mediump_int>		mediump_ivec3;
+
+	//! 3 components vector of low precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec3<lowp_int>			lowp_ivec3;
+
+	//! 3 components vector of high precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec3<highp_uint>		highp_uvec3;
+
+	//! 3 components vector of medium precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec3<mediump_uint>		mediump_uvec3;
+
+	//! 3 components vector of low precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec3<lowp_uint>		lowp_uvec3;
+
+}//namespace precision
+}//namespace type
+}//namespace core
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_vec3.inl"
-#endif
+#endif//GLM_EXTERNAL_TEMPLATE
 
 #endif//glm_core_type_gentype3

glm/core/type_vec4.hpp

@@ -16,275 +16,267 @@
 #include "type_size.hpp"
 #include "_swizzle.hpp"
 
-namespace glm
+namespace glm{
+namespace detail
 {
-	namespace test
+	template <typename T> struct tref2;
+	template <typename T> struct tref3;
+	template <typename T> struct tref4;
+	template <typename T> struct tvec2;
+	template <typename T> struct tvec3;
+
+	///Basic 4D vector type.
+	//! \ingroup core_template
+	template <typename T>
+	struct tvec4
 	{
-		void main_vec4();
-	}//namespace test
+		enum ctor{null};
 
-	namespace detail
-	{
-		template <typename T> struct tref2;
-		template <typename T> struct tref3;
-		template <typename T> struct tref4;
-		template <typename T> struct tvec2;
-		template <typename T> struct tvec3;
-
-		///Basic 4D vector type.
-		//! \ingroup core_template
-		template <typename T>
-		struct tvec4
-		{
-			enum ctor{null};
-
-			typedef T value_type;
-			typedef std::size_t size_type;
-			GLM_FUNC_DECL size_type length() const;
-			static GLM_FUNC_DECL size_type value_size();
-
-			typedef tvec4<T> type;
-			typedef tvec4<bool> bool_type;
-
-			//////////////////////////////////////
-			// Data
-
-#		if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
-			value_type x, y, z, w;
-#		elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT)
-			union 
-			{
-				struct{value_type x, y, z, w;};
-				struct{value_type r, g, b, a;};
-				struct{value_type s, t, p, q;};
-			};
-#		else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
-			union {value_type x, r, s;};
-			union {value_type y, g, t;};
-			union {value_type z, b, p;};
-			union {value_type w, a, q;};
-#		endif//GLM_COMPONENT
-
-			//////////////////////////////////////
-			// Accesses
-
-			GLM_FUNC_DECL value_type & operator[](size_type i);
-			GLM_FUNC_DECL value_type const & operator[](size_type i) const;
-
-			//////////////////////////////////////
-			// Implicit basic constructors
-
-			GLM_FUNC_DECL tvec4();
-			GLM_FUNC_DECL tvec4(type const & v);
-
-			//////////////////////////////////////
-			// Explicit basic constructors
-
-			GLM_FUNC_DECL explicit tvec4(
-				ctor);
-			GLM_FUNC_DECL explicit tvec4(
-				value_type const & s);
-			GLM_FUNC_DECL explicit tvec4(
-				value_type const & s0, 
-				value_type const & s1, 
-				value_type const & s2, 
-				value_type const & s3);
-
-			//////////////////////////////////////
-			// Swizzle constructors
-
-			GLM_FUNC_DECL tvec4(tref4<T> 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL 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> 
-			GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
-
-			//////////////////////////////////////
-			// Unary arithmetic operators
-
-			GLM_FUNC_DECL tvec4<T> & operator= (tvec4<T> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator= (tvec4<U> const & v);
-
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator+=(U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator+=(tvec4<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator-=(U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator-=(tvec4<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator*=(U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator*=(tvec4<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator/=(U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator/=(tvec4<U> const & v);
-			GLM_FUNC_DECL tvec4<T> & operator++();
-			GLM_FUNC_DECL tvec4<T> & operator--();
-
-			//////////////////////////////////////
-			// Unary bit operators
-
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator%= (U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator%= (tvec4<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator&= (U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator&= (tvec4<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator|= (U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator|= (tvec4<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator^= (U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator^= (tvec4<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator<<=(U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator<<=(tvec4<U> const & v);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator>>=(U const & s);
-			template <typename U>
-			GLM_FUNC_DECL tvec4<T> & operator>>=(tvec4<U> const & v);
-
-			//////////////////////////////////////
-			// Swizzle operators
-
-			GLM_FUNC_DECL value_type swizzle(comp X) const;
-			GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
-			GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
-			GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
-			GLM_FUNC_DECL tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
-		};
+		typedef T value_type;
+		typedef std::size_t size_type;
+		GLM_FUNC_DECL size_type length() const;
+		static GLM_FUNC_DECL size_type value_size();
 
-		template <typename T>
-		struct tref4
-		{
-			GLM_FUNC_DECL tref4(T & x, T & y, T & z, T & w);
-			GLM_FUNC_DECL tref4(tref4<T> const & r);
-			GLM_FUNC_DECL tref4(tvec4<T> const & v);
+		typedef tvec4<T> type;
+		typedef tvec4<bool> bool_type;
 
-			GLM_FUNC_DECL tref4<T> & operator= (tref4<T> const & r);
-			GLM_FUNC_DECL tref4<T> & operator= (tvec4<T> const & v);
+		//////////////////////////////////////
+		// Data
 
-			T & x;
-			T & y;
-			T & z;
-			T & w;
+#	if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW)
+		value_type x, y, z, w;
+#	elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT)
+		union 
+		{
+			struct{value_type x, y, z, w;};
+			struct{value_type r, g, b, a;};
+			struct{value_type s, t, p, q;};
 		};
+#	else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES)
+		union {value_type x, r, s;};
+		union {value_type y, g, t;};
+		union {value_type z, b, p;};
+		union {value_type w, a, q;};
+#	endif//GLM_COMPONENT
+
+		//////////////////////////////////////
+		// Accesses
+
+		GLM_FUNC_DECL value_type & operator[](size_type i);
+		GLM_FUNC_DECL value_type const & operator[](size_type i) const;
+
+		//////////////////////////////////////
+		// Implicit basic constructors
+
+		GLM_FUNC_DECL tvec4();
+		GLM_FUNC_DECL tvec4(type const & v);
+
+		//////////////////////////////////////
+		// Explicit basic constructors
+
+		GLM_FUNC_DECL explicit tvec4(
+			ctor);
+		GLM_FUNC_DECL explicit tvec4(
+			value_type const & s);
+		GLM_FUNC_DECL explicit tvec4(
+			value_type const & s0, 
+			value_type const & s1, 
+			value_type const & s2, 
+			value_type const & s3);
+
+		//////////////////////////////////////
+		// Swizzle constructors
+
+		GLM_FUNC_DECL tvec4(tref4<T> 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL 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> 
+		GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
+
+		//////////////////////////////////////
+		// Unary arithmetic operators
+
+		GLM_FUNC_DECL tvec4<T> & operator= (tvec4<T> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator= (tvec4<U> const & v);
+
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator+=(U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator+=(tvec4<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator-=(U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator-=(tvec4<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator*=(U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator*=(tvec4<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator/=(U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator/=(tvec4<U> const & v);
+		GLM_FUNC_DECL tvec4<T> & operator++();
+		GLM_FUNC_DECL tvec4<T> & operator--();
+
+		//////////////////////////////////////
+		// Unary bit operators
+
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator%= (U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator%= (tvec4<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator&= (U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator&= (tvec4<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator|= (U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator|= (tvec4<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator^= (U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator^= (tvec4<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator<<=(U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator<<=(tvec4<U> const & v);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator>>=(U const & s);
+		template <typename U>
+		GLM_FUNC_DECL tvec4<T> & operator>>=(tvec4<U> const & v);
+
+		//////////////////////////////////////
+		// Swizzle operators
+
+		GLM_FUNC_DECL value_type swizzle(comp X) const;
+		GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
+		GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
+		GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
+		GLM_FUNC_DECL tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
+	};
+
+	template <typename T>
+	struct tref4
+	{
+		GLM_FUNC_DECL tref4(T & x, T & y, T & z, T & w);
+		GLM_FUNC_DECL tref4(tref4<T> const & r);
+		GLM_FUNC_DECL tref4(tvec4<T> const & v);
 
-		GLM_DETAIL_IS_VECTOR(tvec4);
-	} //namespace detail
-
-	namespace core{
-	namespace type{
+		GLM_FUNC_DECL tref4<T> & operator= (tref4<T> const & r);
+		GLM_FUNC_DECL tref4<T> & operator= (tvec4<T> const & v);
 
-	//////////////////////////
-	// Float definition
+		T & x;
+		T & y;
+		T & z;
+		T & w;
+	};
 
-	namespace precision
-	{
-		//! 4 components vector of high precision floating-point numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec4<highp_float>		highp_vec4;
-		//! 4 components vector of medium precision floating-point numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec4<mediump_float>	mediump_vec4;
-		//! 4 components vector of low precision floating-point numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec4<lowp_float>		lowp_vec4;
-
-		//! 4 components vector of high precision signed integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec4<highp_int>		highp_ivec4;
-		//! 4 components vector of medium precision signed integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec4<mediump_int>		mediump_ivec4;
-		//! 4 components vector of low precision signed integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec4<lowp_int>			lowp_ivec4;
-
-		//! 4 components vector of high precision unsigned integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec4<highp_uint>		highp_uvec4;
-		//! 4 components vector of medium precision unsigned integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec4<mediump_uint>		mediump_uvec4;
-		//! 4 components vector of low precision unsigned integer numbers. 
-		//! There is no guarantee on the actual precision.
-		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
-		//! \ingroup core_precision
-		typedef detail::tvec4<lowp_uint>		lowp_uvec4;
-	}
-	//namespace precision
-
-	}//namespace type
-	}//namespace core
-
-	using namespace core::type;
+	GLM_DETAIL_IS_VECTOR(tvec4);
+}//namespace detail
 
+namespace core{
+namespace type{
+namespace precision
+{
+	//! 4 components vector of high precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec4<highp_float>		highp_vec4;
+
+	//! 4 components vector of medium precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec4<mediump_float>	mediump_vec4;
+
+	//! 4 components vector of low precision floating-point numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec4<lowp_float>		lowp_vec4;
+
+	//! 4 components vector of high precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec4<highp_int>		highp_ivec4;
+
+	//! 4 components vector of medium precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec4<mediump_int>		mediump_ivec4;
+
+	//! 4 components vector of low precision signed integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec4<lowp_int>			lowp_ivec4;
+
+	//! 4 components vector of high precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec4<highp_uint>		highp_uvec4;
+
+	//! 4 components vector of medium precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec4<mediump_uint>		mediump_uvec4;
+
+	//! 4 components vector of low precision unsigned integer numbers. 
+	//! There is no guarantee on the actual precision.
+	//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+	//! \ingroup core_precision
+	typedef detail::tvec4<lowp_uint>		lowp_uvec4;
+
+}//namespace precision
+}//namespace type
+}//namespace core
 }//namespace glm
 
 #ifndef GLM_EXTERNAL_TEMPLATE
 #include "type_vec4.inl"
-#endif
+#endif//GLM_EXTERNAL_TEMPLATE
 
 #endif//glm_core_type_gentype4