Added all precision types for GTC_type_precision

glm/core/func_packing.hpp

@@ -52,7 +52,7 @@ namespace glm
 	//! 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm2x16.xml">GLSL packUnorm2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	uint32 packUnorm2x16(detail::tvec2<float32, defaultp> const & v);
+	uint32 packUnorm2x16(vec2 const & v);
 
 	//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
 	//! Then, the results are packed into the returned 32-bit unsigned integer.
@@ -65,7 +65,7 @@ namespace glm
 	//! 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm2x16.xml">GLSL packSnorm2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	uint32 packSnorm2x16(detail::tvec2<float32, defaultp> const & v);
+	uint32 packSnorm2x16(vec2 const & v);
 
 	//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
 	//! Then, the results are packed into the returned 32-bit unsigned integer.
@@ -78,7 +78,7 @@ namespace glm
 	//! 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	uint32 packUnorm4x8(detail::tvec4<float32, defaultp> const & v);
+	uint32 packUnorm4x8(vec4 const & v);
 
 	//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. 
 	//! Then, the results are packed into the returned 32-bit unsigned integer.
@@ -91,7 +91,7 @@ namespace glm
 	//! 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	uint32 packSnorm4x8(detail::tvec4<float32, defaultp> const & v);
+	uint32 packSnorm4x8(vec4 const & v);
 
 	//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
 	//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
@@ -104,7 +104,7 @@ namespace glm
 	//! 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	detail::tvec2<float32, defaultp> unpackUnorm2x16(uint32 const & p);
+	vec2 unpackUnorm2x16(uint32 const & p);
 
 	//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
 	//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
@@ -117,7 +117,7 @@ namespace glm
 	//! 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm2x16.xml">GLSL unpackSnorm2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	detail::tvec2<float32, defaultp> unpackSnorm2x16(uint32 const & p);
+	vec2 unpackSnorm2x16(uint32 const & p);
 
 	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
 	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
@@ -130,7 +130,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	detail::tvec4<float32, defaultp> unpackUnorm4x8(uint32 const & p);
+	vec4 unpackUnorm4x8(uint32 const & p);
 
 	/// First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. 
 	/// Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
@@ -143,7 +143,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	detail::tvec4<float32, defaultp> unpackSnorm4x8(uint32 const & p);
+	vec4 unpackSnorm4x8(uint32 const & p);
 
 	/// Returns a double-precision value obtained by packing the components of v into a 64-bit value. 
 	/// If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. 
@@ -153,7 +153,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packDouble2x32.xml">GLSL packDouble2x32 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	double packDouble2x32(detail::tvec2<uint32, defaultp> const & v);
+	double packDouble2x32(uvec2 const & v);
 
 	/// Returns a two-component unsigned integer vector representation of v. 
 	/// The bit-level representation of v is preserved. 
@@ -162,7 +162,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackDouble2x32.xml">GLSL unpackDouble2x32 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	detail::tvec2<uint32, defaultp> unpackDouble2x32(double const & v);
+	uvec2 unpackDouble2x32(double const & v);
 
 	/// Returns an unsigned integer obtained by converting the components of a two-component floating-point vector 
 	/// to the 16-bit floating-point representation found in the OpenGL Specification, 
@@ -172,7 +172,7 @@ namespace glm
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packHalf2x16.xml">GLSL packHalf2x16 man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.4 Floating-Point Pack and Unpack Functions</a>
-	uint packHalf2x16(detail::tvec2<float32, defaultp> const & v);
+	uint packHalf2x16(vec2 const & v);
 	
 	/// Returns a two-component floating-point vector with components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values, 
 	/// interpreting those values as 16-bit floating-point numbers according to the OpenGL Specification, 

glm/core/func_packing.inl

@@ -28,24 +28,24 @@
 
 namespace glm
 {
-	GLM_FUNC_QUALIFIER uint32 packUnorm2x16(detail::tvec2<float32, defaultp> const & v)
+	GLM_FUNC_QUALIFIER uint32 packUnorm2x16(vec2 const & v)
 	{
 		uint16 A(uint16(round(clamp(v.x, 0.0f, 1.0f) * 65535.0f)));
 		uint16 B(uint16(round(clamp(v.y, 0.0f, 1.0f) * 65535.0f)));
 		return uint32((B << 16) | A);
 	}
 
-	GLM_FUNC_QUALIFIER detail::tvec2<float32, defaultp> unpackUnorm2x16(uint32 const & p)
+	GLM_FUNC_QUALIFIER vec2 unpackUnorm2x16(uint32 const & p)
 	{
 		uint32 Mask16((1 << 16) - 1);
 		uint32 A((p >>  0) & Mask16);
 		uint32 B((p >> 16) & Mask16);
-		return detail::tvec2<float32, defaultp>(
+		return vec2(
 			A * 1.0f / 65535.0f,
 			B * 1.0f / 65535.0f);
 	}
 	
-	GLM_FUNC_QUALIFIER uint32 packSnorm2x16(detail::tvec2<float32, defaultp> const & v)
+	GLM_FUNC_QUALIFIER uint32 packSnorm2x16(vec2 const & v)
 	{
 		union iu
 		{
@@ -53,14 +53,14 @@ namespace glm
 			uint16 u;
 		} A, B;
 		
-		detail::tvec2<float32, defaultp> Unpack = clamp(v ,-1.0f, 1.0f) * 32767.0f;
+		vec2 Unpack = clamp(v ,-1.0f, 1.0f) * 32767.0f;
 		A.i = detail::int16(round(Unpack.x));
 		B.i = detail::int16(round(Unpack.y));
 		uint32 Pack = (uint32(B.u) << 16) | (uint32(A.u) << 0);
 		return Pack;
 	}
 
-	GLM_FUNC_QUALIFIER detail::tvec2<float32, defaultp> unpackSnorm2x16(uint32 const & p)
+	GLM_FUNC_QUALIFIER vec2 unpackSnorm2x16(uint32 const & p)
 	{
 		union iu
 		{
@@ -71,12 +71,12 @@ namespace glm
 		uint32 Mask16((1 << 16) - 1);
 		A.u = uint16((p >>  0) & Mask16);
 		B.u = uint16((p >> 16) & Mask16);
-		detail::tvec2<float32, defaultp> Pack(A.i, B.i);
+		glm::vec2 Pack(A.i, B.i);
 		
 		return clamp(Pack * 1.0f / 32767.0f, -1.0f, 1.0f);
 	}
 
-	GLM_FUNC_QUALIFIER uint32 packUnorm4x8(detail::tvec4<float32, defaultp> const & v)
+	GLM_FUNC_QUALIFIER uint32 packUnorm4x8(vec4 const & v)
 	{
 		uint8 A((uint8)round(clamp(v.x, 0.0f, 1.0f) * 255.0f));
 		uint8 B((uint8)round(clamp(v.y, 0.0f, 1.0f) * 255.0f));
@@ -85,21 +85,21 @@ namespace glm
 		return uint32((D << 24) | (C << 16) | (B << 8) | A);
 	}
 
-	GLM_FUNC_QUALIFIER detail::tvec4<float32, defaultp> unpackUnorm4x8(uint32 const & p)
+	GLM_FUNC_QUALIFIER vec4 unpackUnorm4x8(uint32 const & p)
 	{	
 		uint32 Mask8((1 << 8) - 1);
 		uint32 A((p >>  0) & Mask8);
 		uint32 B((p >>  8) & Mask8);
 		uint32 C((p >> 16) & Mask8);
 		uint32 D((p >> 24) & Mask8);
-		return detail::tvec4<float32, defaultp>(
+		return glm::vec4(
 			A * 1.0f / 255.0f, 
 			B * 1.0f / 255.0f, 
 			C * 1.0f / 255.0f, 
 			D * 1.0f / 255.0f);
 	}
 	
-	GLM_FUNC_QUALIFIER uint32 packSnorm4x8(detail::tvec4<float32, defaultp> const & v)
+	GLM_FUNC_QUALIFIER uint32 packSnorm4x8(vec4 const & v)
 	{
 		union iu
 		{
@@ -107,7 +107,7 @@ namespace glm
 			uint8 u;
 		} A, B, C, D;
 	
-		detail::tvec4<float32, defaultp> Unpack = clamp(v ,-1.0f, 1.0f) * 127.0f;
+		glm::vec4 Unpack = clamp(v ,-1.0f, 1.0f) * 127.0f;
 		A.i = int8(round(Unpack.x));
 		B.i = int8(round(Unpack.y));
 		C.i = int8(round(Unpack.z));
@@ -116,7 +116,7 @@ namespace glm
 		return Pack;
 	}
 	
-	GLM_FUNC_QUALIFIER detail::tvec4<float32, defaultp> unpackSnorm4x8(uint32 const & p)
+	GLM_FUNC_QUALIFIER glm::vec4 unpackSnorm4x8(uint32 const & p)
 	{	
 		union iu
 		{
@@ -129,12 +129,12 @@ namespace glm
 		B.u = uint8((p >>  8) & Mask8);
 		C.u = uint8((p >> 16) & Mask8);
 		D.u = uint8((p >> 24) & Mask8);
-		detail::tvec4<float32, defaultp> Pack(A.i, B.i, C.i, D.i);
+		glm::vec4 Pack(A.i, B.i, C.i, D.i);
 	
 		return clamp(Pack * 1.0f / 127.0f, -1.0f, 1.0f);
 	}
 
-	GLM_FUNC_QUALIFIER double packDouble2x32(detail::tvec2<uint32, defaultp> const & v)
+	GLM_FUNC_QUALIFIER double packDouble2x32(uvec2 const & v)
 	{
 		struct uint32_pair
 		{
@@ -155,7 +155,7 @@ namespace glm
 		//return *(double*)&v;
 	}
 
-	GLM_FUNC_QUALIFIER detail::tvec2<uint, defaultp> unpackDouble2x32(double const & v)
+	GLM_FUNC_QUALIFIER uvec2 unpackDouble2x32(double const & v)
 	{
 		struct uint32_pair
 		{
@@ -171,10 +171,10 @@ namespace glm
 
 		Helper.input = v;
 
-		return detail::tvec2<uint, defaultp>(Helper.output.x, Helper.output.y);
+		return uvec2(Helper.output.x, Helper.output.y);
 	}
 
-	GLM_FUNC_QUALIFIER uint packHalf2x16(detail::tvec2<float, defaultp> const & v)
+	GLM_FUNC_QUALIFIER uint packHalf2x16(vec2 const & v)
 	{
 		union helper
 		{

glm/core/precision.hpp

@@ -39,16 +39,6 @@ namespace glm
 	};
 }//namespace glm
 
-#if(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
-#define defaultp		mediump
-#elif(defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
 #define defaultp		highp
-#elif(!defined(GLM_PRECISION_HIGHP_INT) && defined(GLM_PRECISION_MEDIUMP_INT) && !defined(GLM_PRECISION_LOWP_INT))
-#define defaultp		mediump
-#elif(!defined(GLM_PRECISION_HIGHP_INT) && !defined(GLM_PRECISION_MEDIUMP_INT) && defined(GLM_PRECISION_LOWP_INT))
-#define defaultp		lowp
-#else
-#	error "GLM error: multiple default precision requested for signed interger types"
-#endif
 
 #endif//GLM_CORE_PRECISION_INCLUDED

glm/core/type_mat2x2.hpp

@@ -73,10 +73,10 @@ namespace detail
 		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 & 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 & v1,
 			col_type const & v2);
 
 		//////////////////////////////////////
@@ -85,20 +85,20 @@ namespace detail
 		GLM_FUNC_DECL explicit tmat2x2(
 			U const & x);
 
-		template <typename U, typename V, typename M, typename N> 
+		template <typename U, typename V, typename M, typename N>
 		GLM_FUNC_DECL explicit tmat2x2(
-			U const & x1, V const & y1, 
+			U const & x1, V const & y1,
 			M const & x2, N const & y2);
 			
-		template <typename U, typename V> 
+		template <typename U, typename V>
 		GLM_FUNC_DECL explicit tmat2x2(
 			tvec2<U, P> const & v1,
 			tvec2<V, P> const & v2);
 
 		//////////////////////////////////////
 		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U, P> const & m);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T, P> const & x);

glm/core/type_mat2x2.inl

@@ -174,10 +174,10 @@ namespace detail
 	// mat2x2 matrix conversions
 
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P>::tmat2x2
 	(
-		tmat2x2<U, P> const & m
+		tmat2x2<U, Q> const & m
 	)
 	{
 		this->value[0] = col_type(m[0]);
@@ -281,7 +281,7 @@ namespace detail
 	// mat2x2 operators
 
 	// This function shouldn't required but it seems that VC7.1 have an optimisation bug if this operator wasn't declared
-	template <typename T, precision P> 
+	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator=
 	(
 		tmat2x2<T, P> const & m
@@ -292,8 +292,8 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	template <typename U> 
+	template <typename T, precision P>
+	template <typename U>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator=
 	(
 		tmat2x2<U, P> const & m
@@ -304,8 +304,8 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	template <typename U> 
+	template <typename T, precision P>
+	template <typename U>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator+=
 	(
 		U const & s
@@ -316,8 +316,8 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	template <typename U> 
+	template <typename T, precision P>
+	template <typename U>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator+=
 	(
 		tmat2x2<U, P> const & m
@@ -328,8 +328,8 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	template <typename U> 
+	template <typename T, precision P>
+	template <typename U>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-=
 	(
 		U const & s
@@ -340,8 +340,8 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	template <typename U> 
+	template <typename T, precision P>
+	template <typename U>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-=
 	(
 		tmat2x2<U, P> const & m
@@ -352,9 +352,9 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*= 
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*=
 	(
 		U const & s
 	)
@@ -364,9 +364,9 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*= 
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator*=
 	(
 		tmat2x2<U, P> const & m
 	)
@@ -374,9 +374,9 @@ namespace detail
 		return (*this = *this * m);
 	}
 
-	template <typename T, precision P> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/= 
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/=
 	(
 		U const & s
 	)
@@ -386,9 +386,9 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P> 
-	template <typename U> 
-	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/= 
+	template <typename T, precision P>
+	template <typename U>
+	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator/=
 	(
 		tmat2x2<U, P> const & m
 	)
@@ -396,7 +396,7 @@ namespace detail
 		return (*this = *this / m);
 	}
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator++ ()
 	{
 		++this->value[0];
@@ -404,7 +404,7 @@ namespace detail
 		return *this;
 	}
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat2x2<T, P>& tmat2x2<T, P>::operator-- ()
 	{
 		--this->value[0];
@@ -416,9 +416,9 @@ namespace detail
 	// Binary operators
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+ 
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+
 	(
-		tmat2x2<T, P> const & m, 
+		tmat2x2<T, P> const & m,
 		typename tmat2x2<T, P>::value_type const & s
 	)
 	{
@@ -428,9 +428,9 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+ 
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+
 	(
-		typename tmat2x2<T, P>::value_type const & s, 
+		typename tmat2x2<T, P>::value_type const & s,
 		tmat2x2<T, P> const & m
 	)
 	{
@@ -440,9 +440,9 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+ 
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator+
 	(
-		tmat2x2<T, P> const & m1, 
+		tmat2x2<T, P> const & m1,
 		tmat2x2<T, P> const & m2
 	)
 	{
@@ -452,9 +452,9 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator- 
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-
 	(
-		tmat2x2<T, P> const & m, 
+		tmat2x2<T, P> const & m,
 		typename tmat2x2<T, P>::value_type const & s
 	)
 	{
@@ -464,9 +464,9 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator- 
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-
 	(
-		typename tmat2x2<T, P>::value_type const & s, 
+		typename tmat2x2<T, P>::value_type const & s,
 		tmat2x2<T, P> const & m
 	)
 	{
@@ -476,9 +476,9 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator- 
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator-
 	(
-		tmat2x2<T, P> const & m1, 
+		tmat2x2<T, P> const & m1,
 		tmat2x2<T, P> const & m2
 	)
 	{
@@ -488,9 +488,9 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator* 
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*
 	(
-		tmat2x2<T, P> const & m, 
+		tmat2x2<T, P> const & m,
 		typename tmat2x2<T, P>::value_type const & s
 	)
 	{
@@ -500,9 +500,9 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator* 
+	GLM_FUNC_QUALIFIER tmat2x2<T, P> operator*
 	(	
-		typename tmat2x2<T, P>::value_type const & s, 
+		typename tmat2x2<T, P>::value_type const & s,
 		tmat2x2<T, P> const & m
 	)
 	{
@@ -514,7 +514,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::col_type operator*
 	(
-		tmat2x2<T, P> const & m, 
+		tmat2x2<T, P> const & m,
 		typename tmat2x2<T, P>::row_type const & v
 	)
 	{
@@ -526,7 +526,7 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER typename tmat2x2<T, P>::row_type operator*
 	(
-		typename tmat2x2<T, P>::col_type const & v, 
+		typename tmat2x2<T, P>::col_type const & v,
 		tmat2x2<T, P> const & m
 	)
 	{

glm/core/type_mat2x3.hpp

@@ -89,8 +89,8 @@ namespace detail
 
 		//////////////////////////////////////
 		// Matrix conversion
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U, P> const & m);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T, P> const & x);

glm/core/type_mat2x3.inl

@@ -175,10 +175,10 @@ namespace detail
 	// Matrix conversions
 
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tmat2x3<T, P>::tmat2x3
 	(
-		tmat2x3<U, P> const & m
+		tmat2x3<U, Q> const & m
 	)
 	{
 		this->value[0] = col_type(m[0]);

glm/core/type_mat2x4.hpp

@@ -91,8 +91,8 @@ namespace detail
 
 		//////////////////////////////////////
 		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U, P> const & m);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T, P> const & x);
@@ -156,19 +156,19 @@ namespace detail
 		tmat2x4<T, P> const & m, 
 		typename tmat2x4<T, P>::value_type const & s);
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
 	tmat2x4<T, P> operator* (
-		typename tmat2x4<T, P>::value_type const & s, 
+		typename tmat2x4<T, P>::value_type const & s,
 		tmat2x4<T, P> const & m);
 
 	template <typename T, precision P>
 	typename tmat2x4<T, P>::col_type operator* (
-		tmat2x4<T, P> const & m, 
+		tmat2x4<T, P> const & m,
 		typename tmat2x4<T, P>::row_type const & v);
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
 	typename tmat2x4<T, P>::row_type operator* (
-		typename tmat2x4<T, P>::col_type const & v, 
+		typename tmat2x4<T, P>::col_type const & v,
 		tmat2x4<T, P> const & m);
 
 	template <typename T, precision P>
@@ -178,30 +178,30 @@ namespace detail
 		
 	template <typename T, precision P>
 	tmat2x4<T, P> operator* (
-		tmat2x4<T, P> const & m1, 
+		tmat2x4<T, P> const & m1,
 		tmat2x2<T, P> const & m2);
 		
 	template <typename T, precision P>
 	tmat3x4<T, P> operator* (
-		tmat2x4<T, P> const & m1, 
+		tmat2x4<T, P> const & m1,
 		tmat3x2<T, P> const & m2);
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
 	tmat2x4<T, P> operator/ (
-		tmat2x4<T, P> const & m, 
+		tmat2x4<T, P> const & m,
 		typename tmat2x4<T, P>::value_type const & s);
 
 	template <typename T, precision P> 
 	tmat2x4<T, P> operator/ (
-		typename tmat2x4<T, P>::value_type const & s, 
+		typename tmat2x4<T, P>::value_type const & s,
 		tmat2x4<T, P> const & m);
 
 	// Unary constant operators
-	template <typename T, precision P> 
+	template <typename T, precision P>
 	tmat2x4<T, P> const operator-  (
 		tmat2x4<T, P> const & m);
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
 	tmat2x4<T, P> const operator-- (
 		tmat2x4<T, P> const & m, 
 		int);

glm/core/type_mat2x4.inl

@@ -178,10 +178,10 @@ namespace detail
 	// Matrix conversions
 
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tmat2x4<T, P>::tmat2x4
 	(
-		tmat2x4<U, P> const & m
+		tmat2x4<U, Q> const & m
 	)
 	{
 		this->value[0] = col_type(m[0]);

glm/core/type_mat3x2.hpp

@@ -97,8 +97,8 @@ namespace detail
 			tvec2<V3, P> const & v3);
 
 		// Matrix conversions
-		template <typename U>
-		GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U, P> const & m);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T, P> const & x);

glm/core/type_mat3x2.inl

@@ -188,10 +188,10 @@ namespace detail
 	// mat3x2 matrix conversions
 
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tmat3x2<T, P>::tmat3x2
 	(
-		tmat3x2<U, P> const & m
+		tmat3x2<U, Q> const & m
 	)
 	{
 		this->value[0] = col_type(m[0]);

glm/core/type_mat3x3.hpp

@@ -103,8 +103,8 @@ namespace detail
 			tvec3<V3, P> const & v3);
 
 		// Matrix conversions
-		template <typename U>
-		GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U, P> const & m);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T, P> const & x);

glm/core/type_mat3x3.inl

@@ -191,10 +191,10 @@ namespace detail
 	// Conversions
 
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tmat3x3<T, P>::tmat3x3
 	(
-		tmat3x3<U, P> const & m
+		tmat3x3<U, Q> const & m
 	)
 	{
 		this->value[0] = col_type(m[0]);

glm/core/type_mat3x4.hpp

@@ -97,8 +97,8 @@ namespace detail
 			tvec4<V3, P> const & v3);
 
 		// Matrix conversion
-		template <typename U>
-		GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U, P> const & m);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T, P> const & x);

glm/core/type_mat3x4.inl

@@ -126,7 +126,7 @@ namespace detail
 		this->value[2] = col_type(x2, y2, z2, w2);
 	}
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4
 	(
 		col_type const & v0,
@@ -187,10 +187,10 @@ namespace detail
 
 	// Conversion
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tmat3x4<T, P>::tmat3x4
 	(
-		tmat3x4<U, P> const & m
+		tmat3x4<U, Q> const & m
 	)
 	{
 		this->value[0] = col_type(m[0]);

glm/core/type_mat4x2.hpp

@@ -102,8 +102,8 @@ namespace detail
 			tvec2<V4, P> const & v4);
 
 		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U, P> const & m);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U, Q> const & m);
 			
 		GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T, P> const & x);

glm/core/type_mat4x2.inl

@@ -202,10 +202,10 @@ namespace detail
 
 	// Conversion
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tmat4x2<T, P>::tmat4x2
 	(
-		tmat4x2<U, P> const & m
+		tmat4x2<U, Q> const & m
 	)
 	{
 		this->value[0] = col_type(m[0]);

glm/core/type_mat4x3.hpp

@@ -77,7 +77,7 @@ namespace detail
 
 		//////////////////////////////////////
 		// Conversions
-		template <typename U> 
+		template <typename U>
 		GLM_FUNC_DECL explicit tmat4x3(
 			U const & x);
 
@@ -100,8 +100,8 @@ namespace detail
 			tvec3<V4, P> const & v4);
 
 		// Matrix conversions
-		template <typename U>
-		GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U, P> const & m);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U, Q> const & m);
 			
 		GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T, P> const & x);

glm/core/type_mat4x3.inl

@@ -204,10 +204,10 @@ namespace detail
 	// Matrix conversions
 
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
 	(
-		tmat4x3<U, P> const & m
+		tmat4x3<U, Q> const & m
 	)
 	{
 		this->value[0] = col_type(m[0]);
@@ -240,7 +240,7 @@ namespace detail
 		this->value[3] = col_type(value_type(0));
 	}
 
-	template <typename T, precision P> 
+	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tmat4x3<T, P>::tmat4x3
 	(
 		tmat4x4<T, P> const & m

glm/core/type_mat4x4.hpp

@@ -106,8 +106,8 @@ namespace detail
 			tvec4<V4, P> const & v4);
 	
 		// Matrix conversions
-		template <typename U> 
-		GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U, P> const & m);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U, Q> const & m);
 
 		GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T, P> const & x);
 		GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T, P> const & x);

