Apply 'basic grouping patch' Ticket #36

doc/doxyfile

@@ -590,7 +590,7 @@ WARN_LOGFILE           =
 # directories like "/usr/src/myproject". Separate the files or directories 
 # with spaces.
 
-INPUT                  = ../glm
+INPUT                  = ../glm .
 
 # This tag can be used to specify the character encoding of the source files 
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is 
@@ -607,7 +607,7 @@ INPUT_ENCODING         = UTF-8
 # *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx 
 # *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
 
-FILE_PATTERNS          = *.hpp
+FILE_PATTERNS          = *.hpp *.doxy
 
 # The RECURSIVE tag can be used to turn specify whether or not subdirectories 
 # should be searched for input files as well. Possible values are YES and NO. 
@@ -641,7 +641,7 @@ EXCLUDE_PATTERNS       =
 # wildcard * is used, a substring. Examples: ANamespace, AClass, 
 # AClass::ANamespace, ANamespace::*Test
 
-EXCLUDE_SYMBOLS        = detail
+EXCLUDE_SYMBOLS        = 
 
 # The EXAMPLE_PATH tag can be used to specify one or more files or 
 # directories that contain example code fragments that are included (see 

glm/core/func_common.hpp

@@ -21,6 +21,9 @@ namespace glm
 	//! Define common functions from Section 8.3 of GLSL 1.30.8 specification. Included in glm namespace.
 	namespace common{
 
+	/// \addtogroup core_funcs
+	///@{
+
 	//! Returns x if x >= 0; otherwise, it returns -x. 
 	//! (From GLSL 1.30.08 specification, section 8.3)
 	template <typename genFIType> 
@@ -262,6 +265,8 @@ namespace glm
 	template <typename genType, typename genIType>
 	genType ldexp(genType const & x, genIType const & exp);
 
+	///@}
+
 	}//namespace common
 	}//namespace function
 	}//namespace core

glm/core/func_exponential.hpp

@@ -21,6 +21,9 @@ namespace glm
 	//! Define all exponential functions from Section 8.2 of GLSL 1.30.8 specification. Included in glm namespace.
 	namespace exponential{
 
+	/// \addtogroup core_funcs
+	///@{
+
 	//! Returns x raised to the y power. 
 	//! (From GLSL 1.30.08 specification, section 8.2)
 	template <typename genType> 
@@ -59,6 +62,8 @@ namespace glm
 	template <typename genType> 
 	genType inversesqrt(genType const & x);
 
+	///@}
+
 	}//namespace exponential
 	}//namespace function
 	}//namespace core

glm/core/func_geometric.hpp

@@ -21,6 +21,9 @@ namespace glm
 	//! Define all geometric functions from Section 8.4 of GLSL 1.30.8 specification. Included in glm namespace.
 	namespace geometric{
 
+	/// \addtogroup core_funcs
+	///@{
+
 	//! Returns the length of x, i.e., sqrt(x * x).
 	//! (From GLSL 1.30.08 specification, section 8.4)
 	template <typename genType> 
@@ -80,6 +83,8 @@ namespace glm
 		genType const & N, 
 		typename genType::value_type const & eta);
 
+	///@}
+
 	}//namespace geometric
 	}//namespace function
 	}//namespace core

glm/core/func_integer.hpp

@@ -21,6 +21,9 @@ namespace glm
 	//! Define integer functions from Section 8.8 of GLSL 4.00.8 specification. 
 	namespace integer{
 
+		/// \addtogroup core_funcs
+		///@{
+
 		//! Adds 32-bit unsigned integer x and y, returning the sum
 		//! modulo pow(2, 32). The value carry is set to 0 if the sum was
 		//! less than pow(2, 32), or to 1 otherwise.
@@ -128,6 +131,8 @@ namespace glm
 		template <typename T, template <typename> class C>
 		typename C<T>::signed_type findMSB(C<T> const & Value);
 
+		///@}
+
 	}//namespace integer
 	}//namespace function
 	}//namespace core

glm/core/func_matrix.hpp

@@ -21,6 +21,9 @@ namespace glm
 	//! Define all matrix functions from Section 8.5 of GLSL 1.30.8 specification. Included in glm namespace.
 	namespace matrix{
 
+	/// \addtogroup core_funcs
+	///@{
+
 	//! Multiply matrix x by matrix y component-wise, i.e., 
 	//! result[i][j] is the scalar product of x[i][j] and y[i][j].
 	//! (From GLSL 1.30.08 specification, section 8.5)
@@ -80,6 +83,8 @@ namespace glm
 	detail::tmat4x4<T> inverse(
 		detail::tmat4x4<T> const & m);
 
+	///@}
+
 	}//namespace matrix
 	}//namespace function
 	}//namespace core

glm/core/func_noise.hpp

@@ -21,6 +21,9 @@ namespace glm
 	// Define all noise functions from Section 8.9 of GLSL 1.30.8 specification. Included in glm namespace.
 	namespace noise{
 
+	/// \addtogroup core_funcs
+	///@{
+
 	// Returns a 1D noise value based on the input value x.
 	// From GLSL 1.30.08 specification, section 8.9.
 	template <typename genType>
@@ -41,6 +44,8 @@ namespace glm
 	template <typename genType>
 	detail::tvec4<typename genType::value_type> noise4(genType const & x);
 
+	///@}
+
 	}//namespace noise
 	}//namespace function
 	}//namespace core

glm/core/func_packing.hpp

@@ -21,6 +21,9 @@ namespace glm
 	//! Define packing functions from section 8.4 floating-point pack and unpack functions of GLSL 4.00.8 specification
 	namespace packing
 	{
+		/// \addtogroup core_funcs
+		///@{
+
 		detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v);
 		detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v);
 		detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v);
@@ -32,6 +35,8 @@ namespace glm
 		double packDouble2x32(detail::tvec2<detail::uint32> const & v);
 		detail::tvec2<detail::uint32> unpackDouble2x32(double const & v);
 
+		///@}
+
 	}//namespace packing
 	}//namespace function
 	}//namespace core

glm/core/func_trigonometric.hpp

@@ -23,6 +23,9 @@ namespace glm
 	//! Included in glm namespace.
 	namespace trigonometric{
 
+	/// \addtogroup core_funcs
+	///@{
+
 	//! Converts degrees to radians and returns the result.
 	//! (From GLSL 1.30.08 specification, section 8.1)
 	template <typename genType> 
@@ -111,6 +114,8 @@ namespace glm
 	template <typename genType> 
 	genType atanh(genType const & x);
 
+	///@}
+
 	}//namespace trigonometric
 	}//namespace function
 	}//namespace core

glm/core/func_vector_relational.hpp

@@ -24,6 +24,9 @@ namespace glm
 	//! Included in glm namespace.
 	namespace vector_relational
 	{
+		/// \addtogroup core_funcs
+		///@{
+
 		//! Returns the component-wise comparison result of x < y.
 		//! (From GLSL 1.30.08 specification, section 8.6)
 		template <typename T, template <typename> class vecType> 
@@ -183,6 +186,8 @@ namespace glm
 			return Result;
 		}
 
+		///@}
+
 	}//namespace vector_relational
 	}//namespace function
 	}//namespace core

glm/core/type.hpp

@@ -80,64 +80,79 @@ namespace type
 #else
 	//! 2 components vector of floating-point numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_vec2		vec2;
 
 	//! 3 components vector of floating-point numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_vec3		vec3;
 
 	//! 4 components vector of floating-point numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_vec4		vec4;
 
 	//! 2 columns of 2 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat2x2		mat2x2;
 
 	//! 2 columns of 3 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat2x3		mat2x3;
 
 	//! 2 columns of 4 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat2x4		mat2x4;
 
 	//! 3 columns of 2 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat3x2		mat3x2;
 
 	//! 3 columns of 3 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat3x3		mat3x3;
 
 	//! 3 columns of 4 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat3x4		mat3x4;
 
 	//! 4 columns of 2 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat4x2		mat4x2;
 
 	//! 4 columns of 3 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat4x3		mat4x3;
 
 	//! 4 columns of 4 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef precision::mediump_mat4x4		mat4x4;
 
 #endif//GLM_PRECISION
 
 	//! 2 columns of 2 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef mat2x2							mat2;
 
 	//! 3 columns of 3 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef mat3x3							mat3;
 
 	//! 4 columns of 4 components matrix of floating-point numbers. 
 	//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices)
