Doxygen doc fixes

glm/detail/func_integer.hpp

@@ -164,8 +164,6 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
 	template <typename genType>
 	GLM_FUNC_DECL int bitCount(genType v);
 
@@ -175,8 +173,6 @@ namespace glm
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
-	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL vecType<int, P> bitCount(vecType<T, P> const & v);
 
@@ -184,12 +180,21 @@ namespace glm
 	/// 1 in the binary representation of value. 
 	/// If value is zero, -1 will be returned.
 	///
-	/// @tparam T Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	GLM_FUNC_DECL int findLSB(genIUType x);
+
+	/// Returns the bit number of the least significant bit set to
+	/// 1 in the binary representation of value. 
+	/// If value is zero, -1 will be returned.
+	///
+	/// @tparam T Signed or unsigned integer scalar types.
 	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL vecType<int, P> findLSB(vecType<T, P> const & v);
 
@@ -198,12 +203,22 @@ namespace glm
 	/// For negative integers, the result will be the bit number of the most significant
 	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
 	///
-	/// @tparam T Signed or unsigned integer scalar or vector types.
+	/// @tparam T Signed or unsigned integer scalar types.
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
+	template <typename genIUType>
+	GLM_FUNC_DECL int findMSB(genIUType x);
+
+	/// Returns the bit number of the most significant bit in the binary representation of value.
+	/// For positive integers, the result will be the bit number of the most significant bit set to 1. 
+	/// For negative integers, the result will be the bit number of the most significant
+	/// bit set to 0. For a value of zero or negative one, -1 will be returned.
+	///
+	/// @tparam T Signed or unsigned integer scalar types.
 	///
-	/// @todo Clarify the declaration to specify that scalars are suported.
+	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
+	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.8 Integer Functions</a>
 	template <typename T, precision P, template <typename, precision> class vecType>
 	GLM_FUNC_DECL vecType<int, P> findMSB(vecType<T, P> const & v);
 

glm/detail/func_matrix.hpp

@@ -136,8 +136,6 @@ namespace detail
 	///
 	/// @see <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/outerProduct.xml">GLSL outerProduct man page</a>
 	/// @see <a href="http://www.opengl.org/registry/doc/GLSLangSpec.4.20.8.pdf">GLSL 4.20.8 specification, section 8.6 Matrix Functions</a>
-	/// 
-	/// @todo Clarify the declaration to specify that matType doesn't have to be provided when used.
 	template <typename T, precision P, template <typename, precision> class vecTypeA, template <typename, precision> class vecTypeB>
 	GLM_FUNC_DECL typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r);
 

glm/ext.hpp

@@ -48,11 +48,6 @@
 /// Even if it's highly unrecommended, it's possible to include all the extensions 
 /// at once by including <glm/ext.hpp>. Otherwise, each extension needs to be 
 /// included  a specific file.
-/// 
-/// @defgroup virtrev VIRTREV Extensions
-/// 
-/// @brief Extensions develop and maintain by Mathieu [matrem] Roumillac
-/// (http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showprofile&User=22660).
 ///////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
@@ -65,6 +60,7 @@
 #include "./gtc/bitfield.hpp"
 #include "./gtc/constants.hpp"
 #include "./gtc/epsilon.hpp"
+#include "./gtc/integer.hpp"
 #include "./gtc/matrix_access.hpp"
 #include "./gtc/matrix_integer.hpp"
 #include "./gtc/matrix_inverse.hpp"

glm/gtc/constants.hpp

@@ -51,7 +51,6 @@ namespace glm
 	/// @{
 
 	/// Return the epsilon constant for floating point types.
-	/// @todo Implement epsilon for half-precision floating point type.
 	/// @see gtc_constants
 	template <typename genType>
 	GLM_FUNC_DECL genType epsilon();

glm/gtc/vec1.hpp

@@ -27,8 +27,8 @@
 ///
 /// @see core (dependence)
 ///
-/// @defgroup gtc_vec1 GLM_GTX_vec1
-/// @ingroup gtx
+/// @defgroup gtc_vec1 GLM_GTC_vec1
+/// @ingroup gtc
 /// 
 /// @brief Add vec1, ivec1, uvec1 and bvec1 types.
 /// <glm/gtc/vec1.hpp> need to be included to use these functionalities.

glm/gtx/dual_quaternion.hpp

@@ -30,8 +30,8 @@
 /// @see gtc_constants (dependence)
 /// @see gtc_quaternion (dependence)
 ///
-/// @defgroup gtc_dual_quaternion GLM_GTX_dual_quaternion
-/// @ingroup gtc
+/// @defgroup gtx_dual_quaternion GLM_GTX_dual_quaternion
+/// @ingroup gtx
 ///
 /// @brief Defines a templated dual-quaternion type and several dual-quaternion operations.
 ///
