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

Updated header files formatting

Browse Source
This commit is contained in:
Christophe Riccio 2011-05-18 15:38:03 +01:00
parent 9ecdd379e4
commit 14760e9770
61 changed files with 2558 additions and 2703 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
glm/gtx/associated_min_max.hpp
View File

@ -21,13 +21,10 @@
# pragma message("GLM: GLM_GTX_associated_min_max extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace associated_min_max ///< GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
{
namespace gtx
{
//! 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
///@{
@ -72,13 +69,11 @@ namespace glm
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d);
///@}
}//namespace associated_min_max
bool test();
}//namespace gtx
}//namespace glm
} //namespace associated_min_max
} //namespace gtx
} //namespace glm
#include "associated_min_max.inl"

13
glm/gtx/bit.hpp
View File

@ -22,12 +22,10 @@
# pragma message("GLM: GLM_GTX_bit extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace bit ///< GLM_GTX_bit extension: Allow to perform bit operations on integer values
{
namespace gtx{
//! GLM_GTX_bit extension: Allow to perform bit operations on integer values
namespace bit
{
using namespace gtc::half_float;
/// \addtogroup gtx_bit
@ -98,9 +96,8 @@ namespace glm
genType bitRotateLeft(genType const & In, std::size_t Shift);
///@}
}//namespace bit
}//namespace gtx
}//namespace bit
}//namespace gtx
}//namespace glm
#include "bit.inl"

22
glm/gtx/closest_point.hpp
View File

@ -20,27 +20,25 @@
# pragma message("GLM: GLM_GTX_closest_point extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace closest_point ///< GLM_GTX_closest_point extension: Find the point on a straight line which is the closet of a point.
{
namespace gtx{
//! 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.
/// Find the point on a straight line which is the closet of a point.
/// From GLM_GTX_closest_point extension.
template <typename T>
detail::tvec3<T> closestPointOnLine(
detail::tvec3<T> const & point,
detail::tvec3<T> const & a,
detail::tvec3<T> const & b);
///@}
}//namespace closest_point
}//namespace gtx
}//namespace glm
/// @}
}// namespace closest_point
}// namespace gtx
}// namespace glm
#include "closest_point.inl"

12
glm/gtx/color_cast.hpp
View File

@ -22,12 +22,10 @@
# pragma message("GLM: GLM_GTX_color_cast extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace color_cast ///< GLM_GTX_color_cast extension: Conversion between two color types
{
namespace gtx{
//! GLM_GTX_color_cast extension: Conversion between two color types
namespace color_cast
{
using namespace gtx::number_precision;
/// \addtogroup gtx_color_cast
@ -98,8 +96,8 @@ namespace glm
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 color_space
}//namespace gtx
}//namespace glm
#include "color_cast.inl"

17
glm/gtx/color_space.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_color_space extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace color_space ///< GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
{
namespace gtx{
//! 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.
@ -67,10 +65,9 @@ namespace glm
valType luminosity(
detail::tvec3<valType> const & color);
///@}
}//namespace color_space
}//namespace gtx
/// @}
}//namespace color_space
}//namespace gtx
}//namespace glm
#include "color_space.inl"

14
glm/gtx/color_space_YCoCg.hpp
View File

@ -20,12 +20,10 @@
# pragma message("GLM: GLM_GTX_color_space_YCoCg extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace color_space_YCoCg ///< GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
{
namespace gtx{
//! GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
namespace color_space_YCoCg
{
/// \addtogroup gtx_color_space_YCoCg
///@{
@ -55,9 +53,9 @@ namespace glm
detail::tvec3<valType> YCoCgR2rgb(
detail::tvec3<valType> const & YCoCgColor);
///@}
}//namespace color_space_YCoCg
}//namespace gtx
/// @}
}//namespace color_space_YCoCg
}//namespace gtx
}//namespace glm
#include "color_space_YCoCg.inl"

15
glm/gtx/compatibility.hpp
View File

@ -28,12 +28,10 @@
#include <cmath>
#endif//GLM_COMPILER
namespace glm
namespace glm{
namespace gtx{
namespace compatibility ///< GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
{
namespace gtx{
//! GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
namespace compatibility
{
/// \addtogroup gtx_compatibility
///@{
@ -150,10 +148,9 @@ 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 compatibility
}//namespace gtx
}//namespace glm
#include "compatibility.inl"

17
glm/gtx/component_wise.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_component_wise extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace component_wise ///< GLM_GTX_component_wise extension: Operations between components of a type
{
namespace gtx{
//! 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.
@ -53,10 +51,9 @@ namespace glm
typename genType::value_type compMax(
genType const & v);
///@}
}//namespace component_wise
}//namespace gtx
/// @}
}//namespace component_wise
}//namespace gtx
}//namespace glm
#include "component_wise.inl"