+	//! \ingroup core_types
 	typedef mat4x4							mat4;
 
 	//////////////////////////
@@ -158,14 +173,17 @@ namespace type
 #else
 	//! 2 components vector of signed integer numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_ivec2		ivec2;
 
 	//! 3 components vector of signed integer numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_ivec3		ivec3;
 
 	//! 4 components vector of signed integer numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_ivec4		ivec4;
 #endif//GLM_PRECISION
 
@@ -187,14 +205,17 @@ namespace type
 #else
 	//! 2 components vector of unsigned integer numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_uvec2		uvec2;
 
 	//! 3 components vector of unsigned integer numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_uvec3		uvec3;
 
 	//! 4 components vector of unsigned integer numbers. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef precision::mediump_uvec4		uvec4;
 #endif//GLM_PRECISION
 
@@ -203,14 +224,17 @@ namespace type
 
 	//! 2 components vector of boolean. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef detail::tvec2<bool>		bvec2;
 
 	//! 3 components vector of boolean. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef detail::tvec3<bool>		bvec3;
 
 	//! 4 components vector of boolean. 
 	//! From GLSL 1.30.8 specification, section 4.1.5 Vectors.
+	//! \ingroup core_types
 	typedef detail::tvec4<bool>		bvec4;
 
 	//////////////////////////
@@ -218,62 +242,77 @@ namespace type
 
 	//! Vector of 2 double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tvec2<double>	dvec2;
 
 	//! Vector of 3 double-precision floating-point numbers.
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tvec3<double>	dvec3;
 
 	//! Vector of 4 double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tvec4<double>	dvec4;
 
 	//! 2 * 2 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat2x2<double>	dmat2;
 
 	//! 3 * 3 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat3x3<double>	dmat3;
 
 	//! 4 * 4 matrix of double-precision floating-point numbers.
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat4x4<double>	dmat4;
 
 	//! 2 * 2 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat2x2<double>	dmat2x2;
 
 	//! 2 * 3 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat2x3<double>	dmat2x3;
 
 	//! 2 * 4 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat2x4<double>	dmat2x4;
 
 	//! 3 * 2 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat3x2<double>	dmat3x2;
 
 	//! 3 * 3 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat3x3<double>	dmat3x3;
 
 	//! 3 * 4 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat3x4<double>	dmat3x4;
 
 	//! 4 * 2 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat4x2<double>	dmat4x2;
 
 	//! 4 * 3 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat4x3<double>	dmat4x3;
 
 	//! 4 * 4 matrix of double-precision floating-point numbers. 
 	//! From GLSL 4.00.8 specification, section 4.1 Basic Types.
+	//! \ingroup core_types
 	typedef detail::tmat4x4<double>	dmat4x4;
 
 }//namespace type

glm/core/type_float.hpp

@@ -38,16 +38,19 @@ namespace glm
 		typedef double				highp_float_t;
 
 		//! Low precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification
+		//! \ingroup core_precision
 		typedef lowp_float_t		lowp_float;
 		//! Medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification
+		//! \ingroup core_precision
 		typedef mediump_float_t		mediump_float;
 		//! High precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification
+		//! \ingroup core_precision
 		typedef highp_float_t		highp_float;
 	}
 	//namespace precision

glm/core/type_half.hpp

@@ -27,6 +27,8 @@ namespace glm
 		float toFloat32(hdata value);
 		hdata toFloat16(float const & value);
 
