Doxygen fixes

glm/detail/_features.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_features.hpp
+/// @file glm/detail/_features.hpp
 /// @date 2013-02-20 / 2013-02-20
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/_fixes.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_fixes.hpp
+/// @file glm/detail/_fixes.hpp
 /// @date 2011-02-21 / 2011-11-22
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/_literals.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_literals.hpp
+/// @file glm/detail/_literals.hpp
 /// @date 2013-05-06 / 2013-05-06
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/_swizzle.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_swizzle.hpp
+/// @file glm/detail/_swizzle.hpp
 /// @date 2006-04-20 / 2011-02-16
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/_swizzle_func.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_swizzle_func.hpp
+/// @file glm/detail/_swizzle_func.hpp
 /// @date 2011-10-16 / 2011-10-16
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/_vectorize.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/_vectorize.hpp
+/// @file glm/detail/_vectorize.hpp
 /// @date 2011-10-14 / 2011-10-14
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/func_common.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_common.hpp
+/// @file glm/detail/func_common.hpp
 /// @date 2008-03-08 / 2010-01-26
 /// @author Christophe Riccio
 /// 

glm/detail/func_common.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_common.inl
+/// @file glm/detail/func_common.inl
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/func_exponential.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_exponential.hpp
+/// @file glm/detail/func_exponential.hpp
 /// @date 2008-08-08 / 2011-06-14
 /// @author Christophe Riccio
 /// 
@@ -48,7 +48,7 @@ namespace glm
 
 	/// Returns 'base' raised to the power 'exponent'. 
 	///
-	/// @param base Floating point value. pow function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @param base Floating point value. pow function is defined for input values of 'base' defined in the range (inf-, inf+) in the limit of the type precision.
 	/// @param exponent Floating point value representing the 'exponent'.
 	/// @tparam genType Floating-point scalar or vector types.
 	///
@@ -59,7 +59,7 @@ namespace glm
 
 	/// Returns the natural exponentiation of x, i.e., e^x.
 	///
-	/// @param x exp function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @param v exp function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type precision.
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp.xml">GLSL exp man page</a>
@@ -67,11 +67,11 @@ namespace glm
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL vecType<T, P> exp(vecType<T, P> const & v);
 
-	/// Returns the natural logarithm of x, i.e., 
+	/// Returns the natural logarithm of v, i.e., 
 	/// returns the value y which satisfies the equation x = e^y. 
-	/// Results are undefined if x <= 0.
+	/// Results are undefined if v <= 0.
 	///
-	/// @param x log function is defined for input values of x defined in the range (0, inf+) in the limit of the type precision.
+	/// @param v log function is defined for input values of v defined in the range (0, inf+) in the limit of the type precision.
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log.xml">GLSL log man page</a>
@@ -79,9 +79,9 @@ namespace glm
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL vecType<T, P> log(vecType<T, P> const & v);
 
-	/// Returns 2 raised to the x power.
+	/// Returns 2 raised to the v power.
 	/// 
-	/// @param x exp2 function is defined for input values of x defined in the range (inf-, inf+) in the limit of the type precision.
+	/// @param v exp2 function is defined for input values of v defined in the range (inf-, inf+) in the limit of the type precision.
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/exp2.xml">GLSL exp2 man page</a>
@@ -92,7 +92,7 @@ namespace glm
 	/// Returns the base 2 log of x, i.e., returns the value y, 
 	/// which satisfies the equation x = 2 ^ y.
 	/// 
-	/// @param x log2 function is defined for input values of x defined in the range (0, inf+) in the limit of the type precision.
+	/// @param v log2 function is defined for input values of v defined in the range (0, inf+) in the limit of the type precision.
 	/// @tparam genType Floating-point scalar or vector types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/log2.xml">GLSL log2 man page</a>
@@ -100,9 +100,9 @@ namespace glm
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL vecType<T, P> log2(vecType<T, P> const & v);
 
-	/// Returns the positive square root of x.
+	/// Returns the positive square root of v.
 	/// 