13
glm/gtx/epsilon.hpp
View File

@ -22,12 +22,10 @@
# pragma message("GLM: GLM_GTX_epsilon extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace epsilon ///< GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
{
namespace gtx{
//! GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
namespace epsilon
{
/// \addtogroup gtx_epsilon
///@{
@ -48,9 +46,8 @@ namespace glm
genTypeU const & epsilon);
///@}
}//namespace epsilon
}//namespace gtx
}//namespace epsilon
}//namespace gtx
}//namespace glm
#include "epsilon.inl"

16
glm/gtx/euler_angles.hpp
View File

@ -26,14 +26,12 @@
# pragma message("GLM: GLM_GTX_euler_angles extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace euler_angles ///< GLM_GTX_euler_angles extension: Build matrices from Euler angles.
{
namespace gtx{
//! 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.
@ -131,9 +129,9 @@ namespace glm
template <typename T>
detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
///@}
}//namespace euler_angles
}//namespace gtx
/// @}
}//namespace euler_angles
}//namespace gtx
}//namespace glm
#include "euler_angles.inl"

17
glm/gtx/extend.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_extend extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace extend ///< GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
{
namespace gtx{
//! 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.
@ -37,10 +35,9 @@ namespace glm
genType const & Source,
typename genType::value_type const Length);
///@}
}//namespace extend
}//namespace gtx
/// @}
}//namespace extend
}//namespace gtx
}//namespace glm
#include "extend.inl"

15
glm/gtx/extented_min_max.hpp
View File

@ -22,12 +22,10 @@
# pragma message("GLM: GLM_GTX_extented_min_max extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace extented_min_max ///< GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
{
namespace gtx{
//! GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
namespace extented_min_max
{
/// \addtogroup gtx_extented_min_max
///@{
@ -165,10 +163,9 @@ namespace glm
C<T> const & z,
C<T> const & w);
///@}
}//namespace extented_min_max
}//namespace gtx
/// @}
}//namespace extented_min_max
}//namespace gtx
}//namespace glm
#include "extented_min_max.inl"

17
glm/gtx/fast_exponential.hpp
View File

@ -22,15 +22,13 @@
# pragma message("GLM: GLM_GTX_fast_exponential extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace fast_exponential ///< GLM_GTX_fast_exponential extension: Fast but less accurate implementations of exponential based functions.
{
namespace gtx{
//! GLM_GTX_fast_exponential extension: Fast but less accurate implementations of exponential based functions.
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.
@ -71,10 +69,9 @@ namespace glm
template <typename T>
T fastLn(const T& x);
///@}
}//namespace fast_exponential
}//namespace gtx
/// @}
}//namespace fast_exponential
}//namespace gtx
}//namespace glm
#include "fast_exponential.inl"

19
glm/gtx/fast_square_root.hpp
View File

@ -24,14 +24,12 @@
# pragma message("GLM: GLM_GTX_fast_square_root extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace fast_square_root ///< GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
{
namespace gtx{
//! 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.
@ -58,11 +56,10 @@ namespace glm
template <typename genType>
genType fastNormalize(genType const & x);
///@}
}//namespace fast_square_root
}// namespace gtx
}//namespace glm
/// @}
}// namespace fast_square_root
}// namespace gtx
}// namespace glm
#include "fast_square_root.inl"

17
glm/gtx/fast_trigonometry.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_fast_trigonometry extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace fast_trigonometry ///< GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
{
namespace gtx{
//! 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.
@ -71,10 +69,9 @@ namespace glm
template <typename T>
T fastAtan(const T& angle);
///@}
}//namespace fast_trigonometry
}//namespace gtx
/// @}
}//namespace fast_trigonometry
}//namespace gtx
}//namespace glm
#include "fast_trigonometry.inl"

18
glm/gtx/gradient_paint.hpp
View File

@ -21,14 +21,15 @@
# pragma message("GLM: GLM_GTX_gradient_paint extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace gradient_paint ///< GLM_GTX_gradient_paint extension: Compute a radient gradient according section OpenVG 1.1 specifications, 9.3.2 Radial Gradients
{
namespace gtx{
//! GLM_GTX_gradient_paint extension: Compute a radient gradient according section OpenVG 1.1 specifications, 9.3.2 Radial Gradients
namespace gradient_paint
{
using namespace gtx::optimum_pow;
/// \addtogroup gtx_gradient_paint
/// @{
template <typename valType>
valType radialGradient(
glm::detail::tvec2<valType> const & Center,
@ -42,9 +43,10 @@ namespace glm
glm::detail::tvec2<valType> const & Point1,
glm::detail::tvec2<valType> const & Position);
}//namespace gradient_paint
}//namespace gtx
}//namespace glm
/// @}
}// namespace gradient_paint
}// namespace gtx
}// namespace glm
#include "gradient_paint.inl"