+		///16-bit floating point type.
+		/// \ingroup gtc_half_float
 		class thalf
 		{
 		public: 

glm/core/type_int.hpp

@@ -63,32 +63,39 @@ namespace glm
 	namespace core{
 	namespace type{
 
+	///namespace for precision stuff.
 	namespace precision
 	{
 		//! Low precision signed integer. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
 		typedef detail::lowp_int_t				lowp_int;
 		//! Medium precision signed integer. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
 		typedef detail::mediump_int_t			mediump_int;
 		//! High precision signed integer.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
 		typedef detail::highp_int_t				highp_int;
 
 		//! Low precision unsigned integer. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
 		typedef detail::lowp_uint_t				lowp_uint;
 		//! Medium precision unsigned integer. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
 		typedef detail::mediump_uint_t			mediump_uint;
 		//! High precision unsigned integer. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification.
+		//! \ingroup core_precision
 		typedef detail::highp_uint_t			highp_uint;
 	}
 	//namespace precision

glm/core/type_mat2x2.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 2 * 2 matrix of floating-point numbers.
+		//! \brief Template for 2 * 2 matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat2x2
 		{
@@ -222,16 +223,19 @@ namespace glm
 	namespace precision
 	{
 		//! 2 columns of 2 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat2x2<lowp_float>		lowp_mat2x2;
 		//! 2 columns of 2 components matrix of medium precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat2x2<mediump_float>	mediump_mat2x2;
 		//! 2 columns of 2 components matrix of high precision floating-point numbers. 
-		//! There is no garanty on the actual precision. 
+		//! There is no guarantee on the actual precision. 
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat2x2<highp_float>	highp_mat2x2;
 	}
 	//namespace precision

glm/core/type_mat2x3.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 2 columns and 3 rows matrix of floating-point numbers.
+		//! \brief Template for 2 columns and 3 rows matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat2x3
 		{
@@ -189,16 +190,19 @@ namespace glm
 	namespace precision
 	{
 		//! 2 columns of 3 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat2x3<lowp_float>		lowp_mat2x3;
 		//! 2 columns of 3 components matrix of medium precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat2x3<mediump_float>	mediump_mat2x3;
 		//! 2 columns of 3 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat2x3<highp_float>	highp_mat2x3;
 	}
 	//namespace precision

glm/core/type_mat2x4.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 2 columns and 4 rows matrix of floating-point numbers.
+		//! Template for 2 columns and 4 rows matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat2x4
 		{
@@ -189,15 +190,15 @@ namespace glm
 	namespace precision
 	{
 		//! 2 columns of 4 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat2x4<lowp_float>		lowp_mat2x4;
 		//! 2 columns of 4 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat2x4<mediump_float>	mediump_mat2x4;
 		//! 2 columns of 4 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat2x4<highp_float>	highp_mat2x4;
 	}

glm/core/type_mat3x2.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 3 columns and 2 rows matrix of floating-point numbers.
+		//! \brief Template for 3 columns and 2 rows matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat3x2
 		{
@@ -191,15 +192,15 @@ namespace glm
 	namespace precision
 	{
 		//! 3 columns of 2 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat3x2<lowp_float>		lowp_mat3x2;
 		//! 3 columns of 2 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat3x2<mediump_float>	mediump_mat3x2;
 		//! 3 columns of 2 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat3x2<highp_float>	highp_mat3x2;
 	}

glm/core/type_mat3x3.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 3 * 3 matrix of floating-point numbers.
+		//! \brief Template for 3 * 3 matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat3x3
 		{
@@ -221,16 +222,19 @@ namespace glm
 	namespace precision
 	{
 		//! 3 columns of 3 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat3x3<lowp_float>		lowp_mat3x3;
 		//! 3 columns of 3 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat3x3<mediump_float>	mediump_mat3x3;
 		//! 3 columns of 3 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat3x3<highp_float>	highp_mat3x3;
 	}
 	//namespace precision

glm/core/type_mat3x4.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 3 columns and 4 rows matrix of floating-point numbers.
+		//! \brief Template for 3 columns and 4 rows matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat3x4
 		{
@@ -191,15 +192,15 @@ namespace glm
 	namespace precision
 	{
 		//! 3 columns of 4 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat3x4<lowp_float>		lowp_mat3x4;
 		//! 3 columns of 4 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat3x4<mediump_float>	mediump_mat3x4;
 		//! 3 columns of 4 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
 		typedef detail::tmat3x4<highp_float>	highp_mat3x4;
 	}

glm/core/type_mat4x2.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 4 columns and 2 rows matrix of floating-point numbers.
+		//! \brief Template for 4 columns and 2 rows matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat4x2
 		{
@@ -193,16 +194,19 @@ namespace glm
 	namespace precision
 	{
 		//! 4 columns of 2 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x2<lowp_float>		lowp_mat4x2;
 		//! 4 columns of 2 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x2<mediump_float>	mediump_mat4x2;
 		//! 4 columns of 2 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x2<highp_float>	highp_mat4x2;
 	}
 	//namespace precision

glm/core/type_mat4x3.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 4 columns and 3 rows matrix of floating-point numbers.
+		//! \brief Template for 4 columns and 3 rows matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat4x3
 		{
@@ -193,16 +194,19 @@ namespace glm
 	namespace precision
 	{
 		//! 4 columns of 3 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x3<lowp_float>		lowp_mat4x3;
 		//! 4 columns of 3 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x3<mediump_float>	mediump_mat4x3;
 		//! 4 columns of 3 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x3<highp_float>	highp_mat4x3;
 	}
 	//namespace precision

glm/core/type_mat4x4.hpp

@@ -35,7 +35,8 @@ namespace glm
 		template <typename T> struct tmat4x3;
 		template <typename T> struct tmat4x4;
 
-		//!< \brief Template for 4 * 4 matrix of floating-point numbers.
+		//! \brief Template for 4 * 4 matrix of floating-point numbers.
+		//! \ingroup core_template
 		template <typename T> 
 		struct tmat4x4
 		{
@@ -221,16 +222,19 @@ namespace glm
 	namespace precision
 	{
 		//! 4 columns of 4 components matrix of low precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x4<lowp_float>		lowp_mat4x4;
 		//! 4 columns of 4 components matrix of medium precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x4<mediump_float>	mediump_mat4x4;
 		//! 4 columns of 4 components matrix of high precision floating-point numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! (From GLSL 1.30.8 specification, section 4.1.6 Matrices and section 4.5 Precision and Precision Qualifiers)
+		//! \ingroup core_precision
 		typedef detail::tmat4x4<highp_float>	highp_mat4x4;
 	}
 	//namespace precision

glm/core/type_vec2.hpp

@@ -32,6 +32,8 @@ namespace glm
 		template <typename T> struct tvec3;
 		template <typename T> struct tvec4;
 
+		//! The basic 2D vector type.
+		//! \ingroup core_template
 		template <typename T>
 		struct tvec2
 		{
@@ -203,42 +205,51 @@ namespace glm
 	namespace precision
 	{
 		//! 2 components vector of high precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<highp_float>		highp_vec2;
 		//! 2 components vector of medium precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<mediump_float>	mediump_vec2;
 		//! 2 components vector of low precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<lowp_float>		lowp_vec2;
 
 		//! 2 components vector of high precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<highp_int>		highp_ivec2;
 		//! 2 components vector of medium precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<mediump_int>		mediump_ivec2;
 		//! 2 components vector of low precision signed integer numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<lowp_int>			lowp_ivec2;
 	
 		//! 2 components vector of high precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<highp_uint>		highp_uvec2;
 		//! 2 components vector of medium precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<mediump_uint>		mediump_uvec2;
 		//! 2 components vector of low precision unsigned integer numbers.
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec2<lowp_uint>		lowp_uvec2;
 	}
 	//namespace precision

glm/core/type_vec3.hpp

@@ -31,6 +31,8 @@ namespace glm
 		template <typename T> struct tvec2;
 		template <typename T> struct tvec4;
 
+		//! Basic 3D vector type.
+		//! \ingroup core_template
 		template <typename T>
 		struct tvec3
 		{	
@@ -208,42 +210,51 @@ namespace glm
 	namespace precision
 	{
 		//! 3 components vector of high precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<highp_float>		highp_vec3;
 		//! 3 components vector of medium precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<mediump_float>	mediump_vec3;
 		//! 3 components vector of low precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<lowp_float>		lowp_vec3;
 
 		//! 3 components vector of high precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<highp_int>		highp_ivec3;
 		//! 3 components vector of medium precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<mediump_int>		mediump_ivec3;
 		//! 3 components vector of low precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<lowp_int>			lowp_ivec3;
 
 		//! 3 components vector of high precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<highp_uint>		highp_uvec3;
 		//! 3 components vector of medium precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<mediump_uint>		mediump_uvec3;
 		//! 3 components vector of low precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec3<lowp_uint>		lowp_uvec3;
 	}
 	//namespace precision

glm/core/type_vec4.hpp

@@ -32,6 +32,8 @@ namespace glm
 		template <typename T> struct tvec2;
 		template <typename T> struct tvec3;
 
+		///Basic 4D vector type.
+		//! \ingroup core_template
 		template <typename T>
 		struct tvec4
 		{
@@ -225,42 +227,51 @@ namespace glm
 	namespace precision
 	{
 		//! 4 components vector of high precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<highp_float>		highp_vec4;
 		//! 4 components vector of medium precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<mediump_float>	mediump_vec4;
 		//! 4 components vector of low precision floating-point numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.5.2 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<lowp_float>		lowp_vec4;
 
 		//! 4 components vector of high precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<highp_int>		highp_ivec4;
 		//! 4 components vector of medium precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<mediump_int>		mediump_ivec4;
 		//! 4 components vector of low precision signed integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<lowp_int>			lowp_ivec4;
 
 		//! 4 components vector of high precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<highp_uint>		highp_uvec4;
 		//! 4 components vector of medium precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<mediump_uint>		mediump_uvec4;
 		//! 4 components vector of low precision unsigned integer numbers. 
-		//! There is no garanty on the actual precision.
+		//! There is no guarantee on the actual precision.
 		//! From GLSL 1.30.8 specification, section 4.1.5 Precision Qualifiers.
+		//! \ingroup core_precision
 		typedef detail::tvec4<lowp_uint>		lowp_uvec4;
 	}
 	//namespace precision

glm/glm.hpp

@@ -7,26 +7,6 @@
 // File    : glm/glm.hpp
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-/*! \mainpage OpenGL Mathematics
- *
- * OpenGL Mathematics (GLM) is a C++ mathematics library for 3D applications based on the OpenGL Shading Language (GLSL) specification. 
- *
- * GLM provides 3D programmers with math classes and functions that are similar to GLSL or any high level GPU programming language. The idea is to have a library that has identical naming conventions and functionalities than GLSL so that when developers know GLSL, they know how to use GLM.
- *
- * However, this project isn't limited by GLSL features. An extension system, based on the GLSL extension conventions, allows extended capabilities.
- *
- * This library can be used with OpenGL but also for software rendering (Raytracing / Rasterisation), image processing and as much contexts as a simple math library could be used for.
- *
- * GLM is written as a platform independent library and supports the following compilers: 
- * - GNU GCC 3.4 and higher 
- * - Microsoft Visual Studio 8.0 and higher
- * 
- * The source code is under the MIT licence.
- * 
- * Any feedback is welcome and can be sent to glm@g-truc.net.
- *
- */
-
 #ifndef glm_glm
 #define glm_glm
 

glm/gtc/half_float.hpp

@@ -326,6 +326,9 @@ namespace glm
 	//! GLM_GTC_half_float extension: Add support for half precision floating-point types
 	namespace half_float
 	{
+		/// \addtogroup gtc_half_float
+		///@{
+
 		//! Type for half-precision floating-point numbers. 
 		//! From GLM_GTC_half_float extension.
 		typedef detail::thalf					half;
@@ -354,6 +357,8 @@ namespace glm
 		//! From GLM_GTC_half_float extension.
 		typedef detail::tmat4x4<detail::thalf>	hmat4;
 
+		///@}
+
 	}//namespace half_float
 	}//namespace gtc
 }//namespace glm

glm/gtc/matrix_access.hpp

@@ -25,6 +25,9 @@ namespace gtc{
 //! GLM_GTC_matrix_access extension: Set a column or a row of a matrix
 namespace matrix_access
 {
+	/// \addtogroup gtc_matrix_access
+	///@{
+
 	//! Get a specific row of a matrix.
 	//! From GLM_GTC_matrix_access extension.
 	template <typename genType> 
@@ -55,6 +58,8 @@ namespace matrix_access
 		int index, 
 		typename genType::col_type const & x);
 
+	///@}
+
 }//namespace matrix_access
 }//namespace gtc
 }//namespace glm

glm/gtc/matrix_integer.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTC_matrix_integer extension: Add integer matrices
 	namespace matrix_integer
 	{
+		/// \addtogroup gtc_matrix_integer
+		///@{
+
 		typedef detail::tmat2x2<highp_int>				highp_imat2;	//!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef detail::tmat3x3<highp_int>				highp_imat3;	//!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
 		typedef detail::tmat4x4<highp_int>				highp_imat4;	//!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
@@ -201,6 +204,8 @@ namespace glm
 		typedef mediump_umat4x4							umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
 #endif//GLM_PRECISION
 
+		///@}
+
 	}//namespace matrix_integer
 	}//namespace gtc
 }//namespace glm

glm/gtc/matrix_inverse.hpp

@@ -25,6 +25,9 @@ namespace gtc{
 //! GLM_GTC_matrix_inverse extension: Inverse matrix functions
 namespace matrix_inverse
 {
+	/// \addtogroup gtc_matrix_inverse
+	///@{
+
 	//! Fast matrix inverse for affine matrix.
 	//! From GLM_GTC_matrix_inverse extension.
 	template <typename genType> 
@@ -36,6 +39,8 @@ namespace matrix_inverse
 	inline typename genType::value_type inverseTranspose(
 		genType const & m);
 
+	///@}
+
 }//namespace matrix_inverse
 }//namespace gtc
 }//namespace glm

glm/gtc/matrix_transform.hpp

@@ -31,6 +31,9 @@ namespace glm
 	//! GLM_GTC_matrix_transform extension: Add transformation matrices
 	namespace matrix_transform
 	{
+		/// \addtogroup gtc_matrix_transform
+		///@{
+
 		//! Builds a translation 4 * 4 matrix created from a vector of 3 components.
 		//! From GLM_GTC_matrix_transform extension.
 		template <typename T> 
@@ -141,6 +144,7 @@ namespace glm
 			detail::tvec3<T> const & center, 
 			detail::tvec3<T> const & up);
 
+		///@}
 	}//namespace matrix_transform
 	}//namespace gtc
 }//namespace glm

glm/gtc/quaternion.hpp

@@ -36,6 +36,7 @@ namespace glm
 	{
 		//! \brief Template for quaternion. 
 		//! From GLM_GTC_quaternion extension.
+		/// \ingroup gtc_quaternion
 		template <typename T> 
 		struct tquat// : public genType<T, tquat>
 		{
@@ -119,6 +120,9 @@ namespace glm
 	//! GLM_GTC_quaternion extension: Quaternion types and functions
     namespace quaternion
     {
+		/// \addtogroup gtc_quaternion
+		///@{
+
 		//! Returns the length of the quaternion x. 
 		//! From GLM_GTC_quaternion extension.
         template <typename T> 
@@ -213,6 +217,8 @@ namespace glm
 		//! From GLM_GTC_quaternion extension.
 		typedef detail::tquat<double>	dquat;
 
+		///@}
+
     }//namespace quaternion
     }//namespace gtc
 } //namespace glm

glm/gtc/type_precision.hpp

@@ -43,6 +43,9 @@ namespace glm
 		///////////////////////////
 		// Signed int vector types 
 
+		/// \addtogroup gtc_type_precision
+		///@{
+
 		typedef detail::int8						int8;         //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
 		typedef detail::int16						int16;        //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
 		typedef detail::int32						int32;        //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
@@ -210,6 +213,8 @@ namespace glm
 		typedef detail::tquat<f32>					f32quat;    //!< \brief Single-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
 		typedef detail::tquat<f64>					f64quat;    //!< \brief Double-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
 
+		///@}
+
 	}//namespace type_precision
 	}//namespace gtc
 }//namespace glm

glm/gtc/type_ptr.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
 	namespace type_ptr{
 
+		/// \addtogroup gtc_type_ptr
+		///@{
+
 		//! Get the const address of the vector content.
 		//! From GLM_GTC_type_ptr extension.
 		template<typename T>
@@ -291,6 +294,8 @@ namespace glm
 			return &(mat[0].x);
 		}
 
+		///@}
+
 	}//namespace type_ptr
 	}//namespace gtc
 }//namespace glm