-	/// @param x sqrt function is defined for input values of x defined in the range [0, inf+) in the limit of the type precision.
+	/// @param v sqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type precision.
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/sqrt.xml">GLSL sqrt man page</a>
@@ -112,9 +112,9 @@ namespace glm
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL vecType<T, P> sqrt(vecType<T, P> const & v);
 	
-	/// Returns the reciprocal of the positive square root of x.
+	/// Returns the reciprocal of the positive square root of v.
 	/// 
-	/// @param x inversesqrt function is defined for input values of x defined in the range [0, inf+) in the limit of the type precision.
+	/// @param v inversesqrt function is defined for input values of v defined in the range [0, inf+) in the limit of the type precision.
 	/// @tparam genType Floating-point scalar or vector types.
 	/// 
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/inversesqrt.xml">GLSL inversesqrt man page</a>

glm/detail/func_exponential.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_exponential.inl
+/// @file glm/detail/func_exponential.inl
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/func_geometric.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_geometric.hpp
+/// @file glm/detail/func_geometric.hpp
 /// @date 2008-08-03 / 2011-06-14
 /// @author Christophe Riccio
 ///

glm/detail/func_geometric.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_geometric.inl
+/// @file glm/detail/func_geometric.inl
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/func_integer.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_integer.hpp
+/// @file glm/detail/func_integer.hpp
 /// @date 2010-03-17 / 2011-06-18
 /// @author Christophe Riccio
 ///

glm/detail/func_integer.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_integer.inl
+/// @file glm/detail/func_integer.inl
 /// @date 2010-03-17 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/func_matrix.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_matrix.hpp
+/// @file glm/detail/func_matrix.hpp
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///

glm/detail/func_matrix.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_matrix.inl
+/// @file glm/detail/func_matrix.inl
 /// @date 2008-03-08 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/func_noise.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_noise.hpp
+/// @file glm/detail/func_noise.hpp
 /// @date 2008-08-01 / 2011-06-18
 /// @author Christophe Riccio
 ///

glm/detail/func_noise.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_noise.inl
+/// @file glm/detail/func_noise.inl
 /// @date 2008-08-01 / 2011-09-27
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/func_packing.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_packing.hpp
+/// @file glm/detail/func_packing.hpp
 /// @date 2010-03-17 / 2011-06-15
 /// @author Christophe Riccio
 ///

glm/detail/func_packing.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_packing.inl
+/// @file glm/detail/func_packing.inl
 /// @date 2010-03-17 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/func_trigonometric.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_trigonometric.hpp
+/// @file glm/detail/func_trigonometric.hpp
 /// @date 2008-08-01 / 2011-06-15
 /// @author Christophe Riccio
 ///

glm/detail/func_trigonometric.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_trigonometric.inl
+/// @file glm/detail/func_trigonometric.inl
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/func_vector_relational.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_vector_relational.hpp
+/// @file glm/detail/func_vector_relational.hpp
 /// @date 2008-08-03 / 2011-06-15
 /// @author Christophe Riccio
 ///

glm/detail/func_vector_relational.inl

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/func_vector_relational.inl
+/// @file glm/detail/func_vector_relational.inl
 /// @date 2008-08-03 / 2011-09-09
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/detail/hint.hpp

@@ -21,7 +21,7 @@
 /// THE SOFTWARE.
 ///
 /// @ref core
-/// @file glm/core/hint.hpp
+/// @file glm/detail/hint.hpp
 /// @date 2008-08-14 / 2011-06-15
 /// @author Christophe Riccio
 ///////////////////////////////////////////////////////////////////////////////////

glm/glm.hpp

@@ -25,9 +25,9 @@
 /// @date 2005-01-14 / 2011-10-24
 /// @author Christophe Riccio
 ///
-///	@defgroup core GLM Core
+/// @defgroup core GLM Core
 ///