19
glm/gtx/handed_coordinate_space.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_handed_coordinate_space extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace handed_coordinate_space ///< GLM_GTX_handed_coordinate_space extension: To know if a set of three basis vectors defines a right or left-handed coordinate system.
{
namespace gtx{
//! 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.
@ -45,11 +43,10 @@ namespace glm
detail::tvec3<T> const & binormal,
detail::tvec3<T> const & normal);
///@}
}//namespace handed_coordinate_space
}//namespace gtx
}//namespace glm
/// @}
}// namespace handed_coordinate_space
}// namespace gtx
}// namespace glm
#include "handed_coordinate_space.inl"

19
glm/gtx/inertia.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_inertia extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace inertia ///< GLM_GTX_inertia extension: Create inertia matrices
{
namespace gtx{
//! GLM_GTX_inertia extension: Create inertia matrices
namespace inertia
{
/// \addtogroup gtx_inertia
///@{
/// @{
//! Build an inertia matrix for a box.
//! From GLM_GTX_inertia extension.
@ -85,11 +83,10 @@ namespace glm
const T Mass,
const T Radius);
///@}
}//namespace inertia
}//namespace gtx
}//namespace glm
/// @}
}// namespace inertia
}// namespace gtx
}// namespace glm
#include "inertia.inl"

12
glm/gtx/int_10_10_10_2.hpp
View File

@ -21,12 +21,10 @@
# pragma message("GLM: GLM_GTX_int_10_10_10_2 extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace int_10_10_10_2 ///< GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
{
namespace gtx{
//! GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
namespace int_10_10_10_2
{
using namespace gtx::raw_data;
/// \addtogroup gtx_int_10_10_10_2
@ -38,8 +36,8 @@ namespace glm
///@}
}//namespace integer
}//namespace gtx
}//namespace integer
}//namespace gtx
}//namespace glm
#include "int_10_10_10_2.inl"

17
glm/gtx/integer.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_integer extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace integer ///< GLM_GTX_integer extension: Add support for integer for core functions
{
namespace gtx{
//! 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.
@ -46,10 +44,9 @@ namespace glm
template <typename genType>
genType factorial(genType const & x);
///@}
}//namespace integer
}//namespace gtx
/// @}
}//namespace integer
}//namespace gtx
}//namespace glm
#include "integer.inl"

15
glm/gtx/intersect.hpp
View File

@ -22,14 +22,12 @@
# pragma message("GLM: GLM_GTX_closest_point extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace intersect ///< GLM_GTX_intersect extension: Add intersection functions
{
namespace gtx{
//! 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.
@ -63,9 +61,8 @@ namespace glm
genType const & center, typename genType::value_type radius,
genType & position, genType & normal);
///@}
}//namespace intersect
/// @}
}//namespace intersect
}//namespace gtx
}//namespace glm

16
glm/gtx/log_base.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_log_base extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace log_base ///< GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
{
namespace gtx{
//! 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.
@ -36,10 +34,10 @@ namespace glm
genType const & x,
genType const & base);
///@}
/// @}
}//namespace extend
}//namespace gtx
}//namespace extend
}//namespace gtx
}//namespace glm
#include "log_base.inl"

17
glm/gtx/matrix_cross_product.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_matrix_cross_product extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace matrix_cross_product ///< GLM_GTX_matrix_cross_product: Build cross product matrices
{
namespace gtx{
//! 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.
@ -41,10 +39,9 @@ namespace glm
detail::tmat4x4<T> matrixCross4(
detail::tvec3<T> const & x);
///@}
}//namespace matrix_cross_product
}//namespace gtx
/// @}
}//namespace matrix_cross_product
}//namespace gtx
}//namespace glm
#include "matrix_cross_product.inl"

17
glm/gtx/matrix_interpolation.hpp
View File

@ -23,14 +23,12 @@
# pragma message("GLM: GLM_GTX_matrix_interpolation extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace matrix_interpolation ///< GLM_GTX_matrix_interpolation extension: Add transformation matrices
{
namespace gtx{
//! GLM_GTX_matrix_interpolation extension: Add transformation matrices
namespace matrix_interpolation
{
/// \addtogroup gtx_matrix_interpolation
///@{
/// @{
//! Get the axis and angle of the rotation from a matrix.
//! From GLM_GTX_matrix_interpolation extension.
@ -56,10 +54,9 @@ namespace glm
detail::tmat4x4<T> const & m2,
T const delta);
///@}
}//namespace matrix_interpolation
}//namespace gtx
/// @}
}//namespace matrix_interpolation
}//namespace gtx
}//namespace glm
#include "matrix_interpolation.inl"