glm/gtx/associated_min_max.hpp

@@ -32,6 +32,9 @@ namespace glm
 		//! GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
 		namespace associated_min_max
 		{
+			/// \addtogroup gtx_associated_min_max
+			///@{
+
 			//! \brief Min comparison between 2 variables
 			template<typename genTypeT, typename genTypeU>
 			genTypeU associatedMin(
@@ -73,6 +76,7 @@ namespace glm
 				const genTypeT& y, const genTypeU& b, 
 				const genTypeT& z, const genTypeU& c, 
 				const genTypeT& w, const genTypeU& d);
+			///@}
 
 		}//namespace associated_min_max
 

glm/gtx/bit.hpp

@@ -34,6 +34,8 @@ namespace glm
 	{
 		using namespace gtc::half_float;
 
+		/// \addtogroup gtx_bit
+		///@{
 		//! Build a mask of 'count' bits
 		//! From GLM_GTX_bit extension.
 		template <typename genIType>
@@ -97,6 +99,7 @@ namespace glm
 		//! From GLM_GTX_bit extension.
 		template <typename genType>
 		genType bitRotateLeft(genType const & In, std::size_t Shift);
+		///@}
 
 	}//namespace bit
 	}//namespace gtx

glm/gtx/closest_point.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_closest_point extension: Find the point on a straight line which is the closet of a point.
 	namespace closest_point{
 
+	/// \addtogroup gtx_closest_point
+	///@{
+
 	//! Find the point on a straight line which is the closet of a point. 
 	//! From GLM_GTX_closest_point extension.
 	template <typename T> 
@@ -37,6 +40,7 @@ namespace glm
 		detail::tvec3<T> const & point, 
 		detail::tvec3<T> const & a, 
 		detail::tvec3<T> const & b);
+	///@}
 
 	}//namespace closest_point
 	}//namespace gtx

glm/gtx/color_cast.hpp

@@ -34,6 +34,9 @@ namespace glm
 	{
 		using namespace gtx::number_precision;
 
+		/// \addtogroup gtx_color_cast
+		///@{
+
 		//! Conversion of a floating value into a 8bit unsigned int value. 
 		//! From GLM_GTX_color_cast extension.
 		template <typename valType> gtc::type_precision::uint8 u8channel_cast(valType a);
@@ -97,6 +100,8 @@ namespace glm
 		template <typename T> gtc::type_precision::f64vec4 f64_argb_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
 		template <typename T> gtc::type_precision::f64vec4 f64_bgra_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
 		template <typename T> gtc::type_precision::f64vec4 f64_abgr_cast(T c);		//!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
+
+		///@}
 	}//namespace color_space
 	}//namespace gtx
 }//namespace glm

glm/gtx/color_space.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
     namespace color_space
     {
+		/// \addtogroup gtx_color_space
+		///@{
+
 		//! Converts a color from HSV color space to its color in RGB color space.
 		//! From GLM_GTX_color_space extension.
         template <typename valType> 
@@ -68,6 +71,8 @@ namespace glm
 		valType luminosity(
 			detail::tvec3<valType> const & color);
 
+		///@}
+		
 	}//namespace color_space
 	}//namespace gtx
 }//namespace glm

glm/gtx/color_space_YCoCg.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
     namespace color_space_YCoCg
     {
+		/// \addtogroup gtx_color_space_YCoCg
+		///@{
+
         //! Convert a color from RGB color space to YCoCg color space.
 		//! From GLM_GTX_color_space_YCoCg extension.
 		template <typename valType> 
@@ -56,6 +59,7 @@ namespace glm
 		detail::tvec3<valType> YCoCgR2rgb(
 			detail::tvec3<valType> const & YCoCgColor);
 
+		///@}
 	}//namespace color_space_YCoCg
 	}//namespace gtx
 }//namespace glm

glm/gtx/compatibility.hpp

@@ -38,6 +38,9 @@ namespace glm
 	//! GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
 	namespace compatibility
 	{
+		/// \addtogroup gtx_compatibility
+		///@{
+
 		template <typename T> inline T lerp(T x, T y, T a){return mix(x, y, a);}																					//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
 		template <typename T> inline detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
 		template <typename T> inline detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, T a){return mix(x, y, a);}							//!< \brief Returns x * (1.0 - a) + y * a, i.e., the linear blend of x and y using the floating-point value a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
@@ -151,6 +154,8 @@ namespace glm
 		typedef detail::tmat4x3<double>		double4x3;		//!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
 		typedef detail::tmat4x4<double>		double4x4;		//!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
 
+		///@}
+
 	}//namespace compatibility
 	}//namespace gtx
 }//namespace glm

