Updated doxygen documentation

glm/gtc/half_float.hpp

@@ -353,67 +353,67 @@ namespace detail
 	/// @{
 
 	/// Type for half-precision floating-point numbers. 
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::thalf					half;
 
 	/// Vector of 2 half-precision floating-point numbers. 
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tvec2<detail::thalf>	hvec2;
 
 	/// Vector of 3 half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tvec3<detail::thalf>	hvec3;
 
 	/// Vector of 4 half-precision floating-point numbers. 
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tvec4<detail::thalf>	hvec4;
 
 	/// 2 * 2 matrix of half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tmat2x2<detail::thalf>	hmat2;
     
 	/// 3 * 3 matrix of half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tmat3x3<detail::thalf>	hmat3;
 
 	/// 4 * 4 matrix of half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tmat4x4<detail::thalf>	hmat4;
 
 	/// 2 * 2 matrix of half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tmat2x2<detail::thalf>	hmat2x2;
     
 	/// 2 * 3 matrix of half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tmat2x3<detail::thalf>	hmat2x3;
     
 	/// 2 * 4 matrix of half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tmat2x4<detail::thalf>	hmat2x4;
 
 	/// 3 * 2 matrix of half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tmat3x2<detail::thalf>	hmat3x2;
     
 	/// 3 * 3 matrix of half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tmat3x3<detail::thalf>	hmat3x3;
     
 	/// 3 * 4 matrix of half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tmat3x4<detail::thalf>	hmat3x4;
 
 	/// 4 * 2 matrix of half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tmat4x2<detail::thalf>	hmat4x2;    
 
 	/// 4 * 3 matrix of half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tmat4x3<detail::thalf>	hmat4x3;
     
 	/// 4 * 4 matrix of half-precision floating-point numbers.
-	/// @see - gtc_half_float
+	/// @see gtc_half_float
 	typedef detail::tmat4x4<detail::thalf>	hmat4x4;
     
 	/// @}

glm/gtc/quaternion.hpp