17
glm/gtx/matrix_major_storage.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_matrix_major_storage extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace matrix_major_storage ///< GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
{
namespace gtx{
//! 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.
@ -113,10 +111,9 @@ namespace glm
detail::tmat4x4<T> colMajor4(
const detail::tmat4x4<T>& m);
///@}
}//namespace matrix_major_storage
}//namespace gtx
/// @}
}//namespace matrix_major_storage
}//namespace gtx
}//namespace glm
#include "matrix_major_storage.inl"

17
glm/gtx/matrix_operation.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_matrix_operation extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace matrix_operation ///< GLM_GTX_matrix_operation: Build diagonal matrices
{
namespace gtx{
//! GLM_GTX_matrix_operation: Build diagonal matrices
namespace matrix_operation
{
/// \addtogroup gtx_matrix_operation
///@{
/// @{
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
@ -83,10 +81,9 @@ namespace glm
detail::tmat4x4<valType> diagonal4x4(
detail::tvec4<valType> const & v);
///@}
}//namespace matrix_operation
}//namespace gtx
/// @}
}//namespace matrix_operation
}//namespace gtx
}//namespace glm
#include "matrix_operation.inl"

16
glm/gtx/matrix_query.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_matrix_query extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace matrix_query ///< GLM_GTX_matrix_query: Query to evaluate matrix properties
{
namespace gtx{
//! 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.
@ -85,9 +83,9 @@ 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 matrix_query
}//namespace gtx
}//namespace glm
#include "matrix_query.inl"

18
glm/gtx/mixed_product.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_mixed_product extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace mixed_product ///< GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
{
namespace gtx{
//! 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>
@ -36,10 +34,10 @@ namespace glm
detail::tvec3<valType> const & v2,
detail::tvec3<valType> const & v3);
///@}
}//namespace mixed_product
}//namespace gtx
}//namespace glm
/// @}
}// namespace mixed_product
}// namespace gtx
}// namespace glm
#include "mixed_product.inl"

17
glm/gtx/multiple.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_multiple extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace multiple ///< GLM_GTX_multiple: Find the closest number of a number multiple of other number.
{
namespace gtx{
//! 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.
@ -43,10 +41,9 @@ namespace glm
genType const & Source,
genType const & Multiple);
///@}
}//namespace multiple
}//namespace gtx
/// @}
}//namespace multiple
}//namespace gtx
}//namespace glm
#include "multiple.inl"

17
glm/gtx/noise.hpp
View File

@ -25,14 +25,12 @@
# pragma message("GLM: GLM_GTX_noise extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace noise ///< GLM_GTX_noise extension: Comparison functions for a user defined epsilon values.
{
namespace gtx{
//! GLM_GTX_noise extension: Comparison functions for a user defined epsilon values.
namespace noise
{
/// \addtogroup gtx_noise
///@{
/// @{
//! Classic perlin noise.
//! From GLM_GTX_noise extension.
@ -53,10 +51,9 @@ namespace glm
T simplex(
vecType<T> const & p);
///@}
}//namespace noise
}//namespace gtx
/// @}
}//namespace noise
}//namespace gtx
}//namespace glm
#include "noise.inl"

17
glm/gtx/norm.hpp
View File

@ -25,14 +25,12 @@
# pragma message("GLM: GLM_GTX_norm extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace norm ///< GLM_GTX_norm extension: Various way to compute vector norms.
{
namespace gtx{
//! 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.
@ -133,10 +131,9 @@ namespace glm
const detail::tvec3<T>& x,
unsigned int Depth);
///@}
}//namespace norm
}//namespace gtx
/// @}
}//namespace norm
}//namespace gtx
}//namespace glm
#include "norm.inl"

17
glm/gtx/normal.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_normal extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace normal ///< GLM_GTX_normal extension: Compute the normal of a triangle.
{
namespace gtx{
//! 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.
@ -37,10 +35,9 @@ namespace glm
detail::tvec3<T> const & p2,
detail::tvec3<T> const & p3);
///@}
}//namespace normal
}//namespace gtx
/// @}
}//namespace normal
}//namespace gtx
}//namespace glm
#include "normal.inl"

17
glm/gtx/normalize_dot.hpp
View File