@@ -51,7 +51,7 @@
 
 namespace glm
 {
-	/// @addtogroup gtc_dual_quaternion
+	/// @addtogroup gtx_dual_quaternion
 	/// @{
 
 	template <typename T, precision P>
@@ -160,7 +160,7 @@ namespace glm
 
 	/// Returns the normalized quaternion.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	template <typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> normalize(
 		tdualquat<T, P> const & q);
@@ -176,45 +176,35 @@ namespace glm
 
 	/// Returns the q inverse.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	template <typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> inverse(
 		tdualquat<T, P> const & q);
 
-	/*
-	/// Extracts a rotation part from dual-quaternion to a 3 * 3 matrix.
-	/// TODO
-	///
-	/// @see gtc_dual_quaternion
-	template <typename T, precision P>
-	tmat3x3<T, P> mat3_cast(
-		tdualquat<T, P> const & x);
-	*/
-	
 	/// Converts a quaternion to a 2 * 4 matrix.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat2x4<T, P> mat2x4_cast(
 		tdualquat<T, P> const & x);
 
 	/// Converts a quaternion to a 3 * 4 matrix.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	template <typename T, precision P>
 	GLM_FUNC_DECL tmat3x4<T, P> mat3x4_cast(
 		tdualquat<T, P> const & x);
 
 	/// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	template <typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(
 		tmat2x4<T, P> const & x);
 
 	/// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	template <typename T, precision P>
 	GLM_FUNC_DECL tdualquat<T, P> dualquat_cast(
 		tmat3x4<T, P> const & x);
@@ -222,61 +212,61 @@ namespace glm
 	
 	/// Dual-quaternion of low single-precision floating-point numbers.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	typedef tdualquat<float, lowp>		lowp_dualquat;
 	
 	/// Dual-quaternion of medium single-precision floating-point numbers.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	typedef tdualquat<float, mediump>	mediump_dualquat;
 	
 	/// Dual-quaternion of high single-precision floating-point numbers.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	typedef tdualquat<float, highp>		highp_dualquat;
 
 
 	/// Dual-quaternion of low single-precision floating-point numbers.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	typedef tdualquat<float, lowp>		lowp_fdualquat;
 	
 	/// Dual-quaternion of medium single-precision floating-point numbers.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	typedef tdualquat<float, mediump>	mediump_fdualquat;
 	
 	/// Dual-quaternion of high single-precision floating-point numbers.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	typedef tdualquat<float, highp>		highp_fdualquat;
 	
 	
 	/// Dual-quaternion of low double-precision floating-point numbers.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	typedef tdualquat<double, lowp>		lowp_ddualquat;
 	
 	/// Dual-quaternion of medium double-precision floating-point numbers.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	typedef tdualquat<double, mediump>	mediump_ddualquat;
 	
 	/// Dual-quaternion of high double-precision floating-point numbers.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	typedef tdualquat<double, highp>	highp_ddualquat;
 
 	
 #if(!defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
 	/// Dual-quaternion of floating-point numbers.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	typedef highp_fdualquat			dualquat;
 	
 	/// Dual-quaternion of single-precision floating-point numbers.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	typedef highp_fdualquat			fdualquat;
 #elif(defined(GLM_PRECISION_HIGHP_FLOAT) && !defined(GLM_PRECISION_MEDIUMP_FLOAT) && !defined(GLM_PRECISION_LOWP_FLOAT))
 	typedef highp_fdualquat			dualquat;
@@ -295,7 +285,7 @@ namespace glm
 #if(!defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
 	/// Dual-quaternion of default double-precision floating-point numbers.
 	///
-	/// @see gtc_dual_quaternion
+	/// @see gtx_dual_quaternion
 	typedef highp_ddualquat			ddualquat;
 #elif(defined(GLM_PRECISION_HIGHP_DOUBLE) && !defined(GLM_PRECISION_MEDIUMP_DOUBLE) && !defined(GLM_PRECISION_LOWP_DOUBLE))
 	typedef highp_ddualquat			ddualquat;

glm/gtx/rotate_normalized_axis.hpp

@@ -30,7 +30,7 @@
 /// @see gtc_quaternion
 /// 
 /// @defgroup gtx_rotate_normalized_axis GLM_GTX_rotate_normalized_axis
-/// @ingroup gtc
+/// @ingroup gtx
 /// 
 /// @brief Quaternions and matrices rotations around normalized axis.
 /// 

glm/gtx/scalar_relational.hpp

@@ -27,7 +27,7 @@
 ///
 /// @see core (dependence)
 ///
-/// @defgroup gtx_extend GLM_GTX_scalar_relational
+/// @defgroup gtx_scalar_relational GLM_GTX_scalar_relational
 /// @ingroup gtx
 /// 
 /// @brief Extend a position from a source to a position at a defined length.