glm/core/type_mat4x4.inl

@@ -149,10 +149,10 @@ namespace detail
 	}
 
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tmat4x4<T, P>::tmat4x4
 	(
-		tmat4x4<U, P> const & m
+		tmat4x4<U, Q> const & m
 	)
 	{
 		this->value[0] = col_type(m[0]);

glm/core/type_vec1.hpp

@@ -86,21 +86,24 @@ namespace detail
 		// Convertion scalar constructors
 
 		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
+		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, P> const & v);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tvec1(tvec1<U, Q> 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, P> const & v);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tvec1(tvec2<U, Q> 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, P> const & v);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tvec1(tvec3<U, Q> const & v);
+		//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tvec1(tvec4<U, Q> const & v);
 
 		//////////////////////////////////////
 		// Unary arithmetic operators

glm/core/type_vec1.inl

@@ -119,28 +119,37 @@ namespace detail
 	// Convertion vector constructors
 
 	template <typename T, precision P>
-	template <typename U> 
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
 	(
-		tvec2<U, P> const & v
+		tvec1<U, Q> const & v
 	) :
 		x(value_type(v.x))
 	{}
 
 	template <typename T, precision P>
-	template <typename U> 
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
 	(
-		tvec3<U, P> const & v
+		tvec2<U, Q> const & v
 	) :
 		x(value_type(v.x))
 	{}
 
 	template <typename T, precision P>
-	template <typename U> 
+	template <typename U, precision Q>
+	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
+	(
+		tvec3<U, Q> const & v
+	) :
+		x(value_type(v.x))
+	{}
+
+	template <typename T, precision P>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tvec1<T, P>::tvec1
 	(
-		tvec4<U, P> const & v
+		tvec4<U, Q> const & v
 	) :
 		x(value_type(v.x))
 	{}

glm/core/type_vec2.hpp

@@ -131,23 +131,23 @@ namespace detail
 		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> 
+		template <typename U, typename V>
 		GLM_FUNC_DECL explicit tvec2(
-			U const & x, 
+			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, P> const & v);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tvec2(tvec2<U, Q> 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, P> const & v);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tvec2(tvec3<U, Q> 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, P> const & v);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tvec2(tvec4<U, Q> const & v);
 
 		//////////////////////////////////////
 		// Unary arithmetic operators

glm/core/type_vec2.inl

@@ -139,30 +139,30 @@ namespace detail
 	// Convertion vector constructors
 
 	template <typename T, precision P>
-	template <typename U> 
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
 	(
-		tvec2<U, P> const & v
+		tvec2<U, Q> const & v
 	) :
 		x(value_type(v.x)),
 		y(value_type(v.y))
 	{}
 
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
 	(
-		tvec3<U, P> const & v
+		tvec3<U, Q> const & v
 	) :
 		x(value_type(v.x)),
 		y(value_type(v.y))
 	{}
 
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tvec2<T, P>::tvec2
 	(
-		tvec4<U, P> const & v
+		tvec4<U, Q> const & v
 	) :
 		x(value_type(v.x)),
 		y(value_type(v.y))

glm/core/type_vec3.hpp

@@ -110,8 +110,8 @@ namespace detail
 		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 & s1,
+			value_type const & s2,
 			value_type const & s3);
 
 		//////////////////////////////////////
@@ -132,17 +132,17 @@ namespace detail
 		// 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, P> const & v, B const & s);
+		template <typename A, typename B, precision Q>
+		GLM_FUNC_DECL explicit tvec3(tvec2<A, Q> 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, P> const & v);
+		template <typename A, typename B, precision Q>
+		GLM_FUNC_DECL explicit tvec3(A const & s, tvec2<B, Q> 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, P> const & v);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tvec3(tvec3<U, Q> 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, P> const & v);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tvec3(tvec4<U, Q> const & v);
 
 		//////////////////////////////////////
 		// Swizzle constructors

glm/core/type_vec3.inl

@@ -95,8 +95,8 @@ namespace detail
 	template <typename T, precision P>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
 	(
-		value_type const & s0, 
-		value_type const & s1, 
+		value_type const & s0,
+		value_type const & s1,
 		value_type const & s2
 	) :
 		x(s0),
@@ -118,7 +118,7 @@ namespace detail
 	{}
 
 	template <typename T, precision P>