@ -22,16 +22,14 @@
# pragma message("GLM: GLM_GTX_normalize_dot extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace normalize_dot ///< GLM_GTX_normalize_dot extension: Dot product of vectors that need to be normalize with a single square root.
{
namespace gtx{
//! GLM_GTX_normalize_dot extension: Dot product of vectors that need to be normalize with a single square root.
namespace normalize_dot
{
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)).
@ -49,10 +47,9 @@ namespace glm
genType const & x,
genType const & y);
///@}
}//namespace normalize_dot
}//namespace gtx
/// @}
}//namespace normalize_dot
}//namespace gtx
}//namespace glm
#include "normalize_dot.inl"

7
glm/gtx/number_precision.hpp
View File

@ -25,8 +25,7 @@
namespace glm{
namespace gtx{
//! GLM_GTX_number_precision extension: Defined size types.
namespace number_precision
namespace number_precision ///< GLM_GTX_number_precision extension: Defined size types.
{
using namespace gtc::type_precision;
@ -34,7 +33,7 @@ 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)
@ -58,7 +57,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

8
glm/gtx/ocl_type.hpp
View File

@ -22,14 +22,13 @@
namespace glm{
namespace gtx{
//! GLM_GTX_ocl_type extension: OpenCL types.
namespace ocl_type
namespace ocl_type ///< GLM_GTX_ocl_type extension: OpenCL types.
{
///////////////////////////
// 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)
@ -99,8 +98,7 @@ 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

17
glm/gtx/optimum_pow.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_optimum_pow extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace optimum_pow ///< GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
{
namespace gtx{
//! 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.
@ -60,10 +58,9 @@ namespace glm
//! From GLM_GTX_optimum_pow extension.
detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
///@}
}//namespace optimum_pow
}//namespace gtx
/// @}
}//namespace optimum_pow
}//namespace gtx
}//namespace glm
#include "optimum_pow.inl"

17
glm/gtx/orthonormalize.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_orthonormalize extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace orthonormalize ///< GLM_GTX_orthonormalize extension: Orthonormalize matrices.
{
namespace gtx{
//! GLM_GTX_orthonormalize extension: Orthonormalize matrices.
namespace orthonormalize
{
/// \addtogroup gtx_orthonormalize
///@{
/// @{
//! Returns the orthonormalized matrix of m.
//! From GLM_GTX_orthonormalize extension.
@ -42,10 +40,9 @@ namespace glm
const detail::tvec3<T>& x,
const detail::tvec3<T>& y);
///@}
}//namespace orthonormalize
}//namespace gtx
/// @}
}//namespace orthonormalize
}//namespace gtx
}//namespace glm
#include "orthonormalize.inl"

18
glm/gtx/perpendicular.hpp
View File

@ -22,14 +22,12 @@
# pragma message("GLM: GLM_GTX_perpendicular extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace perpendicular ///< GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
{
namespace gtx{
//! 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.
@ -52,11 +50,9 @@ namespace glm
detail::tvec4<T> const & x,
detail::tvec4<T> const & Normal);
///@}
}//namespace perpendicular
}//namespace gtx
/// @}
}//namespace perpendicular
}//namespace gtx
}//namespace glm
#include "perpendicular.inl"

17
glm/gtx/polar_coordinates.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_polar_coordinates extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace polar_coordinates ///< GLM_GTX_polar_coordinates extension: Conversion from Euclidean space to polar space and revert.
{
namespace gtx{
//! 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.
@ -39,10 +37,9 @@ namespace glm
template <typename T>
detail::tvec3<T> euclidean(const detail::tvec3<T>& polar);
///@}
}//namespace polar_coordinates
}//namespace gtx
/// @}
}//namespace polar_coordinates
}//namespace gtx
}//namespace glm
#include "polar_coordinates.inl"

17
glm/gtx/projection.hpp
View File

@ -20,14 +20,12 @@
# pragma message("GLM: GLM_GTX_projection extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace projection ///< GLM_GTX_projection extension: Projection of a vector to other one
{
namespace gtx{
//! 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.
@ -50,10 +48,9 @@ namespace glm
detail::tvec4<T> const & x,
detail::tvec4<T> const & Normal);
///@}
}//namespace projection
}//namespace gtx
/// @}
}//namespace projection
}//namespace gtx
}//namespace glm
#include "projection.inl"

15
glm/gtx/quaternion.hpp
View File

@ -25,12 +25,10 @@
# pragma message("GLM: GLM_GTX_quaternion extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace quaternion ///< GLM_GTX_quaternion extension: Quaternion types and functions
{
namespace gtx{
//! GLM_GTX_quaternion extension: Quaternion types and functions
namespace quaternion
{
using namespace gtc::quaternion;
/// \addtogroup gtx_quaternion
@ -207,10 +205,9 @@ namespace glm
detail::tquat<T> const & y,
T const & a);
///@}
}//namespace quaternion
}//namespace gtx
/// @}
}//namespace quaternion
}//namespace gtx
} //namespace glm
#include "quaternion.inl"