-///	@brief The core of GLM, which implements exactly and only the GLSL specification to the degree possible.
+/// @brief The core of GLM, which implements exactly and only the GLSL specification to the degree possible.
 ///
 /// The GLM core consists of @ref core_types "C++ types that mirror GLSL types" and
 /// C++ functions that mirror the GLSL functions. It also includes 
@@ -37,7 +37,6 @@
 /// The best documentation for GLM Core is the current GLSL specification,
 /// <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.clean.pdf">version 4.2
 /// (pdf file)</a>.
-/// There are a few @ref pg_differences "differences" between GLM core and GLSL.
 /// 
 /// GLM core functionnalities require <glm/glm.hpp> to be included to be used.
 /// 

glm/gtc/matrix_transform.hpp

@@ -77,8 +77,6 @@ namespace glm
 	/// // m[3][0] == 1.0f, m[3][1] == 1.0f, m[3][2] == 1.0f, m[3][3] == 1.0f
 	/// @endcode
 	/// @see gtc_matrix_transform
-	/// @see gtx_transform
-	/// @see - translate(T x, T y, T z)
 	/// @see - translate(tmat4x4<T, P> const & m, T x, T y, T z)
 	/// @see - translate(tvec3<T, P> const & v)
 	template <typename T, precision P>
@@ -93,8 +91,6 @@ namespace glm
 	/// @param axis Rotation axis, recommanded to be normalized.
 	/// @tparam T Value type used to build the matrix. Supported: half, float or double.
 	/// @see gtc_matrix_transform
-	/// @see gtx_transform
-	/// @see - rotate(T angle, T x, T y, T z) 
 	/// @see - rotate(tmat4x4<T, P> const & m, T angle, T x, T y, T z) 
 	/// @see - rotate(T angle, tvec3<T, P> const & v) 
 	template <typename T, precision P>
@@ -109,8 +105,6 @@ namespace glm
 	/// @param v Ratio of scaling for each axis.
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
-	/// @see gtx_transform
-	/// @see - scale(T x, T y, T z) scale(T const & x, T const & y, T const & z)
 	/// @see - scale(tmat4x4<T, P> const & m, T x, T y, T z)
 	/// @see - scale(tvec3<T, P> const & v)
 	template <typename T, precision P>
@@ -175,10 +169,10 @@ namespace glm
 
 	/// Creates a matrix for a symetric perspective-view frustum.
 	/// 
-	/// @param fovy Expressed in radians.
-	/// @param aspect 
-	/// @param near 
-	/// @param far 
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template <typename T>
@@ -193,8 +187,8 @@ namespace glm
 	/// @param fov Expressed in radians.
 	/// @param width 
 	/// @param height 
-	/// @param near 
-	/// @param far 
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param far Specifies the distance from the viewer to the far clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template <typename T>
@@ -207,9 +201,9 @@ namespace glm
 
 	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite.
 	/// 
-	/// @param fovy Expressed in radians.
-	/// @param aspect 
-	/// @param near 
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template <typename T>
@@ -218,9 +212,9 @@ namespace glm
 
 	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
 	/// 
-	/// @param fovy Expressed in radians.
-	/// @param aspect 
-	/// @param near 
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template <typename T>
@@ -229,9 +223,10 @@ namespace glm
 
 	/// Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
 	/// 
-	/// @param fovy Expressed in radians.
-	/// @param aspect 
-	/// @param near 
+	/// @param fovy Specifies the field of view angle, in degrees, in the y direction. Expressed in radians.
+	/// @param aspect Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height).
+	/// @param near Specifies the distance from the viewer to the near clipping plane (always positive).
+	/// @param ep 
 	/// @tparam T Value type used to build the matrix. Currently supported: half (not recommanded), float or double.
 	/// @see gtc_matrix_transform
 	template <typename T>
@@ -240,10 +235,11 @@ namespace glm
 
 	/// Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
 	/// 