glm/gtx/component_wise.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_component_wise extension: Operations between components of a type
 	namespace component_wise
 	{
+		/// \addtogroup gtx_component_wise
+		///@{
+
 		//! Add all vector components together. 
 		//! From GLM_GTX_component_wise extension.
 		template <typename genType> 
@@ -54,6 +57,8 @@ namespace glm
 		typename genType::value_type compMax(
 			genType const & v);
 
+		///@}
+
 	}//namespace component_wise
 	}//namespace gtx
 }//namespace glm

glm/gtx/epsilon.hpp

@@ -29,9 +29,12 @@ namespace glm
 	}//namespace test
 
 	namespace gtx{
-	//! GLM_GTX_epsilon extension: Comparaison functions for a user defined epsilon values.
+	//! GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
 	namespace epsilon
 	{
+		/// \addtogroup gtx_epsilon
+		///@{
+
 		//! Returns the component-wise compare of |x - y| < epsilon.
 		//! From GLM_GTX_epsilon extension.
 		template <typename genTypeT, typename genTypeU> 
@@ -48,6 +51,8 @@ namespace glm
 			genTypeT const & y, 
 			genTypeU const & epsilon);
 
+		///@}
+
 	}//namespace epsilon
 	}//namespace gtx
 }//namespace glm

glm/gtx/euler_angles.hpp

@@ -29,9 +29,12 @@
 namespace glm
 {
     namespace gtx{
-	//! GLM_GTX_euler_angles extension: Build matrices from euler angles.
+	//! GLM_GTX_euler_angles extension: Build matrices from Euler angles.
 	namespace euler_angles
 	{
+		/// \addtogroup gtx_euler_angles
+		///@{
+
 		//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
 		//! From GLM_GTX_euler_angles extension.
 		template <typename valType> 
@@ -127,6 +130,8 @@ namespace glm
 		//! From GLM_GTX_euler_angles extension.
 		template <typename T> 
 		detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
+
+		///@}
 	}//namespace euler_angles
     }//namespace gtx
 }//namespace glm

glm/gtx/extend.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
 	namespace extend
 	{
+		/// \addtogroup gtx_extend
+		///@{
+
 		//! Extends of Length the Origin position using the (Source - Origin) direction.
 		//! From GLM_GTX_extend extension.
 		template <typename genType> 
@@ -38,6 +41,8 @@ namespace glm
 			genType const & Source, 
 			typename genType::value_type const Length);
 
+		///@}
+
 	}//namespace extend
 	}//namespace gtx
 }//namespace glm

glm/gtx/extented_min_max.hpp

@@ -32,6 +32,9 @@ namespace glm
 	//! GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
 	namespace extented_min_max
 	{
+		/// \addtogroup gtx_extented_min_max
+		///@{
+
 		//< Return the minimum component-wise values of 3 inputs 
 		//< From GLM_GTX_extented_min_max extension
 		template <typename T>
@@ -166,6 +169,8 @@ namespace glm
 			C<T> const & z, 
 			C<T> const & w);
 
+		///@}
+
 	}//namespace extented_min_max
 	}//namespace gtx
 }//namespace glm

glm/gtx/fast_exponential.hpp

@@ -33,6 +33,8 @@ namespace glm
 	namespace fast_exponential
 	{
 		using namespace gtc::half_float;
+		/// \addtogroup gtx_fast_exponential
+		///@{
 
 		//! Faster than the common pow function but less accurate.
 		//! From GLM_GTX_fast_exponential extension.
@@ -73,6 +75,8 @@ namespace glm
 		template <typename T> 
 		T fastLn(const T& x);
 
+		///@}
+
 	}//namespace fast_exponential
 	}//namespace gtx
 }//namespace glm

glm/gtx/fast_square_root.hpp

@@ -34,6 +34,9 @@ namespace glm
 	//! GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
 	namespace fast_square_root
 	{
+		/// \addtogroup gtx_fast_square_root
+		///@{
+
 		//! Faster than the common sqrt function but less accurate.
 		//! From GLM_GTX_fast_square_root extension.
 		template <typename genType> 
@@ -59,6 +62,8 @@ namespace glm
 		template <typename genType> 
 		genType fastNormalize(genType const & x);
 
+		///@}
+
 	}//namespace fast_square_root
 	}//	namespace gtx
 }//namespace glm

glm/gtx/fast_trigonometry.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
     namespace fast_trigonometry
     {
+		/// \addtogroup gtx_fast_trigonometry
+		///@{
+
 		//! Faster than the common sin function but less accurate. 
 		//! Defined between -2pi and 2pi. 
 		//! From GLM_GTX_fast_trigonometry extension.
@@ -72,6 +75,8 @@ namespace glm
         template <typename T> 
 		T fastAtan(const T& angle);
 
+		///@}
+
     }//namespace fast_trigonometry
     }//namespace gtx
 }//namespace glm

glm/gtx/handed_coordinate_space.hpp

@@ -23,9 +23,12 @@
 namespace glm
 {
 	namespace gtx{
-	//! GLM_GTX_handed_coordinate_space extension: To know if a triedron is right or left handed
+	//! GLM_GTX_handed_coordinate_space extension: To know if a set of three basis vectors defines a right or left-handed coordinate system.
 	namespace handed_coordinate_space
 	{
+		/// \addtogroup gtx_handed_coordinate_space
+		///@{
+
 		//! Return if a trihedron right handed or not.
 		//! From GLM_GTX_handed_coordinate_space extension.
 		template <typename T> 
@@ -42,6 +45,8 @@ namespace glm
 			detail::tvec3<T> const & binormal, 
 			detail::tvec3<T> const & normal);
 
+		///@}
+
 	}//namespace handed_coordinate_space
 	}//namespace gtx
 }//namespace glm

glm/gtx/inertia.hpp

@@ -26,6 +26,9 @@ namespace glm
 	//! GLM_GTX_inertia extension: Create inertia matrices
 	namespace inertia
 	{
+		/// \addtogroup gtx_inertia
+		///@{
+
 		//! Build an inertia matrix for a box.
 		//! From GLM_GTX_inertia extension.
 		template <typename T> 
@@ -82,6 +85,8 @@ namespace glm
 			const T Mass, 
 			const T Radius);
 
+		///@}
+
 	}//namespace inertia
 	}//namespace gtx
 }//namespace glm

glm/gtx/int_10_10_10_2.hpp

@@ -29,10 +29,15 @@ namespace glm
 	{
 		using namespace gtx::raw_data;
 
+		/// \addtogroup gtx_int_10_10_10_2
+		///@{
+
 		//! From GLM_GTX_int_10_10_10_2 extension.
 		//! Cast a vec4 to an u_10_10_10_2.
 		dword uint10_10_10_2_cast(glm::vec4 const & v);
 
+		///@}
+
 	}//namespace integer
 	}//namespace gtx
 }//namespace glm

glm/gtx/integer.hpp

@@ -26,6 +26,9 @@ namespace glm
 	//! GLM_GTX_integer extension: Add support for integer for core functions
 	namespace integer
 	{
+		/// \addtogroup gtx_integer
+		///@{
+
 		//! Returns x raised to the y power. 
 		//! From GLM_GTX_integer extension.
 		int pow(int x, int y);
@@ -43,6 +46,8 @@ namespace glm
 		template <typename genType> 
 		genType factorial(genType const & x);
 
+		///@}
+
 	}//namespace integer
 	}//namespace gtx
 }//namespace glm

glm/gtx/intersect.hpp

@@ -32,6 +32,9 @@ namespace glm
 	//! GLM_GTX_intersect extension: Add intersection functions
 	namespace intersect
 	{
+		/// \addtogroup gtx_intersect
+		///@{
+
 		//! Compute the intersection of a ray and a triangle.
 		//! From GLM_GTX_intersect extension.
 		template <typename genType>
@@ -64,6 +67,8 @@ namespace glm
 			genType const & center, typename genType::value_type radius,
 			genType & position, genType & normal);
 
+		///@}
+
 	}//namespace intersect
 }//namespace gtx
 }//namespace glm

glm/gtx/log_base.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
 	namespace log_base
 	{
+		/// \addtogroup gtx_log_base
+		///@{
+
 		//! Logarithm for any base.
 		//! From GLM_GTX_log_base.
 		template <typename genType> 
@@ -37,6 +40,8 @@ namespace glm
 			genType const & x, 
 			genType const & base);
 