5
glm/gtx/random.hpp
View File

@ -25,11 +25,10 @@
namespace glm{
namespace gtx{
//! GLM_GTX_random extension: Generate random number from various distribution methods
namespace random
namespace random ///< GLM_GTX_random extension: Generate random number from various distribution methods
{
/// \addtogroup gtx_random
///@{
/// @{
//! Generate a random number in the interval [-1, 1], according a linear distribution.
//! From GLM_GTX_random extension.

12
glm/gtx/raw_data.hpp
View File

@ -22,11 +22,9 @@
#endif
namespace glm{
namespace gtx
namespace gtx{
namespace raw_data ///< GLM_GTX_raw_data extension: Projection of a vector to other one
{
//! GLM_GTX_raw_data extension: Projection of a vector to other one
namespace raw_data
{
using namespace gtc::type_precision;
/// \addtogroup gtx_raw_data
@ -49,9 +47,9 @@ namespace gtx
typedef uint64 qword;
///@}
}
}//namespace gtx
}//namespace glm
}// namespace raw_data
}// namespace gtx
}// namespace glm
#include "raw_data.inl"

17
glm/gtx/reciprocal.hpp
View File

@ -17,14 +17,12 @@
# pragma message("GLM: GLM_GTX_reciprocal extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace reciprocal ///< GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
{
namespace gtx{
//! GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
namespace reciprocal
{
/// \addtogroup gtx_reciprocal
///@{
/// @{
//! Secant function.
//! hypotenuse / adjacent or 1 / cos(x)
@ -89,10 +87,9 @@ namespace glm
template <typename genType>
genType acoth(genType const & x);
///@}
}//namespace reciprocal
}//namespace gtx
/// @}
}//namespace reciprocal
}//namespace gtx
}//namespace glm
#include "reciprocal.inl"

8
glm/gtx/rotate_vector.hpp
View File

@ -23,13 +23,12 @@
namespace glm{
namespace gtx{
//! GLM_GTX_rotate_vector extension: Function to directly rotate a vector
namespace rotate_vector
namespace rotate_vector ///< GLM_GTX_rotate_vector extension: Function to directly rotate a vector
{
using namespace transform;
/// \addtogroup gtx_rotate_vector
///@{
/// @{
//! Rotate a two dimensional vector.
//! From GLM_GTX_rotate_vector extension.
@ -103,8 +102,7 @@ namespace rotate_vector
detail::tvec3<T> const & Normal,
detail::tvec3<T> const & Up);
///@}
/// @}
}//namespace rotate_vector
}//namespace gtx
}//namespace glm

24
glm/gtx/simd_mat4.hpp
View File

@ -28,10 +28,9 @@
# pragma message("GLM: GLM_GTX_simd_mat4 extension included")
#endif
namespace glm
namespace glm{
namespace detail
{
namespace detail
{
/// 4x4 Matrix implemented using SIMD SEE intrinsics.
/// \ingroup gtx_simd_mat4
GLM_ALIGNED_STRUCT(16) fmat4x4SIMD
@ -127,13 +126,11 @@ namespace glm
fmat4x4SIMD const operator- (fmat4x4SIMD const & m);
fmat4x4SIMD const operator-- (fmat4x4SIMD const & m, int);
fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
}//namespace detail
}//namespace detail
namespace gtx{
//! GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
namespace simd_mat4
{
namespace gtx{
namespace simd_mat4 ///< GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
{
typedef detail::fmat4x4SIMD simdMat4;
/// \addtogroup gtx_simd_mat4
@ -174,11 +171,10 @@ namespace glm
detail::fmat4x4SIMD inverse(
detail::fmat4x4SIMD const & m);
///@}
}//namespace simd_mat4
}//namespace gtx
}//namespace glm
/// @}
}// namespace simd_mat4
}// namespace gtx
}// namespace glm
#include "simd_mat4.inl"

21
glm/gtx/simd_vec4.hpp
View File

