mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-23 01:14:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Doxygen doc fixes

Browse Source
This commit is contained in:
Christophe Riccio 2014-11-25 00:16:03 +01:00
parent d12f833017
commit 4f5bd21a5e
8 changed files with 49 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
glm/detail/func_integer.hpp
View File

@ -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/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> /// @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> template <typename genType>
GLM_FUNC_DECL int bitCount(genType v); 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/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> /// @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> template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<int, P> bitCount(vecType<T, P> const & v); 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. /// 1 in the binary representation of value.
/// If value is zero, -1 will be returned. /// 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/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> /// @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.
/// ///
/// @todo Clarify the declaration to specify that scalars are suported. /// @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 T, precision P, template <typename, precision> class vecType> template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<int, P> findLSB(vecType<T, P> const & v); 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 /// 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. /// 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/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> /// @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.
/// ///
/// @todo Clarify the declaration to specify that scalars are suported. /// @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 T, precision P, template <typename, precision> class vecType> template <typename T, precision P, template <typename, precision> class vecType>
GLM_FUNC_DECL vecType<int, P> findMSB(vecType<T, P> const & v); GLM_FUNC_DECL vecType<int, P> findMSB(vecType<T, P> const & v);

2
glm/detail/func_matrix.hpp
View File

@ -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/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> /// @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> 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_FUNC_DECL typename detail::outerProduct_trait<T, P, vecTypeA, vecTypeB>::type outerProduct(vecTypeA<T, P> const & c, vecTypeB<T, P> const & r);

6
glm/ext.hpp
View File

@ -48,11 +48,6 @@
/// Even if it's highly unrecommended, it's possible to include all the extensions /// 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 /// at once by including <glm/ext.hpp>. Otherwise, each extension needs to be
/// included a specific file. /// 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 #pragma once
@ -65,6 +60,7 @@
#include "./gtc/bitfield.hpp" #include "./gtc/bitfield.hpp"
#include "./gtc/constants.hpp" #include "./gtc/constants.hpp"
#include "./gtc/epsilon.hpp" #include "./gtc/epsilon.hpp"
#include "./gtc/integer.hpp"
#include "./gtc/matrix_access.hpp" #include "./gtc/matrix_access.hpp"
#include "./gtc/matrix_integer.hpp" #include "./gtc/matrix_integer.hpp"
#include "./gtc/matrix_inverse.hpp" #include "./gtc/matrix_inverse.hpp"

1
glm/gtc/constants.hpp
View File

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

4
glm/gtc/vec1.hpp
View File

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

52
glm/gtx/dual_quaternion.hpp
View File

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

2
glm/gtx/rotate_normalized_axis.hpp
View File

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

2
glm/gtx/scalar_relational.hpp
View File

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