+		///@}
+
 	}//namespace extend
 	}//namespace gtx
 }//namespace glm

glm/gtx/matrix_cross_product.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_matrix_cross_product: Build cross product matrices
 	namespace matrix_cross_product
 	{
+		/// \addtogroup gtx_matrix_cross_product
+		///@{
+
 		//! Build a cross product matrix.
 		//! From GLM_GTX_matrix_cross_product extension.
 		template <typename T> 
@@ -42,6 +45,8 @@ namespace glm
 		detail::tmat4x4<T> matrixCross4(
 			detail::tvec3<T> const & x);
 
+		///@}
+
 	}//namespace matrix_cross_product
 	}//namespace gtx
 }//namespace glm

glm/gtx/matrix_major_storage.hpp

@@ -23,9 +23,12 @@
 namespace glm
 {
 	namespace gtx{
-	//! GLM_GTX_matrix_cross_product: Build matrices with specific matrix order, row or column
+	//! GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
 	namespace matrix_major_storage
 	{
+		/// \addtogroup gtx_matrix_major_storage
+		///@{
+
 		//! Build a row major matrix from row vectors.
 		//! From GLM_GTX_matrix_major_storage extension.
 		template <typename T> 
@@ -110,6 +113,8 @@ namespace glm
 		detail::tmat4x4<T> colMajor4(
 			const detail::tmat4x4<T>& m);
 
+		///@}
+		
 	}//namespace matrix_major_storage
 	}//namespace gtx
 }//namespace glm

glm/gtx/matrix_operation.hpp

@@ -27,9 +27,12 @@ namespace glm
 	}//namespace test
 
 	namespace gtx{
-	//! GLM_GTX_matrix_operation: Build cross product matrices
+	//! GLM_GTX_matrix_operation: Build diagonal matrices
 	namespace matrix_operation
 	{
+		/// \addtogroup gtx_matrix_operation
+		///@{
+
 		//! Build a diagonal matrix.
 		//! From GLM_GTX_matrix_operation extension.
 		template <typename valType> 
@@ -84,6 +87,8 @@ namespace glm
 		detail::tmat4x4<valType> diagonal4x4(
 			detail::tvec4<valType> const & v);
 
+		///@}
+
 	}//namespace matrix_operation
 	}//namespace gtx
 }//namespace glm

glm/gtx/matrix_query.hpp

@@ -27,9 +27,12 @@ namespace glm
 	}//namespace test
 
 	namespace gtx{
-	//! GLM_GTX_matrix_query: Query to evaluate matrices properties
+	//! GLM_GTX_matrix_query: Query to evaluate matrix properties
 	namespace matrix_query
 	{
+		/// \addtogroup gtx_matrix_query
+		///@{
+
 		//! Return if a matrix a null matrix.
 		//! From GLM_GTX_matrix_query extension.
 		template<typename T> 
@@ -86,6 +89,7 @@ namespace glm
 			const genType& m, 
 			const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
 
+		///@}
 	}//namespace matrix_query
 	}//namespace gtx
 }//namespace glm

glm/gtx/mixed_product.hpp

@@ -30,12 +30,17 @@ namespace glm
 	//! GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
 	namespace mixed_product
 	{
+		/// \addtogroup gtx_mixed_product
+		///@{
+
 		//! \brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
 		template <typename valType> 
 		valType mixedProduct(
 			detail::tvec3<valType> const & v1, 
 			detail::tvec3<valType> const & v2, 
 			detail::tvec3<valType> const & v3);
+
+		///@}
 	}//namespace mixed_product
 	}//namespace gtx
 }//namespace glm

glm/gtx/multiple.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_multiple: Find the closest number of a number multiple of other number.
 	namespace multiple
 	{
+		/// \addtogroup gtx_multiple
+		///@{
+
 		//! Higher Multiple number of Source.
 		//! From GLM_GTX_multiple extension.
 		template <typename genType> 
@@ -44,6 +47,8 @@ namespace glm
 			genType const & Source, 
 			genType const & Multiple);
 
+		///@}
+
 	}//namespace multiple
 	}//namespace gtx
 }//namespace glm

glm/gtx/norm.hpp

@@ -32,9 +32,12 @@ namespace glm
 	}//namespace test
 
 	namespace gtx{
-	//! GLM_GTX_norm extension: Varius way to compute vector norms.
+	//! GLM_GTX_norm extension: Various way to compute vector norms.
 	namespace norm
 	{
+		/// \addtogroup gtx_norm
+		///@{
+
 		//! Returns the squared length of x.
 		//! From GLM_GTX_norm extension.
 		template <typename T> 
@@ -134,6 +137,8 @@ namespace glm
 			const detail::tvec3<T>& x,
 			unsigned int Depth);
 
+		///@}
+
 	}//namespace norm
 	}//namespace gtx
 }//namespace glm

glm/gtx/normal.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_normal extension: Compute the normal of a triangle.
     namespace normal
     {
+		/// \addtogroup gtx_normal
+		///@{
+
 		//! Computes triangle normal from triangle points. 
 		//! From GLM_GTX_normal extension.
         template <typename T> 
@@ -38,6 +41,8 @@ namespace glm
 			detail::tvec3<T> const & p2, 
 			detail::tvec3<T> const & p3);
 
+		///@}
+
     }//namespace normal
     }//namespace gtx
 }//namespace glm

glm/gtx/normalize_dot.hpp

@@ -30,6 +30,9 @@ namespace glm
 	{
 		using namespace gtx::fast_square_root;
 
+		/// \addtogroup gtx_normalize_dot
+		///@{
+
 		//! Normalize parameters and returns the dot product of x and y.
 		//! It's faster that dot(normalize(x), normalize(y)).
 		//! From GLM_GTX_normalize_dot extension.
@@ -46,6 +49,8 @@ namespace glm
 			genType const & x, 
 			genType const & y);
 
+		///@}
+
 	}//namespace normalize_dot
 	}//namespace gtx
 }//namespace glm

glm/gtx/number_precision.hpp

@@ -33,6 +33,9 @@ namespace number_precision
 	/////////////////////////////
 	// Unsigned int vector types 
 
+	/// \addtogroup gtx_number_precision
+	///@{
+
 	typedef u8			u8vec1;		//!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
 	typedef u16			u16vec1;    //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
 	typedef u32			u32vec1;    //!< \brief 32bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
@@ -55,6 +58,7 @@ namespace number_precision
 	typedef f64			f64mat1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
 	typedef f64			f64mat1x1;	//!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
 
+	///@}
 }//namespace number_precision
 }//namespace gtx
 }//namespace glm

glm/gtx/ocl_type.hpp

@@ -28,6 +28,9 @@ namespace ocl_type
 	///////////////////////////
 	// Scalar types 
 
+	/// \addtogroup gtx_ocl_type
+	///@{
+
 	typedef detail::int8						cl_char;		//!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
 	typedef detail::int16						cl_short;		//!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
 	typedef detail::int32						cl_int;			//!< \brief 32bit signed integer. (from GLM_GTX_ocl_type extension)
@@ -96,6 +99,8 @@ namespace ocl_type
 	//typedef detail::tvec4<detail::float16>		cl_half4;	//!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
 	typedef detail::tvec4<detail::float32>		cl_float4;	//!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
 
+	///@}
+
 }//namespace ocl_type
 }//namespace gtx
 }//namespace glm

glm/gtx/optimum_pow.hpp

@@ -27,9 +27,12 @@ namespace glm
 	}//namespace test
 
     namespace gtx{
-	//! GLM_GTX_optimum_pow extension: Integer exponenciation of power functions.
+	//! GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
     namespace optimum_pow
     {
+		/// \addtogroup gtx_optimum_pow
+		///@{
+
 		//! Returns x raised to the power of 2.
 		//! From GLM_GTX_optimum_pow extension.
         template <typename genType> 
@@ -61,6 +64,8 @@ namespace glm
 		//! From GLM_GTX_optimum_pow extension.
         detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
 
+		///@}
+
     }//namespace optimum_pow
     }//namespace gtx
 }//namespace glm

glm/gtx/orthonormalize.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_orthonormalize extension: Orthonormalize matrices.
     namespace orthonormalize
     {
+		/// \addtogroup gtx_orthonormalize
+		///@{
+
 		//! Returns the orthonormalized matrix of m.
 		//! From GLM_GTX_orthonormalize extension.
 		template <typename T> 
@@ -43,6 +46,8 @@ namespace glm
 			const detail::tvec3<T>& x, 
 			const detail::tvec3<T>& y);
 