@ -28,10 +28,9 @@
# pragma message("GLM: GLM_GTX_simd_vec4 extension included")
#endif
namespace glm
namespace glm{
namespace detail
{
namespace detail
{
/// 4-dimensional vector implemented using SIMD SEE intrinsics.
/// \ingroup gtx_simd_vec4
GLM_ALIGNED_STRUCT(4) fvec4SIMD
@ -110,13 +109,11 @@ namespace glm
template <comp X>
fvec4SIMD swizzle() const;
};
}//namespace detail
}//namespace detail
namespace gtx{
//! GLM_GTX_simd_vec4 extension: SIMD implementation of vec4 type.
namespace simd_vec4
{
namespace gtx{
namespace simd_vec4 ///< GLM_GTX_simd_vec4 extension: SIMD implementation of vec4 type.
{
typedef detail::fvec4SIMD simdVec4;
/// \addtogroup gtx_simd_vec4
@ -465,9 +462,9 @@ namespace glm
detail::fvec4SIMD fastInversesqrt(
detail::fvec4SIMD const & x);
///@}
}//namespace simd_vec4
}//namespace gtx
/// @}
}//namespace simd_vec4
}//namespace gtx
}//namespace glm
#include "simd_vec4.inl"

12
glm/gtx/simplex.hpp
View File

@ -22,8 +22,7 @@
namespace glm{
namespace gtx{
//! GLM_GTX_simplex extension: Spline functions
namespace spline
namespace spline ///< GLM_GTX_simplex extension: Spline functions
{
/// \addtogroup gtx_spline
///@{
@ -58,11 +57,10 @@ namespace spline
genType const & v4,
typename genType::value_type const & s);
///@}
}//namespace simplex
}//namespace gtx
}//namespace glm
/// @}
}// namespace simplex
}// namespace gtx
}// namespace glm
#include "simplex.inl"

8
glm/gtx/spline.hpp
View File

@ -23,13 +23,12 @@
namespace glm{
namespace gtx{
//! GLM_GTX_spline extension: Spline functions
namespace spline
namespace spline ///< GLM_GTX_spline extension: Spline functions
{
using namespace gtx::optimum_pow;
/// \addtogroup gtx_spline
///@{
/// @{
//! Return a point from a catmull rom curve.
//! From GLM_GTX_spline extension.
@ -61,8 +60,7 @@ namespace spline
genType const & v4,
typename genType::value_type const & s);
///@}
/// @}
}//namespace spline
}//namespace gtx
}//namespace glm

12
glm/gtx/std_based_type.hpp
View File

@ -21,12 +21,10 @@
# pragma message("GLM: GLM_GTX_std_based_type extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace std_based_type ///< GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
{
namespace gtx{
//! GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
namespace std_based_type
{
typedef detail::tvec2<std::size_t> size2;
typedef detail::tvec3<std::size_t> size3;
typedef detail::tvec4<std::size_t> size4;
@ -63,8 +61,8 @@ namespace glm
typedef detail::tvec3<unsigned long> ulvec3;
typedef detail::tvec4<unsigned long> ulvec4;
}//namespace std_based_type
}//namespace gtx
}//namespace std_based_type
}//namespace gtx
}//namespace glm
#include "std_based_type.inl"

17
glm/gtx/string_cast.hpp
View File

@ -28,29 +28,26 @@
# pragma message("GLM: GLM_GTX_string_cast extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace string_cast ///< GLM_GTX_string_cast extension: Setup strings for GLM type values
{
namespace gtx{
//! GLM_GTX_string_cast extension: Setup strings for GLM type values
namespace string_cast
{
using namespace gtc::half_float;
using namespace gtx::integer;
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 string_cast
}//namespace gtx
}//namespace glm
#include "string_cast.inl"

17
glm/gtx/transform.hpp
View File

@ -22,16 +22,14 @@
# pragma message("GLM: GLM_GTX_transform extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace transform ///< GLM_GTX_transform extension: Add transformation matrices
{
namespace gtx{
//! GLM_GTX_transform extension: Add transformation matrices
namespace transform
{
using namespace gtc::matrix_transform;
/// \addtogroup gtx_transform
///@{
/// @{
//! Builds a translation 4 * 4 matrix created from 3 scalars.
//! From GLM_GTX_transform extension.
@ -93,10 +91,9 @@ namespace glm
detail::tmat4x4<T> scale(
detail::tvec3<T> const & v);
///@}
}//namespace transform
}//namespace gtx
/// @}
}//namespace transform
}//namespace gtx
}//namespace glm
#include "transform.inl"

19
glm/gtx/transform2.hpp
View File

@ -22,16 +22,14 @@
# pragma message("GLM: GLM_GTX_transform2 extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace transform2 ///< GLM_GTX_transform2 extension: Add extra transformation matrices
{
namespace gtx{
//! GLM_GTX_transform2 extension: Add extra transformation matrices
namespace transform2
{
using namespace gtx::transform;
/// \addtogroup gtx_transform2
///@{
/// @{
//! Transforms a matrix with a shearing on X axis.
//! From GLM_GTX_transform2 extension.
@ -108,11 +106,10 @@ namespace glm
valType scale,
valType bias);
///@}
}//namespace transform2
}//namespace gtx
}//namespace glm
/// @}
}// namespace transform2
}// namespace gtx
}// namespace glm
#include "transform2.inl"