-	/// @param obj 
-	/// @param model 
-	/// @param proj
-	/// @param viewport 
+	/// @param obj Specify the object coordinates.
+	/// @param model Specifies the current modelview matrix
+	/// @param proj Specifies the current projection matrix
+	/// @param viewport Specifies the current viewport
+	/// @return Return the computed window coordinates.
 	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
 	/// @tparam U Currently supported: Floating-point types and integer types.
 	/// @see gtc_matrix_transform
@@ -256,10 +252,11 @@ namespace glm
 
 	/// Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
 	///
-	/// @param win
-	/// @param model
-	/// @param proj
-	/// @param viewport
+	/// @param win Specify the window coordinates to be mapped.
+	/// @param model Specifies the modelview matrix
+	/// @param proj Specifies the projection matrix
+	/// @param viewport Specifies the viewport
+	/// @return Returns the computed object coordinates.
 	/// @tparam T Native type used for the computation. Currently supported: half (not recommanded), float or double.
 	/// @tparam U Currently supported: Floating-point types and integer types.
 	/// @see gtc_matrix_transform

glm/gtc/round.hpp

@@ -107,19 +107,19 @@ namespace glm
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL vecType<T, P> roundPowerOfTwo(vecType<T, P> const & value);
 
-	/// Return true if the <Value> is a multiple of <Multiple>.
+	/// Return true if the 'Value' is a multiple of 'Multiple'.
 	///
 	/// @see gtc_round
 	template <typename genIUType>
 	GLM_FUNC_DECL bool isMultiple(genIUType Value, genIUType Multiple);
 
-	/// Return true if the <Value> is a multiple of <Multiple>.
+	/// Return true if the 'Value' is a multiple of 'Multiple'.
 	///
 	/// @see gtc_round
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL vecType<bool, P> isMultiple(vecType<T, P> const & Value, T Multiple);
 
-	/// Return true if the <Value> is a multiple of <Multiple>.
+	/// Return true if the 'Value' is a multiple of 'Multiple'.
 	///
 	/// @see gtc_round
 	template <typename T, precision P, template <typename, precision> class vecType>

glm/gtx/range.hpp

@@ -25,13 +25,18 @@
 /// @date 2014-09-19 / 2014-09-19
 /// @author Joshua Moerman
 ///
+/// @defgroup gtx_range GLM_GTX_range
+/// @ingroup gtx
+///
 /// @brief Defines begin and end for vectors and matrices. Useful for range-based for loop.
 /// The range is defined over the elements, not over columns or rows (e.g. mat4 has 16 elements).
 ///
+/// <glm/gtx/range.hpp> need to be included to use these functionalities.
 ///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 
+// Dependencies
 #include "../detail/setup.hpp"
 
 #if !GLM_HAS_RANGE_FOR
@@ -66,6 +71,9 @@ namespace detail
 	}
 }//namespace
 
+	/// @addtogroup gtx_range
+	/// @{
+
 	template <typename genType>
 	const typename genType::value_type * begin(genType const & v){
 		return value_ptr(v);
@@ -85,4 +93,6 @@ namespace detail
 	typename genType::value_type * end(genType& v){
 		return begin(v) + detail::number_of_elements_(v);
 	}
+
+	/// @}
 }//namespace glm

glm/gtx/simd_quat.hpp

@@ -27,7 +27,7 @@
 ///
 /// @see core (dependence)
 ///
-/// @defgroup gtx_simd_vec4 GLM_GTX_simd_quat
+/// @defgroup gtx_simd_quat GLM_GTX_simd_quat
 /// @ingroup gtx
 /// 
 /// @brief SIMD implementation of quat type.
@@ -54,19 +54,15 @@
 #	pragma message("GLM: GLM_GTX_simd_quat extension included")
 #endif
 
-
 // Warning silencer for nameless struct/union.
 #if (GLM_COMPILER & GLM_COMPILER_VC)
 #   pragma warning(push)
 #   pragma warning(disable:4201)   // warning C4201: nonstandard extension used : nameless struct/union
 #endif
 