@@ -152,21 +152,21 @@ namespace detail
 
 	/// Returns the length of the quaternion. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
     template <typename T> 
     T length(
 		detail::tquat<T> const & q);
 
     /// Returns the normalized quaternion. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	template <typename T> 
 	detail::tquat<T> normalize(
 		detail::tquat<T> const & q);
 		
     /// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ... 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	template <typename T> 
 	T dot(
 		detail::tquat<T> const & q1, 
@@ -174,7 +174,7 @@ namespace detail
 
 	/// Returns a SLERP interpolated quaternion of x and y according a. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	template <typename T> 
 	detail::tquat<T> mix(
 		detail::tquat<T> const & x, 
@@ -183,21 +183,21 @@ namespace detail
 		
 	/// Returns the q conjugate. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
     template <typename T> 
 	detail::tquat<T> conjugate(
 		detail::tquat<T> const & q);
 
 	/// Returns the q inverse. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
     template <typename T> 
 	detail::tquat<T> inverse(
 		detail::tquat<T> const & q);
 
 	/// Rotates a quaternion from an vector of 3 components axis and an angle expressed in degrees.
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	template <typename T> 
 	detail::tquat<T> rotate(
 		detail::tquat<T> const & q, 
@@ -206,65 +206,65 @@ namespace detail
 
 	/// Converts a quaternion to a 3 * 3 matrix. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
     template <typename T> 
 	detail::tmat3x3<T> mat3_cast(
 		detail::tquat<T> const & x);
 
 	/// Converts a quaternion to a 4 * 4 matrix. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	template <typename T> 
 	detail::tmat4x4<T> mat4_cast(
 		detail::tquat<T> const & x);
 
 	/// Converts a 3 * 3 matrix to a quaternion. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	template <typename T> 
 	detail::tquat<T> quat_cast(
 		detail::tmat3x3<T> const & x);
 
 	/// Converts a 4 * 4 matrix to a quaternion. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	template <typename T> 
 	detail::tquat<T> quat_cast(
 		detail::tmat4x4<T> const & x);
 
 	/// Quaternion of floating-point numbers. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
     typedef detail::tquat<float> quat;
 
 	/// Quaternion of half-precision floating-point numbers.
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	typedef detail::tquat<detail::thalf>	hquat;
 
 	/// Quaternion of single-precision floating-point numbers. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	typedef detail::tquat<float>	fquat;
 
 	/// Quaternion of double-precision floating-point numbers. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	typedef detail::tquat<double>	dquat;
 
 	/// Quaternion of low precision floating-point numbers.
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	typedef detail::tquat<lowp_float>		lowp_quat;
 
 	/// Quaternion of medium precision floating-point numbers. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	typedef detail::tquat<mediump_float>	mediump_quat;
 
 	/// Quaternion of high precision floating-point numbers. 
 	/// 
-	/// @see - gtc_quaternion
+	/// @see gtc_quaternion
 	typedef detail::tquat<highp_float>		highp_quat;
 
 	/// @}

glm/gtc/type_precision.hpp

@@ -22,7 +22,7 @@
 /// 
 /// @ref gtc_type_precision
 /// @file glm/gtc/type_precision.hpp
-/// @date 2009-06-04 / 2011-06-05
+/// @date 2009-06-04 / 2011-12-07
 /// @author Christophe Riccio
 /// 
 /// @see core (dependence)
@@ -60,186 +60,606 @@ namespace glm
 	/// @addtogroup gtc_type_precision
 	/// @{
 
-	typedef detail::int8						int8;         //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
+	/// 8 bit signed integer type. 
-	typedef detail::int16						int16;        //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::int32						int32;        //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef detail::int8 int8;
-	typedef detail::int64						int64;        //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension)
 	
-	typedef detail::int8						int8_t;         //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
+	/// 16 bit signed integer type. 
-	typedef detail::int16						int16_t;        //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::int32						int32_t;        //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef detail::int16 int16;
-	typedef detail::int64						int64_t;        //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension)
 
-	typedef int8								i8;         //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
+	/// 32 bit signed integer type. 
-	typedef int16								i16;        //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef int32								i32;        //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
+	typedef detail::int32 int32;
-	typedef int64								i64;        //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension)
 
-	typedef detail::tvec1<i8>					i8vec1;		//!< \brief 8bit signed integer scalar. (from GLM_GTC_type_precision extension)
+	/// 64 bit signed integer type. 
-	typedef detail::tvec2<i8>					i8vec2;     //!< \brief 8bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tvec3<i8>					i8vec3;     //!< \brief 8bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::int64 int64;
-	typedef detail::tvec4<i8>					i8vec4;     //!< \brief 8bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
 
-	typedef detail::tvec1<i16>					i16vec1;	//!< \brief 16bit signed integer scalar. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec2<i16>					i16vec2;    //!< \brief 16bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec3<i16>					i16vec3;    //!< \brief 16bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec4<i16>					i16vec4;    //!< \brief 16bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
 
-	typedef detail::tvec1<i32>					i32vec1;	//!< \brief 32bit signed integer scalar. (from GLM_GTC_type_precision extension)
+	/// 8 bit signed integer type. 
-	typedef detail::tvec2<i32>					i32vec2;    //!< \brief 32bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tvec3<i32>					i32vec3;    //!< \brief 32bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::int8 int8_t;
-	typedef detail::tvec4<i32>					i32vec4;    //!< \brief 32bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
+	
+	/// 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;
+	
+	/// 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. 
+	/// @see gtc_type_precision
+	typedef detail::tvec1<i8> i8vec1;
+	
+	/// 8 bit signed integer vector of 2 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec2<i8> i8vec2;
+
+	/// 8 bit signed integer vector of 3 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec3<i8> i8vec3;
+
+	/// 8 bit signed integer vector of 4 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec4<i8> i8vec4;
+
+
+	/// 16 bit signed integer scalar type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec1<i16> i16vec1;
+	
+	/// 16 bit signed integer vector of 2 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec2<i16> i16vec2;
+
+	/// 16 bit signed integer vector of 3 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec3<i16> i16vec3;
+
+	/// 16 bit signed integer vector of 4 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec4<i16> i16vec4;
+
+
+	/// 32 bit signed integer scalar type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec1<i32> i32vec1;
+	
+	/// 32 bit signed integer vector of 2 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec2<i32> i32vec2;
+
+	/// 32 bit signed integer vector of 3 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec3<i32> i32vec3;
+
+	/// 32 bit signed integer vector of 4 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec4<i32> i32vec4;
+
+
+	/// 64 bit signed integer scalar type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec1<i64> i64vec1;
+	
+	/// 64 bit signed integer vector of 2 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec2<i64> i64vec2;
+
+	/// 64 bit signed integer vector of 3 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec3<i64> i64vec3;
+
+	/// 64 bit signed integer vector of 4 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec4<i64> i64vec4;
 
-	typedef detail::tvec1<i64>					i64vec1;	//!< \brief 32bit signed integer scalar. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec2<i64>					i64vec2;    //!< \brief 64bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec3<i64>					i64vec3;    //!< \brief 64bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec4<i64>					i64vec4;    //!< \brief 64bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
 
 	/////////////////////////////
 	// Unsigned int vector types 
 
-	typedef detail::uint8						uint8;         //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension)
+	/// 8 bit unsigned integer type. 
-	typedef detail::uint16						uint16;        //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::uint32						uint32;        //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef detail::uint8 uint8;
-	typedef detail::uint64						uint64;        //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension)
 	
-	typedef detail::uint8						uint8_t;         //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension)
+	/// 16 bit unsigned integer type. 
-	typedef detail::uint16						uint16_t;        //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::uint32						uint32_t;        //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef detail::uint16 uint16;
-	typedef detail::uint64						uint64_t;        //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension)
 
-	typedef uint8								u8;         //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension)
+	/// 32 bit unsigned integer type. 
-	typedef uint16								u16;        //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef uint32								u32;        //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension)
+	typedef detail::uint32 uint32;
-	typedef uint64								u64;        //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension)
 
-	typedef detail::tvec1<u8>					u8vec1;		//!< \brief 8bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
+	/// 64 bit unsigned integer type. 
-	typedef detail::tvec2<u8>					u8vec2;     //!< \brief 8bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tvec3<u8>					u8vec3;     //!< \brief 8bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::uint64 uint64;
-	typedef detail::tvec4<u8>					u8vec4;     //!< \brief 8bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
 
-	typedef detail::tvec1<u16>					u16vec1;    //!< \brief 16bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec2<u16>					u16vec2;    //!< \brief 16bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec3<u16>					u16vec3;    //!< \brief 16bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec4<u16>					u16vec4;    //!< \brief 16bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
 
-	typedef detail::tvec1<u32>					u32vec1;    //!< \brief 32bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
+	/// 8 bit unsigned integer type. 
-	typedef detail::tvec2<u32>					u32vec2;    //!< \brief 32bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tvec3<u32>					u32vec3;    //!< \brief 32bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::uint8 uint8_t;
-	typedef detail::tvec4<u32>					u32vec4;    //!< \brief 32bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
+	
+	/// 16 bit unsigned integer type. 
+	/// @see gtc_type_precision
+	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;
+	
+	/// 16 bit unsigned integer type. 
+	/// @see gtc_type_precision
+	typedef detail::uint16 u16;
+
+	/// 32 bit unsigned integer type. 
+	/// @see gtc_type_precision
+	typedef detail::uint32 u32;
+
+	/// 64 bit unsigned integer type. 
+	/// @see gtc_type_precision
+	typedef detail::uint64 u64;
+
+
+	/// 8 bit unsigned integer scalar type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u8> u8vec1;
+	
+	/// 8 bit unsigned integer vector of 2 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u8> u8vec2;
+
+	/// 8 bit unsigned integer vector of 3 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec3<u8> u8vec3;
+
+	/// 8 bit unsigned integer vector of 4 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u8> u8vec4;
+
+
+	/// 16 bit unsigned integer scalar type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u16> u16vec1;
+	
+	/// 16 bit unsigned integer vector of 2 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u16> u16vec2;
+
+	/// 16 bit unsigned integer vector of 3 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec3<u16> u16vec3;
+
+	/// 16 bit unsigned integer vector of 4 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u16> u16vec4;
+
+
+	/// 32 bit unsigned integer scalar type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u32> u32vec1;
+	
+	/// 32 bit unsigned integer vector of 2 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u32> u32vec2;
+
+	/// 32 bit unsigned integer vector of 3 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec3<u32> u32vec3;
+
+	/// 32 bit unsigned integer vector of 4 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u32> u32vec4;
+
+
+	/// 64 bit unsigned integer scalar type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec1<u64> u64vec1;
+	
+	/// 64 bit unsigned integer vector of 2 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec2<u64> u64vec2;
+
+	/// 64 bit unsigned integer vector of 3 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec3<u64> u64vec3;
+
+	/// 64 bit unsigned integer vector of 4 components type. 
+	/// @see gtc_type_precision
+	typedef detail::tvec4<u64> u64vec4;
 
-	typedef detail::tvec1<u64>					u64vec1;    //!< \brief 64bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec2<u64>					u64vec2;    //!< \brief 64bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec3<u64>					u64vec3;    //!< \brief 64bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec4<u64>					u64vec4;    //!< \brief 64bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
 
 	//////////////////////
 	// Float vector types 
 
-	typedef detail::float16						float16;	//!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// 16 bit half-precision floating-point scalar. 
-	typedef detail::float32						float32;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::float64						float64;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::float16 float16;
 
-	typedef detail::float16						float16_t;	//!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// 32 bit single-precision floating-point scalar. 
-	typedef detail::float32						float32_t;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::float64						float64_t;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::float32 float32;
 
-	typedef float16								f16;        //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// 64 bit double-precision floating-point scalar. 
-	typedef float32								f32;        //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef float64								f64;        //!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	typedef detail::float64 float64;
 
-	typedef detail::tvec2<float>				fvec2;		//!<  Vector of 2 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec3<float>				fvec3;		//!<  Vector of 3 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec4<float>				fvec4;		//!<  Vector of 4 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
 
-	typedef detail::tvec1<f16>					f16vec1;    //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// 16 bit half-precision floating-point scalar. 
-	typedef detail::tvec2<f16>					f16vec2;    //!< \brief Half-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tvec3<f16>					f16vec3;    //!< \brief Half-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::float16 float16_t;
-	typedef detail::tvec4<f16>					f16vec4;    //!< \brief Half-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
 
-	typedef detail::tvec1<f32>					f32vec1;    //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// 32 bit single-precision floating-point scalar. 
-	typedef detail::tvec2<f32>					f32vec2;    //!< \brief Single-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tvec3<f32>					f32vec3;    //!< \brief Single-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
+	typedef detail::float32 float32_t;
-	typedef detail::tvec4<f32>					f32vec4;    //!< \brief Single-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
+
+	/// 64 bit double-precision floating-point scalar. 
+	/// @see gtc_type_precision
+	typedef detail::float64 float64_t;
+
+
+	/// 16 bit half-precision floating-point scalar. 
+	/// @see gtc_type_precision
+	typedef float16 f16;
+
+	/// 32 bit single-precision floating-point scalar. 
+	/// @see gtc_type_precision
+	typedef float32 f32;
+
+	/// 64 bit double-precision floating-point scalar. 
+	/// @see gtc_type_precision
+	typedef float64 f64;
+
+
+	/// Single-precision floating-point vector of 1 component. 
+	/// @see gtc_type_precision
+	typedef detail::tvec1<float> fvec1;
+
+	/// Single-precision floating-point vector of 2 components. 
+	/// @see gtc_type_precision
+	typedef detail::tvec2<float> fvec2;
+
+	/// Single-precision floating-point vector of 3 components. 
+	/// @see gtc_type_precision
+	typedef detail::tvec3<float> fvec3;
+
+	/// Single-precision floating-point vector of 4 components. 
+	/// @see gtc_type_precision
+	typedef detail::tvec4<float> fvec4;
+
+
+	/// Half-precision floating-point vector of 1 component. 
+	/// @see gtc_type_precision
+	typedef detail::tvec1<f16> f16vec1;
+
+	/// Half-precision floating-point vector of 2 components. 
+	/// @see gtc_type_precision
+	typedef detail::tvec2<f16> f16vec2;
+
+	/// Half-precision floating-point vector of 3 components. 
+	/// @see gtc_type_precision
+	typedef detail::tvec3<f16> f16vec3;
+
+	/// Half-precision floating-point vector of 4 components. 
+	/// @see gtc_type_precision
+	typedef detail::tvec4<f16> f16vec4;
+
+	
+	/// Single-precision floating-point vector of 1 component. 
+	/// @see gtc_type_precision
+	typedef detail::tvec1<f32> f32vec1;
+
+	/// Single-precision floating-point vector of 2 components. 
+	/// @see gtc_type_precision
+	typedef detail::tvec2<f32> f32vec2;
+
+	/// Single-precision floating-point vector of 3 components. 
+	/// @see gtc_type_precision
+	typedef detail::tvec3<f32> f32vec3;
+
+	/// Single-precision floating-point vector of 4 components. 
+	/// @see gtc_type_precision
+	typedef detail::tvec4<f32> f32vec4;
+
+
+	/// Double-precision floating-point vector of 1 component. 
+	/// @see gtc_type_precision
+	typedef detail::tvec1<f64> f64vec1;
+
+	/// Double-precision floating-point vector of 2 components. 
+	/// @see gtc_type_precision
+	typedef detail::tvec2<f64> f64vec2;
+
+	/// Double-precision floating-point vector of 3 components. 
+	/// @see gtc_type_precision
+	typedef detail::tvec3<f64> f64vec3;
+
+	/// Double-precision floating-point vector of 4 components. 
+	/// @see gtc_type_precision
+	typedef detail::tvec4<f64> f64vec4;
 
-	typedef detail::tvec1<f64>					f64vec1;    //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec2<f64>					f64vec2;    //!< \brief Double-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec3<f64>					f64vec3;    //!< \brief Double-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
-	typedef detail::tvec4<f64>					f64vec4;    //!< \brief Double-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
 
 	//////////////////////
 	// Float matrix types 
 
-	//typedef f32									fmat1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// Single-precision floating-point 1x1 matrix. 
-	typedef detail::tmat2x2<f32>				fmat2;	//!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f32>				fmat3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	//typedef detail::tmat1x1<f32> fmat1;
-	typedef detail::tmat4x4<f32>				fmat4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
 
-	//typedef f32									fmat1x1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// Single-precision floating-point 2x2 matrix. 
-	typedef detail::tmat2x2<f32>				fmat2x2;  //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f32>				fmat2x3;	//!< \brief Single-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f32> fmat2;
-	typedef detail::tmat2x4<f32>				fmat2x4;	//!< \brief Single-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x2<f32>				fmat3x2;	//!< \brief Single-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x3<f32>				fmat3x3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x4<f32>				fmat3x4;	//!< \brief Single-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x2<f32>				fmat4x2;	//!< \brief Single-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x3<f32>				fmat4x3;	//!< \brief Single-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x4<f32>				fmat4x4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
 
-	//typedef f16									f16mat1;    //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// Single-precision floating-point 3x3 matrix. 
-	typedef detail::tmat2x2<f16>				f16mat2;	//!< \brief Half-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f16>				f16mat3;	//!< \brief Half-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat3x3<f32> fmat3;
-	typedef detail::tmat4x4<f16>				f16mat4;	//!< \brief Half-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
 
-	//typedef f16									f16mat1x1;	//!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// Single-precision floating-point 4x4 matrix. 
-	typedef detail::tmat2x2<f16>				f16mat2x2;	//!< \brief Half-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f16>				f16mat2x3;	//!< \brief Half-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat4x4<f32> fmat4;
-	typedef detail::tmat2x4<f16>				f16mat2x4;	//!< \brief Half-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x2<f16>				f16mat3x2;	//!< \brief Half-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x3<f16>				f16mat3x3;	//!< \brief Half-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x4<f16>				f16mat3x4;	//!< \brief Half-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x2<f16>				f16mat4x2;	//!< \brief Half-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x3<f16>				f16mat4x3;	//!< \brief Half-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x4<f16>				f16mat4x4;	//!< \brief Half-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
 
-	//typedef f32									f32mat1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat2x2<f32>				f32mat2;	//!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x3<f32>				f32mat3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x4<f32>				f32mat4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
 
-	//typedef f32									f32mat1x1;	//!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// Single-precision floating-point 1x1 matrix. 
-	typedef detail::tmat2x2<f32>				f32mat2x2;  //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tmat2x3<f32>				f32mat2x3;	//!< \brief Single-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
+	//typedef f32 fmat1x1;
-	typedef detail::tmat2x4<f32>				f32mat2x4;	//!< \brief Single-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x2<f32>				f32mat3x2;	//!< \brief Single-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x3<f32>				f32mat3x3;	//!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x4<f32>				f32mat3x4;	//!< \brief Single-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x2<f32>				f32mat4x2;	//!< \brief Single-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x3<f32>				f32mat4x3;	//!< \brief Single-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x4<f32>				f32mat4x4;	//!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
 
-	//typedef f64									f64mat1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
+	/// Single-precision floating-point 2x2 matrix. 
-	typedef detail::tmat2x2<f64>				f64mat2;	//!< \brief Double-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tmat3x3<f64>				f64mat3;	//!< \brief Double-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
+	typedef detail::tmat2x2<f32> fmat2x2;
-	typedef detail::tmat4x4<f64>				f64mat4;	//!< \brief Double-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
+
+	/// Single-precision floating-point 2x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f32> fmat2x3;
+
+	/// Single-precision floating-point 2x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f32> fmat2x4;
+
+	/// Single-precision floating-point 3x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f32> fmat3x2;
+
+	/// Single-precision floating-point 3x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f32> fmat3x3;
+
+	/// Single-precision floating-point 3x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f32> fmat3x4;
+
+	/// Single-precision floating-point 4x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f32> fmat4x2;
+
+	/// Single-precision floating-point 4x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f32> fmat4x3;
+
+	/// Single-precision floating-point 4x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f32> fmat4x4;
+
+
+	/// Half-precision floating-point 1x1 matrix. 
+	/// @see gtc_type_precision
+	//typedef detail::tmat1x1<f16> f16mat1;
+
+	/// Half-precision floating-point 2x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f16> f16mat2;
+
+	/// Half-precision floating-point 3x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f16> f16mat3;
+
+	/// Half-precision floating-point 4x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f16> f16mat4;
+
+
+	/// Half-precision floating-point 1x1 matrix. 
+	/// @see gtc_type_precision
+	//typedef f16 f16mat1x1;
+
+	/// Half-precision floating-point 2x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f16> f16mat2x2;
+
+	/// Half-precision floating-point 2x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f16> f16mat2x3;
+
+	/// Half-precision floating-point 2x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f16> f16mat2x4;
+
+	/// Half-precision floating-point 3x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f16> f16mat3x2;
+
+	/// Half-precision floating-point 3x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f16> f16mat3x3;
+
+	/// Half-precision floating-point 3x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f16> f16mat3x4;
+
+	/// Half-precision floating-point 4x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f16> f16mat4x2;
+
+	/// Half-precision floating-point 4x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f16> f16mat4x3;
+
+	/// Half-precision floating-point 4x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f16> f16mat4x4;
+
+
+	/// Single-precision floating-point 1x1 matrix. 
+	/// @see gtc_type_precision
+	//typedef detail::tmat1x1<f32> f32mat1;
+
+	/// Single-precision floating-point 2x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f32> f32mat2;
+
+	/// Single-precision floating-point 3x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f32> f32mat3;
+
+	/// Single-precision floating-point 4x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f32> f32mat4;
+
+
+	/// Single-precision floating-point 1x1 matrix. 
+	/// @see gtc_type_precision
+	//typedef f32 f32mat1x1;
+
+	/// Single-precision floating-point 2x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f32> f32mat2x2;
+
+	/// Single-precision floating-point 2x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f32> f32mat2x3;
+
+	/// Single-precision floating-point 2x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f32> f32mat2x4;
+
+	/// Single-precision floating-point 3x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f32> f32mat3x2;
+
+	/// Single-precision floating-point 3x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f32> f32mat3x3;
+
+	/// Single-precision floating-point 3x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f32> f32mat3x4;
+
+	/// Single-precision floating-point 4x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f32> f32mat4x2;
+
+	/// Single-precision floating-point 4x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f32> f32mat4x3;
+
+	/// Single-precision floating-point 4x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f32> f32mat4x4;
+
+
+	/// Double-precision floating-point 1x1 matrix. 
+	/// @see gtc_type_precision
+	//typedef detail::tmat1x1<f64> f64mat1;
+
+	/// Double-precision floating-point 2x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f64> f64mat2;
+
+	/// Double-precision floating-point 3x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f64> f64mat3;
+
+	/// Double-precision floating-point 4x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f64> f64mat4;
+
+
+	/// Double-precision floating-point 1x1 matrix. 
+	/// @see gtc_type_precision
+	//typedef f64 f64mat1x1;
+
+	/// Double-precision floating-point 2x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x2<f64> f64mat2x2;
+
+	/// Double-precision floating-point 2x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x3<f64> f64mat2x3;
+
+	/// Double-precision floating-point 2x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat2x4<f64> f64mat2x4;
+
+	/// Double-precision floating-point 3x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x2<f64> f64mat3x2;
+
+	/// Double-precision floating-point 3x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x3<f64> f64mat3x3;
+
+	/// Double-precision floating-point 3x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat3x4<f64> f64mat3x4;
+
+	/// Double-precision floating-point 4x2 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x2<f64> f64mat4x2;
+
+	/// Double-precision floating-point 4x3 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x3<f64> f64mat4x3;
+
+	/// Double-precision floating-point 4x4 matrix. 
+	/// @see gtc_type_precision
+	typedef detail::tmat4x4<f64> f64mat4x4;
 
-	//typedef f64									f64mat1x1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat2x2<f64>				f64mat2x2;	//!< \brief Double-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat2x3<f64>				f64mat2x3;	//!< \brief Double-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat2x4<f64>				f64mat2x4;	//!< \brief Double-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x2<f64>				f64mat3x2;	//!< \brief Double-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x3<f64>				f64mat3x3;	//!< \brief Double-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat3x4<f64>				f64mat3x4;	//!< \brief Double-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x2<f64>				f64mat4x2;	//!< \brief Double-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x3<f64>				f64mat4x3;	//!< \brief Double-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
-	typedef detail::tmat4x4<f64>				f64mat4x4;	//!< \brief Double-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
 
 	//////////////////////////
-	// Float quaternion types 
+	// Quaternion types 
 
-	typedef detail::tquat<f16>					f16quat;    //!< \brief Half-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
+	/// Half-precision floating-point quaternion. 
-	typedef detail::tquat<f32>					f32quat;    //!< \brief Single-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
+	/// @see gtc_type_precision
-	typedef detail::tquat<f64>					f64quat;    //!< \brief Double-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
+	typedef detail::tquat<f16> f16quat;
+
+	/// Single-precision floating-point quaternion. 
+	/// @see gtc_type_precision
+	typedef detail::tquat<f32> f32quat;
+
+	/// Double-precision floating-point quaternion. 
+	/// @see gtc_type_precision
+	typedef detail::tquat<f64> f64quat;
 
 	/// @}
 }//namespace glm

glm/gtx/associated_min_max.hpp

@@ -50,20 +50,23 @@ namespace glm
 	/// @addtogroup gtx_associated_min_max
 	/// @{
 
-	//! \brief Min comparison between 2 variables
+	/// Min comparison between 2 variables
+	/// @see gtx_associated_min_max
 	template<typename genTypeT, typename genTypeU>
 	genTypeU associatedMin(
 		const genTypeT& x, const genTypeU& a, 
 		const genTypeT& y, const genTypeU& b);
 
-	//! \brief Min comparison between 3 variables
+	/// Min comparison between 3 variables
+	/// @see gtx_associated_min_max
 	template<typename genTypeT, typename genTypeU>
 	genTypeU associatedMin(
 		const genTypeT& x, const genTypeU& a, 
 		const genTypeT& y, const genTypeU& b, 
 		const genTypeT& z, const genTypeU& c);
 
-	//! \brief Min comparison between 4 variables
+	/// Min comparison between 4 variables
+	/// @see gtx_associated_min_max
 	template<typename genTypeT, typename genTypeU>
 	genTypeU associatedMin(
 		const genTypeT& x, const genTypeU& a, 
@@ -71,20 +74,23 @@ namespace glm
 		const genTypeT& z, const genTypeU& c, 
 		const genTypeT& w, const genTypeU& d);
 
-	//! \brief Max comparison between 2 variables
+	/// Max comparison between 2 variables
+	/// @see gtx_associated_min_max
 	template<typename genTypeT, typename genTypeU>
 	genTypeU associatedMax(
 		const genTypeT& x, const genTypeU& a, 
 		const genTypeT& y, const genTypeU& b);
 
-	//! \brief Max comparison between 3 variables
+	/// Max comparison between 3 variables
+	/// @see gtx_associated_min_max
 	template<typename genTypeT, typename genTypeU>
 	genTypeU associatedMax(
 		const genTypeT& x, const genTypeU& a, 
 		const genTypeT& y, const genTypeU& b, 
 		const genTypeT& z, const genTypeU& c);
 
-	//! \brief Max comparison between 4 variables
+	/// Max comparison between 4 variables
+	/// @see gtx_associated_min_max
 	template<typename genTypeT, typename genTypeU>
 	genTypeU associatedMax(
 		const genTypeT& x, const genTypeU& a, 

glm/gtx/bit.hpp

@@ -53,13 +53,13 @@ namespace glm
 	/// @{
 
 	/// Build a mask of 'count' bits
-	/// From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genIType>
 	genIType mask(genIType const & count);
 
 	/// Component wise extraction of bit fields.
 	/// genType and genIType could be a scalar or a vector.
-	/// From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genIUType, typename sizeType>
 	genIUType extractField(
 		genIUType const & v, 
@@ -67,57 +67,57 @@ namespace glm
 		sizeType const & count);
 
 	//! Find the lowest bit set to 1 in a integer variable.
-	//! From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genType> 
 	int lowestBit(genType const & value);
 
 	//! Find the highest bit set to 1 in a integer variable.
-	//! From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genType> 
 	int highestBit(genType const & value);
 
 	//! Find the highest bit set to 1 in a integer variable and return its value. 
-	//! From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genType> 
 	genType highestBitValue(genType const & value);
 
 	//! Return true if the value is a power of two number. 
-	//! From GLM_GTX_bit extension. 
+	/// @see gtx_bit
 	template <typename genType> 
 	bool isPowerOfTwo(genType const & value);
 
 	//! Return the power of two number which value is just higher the input value.
-	//! From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genType> 
 	genType powerOfTwoAbove(genType const & value);
 
 	//! Return the power of two number which value is just lower the input value. 
-	//! From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genType> 
 	genType powerOfTwoBelow(genType const & value);
 
 	//! Return the power of two number which value is the closet to the input value. 
-	//! From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genType> 
 	genType powerOfTwoNearest(genType const & value);
 
 	//! Revert all bits of any integer based type. 
-	//! From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genType> 
 	genType bitRevert(genType const & value);
 
 	//! Rotate all bits to the right.
-	//! From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genType>
 	genType bitRotateRight(genType const & In, std::size_t Shift);
 
 	//! Rotate all bits to the left.
-	//! From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genType>
 	genType bitRotateLeft(genType const & In, std::size_t Shift);
 
 	//! Set to 1 a range of bits.
-	//! From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genIUType>
 	genIUType fillBitfieldWithOne(
 		genIUType const & Value,
@@ -125,7 +125,7 @@ namespace glm
 		int const & ToBit);
 
 	//! Set to 0 a range of bits.
-	//! From GLM_GTX_bit extension.
+	/// @see gtx_bit
 	template <typename genIUType>
 	genIUType fillBitfieldWithZero(
 		genIUType const & Value,

glm/gtx/closest_point.hpp

@@ -51,7 +51,7 @@ namespace glm
 	/// @{
 
 	/// Find the point on a straight line which is the closet of a point. 
-	/// From GLM_GTX_closest_point extension.
+	/// @see gtx_closest_point
 	template <typename T> 
 	detail::tvec3<T> closestPointOnLine(
 		detail::tvec3<T> const & point, 

glm/gtx/color_cast.hpp

@@ -53,11 +53,11 @@ namespace glm
 	/// @{
 
 	//! Conversion of a floating value into a 8bit unsigned int value. 
-	//! From GLM_GTX_color_cast extension.
+	/// @see gtx_color_cast
 	template <typename valType> uint8 u8channel_cast(valType a);
 
-	//! Conversion of a floating value into a 16bit unsigned int value. 
+	/// Conversion of a floating value into a 16bit unsigned int value. 
-	//! From GLM_GTX_color_cast extension.
+	/// @see gtx_color_cast
 	template <typename valType>	uint16 u16channel_cast(valType a);
 
 	template <typename T> uint32 u32_rgbx_cast(const detail::tvec3<T>& c);		//!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)

glm/gtx/color_space.hpp

@@ -50,40 +50,40 @@ namespace glm
 	/// @addtogroup gtx_color_space
 	/// @{
 
-	//! Converts a color from HSV color space to its color in RGB color space.
+	/// Converts a color from HSV color space to its color in RGB color space.
-	//! From GLM_GTX_color_space extension.
+	/// @see gtx_color_space
     template <typename valType> 
 	detail::tvec3<valType> rgbColor(
 		detail::tvec3<valType> const & hsvValue);
 
-	//! Converts a color from RGB color space to its color in HSV color space.
+	/// Converts a color from RGB color space to its color in HSV color space.
-	//! From GLM_GTX_color_space extension.
+	/// @see gtx_color_space
     template <typename valType> 
 	detail::tvec3<valType> hsvColor(
 		detail::tvec3<valType> const & rgbValue);
 		
-	//! Build a saturation matrix.
+	/// Build a saturation matrix.
-	//! From GLM_GTX_color_space extension
+	/// @see gtx_color_space
     template <typename valType> 
 	detail::tmat4x4<valType> saturation(
 		valType const s);
 
-    //! Modify the saturation of a color.
+    /// Modify the saturation of a color.
-	//! From GLM_GTX_color_space extension.
+	/// @see gtx_color_space
 	template <typename valType> 
 	detail::tvec3<valType> saturation(
 		valType const s, 
 		detail::tvec3<valType> const & color);
 		
-	//! Modify the saturation of a color.
+	/// Modify the saturation of a color.
-	//! From GLM_GTX_color_space extension.
+	/// @see gtx_color_space
     template <typename valType> 
 	detail::tvec4<valType> saturation(
 		valType const s, 
 		detail::tvec4<valType> const & color);
 		
-	//! Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
+	/// Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
-	//! From GLM_GTX_color_space extension.
+	/// @see gtx_color_space
 	template <typename valType> 
 	valType luminosity(
 		detail::tvec3<valType> const & color);

glm/gtx/color_space_YCoCg.hpp

@@ -50,28 +50,28 @@ namespace glm
 	/// @addtogroup gtx_color_space_YCoCg
 	/// @{
 
-    //! Convert a color from RGB color space to YCoCg color space.
+    /// Convert a color from RGB color space to YCoCg color space.
-	//! From GLM_GTX_color_space_YCoCg extension.
+	/// @see gtx_color_space_YCoCg
 	template <typename valType> 
 	detail::tvec3<valType> rgb2YCoCg(
 		detail::tvec3<valType> const & rgbColor);
 
-    //! Convert a color from YCoCg color space to RGB color space.
+    /// Convert a color from YCoCg color space to RGB color space.
-	//! From GLM_GTX_color_space_YCoCg extension.
+	/// @see gtx_color_space_YCoCg
     template <typename valType> 
 	detail::tvec3<valType> YCoCg2rgb(
 		detail::tvec3<valType> const & YCoCgColor);
 
-    //! Convert a color from RGB color space to YCoCgR color space.
+    /// Convert a color from RGB color space to YCoCgR color space.
-	//! \see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
+	/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
-	//! From GLM_GTX_color_space_YCoCg extension.
+	/// @see gtx_color_space_YCoCg
 	template <typename valType> 
 	detail::tvec3<valType> rgb2YCoCgR(
 		detail::tvec3<valType> const & rgbColor);
 
-    //! Convert a color from YCoCgR color space to RGB color space.
+    /// Convert a color from YCoCgR color space to RGB color space.
-	//! \see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
+	/// @see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
-	//! From GLM_GTX_color_space_YCoCg extension.
+	/// @see gtx_color_space_YCoCg
     template <typename valType> 
 	detail::tvec3<valType> YCoCgR2rgb(
 		detail::tvec3<valType> const & YCoCgColor);

glm/gtx/component_wise.hpp

@@ -50,26 +50,26 @@ namespace glm
 	/// @addtogroup gtx_component_wise
 	/// @{
 
-	//! Add all vector components together. 
+	/// Add all vector components together. 
-	//! From GLM_GTX_component_wise extension.
+	/// @see gtx_component_wise
 	template <typename genType> 
 	typename genType::value_type compAdd(
 		genType const & v);
 
-	//! Multiply all vector components together. 
+	/// Multiply all vector components together. 
-	//! From GLM_GTX_component_wise extension.
+	/// @see gtx_component_wise
 	template <typename genType> 
 	typename genType::value_type compMul(
 		genType const & v);
 
-	//! Find the minimum value between single vector components.
+	/// Find the minimum value between single vector components.
-	//! From GLM_GTX_component_wise extension.
+	/// @see gtx_component_wise
 	template <typename genType> 
 	typename genType::value_type compMin(
 		genType const & v);
 
-	//! Find the maximum value between single vector components.
+	/// Find the maximum value between single vector components.
-	//! From GLM_GTX_component_wise extension.
+	/// @see gtx_component_wise
 	template <typename genType> 
 	typename genType::value_type compMax(
 		genType const & v);

glm/gtx/constants.hpp

@@ -52,126 +52,106 @@ namespace glm
 	/// @addtogroup gtx_constants
 	/// @{
 
+	/// Return the epsilon constant for floating point types.
 	/// @todo Implement epsilon for half-precision floating point type.
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T epsilon()
+	T epsilon();
-	{
-		return std::numeric_limits<T>::epsilon();
-	}
 
+	/// Return the pi constant.
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T pi()
+	T pi();
-	{
-		return T(3.14159265358979323846264338327950288);
-	}
 
+	/// Return square root of pi.
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T root_pi()
+	T root_pi();
-	{
-		return T(1.772453850905516027);
-	}
 
+	/// Return pi / 2.
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T half_pi()
+	T half_pi();
-	{
-		return T(1.57079632679489661923132169163975144);
-	}
 
+	/// Return pi / 4.
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T quarter_pi()
+	T quarter_pi();
-	{
-		return T(0.785398163397448309615660845819875721);
-	}
 
+	/// Return 1 / pi.
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T one_over_pi()
+	T one_over_pi();
-	{
-		return T(0.318309886183790671537767526745028724);
-	}
 
+	/// Return 2 / pi.
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T two_over_pi()
+	T two_over_pi();
-	{
-		return T(0.636619772367581343075535053490057448);
-	}
 
+	/// Return 2 / sqrt(pi).
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T two_over_root_pi()
+	T two_over_root_pi();
-	{
-		return T(1.12837916709551257389615890312154517);
-	}
 
+	/// Return 1 / sqrt(2).
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T one_over_root_two()
+	T one_over_root_two();
-	{
-		return T(0.707106781186547524400844362104849039);
-	}
 
+	/// Return sqrt(pi / 2).
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T root_half_pi()
+	T root_half_pi();
-	{
-		return T(1.253314137315500251);
-	}
 
+	/// Return sqrt(2 * pi).
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T root_two_pi()
+	T root_two_pi();
-	{
-		return T(2.506628274631000502);
-	}
 
+	/// Return sqrt(ln(4)).
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T root_ln_four()
+	T root_ln_four();
-	{
-		return T(1.17741002251547469);
-	}
 
+	/// Return e constant.
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T e()
+	T e();
-	{
-		return T(2.71828182845904523536);
-	}
 
+	/// Return Euler's constant.
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T euler()
+	T euler();
-	{
-		return T(0.577215664901532860606);
-	}
 
+	/// Return sqrt(2).
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T root_two()
+	T root_two();
-	{
-		return T(1.41421356237309504880168872420969808);
-	}
 
+	/// Return ln(2).
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T ln_two()
+	T ln_two();
-	{
-		return T(0.693147180559945309417232121458176568);
-	}
 
+	/// Return ln(10).
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T ln_ten()
+	T ln_ten();
-	{
-		return T(2.30258509299404568401799145468436421);
-	}
 
+	/// Return ln(ln(2)).
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T ln_ln_two()
+	T ln_ln_two();
-	{
-		return T(-0.3665129205816643);
-	}
 
+	/// Return 1 / 3.
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T third()
+	T third();
-	{
-		return T(0.333333333333333333);
-	}
 
+	/// Return 2 / 3.
+	/// @see gtx_constants
 	template <typename T>
-	GLM_FUNC_QUALIFIER T twothirds()
+	T twothirds();
-	{
-		return T(0.666666666666666666);
-	}
 
 	/// @}
 } //namespace glm

glm/gtx/constants.inl

@@ -25,3 +25,126 @@
 /// @date 2011-10-14 / 2011-10-14
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////
+
+namespace glm
+{
+	template <typename T>
+	GLM_FUNC_QUALIFIER T epsilon()
+	{
+		return std::numeric_limits<T>::epsilon();
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T pi()
+	{
+		return T(3.14159265358979323846264338327950288);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T root_pi()
+	{
+		return T(1.772453850905516027);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T half_pi()
+	{
+		return T(1.57079632679489661923132169163975144);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T quarter_pi()
+	{
+		return T(0.785398163397448309615660845819875721);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T one_over_pi()
+	{
+		return T(0.318309886183790671537767526745028724);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T two_over_pi()
+	{
+		return T(0.636619772367581343075535053490057448);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T two_over_root_pi()
+	{
+		return T(1.12837916709551257389615890312154517);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T one_over_root_two()
+	{
+		return T(0.707106781186547524400844362104849039);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T root_half_pi()
+	{
+		return T(1.253314137315500251);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T root_two_pi()
+	{
+		return T(2.506628274631000502);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T root_ln_four()
+	{
+		return T(1.17741002251547469);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T e()
+	{
+		return T(2.71828182845904523536);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T euler()
+	{
+		return T(0.577215664901532860606);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T root_two()
+	{
+		return T(1.41421356237309504880168872420969808);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T ln_two()
+	{
+		return T(0.693147180559945309417232121458176568);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T ln_ten()
+	{
+		return T(2.30258509299404568401799145468436421);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T ln_ln_two()
+	{
+		return T(-0.3665129205816643);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T third()
+	{
+		return T(0.333333333333333333);
+	}
+
+	template <typename T>
+	GLM_FUNC_QUALIFIER T twothirds()
+	{
+		return T(0.666666666666666667);
+	}
+} //namespace glm

glm/gtx/extend.hpp

@@ -50,8 +50,8 @@ namespace glm
 	/// @addtogroup gtx_extend
 	/// @{
 
-	//! Extends of Length the Origin position using the (Source - Origin) direction.
+	/// Extends of Length the Origin position using the (Source - Origin) direction.
-	//! From GLM_GTX_extend extension.
+	/// From GLM_GTX_extend extension.
 	template <typename genType> 
 	genType extend(
 		genType const & Origin,