organicmaps/glm
13
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2025-04-10 07:18:54 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions

Apply 'basic grouping patch' Ticket #36

Browse source
This commit is contained in:
Christophe Riccio 2011-02-05 00:49:50 +00:00
parent d92ffaa9ef
commit 2cf02a836c
90 changed files with 570 additions and 128 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
doc/doxyfile
View file

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

5
glm/core/func_common.hpp
View file

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

5
glm/core/func_exponential.hpp
View file

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

5
glm/core/func_geometric.hpp
View file

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

5
glm/core/func_integer.hpp
View file

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

5
glm/core/func_matrix.hpp
View file

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

5
glm/core/func_noise.hpp
View file

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

5
glm/core/func_packing.hpp
View file

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

5
glm/core/func_trigonometric.hpp
View file

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

5
glm/core/func_vector_relational.hpp
View file

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

39
glm/core/type.hpp
View file

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

9
glm/core/type_float.hpp
View file

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

2
glm/core/type_half.hpp
View file

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

19
glm/core/type_int.hpp
View file

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

12
glm/core/type_mat2x2.hpp
View file

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

12
glm/core/type_mat2x3.hpp
View file

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

9
glm/core/type_mat2x4.hpp
View file

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

9
glm/core/type_mat3x2.hpp
View file

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

12
glm/core/type_mat3x3.hpp
View file

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

9
glm/core/type_mat3x4.hpp
View file

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

12
glm/core/type_mat4x2.hpp
View file

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

12
glm/core/type_mat4x3.hpp
View file

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

12
glm/core/type_mat4x4.hpp
View file

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

29
glm/core/type_vec2.hpp
View file

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

29
glm/core/type_vec3.hpp
View file

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

29
glm/core/type_vec4.hpp
View file

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

20
glm/glm.hpp
View file

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

5
glm/gtc/half_float.hpp
View file

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

5
glm/gtc/matrix_access.hpp
View file

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

5
glm/gtc/matrix_integer.hpp
View file

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

5
glm/gtc/matrix_inverse.hpp
View file

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

4
glm/gtc/matrix_transform.hpp
View file

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

6
glm/gtc/quaternion.hpp
View file

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

5
glm/gtc/type_precision.hpp
View file

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

5
glm/gtc/type_ptr.hpp
View file

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

4
glm/gtx/associated_min_max.hpp
View file

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

3
glm/gtx/bit.hpp
View file

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

4
glm/gtx/closest_point.hpp
View file

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

5
glm/gtx/color_cast.hpp
View file

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

5
glm/gtx/color_space.hpp
View file

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

4
glm/gtx/color_space_YCoCg.hpp
View file

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

5
glm/gtx/compatibility.hpp
View file

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

5
glm/gtx/component_wise.hpp
View file

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

7
glm/gtx/epsilon.hpp
View file

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

7
glm/gtx/euler_angles.hpp
View file

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

5
glm/gtx/extend.hpp
View file

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

5
glm/gtx/extented_min_max.hpp
View file

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

4
glm/gtx/fast_exponential.hpp
View file

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

5
glm/gtx/fast_square_root.hpp
View file

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

5
glm/gtx/fast_trigonometry.hpp
View file

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

7
glm/gtx/handed_coordinate_space.hpp
View file

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

5
glm/gtx/inertia.hpp
View file

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

5
glm/gtx/int_10_10_10_2.hpp
View file

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

5
glm/gtx/integer.hpp
View file

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

7
glm/gtx/intersect.hpp
View file

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

5
glm/gtx/log_base.hpp
View file

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

5
glm/gtx/matrix_cross_product.hpp
View file

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

7
glm/gtx/matrix_major_storage.hpp
View file

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

7
glm/gtx/matrix_operation.hpp
View file

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

6
glm/gtx/matrix_query.hpp
View file

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

5
glm/gtx/mixed_product.hpp
View file

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

5
glm/gtx/multiple.hpp
View file

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

7
glm/gtx/norm.hpp
View file

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

5
glm/gtx/normal.hpp
View file

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

5
glm/gtx/normalize_dot.hpp
View file

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

4
glm/gtx/number_precision.hpp
View file

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

5
glm/gtx/ocl_type.hpp
View file

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

7
glm/gtx/optimum_pow.hpp
View file

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

7
glm/gtx/orthonormalize.hpp
View file

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

8
glm/gtx/perpendicular.hpp
View file

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

5
glm/gtx/polar_coordinates.hpp
View file

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

5
glm/gtx/projection.hpp
View file

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

7
glm/gtx/quaternion.hpp
View file

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

6
glm/gtx/random.hpp
View file

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

5
glm/gtx/raw_data.hpp
View file

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

5
glm/gtx/reciprocal.hpp
View file

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

21
glm/gtx/rotate_vector.hpp
View file

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

9
glm/gtx/simd_mat4.hpp
View file

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

7
glm/gtx/simd_vec4.hpp
View file

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

7
glm/gtx/spline.hpp
View file

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

5
glm/gtx/string_cast.hpp
View file

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

5
glm/gtx/transform.hpp
View file

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

5
glm/gtx/transform2.hpp
View file

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

5
glm/gtx/unsigned_int.hpp
View file

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

18
glm/gtx/vec1.hpp
View file

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

5
glm/gtx/vector_access.hpp
View file

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

5
glm/gtx/vector_angle.hpp
View file

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

7
glm/gtx/vector_query.hpp
View file

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

5
glm/gtx/verbose_operator.hpp
View file

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

5
glm/gtx/wrap.hpp
View file

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