9
glm/gtx/ulp.hpp
View File

@ -25,7 +25,7 @@ namespace gtx{
namespace ulp ///< GLM_GTX_ulp extension: Precision calculation functions
{
/// \addtogroup gtx_ulp
///@{
/// @{
//! Return the next ULP value(s) after the input value(s).
//! From GLM_GTX_ulp extension.
@ -58,10 +58,9 @@ namespace ulp ///< GLM_GTX_ulp extension: Precision calculation functions
vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
///@}
}//namespace ulp
}//namespace gtx
}//namespace glm
}// namespace ulp
}// namespace gtx
}// namespace glm
#include "ulp.inl"

5
glm/gtx/unsigned_int.hpp
View File

@ -29,7 +29,7 @@ namespace unsigned_int ///< GLM_GTX_unsigned_int extension: Add support for unsi
using namespace gtx::integer;
/// \addtogroup gtx_unsigned_int
///@{
/// @{
//! 32bit signed integer.
//! From GLM_GTX_unsigned_int extension.
@ -47,8 +47,7 @@ namespace unsigned_int ///< GLM_GTX_unsigned_int extension: Add support for unsi
//! From GLM_GTX_unsigned_int extension.
uint mod(uint x, uint y);
///@}
/// @}
}//namespace unsigned_int
}//namespace gtx
}//namespace glm

6
glm/gtx/vec1.hpp
View File

@ -109,9 +109,9 @@ namespace precision
typedef precision::mediump_uvec1 uvec1;
#endif//GLM_PRECISION
}//namespace vec1
}//namespace gtx
}//namespace glm
}// namespace vec1
}// namespace gtx
}// namespace glm
#include "vec1.inl"

5
glm/gtx/vector_access.hpp
View File

@ -25,7 +25,7 @@ namespace gtx{
namespace vector_access ///< GLM_GTX_vector_access extension: Function to set values to vectors
{
/// \addtogroup gtx_vector_access
///@{
/// @{
//! Set values to a 2 components vector.
//! From GLM_GTX_vector_access extension.
@ -54,8 +54,7 @@ namespace vector_access ///< GLM_GTX_vector_access extension: Function to set va
valType const & z,
valType const & w);
///@}
/// @}
}//namespace vector_access
}//namespace gtx
}//namespace glm

8
glm/gtx/vector_angle.hpp
View File

@ -60,10 +60,10 @@ namespace vector_angle ///< GLM_GTX_vector_angle extension: Compute angle betwee
detail::tvec3<T> const & y,
detail::tvec3<T> const & ref);
///@}
}//namespace vector_angle
}//namespace gtx
}//namespace glm
/// @}
}// namespace vector_angle
}// namespace gtx
}// namespace glm
#include "vector_angle.inl"

11
glm/gtx/vector_query.hpp
View File

@ -27,7 +27,7 @@ namespace gtx{
namespace vector_query ///< GLM_GTX_vector_query extension: Query informations of vector types
{
/// \addtogroup gtx_vector_query
///@{
/// @{
//! Check if two vectors are collinears.
//! From GLM_GTX_vector_query extensions.
@ -83,11 +83,10 @@ namespace vector_query ///< GLM_GTX_vector_query extension: Query informations o
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
///@}
}//namespace vector_query
}//namespace gtx
}//namespace glm
/// @}
}// namespace vector_query
}// namespace gtx
}// namespace glm
#include "vector_query.inl"

10
glm/gtx/verbose_operator.hpp
View File

@ -25,7 +25,7 @@ namespace gtx{
namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to replace operators
{
/// \addtogroup gtx_verbose_operator
///@{
/// @{
//! Addition of two values
//! From GLM_GTX_verbose_operator extension.
@ -52,10 +52,10 @@ namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to
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
/// @}
}// namespace verbose_operator
}// namespace gtx
}// namespace glm
#include "verbose_operator.inl"

11
glm/gtx/wrap.hpp
View File

@ -25,7 +25,7 @@ namespace gtx{
namespace wrap ///< GLM_GTX_wrap: Wrapping mode using my texture samping.
{
/// \addtogroup gtx_wrap
///@{
/// @{
//! Simulate GL_CLAMP OpenGL wrap mode
//! From GLM_GTX_wrap extension.
@ -42,11 +42,10 @@ namespace wrap ///< GLM_GTX_wrap: Wrapping mode using my texture samping.
template <typename genType>
genType mirrorRepeat(genType const & Texcoord);
///@}
}//namespace wrap
}//namespace gtx
}//namespace glm
/// @}
}// namespace wrap
}// namespace gtx
}// namespace glm
#include "wrap.inl"