+		///@}
+
     }//namespace orthonormalize
     }//namespace gtx
 }//namespace glm

glm/gtx/perpendicular.hpp

@@ -32,6 +32,9 @@ namespace glm
 	//! GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
     namespace perpendicular
     {
+		/// \addtogroup gtx_perpendicular
+		///@{
+
 		//! Projects x a perpendicular axis of Normal.
 		//! From GLM_GTX_perpendicular extension.
 		template <typename T> 
@@ -53,6 +56,9 @@ namespace glm
 			detail::tvec4<T> const & x, 
 			detail::tvec4<T> const & Normal);
 
+
+		///@}
+		
     }//namespace perpendicular
     }//namespace gtx
 }//namespace glm

glm/gtx/polar_coordinates.hpp

@@ -26,6 +26,9 @@ namespace glm
 	//! GLM_GTX_polar_coordinates extension: Conversion from Euclidean space to polar space and revert.
 	namespace polar_coordinates
 	{
+		/// \addtogroup gtx_polar_coordinates
+		///@{
+
 		//! Convert Euclidean to Polar coordinates, x is the xz distance, y, the latitude and z the longitude.
 		//! From GLM_GTX_polar_coordinates extension.
 		template <typename T> 
@@ -36,6 +39,8 @@ namespace glm
 		template <typename T> 
 		detail::tvec3<T> euclidean(const detail::tvec3<T>& polar);
 
+		///@}
+
 	}//namespace polar_coordinates
 	}//namespace gtx
 }//namespace glm

glm/gtx/projection.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_projection extension: Projection of a vector to other one
 	namespace projection
 	{
+		/// \addtogroup gtx_projection
+		///@{
+
 		//! Projects x on Normal.
 		//! From GLM_GTX_projection extension.
 		template <typename T> 
@@ -51,6 +54,8 @@ namespace glm
 			detail::tvec4<T> const & x, 
 			detail::tvec4<T> const & Normal);
 
+		///@}
+		
 	}//namespace projection
     }//namespace gtx
 }//namespace glm

glm/gtx/quaternion.hpp

@@ -33,6 +33,9 @@ namespace glm
     {
 		using namespace gtc::quaternion;
 
+		/// \addtogroup gtx_quaternion
+		///@{
+
 		//! Compute a cross product between a quaternion and a vector. 
 		//! From GLM_GTX_quaternion extension.
 		template <typename valType> 
@@ -188,6 +191,8 @@ namespace glm
 		detail::tquat<valType> toQuat(
 			detail::tmat4x4<valType> const & x){return gtc::quaternion::quat_cast(x);}
 
+		///@}
+
     }//namespace quaternion
     }//namespace gtx
 } //namespace glm

glm/gtx/random.hpp

@@ -25,9 +25,12 @@
 
 namespace glm{
 namespace gtx{
-//! GLM_GTX_random extension: Generate random number from varius distribution methods
+//! GLM_GTX_random extension: Generate random number from various distribution methods
 namespace random
 {
+	/// \addtogroup gtx_random
+	///@{
+
 	//! Generate a random number in the interval [-1, 1], according a linear distribution.
 	//! From GLM_GTX_random extension.
     template <typename T> T signedRand1();
@@ -75,6 +78,7 @@ namespace random
     template <typename T> detail::tvec3<T> gaussRand3(const detail::tvec3<T>& mean, const detail::tvec3<T>& std_deviation);     //!< \brief Gererate 3 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
     template <typename T> detail::tvec4<T> gaussRand4(const detail::tvec4<T>& mean, const detail::tvec4<T>& std_deviation);     //!< \brief Gererate 4 random floating numbers according a Gauss distribution. (From GLM_GTX_random extension)
 
+	///@}
 }//namespace random
 }//namespace gtx
 }//namespace glm

glm/gtx/raw_data.hpp

@@ -29,6 +29,9 @@ namespace gtx
     {
 		using namespace gtc::type_precision;
 
+		/// \addtogroup gtx_raw_data
+		///@{
+
 		//! Type for byte numbers. 
 		//! From GLM_GTX_raw_data extension.
 		typedef uint8		byte;
@@ -44,6 +47,8 @@ namespace gtx
 		//! Type for qword numbers. 
 		//! From GLM_GTX_raw_data extension.
 		typedef uint64		qword;
+
+		///@}
 	}
 }//namespace gtx
 }//namespace glm

glm/gtx/reciprocal.hpp

@@ -27,6 +27,9 @@ namespace glm
 	//! GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
 	namespace reciprocal
 	{
+		/// \addtogroup gtx_reciprocal
+		///@{
+
 		//! Secant function. 
 		//! hypotenuse / adjacent or 1 / cos(x)
 		//! From GLM_GTX_reciprocal extension.
@@ -90,6 +93,8 @@ namespace glm
 		template <typename genType> 
 		genType acoth(genType const & x);
 
+		///@}
+
 	}//namespace reciprocal
 	}//namespace gtx
 }//namespace glm

glm/gtx/rotate_vector.hpp

@@ -29,14 +29,17 @@ namespace glm
 	{
 		using namespace transform;
 
-		//! Rotate a two dimentionnals vector.
+		/// \addtogroup gtx_rotate_vector
+		///@{
+
+		//! Rotate a two dimensional vector.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec2<T> rotate(
 			const detail::tvec2<T>& v, 
 			T angle);
 		
-		//! Rotate a three dimentionnals vector around an axis.
+		//! Rotate a three dimensional vector around an axis.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec3<T> rotate(
@@ -44,28 +47,28 @@ namespace glm
 			T angle, 
 			const detail::tvec3<T>& normal);
 		
-		//! Rotate a four dimentionnals vector around an axis.
+		//! Rotate a four dimensional vector around an axis.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec4<T> rotate(
 			const detail::tvec4<T>& v, T angle, 
 			const detail::tvec3<T>& normal);
 		
-		//! Rotate a three dimentionnals vector around the X axis.
+		//! Rotate a three dimensional vector around the X axis.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec3<T> rotateX(
 			const detail::tvec3<T>& v, 
 			T angle);
 
-		//! Rotate a three dimentionnals vector around the Y axis.
+		//! Rotate a three dimensional vector around the Y axis.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec3<T> rotateY(
 			const detail::tvec3<T>& v, 
 			T angle);
 		
-		//! Rotate a three dimentionnals vector around the Z axis.
+		//! Rotate a three dimensional vector around the Z axis.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec3<T> rotateZ(
@@ -79,14 +82,14 @@ namespace glm
 			const detail::tvec4<T>& v, 
 			T angle);
 		
-		//! Rotate a four dimentionnals vector around the X axis.
+		//! Rotate a four dimensional vector around the X axis.
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec4<T> rotateY(
 			const detail::tvec4<T>& v, 
 			T angle);
 		
-		//! Rotate a four dimentionnals vector around the X axis. 
+		//! Rotate a four dimensional vector around the X axis. 
 		//! From GLM_GTX_rotate_vector extension.
 		template <typename T> 
 		detail::tvec4<T> rotateZ(
@@ -100,6 +103,8 @@ namespace glm
 			const detail::tvec3<T>& Normal, 
 			const detail::tvec3<T>& Up);
 
+		///@}
+		
 	}//namespace rotate_vector
 	}//namespace gtx
 }//namespace glm

glm/gtx/simd_mat4.hpp