-
 namespace glm{
 namespace detail
 {
-	/// Quaternion implemented using SIMD SEE intrinsics.
-	/// \ingroup gtx_simd_vec4
 	GLM_ALIGNED_STRUCT(16) fquatSIMD
 	{
 		typedef __m128 value_type;
@@ -77,13 +73,13 @@ namespace detail
 		typedef tquat<bool, defaultp> bool_type;
 
 #ifdef GLM_SIMD_ENABLE_XYZW_UNION
-        union
-        {
-		    __m128 Data;
-            struct {float x, y, z, w;};
-        };
+		union
+		{
+			__m128 Data;
+			struct {float x, y, z, w;};
+		};
 #else
-        __m128 Data;
+		__m128 Data;
 #endif
 
 		//////////////////////////////////////
@@ -105,7 +101,7 @@ namespace detail
 			float const & z);
 		explicit fquatSIMD(
 			quat const & v);
-        explicit fquatSIMD(
+		explicit fquatSIMD(
 			vec3 const & eulerAngles);
 		
 
@@ -154,59 +150,59 @@ namespace detail
 
 }//namespace detail
 
-	typedef glm::detail::fquatSIMD simdQuat;
-
 	/// @addtogroup gtx_simd_quat
 	/// @{
 
+	typedef glm::detail::fquatSIMD simdQuat;
+
 	//! Convert a simdQuat to a quat.
-	//! (From GLM_GTX_simd_quat extension)
+	/// @see gtx_simd_quat
 	quat quat_cast(
 		detail::fquatSIMD const & x);
 
 	//! Convert a simdMat4 to a simdQuat.
-	//! (From GLM_GTX_simd_quat extension)
+	/// @see gtx_simd_quat
 	detail::fquatSIMD quatSIMD_cast(
 		detail::fmat4x4SIMD const & m);
 
 	//! Converts a mat4 to a simdQuat.
-	//! (From GLM_GTX_simd_quat extension)
+	/// @see gtx_simd_quat
 	template <typename T, precision P>
 	detail::fquatSIMD quatSIMD_cast(
 		tmat4x4<T, P> const & m);
 
 	//! Converts a mat3 to a simdQuat.
-	//! (From GLM_GTX_simd_quat extension)
+	/// @see gtx_simd_quat
 	template <typename T, precision P>
 	detail::fquatSIMD quatSIMD_cast(
 		tmat3x3<T, P> const & m);
 
 	//! Convert a simdQuat to a simdMat4
-	//! (From GLM_GTX_simd_quat extension)
+	/// @see gtx_simd_quat
 	detail::fmat4x4SIMD mat4SIMD_cast(
 		detail::fquatSIMD const & q);
 
 	//! Converts a simdQuat to a standard mat4.
-	//! (From GLM_GTX_simd_quat extension)
+	/// @see gtx_simd_quat
 	mat4 mat4_cast(
 		detail::fquatSIMD const & q);
 
 
 	/// Returns the length of the quaternion. 
 	/// 
-	/// @see gtc_quaternion
+	/// @see gtx_simd_quat
 	float length(
 		detail::fquatSIMD const & x);
 
 	/// Returns the normalized quaternion. 
 	/// 
-	/// @see gtc_quaternion
+	/// @see gtx_simd_quat
 	detail::fquatSIMD normalize(
 		detail::fquatSIMD const & x);
 
 	/// Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ... 
 	/// 
-	/// @see gtc_quaternion
+	/// @see gtx_simd_quat
 	float dot(
 		detail::fquatSIMD const & q1, 
 		detail::fquatSIMD const & q2);
@@ -219,7 +215,7 @@ namespace detail
 	/// @param y A quaternion
 	/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
 	/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
-	/// @see gtc_quaternion
+	/// @see gtx_simd_quat
 	/// @see - slerp(detail::fquatSIMD const & x, detail::fquatSIMD const & y, T const & a) 
 	detail::fquatSIMD mix(
 		detail::fquatSIMD const & x, 
@@ -233,7 +229,7 @@ namespace detail
 	/// @param y A quaternion
 	/// @param a Interpolation factor. The interpolation is defined in the range [0, 1].
 	/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
-	/// @see gtc_quaternion
+	/// @see gtx_simd_quat
 	detail::fquatSIMD lerp(
 		detail::fquatSIMD const & x, 
 		detail::fquatSIMD const & y, 
@@ -246,7 +242,7 @@ namespace detail
 	/// @param y A quaternion
 	/// @param a Interpolation factor. The interpolation is defined beyond the range [0, 1].
 	/// @tparam T Value type used to build the quaternion. Supported: half, float or double.
-	/// @see gtc_quaternion
+	/// @see gtx_simd_quat
 	detail::fquatSIMD slerp(
 		detail::fquatSIMD const & x, 
 		detail::fquatSIMD const & y, 
@@ -261,7 +257,7 @@ namespace detail
 	///
 	/// This will use the equivalent to fastAcos() and fastSin().
 	///
-	/// @see gtc_quaternion
+	/// @see gtx_simd_quat
 	/// @see - mix(detail::fquatSIMD const & x, detail::fquatSIMD const & y, T const & a) 
 	detail::fquatSIMD fastMix(
 		detail::fquatSIMD const & x, 
@@ -283,13 +279,13 @@ namespace detail
 
 	/// Returns the q conjugate. 
 	/// 
-	/// @see gtc_quaternion
+	/// @see gtx_simd_quat
 	detail::fquatSIMD conjugate(
 		detail::fquatSIMD const & q);
 
 	/// Returns the q inverse. 
 	/// 
-	/// @see gtc_quaternion
+	/// @see gtx_simd_quat
 	detail::fquatSIMD inverse(
 		detail::fquatSIMD const & q);
 
@@ -298,7 +294,7 @@ namespace detail
 	/// @param angle Angle expressed in radians.
 	/// @param axis Axis of the quaternion, must be normalized. 
 	///
-	/// @see gtc_quaternion
+	/// @see gtx_simd_quat
 	detail::fquatSIMD angleAxisSIMD(
 		float const & angle, 
 		vec3 const & axis);
@@ -310,19 +306,17 @@ namespace detail
 	/// @param y y component of the y-axis, x, y, z must be a normalized axis
 	/// @param z z component of the z-axis, x, y, z must be a normalized axis
 	///
-	/// @see gtc_quaternion
+	/// @see gtx_simd_quat
 	detail::fquatSIMD angleAxisSIMD(
 		float const & angle, 
 		float const & x, 
 		float const & y, 
 		float const & z);
 
-
 	// TODO: Move this to somewhere more appropriate. Used with fastMix() and fastSlerp().
 	/// Performs the equivalent of glm::fastSin() on each component of the given __m128.
 	__m128 fastSin(__m128 x);
 
-
 	/// @}
 }//namespace glm
 

glm/gtx/transform.hpp

@@ -54,23 +54,23 @@ namespace glm
 	/// @{
 
 	/// Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars.
-	/// - From \link gtx_transform GLM_GTX_transform \endlink extension
-	/// - See also: \link glm::translate GLM_GTC_matrix_transform \endlink
+	/// @see gtc_matrix_transform
+	/// @see gtx_transform
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat4x4<T, P> translate(
 		tvec3<T, P> const & v);
 
 	/// Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees. 
-	/// - From \link gtx_transform GLM_GTX_transform \endlink extension
-	/// - See also: \link glm::rotate GLM_GTC_matrix_transform \endlink
+	/// @see gtc_matrix_transform
+	/// @see gtx_transform
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat4x4<T, P> rotate(
 		T angle, 
 		tvec3<T, P> const & v);
 
 	/// Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components.
-	/// - From \link gtx_transform GLM_GTX_transform \endlink extension
-	/// - See also: \link glm::scale GLM_GTC_matrix_transform \endlink
+	/// @see gtc_matrix_transform
+	/// @see gtx_transform
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat4x4<T, P> scale(
 		tvec3<T, P> const & v);