-	template <typename A, typename B> 
+	template <typename A, typename B>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
 	(
 		tref2<A, P> const & v,
@@ -130,7 +130,7 @@ namespace detail
 	{}
 
 	template <typename T, precision P>
-	template <typename A, typename B> 
+	template <typename A, typename B>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
 	(
 		A const & s,
@@ -145,7 +145,7 @@ namespace detail
 	// Convertion scalar constructors
 		
 	template <typename T, precision P>
-	template <typename U> 
+	template <typename U>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
 	(
 		U const & s
@@ -156,7 +156,7 @@ namespace detail
 	{}
 
 	template <typename T, precision P>
-	template <typename A, typename B, typename C> 
+	template <typename A, typename B, typename C>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
 	(
 		A const & x,
@@ -172,10 +172,10 @@ namespace detail
 	// Convertion vector constructors
 
 	template <typename T, precision P>
-	template <typename A, typename B> 
+	template <typename A, typename B, precision Q>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
 	(
-		tvec2<A, P> const & v,
+		tvec2<A, Q> const & v,
 		B const & s
 	) :
 		x(value_type(v.x)),
@@ -184,11 +184,11 @@ namespace detail
 	{}
 
 	template <typename T, precision P>
-	template <typename A, typename B>
+	template <typename A, typename B, precision Q>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
 	(	
 		A const & s,
-		tvec2<B, P> const & v
+		tvec2<B, Q> const & v
 	) :
 		x(value_type(s)),
 		y(value_type(v.x)),
@@ -196,10 +196,10 @@ namespace detail
 	{}
 
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
 	(
-		tvec3<U, P> const & v
+		tvec3<U, Q> const & v
 	) :
 		x(value_type(v.x)),
 		y(value_type(v.y)),
@@ -207,10 +207,10 @@ namespace detail
 	{}
 
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tvec3<T, P>::tvec3
 	(
-		tvec4<U, P> const & v
+		tvec4<U, Q> const & v
 	) :
 		x(value_type(v.x)),
 		y(value_type(v.y)),

glm/core/type_vec4.hpp

@@ -111,50 +111,50 @@ namespace detail
 		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 & s0,
+			value_type const & s1,
+			value_type const & s2,
 			value_type const & s3);
 
 		//////////////////////////////////////
 		// Convertion scalar constructors
 
 		//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
-		template <typename U> 
+		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> 
+		template <typename A, typename B, typename C, typename D>
 		GLM_FUNC_DECL explicit tvec4(
-			A const & x, 
-			B const & y, 
-			C const & z, 
+			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, P> const & v, B const & s1, C const & s2);
+		template <typename A, typename B, typename C, precision Q>
+		GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> 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, P> const & v, C const & s2);
+		template <typename A, typename B, typename C, precision Q>
+		GLM_FUNC_DECL explicit tvec4(A const & s1, tvec2<B, Q> 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, P> const & v);
+		template <typename A, typename B, typename C, precision Q>
+		GLM_FUNC_DECL explicit tvec4(A const & s1, B const & s2, tvec2<C, Q> 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, P> const & v, B const & s);
+		template <typename A, typename B, precision Q>
+		GLM_FUNC_DECL explicit tvec4(tvec3<A, Q> 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, P> const & v);
+		template <typename A, typename B, precision Q>
+		GLM_FUNC_DECL explicit tvec4(A const & s, tvec3<B, Q> 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, P> const & v1, tvec2<B, P> const & v2);
+		template <typename A, typename B, precision Q>
+		GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & v1, tvec2<B, Q> 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, P> const & v);
+		template <typename U, precision Q>
+		GLM_FUNC_DECL explicit tvec4(tvec4<U, Q> const & v);
 
 		template <int E0, int E1, int E2, int E3>
 		GLM_FUNC_DECL tvec4(glm::detail::swizzle<4, T, tvec4<T, P>, E0, E1, E2, E3> const & that)

glm/core/type_vec4.inl

@@ -270,10 +270,10 @@ namespace detail
 	// Convertion vector constructors
 
 	template <typename T, precision P>
-	template <typename A, typename B, typename C>
+	template <typename A, typename B, typename C, precision Q>
 	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
 	(
-		tvec2<A, P> const & v,
+		tvec2<A, Q> const & v,
 		B const & s1,
 		C const & s2
 	) :
@@ -284,11 +284,11 @@ namespace detail
 	{}
 
 	template <typename T, precision P>
-	template <typename A, typename B, typename C>
+	template <typename A, typename B, typename C, precision Q>
 	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
 	(
 		A const & s1,
-		tvec2<B, P> const & v,
+		tvec2<B, Q> const & v,
 		C const & s2
 	) :
 		x(value_type(s1)),
@@ -298,12 +298,12 @@ namespace detail
 	{}
 
 	template <typename T, precision P>
-	template <typename A, typename B, typename C>
+	template <typename A, typename B, typename C, precision Q>
 	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
 	(
 		A const & s1,
 		B const & s2,
-		tvec2<C, P> const & v
+		tvec2<C, Q> const & v
 	) :
 		x(value_type(s1)),
 		y(value_type(s2)),
@@ -312,10 +312,10 @@ namespace detail
 	{}
 
 	template <typename T, precision P>
-	template <typename A, typename B>
+	template <typename A, typename B, precision Q>
 	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
 	(
-		tvec3<A, P> const & v,
+		tvec3<A, Q> const & v,
 		B const & s
 	) :
 		x(value_type(v.x)),
@@ -325,11 +325,11 @@ namespace detail
 	{}
 
 	template <typename T, precision P>
-	template <typename A, typename B>
+	template <typename A, typename B, precision Q>
 	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
 	(
 		A const & s,
-		tvec3<B, P> const & v
+		tvec3<B, Q> const & v
 	) :
 		x(value_type(s)),
 		y(value_type(v.x)),
@@ -338,11 +338,11 @@ namespace detail
 	{}
 
 	template <typename T, precision P>
-	template <typename A, typename B>
+	template <typename A, typename B, precision Q>
 	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
 	(
-		tvec2<A, P> const & v1,
-		tvec2<B, P> const & v2
+		tvec2<A, Q> const & v1,
+		tvec2<B, Q> const & v2
 	) :
 		x(value_type(v1.x)),
 		y(value_type(v1.y)),
@@ -351,10 +351,10 @@ namespace detail
 	{}
 
 	template <typename T, precision P>
-	template <typename U>
+	template <typename U, precision Q>
 	GLM_FUNC_QUALIFIER tvec4<T, P>::tvec4
 	(
-		tvec4<U, P> const & v
+		tvec4<U, Q> const & v
 	) :
 		x(value_type(v.x)),
 		y(value_type(v.y)),

glm/fwd.hpp

@@ -157,7 +157,152 @@ namespace glm
 {
 	/// @addtogroup gtc_type_precision
 	/// @{
+
+	/// Low precision 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 lowp_int8;
+	
+	/// Low precision 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 lowp_int16;
+
+	/// Low precision 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 lowp_int32;
+
+	/// Low precision 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 lowp_int64;
+
+	/// Low precision 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 lowp_int8_t;
+	
+	/// Low precision 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 lowp_int16_t;
+
+	/// Low precision 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 lowp_int32_t;
+
+	/// Low precision 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 lowp_int64_t;
+
+	/// Low precision 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 lowp_i8;
+	
+	/// Low precision 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 lowp_i16;
+
+	/// Low precision 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 lowp_i32;
+
+	/// Low precision 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 lowp_i64;
+
+	/// Medium precision 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 mediump_int8;
+	
+	/// Medium precision 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 mediump_int16;
+
+	/// Medium precision 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 mediump_int32;
+
+	/// Medium precision 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 mediump_int64;
+
+	/// Medium precision 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 mediump_int8_t;
+	
+	/// Medium precision 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 mediump_int16_t;
+
+	/// Medium precision 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 mediump_int32_t;
+
+	/// Medium precision 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 mediump_int64_t;
+
+	/// Medium precision 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 mediump_i8;
+	
+	/// Medium precision 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 mediump_i16;
+
+	/// Medium precision 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 mediump_i32;
+
+	/// Medium precision 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 mediump_i64;
+
+	/// High precision 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 highp_int8;
+	
+	/// High precision 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 highp_int16;
+
+	/// High precision 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 highp_int32;
+
+	/// High precision 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 highp_int64;
+
+	/// High precision 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 highp_int8_t;
+	
+	/// High precision 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 highp_int16_t;
+
+	/// 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 highp_int32_t;
+
+	/// High precision 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 highp_int64_t;
+
+	/// High precision 8 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int8 highp_i8;
+	
+	/// High precision 16 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int16 highp_i16;
+
+	/// High precision 32 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int32 highp_i32;
+
+	/// High precision 64 bit signed integer type.
+	/// @see gtc_type_precision
+	typedef detail::int64 highp_i64;
 	
+
 	/// 8 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int8 int8;
@@ -165,16 +310,15 @@ namespace glm
 	/// 16 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int16 int16;
-	
+
 	/// 32 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int32 int32;
-	
+
 	/// 64 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int64 int64;
-	
-	
+
 	/// 8 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int8 int8_t;
@@ -182,16 +326,15 @@ namespace glm
 	/// 16 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int16 int16_t;
-	
+
 	/// 32 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int32 int32_t;
-	
+
 	/// 64 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int64 int64_t;
-	
-	
+
 	/// 8 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int8 i8;
@@ -199,565 +342,2733 @@ namespace glm
 	/// 16 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int16 i16;
-	
+
 	/// 32 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int32 i32;
-	
+
 	/// 64 bit signed integer type.
 	/// @see gtc_type_precision
 	typedef detail::int64 i64;
 	
 	
-	/// 8 bit signed integer scalar type.
+	
+	/// Low precision 8 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<i8, mediump> i8vec1;
+	typedef detail::tvec1<i8, lowp> lowp_i8vec1;
 	
-	/// 8 bit signed integer vector of 2 components type.
+	/// Low precision 8 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<i8, mediump> i8vec2;
+	typedef detail::tvec2<i8, lowp> lowp_i8vec2;
 	
-	/// 8 bit signed integer vector of 3 components type.
+	/// Low precision 8 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<i8, mediump> i8vec3;
+	typedef detail::tvec3<i8, lowp> lowp_i8vec3;
 	
-	/// 8 bit signed integer vector of 4 components type.
+	/// Low precision 8 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<i8, mediump> i8vec4;
+	typedef detail::tvec4<i8, lowp> lowp_i8vec4;
 	
+
+	/// Medium precision 8 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<i8, mediump> mediump_i8vec1;
 	
-	/// 16 bit signed integer scalar type.
+	/// Medium precision 8 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<i16, mediump> i16vec1;
+	typedef detail::tvec2<i8, mediump> mediump_i8vec2;
 	
-	/// 16 bit signed integer vector of 2 components type.
+	/// Medium precision 8 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<i16, mediump> i16vec2;
+	typedef detail::tvec3<i8, mediump> mediump_i8vec3;
 	
-	/// 16 bit signed integer vector of 3 components type.
+	/// Medium precision 8 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<i16, mediump> i16vec3;
+	typedef detail::tvec4<i8, mediump> mediump_i8vec4;
+	
 	
-	/// 16 bit signed integer vector of 4 components type.
+	/// High precision 8 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<i16, mediump> i16vec4;
+	typedef detail::tvec1<i8, highp> highp_i8vec1;
 	
+	/// High precision 8 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<i8, highp> highp_i8vec2;
 	
-	/// 32 bit signed integer scalar type.
+	/// High precision 8 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<i32, mediump> i32vec1;
+	typedef detail::tvec3<i8, highp> highp_i8vec3;
 	
-	/// 32 bit signed integer vector of 2 components type.
+	/// High precision 8 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<i32, mediump> i32vec2;
+	typedef detail::tvec4<i8, highp> highp_i8vec4;
 	
-	/// 32 bit signed integer vector of 3 components type.
+#if(defined(GLM_PRECISION_LOWP_INT))
+	typedef lowp_i8vec1				i8vec1;
+	typedef lowp_i8vec2				i8vec2;
+	typedef lowp_i8vec3				i8vec3;
+	typedef lowp_i8vec4				i8vec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef mediump_i8vec1			i8vec1;
+	typedef mediump_i8vec2			i8vec2;
+	typedef mediump_i8vec3			i8vec3;
+	typedef mediump_i8vec4			i8vec4;	
+#else
+	/// Default precision 8 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<i32, mediump> i32vec3;
+	typedef highp_i8vec1			i8vec1;
 	
-	/// 32 bit signed integer vector of 4 components type.
+	/// Default precision 8 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<i32, mediump> i32vec4;
+	typedef highp_i8vec2			i8vec2;
 	
+	/// Default precision 8 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef highp_i8vec3			i8vec3;
 	
-	/// 64 bit signed integer scalar type.
+	/// Default precision 8 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<i64, mediump> i64vec1;
+	typedef highp_i8vec4			i8vec4;
+#endif
+	
 	
-	/// 64 bit signed integer vector of 2 components type.
+	/// Low precision 16 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<i64, mediump> i64vec2;
+	typedef detail::tvec1<i16, lowp>		lowp_i16vec1;
 	
-	/// 64 bit signed integer vector of 3 components type.
+	/// Low precision 16 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<i64, mediump> i64vec3;
+	typedef detail::tvec2<i16, lowp>		lowp_i16vec2;
 	
-	/// 64 bit signed integer vector of 4 components type.
+	/// Low precision 16 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<i64, mediump> i64vec4;
+	typedef detail::tvec3<i16, lowp>		lowp_i16vec3;
 	
+	/// Low precision 16 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<i16, lowp>		lowp_i16vec4;
 	
-	/////////////////////////////
-	// Unsigned int vector types
 	
-	/// 8 bit unsigned integer type.
+	/// Medium precision 16 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::uint8 uint8;
+	typedef detail::tvec1<i16, mediump>		mediump_i16vec1;
 	
-	/// 16 bit unsigned integer type.
+	/// Medium precision 16 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::uint16 uint16;
+	typedef detail::tvec2<i16, mediump>		mediump_i16vec2;
 	
-	/// 32 bit unsigned integer type.
+	/// Medium precision 16 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::uint32 uint32;
+	typedef detail::tvec3<i16, mediump>		mediump_i16vec3;
 	
-	/// 64 bit unsigned integer type.
+	/// Medium precision 16 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::uint64 uint64;
+	typedef detail::tvec4<i16, mediump>		mediump_i16vec4;
 	
 	
-	/// 8 bit unsigned integer type.
+	/// High precision 16 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::uint8 uint8_t;
+	typedef detail::tvec1<i16, highp>		highp_i16vec1;
 	
-	/// 16 bit unsigned integer type.
+	/// High precision 16 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::uint16 uint16_t;
+	typedef detail::tvec2<i16, highp>		highp_i16vec2;
 	
-	/// 32 bit unsigned integer type.
+	/// High precision 16 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::uint32 uint32_t;
+	typedef detail::tvec3<i16, highp>		highp_i16vec3;
 	
-	/// 64 bit unsigned integer type.
+	/// High precision 16 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::uint64 uint64_t;
+	typedef detail::tvec4<i16, highp>		highp_i16vec4;
 	
 	
-	/// 8 bit unsigned integer type.
+#if(defined(GLM_PRECISION_LOWP_INT))
+	typedef lowp_i16vec1			i16vec1;
+	typedef lowp_i16vec2			i16vec2;
+	typedef lowp_i16vec3			i16vec3;
+	typedef lowp_i16vec4			i16vec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef mediump_i16vec1			i16vec1;
+	typedef mediump_i16vec2			i16vec2;
+	typedef mediump_i16vec3			i16vec3;
+	typedef mediump_i16vec4			i16vec4;
+#else
+	/// Default precision 16 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::uint8 u8;
+	typedef highp_i16vec1			i16vec1;
 	
-	/// 16 bit unsigned integer type.
+	/// Default precision 16 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::uint16 u16;
+	typedef highp_i16vec2			i16vec2;
 	
-	/// 32 bit unsigned integer type.
+	/// Default precision 16 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::uint32 u32;
+	typedef highp_i16vec3			i16vec3;
 	
-	/// 64 bit unsigned integer type.
+	/// Default precision 16 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::uint64 u64;
+	typedef highp_i16vec4			i16vec4;
+#endif
+
+
+	/// Low precision 32 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<i32, lowp>		lowp_i32vec1;
 	
+	/// Low precision 32 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<i32, lowp>		lowp_i32vec2;
 	
-	/// 8 bit unsigned integer scalar type.
+	/// Low precision 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<u8, mediump> u8vec1;
+	typedef detail::tvec3<i32, lowp>		lowp_i32vec3;
 	
-	/// 8 bit unsigned integer vector of 2 components type.
+	/// Low precision 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<u8, mediump> u8vec2;
+	typedef detail::tvec4<i32, lowp>		lowp_i32vec4;
 	
-	/// 8 bit unsigned integer vector of 3 components type.
+	
+	/// Medium precision 32 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<u8, mediump> u8vec3;
+	typedef detail::tvec1<i32, mediump>		mediump_i32vec1;
 	
-	/// 8 bit unsigned integer vector of 4 components type.
+	/// Medium precision 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<u8, mediump> u8vec4;
+	typedef detail::tvec2<i32, mediump>		mediump_i32vec2;
 	
+	/// Medium precision 32 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<i32, mediump>		mediump_i32vec3;
 	
-	/// 16 bit unsigned integer scalar type.
+	/// Medium precision 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<u16, mediump> u16vec1;
+	typedef detail::tvec4<i32, mediump>		mediump_i32vec4;
 	
-	/// 16 bit unsigned integer vector of 2 components type.
+	
+	/// High precision 32 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<u16, mediump> u16vec2;
+	typedef detail::tvec1<i32, highp>		highp_i32vec1;
 	
-	/// 16 bit unsigned integer vector of 3 components type.
+	/// High precision 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<u16, mediump> u16vec3;
+	typedef detail::tvec2<i32, highp>		highp_i32vec2;
 	
-	/// 16 bit unsigned integer vector of 4 components type.
+	/// High precision 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<u16, mediump> u16vec4;
+	typedef detail::tvec3<i32, highp>		highp_i32vec3;
 	
+	/// High precision 32 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<i32, highp>		highp_i32vec4;
 	
-	/// 32 bit unsigned integer scalar type.
+#if(defined(GLM_PRECISION_LOWP_INT))
+	typedef lowp_i32vec1			i32vec1;
+	typedef lowp_i32vec2			i32vec2;
+	typedef lowp_i32vec3			i32vec3;
+	typedef lowp_i32vec4			i32vec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef mediump_i32vec1			i32vec1;
+	typedef mediump_i32vec2			i32vec2;
+	typedef mediump_i32vec3			i32vec3;
+	typedef mediump_i32vec4			i32vec4;
+#else
+	/// Default precision 32 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<u32, mediump> u32vec1;
+	typedef highp_i32vec1			i32vec1;
 	
-	/// 32 bit unsigned integer vector of 2 components type.
+	/// Default precision 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<u32, mediump> u32vec2;
+	typedef highp_i32vec2			i32vec2;
 	
-	/// 32 bit unsigned integer vector of 3 components type.
+	/// Default precision 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<u32, mediump> u32vec3;
+	typedef highp_i32vec3			i32vec3;
 	
-	/// 32 bit unsigned integer vector of 4 components type.
+	/// Default precision 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<u32, mediump> u32vec4;
+	typedef highp_i32vec4			i32vec4;
+#endif
+
+
+	/// Low precision 32 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<i32, lowp>		lowp_i32vec1;
 	
+	/// Low precision 32 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<i32, lowp>		lowp_i32vec2;
 	
-	/// 64 bit unsigned integer scalar type.
+	/// Low precision 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<u64, mediump> u64vec1;
+	typedef detail::tvec3<i32, lowp>		lowp_i32vec3;
 	
-	/// 64 bit unsigned integer vector of 2 components type.
+	/// Low precision 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<u64, mediump> u64vec2;
+	typedef detail::tvec4<i32, lowp>		lowp_i32vec4;
+	
 	
-	/// 64 bit unsigned integer vector of 3 components type.
+	/// Medium precision 32 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<u64, mediump> u64vec3;
+	typedef detail::tvec1<i32, mediump>		mediump_i32vec1;
 	
-	/// 64 bit unsigned integer vector of 4 components type.
+	/// Medium precision 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<u64, mediump> u64vec4;
+	typedef detail::tvec2<i32, mediump>		mediump_i32vec2;
 	
+	/// Medium precision 32 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<i32, mediump>		mediump_i32vec3;
 	
-	//////////////////////
-	// Float vector types
+	/// Medium precision 32 bit signed integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<i32, mediump>		mediump_i32vec4;
+	
+	
+	/// High precision 32 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<i32, highp>		highp_i32vec1;
 	
-	/// 16 bit half-precision floating-point scalar.
+	/// High precision 32 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::float16 float16;
+	typedef detail::tvec2<i32, highp>		highp_i32vec2;
 	
-	/// 32 bit single-precision floating-point scalar.
+	/// High precision 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::float32 float32;
+	typedef detail::tvec3<i32, highp>		highp_i32vec3;
 	
-	/// 64 bit double-precision floating-point scalar.
+	/// High precision 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::float64 float64;
+	typedef detail::tvec4<i32, highp>		highp_i32vec4;
 	
+#if(defined(GLM_PRECISION_LOWP_INT))
+	typedef lowp_i32vec1			i32vec1;
+	typedef lowp_i32vec2			i32vec2;
+	typedef lowp_i32vec3			i32vec3;
+	typedef lowp_i32vec4			i32vec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef mediump_i32vec1			i32vec1;
+	typedef mediump_i32vec2			i32vec2;
+	typedef mediump_i32vec3			i32vec3;
+	typedef mediump_i32vec4			i32vec4;
+#else
+	/// Default precision 32 bit signed integer scalar type.
+	/// @see gtc_type_precision
+	typedef highp_i32vec1			i32vec1;
+
+	/// Default precision 32 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef highp_i32vec2			i32vec2;
 	
-	/// 16 bit half-precision floating-point scalar.
+	/// Default precision 32 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::float16 float16_t;
+	typedef highp_i32vec3			i32vec3;
 	
-	/// 32 bit single-precision floating-point scalar.
+	/// Default precision 32 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::float32 float32_t;
+	typedef highp_i32vec4			i32vec4;
+#endif
+
+
 	
-	/// 64 bit double-precision floating-point scalar.
+	/// Low precision 64 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::float64 float64_t;
+	typedef detail::tvec1<i64, lowp>		lowp_i64vec1;
 	
+	/// Low precision 64 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<i64, lowp>		lowp_i64vec2;
 	
-	/// 16 bit half-precision floating-point scalar.
+	/// Low precision 64 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef float16 f16;
+	typedef detail::tvec3<i64, lowp>		lowp_i64vec3;
 	
-	/// 32 bit single-precision floating-point scalar.
+	/// Low precision 64 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef float32 f32;
+	typedef detail::tvec4<i64, lowp>		lowp_i64vec4;
 	
-	/// 64 bit double-precision floating-point scalar.
+	
+	/// Medium precision 64 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef float64 f64;
+	typedef detail::tvec1<i64, mediump>		mediump_i64vec1;
 	
+	/// Medium precision 64 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<i64, mediump>		mediump_i64vec2;
 	
-	/// Single-precision floating-point vector of 1 component.
+	/// Medium precision 64 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<float, mediump> fvec1;
+	typedef detail::tvec3<i64, mediump>		mediump_i64vec3;
 	
-	/// Single-precision floating-point vector of 2 components.
+	/// Medium precision 64 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<float, mediump> fvec2;
+	typedef detail::tvec4<i64, mediump>		mediump_i64vec4;
 	
-	/// Single-precision floating-point vector of 3 components.
+	
+	/// High precision 64 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<float, mediump> fvec3;
+	typedef detail::tvec1<i64, highp>		highp_i64vec1;
 	
-	/// Single-precision floating-point vector of 4 components.
+	/// High precision 64 bit signed integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<float, mediump> fvec4;
+	typedef detail::tvec2<i64, highp>		highp_i64vec2;
 	
+	/// High precision 64 bit signed integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<i64, highp>		highp_i64vec3;
 	
-	/// Half-precision floating-point vector of 1 component.
+	/// High precision 64 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<f16, mediump> f16vec1;
+	typedef detail::tvec4<i64, highp>		highp_i64vec4;
 	
-	/// Half-precision floating-point vector of 2 components.
+#if(defined(GLM_PRECISION_LOWP_INT))
+	typedef lowp_i64vec1			i64vec1;
+	typedef lowp_i64vec2			i64vec2;
+	typedef lowp_i64vec3			i64vec3;
+	typedef lowp_i64vec4			i64vec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef mediump_i64vec1			i64vec1;
+	typedef mediump_i64vec2			i64vec2;
+	typedef mediump_i64vec3			i64vec3;
+	typedef mediump_i64vec4			i64vec4;
+#else
+	/// Default precision 64 bit signed integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<f16, mediump> f16vec2;
+	typedef highp_i64vec1			i64vec1;
+
+	/// Default precision 64 bit signed integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef highp_i64vec2			i64vec2;
 	
-	/// Half-precision floating-point vector of 3 components.
+	/// Default precision 64 bit signed integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<f16, mediump> f16vec3;
+	typedef highp_i64vec3			i64vec3;
 	
-	/// Half-precision floating-point vector of 4 components.
+	/// Default precision 64 bit signed integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<f16, mediump> f16vec4;
+	typedef highp_i64vec4			i64vec4;
+#endif
+	
 	
+	/////////////////////////////
+	// Unsigned int vector types
 	
-	/// Single-precision floating-point vector of 1 component.
+	/// Low precision 8 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<f32, mediump> f32vec1;
+	typedef detail::uint8 lowp_uint8;
 	
-	/// Single-precision floating-point vector of 2 components.
+	/// Low precision 16 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<f32, mediump> f32vec2;
+	typedef detail::uint16 lowp_uint16;
 	
-	/// Single-precision floating-point vector of 3 components.
+	/// Low precision 32 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<f32, mediump> f32vec3;
+	typedef detail::uint32 lowp_uint32;
 	
-	/// Single-precision floating-point vector of 4 components.
+	/// Low precision 64 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<f32, mediump> f32vec4;
+	typedef detail::uint64 lowp_uint64;
 	
 	
-	/// Double-precision floating-point vector of 1 component.
+	/// Low precision 8 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tvec1<f64, mediump> f64vec1;
+	typedef detail::uint8 lowp_uint8_t;
 	
-	/// Double-precision floating-point vector of 2 components.
+	/// Low precision 16 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tvec2<f64, mediump> f64vec2;
+	typedef detail::uint16 lowp_uint16_t;
 	
-	/// Double-precision floating-point vector of 3 components.
+	/// Low precision 32 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tvec3<f64, mediump> f64vec3;
+	typedef detail::uint32 lowp_uint32_t;
 	
-	/// Double-precision floating-point vector of 4 components.
+	/// Low precision 64 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tvec4<f64, mediump> f64vec4;
+	typedef detail::uint64 lowp_uint64_t;
 	
 	
-	//////////////////////
-	// Float matrix types
+	/// Low precision 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 lowp_u8;
 	
-	/// Single-precision floating-point 1x1 matrix.
+	/// Low precision 16 bit unsigned integer type.
 	/// @see gtc_type_precision
-	//typedef detail::tmat1x1<f32, mediump> fmat1;
+	typedef detail::uint16 lowp_u16;
 	
-	/// Single-precision floating-point 2x2 matrix.
+	/// Low precision 32 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f32, mediump> fmat2;
+	typedef detail::uint32 lowp_u32;
 	
-	/// Single-precision floating-point 3x3 matrix.
+	/// Low precision 64 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32, mediump> fmat3;
+	typedef detail::uint64 lowp_u64;
+	
 	
-	/// Single-precision floating-point 4x4 matrix.
+	
+	/// Medium precision 8 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f32, mediump> fmat4;
+	typedef detail::uint8 mediump_uint8;
 	
+	/// Medium precision 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 mediump_uint16;
 	
-	/// Single-precision floating-point 1x1 matrix.
+	/// Medium precision 32 bit unsigned integer type.
 	/// @see gtc_type_precision
-	//typedef f32 fmat1x1;
+	typedef detail::uint32 mediump_uint32;
 	
-	/// Single-precision floating-point 2x2 matrix.
+	/// Medium precision 64 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f32, mediump> fmat2x2;
+	typedef detail::uint64 mediump_uint64;
 	
-	/// Single-precision floating-point 2x3 matrix.
+	/// Medium precision 8 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f32, mediump> fmat2x3;
+	typedef detail::uint8 mediump_uint8_t;
 	
-	/// Single-precision floating-point 2x4 matrix.
+	/// Medium precision 16 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x4<f32, mediump> fmat2x4;
+	typedef detail::uint16 mediump_uint16_t;
 	
-	/// Single-precision floating-point 3x2 matrix.
+	/// Medium precision 32 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x2<f32, mediump> fmat3x2;
+	typedef detail::uint32 mediump_uint32_t;
 	
-	/// Single-precision floating-point 3x3 matrix.
+	/// Medium precision 64 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32, mediump> fmat3x3;
+	typedef detail::uint64 mediump_uint64_t;
 	
-	/// Single-precision floating-point 3x4 matrix.
+	/// Medium precision 8 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x4<f32, mediump> fmat3x4;
+	typedef detail::uint8 mediump_u8;
 	
-	/// Single-precision floating-point 4x2 matrix.
+	/// Medium precision 16 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x2<f32, mediump> fmat4x2;
+	typedef detail::uint16 mediump_u16;
 	
-	/// Single-precision floating-point 4x3 matrix.
+	/// Medium precision 32 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x3<f32, mediump> fmat4x3;
+	typedef detail::uint32 mediump_u32;
 	
-	/// Single-precision floating-point 4x4 matrix.
+	/// Medium precision 64 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f32, mediump> fmat4x4;
+	typedef detail::uint64 mediump_u64;
+		
 	
 	
-	/// Half-precision floating-point 1x1 matrix.
+	/// Medium precision 8 bit unsigned integer type.
 	/// @see gtc_type_precision
-	//typedef detail::tmat1x1<f16, mediump> f16mat1;
+	typedef detail::uint8 highp_uint8;
 	
-	/// Half-precision floating-point 2x2 matrix.
+	/// Medium precision 16 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f16, mediump> f16mat2;
+	typedef detail::uint16 highp_uint16;
 	
-	/// Half-precision floating-point 3x3 matrix.
+	/// Medium precision 32 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f16, mediump> f16mat3;
+	typedef detail::uint32 highp_uint32;
 	
-	/// Half-precision floating-point 4x4 matrix.
+	/// Medium precision 64 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f16, mediump> f16mat4;
+	typedef detail::uint64 highp_uint64;
 	
+	/// Medium precision 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 highp_uint8_t;
+	
+	/// Medium precision 16 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint16 highp_uint16_t;
 	
-	/// Half-precision floating-point 1x1 matrix.
+	/// Medium precision 32 bit unsigned integer type.
 	/// @see gtc_type_precision
-	//typedef f16 f16mat1x1;
+	typedef detail::uint32 highp_uint32_t;
 	
-	/// Half-precision floating-point 2x2 matrix.
+	/// Medium precision 64 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f16, mediump> f16mat2x2;
+	typedef detail::uint64 highp_uint64_t;
 	
-	/// Half-precision floating-point 2x3 matrix.
+	/// Medium precision 8 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f16, mediump> f16mat2x3;
+	typedef detail::uint8 highp_u8;
 	
-	/// Half-precision floating-point 2x4 matrix.
+	/// Medium precision 16 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x4<f16, mediump> f16mat2x4;
+	typedef detail::uint16 highp_u16;
 	
-	/// Half-precision floating-point 3x2 matrix.
+	/// Medium precision 32 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x2<f16, mediump> f16mat3x2;
+	typedef detail::uint32 highp_u32;
 	
-	/// Half-precision floating-point 3x3 matrix.
+	/// Medium precision 64 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f16, mediump> f16mat3x3;
+	typedef detail::uint64 highp_u64;
+	
 	
-	/// Half-precision floating-point 3x4 matrix.
+	
+	/// 8 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x4<f16, mediump> f16mat3x4;
+	typedef detail::uint8 uint8;
 	
-	/// Half-precision floating-point 4x2 matrix.
+	/// 16 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x2<f16, mediump> f16mat4x2;
+	typedef detail::uint16 uint16;
 	
-	/// Half-precision floating-point 4x3 matrix.
+	/// 32 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x3<f16, mediump> f16mat4x3;
+	typedef detail::uint32 uint32;
 	
-	/// Half-precision floating-point 4x4 matrix.
+	/// 64 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f16, mediump> f16mat4x4;
+	typedef detail::uint64 uint64;
 	
+	/// 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 uint8_t;
 	
-	/// Single-precision floating-point 1x1 matrix.
+	/// 16 bit unsigned integer type.
 	/// @see gtc_type_precision
-	//typedef detail::tmat1x1<f32, mediump> f32mat1;
+	typedef detail::uint16 uint16_t;
+	
+	/// 32 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint32 uint32_t;
+	
+	/// 64 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint64 uint64_t;
+	
+	/// 8 bit unsigned integer type.
+	/// @see gtc_type_precision
+	typedef detail::uint8 u8;
 	
-	/// Single-precision floating-point 2x2 matrix.
+	/// 16 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f32, mediump> f32mat2;
+	typedef detail::uint16 u16;
 	
-	/// Single-precision floating-point 3x3 matrix.
+	/// 32 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32, mediump> f32mat3;
+	typedef detail::uint32 u32;
 	
-	/// Single-precision floating-point 4x4 matrix.
+	/// 64 bit unsigned integer type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f32, mediump> f32mat4;
+	typedef detail::uint64 u64;
+	
+	
+	
 	
+	/// Low precision 8 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u8, lowp> lowp_u8vec1;
 	
-	/// Single-precision floating-point 1x1 matrix.
+	/// Low precision 8 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	//typedef f32 f32mat1x1;
+	typedef detail::tvec2<u8, lowp> lowp_u8vec2;
 	
-	/// Single-precision floating-point 2x2 matrix.
+	/// Low precision 8 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f32, mediump> f32mat2x2;
+	typedef detail::tvec3<u8, lowp> lowp_u8vec3;
 	
-	/// Single-precision floating-point 2x3 matrix.
+	/// Low precision 8 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f32, mediump> f32mat2x3;
+	typedef detail::tvec4<u8, lowp> lowp_u8vec4;
 	
-	/// Single-precision floating-point 2x4 matrix.
+
+	/// Medium precision 8 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x4<f32, mediump> f32mat2x4;
+	typedef detail::tvec1<u8, mediump> mediump_u8vec1;
 	
-	/// Single-precision floating-point 3x2 matrix.
+	/// Medium precision 8 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x2<f32, mediump> f32mat3x2;
+	typedef detail::tvec2<u8, mediump> mediump_u8vec2;
 	
-	/// Single-precision floating-point 3x3 matrix.
+	/// Medium precision 8 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32, mediump> f32mat3x3;
+	typedef detail::tvec3<u8, mediump> mediump_u8vec3;
 	
-	/// Single-precision floating-point 3x4 matrix.
+	/// Medium precision 8 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x4<f32, mediump> f32mat3x4;
+	typedef detail::tvec4<u8, mediump> mediump_u8vec4;
 	
-	/// Single-precision floating-point 4x2 matrix.
+	
+	/// High precision 8 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x2<f32, mediump> f32mat4x2;
+	typedef detail::tvec1<u8, highp> highp_u8vec1;
 	
-	/// Single-precision floating-point 4x3 matrix.
+	/// High precision 8 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x3<f32, mediump> f32mat4x3;
+	typedef detail::tvec2<u8, highp> highp_u8vec2;
 	
-	/// Single-precision floating-point 4x4 matrix.
+	/// High precision 8 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f32, mediump> f32mat4x4;
+	typedef detail::tvec3<u8, highp> highp_u8vec3;
 	
+	/// High precision 8 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u8, highp> highp_u8vec4;
 	
-	/// Double-precision floating-point 1x1 matrix.
+#if(defined(GLM_PRECISION_LOWP_INT))
+	typedef lowp_u8vec1				u8vec1;
+	typedef lowp_u8vec2				u8vec2;
+	typedef lowp_u8vec3				u8vec3;
+	typedef lowp_u8vec4				u8vec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef mediump_u8vec1			u8vec1;
+	typedef mediump_u8vec2			u8vec2;
+	typedef mediump_u8vec3			u8vec3;
+	typedef mediump_u8vec4			u8vec4;	
+#else
+	/// Default precision 8 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	//typedef detail::tmat1x1<f64, mediump> f64mat1;
+	typedef highp_u8vec1			u8vec1;
 	
-	/// Double-precision floating-point 2x2 matrix.
+	/// Default precision 8 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f64, mediump> f64mat2;
+	typedef highp_u8vec2			u8vec2;
 	
-	/// Double-precision floating-point 3x3 matrix.
+	/// Default precision 8 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f64, mediump> f64mat3;
+	typedef highp_u8vec3			u8vec3;
 	
-	/// Double-precision floating-point 4x4 matrix.
+	/// Default precision 8 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f64, mediump> f64mat4;
+	typedef highp_u8vec4			u8vec4;
+#endif
+	
 	
+	/// Low precision 16 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u16, lowp>		lowp_u16vec1;
 	
-	/// Double-precision floating-point 1x1 matrix.
+	/// Low precision 16 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	//typedef f64 f64mat1x1;
+	typedef detail::tvec2<u16, lowp>		lowp_u16vec2;
 	
-	/// Double-precision floating-point 2x2 matrix.
+	/// Low precision 16 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x2<f64, mediump> f64mat2x2;
+	typedef detail::tvec3<u16, lowp>		lowp_u16vec3;
 	
-	/// Double-precision floating-point 2x3 matrix.
+	/// Low precision 16 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f64, mediump> f64mat2x3;
+	typedef detail::tvec4<u16, lowp>		lowp_u16vec4;
+	
 	
-	/// Double-precision floating-point 2x4 matrix.
+	/// Medium precision 16 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tmat2x4<f64, mediump> f64mat2x4;
+	typedef detail::tvec1<u16, mediump>		mediump_u16vec1;
 	
-	/// Double-precision floating-point 3x2 matrix.
+	/// Medium precision 16 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x2<f64, mediump> f64mat3x2;
+	typedef detail::tvec2<u16, mediump>		mediump_u16vec2;
 	
-	/// Double-precision floating-point 3x3 matrix.
+	/// Medium precision 16 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f64, mediump> f64mat3x3;
+	typedef detail::tvec3<u16, mediump>		mediump_u16vec3;
 	
-	/// Double-precision floating-point 3x4 matrix.
+	/// Medium precision 16 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat3x4<f64, mediump> f64mat3x4;
+	typedef detail::tvec4<u16, mediump>		mediump_u16vec4;
 	
-	/// Double-precision floating-point 4x2 matrix.
+	
+	/// High precision 16 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x2<f64, mediump> f64mat4x2;
+	typedef detail::tvec1<u16, highp>		highp_u16vec1;
 	
-	/// Double-precision floating-point 4x3 matrix.
+	/// High precision 16 bit unsigned integer vector of 2 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x3<f64, mediump> f64mat4x3;
+	typedef detail::tvec2<u16, highp>		highp_u16vec2;
 	
-	/// Double-precision floating-point 4x4 matrix.
+	/// High precision 16 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tmat4x4<f64, mediump> f64mat4x4;
+	typedef detail::tvec3<u16, highp>		highp_u16vec3;
 	
+	/// High precision 16 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u16, highp>		highp_u16vec4;
 	
-	//////////////////////////
-	// Quaternion types
 	
-	/// Half-precision floating-point quaternion.
+#if(defined(GLM_PRECISION_LOWP_INT))
+	typedef lowp_u16vec1			u16vec1;
+	typedef lowp_u16vec2			u16vec2;
+	typedef lowp_u16vec3			u16vec3;
+	typedef lowp_u16vec4			u16vec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef mediump_u16vec1			u16vec1;
+	typedef mediump_u16vec2			u16vec2;
+	typedef mediump_u16vec3			u16vec3;
+	typedef mediump_u16vec4			u16vec4;
+#else
+	/// Default precision 16 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef highp_u16vec1			u16vec1;
+	
+	/// Default precision 16 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef highp_u16vec2			u16vec2;
+	
+	/// Default precision 16 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef highp_u16vec3			u16vec3;
+	
+	/// Default precision 16 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef highp_u16vec4			u16vec4;
+#endif
+
+
+	/// Low precision 32 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u32, lowp>		lowp_u32vec1;
+	
+	/// Low precision 32 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u32, lowp>		lowp_u32vec2;
+	
+	/// Low precision 32 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<u32, lowp>		lowp_u32vec3;
+	
+	/// Low precision 32 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u32, lowp>		lowp_u32vec4;
+	
+	
+	/// Medium precision 32 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u32, mediump>		mediump_u32vec1;
+	
+	/// Medium precision 32 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u32, mediump>		mediump_u32vec2;
+	
+	/// Medium precision 32 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<u32, mediump>		mediump_u32vec3;
+	
+	/// Medium precision 32 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u32, mediump>		mediump_u32vec4;
+	
+	
+	/// High precision 32 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u32, highp>		highp_u32vec1;
+	
+	/// High precision 32 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u32, highp>		highp_u32vec2;
+	
+	/// High precision 32 bit unsigned integer vector of 3 components type.
 	/// @see gtc_type_precision
-	typedef detail::tquat<f16, mediump> f16quat;
+	typedef detail::tvec3<u32, highp>		highp_u32vec3;
 	
-	/// Single-precision floating-point quaternion.
+	/// High precision 32 bit unsigned integer vector of 4 components type.
 	/// @see gtc_type_precision
-	typedef detail::tquat<f32, mediump> f32quat;
+	typedef detail::tvec4<u32, highp>		highp_u32vec4;
 	
-	/// Double-precision floating-point quaternion. 
+#if(defined(GLM_PRECISION_LOWP_INT))
+	typedef lowp_u32vec1			u32vec1;
+	typedef lowp_u32vec2			u32vec2;
+	typedef lowp_u32vec3			u32vec3;
+	typedef lowp_u32vec4			u32vec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef mediump_u32vec1			u32vec1;
+	typedef mediump_u32vec2			u32vec2;
+	typedef mediump_u32vec3			u32vec3;
+	typedef mediump_u32vec4			u32vec4;
+#else
+	/// Default precision 32 bit unsigned integer scalar type.
 	/// @see gtc_type_precision
-	typedef detail::tquat<f64, mediump> f64quat;
+	typedef highp_u32vec1			u32vec1;
+	
+	/// Default precision 32 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef highp_u32vec2			u32vec2;
+	
+	/// Default precision 32 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef highp_u32vec3			u32vec3;
+	
+	/// Default precision 32 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef highp_u32vec4			u32vec4;
+#endif
+
+
+	/// Low precision 32 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u32, lowp>		lowp_u32vec1;
+	
+	/// Low precision 32 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u32, lowp>		lowp_u32vec2;
+	
+	/// Low precision 32 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<u32, lowp>		lowp_u32vec3;
+	
+	/// Low precision 32 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u32, lowp>		lowp_u32vec4;
+	
+	
+	/// Medium precision 32 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u32, mediump>		mediump_u32vec1;
+	
+	/// Medium precision 32 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u32, mediump>		mediump_u32vec2;
+	
+	/// Medium precision 32 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<u32, mediump>		mediump_u32vec3;
+	
+	/// Medium precision 32 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u32, mediump>		mediump_u32vec4;
+	
+	
+	/// High precision 32 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u32, highp>		highp_u32vec1;
+	
+	/// High precision 32 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u32, highp>		highp_u32vec2;
+	
+	/// High precision 32 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<u32, highp>		highp_u32vec3;
+	
+	/// High precision 32 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u32, highp>		highp_u32vec4;
+	
+#if(defined(GLM_PRECISION_LOWP_INT))
+	typedef lowp_u32vec1			u32vec1;
+	typedef lowp_u32vec2			u32vec2;
+	typedef lowp_u32vec3			u32vec3;
+	typedef lowp_u32vec4			u32vec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_INT))
+	typedef mediump_u32vec1			u32vec1;
+	typedef mediump_u32vec2			u32vec2;
+	typedef mediump_u32vec3			u32vec3;
+	typedef mediump_u32vec4			u32vec4;
+#else
+	/// Default precision 32 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef highp_u32vec1			u32vec1;
+
+	/// Default precision 32 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef highp_u32vec2			u32vec2;
+	
+	/// Default precision 32 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef highp_u32vec3			u32vec3;
+	
+	/// Default precision 32 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef highp_u32vec4			u32vec4;
+#endif
+
+
+	
+	/// Low precision 64 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u64, lowp>		lowp_u64vec1;
+	
+	/// Low precision 64 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u64, lowp>		lowp_u64vec2;
+	
+	/// Low precision 64 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<u64, lowp>		lowp_u64vec3;
+	
+	/// Low precision 64 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u64, lowp>		lowp_u64vec4;
+	
+	
+	/// Medium precision 64 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u64, mediump>		mediump_u64vec1;
+	
+	/// Medium precision 64 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u64, mediump>		mediump_u64vec2;
+	
+	/// Medium precision 64 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<u64, mediump>		mediump_u64vec3;
+	
+	/// Medium precision 64 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u64, mediump>		mediump_u64vec4;
+	
+	
+	/// High precision 64 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u64, highp>		highp_u64vec1;
+	
+	/// High precision 64 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u64, highp>		highp_u64vec2;
+	
+	/// High precision 64 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<u64, highp>		highp_u64vec3;
+	
+	/// High precision 64 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u64, highp>		highp_u64vec4;
+	
+#if(defined(GLM_PRECISION_LOWP_UINT))
+	typedef lowp_u64vec1			u64vec1;
+	typedef lowp_u64vec2			u64vec2;
+	typedef lowp_u64vec3			u64vec3;
+	typedef lowp_u64vec4			u64vec4;
+#elif(defined(GLM_PRECISION_MEDIUMP_UINT))
+	typedef mediump_u64vec1			u64vec1;
+	typedef mediump_u64vec2			u64vec2;
+	typedef mediump_u64vec3			u64vec3;
+	typedef mediump_u64vec4			u64vec4;
+#else
+	/// Default precision 64 bit unsigned integer scalar type.
+	/// @see gtc_type_precision
+	typedef highp_u64vec1			u64vec1;
+
+	/// Default precision 64 bit unsigned integer vector of 2 components type.
+	/// @see gtc_type_precision
+	typedef highp_u64vec2			u64vec2;
+	
+	/// Default precision 64 bit unsigned integer vector of 3 components type.
+	/// @see gtc_type_precision
+	typedef highp_u64vec3			u64vec3;
+	
+	/// Default precision 64 bit unsigned integer vector of 4 components type.
+	/// @see gtc_type_precision
+	typedef highp_u64vec4			u64vec4;
+#endif
+	
+	
+	//////////////////////
+	// Float vector types
+	
+	/// Low 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float16 lowp_float16;
+	
+	/// Low 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float32 lowp_float32;
+	
+	/// Low 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float64 lowp_float64;
+	
+	/// Low 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float16 lowp_float16_t;
+	
+	/// Low 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float32 lowp_float32_t;
+	
+	/// Low 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float64 lowp_float64_t;
+	
+	/// Low 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float16 lowp_f16;
+	
+	/// Low 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 lowp_f32;
+	
+	/// Low 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 lowp_f64;
+
+	/// Low 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float16 lowp_float16;
+	
+	/// Low 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float32 lowp_float32;
+	
+	/// Low 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float64 lowp_float64;
+	
+	/// Low 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float16 lowp_float16_t;
+	
+	/// Low 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float32 lowp_float32_t;
+	
+	/// Low 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float64 lowp_float64_t;
+	
+	/// Low 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float16 lowp_f16;
+	
+	/// Low 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 lowp_f32;
+	
+	/// Low 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 lowp_f64;
+
+
+
+	/// Low 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float16 lowp_float16;
+	
+	/// Low 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float32 lowp_float32;
+	
+	/// Low 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float64 lowp_float64;
+	
+	/// Low 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float16 lowp_float16_t;
+	
+	/// Low 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float32 lowp_float32_t;
+	
+	/// Low 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float64 lowp_float64_t;
+	
+	/// Low 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float16 lowp_f16;
+	
+	/// Low 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 lowp_f32;
+	
+	/// Low 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 lowp_f64;
+
+	
+	/// Medium 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float16 mediump_float16;
+	
+	/// Medium 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float32 mediump_float32;
+	
+	/// Medium 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float64 mediump_float64;
+	
+	/// Medium 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float16 mediump_float16_t;
+	
+	/// Medium 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float32 mediump_float32_t;
+	
+	/// Medium 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float64 mediump_float64_t;
+	
+	/// Medium 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float16 mediump_f16;
+	
+	/// Medium 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 mediump_f32;
+	
+	/// Medium 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 mediump_f64;
+
+
+	/// High 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float16 highp_float16;
+	
+	/// High 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float32 highp_float32;
+	
+	/// High 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float64 highp_float64;
+	
+	/// High 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float16 highp_float16_t;
+	
+	/// High 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float32 highp_float32_t;
+	
+	/// High 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef detail::float64 highp_float64_t;
+	
+	/// High 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float16 highp_f16;
+	
+	/// High 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float32 highp_f32;
+	
+	/// High 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef float64 highp_f64;
+
+
+#if(defined(GLM_PRECISION_LOWP_FLOAT))
+	/// Default 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_float16 float16;
+	
+	/// Default 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_float32 float32;
+	
+	/// Default 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_float64 float64;
+	
+	/// Default 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_float16 float16_t;
+	
+	/// Default 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_float32_t float32_t;
+	
+	/// Default 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_float64_t float64_t;
+	
+	/// Default 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_f16 f16;
+	
+	/// Default 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_f32 f32;
+	
+	/// Default 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef lowp_f64 f64;
+
+#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
+	/// Default 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float16 float16;
+	
+	/// Default 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float32 float32;
+	
+	/// Default 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float64 float64;
+	
+	/// Default 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float16 float16_t;
+	
+	/// Default 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float32 float32_t;
+	
+	/// Default 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float64 float64_t;
+	
+	/// Default 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float16 f16;
+	
+	/// Default 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float32 f32;
+	
+	/// Default 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef mediump_float64 f64;
+
+#else//(defined(GLM_PRECISION_HIGHP_FLOAT))
+	/// Default 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float16 float16;
+	
+	/// Default 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float32 float32;
+	
+	/// Default 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float64 float64;
+	
+	/// Default 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float16_t float16_t;
+	
+	/// Default 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float32_t float32_t;
+	
+	/// Default 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float64_t float64_t;
+	
+	/// Default 16 bit half-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float16_t f16;
+	
+	/// Default 32 bit single-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float32_t f32;
+	
+	/// Default 64 bit double-precision floating-point scalar.
+	/// @see gtc_type_precision
+	typedef highp_float64_t f64;
+#endif
+
+
+	/// Low single-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<float, lowp> lowp_vec1;
+	
+	/// Low single-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<float, lowp> lowp_vec2;
+	
+	/// Low single-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<float, lowp> lowp_vec3;
+	
+	/// Low single-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<float, lowp> lowp_vec4;
+	
+	/// Low single-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<float, lowp> lowp_fvec1;
+	
+	/// Low single-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<float, lowp> lowp_fvec2;
+	
+	/// Low single-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<float, lowp> lowp_fvec3;
+	
+	/// Low single-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<float, lowp> lowp_fvec4;
+	
+	
+	
+	/// Medium single-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<float, mediump> mediump_vec1;
+	
+	/// Medium Single-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<float, mediump> mediump_vec2;
+	
+	/// Medium Single-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<float, mediump> mediump_vec3;
+	
+	/// Medium Single-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<float, mediump> mediump_vec4;
+	
+	/// Medium single-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<float, mediump> mediump_fvec1;
+	
+	/// Medium Single-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<float, mediump> mediump_fvec2;
+	
+	/// Medium Single-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<float, mediump> mediump_fvec3;
+	
+	/// Medium Single-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<float, mediump> mediump_fvec4;
+	
+
+
+	/// High single-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<float, highp> highp_vec1;
+	
+	/// High Single-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<float, highp> highp_vec2;
+	
+	/// High Single-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<float, highp> highp_vec3;
+	
+	/// High Single-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<float, highp> highp_vec4;
+	
+	/// High single-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<float, highp> highp_fvec1;
+	
+	/// High Single-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<float, highp> highp_fvec2;
+	
+	/// High Single-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<float, highp> highp_fvec3;
+	
+	/// High Single-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<float, highp> highp_fvec4;
+	
+	
+	
+	/// Low half-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<f16, lowp> lowp_f16vec1;
+	
+	/// Low half-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<f16, lowp> lowp_f16vec2;
+	
+	/// Low half-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<f16, lowp> lowp_f16vec3;
+	
+	/// Low half-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<f16, lowp> lowp_f16vec4;
+	
+	/// Medium half-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<f16, mediump> mediump_f16vec1;
+	
+	/// Medium half-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<f16, mediump> mediump_f16vec2;
+	
+	/// Medium half-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<f16, mediump> mediump_f16vec3;
+	
+	/// Medium half-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<f16, mediump> mediump_f16vec4;
+	
+	/// High half-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<f16, highp> highp_f16vec1;
+	
+	/// High half-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<f16, highp> highp_f16vec2;
+	
+	/// High half-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<f16, highp> highp_f16vec3;
+	
+	/// High half-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<f16, highp> highp_f16vec4;
+	
+	
+	
+	/// Low single-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<f32, lowp> lowp_f32vec1;
+	
+	/// Low single-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<f32, lowp> lowp_f32vec2;
+	
+	/// Low single-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<f32, lowp> lowp_f32vec3;
+	
+	/// Low single-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<f32, lowp> lowp_f32vec4;
+		
+	/// Medium single-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<f32, mediump> mediump_f32vec1;
+	
+	/// Medium single-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<f32, mediump> mediump_f32vec2;
+	
+	/// Medium single-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<f32, mediump> mediump_f32vec3;
+	
+	/// Medium single-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<f32, mediump> mediump_f32vec4;
+
+	/// High single-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<f32, highp> highp_f32vec1;
+	
+	/// High single-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<f32, highp> highp_f32vec2;
+	
+	/// High single-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<f32, highp> highp_f32vec3;
+	
+	/// High single-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<f32, highp> highp_f32vec4;
+	
+
+
+	/// Low double-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<f64, lowp> lowp_f64vec1;
+	
+	/// Low double-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<f64, lowp> lowp_f64vec2;
+	
+	/// Low double-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<f64, lowp> lowp_f64vec3;
+	
+	/// Low double-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<f64, lowp> lowp_f64vec4;
+	
+	/// Medium double-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<f64, mediump> mediump_f64vec1;
+	
+	/// Medium double-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<f64, mediump> mediump_f64vec2;
+	
+	/// Medium double-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<f64, mediump> mediump_f64vec3;
+	
+	/// Medium double-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<f64, mediump> mediump_f64vec4;
+	
+	/// High double-precision floating-point vector of 1 component.
+	/// @see gtc_type_precision
+	typedef detail::tvec1<f64, highp> highp_f64vec1;
+	
+	/// High double-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec2<f64, highp> highp_f64vec2;
+	
+	/// High double-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec3<f64, highp> highp_f64vec3;
+	
+	/// High double-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef detail::tvec4<f64, highp> highp_f64vec4;
+	
+	//////////////////////
+	// Float matrix types
+
+	
+	/// Low single-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef lowp_f32 lowp_fmat1x1;
+	
+	/// Low single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f32, lowp> lowp_fmat2x2;
+	
+	/// Low single-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f32, lowp> lowp_fmat2x3;
+	
+	/// Low single-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f32, lowp> lowp_fmat2x4;
+	
+	/// Low single-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f32, lowp> lowp_fmat3x2;
+	
+	/// Low single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f32, lowp> lowp_fmat3x3;
+	
+	/// Low single-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f32, lowp> lowp_fmat3x4;
+	
+	/// Low single-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f32, lowp> lowp_fmat4x2;
+	
+	/// Low single-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f32, lowp> lowp_fmat4x3;
+	
+	/// Low single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f32, lowp> lowp_fmat4x4;
+	
+	/// Low single-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef lowp_fmat1x1 lowp_fmat1;
+	
+	/// Low single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_fmat2x2 lowp_fmat2;
+	
+	/// Low single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_fmat3x3 lowp_fmat3;
+	
+	/// Low single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_fmat4x4 lowp_fmat4;
+	
+	
+	/// Medium single-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef mediump_f32 mediump_fmat1x1;
+	
+	/// Medium single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f32, mediump> mediump_fmat2x2;
+	
+	/// Medium single-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f32, mediump> mediump_fmat2x3;
+	
+	/// Medium single-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f32, mediump> mediump_fmat2x4;
+	
+	/// Medium single-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f32, mediump> mediump_fmat3x2;
+	
+	/// Medium single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f32, mediump> mediump_fmat3x3;
+	
+	/// Medium single-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f32, mediump> mediump_fmat3x4;
+	
+	/// Medium single-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f32, mediump> mediump_fmat4x2;
+	
+	/// Medium single-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f32, mediump> mediump_fmat4x3;
+	
+	/// Medium single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f32, mediump> mediump_fmat4x4;
+	
+	/// Medium single-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef mediump_fmat1x1 mediump_fmat1;
+	
+	/// Medium single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_fmat2x2 mediump_fmat2;
+	
+	/// Medium single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_fmat3x3 mediump_fmat3;
+	
+	/// Medium single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_fmat4x4 mediump_fmat4;
+	
+
+	
+	/// High single-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef highp_f32 highp_fmat1x1;
+	
+	/// High single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f32, highp> highp_fmat2x2;
+	
+	/// High single-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f32, highp> highp_fmat2x3;
+	
+	/// High single-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f32, highp> highp_fmat2x4;
+	
+	/// High single-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f32, highp> highp_fmat3x2;
+	
+	/// High single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f32, highp> highp_fmat3x3;
+	
+	/// High single-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f32, highp> highp_fmat3x4;
+	
+	/// High single-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f32, highp> highp_fmat4x2;
+	
+	/// High single-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f32, highp> highp_fmat4x3;
+	
+	/// High single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f32, highp> highp_fmat4x4;
+	
+	/// High single-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef highp_fmat1x1 highp_fmat1;
+	
+	/// High single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_fmat2x2 highp_fmat2;
+	
+	/// High single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_fmat3x3 highp_fmat3;
+	
+	/// High single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_fmat4x4 highp_fmat4;
+
+	
+
+
+	/// Low half-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef lowp_f16 lowp_f16mat1x1;
+	
+	/// Low half-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f16, lowp> lowp_f16mat2x2;
+	
+	/// Low half-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f16, lowp> lowp_f16mat2x3;
+	
+	/// Low half-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f16, lowp> lowp_f16mat2x4;
+	
+	/// Low half-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f16, lowp> lowp_f16mat3x2;
+	
+	/// Low half-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f16, lowp> lowp_f16mat3x3;
+	
+	/// Low half-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f16, lowp> lowp_f16mat3x4;
+	
+	/// Low half-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f16, lowp> lowp_f16mat4x2;
+	
+	/// Low half-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f16, lowp> lowp_f16mat4x3;
+	
+	/// Low half-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f16, lowp> lowp_f16mat4x4;
+	
+	/// Low half-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef lowp_f16mat1x1 lowp_f16mat1;
+	
+	/// Low half-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f16mat2x2 lowp_f16mat2;
+	
+	/// Low half-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f16mat3x3 lowp_f16mat3;
+	
+	/// Low half-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f16mat4x4 lowp_f16mat4;
+	
+	
+	/// Medium half-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef mediump_f16 mediump_f16mat1x1;
+	
+	/// Medium half-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f16, mediump> mediump_f16mat2x2;
+	
+	/// Medium half-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f16, mediump> mediump_f16mat2x3;
+	
+	/// Medium half-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f16, mediump> mediump_f16mat2x4;
+	
+	/// Medium half-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f16, mediump> mediump_f16mat3x2;
+	
+	/// Medium half-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f16, mediump> mediump_f16mat3x3;
+	
+	/// Medium half-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f16, mediump> mediump_f16mat3x4;
+	
+	/// Medium half-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f16, mediump> mediump_f16mat4x2;
+	
+	/// Medium half-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f16, mediump> mediump_f16mat4x3;
+	
+	/// Medium half-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f16, mediump> mediump_f16mat4x4;
+	
+	/// Medium half-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef mediump_f16mat1x1 mediump_f16mat1;
+	
+	/// Medium half-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f16mat2x2 mediump_f16mat2;
+	
+	/// Medium half-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f16mat3x3 mediump_f16mat3;
+	
+	/// Medium half-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f16mat4x4 mediump_f16mat4;
+	
+	
+	
+	/// High half-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef highp_f16 highp_f16mat1x1;
+	
+	/// High half-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f16, highp> highp_f16mat2x2;
+	
+	/// High half-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f16, highp> highp_f16mat2x3;
+	
+	/// High half-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f16, highp> highp_f16mat2x4;
+	
+	/// High half-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f16, highp> highp_f16mat3x2;
+	
+	/// High half-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f16, highp> highp_f16mat3x3;
+	
+	/// High half-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f16, highp> highp_f16mat3x4;
+	
+	/// High half-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f16, highp> highp_f16mat4x2;
+	
+	/// High half-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f16, highp> highp_f16mat4x3;
+	
+	/// High half-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f16, highp> highp_f16mat4x4;
+	
+	/// High half-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef highp_f16mat1x1 highp_f16mat1;
+	
+	/// High half-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f16mat2x2 highp_f16mat2;
+	
+	/// High half-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f16mat3x3 highp_f16mat3;
+	
+	/// High half-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f16mat4x4 highp_f16mat4;
+	
+
+
+	/// Low single-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f32 lowp_f32mat1x1;
+	
+	/// Low single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f32, lowp> lowp_f32mat2x2;
+	
+	/// Low single-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f32, lowp> lowp_f32mat2x3;
+	
+	/// Low single-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f32, lowp> lowp_f32mat2x4;
+	
+	/// Low single-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f32, lowp> lowp_f32mat3x2;
+	
+	/// Low single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f32, lowp> lowp_f32mat3x3;
+	
+	/// Low single-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f32, lowp> lowp_f32mat3x4;
+	
+	/// Low single-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f32, lowp> lowp_f32mat4x2;
+	
+	/// Low single-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f32, lowp> lowp_f32mat4x3;
+	
+	/// Low single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f32, lowp> lowp_f32mat4x4;
+	
+	/// Low single-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef detail::tmat1x1<f32, lowp> lowp_f32mat1;
+	
+	/// Low single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f32mat2x2 lowp_f32mat2;
+	
+	/// Low single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f32mat3x3 lowp_f32mat3;
+	
+	/// Low single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f32mat4x4 lowp_f32mat4;
+
+
+
+	/// High single-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f32 mediump_f32mat1x1;
+	
+	/// Low single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f32, mediump> mediump_f32mat2x2;
+	
+	/// Medium single-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f32, mediump> mediump_f32mat2x3;
+	
+	/// Medium single-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f32, mediump> mediump_f32mat2x4;
+	
+	/// Medium single-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f32, mediump> mediump_f32mat3x2;
+	
+	/// Medium single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f32, mediump> mediump_f32mat3x3;
+	
+	/// Medium single-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f32, mediump> mediump_f32mat3x4;
+	
+	/// Medium single-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f32, mediump> mediump_f32mat4x2;
+	
+	/// Medium single-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f32, mediump> mediump_f32mat4x3;
+	
+	/// Medium single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f32, mediump> mediump_f32mat4x4;
+	
+	/// Medium single-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef detail::tmat1x1<f32, mediump> f32mat1;
+	
+	/// Medium single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f32mat2x2 mediump_f32mat2;
+	
+	/// Medium single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f32mat3x3 mediump_f32mat3;
+	
+	/// Medium single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f32mat4x4 mediump_f32mat4;
+
+
+
+	
+	/// High single-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f32 highp_f32mat1x1;
+	
+	/// High single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f32, highp> highp_f32mat2x2;
+	
+	/// High single-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f32, highp> highp_f32mat2x3;
+	
+	/// High single-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f32, highp> highp_f32mat2x4;
+	
+	/// High single-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f32, highp> highp_f32mat3x2;
+	
+	/// High single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f32, highp> highp_f32mat3x3;
+	
+	/// High single-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f32, highp> highp_f32mat3x4;
+	
+	/// High single-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f32, highp> highp_f32mat4x2;
+	
+	/// High single-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f32, highp> highp_f32mat4x3;
+	
+	/// High single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f32, highp> highp_f32mat4x4;
+	
+	/// High single-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef detail::tmat1x1<f32, highp> f32mat1;
+	
+	/// High single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat2x2 highp_f32mat2;
+	
+	/// High single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat3x3 highp_f32mat3;
+	
+	/// High single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat4x4 highp_f32mat4;
+	
+
+
+	/// Low double-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f64 lowp_f64mat1x1;
+	
+	/// Low double-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f64, lowp> lowp_f64mat2x2;
+	
+	/// Low double-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f64, lowp> lowp_f64mat2x3;
+	
+	/// Low double-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f64, lowp> lowp_f64mat2x4;
+	
+	/// Low double-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f64, lowp> lowp_f64mat3x2;
+	
+	/// Low double-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f64, lowp> lowp_f64mat3x3;
+	
+	/// Low double-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f64, lowp> lowp_f64mat3x4;
+	
+	/// Low double-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f64, lowp> lowp_f64mat4x2;
+	
+	/// Low double-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f64, lowp> lowp_f64mat4x3;
+	
+	/// Low double-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f64, lowp> lowp_f64mat4x4;
+
+	/// Low double-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef lowp_f64mat1x1 lowp_f64mat1;
+	
+	/// Low double-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f64mat2x2 lowp_f64mat2;
+	
+	/// Low double-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f64mat3x3 lowp_f64mat3;
+	
+	/// Low double-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef lowp_f64mat4x4 lowp_f64mat4;
+
+	
+	
+	/// Medium double-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f64 Highp_f64mat1x1;
+	
+	/// Medium double-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f64, mediump> mediump_f64mat2x2;
+	
+	/// Medium double-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f64, mediump> mediump_f64mat2x3;
+	
+	/// Medium double-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f64, mediump> mediump_f64mat2x4;
+	
+	/// Medium double-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f64, mediump> mediump_f64mat3x2;
+	
+	/// Medium double-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f64, mediump> mediump_f64mat3x3;
+	
+	/// Medium double-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f64, mediump> mediump_f64mat3x4;
+	
+	/// Medium double-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f64, mediump> mediump_f64mat4x2;
+	
+	/// Medium double-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f64, mediump> mediump_f64mat4x3;
+	
+	/// Medium double-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f64, mediump> mediump_f64mat4x4;
+
+	/// Medium double-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef mediump_f64mat1x1 mediump_f64mat1;
+	
+	/// Medium double-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f64mat2x2 mediump_f64mat2;
+	
+	/// Medium double-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f64mat3x3 mediump_f64mat3;
+	
+	/// Medium double-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef mediump_f64mat4x4 mediump_f64mat4;
+	
+	
+	
+	/// High double-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef f64 highp_f64mat1x1;
+	
+	/// High double-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f64, highp> highp_f64mat2x2;
+	
+	/// High double-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f64, highp> highp_f64mat2x3;
+	
+	/// High double-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f64, highp> highp_f64mat2x4;
+	
+	/// High double-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f64, highp> highp_f64mat3x2;
+	
+	/// High double-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f64, highp> highp_f64mat3x3;
+	
+	/// High double-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f64, highp> highp_f64mat3x4;
+	
+	/// High double-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f64, highp> highp_f64mat4x2;
+	
+	/// High double-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f64, highp> highp_f64mat4x3;
+	
+	/// High double-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f64, highp> highp_f64mat4x4;
+
+	/// High double-precision floating-point 1x1 matrix.
+	/// @see gtc_type_precision
+	//typedef highp_f64mat1x1 highp_f64mat1;
+	
+	/// High double-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat2x2 highp_f64mat2;
+	
+	/// High double-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat3x3 highp_f64mat3;
+	
+	/// High double-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat4x4 highp_f64mat4;
+	
+	
+	
+	//////////////////////////
+	// Quaternion types
+
+	/// Low half-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef detail::tquat<f16, lowp> lowp_f16quat;
+	
+	/// Low single-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef detail::tquat<f32, lowp> lowp_f32quat;
+	
+	/// Low double-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef detail::tquat<f64, lowp> lowp_f64quat;
+	
+	/// Medium half-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef detail::tquat<f16, mediump> mediump_f16quat;
+	
+	/// Medium single-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef detail::tquat<f32, mediump> mediump_f32quat;
+	
+	/// Medium double-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef detail::tquat<f64, mediump> mediump_f64quat;
+	
+	/// High half-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef detail::tquat<f16, highp> highp_f16quat;
+	
+	/// High single-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef detail::tquat<f32, highp> highp_f32quat;
+	
+	/// High double-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef detail::tquat<f64, highp> highp_f64quat;
+	
+
+#if(defined(GLM_PRECISION_LOWP_HALF))
+	typedef lowp_f16vec1			f16vec1;
+	typedef lowp_f16vec2			f16vec2;
+	typedef lowp_f16vec3			f16vec3;
+	typedef lowp_f16vec4			f16vec4;
+	typedef lowp_f16mat2			f16mat2;
+	typedef lowp_f16mat3			f16mat3;
+	typedef lowp_f16mat4			f16mat4;
+	typedef lowp_f16mat2x2			f16mat2x2;
+	typedef lowp_f16mat3x2			f16mat3x2;
+	typedef lowp_f16mat4x2			f16mat4x2;
+	typedef lowp_f16mat2x3			f16mat2x3;
+	typedef lowp_f16mat3x3			f16mat3x3;
+	typedef lowp_f16mat4x3			f16mat4x3;
+	typedef lowp_f16mat2x4			f16mat2x4;
+	typedef lowp_f16mat3x4			f16mat3x4;
+	typedef lowp_f16mat4x4			f16mat4x4;
+	typedef lowp_f16quat			f16quat;
+#elif(defined(GLM_PRECISION_MEDIUMP_HALF))
+	typedef mediump_f16vec1			f16vec1;
+	typedef mediump_f16vec2			f16vec2;
+	typedef mediump_f16vec3			f16vec3;
+	typedef mediump_f16vec4			f16vec4;
+	typedef mediump_f16mat2			f16mat2;
+	typedef mediump_f16mat3			f16mat3;
+	typedef mediump_f16mat4			f16mat4;
+	typedef mediump_f16mat2x2		f16mat2x2;
+	typedef mediump_f16mat3x2		f16mat3x2;
+	typedef mediump_f16mat4x2		f16mat4x2;
+	typedef mediump_f16mat2x3		f16mat2x3;
+	typedef mediump_f16mat3x3		f16mat3x3;
+	typedef mediump_f16mat4x3		f16mat4x3;
+	typedef mediump_f16mat2x4		f16mat2x4;
+	typedef mediump_f16mat3x4		f16mat3x4;
+	typedef mediump_f16mat4x4		f16mat4x4;
+	typedef mediump_f16quat			f16quat;
+#else//if(defined(GLM_PRECISION_HIGHP_HALF))
+	/// Default half-precision floating-point vector of 1 components.
+	/// @see gtc_type_precision
+	typedef highp_f16vec1			f16vec1;
+
+	/// Default half-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef highp_f16vec2			f16vec2;
+	
+	/// Default half-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef highp_f16vec3			f16vec3;
+	
+	/// Default half-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef highp_f16vec4			f16vec4;
+
+	/// Default half-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f16mat2x2			f16mat2x2;
+
+	/// Default half-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f16mat2x3			f16mat2x3;
+		
+	/// Default half-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f16mat2x4			f16mat2x4;
+
+	/// Default half-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f16mat3x2			f16mat3x2;
+
+	/// Default half-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f16mat3x3			f16mat3x3;
+		
+	/// Default half-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f16mat3x4			f16mat3x4;
+
+	/// Default half-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f16mat4x2			f16mat4x2;
+
+	/// Default half-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f16mat4x3			f16mat4x3;
+		
+	/// Default half-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f16mat4x4			f16mat4x4;
+
+	/// Default half-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef f16mat2x2				f16mat2;
+
+	/// Default half-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef f16mat3x3				f16mat3;
+
+	/// Default half-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef f16mat4x4				f16mat4;	
+	
+	/// Default half-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef highp_f16quat			f16quat;
+#endif
+
+	
+#if(defined(GLM_PRECISION_LOWP_FLOAT))
+	typedef lowp_f32vec1			fvec1;
+	typedef lowp_f32vec2			fvec2;
+	typedef lowp_f32vec3			fvec3;
+	typedef lowp_f32vec4			fvec4;
+	typedef lowp_f32mat2			fmat2;
+	typedef lowp_f32mat3			fmat3;
+	typedef lowp_f32mat4			fmat4;
+	typedef lowp_f32mat2x2			fmat2x2;
+	typedef lowp_f32mat3x2			fmat3x2;
+	typedef lowp_f32mat4x2			fmat4x2;
+	typedef lowp_f32mat2x3			fmat2x3;
+	typedef lowp_f32mat3x3			fmat3x3;
+	typedef lowp_f32mat4x3			fmat4x3;
+	typedef lowp_f32mat2x4			fmat2x4;
+	typedef lowp_f32mat3x4			fmat3x4;
+	typedef lowp_f32mat4x4			fmat4x4;
+	typedef lowp_f32quat			fquat;
+
+	typedef lowp_f32vec1			f32vec1;
+	typedef lowp_f32vec2			f32vec2;
+	typedef lowp_f32vec3			f32vec3;
+	typedef lowp_f32vec4			f32vec4;
+	typedef lowp_f32mat2			f32mat2;
+	typedef lowp_f32mat3			f32mat3;
+	typedef lowp_f32mat4			f32mat4;
+	typedef lowp_f32mat2x2			f32mat2x2;
+	typedef lowp_f32mat3x2			f32mat3x2;
+	typedef lowp_f32mat4x2			f32mat4x2;
+	typedef lowp_f32mat2x3			f32mat2x3;
+	typedef lowp_f32mat3x3			f32mat3x3;
+	typedef lowp_f32mat4x3			f32mat4x3;
+	typedef lowp_f32mat2x4			f32mat2x4;
+	typedef lowp_f32mat3x4			f32mat3x4;
+	typedef lowp_f32mat4x4			f32mat4x4;
+	typedef lowp_f32quat			f32quat;
+#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
+	typedef mediump_f32vec1			fvec1;
+	typedef mediump_f32vec2			fvec2;
+	typedef mediump_f32vec3			fvec3;
+	typedef mediump_f32vec4			fvec4;
+	typedef mediump_f32mat2			fmat2;
+	typedef mediump_f32mat3			fmat3;
+	typedef mediump_f32mat4			fmat4;
+	typedef mediump_f32mat2x2		fmat2x2;
+	typedef mediump_f32mat3x2		fmat3x2;
+	typedef mediump_f32mat4x2		fmat4x2;
+	typedef mediump_f32mat2x3		fmat2x3;
+	typedef mediump_f32mat3x3		fmat3x3;
+	typedef mediump_f32mat4x3		fmat4x3;
+	typedef mediump_f32mat2x4		fmat2x4;
+	typedef mediump_f32mat3x4		fmat3x4;
+	typedef mediump_f32mat4x4		fmat4x4;
+	typedef mediump_f32quat			fquat;
+
+	typedef mediump_f32vec1			f32vec1;
+	typedef mediump_f32vec2			f32vec2;
+	typedef mediump_f32vec3			f32vec3;
+	typedef mediump_f32vec4			f32vec4;
+	typedef mediump_f32mat2			f32mat2;
+	typedef mediump_f32mat3			f32mat3;
+	typedef mediump_f32mat4			f32mat4;
+	typedef mediump_f32mat2x2		f32mat2x2;
+	typedef mediump_f32mat3x2		f32mat3x2;
+	typedef mediump_f32mat4x2		f32mat4x2;
+	typedef mediump_f32mat2x3		f32mat2x3;
+	typedef mediump_f32mat3x3		f32mat3x3;
+	typedef mediump_f32mat4x3		f32mat4x3;
+	typedef mediump_f32mat2x4		f32mat2x4;
+	typedef mediump_f32mat3x4		f32mat3x4;
+	typedef mediump_f32mat4x4		f32mat4x4;
+	typedef mediump_f32quat			f32quat;
+#else//if(defined(GLM_PRECISION_HIGHP_FLOAT))
+	/// Default single-precision floating-point vector of 1 components.
+	/// @see gtc_type_precision
+	typedef highp_f32vec1			fvec1;
+
+	/// Default single-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef highp_f32vec2			fvec2;
+	
+	/// Default single-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef highp_f32vec3			fvec3;
+	
+	/// Default single-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef highp_f32vec4			fvec4;
+
+	/// Default single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat2x2			fmat2x2;
+
+	/// Default single-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat2x3			fmat2x3;
+		
+	/// Default single-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat2x4			fmat2x4;
+
+	/// Default single-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat3x2			fmat3x2;
+
+	/// Default single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat3x3			fmat3x3;
+		
+	/// Default single-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat3x4			fmat3x4;
+
+	/// Default single-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat4x2			fmat4x2;
+
+	/// Default single-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat4x3			fmat4x3;
+		
+	/// Default single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat4x4			fmat4x4;
+	
+	/// Default single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef fmat2x2					fmat2;
+
+	/// Default single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef fmat3x3					fmat3;
+
+	/// Default single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef fmat4x4					fmat4;
+	
+	/// Default single-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef highp_fquat				fquat;
+	
+
+
+	/// Default single-precision floating-point vector of 1 components.
+	/// @see gtc_type_precision
+	typedef highp_f32vec1			f32vec1;
+
+	/// Default single-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef highp_f32vec2			f32vec2;
+	
+	/// Default single-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef highp_f32vec3			f32vec3;
+	
+	/// Default single-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef highp_f32vec4			f32vec4;
+
+	/// Default single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat2x2			f32mat2x2;
+
+	/// Default single-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat2x3			f32mat2x3;
+		
+	/// Default single-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat2x4			f32mat2x4;
+
+	/// Default single-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat3x2			f32mat3x2;
+
+	/// Default single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat3x3			f32mat3x3;
+		
+	/// Default single-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat3x4			f32mat3x4;
+
+	/// Default single-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat4x2			f32mat4x2;
+
+	/// Default single-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat4x3			f32mat4x3;
+		
+	/// Default single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f32mat4x4			f32mat4x4;
+	
+	/// Default single-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef f32mat2x2				f32mat2;
+
+	/// Default single-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef f32mat3x3				f32mat3;
+
+	/// Default single-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef f32mat4x4				f32mat4;
+	
+	/// Default single-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef highp_f32quat			f32quat;
+#endif
+
+	
+#if(defined(GLM_PRECISION_LOWP_DOUBLE))
+	typedef lowp_f64vec1			f64vec1;
+	typedef lowp_f64vec2			f64vec2;
+	typedef lowp_f64vec3			f64vec3;
+	typedef lowp_f64vec4			f64vec4;
+	typedef lowp_f64mat2			f64mat2;
+	typedef lowp_f64mat3			f64mat3;
+	typedef lowp_f64mat4			f64mat4;
+	typedef lowp_f64mat2x2			f64mat2x2;
+	typedef lowp_f64mat3x2			f64mat3x2;
+	typedef lowp_f64mat4x2			f64mat4x2;
+	typedef lowp_f64mat2x3			f64mat2x3;
+	typedef lowp_f64mat3x3			f64mat3x3;
+	typedef lowp_f64mat4x3			f64mat4x3;
+	typedef lowp_f64mat2x4			f64mat2x4;
+	typedef lowp_f64mat3x4			f64mat3x4;
+	typedef lowp_f64mat4x4			f64mat4x4;
+	typedef lowp_f64quat			f64quat;
+#elif(defined(GLM_PRECISION_MEDIUMP_DOUBLE))
+	typedef mediump_f64vec1			f64vec1;
+	typedef mediump_f64vec2			f64vec2;
+	typedef mediump_f64vec3			f64vec3;
+	typedef mediump_f64vec4			f64vec4;
+	typedef mediump_f64mat2			f64mat2;
+	typedef mediump_f64mat3			f64mat3;
+	typedef mediump_f64mat4			f64mat4;
+	typedef mediump_f64mat2x2		f64mat2x2;
+	typedef mediump_f64mat3x2		f64mat3x2;
+	typedef mediump_f64mat4x2		f64mat4x2;
+	typedef mediump_f64mat2x3		f64mat2x3;
+	typedef mediump_f64mat3x3		f64mat3x3;
+	typedef mediump_f64mat4x3		f64mat4x3;
+	typedef mediump_f64mat2x4		f64mat2x4;
+	typedef mediump_f64mat3x4		f64mat3x4;
+	typedef mediump_f64mat4x4		f64mat4x4;
+	typedef mediump_f64quat			f64quat;
+#else
+	/// Default double-precision floating-point vector of 1 components.
+	/// @see gtc_type_precision
+	typedef highp_f64vec1			f64vec1;
+
+	/// Default double-precision floating-point vector of 2 components.
+	/// @see gtc_type_precision
+	typedef highp_f64vec2			f64vec2;
+	
+	/// Default double-precision floating-point vector of 3 components.
+	/// @see gtc_type_precision
+	typedef highp_f64vec3			f64vec3;
+	
+	/// Default double-precision floating-point vector of 4 components.
+	/// @see gtc_type_precision
+	typedef highp_f64vec4			f64vec4;
+
+	/// Default double-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat2x2			f64mat2x2;
+
+	/// Default double-precision floating-point 2x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat2x3			f64mat2x3;
+		
+	/// Default double-precision floating-point 2x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat2x4			f64mat2x4;
+
+	/// Default double-precision floating-point 3x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat3x2			f64mat3x2;
+
+	/// Default double-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat3x3			f64mat3x3;
+
+	/// Default double-precision floating-point 3x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat3x4			f64mat3x4;
+
+	/// Default double-precision floating-point 4x2 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat4x2			f64mat4x2;
+
+	/// Default double-precision floating-point 4x3 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat4x3			f64mat4x3;
+
+	/// Default double-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef highp_f64mat4x4			f64mat4x4;
+
+	/// Default double-precision floating-point 2x2 matrix.
+	/// @see gtc_type_precision
+	typedef f32mat2x2				f64mat2;
+
+	/// Default double-precision floating-point 3x3 matrix.
+	/// @see gtc_type_precision
+	typedef f32mat3x3				f64mat3;
+
+	/// Default double-precision floating-point 4x4 matrix.
+	/// @see gtc_type_precision
+	typedef f32mat4x4				f64mat4;
+
+	/// Default double-precision floating-point quaternion.
+	/// @see gtc_type_precision
+	typedef highp_f64quat			f64quat;
+#endif
 }//namespace glm
 
 #endif//GLM_FWD_INCLUDED

