anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Fixed more typos

Browse Source
master
Christophe Riccio ago%!(EXTRA string=14 years)
parent f8473154eb
commit f73b0c5b80
17 changed files with 481 additions and 514 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 16
      glm/core/func_common.hpp
  2. 18
      glm/core/func_exponential.hpp
  3. 21
      glm/core/func_geometric.hpp
  4. 272
      glm/core/func_integer.hpp
  5. 22
      glm/core/func_matrix.hpp
  6. 22
      glm/core/func_noise.hpp
  7. 220
      glm/core/func_packing.hpp
  8. 27
      glm/core/func_trigonometric.hpp
  9. 383
      glm/core/func_vector_relational.hpp
  10. 2
      glm/gtc/half_float.hpp
  11. 2
      glm/gtc/matrix_integer.hpp
  12. 1
      glm/gtc/quaternion.hpp
  13. 1
      glm/gtc/type_ptr.hpp
  14. 4
      glm/gtx/associated_min_max.hpp
  15. 2
      glm/gtx/bit.hpp
  16. 4
      glm/gtx/color_cast.hpp
  17. 2
      glm/gtx/color_space_YCoCg.hpp

16
glm/core/func_common.hpp
Unescape View File

@ -12,12 +12,11 @@
#include "_fixes.hpp" #include "_fixes.hpp"
namespace glm namespace glm{
namespace core{
namespace function{
namespace common //!< Define common functions from Section 8.3 of GLSL 1.30.8 specification. Included in glm namespace.
{ {
namespace core{
namespace function{
namespace common{ //!< Define common functions from Section 8.3 of GLSL 1.30.8 specification. Included in glm namespace.
/// \addtogroup core_funcs /// \addtogroup core_funcs
///@{ ///@{
@ -325,10 +324,9 @@ namespace glm
genType ldexp(genType const & x, genIType const & exp); genType ldexp(genType const & x, genIType const & exp);
///@} ///@}
}//namespace common }//namespace common
}//namespace function }//namespace function
}//namespace core }//namespace core
using namespace core::function::common; using namespace core::function::common;
}//namespace glm }//namespace glm

18
glm/core/func_exponential.hpp
Unescape View File

@ -10,13 +10,11 @@
#ifndef glm_core_func_exponential #ifndef glm_core_func_exponential
#define glm_core_func_exponential #define glm_core_func_exponential
namespace glm namespace glm{
namespace core{
namespace function{
namespace exponential //!< Define all exponential functions from Section 8.2 of GLSL 1.30.8 specification. Included in glm namespace.
{ {
namespace core{
namespace function{
//! Define all exponential functions from Section 8.2 of GLSL 1.30.8 specification. Included in glm namespace.
namespace exponential{
/// \addtogroup core_funcs /// \addtogroup core_funcs
///@{ ///@{
@ -73,11 +71,9 @@ namespace glm
genType inversesqrt(genType const & x); genType inversesqrt(genType const & x);
///@} ///@}
}//namespace exponential
}//namespace exponential }//namespace function
}//namespace function }//namespace core
}//namespace core
using namespace core::function::exponential; using namespace core::function::exponential;
}//namespace glm }//namespace glm

21
glm/core/func_geometric.hpp
Unescape View File

@ -10,14 +10,13 @@
#ifndef glm_core_func_geometric #ifndef glm_core_func_geometric
#define glm_core_func_geometric #define glm_core_func_geometric
namespace glm namespace glm{
namespace core{
namespace function{
namespace geometric //!< Define all geometric functions from Section 8.4 of GLSL 1.30.8 specification. Included in glm namespace.
{ {
namespace core{
namespace function{
namespace geometric{ //!< Define all geometric functions from Section 8.4 of GLSL 1.30.8 specification. Included in glm namespace.
/// \addtogroup core_funcs /// \addtogroup core_funcs
///@{ /// @{
//! Returns the length of x, i.e., sqrt(x * x). //! Returns the length of x, i.e., sqrt(x * x).
//! //!
@ -94,12 +93,10 @@ namespace glm
genType const & N, genType const & N,
typename genType::value_type const & eta); typename genType::value_type const & eta);
///@} /// @}
}//namespace geometric
}//namespace geometric }//namespace function
}//namespace function }//namespace core
}//namespace core
using namespace core::function::geometric; using namespace core::function::geometric;
}//namespace glm }//namespace glm

272
glm/core/func_integer.hpp
Unescape View File

@ -10,145 +10,141 @@
#ifndef glm_core_func_integer #ifndef glm_core_func_integer
#define glm_core_func_integer #define glm_core_func_integer
namespace glm namespace glm{
namespace core{
namespace function{
namespace integer //!< Define integer functions from Section 8.8 of GLSL 4.00.8 specification.
{ {
namespace core{ /// \addtogroup core_funcs
namespace function{ /// @{
//! Define integer functions from Section 8.8 of GLSL 4.00.8 specification.
namespace integer{ //! 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
/// \addtogroup core_funcs //! less than pow(2, 32), or to 1 otherwise.
///@{ //!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a>
//! Adds 32-bit unsigned integer x and y, returning the sum //! \li GLSL 4.00.08 specification, section 8.8
//! modulo pow(2, 32). The value carry is set to 0 if the sum was template <typename genUType>
//! less than pow(2, 32), or to 1 otherwise. genUType uaddCarry(
//! genUType const & x,
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/uaddCarry.xml">GLSL uaddCarry man page</a> genUType const & y,
//! \li GLSL 4.00.08 specification, section 8.8 genUType & carry);
template <typename genUType>
genUType uaddCarry( //! Subtracts the 32-bit unsigned integer y from x, returning
genUType const & x, //! the difference if non-negative, or pow(2, 32) plus the difference
genUType const & y, //! otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise.
genUType & carry); //!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a>
//! Subtracts the 32-bit unsigned integer y from x, returning //! \li GLSL 4.00.08 specification, section 8.8
//! the difference if non-negative, or pow(2, 32) plus the difference template <typename genUType>
//! otherwise. The value borrow is set to 0 if x >= y, or to 1 otherwise. genUType usubBorrow(
//! genUType const & x,
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/usubBorrow.xml">GLSL usubBorrow man page</a> genUType const & y,
//! \li GLSL 4.00.08 specification, section 8.8 genUType & borrow);
template <typename genUType>
genUType usubBorrow( //! Multiplies 32-bit integers x and y, producing a 64-bit
genUType const & x, //! result. The 32 least-significant bits are returned in lsb.
genUType const & y, //! The 32 most-significant bits are returned in msb.
genUType & borrow); //!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a>
//! Multiplies 32-bit integers x and y, producing a 64-bit //! \li GLSL 4.00.08 specification, section 8.8
//! result. The 32 least-significant bits are returned in lsb. template <typename genUType>
//! The 32 most-significant bits are returned in msb. void umulExtended(
//! genUType const & x,
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/umulExtended.xml">GLSL umulExtended man page</a> genUType const & y,
//! \li GLSL 4.00.08 specification, section 8.8 genUType & msb,
template <typename genUType> genUType & lsb);
void umulExtended(
genUType const & x, //! Multiplies 32-bit integers x and y, producing a 64-bit
genUType const & y, //! result. The 32 least-significant bits are returned in lsb.
genUType & msb, //! The 32 most-significant bits are returned in msb.
genUType & lsb); //!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a>
//! Multiplies 32-bit integers x and y, producing a 64-bit //! \li GLSL 4.00.08 specification, section 8.8
//! result. The 32 least-significant bits are returned in lsb. template <typename genIType>
//! The 32 most-significant bits are returned in msb. void imulExtended(
//! genIType const & x,
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/imulExtended.xml">GLSL imulExtended man page</a> genIType const & y,
//! \li GLSL 4.00.08 specification, section 8.8 genIType & msb,
template <typename genIType> genIType & lsb);
void imulExtended(
genIType const & x, //! Extracts bits [offset, offset + bits - 1] from value,
genIType const & y, //! returning them in the least significant bits of the result.
genIType & msb, //! For unsigned data types, the most significant bits of the
genIType & lsb); //! result will be set to zero. For signed data types, the
//! most significant bits will be set to the value of bit offset + base – 1.
//! Extracts bits [offset, offset + bits - 1] from value, //!
//! returning them in the least significant bits of the result. //! If bits is zero, the result will be zero. The result will be
//! For unsigned data types, the most significant bits of the //! undefined if offset or bits is negative, or if the sum of
//! result will be set to zero. For signed data types, the //! offset and bits is greater than the number of bits used
//! most significant bits will be set to the value of bit offset + base – 1. //! to store the operand.
//! //!
//! If bits is zero, the result will be zero. The result will be //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a>
//! undefined if offset or bits is negative, or if the sum of //! \li GLSL 4.00.08 specification, section 8.8
//! offset and bits is greater than the number of bits used template <typename genIUType>
//! to store the operand. genIUType bitfieldExtract(
//! genIUType const & Value,
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldExtract.xml">GLSL bitfieldExtract man page</a> int const & Offset,
//! \li GLSL 4.00.08 specification, section 8.8 int const & Bits);
template <typename genIUType>
genIUType bitfieldExtract( //! Returns the insertion the bits least-significant bits of insert into base.
genIUType const & Value, //!
int const & Offset, //! The result will have bits [offset, offset + bits - 1] taken
int const & Bits); //! from bits [0, bits – 1] of insert, and all other bits taken
//! directly from the corresponding bits of base. If bits is
//! Returns the insertion the bits least-significant bits of insert into base. //! zero, the result will simply be base. The result will be
//! //! undefined if offset or bits is negative, or if the sum of
//! The result will have bits [offset, offset + bits - 1] taken //! offset and bits is greater than the number of bits used to
//! from bits [0, bits – 1] of insert, and all other bits taken //! store the operand.
//! directly from the corresponding bits of base. If bits is //!
//! zero, the result will simply be base. The result will be //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a>
//! undefined if offset or bits is negative, or if the sum of //! \li GLSL 4.00.08 specification, section 8.8
//! offset and bits is greater than the number of bits used to template <typename genIUType>
//! store the operand. genIUType bitfieldInsert(
//! genIUType const & Base,
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldInsert.xml">GLSL bitfieldInsert man page</a> genIUType const & Insert,
//! \li GLSL 4.00.08 specification, section 8.8 int const & Offset,
template <typename genIUType> int const & Bits);
genIUType bitfieldInsert(
genIUType const & Base, //! Returns the reversal of the bits of value.
genIUType const & Insert, //! The bit numbered n of the result will be taken from bit (bits - 1) - n of value,
int const & Offset, //! where bits is the total number of bits used to represent value.
int const & Bits); //!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a>
//! Returns the reversal of the bits of value. //! \li GLSL 4.00.08 specification, section 8.8
//! The bit numbered n of the result will be taken from bit (bits - 1) - n of value, template <typename genIUType>
//! where bits is the total number of bits used to represent value. genIUType bitfieldReverse(genIUType const & value);
//!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitfieldReverse.xml">GLSL bitfieldReverse man page</a> //! Returns the number of bits set to 1 in the binary representation of value.
//! \li GLSL 4.00.08 specification, section 8.8 //!
template <typename genIUType> //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a>
genIUType bitfieldReverse(genIUType const & value); //! \li GLSL 4.00.08 specification, section 8.8
template <typename T, template <typename> class C>
//! Returns the number of bits set to 1 in the binary representation of value. typename C<T>::signed_type bitCount(C<T> const & Value);
//!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/bitCount.xml">GLSL bitCount man page</a> //! Returns the bit number of the least significant bit set to
//! \li GLSL 4.00.08 specification, section 8.8 //! 1 in the binary representation of value.
template <typename T, template <typename> class C> //! If value is zero, -1 will be returned.
typename C<T>::signed_type bitCount(C<T> const & Value); //!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a>
//! Returns the bit number of the least significant bit set to //! \li GLSL 4.00.08 specification, section 8.8
//! 1 in the binary representation of value. template <typename T, template <typename> class C>
//! If value is zero, -1 will be returned. typename C<T>::signed_type findLSB(C<T> const & Value);
//!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findLSB.xml">GLSL findLSB man page</a> //! Returns the bit number of the most significant bit in the binary representation of value.
//! \li GLSL 4.00.08 specification, section 8.8 //! For positive integers, the result will be the bit number of the most significant bit set to 1.
template <typename T, template <typename> class C> //! For negative integers, the result will be the bit number of the most significant
typename C<T>::signed_type findLSB(C<T> const & Value); //! bit set to 0. For a value of zero or negative one, -1 will be returned.
//!
//! Returns the bit number of the most significant bit in the binary representation of value. //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a>
//! For positive integers, the result will be the bit number of the most significant bit set to 1. //! \li GLSL 4.00.08 specification, section 8.8
//! For negative integers, the result will be the bit number of the most significant template <typename T, template <typename> class C>
//! bit set to 0. For a value of zero or negative one, -1 will be returned. typename C<T>::signed_type findMSB(C<T> const & Value);
//!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/findMSB.xml">GLSL findMSB man page</a> /// @}
//! \li GLSL 4.00.08 specification, section 8.8 }//namespace integer
template <typename T, template <typename> class C> }//namespace function
typename C<T>::signed_type findMSB(C<T> const & Value); }//namespace core
///@}
}//namespace integer
}//namespace function
}//namespace core
using namespace core::function::integer; using namespace core::function::integer;
}//namespace glm }//namespace glm

22
glm/core/func_matrix.hpp
Unescape View File

@ -10,15 +10,13 @@
#ifndef glm_core_func_matrix #ifndef glm_core_func_matrix
#define glm_core_func_matrix #define glm_core_func_matrix
namespace glm namespace glm{
namespace core{
namespace function{
namespace matrix //!< Define all matrix functions from Section 8.5 of GLSL 1.30.8 specification. Included in glm namespace.
{ {
namespace core{
namespace function{
//! Define all matrix functions from Section 8.5 of GLSL 1.30.8 specification. Included in glm namespace.
namespace matrix{
/// \addtogroup core_funcs /// \addtogroup core_funcs
///@{ /// @{
//! Multiply matrix x by matrix y component-wise, i.e., //! 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]. //! result[i][j] is the scalar product of x[i][j] and y[i][j].
@ -97,12 +95,10 @@ namespace glm
detail::tmat4x4<T> inverse( detail::tmat4x4<T> inverse(
detail::tmat4x4<T> const & m); detail::tmat4x4<T> const & m);
///@} /// @}
}//namespace matrix
}//namespace matrix }//namespace function
}//namespace function }//namespace core
}//namespace core
using namespace core::function::matrix; using namespace core::function::matrix;
}//namespace glm }//namespace glm

22
glm/core/func_noise.hpp
Unescape View File

@ -10,15 +10,13 @@
#ifndef glm_core_func_noise #ifndef glm_core_func_noise
#define glm_core_func_noise #define glm_core_func_noise
namespace glm namespace glm{
namespace core{
namespace function{
namespace noise //< Define all noise functions from Section 8.9 of GLSL 1.30.8 specification. Included in glm namespace.
{ {
namespace core{
namespace function{
// Define all noise functions from Section 8.9 of GLSL 1.30.8 specification. Included in glm namespace.
namespace noise{
/// \addtogroup core_funcs /// \addtogroup core_funcs
///@{ /// @{
//! Returns a 1D noise value based on the input value x. //! Returns a 1D noise value based on the input value x.
//! //!
@ -48,12 +46,10 @@ namespace glm
template <typename genType> template <typename genType>
detail::tvec4<typename genType::value_type> noise4(genType const & x); detail::tvec4<typename genType::value_type> noise4(genType const & x);
///@} /// @}
}//namespace noise
}//namespace noise }//namespace function
}//namespace function }//namespace core
}//namespace core
using namespace core::function::noise; using namespace core::function::noise;
}//namespace glm }//namespace glm

220
glm/core/func_packing.hpp
Unescape View File

@ -10,119 +10,115 @@
#ifndef glm_core_func_packing #ifndef glm_core_func_packing
#define glm_core_func_packing #define glm_core_func_packing
namespace glm namespace glm{
namespace core{
namespace function{
namespace packing //!< Define packing functions from section 8.4 floating-point pack and unpack functions of GLSL 4.00.8 specification
{ {
namespace core{ /// \addtogroup core_funcs
namespace function{ ///@{
//! Define packing functions from section 8.4 floating-point pack and unpack functions of GLSL 4.00.8 specification
namespace packing //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
{ //! Then, the results are packed into the returned 32-bit unsigned integer.
/// \addtogroup core_funcs //!
///@{ //! The conversion for component c of v to fixed point is done as follows:
//! packUnorm2x16: round(clamp(c, 0, +1) * 65535.0)
//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. //!
//! Then, the results are packed into the returned 32-bit unsigned integer. //! The first component of the vector will be written to the least significant bits of the output;
//! //! the last component will be written to the most significant bits.
//! The conversion for component c of v to fixed point is done as follows: //!
//! packUnorm2x16: round(clamp(c, 0, +1) * 65535.0) //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm2x16.xml">GLSL packUnorm2x16 man page</a>
//! //! \li GLSL 4.00.08 specification, section 8.4
//! The first component of the vector will be written to the least significant bits of the output; detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v);
//! the last component will be written to the most significant bits.
//! //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm2x16.xml">GLSL packUnorm2x16 man page</a> //! Then, the results are packed into the returned 32-bit unsigned integer.
//! \li GLSL 4.00.08 specification, section 8.4 //!
detail::uint32 packUnorm2x16(detail::tvec2<detail::float32> const & v); //! The conversion for component c of v to fixed point is done as follows:
//! packUnorm4x8: round(clamp(c, 0, +1) * 255.0)
//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. //!
//! Then, the results are packed into the returned 32-bit unsigned integer. //! The first component of the vector will be written to the least significant bits of the output;
//! //! the last component will be written to the most significant bits.
//! The conversion for component c of v to fixed point is done as follows: //!
//! packUnorm4x8: round(clamp(c, 0, +1) * 255.0) //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a>
//! //! \li GLSL 4.00.08 specification, section 8.4
//! The first component of the vector will be written to the least significant bits of the output; detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v);
//! the last component will be written to the most significant bits.
//! //! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values.
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packUnorm4x8.xml">GLSL packUnorm4x8 man page</a> //! Then, the results are packed into the returned 32-bit unsigned integer.
//! \li GLSL 4.00.08 specification, section 8.4 //!
detail::uint32 packUnorm4x8(detail::tvec4<detail::float32> const & v); //! The conversion for component c of v to fixed point is done as follows:
//! packSnorm4x8: round(clamp(c, -1, +1) * 127.0)
//! First, converts each component of the normalized floating-point value v into 8- or 16-bit integer values. //!
//! Then, the results are packed into the returned 32-bit unsigned integer. //! The first component of the vector will be written to the least significant bits of the output;
//! //! the last component will be written to the most significant bits.
//! The conversion for component c of v to fixed point is done as follows: //!
//! packSnorm4x8: round(clamp(c, -1, +1) * 127.0) //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a>
//! //! \li GLSL 4.00.08 specification, section 8.4
//! The first component of the vector will be written to the least significant bits of the output; detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v);
//! the last component will be written to the most significant bits.
//! //! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packSnorm4x8.xml">GLSL packSnorm4x8 man page</a> //! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
//! \li GLSL 4.00.08 specification, section 8.4 //!
detail::uint32 packSnorm4x8(detail::tvec4<detail::float32> const & v); //! The conversion for unpacked fixed-point value f to floating point is done as follows:
//! unpackUnorm2x16: f / 65535.0
//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. //!
//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. //! The first component of the returned vector will be extracted from the least significant bits of the input;
//! //! the last component will be extracted from the most significant bits.
//! The conversion for unpacked fixed-point value f to floating point is done as follows: //!
//! unpackUnorm2x16: f / 65535.0 //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a>
//! //! \li GLSL 4.00.08 specification, section 8.4
//! The first component of the returned vector will be extracted from the least significant bits of the input; detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p);
//! the last component will be extracted from the most significant bits.
//! //! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm2x16.xml">GLSL unpackUnorm2x16 man page</a> //! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
//! \li GLSL 4.00.08 specification, section 8.4 //!
detail::tvec2<detail::float32> unpackUnorm2x16(detail::uint32 const & p); //! The conversion for unpacked fixed-point value f to floating point is done as follows:
//! unpackUnorm4x8: f / 255.0
//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. //!
//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. //! The first component of the returned vector will be extracted from the least significant bits of the input;
//! //! the last component will be extracted from the most significant bits.
//! The conversion for unpacked fixed-point value f to floating point is done as follows: //!
//! unpackUnorm4x8: f / 255.0 //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a>
//! //! \li GLSL 4.00.08 specification, section 8.4
//! The first component of the returned vector will be extracted from the least significant bits of the input; detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p);
//! the last component will be extracted from the most significant bits.
//! //! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers.
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackUnorm4x8.xml">GLSL unpackUnorm4x8 man page</a> //! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector.
//! \li GLSL 4.00.08 specification, section 8.4 //!
detail::tvec4<detail::float32> unpackUnorm4x8(detail::uint32 const & p); //! The conversion for unpacked fixed-point value f to floating point is done as follows:
//! unpackSnorm4x8: clamp(f / 127.0, -1, +1)
//! First, unpacks a single 32-bit unsigned integer p into a pair of 16-bit unsigned integers, four 8-bit unsigned integers, or four 8-bit signed integers. //!
//! Then, each component is converted to a normalized floating-point value to generate the returned two- or four-component vector. //! The first component of the returned vector will be extracted from the least significant bits of the input;
//! //! the last component will be extracted from the most significant bits.
//! The conversion for unpacked fixed-point value f to floating point is done as follows: //!
//! unpackSnorm4x8: clamp(f / 127.0, -1, +1) //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a>
//! //! \li GLSL 4.00.08 specification, section 8.4
//! The first component of the returned vector will be extracted from the least significant bits of the input; detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p);
//! the last component will be extracted from the most significant bits.
//! //! Returns a double-precision value obtained by packing the components of v into a 64-bit value.
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackSnorm4x8.xml">GLSL unpackSnorm4x8 man page</a> //! If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified.
//! \li GLSL 4.00.08 specification, section 8.4 //! Otherwise, the bit- level representation of v is preserved.
detail::tvec4<detail::float32> unpackSnorm4x8(detail::uint32 const & p); //! The first vector component specifies the 32 least significant bits;
//! the second component specifies the 32 most significant bits.
//! Returns a double-precision value obtained by packing the components of v into a 64-bit value. //!
//! If an IEEE 754 Inf or NaN is created, it will not signal, and the resulting floating point value is unspecified. //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packDouble2x32.xml">GLSL packDouble2x32 man page</a>
//! Otherwise, the bit- level representation of v is preserved. //! \li GLSL 4.00.08 specification, section 8.4
//! The first vector component specifies the 32 least significant bits; double packDouble2x32(detail::tvec2<detail::uint32> const & v);
//! the second component specifies the 32 most significant bits.
//! //! Returns a two-component unsigned integer vector representation of v.
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/packDouble2x32.xml">GLSL packDouble2x32 man page</a> //! The bit-level representation of v is preserved.
//! \li GLSL 4.00.08 specification, section 8.4 //! The first component of the vector contains the 32 least significant bits of the double;
double packDouble2x32(detail::tvec2<detail::uint32> const & v); //! the second component consists the 32 most significant bits.
//!
//! Returns a two-component unsigned integer vector representation of v. //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackDouble2x32.xml">GLSL unpackDouble2x32 man page</a>
//! The bit-level representation of v is preserved. //! \li GLSL 4.00.08 specification, section 8.4
//! The first component of the vector contains the 32 least significant bits of the double; detail::tvec2<detail::uint32> unpackDouble2x32(double const & v);
//! the second component consists the 32 most significant bits.
//! ///@}
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/unpackDouble2x32.xml">GLSL unpackDouble2x32 man page</a> }//namespace packing
//! \li GLSL 4.00.08 specification, section 8.4 }//namespace function
detail::tvec2<detail::uint32> unpackDouble2x32(double const & v); }//namespace core
///@}
}//namespace packing
}//namespace function
}//namespace core
using namespace core::function::packing; using namespace core::function::packing;
}//namespace glm }//namespace glm

27
glm/core/func_trigonometric.hpp
Unescape View File

@ -10,17 +10,16 @@
#ifndef glm_core_func_trigonometric #ifndef glm_core_func_trigonometric
#define glm_core_func_trigonometric #define glm_core_func_trigonometric
namespace glm namespace glm{
namespace core{
namespace function{
//! Define Angle and trigonometry functions
//! from Section 8.1 of GLSL 1.30.8 specification.
//! Included in glm namespace.
namespace trigonometric
{ {
namespace core{
namespace function{
//! Define Angle and trigonometry functions
//! from Section 8.1 of GLSL 1.30.8 specification.
//! Included in glm namespace.
namespace trigonometric{
/// \addtogroup core_funcs /// \addtogroup core_funcs
///@{ /// @{
//! Converts degrees to radians and returns the result. //! Converts degrees to radians and returns the result.
//! //!
@ -140,12 +139,10 @@ namespace glm
template <typename genType> template <typename genType>
genType atanh(genType const & x); genType atanh(genType const & x);
///@} /// @}
}//namespace trigonometric
}//namespace trigonometric }//namespace function
}//namespace function }//namespace core
}//namespace core
using namespace core::function::trigonometric; using namespace core::function::trigonometric;
}//namespace glm }//namespace glm

383
glm/core/func_vector_relational.hpp
Unescape View File

@ -12,201 +12,198 @@
#include "_detail.hpp" #include "_detail.hpp"
namespace glm namespace glm{
namespace core{
namespace function{
//! Define vector relational functions from Section 8.6 of GLSL 1.30.8 specification.
//! Included in glm namespace.
namespace vector_relational
{ {
namespace core{ /// \addtogroup core_funcs
namespace function{ /// @{
//! Define vector relational functions from Section 8.6 of GLSL 1.30.8 specification.
//! Included in glm namespace. //! Returns the component-wise comparison result of x < y.
namespace vector_relational //!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a>
//! \li GLSL 1.30.08 specification, section 8.6
template <typename T, template <typename> class vecType>
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type lessThan
(
vecType<T> const & x,
vecType<T> const & y
)
{ {
/// \addtogroup core_funcs GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES,
///@{ "Invalid template instantiation of 'lessThan', GLM vector types required");
GLM_STATIC_ASSERT(detail::is_bool<T>::_NO,
//! Returns the component-wise comparison result of x < y. "Invalid template instantiation of 'lessThan', GLM vector types required floating-point or integer value types vectors");
//!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThan.xml">GLSL lessThan man page</a> typename vecType<bool>::bool_type Result(vecType<bool>::null);
//! \li GLSL 1.30.08 specification, section 8.6 for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
template <typename T, template <typename> class vecType> Result[i] = x[i] < y[i];
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type lessThan
( return Result;
vecType<T> const & x, }
vecType<T> const & y
) //! Returns the component-wise comparison of result x <= y.
{ //!
GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a>
"Invalid template instantiation of 'lessThan', GLM vector types required"); //! \li GLSL 1.30.08 specification, section 8.6
GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, template <typename T, template <typename> class vecType>
"Invalid template instantiation of 'lessThan', GLM vector types required floating-point or integer value types vectors"); GLM_FUNC_QUALIFIER typename vecType<T>::bool_type lessThanEqual
(
typename vecType<bool>::bool_type Result(vecType<bool>::null); vecType<T> const & x,
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i) vecType<T> const & y
Result[i] = x[i] < y[i]; )
{
return Result; GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES,
} "Invalid template instantiation of 'lessThanEqual', GLM vector types required");
GLM_STATIC_ASSERT(detail::is_bool<T>::_NO,
//! Returns the component-wise comparison of result x <= y. "Invalid template instantiation of 'lessThanEqual', GLM vector types required floating-point or integer value types vectors");
//!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/lessThanEqual.xml">GLSL lessThanEqual man page</a> typename vecType<bool>::bool_type Result(vecType<bool>::null);
//! \li GLSL 1.30.08 specification, section 8.6 for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
template <typename T, template <typename> class vecType> Result[i] = x[i] <= y[i];
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type lessThanEqual return Result;
( }
vecType<T> const & x,
vecType<T> const & y //! Returns the component-wise comparison of result x > y.
) //!
{ //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a>
GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, //! \li GLSL 1.30.08 specification, section 8.6
"Invalid template instantiation of 'lessThanEqual', GLM vector types required"); template <typename T, template <typename> class vecType>
GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, GLM_FUNC_QUALIFIER typename vecType<T>::bool_type greaterThan
"Invalid template instantiation of 'lessThanEqual', GLM vector types required floating-point or integer value types vectors"); (
vecType<T> const & x,
typename vecType<bool>::bool_type Result(vecType<bool>::null); vecType<T> const & y
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i) )
Result[i] = x[i] <= y[i]; {
return Result; GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES,
} "Invalid template instantiation of 'greaterThan', GLM vector types required");
GLM_STATIC_ASSERT(detail::is_bool<T>::_NO,
//! Returns the component-wise comparison of result x > y. "Invalid template instantiation of 'greaterThan', GLM vector types required floating-point or integer value types vectors");
//!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThan.xml">GLSL greaterThan man page</a> typename vecType<bool>::bool_type Result(vecType<bool>::null);
//! \li GLSL 1.30.08 specification, section 8.6 for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
template <typename T, template <typename> class vecType> Result[i] = x[i] > y[i];
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type greaterThan return Result;
( }
vecType<T> const & x,
vecType<T> const & y //! Returns the component-wise comparison of result x >= y.
) //!
{ //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a>
GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, //! \li GLSL 1.30.08 specification, section 8.6
"Invalid template instantiation of 'greaterThan', GLM vector types required"); template <typename T, template <typename> class vecType>
GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, GLM_FUNC_QUALIFIER typename vecType<T>::bool_type greaterThanEqual
"Invalid template instantiation of 'greaterThan', GLM vector types required floating-point or integer value types vectors"); (
vecType<T> const & x,
typename vecType<bool>::bool_type Result(vecType<bool>::null); vecType<T> const & y
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i) )
Result[i] = x[i] > y[i]; {
return Result; GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES,
} "Invalid template instantiation of 'greaterThanEqual', GLM vector types required");
GLM_STATIC_ASSERT(detail::is_bool<T>::_NO,
//! Returns the component-wise comparison of result x >= y. "Invalid template instantiation of 'greaterThanEqual', GLM vector types required floating-point or integer value types vectors");
//!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/greaterThanEqual.xml">GLSL greaterThanEqual man page</a> typename vecType<bool>::bool_type Result(vecType<bool>::null);
//! \li GLSL 1.30.08 specification, section 8.6 for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
template <typename T, template <typename> class vecType> Result[i] = x[i] >= y[i];
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type greaterThanEqual return Result;
( }
vecType<T> const & x,
vecType<T> const & y //! Returns the component-wise comparison of result x == y.
) //!
{ //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a>
GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, //! \li GLSL 1.30.08 specification, section 8.6
"Invalid template instantiation of 'greaterThanEqual', GLM vector types required"); template <typename T, template <typename> class vecType>
GLM_STATIC_ASSERT(detail::is_bool<T>::_NO, GLM_FUNC_QUALIFIER typename vecType<T>::bool_type equal
"Invalid template instantiation of 'greaterThanEqual', GLM vector types required floating-point or integer value types vectors"); (
vecType<T> const & x,
typename vecType<bool>::bool_type Result(vecType<bool>::null); vecType<T> const & y
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i) )
Result[i] = x[i] >= y[i]; {
return Result; GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES,
} "Invalid template instantiation of 'equal', GLM vector types required");
//! Returns the component-wise comparison of result x == y. typename vecType<bool>::bool_type Result(vecType<bool>::null);
//! for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/equal.xml">GLSL equal man page</a> Result[i] = x[i] == y[i];
//! \li GLSL 1.30.08 specification, section 8.6 return Result;
template <typename T, template <typename> class vecType> }
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type equal
( //! Returns the component-wise comparison of result x != y.
vecType<T> const & x, //!
vecType<T> const & y //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a>
) //! \li GLSL 1.30.08 specification, section 8.6
{ template <typename T, template <typename> class vecType>
GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, GLM_FUNC_QUALIFIER typename vecType<T>::bool_type notEqual
"Invalid template instantiation of 'equal', GLM vector types required"); (
vecType<T> const & x,
typename vecType<bool>::bool_type Result(vecType<bool>::null); vecType<T> const & y
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i) )
Result[i] = x[i] == y[i]; {
return Result; GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES,
} "Invalid template instantiation of 'notEqual', GLM vector types required");
//! Returns the component-wise comparison of result x != y. typename vecType<bool>::bool_type Result(vecType<bool>::null);
//! for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/notEqual.xml">GLSL notEqual man page</a> Result[i] = x[i] != y[i];
//! \li GLSL 1.30.08 specification, section 8.6 return Result;
template <typename T, template <typename> class vecType> }
GLM_FUNC_QUALIFIER typename vecType<T>::bool_type notEqual
( //! Returns true if any component of x is true.
vecType<T> const & x, //!
vecType<T> const & y //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/any.xml">GLSL any man page</a>
) //! \li GLSL 1.30.08 specification, section 8.6
{ template <template <typename> class vecType>
GLM_STATIC_ASSERT(detail::is_vector<vecType<T> >::_YES, GLM_FUNC_QUALIFIER bool any(vecType<bool> const & v)
"Invalid template instantiation of 'notEqual', GLM vector types required"); {
GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES,
typename vecType<bool>::bool_type Result(vecType<bool>::null); "Invalid template instantiation of 'any', GLM boolean vector types required");
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
Result[i] = x[i] != y[i]; bool Result = false;
return Result; for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
} Result = Result || v[i];
return Result;
//! Returns true if any component of x is true. }
//!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/any.xml">GLSL any man page</a> //! Returns true if all components of x are true.
//! \li GLSL 1.30.08 specification, section 8.6 //!
template <template <typename> class vecType> //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/all.xml">GLSL all man page</a>
GLM_FUNC_QUALIFIER bool any(vecType<bool> const & v) //! \li GLSL 1.30.08 specification, section 8.6
{ template <template <typename> class vecType>
GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES, GLM_FUNC_QUALIFIER bool all(vecType<bool> const & v)
"Invalid template instantiation of 'any', GLM boolean vector types required"); {
GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES,
bool Result = false; "Invalid template instantiation of 'all', GLM boolean vector types required");
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
Result = Result || v[i]; bool Result = true;
return Result; for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
} Result = Result && v[i];
return Result;
//! Returns true if all components of x are true. }
//!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/all.xml">GLSL all man page</a> //! Returns the component-wise logical complement of x.
//! \li GLSL 1.30.08 specification, section 8.6 //! /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead.
template <template <typename> class vecType> //!
GLM_FUNC_QUALIFIER bool all(vecType<bool> const & v) //! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/not.xml">GLSL not man page</a>
{ //! \li GLSL 1.30.08 specification, section 8.6
GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES, template <template <typename> class vecType>
"Invalid template instantiation of 'all', GLM boolean vector types required"); GLM_FUNC_QUALIFIER vecType<bool> not_(vecType<bool> const & v)
{
bool Result = true; GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES,
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i) "Invalid template instantiation of 'not_', GLM vector types required");
Result = Result && v[i];
return Result; typename vecType<bool>::bool_type Result(vecType<bool>::null);
} for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
Result[i] = !v[i];
//! Returns the component-wise logical complement of x. return Result;
//! /!\ Because of language incompatibilities between C++ and GLSL, GLM defines the function not but not_ instead. }
//!
//! \li <a href="http://www.opengl.org/sdk/docs/manglsl/xhtml/not.xml">GLSL not man page</a> /// @}
//! \li GLSL 1.30.08 specification, section 8.6 }//namespace vector_relational
template <template <typename> class vecType> }//namespace function
GLM_FUNC_QUALIFIER vecType<bool> not_(vecType<bool> const & v) }//namespace core
{
GLM_STATIC_ASSERT(detail::is_vector<vecType<bool> >::_YES,
"Invalid template instantiation of 'not_', GLM vector types required");
typename vecType<bool>::bool_type Result(vecType<bool>::null);
for(typename vecType<bool>::size_type i = 0; i < vecType<bool>::value_size(); ++i)
Result[i] = !v[i];
return Result;
}
///@}
}//namespace vector_relational
}//namespace function
}//namespace core
using namespace core::function::vector_relational; using namespace core::function::vector_relational;
}//namespace glm }//namespace glm

2
glm/gtc/half_float.hpp
Unescape View File

@ -325,7 +325,7 @@ namespace gtc{
namespace half_float ///< GLM_GTC_half_float extension: Add support for half precision floating-point types namespace half_float ///< GLM_GTC_half_float extension: Add support for half precision floating-point types
{ {
/// \addtogroup gtc_half_float /// \addtogroup gtc_half_float
///@{ /// @{
/// Type for half-precision floating-point numbers. /// Type for half-precision floating-point numbers.
/// From GLM_GTC_half_float extension. /// From GLM_GTC_half_float extension.

2
glm/gtc/matrix_integer.hpp
Unescape View File

@ -25,7 +25,7 @@ namespace gtc{
namespace matrix_integer ///< GLM_GTC_matrix_integer extension: Add integer matrices namespace matrix_integer ///< GLM_GTC_matrix_integer extension: Add integer matrices
{ {
/// \addtogroup gtc_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::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::tmat3x3<highp_int> highp_imat3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)

1
glm/gtc/quaternion.hpp
Unescape View File

@ -35,7 +35,6 @@ namespace detail
template <typename T> template <typename T>
struct tquat// : public genType<T, tquat> struct tquat// : public genType<T, tquat>
{ {
enum ctor{null}; enum ctor{null};
typedef T value_type; typedef T value_type;

1
glm/gtc/type_ptr.hpp
Unescape View File

@ -25,7 +25,6 @@ namespace glm{
namespace gtc{ namespace gtc{
namespace type_ptr ///< GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address. namespace type_ptr ///< GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
{ {
/// \addtogroup gtc_type_ptr /// \addtogroup gtc_type_ptr
///@{ ///@{

4
glm/gtx/associated_min_max.hpp
Unescape View File

@ -26,7 +26,7 @@ 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 associated_min_max ///< GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
{ {
/// \addtogroup gtx_associated_min_max /// \addtogroup gtx_associated_min_max
///@{ /// @{
//! \brief Min comparison between 2 variables //! \brief Min comparison between 2 variables
template<typename genTypeT, typename genTypeU> template<typename genTypeT, typename genTypeU>
@ -70,7 +70,7 @@ namespace associated_min_max ///< GLM_GTX_associated_min_max extension: Min and
const genTypeT& z, const genTypeU& c, const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d); const genTypeT& w, const genTypeU& d);
///@} /// @}
} //namespace associated_min_max } //namespace associated_min_max
} //namespace gtx } //namespace gtx
} //namespace glm } //namespace glm

2
glm/gtx/bit.hpp
Unescape View File

@ -29,7 +29,7 @@ namespace bit ///< GLM_GTX_bit extension: Allow to perform bit operations on int
using namespace gtc::half_float; using namespace gtc::half_float;
/// \addtogroup gtx_bit /// \addtogroup gtx_bit
///@{ /// @{
//! Build a mask of 'count' bits //! Build a mask of 'count' bits
//! From GLM_GTX_bit extension. //! From GLM_GTX_bit extension.

4
glm/gtx/color_cast.hpp
Unescape View File

@ -29,7 +29,7 @@ namespace color_cast ///< GLM_GTX_color_cast extension: Conversion between two c
using namespace gtx::number_precision; using namespace gtx::number_precision;
/// \addtogroup gtx_color_cast /// \addtogroup gtx_color_cast
///@{ /// @{
//! Conversion of a floating value into a 8bit unsigned int value. //! Conversion of a floating value into a 8bit unsigned int value.
//! From GLM_GTX_color_cast extension. //! From GLM_GTX_color_cast extension.
@ -95,7 +95,7 @@ namespace color_cast ///< GLM_GTX_color_cast extension: Conversion between two c
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_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) 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 color_space
}//namespace gtx }//namespace gtx
}//namespace glm }//namespace glm

2
glm/gtx/color_space_YCoCg.hpp
Unescape View File

@ -25,7 +25,7 @@ namespace gtx{
namespace color_space_YCoCg ///< GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations namespace color_space_YCoCg ///< GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
{ {
/// \addtogroup gtx_color_space_YCoCg /// \addtogroup gtx_color_space_YCoCg
///@{ /// @{
//! Convert a color from RGB color space to YCoCg color space. //! Convert a color from RGB color space to YCoCg color space.
//! From GLM_GTX_color_space_YCoCg extension. //! From GLM_GTX_color_space_YCoCg extension.

Write Preview
Loading…
Cancel
Save