@@ -32,6 +32,8 @@ namespace glm
 {
 	namespace detail
 	{
+		/// 4x4 Matrix implemented using SIMD SEE intrinsics.
+		/// \ingroup gtx_simd_mat4
 		GLM_ALIGN(16) struct fmat4x4SIMD
 		{
 			enum ctor{null};
@@ -129,11 +131,14 @@ namespace glm
 	}//namespace detail
 
 	namespace gtx{
-	//! GLM_GTX_simd_mat4 extension: SIMD implementation of vec4 type.
+	//! GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
 	namespace simd_mat4
 	{
 		typedef detail::fmat4x4SIMD simdMat4;
 
+		/// \addtogroup gtx_simd_mat4
+		///@{
+
 		//! Convert a simdMat4 to a mat4.
 		//! (From GLM_GTX_simd_mat4 extension)
 		detail::tmat4x4<float> mat4_cast(
@@ -169,6 +174,8 @@ namespace glm
 		detail::fmat4x4SIMD simdInverse(
 			detail::fmat4x4SIMD const & m);
 
+		///@}
+
 	}//namespace simd_mat4
 	}//namespace gtx
 }//namespace glm

glm/gtx/simd_vec4.hpp

@@ -32,6 +32,8 @@ namespace glm
 {
 	namespace detail
 	{
+		/// 4-dimensional vector implemented using SIMD SEE intrinsics.
+		/// \ingroup gtx_simd_vec4
 		GLM_ALIGN(4) struct fvec4SIMD
 		{
 			enum ctor{null};
@@ -117,6 +119,9 @@ namespace glm
 	{
 		typedef detail::fvec4SIMD simdVec4;
 
+		/// \addtogroup gtx_simd_vec4
+		///@{
+
 		//! Convert a simdVec4 to a vec4.
 		//! (From GLM_GTX_simd_vec4 extension)
 		detail::tvec4<float> vec4_cast(
@@ -401,6 +406,8 @@ namespace glm
 			detail::fvec4SIMD const & I,
 			detail::fvec4SIMD const & N,
 			float const & eta);
+
+		///@}
 	}//namespace simd_vec4
 	}//namespace gtx
 }//namespace glm

glm/gtx/spline.hpp

@@ -29,6 +29,9 @@ namespace glm
     {
 		using namespace gtx::optimum_pow;
 
+		/// \addtogroup gtx_spline
+		///@{
+
 		//! Return a point from a catmull rom curve.
 		//! From GLM_GTX_spline extension.
 		template <typename genType> 
@@ -59,6 +62,8 @@ namespace glm
 			const genType& v4, 
 			const GLMvalType& s);
 
+		///@}
+
 	}//namespace spline
     }//namespace gtx
 }//namespace glm

glm/gtx/string_cast.hpp

@@ -43,11 +43,16 @@ namespace glm
 		using namespace gtx::unsigned_int; 
 		using namespace gtx::quaternion; 
 
+		/// \addtogroup gtx_string_cast
+		///@{
+
 		//! Create a string from a GLM type value.
 		//! From GLM_GTX_string_cast extension.
 		template <typename genType> 
 		std::string to_string(genType const & x);
 
+		///@}
+
 	}//namespace string_cast
 	}//namespace gtx
 }//namespace glm

glm/gtx/transform.hpp

@@ -34,6 +34,9 @@ namespace glm
 	{
 		using namespace gtc::matrix_transform; 
 
+		/// \addtogroup gtx_transform
+		///@{
+
 		//! Builds a translation 4 * 4 matrix created from 3 scalars.
 		//! From GLM_GTX_transform extension.
 		template <typename T> 
@@ -94,6 +97,8 @@ namespace glm
 		detail::tmat4x4<T> scale(
 			detail::tvec3<T> const & v);
 
+		///@}
+
 	}//namespace transform
 	}//namespace gtx
 }//namespace glm

glm/gtx/transform2.hpp

@@ -34,6 +34,9 @@ namespace glm
 	{
 		using namespace gtx::transform;
 
+		/// \addtogroup gtx_transform2
+		///@{
+
 		//! Transforms a matrix with a shearing on X axis.
 		//! From GLM_GTX_transform2 extension.
 		template <typename T> 
@@ -109,6 +112,8 @@ namespace glm
 			valType scale, 
 			valType bias);
 
+		///@}
+
 	}//namespace transform2
     }//namespace gtx
 }//namespace glm

glm/gtx/unsigned_int.hpp

@@ -34,6 +34,9 @@ namespace glm
 	{
 		using namespace gtx::integer;
 
+		/// \addtogroup gtx_unsigned_int
+		///@{
+
 		//! 32bit signed integer. 
 		//! From GLM_GTX_unsigned_int extension.
 		typedef signed int					sint;
@@ -50,6 +53,8 @@ namespace glm
 		//! From GLM_GTX_unsigned_int extension.
 		uint mod(uint x, uint y);
 
+		///@}
+
 	}//namespace unsigned_int
 	}//namespace gtx
 }//namespace glm

glm/gtx/vec1.hpp

@@ -34,41 +34,41 @@ namespace glm
 		namespace precision
 		{
 			//! 1 component vector of high precision floating-point numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::highp_vec1_t			highp_vec1;
 			//! 1 component vector of medium precision floating-point numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::mediump_vec1_t			mediump_vec1;
 			//! 1 component vector of low precision floating-point numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::lowp_vec1_t				lowp_vec1;
 
 			//! 1 component vector of high precision signed integer numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::highp_ivec1_t			highp_ivec1;
 			//! 1 component vector of medium precision signed integer numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::mediump_ivec1_t			mediump_ivec1;
 			//! 1 component vector of low precision signed integer numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::lowp_ivec1_t			lowp_ivec1;
 
 			//! 1 component vector of high precision unsigned integer numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::highp_uvec1_t			highp_uvec1;
 			//! 1 component vector of medium precision unsigned integer numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::mediump_uvec1_t			mediump_uvec1;
 			//! 1 component vector of low precision unsigned integer numbers. 
-			//! There is no garanty on the actual precision.
+			//! There is no guarantee on the actual precision.
 			//! From GLM_GTX_vec1 extension.
 			typedef detail::lowp_uvec1_t			lowp_uvec1;
 		}//namespace precision

glm/gtx/vector_access.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_vector_access extension: Function to set values to vectors
     namespace vector_access
     {
+		/// \addtogroup gtx_vector_access
+		///@{
+
 		//! Set values to a 2 components vector.
 		//! From GLM_GTX_vector_access extension.
         template <typename valType> 
@@ -57,6 +60,8 @@ namespace glm
 			valType const & z, 
 			valType const & w);
 
+		///@}
+
     }//namespace vector_access
     }//namespace gtx
 }//namespace glm

glm/gtx/vector_angle.hpp

@@ -37,6 +37,9 @@ namespace glm
 		using namespace quaternion;
 		using namespace epsilon;
 
+		/// \addtogroup gtx_vector_angle
+		///@{
+
 		//! Returns the absolute angle between x and y.
 		//! Parameters need to be normalized.
 		//! From GLM_GTX_vector_angle extension
@@ -61,6 +64,8 @@ namespace glm
 			vecType const & x,
 			vecType const & y,
 			detail::tvec3<typename vecType::value_type> const & ref);
+
+		///@}
     }//namespace vector_angle
     }//namespace gtx
 }//namespace glm

glm/gtx/vector_query.hpp

@@ -32,6 +32,9 @@ namespace glm
 	//! GLM_GTX_vector_query extension: Query informations of vector types
     namespace vector_query
     {
+		/// \addtogroup gtx_vector_query
+		///@{
+
 		//! Check if two vectors are collinears.
 		//! From GLM_GTX_vector_query extensions.
 		template <typename genType> 
@@ -86,6 +89,8 @@ namespace glm
 			const genType& v1, 
 			const GLMvalType epsilon = std::numeric_limits<GLMvalType>::epsilon());
 
+		///@}
+
     }//namespace vector_query
     }//namespace gtx
 }//namespace glm

glm/gtx/verbose_operator.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_verbose_operator extension: Use words to replace operators
 	namespace verbose_operator
 	{
+		/// \addtogroup gtx_verbose_operator
+		///@{
+
 		//! Addition of two values
 		//! From GLM_GTX_verbose_operator extension.
 		template <typename genTypeT, typename genTypeU> 
@@ -54,6 +57,8 @@ namespace glm
 		//! From GLM_GTX_verbose_operator extension.
 		template <typename genTypeT, typename genTypeU, typename genTypeV> 
 		genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
+
+		///@}
 	}//namespace verbose_operator
 	}//namespace gtx
 }//namespace glm

glm/gtx/wrap.hpp

@@ -30,6 +30,9 @@ namespace glm
 	//! GLM_GTX_wrap: Wrapping mode using my texture samping.
 	namespace wrap
 	{
+		/// \addtogroup gtx_wrap
+		///@{
+
 		//! Simulate GL_CLAMP OpenGL wrap mode
 		//! From GLM_GTX_wrap extension.
 		template <typename genType> 
@@ -45,6 +48,8 @@ namespace glm
 		template <typename genType> 
 		genType mirrorRepeat(genType const & Texcoord);
 
+		///@}
+
 	}//namespace wrap
 	}//namespace gtx
 }//namespace glm