glm/gtx/dual_quaternion.hpp

@@ -295,7 +295,7 @@ namespace detail
 	/// Dual-quaternion of default half-precision floating-point numbers.
 	///
 	/// @see gtc_dual_quaternion
-	typedef mediump_hdualquat		hdualquat;
+	typedef highp_hdualquat			hdualquat;
 #elif(defined(GLM_PRECISION_HIGHP_HALF) && !defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
 	typedef highp_hdualquat			hdualquat;
 #elif(!defined(GLM_PRECISION_HIGHP_HALF) && defined(GLM_PRECISION_MEDIUMP_HALF) && !defined(GLM_PRECISION_LOWP_HALF))
@@ -311,7 +311,7 @@ namespace detail
 	/// Dual-quaternion of default double-precision floating-point numbers.
 	///
 	/// @see gtc_dual_quaternion
-	typedef mediump_ddualquat		ddualquat;
+	typedef highp_ddualquat			ddualquat;
 #elif(defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
 	typedef highp_ddualquat			ddualquat;
 #elif(!defined(GLM_PRECISION_HIGHP_DOUBLE) && defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))

test/core/core_func_packing.cpp

@@ -136,16 +136,16 @@ int test_packDouble2x32()
 {
 	int Error = 0;
 	
-	std::vector<glm::u32vec2> A;
-	A.push_back(glm::u32vec2( 1, 2));
-	A.push_back(glm::u32vec2(-1,-2));
-	A.push_back(glm::u32vec2(-1000, 1100));
+	std::vector<glm::uvec2> A;
+	A.push_back(glm::uvec2( 1, 2));
+	A.push_back(glm::uvec2(-1,-2));
+	A.push_back(glm::uvec2(-1000, 1100));
 	
 	for(std::size_t i = 0; i < A.size(); ++i)
 	{
-		glm::u32vec2 B(A[i]);
+		glm::uvec2 B(A[i]);
 		double C = glm::packDouble2x32(B);
-		glm::u32vec2 D = glm::unpackDouble2x32(C);
+		glm::uvec2 D = glm::unpackDouble2x32(C);
 		Error += B == D ? 0 : 1;
 		assert(!Error);
 	}

test/gtc/gtc_type_precision.cpp

@@ -2,7 +2,7 @@
 // OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // Created : 2010-09-16
-// Updated : 2011-05-08
+// Updated : 2013-04-16
 // Licence : This source is under MIT licence
 // File    : test/gtc/type_precision.cpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
@@ -12,154 +12,522 @@
 
 static int test_scalar_size()
 {
-	int Error = 0;
-    Error += sizeof(glm::int8) != 1;
-    Error += sizeof(glm::int16) != 2;
-    Error += sizeof(glm::int32) != 4;
-    Error += sizeof(glm::int64) != 8;
-    Error += sizeof(glm::uint8) != 1;
-    Error += sizeof(glm::uint16) != 2;
-    Error += sizeof(glm::uint32) != 4;
-    Error += sizeof(glm::uint64) != 8;
-    Error += sizeof(glm::float16) != 2;
-    Error += sizeof(glm::float32) != 4;
-    Error += sizeof(glm::float64) != 8;
+	int Error(0);
+	Error += sizeof(glm::int8) != 1;
+	Error += sizeof(glm::int16) != 2;
+	Error += sizeof(glm::int32) != 4;
+	Error += sizeof(glm::int64) != 8;
+	Error += sizeof(glm::uint8) != 1;
+	Error += sizeof(glm::uint16) != 2;
+	Error += sizeof(glm::uint32) != 4;
+	Error += sizeof(glm::uint64) != 8;
+	Error += sizeof(glm::float16) != 2;
+	Error += sizeof(glm::float32) != 4;
+	Error += sizeof(glm::float64) != 8;
+	
+	Error += sizeof(glm::lowp_int8) != 1;
+	Error += sizeof(glm::lowp_int16) != 2;
+	Error += sizeof(glm::lowp_int32) != 4;
+	Error += sizeof(glm::lowp_int64) != 8;
+	Error += sizeof(glm::lowp_uint8) != 1;
+	Error += sizeof(glm::lowp_uint16) != 2;
+	Error += sizeof(glm::lowp_uint32) != 4;
+	Error += sizeof(glm::lowp_uint64) != 8;
+	Error += sizeof(glm::lowp_float16) != 2;
+	Error += sizeof(glm::lowp_float32) != 4;
+	Error += sizeof(glm::lowp_float64) != 8;
+	
+	Error += sizeof(glm::mediump_int8) != 1;
+	Error += sizeof(glm::mediump_int16) != 2;
+	Error += sizeof(glm::mediump_int32) != 4;
+	Error += sizeof(glm::mediump_int64) != 8;
+	Error += sizeof(glm::mediump_uint8) != 1;
+	Error += sizeof(glm::mediump_uint16) != 2;
+	Error += sizeof(glm::mediump_uint32) != 4;
+	Error += sizeof(glm::mediump_uint64) != 8;
+	Error += sizeof(glm::mediump_float16) != 2;
+	Error += sizeof(glm::mediump_float32) != 4;
+	Error += sizeof(glm::mediump_float64) != 8;
+	
+	Error += sizeof(glm::highp_int8) != 1;
+	Error += sizeof(glm::highp_int16) != 2;
+	Error += sizeof(glm::highp_int32) != 4;
+	Error += sizeof(glm::highp_int64) != 8;
+	Error += sizeof(glm::highp_uint8) != 1;
+	Error += sizeof(glm::highp_uint16) != 2;
+	Error += sizeof(glm::highp_uint32) != 4;
+	Error += sizeof(glm::highp_uint64) != 8;
+	Error += sizeof(glm::highp_float16) != 2;
+	Error += sizeof(glm::highp_float32) != 4;
+	Error += sizeof(glm::highp_float64) != 8;
 	return Error;
 }
 
 static int test_fvec_size()
 {
-    int Error = 0;
-    Error += sizeof(glm::f16vec2) != 4;
-    Error += sizeof(glm::f16vec3) != 6;
-    Error += sizeof(glm::f16vec4) != 8;
-    Error += sizeof(glm::f32vec2) != 8;
-    Error += sizeof(glm::f32vec3) != 12;
-    Error += sizeof(glm::f32vec4) != 16;
-    Error += sizeof(glm::f64vec2) != 16;
-    Error += sizeof(glm::f64vec3) != 24;
-    Error += sizeof(glm::f64vec4) != 32;
+	int Error(0);
+	Error += sizeof(glm::f16vec2) != 4;
+	Error += sizeof(glm::f16vec3) != 6;
+	Error += sizeof(glm::f16vec4) != 8;
+	Error += sizeof(glm::f32vec2) != 8;
+	Error += sizeof(glm::f32vec3) != 12;
+	Error += sizeof(glm::f32vec4) != 16;
+	Error += sizeof(glm::f64vec2) != 16;
+	Error += sizeof(glm::f64vec3) != 24;
+	Error += sizeof(glm::f64vec4) != 32;
+	
+	Error += sizeof(glm::lowp_f16vec2) != 4;
+	Error += sizeof(glm::lowp_f16vec3) != 6;
+	Error += sizeof(glm::lowp_f16vec4) != 8;
+	Error += sizeof(glm::lowp_f32vec2) != 8;
+	Error += sizeof(glm::lowp_f32vec3) != 12;
+	Error += sizeof(glm::lowp_f32vec4) != 16;
+	Error += sizeof(glm::lowp_f64vec2) != 16;
+	Error += sizeof(glm::lowp_f64vec3) != 24;
+	Error += sizeof(glm::lowp_f64vec4) != 32;
+	
+	Error += sizeof(glm::mediump_f16vec2) != 4;
+	Error += sizeof(glm::mediump_f16vec3) != 6;
+	Error += sizeof(glm::mediump_f16vec4) != 8;
+	Error += sizeof(glm::mediump_f32vec2) != 8;
+	Error += sizeof(glm::mediump_f32vec3) != 12;
+	Error += sizeof(glm::mediump_f32vec4) != 16;
+	Error += sizeof(glm::mediump_f64vec2) != 16;
+	Error += sizeof(glm::mediump_f64vec3) != 24;
+	Error += sizeof(glm::mediump_f64vec4) != 32;
+	
+	Error += sizeof(glm::highp_f16vec2) != 4;
+	Error += sizeof(glm::highp_f16vec3) != 6;
+	Error += sizeof(glm::highp_f16vec4) != 8;
+	Error += sizeof(glm::highp_f32vec2) != 8;
+	Error += sizeof(glm::highp_f32vec3) != 12;
+	Error += sizeof(glm::highp_f32vec4) != 16;
+	Error += sizeof(glm::highp_f64vec2) != 16;
+	Error += sizeof(glm::highp_f64vec3) != 24;
+	Error += sizeof(glm::highp_f64vec4) != 32;
 	return Error;
 }
 
 static int test_ivec_size()
 {
-    int Error = 0;
-    Error += sizeof(glm::i8vec2) != 2;
-    Error += sizeof(glm::i8vec3) != 3;
-    Error += sizeof(glm::i8vec4) != 4;
-    Error += sizeof(glm::i16vec2) != 4;
-    Error += sizeof(glm::i16vec3) != 6;
-    Error += sizeof(glm::i16vec4) != 8;
-    Error += sizeof(glm::i32vec2) != 8;
-    Error += sizeof(glm::i32vec3) != 12;
-    Error += sizeof(glm::i32vec4) != 16;
-    Error += sizeof(glm::i64vec2) != 16;
-    Error += sizeof(glm::i64vec3) != 24;
-    Error += sizeof(glm::i64vec4) != 32;
+	int Error(0);
+	Error += sizeof(glm::i8vec2) != 2;
+	Error += sizeof(glm::i8vec3) != 3;
+	Error += sizeof(glm::i8vec4) != 4;
+	Error += sizeof(glm::i16vec2) != 4;
+	Error += sizeof(glm::i16vec3) != 6;
+	Error += sizeof(glm::i16vec4) != 8;
+	Error += sizeof(glm::i32vec2) != 8;
+	Error += sizeof(glm::i32vec3) != 12;
+	Error += sizeof(glm::i32vec4) != 16;
+	Error += sizeof(glm::i64vec2) != 16;
+	Error += sizeof(glm::i64vec3) != 24;
+	Error += sizeof(glm::i64vec4) != 32;
+	
+	Error += sizeof(glm::lowp_i8vec2) != 2;
+	Error += sizeof(glm::lowp_i8vec3) != 3;
+	Error += sizeof(glm::lowp_i8vec4) != 4;
+	Error += sizeof(glm::lowp_i16vec2) != 4;
+	Error += sizeof(glm::lowp_i16vec3) != 6;
+	Error += sizeof(glm::lowp_i16vec4) != 8;
+	Error += sizeof(glm::lowp_i32vec2) != 8;
+	Error += sizeof(glm::lowp_i32vec3) != 12;
+	Error += sizeof(glm::lowp_i32vec4) != 16;
+	Error += sizeof(glm::lowp_i64vec2) != 16;
+	Error += sizeof(glm::lowp_i64vec3) != 24;
+	Error += sizeof(glm::lowp_i64vec4) != 32;
+	
+	Error += sizeof(glm::mediump_i8vec2) != 2;
+	Error += sizeof(glm::mediump_i8vec3) != 3;
+	Error += sizeof(glm::mediump_i8vec4) != 4;
+	Error += sizeof(glm::mediump_i16vec2) != 4;
+	Error += sizeof(glm::mediump_i16vec3) != 6;
+	Error += sizeof(glm::mediump_i16vec4) != 8;
+	Error += sizeof(glm::mediump_i32vec2) != 8;
+	Error += sizeof(glm::mediump_i32vec3) != 12;
+	Error += sizeof(glm::mediump_i32vec4) != 16;
+	Error += sizeof(glm::mediump_i64vec2) != 16;
+	Error += sizeof(glm::mediump_i64vec3) != 24;
+	Error += sizeof(glm::mediump_i64vec4) != 32;
+	
+	Error += sizeof(glm::highp_i8vec2) != 2;
+	Error += sizeof(glm::highp_i8vec3) != 3;
+	Error += sizeof(glm::highp_i8vec4) != 4;
+	Error += sizeof(glm::highp_i16vec2) != 4;
+	Error += sizeof(glm::highp_i16vec3) != 6;
+	Error += sizeof(glm::highp_i16vec4) != 8;
+	Error += sizeof(glm::highp_i32vec2) != 8;
+	Error += sizeof(glm::highp_i32vec3) != 12;
+	Error += sizeof(glm::highp_i32vec4) != 16;
+	Error += sizeof(glm::highp_i64vec2) != 16;
+	Error += sizeof(glm::highp_i64vec3) != 24;
+	Error += sizeof(glm::highp_i64vec4) != 32;
 	return Error;
 }
 
 static int test_uvec_size()
 {
-    int Error = 0;
-    Error += sizeof(glm::u8vec2) != 2;
-    Error += sizeof(glm::u8vec3) != 3;
-    Error += sizeof(glm::u8vec4) != 4;
-    Error += sizeof(glm::u16vec2) != 4;
-    Error += sizeof(glm::u16vec3) != 6;
-    Error += sizeof(glm::u16vec4) != 8;
-    Error += sizeof(glm::u32vec2) != 8;
-    Error += sizeof(glm::u32vec3) != 12;
-    Error += sizeof(glm::u32vec4) != 16;
-    Error += sizeof(glm::u64vec2) != 16;
-    Error += sizeof(glm::u64vec3) != 24;
-    Error += sizeof(glm::u64vec4) != 32;
+	int Error(0);
+	Error += sizeof(glm::u8vec2) != 2;
+	Error += sizeof(glm::u8vec3) != 3;
+	Error += sizeof(glm::u8vec4) != 4;
+	Error += sizeof(glm::u16vec2) != 4;
+	Error += sizeof(glm::u16vec3) != 6;
+	Error += sizeof(glm::u16vec4) != 8;
+	Error += sizeof(glm::u32vec2) != 8;
+	Error += sizeof(glm::u32vec3) != 12;
+	Error += sizeof(glm::u32vec4) != 16;
+	Error += sizeof(glm::u64vec2) != 16;
+	Error += sizeof(glm::u64vec3) != 24;
+	Error += sizeof(glm::u64vec4) != 32;
+	
+	Error += sizeof(glm::lowp_u8vec2) != 2;
+	Error += sizeof(glm::lowp_u8vec3) != 3;
+	Error += sizeof(glm::lowp_u8vec4) != 4;
+	Error += sizeof(glm::lowp_u16vec2) != 4;
+	Error += sizeof(glm::lowp_u16vec3) != 6;
+	Error += sizeof(glm::lowp_u16vec4) != 8;
+	Error += sizeof(glm::lowp_u32vec2) != 8;
+	Error += sizeof(glm::lowp_u32vec3) != 12;
+	Error += sizeof(glm::lowp_u32vec4) != 16;
+	Error += sizeof(glm::lowp_u64vec2) != 16;
+	Error += sizeof(glm::lowp_u64vec3) != 24;
+	Error += sizeof(glm::lowp_u64vec4) != 32;
+	
+	Error += sizeof(glm::mediump_u8vec2) != 2;
+	Error += sizeof(glm::mediump_u8vec3) != 3;
+	Error += sizeof(glm::mediump_u8vec4) != 4;
+	Error += sizeof(glm::mediump_u16vec2) != 4;
+	Error += sizeof(glm::mediump_u16vec3) != 6;
+	Error += sizeof(glm::mediump_u16vec4) != 8;
+	Error += sizeof(glm::mediump_u32vec2) != 8;
+	Error += sizeof(glm::mediump_u32vec3) != 12;
+	Error += sizeof(glm::mediump_u32vec4) != 16;
+	Error += sizeof(glm::mediump_u64vec2) != 16;
+	Error += sizeof(glm::mediump_u64vec3) != 24;
+	Error += sizeof(glm::mediump_u64vec4) != 32;
+	
+	Error += sizeof(glm::highp_u8vec2) != 2;
+	Error += sizeof(glm::highp_u8vec3) != 3;
+	Error += sizeof(glm::highp_u8vec4) != 4;
+	Error += sizeof(glm::highp_u16vec2) != 4;
+	Error += sizeof(glm::highp_u16vec3) != 6;
+	Error += sizeof(glm::highp_u16vec4) != 8;
+	Error += sizeof(glm::highp_u32vec2) != 8;
+	Error += sizeof(glm::highp_u32vec3) != 12;
+	Error += sizeof(glm::highp_u32vec4) != 16;
+	Error += sizeof(glm::highp_u64vec2) != 16;
+	Error += sizeof(glm::highp_u64vec3) != 24;
+	Error += sizeof(glm::highp_u64vec4) != 32;
 	return Error;
 }
 
 static int test_hmat_size()
 {
-    int Error = 0;
-    Error += sizeof(glm::f16mat2) != 8;
-    Error += sizeof(glm::f16mat3) != 18;
-    Error += sizeof(glm::f16mat4) != 32;
-    Error += sizeof(glm::f16mat2x2) != 8;
-    Error += sizeof(glm::f16mat2x3) != 12;
-    Error += sizeof(glm::f16mat2x4) != 16;
-    Error += sizeof(glm::f16mat3x2) != 12;
-    Error += sizeof(glm::f16mat3x3) != 18;
-    Error += sizeof(glm::f16mat3x4) != 24;
-    Error += sizeof(glm::f16mat4x2) != 16;
-    Error += sizeof(glm::f16mat4x3) != 24;
-    Error += sizeof(glm::f16mat4x4) != 32;
+	int Error(0);
+	Error += sizeof(glm::f16mat2) != 8;
+	Error += sizeof(glm::f16mat3) != 18;
+	Error += sizeof(glm::f16mat4) != 32;
+	Error += sizeof(glm::f16mat2x2) != 8;
+	Error += sizeof(glm::f16mat2x3) != 12;
+	Error += sizeof(glm::f16mat2x4) != 16;
+	Error += sizeof(glm::f16mat3x2) != 12;
+	Error += sizeof(glm::f16mat3x3) != 18;
+	Error += sizeof(glm::f16mat3x4) != 24;
+	Error += sizeof(glm::f16mat4x2) != 16;
+	Error += sizeof(glm::f16mat4x3) != 24;
+	Error += sizeof(glm::f16mat4x4) != 32;
+	
+	Error += sizeof(glm::lowp_f16mat2) != 8;
+	Error += sizeof(glm::lowp_f16mat3) != 18;
+	Error += sizeof(glm::lowp_f16mat4) != 32;
+	Error += sizeof(glm::lowp_f16mat2x2) != 8;
+	Error += sizeof(glm::lowp_f16mat2x3) != 12;
+	Error += sizeof(glm::lowp_f16mat2x4) != 16;
+	Error += sizeof(glm::lowp_f16mat3x2) != 12;
+	Error += sizeof(glm::lowp_f16mat3x3) != 18;
+	Error += sizeof(glm::lowp_f16mat3x4) != 24;
+	Error += sizeof(glm::lowp_f16mat4x2) != 16;
+	Error += sizeof(glm::lowp_f16mat4x3) != 24;
+	Error += sizeof(glm::lowp_f16mat4x4) != 32;
+	
+	Error += sizeof(glm::mediump_f16mat2) != 8;
+	Error += sizeof(glm::mediump_f16mat3) != 18;
+	Error += sizeof(glm::mediump_f16mat4) != 32;
+	Error += sizeof(glm::mediump_f16mat2x2) != 8;
+	Error += sizeof(glm::mediump_f16mat2x3) != 12;
+	Error += sizeof(glm::mediump_f16mat2x4) != 16;
+	Error += sizeof(glm::mediump_f16mat3x2) != 12;
+	Error += sizeof(glm::mediump_f16mat3x3) != 18;
+	Error += sizeof(glm::mediump_f16mat3x4) != 24;
+	Error += sizeof(glm::mediump_f16mat4x2) != 16;
+	Error += sizeof(glm::mediump_f16mat4x3) != 24;
+	Error += sizeof(glm::mediump_f16mat4x4) != 32;
+	
+	Error += sizeof(glm::highp_f16mat2) != 8;
+	Error += sizeof(glm::highp_f16mat3) != 18;
+	Error += sizeof(glm::highp_f16mat4) != 32;
+	Error += sizeof(glm::highp_f16mat2x2) != 8;
+	Error += sizeof(glm::highp_f16mat2x3) != 12;
+	Error += sizeof(glm::highp_f16mat2x4) != 16;
+	Error += sizeof(glm::highp_f16mat3x2) != 12;
+	Error += sizeof(glm::highp_f16mat3x3) != 18;
+	Error += sizeof(glm::highp_f16mat3x4) != 24;
+	Error += sizeof(glm::highp_f16mat4x2) != 16;
+	Error += sizeof(glm::highp_f16mat4x3) != 24;
+	Error += sizeof(glm::highp_f16mat4x4) != 32;
 	return Error;
 }
 
 static int test_fmat_size()
 {
-    int Error = 0;
-    Error += sizeof(glm::fmat2) != 16;
-    Error += sizeof(glm::fmat3) != 36;
-    Error += sizeof(glm::fmat4) != 64;
-    Error += sizeof(glm::fmat2x2) != 16;
-    Error += sizeof(glm::fmat2x3) != 24;
-    Error += sizeof(glm::fmat2x4) != 32;
-    Error += sizeof(glm::fmat3x2) != 24;
-    Error += sizeof(glm::fmat3x3) != 36;
-    Error += sizeof(glm::fmat3x4) != 48;
-    Error += sizeof(glm::fmat4x2) != 32;
-    Error += sizeof(glm::fmat4x3) != 48;
-    Error += sizeof(glm::fmat4x4) != 64;
-
-    Error += sizeof(glm::f32mat2) != 16;
-    Error += sizeof(glm::f32mat3) != 36;
-    Error += sizeof(glm::f32mat4) != 64;
-    Error += sizeof(glm::f32mat2x2) != 16;
-    Error += sizeof(glm::f32mat2x3) != 24;
-    Error += sizeof(glm::f32mat2x4) != 32;
-    Error += sizeof(glm::f32mat3x2) != 24;
-    Error += sizeof(glm::f32mat3x3) != 36;
-    Error += sizeof(glm::f32mat3x4) != 48;
-    Error += sizeof(glm::f32mat4x2) != 32;
-    Error += sizeof(glm::f32mat4x3) != 48;
-    Error += sizeof(glm::f32mat4x4) != 64;
+	int Error(0);
+	Error += sizeof(glm::mat2) != 16;
+	Error += sizeof(glm::mat3) != 36;
+	Error += sizeof(glm::mat4) != 64;
+	Error += sizeof(glm::mat2x2) != 16;
+	Error += sizeof(glm::mat2x3) != 24;
+	Error += sizeof(glm::mat2x4) != 32;
+	Error += sizeof(glm::mat3x2) != 24;
+	Error += sizeof(glm::mat3x3) != 36;
+	Error += sizeof(glm::mat3x4) != 48;
+	Error += sizeof(glm::mat4x2) != 32;
+	Error += sizeof(glm::mat4x3) != 48;
+	Error += sizeof(glm::mat4x4) != 64;
+
+	Error += sizeof(glm::fmat2) != 16;
+	Error += sizeof(glm::fmat3) != 36;
+	Error += sizeof(glm::fmat4) != 64;
+	Error += sizeof(glm::fmat2x2) != 16;
+	Error += sizeof(glm::fmat2x3) != 24;
+	Error += sizeof(glm::fmat2x4) != 32;
+	Error += sizeof(glm::fmat3x2) != 24;
+	Error += sizeof(glm::fmat3x3) != 36;
+	Error += sizeof(glm::fmat3x4) != 48;
+	Error += sizeof(glm::fmat4x2) != 32;
+	Error += sizeof(glm::fmat4x3) != 48;
+	Error += sizeof(glm::fmat4x4) != 64;
+
+	Error += sizeof(glm::f32mat2) != 16;
+	Error += sizeof(glm::f32mat3) != 36;
+	Error += sizeof(glm::f32mat4) != 64;
+	Error += sizeof(glm::f32mat2x2) != 16;
+	Error += sizeof(glm::f32mat2x3) != 24;
+	Error += sizeof(glm::f32mat2x4) != 32;
+	Error += sizeof(glm::f32mat3x2) != 24;
+	Error += sizeof(glm::f32mat3x3) != 36;
+	Error += sizeof(glm::f32mat3x4) != 48;
+	Error += sizeof(glm::f32mat4x2) != 32;
+	Error += sizeof(glm::f32mat4x3) != 48;
+	Error += sizeof(glm::f32mat4x4) != 64;
+	
+	
+	Error += sizeof(glm::lowp_mat2) != 16;
+	Error += sizeof(glm::lowp_mat3) != 36;
+	Error += sizeof(glm::lowp_mat4) != 64;
+	Error += sizeof(glm::lowp_mat2x2) != 16;
+	Error += sizeof(glm::lowp_mat2x3) != 24;
+	Error += sizeof(glm::lowp_mat2x4) != 32;
+	Error += sizeof(glm::lowp_mat3x2) != 24;
+	Error += sizeof(glm::lowp_mat3x3) != 36;
+	Error += sizeof(glm::lowp_mat3x4) != 48;
+	Error += sizeof(glm::lowp_mat4x2) != 32;
+	Error += sizeof(glm::lowp_mat4x3) != 48;
+	Error += sizeof(glm::lowp_mat4x4) != 64;
+
+	Error += sizeof(glm::lowp_fmat2) != 16;
+	Error += sizeof(glm::lowp_fmat3) != 36;
+	Error += sizeof(glm::lowp_fmat4) != 64;
+	Error += sizeof(glm::lowp_fmat2x2) != 16;
+	Error += sizeof(glm::lowp_fmat2x3) != 24;
+	Error += sizeof(glm::lowp_fmat2x4) != 32;
+	Error += sizeof(glm::lowp_fmat3x2) != 24;
+	Error += sizeof(glm::lowp_fmat3x3) != 36;
+	Error += sizeof(glm::lowp_fmat3x4) != 48;
+	Error += sizeof(glm::lowp_fmat4x2) != 32;
+	Error += sizeof(glm::lowp_fmat4x3) != 48;
+	Error += sizeof(glm::lowp_fmat4x4) != 64;
+
+	Error += sizeof(glm::lowp_f32mat2) != 16;
+	Error += sizeof(glm::lowp_f32mat3) != 36;
+	Error += sizeof(glm::lowp_f32mat4) != 64;
+	Error += sizeof(glm::lowp_f32mat2x2) != 16;
+	Error += sizeof(glm::lowp_f32mat2x3) != 24;
+	Error += sizeof(glm::lowp_f32mat2x4) != 32;
+	Error += sizeof(glm::lowp_f32mat3x2) != 24;
+	Error += sizeof(glm::lowp_f32mat3x3) != 36;
+	Error += sizeof(glm::lowp_f32mat3x4) != 48;
+	Error += sizeof(glm::lowp_f32mat4x2) != 32;
+	Error += sizeof(glm::lowp_f32mat4x3) != 48;
+	Error += sizeof(glm::lowp_f32mat4x4) != 64;
+	
+	
+	Error += sizeof(glm::mediump_mat2) != 16;
+	Error += sizeof(glm::mediump_mat3) != 36;
+	Error += sizeof(glm::mediump_mat4) != 64;
+	Error += sizeof(glm::mediump_mat2x2) != 16;
+	Error += sizeof(glm::mediump_mat2x3) != 24;
+	Error += sizeof(glm::mediump_mat2x4) != 32;
+	Error += sizeof(glm::mediump_mat3x2) != 24;
+	Error += sizeof(glm::mediump_mat3x3) != 36;
+	Error += sizeof(glm::mediump_mat3x4) != 48;
+	Error += sizeof(glm::mediump_mat4x2) != 32;
+	Error += sizeof(glm::mediump_mat4x3) != 48;
+	Error += sizeof(glm::mediump_mat4x4) != 64;
+
+	Error += sizeof(glm::mediump_fmat2) != 16;
+	Error += sizeof(glm::mediump_fmat3) != 36;
+	Error += sizeof(glm::mediump_fmat4) != 64;
+	Error += sizeof(glm::mediump_fmat2x2) != 16;
+	Error += sizeof(glm::mediump_fmat2x3) != 24;
+	Error += sizeof(glm::mediump_fmat2x4) != 32;
+	Error += sizeof(glm::mediump_fmat3x2) != 24;
+	Error += sizeof(glm::mediump_fmat3x3) != 36;
+	Error += sizeof(glm::mediump_fmat3x4) != 48;
+	Error += sizeof(glm::mediump_fmat4x2) != 32;
+	Error += sizeof(glm::mediump_fmat4x3) != 48;
+	Error += sizeof(glm::mediump_fmat4x4) != 64;
+
+	Error += sizeof(glm::mediump_f32mat2) != 16;
+	Error += sizeof(glm::mediump_f32mat3) != 36;
+	Error += sizeof(glm::mediump_f32mat4) != 64;
+	Error += sizeof(glm::mediump_f32mat2x2) != 16;
+	Error += sizeof(glm::mediump_f32mat2x3) != 24;
+	Error += sizeof(glm::mediump_f32mat2x4) != 32;
+	Error += sizeof(glm::mediump_f32mat3x2) != 24;
+	Error += sizeof(glm::mediump_f32mat3x3) != 36;
+	Error += sizeof(glm::mediump_f32mat3x4) != 48;
+	Error += sizeof(glm::mediump_f32mat4x2) != 32;
+	Error += sizeof(glm::mediump_f32mat4x3) != 48;
+	Error += sizeof(glm::mediump_f32mat4x4) != 64;
+	
+	
+	Error += sizeof(glm::highp_mat2) != 16;
+	Error += sizeof(glm::highp_mat3) != 36;
+	Error += sizeof(glm::highp_mat4) != 64;
+	Error += sizeof(glm::highp_mat2x2) != 16;
+	Error += sizeof(glm::highp_mat2x3) != 24;
+	Error += sizeof(glm::highp_mat2x4) != 32;
+	Error += sizeof(glm::highp_mat3x2) != 24;
+	Error += sizeof(glm::highp_mat3x3) != 36;
+	Error += sizeof(glm::highp_mat3x4) != 48;
+	Error += sizeof(glm::highp_mat4x2) != 32;
+	Error += sizeof(glm::highp_mat4x3) != 48;
+	Error += sizeof(glm::highp_mat4x4) != 64;
+
+	Error += sizeof(glm::highp_fmat2) != 16;
+	Error += sizeof(glm::highp_fmat3) != 36;
+	Error += sizeof(glm::highp_fmat4) != 64;
+	Error += sizeof(glm::highp_fmat2x2) != 16;
+	Error += sizeof(glm::highp_fmat2x3) != 24;
+	Error += sizeof(glm::highp_fmat2x4) != 32;
+	Error += sizeof(glm::highp_fmat3x2) != 24;
+	Error += sizeof(glm::highp_fmat3x3) != 36;
+	Error += sizeof(glm::highp_fmat3x4) != 48;
+	Error += sizeof(glm::highp_fmat4x2) != 32;
+	Error += sizeof(glm::highp_fmat4x3) != 48;
+	Error += sizeof(glm::highp_fmat4x4) != 64;
+
+	Error += sizeof(glm::highp_f32mat2) != 16;
+	Error += sizeof(glm::highp_f32mat3) != 36;
+	Error += sizeof(glm::highp_f32mat4) != 64;
+	Error += sizeof(glm::highp_f32mat2x2) != 16;
+	Error += sizeof(glm::highp_f32mat2x3) != 24;
+	Error += sizeof(glm::highp_f32mat2x4) != 32;
+	Error += sizeof(glm::highp_f32mat3x2) != 24;
+	Error += sizeof(glm::highp_f32mat3x3) != 36;
+	Error += sizeof(glm::highp_f32mat3x4) != 48;
+	Error += sizeof(glm::highp_f32mat4x2) != 32;
+	Error += sizeof(glm::highp_f32mat4x3) != 48;
+	Error += sizeof(glm::highp_f32mat4x4) != 64;
 	return Error;
 }
 
 static int test_dmat_size()
 {
-    int Error = 0;
-    Error += sizeof(glm::f64mat2) != 32;
-    Error += sizeof(glm::f64mat3) != 72;
-    Error += sizeof(glm::f64mat4) != 128;
-    Error += sizeof(glm::f64mat2x2) != 32;
-    Error += sizeof(glm::f64mat2x3) != 48;
-    Error += sizeof(glm::f64mat2x4) != 64;
-    Error += sizeof(glm::f64mat3x2) != 48;
-    Error += sizeof(glm::f64mat3x3) != 72;
-    Error += sizeof(glm::f64mat3x4) != 96;
-    Error += sizeof(glm::f64mat4x2) != 64;
-    Error += sizeof(glm::f64mat4x3) != 96;
-    Error += sizeof(glm::f64mat4x4) != 128;
+	int Error(0);
+	Error += sizeof(glm::f64mat2) != 32;
+	Error += sizeof(glm::f64mat3) != 72;
+	Error += sizeof(glm::f64mat4) != 128;
+	Error += sizeof(glm::f64mat2x2) != 32;
+	Error += sizeof(glm::f64mat2x3) != 48;
+	Error += sizeof(glm::f64mat2x4) != 64;
+	Error += sizeof(glm::f64mat3x2) != 48;
+	Error += sizeof(glm::f64mat3x3) != 72;
+	Error += sizeof(glm::f64mat3x4) != 96;
+	Error += sizeof(glm::f64mat4x2) != 64;
+	Error += sizeof(glm::f64mat4x3) != 96;
+	Error += sizeof(glm::f64mat4x4) != 128;
+
+	Error += sizeof(glm::lowp_f64mat2) != 32;
+	Error += sizeof(glm::lowp_f64mat3) != 72;
+	Error += sizeof(glm::lowp_f64mat4) != 128;
+	Error += sizeof(glm::lowp_f64mat2x2) != 32;
+	Error += sizeof(glm::lowp_f64mat2x3) != 48;
+	Error += sizeof(glm::lowp_f64mat2x4) != 64;
+	Error += sizeof(glm::lowp_f64mat3x2) != 48;
+	Error += sizeof(glm::lowp_f64mat3x3) != 72;
+	Error += sizeof(glm::lowp_f64mat3x4) != 96;
+	Error += sizeof(glm::lowp_f64mat4x2) != 64;
+	Error += sizeof(glm::lowp_f64mat4x3) != 96;
+	Error += sizeof(glm::lowp_f64mat4x4) != 128;
+	
+	Error += sizeof(glm::mediump_f64mat2) != 32;
+	Error += sizeof(glm::mediump_f64mat3) != 72;
+	Error += sizeof(glm::mediump_f64mat4) != 128;
+	Error += sizeof(glm::mediump_f64mat2x2) != 32;
+	Error += sizeof(glm::mediump_f64mat2x3) != 48;
+	Error += sizeof(glm::mediump_f64mat2x4) != 64;
+	Error += sizeof(glm::mediump_f64mat3x2) != 48;
+	Error += sizeof(glm::mediump_f64mat3x3) != 72;
+	Error += sizeof(glm::mediump_f64mat3x4) != 96;
+	Error += sizeof(glm::mediump_f64mat4x2) != 64;
+	Error += sizeof(glm::mediump_f64mat4x3) != 96;
+	Error += sizeof(glm::mediump_f64mat4x4) != 128;
+	
+	Error += sizeof(glm::highp_f64mat2) != 32;
+	Error += sizeof(glm::highp_f64mat3) != 72;
+	Error += sizeof(glm::highp_f64mat4) != 128;
+	Error += sizeof(glm::highp_f64mat2x2) != 32;
+	Error += sizeof(glm::highp_f64mat2x3) != 48;
+	Error += sizeof(glm::highp_f64mat2x4) != 64;
+	Error += sizeof(glm::highp_f64mat3x2) != 48;
+	Error += sizeof(glm::highp_f64mat3x3) != 72;
+	Error += sizeof(glm::highp_f64mat3x4) != 96;
+	Error += sizeof(glm::highp_f64mat4x2) != 64;
+	Error += sizeof(glm::highp_f64mat4x3) != 96;
+	Error += sizeof(glm::highp_f64mat4x4) != 128;
+
 	return Error;
 }
 
 static int test_quat_size()
 {
-    int Error = 0;
-    Error += sizeof(glm::f16quat) != 8; 
-    Error += sizeof(glm::f32quat) != 16; 
-    Error += sizeof(glm::f64quat) != 32;
+	int Error = 0;
+	Error += sizeof(glm::lowp_f16quat) != 8;
+	Error += sizeof(glm::f32quat) != 16;
+	Error += sizeof(glm::f64quat) != 32;
+	
+	Error += sizeof(glm::lowp_f16quat) != 8;
+	Error += sizeof(glm::lowp_f32quat) != 16;
+	Error += sizeof(glm::lowp_f64quat) != 32;
+	
+	Error += sizeof(glm::mediump_f16quat) != 8;
+	Error += sizeof(glm::mediump_f32quat) != 16;
+	Error += sizeof(glm::mediump_f64quat) != 32;
+	
+	Error += sizeof(glm::highp_f16quat) != 8;
+	Error += sizeof(glm::highp_f32quat) != 16;
+	Error += sizeof(glm::highp_f64quat) != 32;
 	return Error;
 }
 
 int main()
 {
 	int Error = 0;
-    Error += test_scalar_size();
+	Error += test_scalar_size();
 	Error += test_fvec_size();
-    Error += test_ivec_size();
+	Error += test_ivec_size();
 	Error += test_uvec_size();
 	Error += test_hmat_size();
 	Error += test_fmat_size();

test/gtx/gtx_dual_quaternion.cpp

@@ -17,23 +17,23 @@
 
 int myrand()
 {
-    static int holdrand = 1;
-    return (((holdrand = holdrand * 214013L + 2531011L) >> 16) & 0x7fff);
+	static int holdrand = 1;
+	return (((holdrand = holdrand * 214013L + 2531011L) >> 16) & 0x7fff);
 }
 
 float myfrand() // returns values from -1 to 1 inclusive
 {
-    return float(double(myrand()) / double( 0x7ffff )) * 2.0f - 1.0f;
+	return float(double(myrand()) / double( 0x7ffff )) * 2.0f - 1.0f;
 }
 
 int test_dquat_type()
 {
-    glm::dvec3 vA;
-    glm::dquat dqA,dqB;
-    glm::ddualquat C(dqA,dqB);
-    glm::ddualquat B(dqA);
-    glm::ddualquat D(dqA,vA);
-    return 0;
+	glm::dvec3 vA;
+	glm::dquat dqA,dqB;
+	glm::ddualquat C(dqA,dqB);
+	glm::ddualquat B(dqA);
+	glm::ddualquat D(dqA,vA);
+	return 0;
 }
 
 int test_scalars() {
@@ -76,7 +76,8 @@ int test_inverse()
     glm::dualquat dqid;
     glm::mat4x4 mid(1.0f);
 
-    for (int j = 0; j < 100; ++j) {
+    for (int j = 0; j < 100; ++j)
+	{
         glm::mat4x4 rot = glm::yawPitchRoll(myfrand() * 360.0f, myfrand() * 360.0f, myfrand() * 360.0f);
         glm::vec3 vt = glm::vec3(myfrand() * 10.0f, myfrand() * 10.0f, myfrand() * 10.0f);