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

Updated header files formatting

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

95
glm/gtx/associated_min_max.hpp
View File

@ -21,64 +21,59 @@
# pragma message("GLM: GLM_GTX_associated_min_max extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace associated_min_max ///< GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
{
namespace gtx
{
//! GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
namespace associated_min_max
{
/// \addtogroup gtx_associated_min_max
///@{
/// \addtogroup gtx_associated_min_max
///@{
//! \brief Min comparison between 2 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b);
//! \brief Min comparison between 2 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b);
//! \brief Min comparison between 3 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c);
//! \brief Min comparison between 3 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c);
//! \brief Min comparison between 4 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d);
//! \brief Min comparison between 4 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d);
//! \brief Max comparison between 2 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b);
//! \brief Max comparison between 2 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b);
//! \brief Max comparison between 3 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c);
//! \brief Max comparison between 3 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c);
//! \brief Max comparison between 4 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d);
///@}
//! \brief Max comparison between 4 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d);
}//namespace associated_min_max
bool test();
}//namespace gtx
}//namespace glm
///@}
} //namespace associated_min_max
} //namespace gtx
} //namespace glm
#include "associated_min_max.inl"

125
glm/gtx/bit.hpp
View File

@ -22,85 +22,82 @@
# pragma message("GLM: GLM_GTX_bit extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace bit ///< GLM_GTX_bit extension: Allow to perform bit operations on integer values
{
namespace gtx{
//! GLM_GTX_bit extension: Allow to perform bit operations on integer values
namespace bit
{
using namespace gtc::half_float;
using namespace gtc::half_float;
/// \addtogroup gtx_bit
///@{
/// \addtogroup gtx_bit
///@{
//! Build a mask of 'count' bits
//! From GLM_GTX_bit extension.
template <typename genIType>
genIType mask(genIType const & count);
//! Build a mask of 'count' bits
//! From GLM_GTX_bit extension.
template <typename genIType>
genIType mask(genIType const & count);
//! Component wise extraction of bit fields.
//! genType and genIType could be a scalar or a vector.
//! From GLM_GTX_bit extension.
template <typename genIUType, typename sizeType>
genIUType extractField(
genIUType const & v,
sizeType const & first,
sizeType const & count);
//! Component wise extraction of bit fields.
//! genType and genIType could be a scalar or a vector.
//! From GLM_GTX_bit extension.
template <typename genIUType, typename sizeType>
genIUType extractField(
genIUType const & v,
sizeType const & first,
sizeType const & count);
//! Find the lowest bit set to 1 in a integer variable.
//! From GLM_GTX_bit extension.
template <typename genType>
int lowestBit(genType const & value);
//! Find the lowest bit set to 1 in a integer variable.
//! From GLM_GTX_bit extension.
template <typename genType>
int lowestBit(genType const & value);
//! Find the highest bit set to 1 in a integer variable.
//! From GLM_GTX_bit extension.
template <typename genType>
int highestBit(genType const & value);
//! Find the highest bit set to 1 in a integer variable.
//! From GLM_GTX_bit extension.
template <typename genType>
int highestBit(genType const & value);
//! Find the highest bit set to 1 in a integer variable and return its value.
//! From GLM_GTX_bit extension.
template <typename genType>
genType highestBitValue(genType const & value);
//! Find the highest bit set to 1 in a integer variable and return its value.
//! From GLM_GTX_bit extension.
template <typename genType>
genType highestBitValue(genType const & value);
//! Return true if the value is a power of two number.
//! From GLM_GTX_bit extension.
template <typename genType>
bool isPowerOfTwo(genType const & value);
//! Return true if the value is a power of two number.
//! From GLM_GTX_bit extension.
template <typename genType>
bool isPowerOfTwo(genType const & value);
//! Return the power of two number which value is just higher the input value.
//! From GLM_GTX_bit extension.
template <typename genType>
genType powerOfTwoAbove(genType const & value);
//! Return the power of two number which value is just higher the input value.
//! From GLM_GTX_bit extension.
template <typename genType>
genType powerOfTwoAbove(genType const & value);
//! Return the power of two number which value is just lower the input value.
//! From GLM_GTX_bit extension.
template <typename genType>
genType powerOfTwoBelow(genType const & value);
//! Return the power of two number which value is just lower the input value.
//! From GLM_GTX_bit extension.
template <typename genType>
genType powerOfTwoBelow(genType const & value);
//! Return the power of two number which value is the closet to the input value.
//! From GLM_GTX_bit extension.
template <typename genType>
genType powerOfTwoNearest(genType const & value);
//! Return the power of two number which value is the closet to the input value.
//! From GLM_GTX_bit extension.
template <typename genType>
genType powerOfTwoNearest(genType const & value);
//! Revert all bits of any integer based type.
//! From GLM_GTX_bit extension.
template <typename genType>
genType bitRevert(genType const & value);
//! Revert all bits of any integer based type.
//! From GLM_GTX_bit extension.
template <typename genType>
genType bitRevert(genType const & value);
//! Rotate all bits to the right.
//! From GLM_GTX_bit extension.
template <typename genType>
genType bitRotateRight(genType const & In, std::size_t Shift);
//! Rotate all bits to the right.
//! From GLM_GTX_bit extension.
template <typename genType>
genType bitRotateRight(genType const & In, std::size_t Shift);
//! Rotate all bits to the left.
//! From GLM_GTX_bit extension.
template <typename genType>
genType bitRotateLeft(genType const & In, std::size_t Shift);
//! Rotate all bits to the left.
//! From GLM_GTX_bit extension.
template <typename genType>
genType bitRotateLeft(genType const & In, std::size_t Shift);
///@}
}//namespace bit
}//namespace gtx
///@}
}//namespace bit
}//namespace gtx
}//namespace glm
#include "bit.inl"

22
glm/gtx/closest_point.hpp
View File

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

118
glm/gtx/color_cast.hpp
View File

@ -22,84 +22,82 @@
# pragma message("GLM: GLM_GTX_color_cast extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace color_cast ///< GLM_GTX_color_cast extension: Conversion between two color types
{
namespace gtx{
//! GLM_GTX_color_cast extension: Conversion between two color types
namespace color_cast
{
using namespace gtx::number_precision;
using namespace gtx::number_precision;
/// \addtogroup gtx_color_cast
///@{
/// \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);
//! 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);
//! Conversion of a floating value into a 16bit unsigned int value.
//! From GLM_GTX_color_cast extension.
template <typename valType> gtc::type_precision::uint16 u16channel_cast(valType a);
//! Conversion of a floating value into a 16bit unsigned int value.
//! From GLM_GTX_color_cast extension.
template <typename valType> gtc::type_precision::uint16 u16channel_cast(valType a);
template <typename T> gtc::type_precision::uint32 u32_rgbx_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_xrgb_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_bgrx_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_xbgr_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_rgbx_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_xrgb_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_bgrx_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_xbgr_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_rgba_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_argb_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_bgra_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_abgr_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_rgba_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_argb_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_bgra_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint32 u32_abgr_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 32bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_rgbx_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_xrgb_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_bgrx_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_xbgr_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_rgbx_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_xrgb_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_bgrx_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_xbgr_cast(const detail::tvec3<T>& c); //!< \brief Conversion of a 3 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_rgba_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_argb_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_bgra_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_abgr_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_rgba_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_argb_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_bgra_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::uint64 u64_abgr_cast(const detail::tvec4<T>& c); //!< \brief Conversion of a 4 components color into an 64bit unsigned int value. (From GLM_GTX_color_cast extension)
template <typename T> gtx::number_precision::f16vec1 f16_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
template <typename T> gtx::number_precision::f16vec1 f16_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f16vec3 f16_rgbx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f16vec3 f16_xrgb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f16vec3 f16_bgrx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f16vec3 f16_xbgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f16vec3 f16_rgbx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f16vec3 f16_xrgb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f16vec3 f16_bgrx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f16vec3 f16_xbgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f16vec4 f16_rgba_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::f16vec4 f16_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::f16vec4 f16_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::f16vec4 f16_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::f16vec4 f16_rgba_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::f16vec4 f16_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::f16vec4 f16_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::f16vec4 f16_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> gtx::number_precision::f32vec1 f32_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
template <typename T> gtx::number_precision::f32vec1 f32_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f32vec3 f32_rgbx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f32vec3 f32_xrgb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f32vec3 f32_bgrx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f32vec3 f32_xbgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f32vec3 f32_rgbx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f32vec3 f32_xrgb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f32vec3 f32_bgrx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f32vec3 f32_xbgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f32vec4 f32_rgba_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::f32vec4 f32_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::f32vec4 f32_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::f32vec4 f32_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::f32vec4 f32_rgba_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::f32vec4 f32_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::f32vec4 f32_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::f32vec4 f32_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> gtx::number_precision::f64vec1 f64_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
template <typename T> gtx::number_precision::f64vec1 f64_channel_cast(T a); //!< \brief Conversion of a u8 or u16 value to a single channel floating value. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f64vec3 f64_rgbx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f64vec3 f64_xrgb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f64vec3 f64_bgrx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f64vec3 f64_xbgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f64vec3 f64_rgbx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f64vec3 f64_xrgb_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f64vec3 f64_bgrx_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f64vec3 f64_xbgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 3 components floating color. (From GLM_GTX_color_cast extension)
template <typename T> gtc::type_precision::f64vec4 f64_rgba_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_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)
template <typename T> gtc::type_precision::f64vec4 f64_rgba_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_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 color_space
}//namespace gtx
}//namespace glm
#include "color_cast.inl"

83
glm/gtx/color_space.hpp
View File

@ -20,57 +20,54 @@
# pragma message("GLM: GLM_GTX_color_space extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace color_space ///< GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
{
namespace gtx{
//! GLM_GTX_color_space extension: Related to RGB to HSV conversions and operations
namespace color_space
{
/// \addtogroup gtx_color_space
///@{
/// \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>
detail::tvec3<valType> rgbColor(
detail::tvec3<valType> const & hsvValue);
//! Converts a color from HSV color space to its color in RGB color space.
//! From GLM_GTX_color_space extension.
template <typename valType>
detail::tvec3<valType> rgbColor(
detail::tvec3<valType> const & hsvValue);
//! Converts a color from RGB color space to its color in HSV color space.
//! From GLM_GTX_color_space extension.
template <typename valType>
detail::tvec3<valType> hsvColor(
detail::tvec3<valType> const & rgbValue);
//! Converts a color from RGB color space to its color in HSV color space.
//! From GLM_GTX_color_space extension.
template <typename valType>
detail::tvec3<valType> hsvColor(
detail::tvec3<valType> const & rgbValue);
//! Build a saturation matrix.
//! From GLM_GTX_color_space extension
template <typename valType>
detail::tmat4x4<valType> saturation(
valType const s);
//! Build a saturation matrix.
//! From GLM_GTX_color_space extension
template <typename valType>
detail::tmat4x4<valType> saturation(
valType const s);
//! Modify the saturation of a color.
//! From GLM_GTX_color_space extension.
template <typename valType>
detail::tvec3<valType> saturation(
valType const s,
detail::tvec3<valType> const & color);
//! Modify the saturation of a color.
//! From GLM_GTX_color_space extension.
template <typename valType>
detail::tvec3<valType> saturation(
valType const s,
detail::tvec3<valType> const & color);
//! Modify the saturation of a color.
//! From GLM_GTX_color_space extension.
template <typename valType>
detail::tvec4<valType> saturation(
valType const s,
detail::tvec4<valType> const & color);
//! Modify the saturation of a color.
//! From GLM_GTX_color_space extension.
template <typename valType>
detail::tvec4<valType> saturation(
valType const s,
detail::tvec4<valType> const & color);
//! Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
//! From GLM_GTX_color_space extension.
template <typename valType>
valType luminosity(
detail::tvec3<valType> const & color);
//! Compute color luminosity associating ratios (0.33, 0.59, 0.11) to RGB canals.
//! From GLM_GTX_color_space extension.
template <typename valType>
valType luminosity(
detail::tvec3<valType> const & color);
///@}
}//namespace color_space
}//namespace gtx
/// @}
}//namespace color_space
}//namespace gtx
}//namespace glm
#include "color_space.inl"

62
glm/gtx/color_space_YCoCg.hpp
View File

@ -20,44 +20,42 @@
# pragma message("GLM: GLM_GTX_color_space_YCoCg extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace color_space_YCoCg ///< GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
{
namespace gtx{
//! GLM_GTX_color_space_YCoCg extension: RGB to YCoCg conversions and operations
namespace color_space_YCoCg
{
/// \addtogroup gtx_color_space_YCoCg
///@{
/// \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>
detail::tvec3<valType> rgb2YCoCg(
detail::tvec3<valType> const & rgbColor);
//! Convert a color from RGB color space to YCoCg color space.
//! From GLM_GTX_color_space_YCoCg extension.
template <typename valType>
detail::tvec3<valType> rgb2YCoCg(
detail::tvec3<valType> const & rgbColor);
//! Convert a color from YCoCg color space to RGB color space.
//! From GLM_GTX_color_space_YCoCg extension.
template <typename valType>
detail::tvec3<valType> YCoCg2rgb(
detail::tvec3<valType> const & YCoCgColor);
//! Convert a color from YCoCg color space to RGB color space.
//! From GLM_GTX_color_space_YCoCg extension.
template <typename valType>
detail::tvec3<valType> YCoCg2rgb(
detail::tvec3<valType> const & YCoCgColor);
//! Convert a color from RGB color space to YCoCgR color space.
//! \see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
//! From GLM_GTX_color_space_YCoCg extension.
template <typename valType>
detail::tvec3<valType> rgb2YCoCgR(
detail::tvec3<valType> const & rgbColor);
//! Convert a color from RGB color space to YCoCgR color space.
//! \see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
//! From GLM_GTX_color_space_YCoCg extension.
template <typename valType>
detail::tvec3<valType> rgb2YCoCgR(
detail::tvec3<valType> const & rgbColor);
//! Convert a color from YCoCgR color space to RGB color space.
//! \see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
//! From GLM_GTX_color_space_YCoCg extension.
template <typename valType>
detail::tvec3<valType> YCoCgR2rgb(
detail::tvec3<valType> const & YCoCgColor);
//! Convert a color from YCoCgR color space to RGB color space.
//! \see "YCoCg-R: A Color Space with RGB Reversibility and Low Dynamic Range"
//! From GLM_GTX_color_space_YCoCg extension.
template <typename valType>
detail::tvec3<valType> YCoCgR2rgb(
detail::tvec3<valType> const & YCoCgColor);
///@}
}//namespace color_space_YCoCg
}//namespace gtx
/// @}
}//namespace color_space_YCoCg
}//namespace gtx
}//namespace glm
#include "color_space_YCoCg.inl"

213
glm/gtx/compatibility.hpp
View File

@ -28,132 +28,129 @@
#include <cmath>
#endif//GLM_COMPILER
namespace glm
namespace glm{
namespace gtx{
namespace compatibility ///< GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
{
namespace gtx{
//! GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages
namespace compatibility
{
/// \addtogroup gtx_compatibility
///@{
/// \addtogroup gtx_compatibility
///@{
template <typename T> GLM_FUNC_QUALIFIER 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> GLM_FUNC_QUALIFIER 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> GLM_FUNC_QUALIFIER 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)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<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> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, const detail::tvec2<T>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, const detail::tvec3<T>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, const detail::tvec4<T>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER 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> GLM_FUNC_QUALIFIER 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> GLM_FUNC_QUALIFIER 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)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<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> GLM_FUNC_QUALIFIER detail::tvec2<T> lerp(const detail::tvec2<T>& x, const detail::tvec2<T>& y, const detail::tvec2<T>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> lerp(const detail::tvec3<T>& x, const detail::tvec3<T>& y, const detail::tvec3<T>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> lerp(const detail::tvec4<T>& x, const detail::tvec4<T>& y, const detail::tvec4<T>& a){return mix(x, y, a);} //!< \brief Returns the component-wise result of x * (1.0 - a) + y * a, i.e., the linear blend of x and y using vector a. The value for a is not restricted to the range [0, 1]. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> saturate(const detail::tvec2<T>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> saturate(const detail::tvec3<T>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> saturate(const detail::tvec4<T>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER T saturate(T x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> saturate(const detail::tvec2<T>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> saturate(const detail::tvec3<T>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> saturate(const detail::tvec4<T>& x){return clamp(x, T(0), T(1));} //!< \brief Returns clamp(x, 0, 1) for each component in x. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> atan2(const detail::tvec2<T>& x, const detail::tvec2<T>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> atan2(const detail::tvec3<T>& x, const detail::tvec3<T>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> atan2(const detail::tvec4<T>& x, const detail::tvec4<T>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER T atan2(T x, T y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec2<T> atan2(const detail::tvec2<T>& x, const detail::tvec2<T>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec3<T> atan2(const detail::tvec3<T>& x, const detail::tvec3<T>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename T> GLM_FUNC_QUALIFIER detail::tvec4<T> atan2(const detail::tvec4<T>& x, const detail::tvec4<T>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
template <typename genType> bool isfinite(genType const & x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename valType> detail::tvec2<bool> isfinite(const detail::tvec2<valType>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename valType> detail::tvec3<bool> isfinite(const detail::tvec3<valType>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename valType> detail::tvec4<bool> isfinite(const detail::tvec4<valType>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename genType> bool isfinite(genType const & x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename valType> detail::tvec2<bool> isfinite(const detail::tvec2<valType>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename valType> detail::tvec3<bool> isfinite(const detail::tvec3<valType>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename valType> detail::tvec4<bool> isfinite(const detail::tvec4<valType>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename genType> bool isinf(genType const & x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec2<bool> isinf(const detail::tvec2<genType>& x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec3<bool> isinf(const detail::tvec3<genType>& x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec4<bool> isinf(const detail::tvec4<genType>& x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
template <typename genType> bool isinf(genType const & x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec2<bool> isinf(const detail::tvec2<genType>& x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec3<bool> isinf(const detail::tvec3<genType>& x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec4<bool> isinf(const detail::tvec4<genType>& x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
template <typename genType> bool isnan(genType const & x); //!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec2<bool> isnan(const detail::tvec2<genType>& x); //!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec3<bool> isnan(const detail::tvec3<genType>& x); //!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec4<bool> isnan(const detail::tvec4<genType>& x); //!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
template <typename genType> bool isnan(genType const & x); //!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec2<bool> isnan(const detail::tvec2<genType>& x); //!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec3<bool> isnan(const detail::tvec3<genType>& x); //!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec4<bool> isnan(const detail::tvec4<genType>& x); //!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
typedef bool bool1; //!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<bool> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<bool> bool3; //!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<bool> bool4; //!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
typedef bool bool1; //!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<bool> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<bool> bool3; //!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<bool> bool4; //!< \brief boolean type with 4 components. (From GLM_GTX_compatibility extension)
typedef bool bool1x1; //!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<bool> bool2x2; //!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<bool> bool2x3; //!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<bool> bool2x4; //!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<bool> bool3x2; //!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<bool> bool3x3; //!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<bool> bool3x4; //!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<bool> bool4x2; //!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<bool> bool4x3; //!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<bool> bool4x4; //!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef bool bool1x1; //!< \brief boolean matrix with 1 x 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<bool> bool2x2; //!< \brief boolean matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<bool> bool2x3; //!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<bool> bool2x4; //!< \brief boolean matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<bool> bool3x2; //!< \brief boolean matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<bool> bool3x3; //!< \brief boolean matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<bool> bool3x4; //!< \brief boolean matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<bool> bool4x2; //!< \brief boolean matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<bool> bool4x3; //!< \brief boolean matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<bool> bool4x4; //!< \brief boolean matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef int int1; //!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<int> int2; //!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<int> int3; //!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<int> int4; //!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
typedef int int1; //!< \brief integer vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<int> int2; //!< \brief integer vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<int> int3; //!< \brief integer vector with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<int> int4; //!< \brief integer vector with 4 components. (From GLM_GTX_compatibility extension)
typedef int int1x1; //!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<int> int2x2; //!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<int> int2x3; //!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<int> int2x4; //!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<int> int3x2; //!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<int> int3x3; //!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<int> int3x4; //!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<int> int4x2; //!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<int> int4x3; //!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<int> int4x4; //!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef int int1x1; //!< \brief integer matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<int> int2x2; //!< \brief integer matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<int> int2x3; //!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<int> int2x4; //!< \brief integer matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<int> int3x2; //!< \brief integer matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<int> int3x3; //!< \brief integer matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<int> int3x4; //!< \brief integer matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<int> int4x2; //!< \brief integer matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<int> int4x3; //!< \brief integer matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<int> int4x4; //!< \brief integer matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef gtc::half_float::half half1; //!< \brief half-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<gtc::half_float::half> half2; //!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<gtc::half_float::half> half3; //!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<gtc::half_float::half> half4; //!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef gtc::half_float::half half1; //!< \brief half-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<gtc::half_float::half> half2; //!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<gtc::half_float::half> half3; //!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<gtc::half_float::half> half4; //!< \brief half-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef gtc::half_float::half half1x1; //!< \brief half-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<gtc::half_float::half> half2x2; //!< \brief half-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<gtc::half_float::half> half2x3; //!< \brief half-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<gtc::half_float::half> half2x4; //!< \brief half-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<gtc::half_float::half> half3x2; //!< \brief half-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<gtc::half_float::half> half3x3; //!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<gtc::half_float::half> half3x4; //!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<gtc::half_float::half> half4x2; //!< \brief half-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<gtc::half_float::half> half4x3; //!< \brief half-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<gtc::half_float::half> half4x4; //!< \brief half-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef gtc::half_float::half half1x1; //!< \brief half-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<gtc::half_float::half> half2x2; //!< \brief half-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<gtc::half_float::half> half2x3; //!< \brief half-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<gtc::half_float::half> half2x4; //!< \brief half-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<gtc::half_float::half> half3x2; //!< \brief half-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<gtc::half_float::half> half3x3; //!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<gtc::half_float::half> half3x4; //!< \brief half-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<gtc::half_float::half> half4x2; //!< \brief half-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<gtc::half_float::half> half4x3; //!< \brief half-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<gtc::half_float::half> half4x4; //!< \brief half-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef float float1; //!< \brief single-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<float> float2; //!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<float> float3; //!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<float> float4; //!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
typedef float float1; //!< \brief single-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<float> float2; //!< \brief single-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<float> float3; //!< \brief single-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<float> float4; //!< \brief single-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
typedef float float1x1; //!< \brief single-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<float> float2x2; //!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<float> float2x3; //!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<float> float2x4; //!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<float> float3x2; //!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<float> float3x3; //!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<float> float3x4; //!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<float> float4x2; //!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<float> float4x3; //!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<float> float4x4; //!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef float float1x1; //!< \brief single-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<float> float2x2; //!< \brief single-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<float> float2x3; //!< \brief single-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<float> float2x4; //!< \brief single-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<float> float3x2; //!< \brief single-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<float> float3x3; //!< \brief single-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<float> float3x4; //!< \brief single-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<float> float4x2; //!< \brief single-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<float> float4x3; //!< \brief single-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<float> float4x4; //!< \brief single-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
typedef double double1; //!< \brief double-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<double> double2; //!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<double> double3; //!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<double> double4; //!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
typedef double double1; //!< \brief double-precision floating-point vector with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<double> double2; //!< \brief double-precision floating-point vector with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<double> double3; //!< \brief double-precision floating-point vector with 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<double> double4; //!< \brief double-precision floating-point vector with 4 components. (From GLM_GTX_compatibility extension)
typedef double double1x1; //!< \brief double-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<double> double2x2; //!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<double> double2x3; //!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<double> double2x4; //!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<double> double3x2; //!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<double> double3x3; //!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<double> double3x4; //!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<double> double4x2; //!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
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)
typedef double double1x1; //!< \brief double-precision floating-point matrix with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x2<double> double2x2; //!< \brief double-precision floating-point matrix with 2 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x3<double> double2x3; //!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat2x4<double> double2x4; //!< \brief double-precision floating-point matrix with 2 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x2<double> double3x2; //!< \brief double-precision floating-point matrix with 3 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x3<double> double3x3; //!< \brief double-precision floating-point matrix with 3 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat3x4<double> double3x4; //!< \brief double-precision floating-point matrix with 3 x 4 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x2<double> double4x2; //!< \brief double-precision floating-point matrix with 4 x 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x3<double> double4x3; //!< \brief double-precision floating-point matrix with 4 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tmat4x4<double> double4x4; //!< \brief double-precision floating-point matrix with 4 x 4 components. (From GLM_GTX_compatibility extension)
///@}
}//namespace compatibility
}//namespace gtx
/// @}
}//namespace compatibility
}//namespace gtx
}//namespace glm
#include "compatibility.inl"

59
glm/gtx/component_wise.hpp
View File

@ -20,43 +20,40 @@
# pragma message("GLM: GLM_GTX_component_wise extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace component_wise ///< GLM_GTX_component_wise extension: Operations between components of a type
{
namespace gtx{
//! GLM_GTX_component_wise extension: Operations between components of a type
namespace component_wise
{
/// \addtogroup gtx_component_wise
///@{
/// \addtogroup gtx_component_wise
/// @{
//! Add all vector components together.
//! From GLM_GTX_component_wise extension.
template <typename genType>
typename genType::value_type compAdd(
genType const & v);
//! Add all vector components together.
//! From GLM_GTX_component_wise extension.
template <typename genType>
typename genType::value_type compAdd(
genType const & v);
//! Multiply all vector components together.
//! From GLM_GTX_component_wise extension.
template <typename genType>
typename genType::value_type compMul(
genType const & v);
//! Multiply all vector components together.
//! From GLM_GTX_component_wise extension.
template <typename genType>
typename genType::value_type compMul(
genType const & v);
//! Find the minimum value between single vector components.
//! From GLM_GTX_component_wise extension.
template <typename genType>
typename genType::value_type compMin(
genType const & v);
//! Find the minimum value between single vector components.
//! From GLM_GTX_component_wise extension.
template <typename genType>
typename genType::value_type compMin(
genType const & v);
//! Find the maximum value between single vector components.
//! From GLM_GTX_component_wise extension.
template <typename genType>
typename genType::value_type compMax(
genType const & v);
//! Find the maximum value between single vector components.
//! From GLM_GTX_component_wise extension.
template <typename genType>
typename genType::value_type compMax(
genType const & v);
///@}
}//namespace component_wise
}//namespace gtx
/// @}
}//namespace component_wise
}//namespace gtx
}//namespace glm
#include "component_wise.inl"

47
glm/gtx/epsilon.hpp
View File

@ -22,35 +22,32 @@
# pragma message("GLM: GLM_GTX_epsilon extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace epsilon ///< GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
{
namespace gtx{
//! GLM_GTX_epsilon extension: Comparison functions for a user defined epsilon values.
namespace epsilon
{
/// \addtogroup gtx_epsilon
///@{
/// \addtogroup gtx_epsilon
///@{
//! Returns the component-wise compare of |x - y| < epsilon.
//! From GLM_GTX_epsilon extension.
template <typename genTypeT, typename genTypeU>
bool equalEpsilon(
genTypeT const & x,
genTypeT const & y,
genTypeU const & epsilon);
//! Returns the component-wise compare of |x - y| < epsilon.
//! From GLM_GTX_epsilon extension.
template <typename genTypeT, typename genTypeU>
bool equalEpsilon(
genTypeT const & x,
genTypeT const & y,
genTypeU const & epsilon);
//! Returns the component-wise compare of |x - y| >= epsilon.
//! From GLM_GTX_epsilon extension.
template <typename genTypeT, typename genTypeU>
bool notEqualEpsilon(
genTypeT const & x,
genTypeT const & y,
genTypeU const & epsilon);
//! Returns the component-wise compare of |x - y| >= epsilon.
//! From GLM_GTX_epsilon extension.
template <typename genTypeT, typename genTypeU>
bool notEqualEpsilon(
genTypeT const & x,
genTypeT const & y,
genTypeU const & epsilon);
///@}
}//namespace epsilon
}//namespace gtx
///@}
}//namespace epsilon
}//namespace gtx
}//namespace glm
#include "epsilon.inl"

180
glm/gtx/euler_angles.hpp
View File

@ -26,114 +26,112 @@
# pragma message("GLM: GLM_GTX_euler_angles extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace euler_angles ///< GLM_GTX_euler_angles extension: Build matrices from Euler angles.
{
namespace gtx{
//! GLM_GTX_euler_angles extension: Build matrices from Euler angles.
namespace euler_angles
{
/// \addtogroup gtx_euler_angles
///@{
/// \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>
detail::tmat4x4<valType> eulerAngleX(
valType const & angleX);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle X.
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleX(
valType const & angleX);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleY(
valType const & angleY);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Y.
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleY(
valType const & angleY);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleZ(
valType const & angleZ);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from an euler angle Z.
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleZ(
valType const & angleZ);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleXY(
valType const & angleX,
valType const & angleY);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Y).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleXY(
valType const & angleX,
valType const & angleY);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleYX(
valType const & angleY,
valType const & angleX);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleYX(
valType const & angleY,
valType const & angleX);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleXZ(
valType const & angleX,
valType const & angleZ);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (X * Z).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleXZ(
valType const & angleX,
valType const & angleZ);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleZX(
valType const & angleZ,
valType const & angleX);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * X).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleZX(
valType const & angleZ,
valType const & angleX);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleYZ(
valType const & angleY,
valType const & angleZ);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * Z).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleYZ(
valType const & angleY,
valType const & angleZ);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleZY(
valType const & angleZ,
valType const & angleY);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Z * Y).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleZY(
valType const & angleZ,
valType const & angleY);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleYXZ(
valType const & yaw,
valType const & pitch,
valType const & roll);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> eulerAngleYXZ(
valType const & yaw,
valType const & pitch,
valType const & roll);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> yawPitchRoll(
valType const & yaw,
valType const & pitch,
valType const & roll);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
//! From GLM_GTX_euler_angles extension.
template <typename valType>
detail::tmat4x4<valType> yawPitchRoll(
valType const & yaw,
valType const & pitch,
valType const & roll);
//! Creates a 2D 2 * 2 rotation matrix from an euler angle.
//! From GLM_GTX_euler_angles extension.
template <typename T>
detail::tmat2x2<T> orientate2(T const & angle);
//! Creates a 2D 2 * 2 rotation matrix from an euler angle.
//! From GLM_GTX_euler_angles extension.
template <typename T>
detail::tmat2x2<T> orientate2(T const & angle);
//! Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.
//! From GLM_GTX_euler_angles extension.
template <typename T>
detail::tmat3x3<T> orientate3(T const & angle);
//! Creates a 2D 4 * 4 homogeneous rotation matrix from an euler angle.
//! From GLM_GTX_euler_angles extension.
template <typename T>
detail::tmat3x3<T> orientate3(T const & angle);
//! Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z).
//! From GLM_GTX_euler_angles extension.
template <typename T>
detail::tmat3x3<T> orientate3(detail::tvec3<T> const & angles);
//! Creates a 3D 3 * 3 rotation matrix from euler angles (Y * X * Z).
//! From GLM_GTX_euler_angles extension.
template <typename T>
detail::tmat3x3<T> orientate3(detail::tvec3<T> const & angles);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
//! From GLM_GTX_euler_angles extension.
template <typename T>
detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
//! Creates a 3D 4 * 4 homogeneous rotation matrix from euler angles (Y * X * Z).
//! From GLM_GTX_euler_angles extension.
template <typename T>
detail::tmat4x4<T> orientate4(detail::tvec3<T> const & angles);
///@}
}//namespace euler_angles
}//namespace gtx
/// @}
}//namespace euler_angles
}//namespace gtx
}//namespace glm
#include "euler_angles.inl"

33
glm/gtx/extend.hpp
View File

@ -20,27 +20,24 @@
# pragma message("GLM: GLM_GTX_extend extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace extend ///< GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
{
namespace gtx{
//! GLM_GTX_extend extension: Extend a position from a source to a position at a defined length.
namespace extend
{
/// \addtogroup gtx_extend
///@{
/// \addtogroup gtx_extend
/// @{
//! Extends of Length the Origin position using the (Source - Origin) direction.
//! From GLM_GTX_extend extension.
template <typename genType>
genType extend(
genType const & Origin,
genType const & Source,
typename genType::value_type const Length);
//! Extends of Length the Origin position using the (Source - Origin) direction.
//! From GLM_GTX_extend extension.
template <typename genType>
genType extend(
genType const & Origin,
genType const & Source,
typename genType::value_type const Length);
///@}
}//namespace extend
}//namespace gtx
/// @}
}//namespace extend
}//namespace gtx
}//namespace glm
#include "extend.inl"

263
glm/gtx/extented_min_max.hpp
View File

@ -22,153 +22,150 @@
# pragma message("GLM: GLM_GTX_extented_min_max extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace extented_min_max ///< GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
{
namespace gtx{
//! GLM_GTX_extented_min_max extension: Min and max functions for 3 to 4 parameters.
namespace extented_min_max
{
/// \addtogroup gtx_extented_min_max
///@{
/// \addtogroup gtx_extented_min_max
///@{
//< Return the minimum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template <typename T>
T min(
T const & x,
T const & y,
T const & z);
//< Return the minimum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template <typename T>
T min(
T const & x,
T const & y,
T const & z);
//< Return the minimum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> min(
C<T> const & x,
typename C<T>::value_type const & y,
typename C<T>::value_type const & z);
//< Return the minimum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> min(
C<T> const & x,
typename C<T>::value_type const & y,
typename C<T>::value_type const & z);
//< Return the minimum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> min(
C<T> const & x,
C<T> const & y,
C<T> const & z);
//< Return the minimum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> min(
C<T> const & x,
C<T> const & y,
C<T> const & z);
//< Return the minimum component-wise values of 4 inputs
//< From GLM_GTX_extented_min_max extension
template <typename T>
T min(
T const & x,
T const & y,
T const & z,
T const & w);
//< Return the minimum component-wise values of 4 inputs
//< From GLM_GTX_extented_min_max extension
template <typename T>
T min(
T const & x,
T const & y,
T const & z,
T const & w);
//< Return the minimum component-wise values of 4 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> min(
C<T> const & x,
typename C<T>::value_type const & y,
typename C<T>::value_type const & z,
typename C<T>::value_type const & w);
//< Return the minimum component-wise values of 4 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> min(
C<T> const & x,
typename C<T>::value_type const & y,
typename C<T>::value_type const & z,
typename C<T>::value_type const & w);
//< Return the minimum component-wise values of 4 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> min(
C<T> const & x,
C<T> const & y,
C<T> const & z,
C<T> const & w);
//< Return the minimum component-wise values of 4 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> min(
C<T> const & x,
C<T> const & y,
C<T> const & z,
C<T> const & w);
//< Return the maximum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template <typename T>
T max(
T const & x,
T const & y,
T const & z);
//< Return the maximum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template <typename T>
T max(
T const & x,
T const & y,
T const & z);
//< Return the maximum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> max(
C<T> const & x,
typename C<T>::value_type const & y,
typename C<T>::value_type const & z);
//< Return the maximum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> max(
C<T> const & x,
typename C<T>::value_type const & y,
typename C<T>::value_type const & z);
//< Return the maximum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> max(
C<T> const & x,
C<T> const & y,
C<T> const & z);
//< Return the maximum component-wise values of 3 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> max(
C<T> const & x,
C<T> const & y,
C<T> const & z);
//< Return the maximum component-wise values of 4 inputs
//< From GLM_GTX_extented_min_max extension
template <typename T>
T max(
T const & x,
T const & y,
T const & z,
T const & w);
//< Return the maximum component-wise values of 4 inputs
//< From GLM_GTX_extented_min_max extension
template <typename T>
T max(
T const & x,
T const & y,
T const & z,
T const & w);
//< Return the maximum component-wise values of 4 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> max(
C<T> const & x,
typename C<T>::value_type const & y,
typename C<T>::value_type const & z,
typename C<T>::value_type const & w);
//< Return the maximum component-wise values of 4 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> max(
C<T> const & x,
typename C<T>::value_type const & y,
typename C<T>::value_type const & z,
typename C<T>::value_type const & w);
//< Return the maximum component-wise values of 4 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> max(
C<T> const & x,
C<T> const & y,
C<T> const & z,
C<T> const & w);
//< Return the maximum component-wise values of 4 inputs
//< From GLM_GTX_extented_min_max extension
template
<
typename T,
template <typename> class C
>
C<T> max(
C<T> const & x,
C<T> const & y,
C<T> const & z,
C<T> const & w);
///@}
}//namespace extented_min_max
}//namespace gtx
/// @}
}//namespace extented_min_max
}//namespace gtx
}//namespace glm
#include "extented_min_max.inl"

85
glm/gtx/fast_exponential.hpp
View File

@ -22,59 +22,56 @@
# pragma message("GLM: GLM_GTX_fast_exponential extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace fast_exponential ///< GLM_GTX_fast_exponential extension: Fast but less accurate implementations of exponential based functions.
{
namespace gtx{
//! GLM_GTX_fast_exponential extension: Fast but less accurate implementations of exponential based functions.
namespace fast_exponential
{
using namespace gtc::half_float;
/// \addtogroup gtx_fast_exponential
///@{
using namespace gtc::half_float;
/// \addtogroup gtx_fast_exponential
/// @{
//! Faster than the common pow function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename valType>
valType fastPow(
valType const & x,
valType const & y);
//! Faster than the common pow function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename valType>
valType fastPow(
valType const & x,
valType const & y);
//! Faster than the common pow function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T, typename U>
T fastPow(
const T& x,
const U& y);
//! Faster than the common pow function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T, typename U>
T fastPow(
const T& x,
const U& y);
//! Faster than the common exp function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T>
T fastExp(const T& x);
//! Faster than the common exp function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T>
T fastExp(const T& x);
//! Faster than the common log function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T>
T fastLog(const T& x);
//! Faster than the common log function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T>
T fastLog(const T& x);
//! Faster than the common exp2 function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T>
T fastExp2(const T& x);
//! Faster than the common exp2 function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T>
T fastExp2(const T& x);
//! Faster than the common log2 function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T>
T fastLog2(const T& x);
//! Faster than the common log2 function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T>
T fastLog2(const T& x);
//! Faster than the common ln function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T>
T fastLn(const T& x);
//! Faster than the common ln function but less accurate.
//! From GLM_GTX_fast_exponential extension.
template <typename T>
T fastLn(const T& x);
///@}
}//namespace fast_exponential
}//namespace gtx
/// @}
}//namespace fast_exponential
}//namespace gtx
}//namespace glm
#include "fast_exponential.inl"

61
glm/gtx/fast_square_root.hpp
View File

@ -24,45 +24,42 @@
# pragma message("GLM: GLM_GTX_fast_square_root extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace fast_square_root ///< GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
{
namespace gtx{
//! GLM_GTX_fast_square_root extension: Fast but less accurate implementations of square root based functions.
namespace fast_square_root
{
/// \addtogroup gtx_fast_square_root
///@{
/// \addtogroup gtx_fast_square_root
/// @{
//! Faster than the common sqrt function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
genType fastSqrt(genType const & x);
//! Faster than the common sqrt function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
genType fastSqrt(genType const & x);
//! Faster than the common inversesqrt function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
genType fastInverseSqrt(genType const & x);
//! Faster than the common inversesqrt function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
genType fastInverseSqrt(genType const & x);
//! Faster than the common length function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
typename genType::value_type fastLength(genType const & x);
//! Faster than the common length function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
typename genType::value_type fastLength(genType const & x);
//! Faster than the common distance function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
typename genType::value_type fastDistance(genType const & x, genType const & y);
//! Faster than the common distance function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
typename genType::value_type fastDistance(genType const & x, genType const & y);
//! Faster than the common normalize function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
genType fastNormalize(genType const & x);
//! Faster than the common normalize function but less accurate.
//! From GLM_GTX_fast_square_root extension.
template <typename genType>
genType fastNormalize(genType const & x);
///@}
}//namespace fast_square_root
}// namespace gtx
}//namespace glm
/// @}
}// namespace fast_square_root
}// namespace gtx
}// namespace glm
#include "fast_square_root.inl"

89
glm/gtx/fast_trigonometry.hpp
View File

@ -20,61 +20,58 @@
# pragma message("GLM: GLM_GTX_fast_trigonometry extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace fast_trigonometry ///< GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
{
namespace gtx{
//! GLM_GTX_fast_trigonometry extension: Fast but less accurate implementations of trigonometric functions.
namespace fast_trigonometry
{
/// \addtogroup gtx_fast_trigonometry
///@{
/// \addtogroup gtx_fast_trigonometry
/// @{
//! Faster than the common sin function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastSin(const T& angle);
//! Faster than the common sin function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastSin(const T& angle);
//! Faster than the common cos function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastCos(const T& angle);
//! Faster than the common cos function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastCos(const T& angle);
//! Faster than the common tan function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastTan(const T& angle);
//! Faster than the common tan function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastTan(const T& angle);
//! Faster than the common asin function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastAsin(const T& angle);
//! Faster than the common asin function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastAsin(const T& angle);
//! Faster than the common acos function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastAcos(const T& angle);
//! Faster than the common acos function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastAcos(const T& angle);
//! Faster than the common atan function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastAtan(const T& y, const T& x);
//! Faster than the common atan function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastAtan(const T& y, const T& x);
//! Faster than the common atan function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastAtan(const T& angle);
//! Faster than the common atan function but less accurate.
//! Defined between -2pi and 2pi.
//! From GLM_GTX_fast_trigonometry extension.
template <typename T>
T fastAtan(const T& angle);
///@}
}//namespace fast_trigonometry
}//namespace gtx
/// @}
}//namespace fast_trigonometry
}//namespace gtx
}//namespace glm
#include "fast_trigonometry.inl"

42
glm/gtx/gradient_paint.hpp
View File

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

49
glm/gtx/handed_coordinate_space.hpp
View File

@ -20,36 +20,33 @@
# pragma message("GLM: GLM_GTX_handed_coordinate_space extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace handed_coordinate_space ///< GLM_GTX_handed_coordinate_space extension: To know if a set of three basis vectors defines a right or left-handed coordinate system.
{
namespace gtx{
//! GLM_GTX_handed_coordinate_space extension: To know if a set of three basis vectors defines a right or left-handed coordinate system.
namespace handed_coordinate_space
{
/// \addtogroup gtx_handed_coordinate_space
///@{
/// \addtogroup gtx_handed_coordinate_space
/// @{
//! Return if a trihedron right handed or not.
//! From GLM_GTX_handed_coordinate_space extension.
template <typename T>
bool rightHanded(
detail::tvec3<T> const & tangent,
detail::tvec3<T> const & binormal,
detail::tvec3<T> const & normal);
//! Return if a trihedron right handed or not.
//! From GLM_GTX_handed_coordinate_space extension.
template <typename T>
bool rightHanded(
detail::tvec3<T> const & tangent,
detail::tvec3<T> const & binormal,
detail::tvec3<T> const & normal);
//! Return if a trihedron left handed or not.
//! From GLM_GTX_handed_coordinate_space extension.
template <typename T>
bool leftHanded(
detail::tvec3<T> const & tangent,
detail::tvec3<T> const & binormal,
detail::tvec3<T> const & normal);
//! Return if a trihedron left handed or not.
//! From GLM_GTX_handed_coordinate_space extension.
template <typename T>
bool leftHanded(
detail::tvec3<T> const & tangent,
detail::tvec3<T> const & binormal,
detail::tvec3<T> const & normal);
///@}
}//namespace handed_coordinate_space
}//namespace gtx
}//namespace glm
/// @}
}// namespace handed_coordinate_space
}// namespace gtx
}// namespace glm
#include "handed_coordinate_space.inl"

117
glm/gtx/inertia.hpp
View File

@ -20,76 +20,73 @@
# pragma message("GLM: GLM_GTX_inertia extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace inertia ///< GLM_GTX_inertia extension: Create inertia matrices
{
namespace gtx{
//! GLM_GTX_inertia extension: Create inertia matrices
namespace inertia
{
/// \addtogroup gtx_inertia
///@{
/// \addtogroup gtx_inertia
/// @{
//! Build an inertia matrix for a box.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat3x3<T> boxInertia3(
const T Mass,
const detail::tvec3<T>& Scale);
//! Build an inertia matrix for a box.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat3x3<T> boxInertia3(
const T Mass,
const detail::tvec3<T>& Scale);
//! Build an inertia matrix for a box.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat4x4<T> boxInertia4(
const T Mass,
const detail::tvec3<T>& Scale);
//! Build an inertia matrix for a box.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat4x4<T> boxInertia4(
const T Mass,
const detail::tvec3<T>& Scale);
//! Build an inertia matrix for a disk.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat3x3<T> diskInertia3(
const T Mass,
const T Radius);
//! Build an inertia matrix for a disk.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat3x3<T> diskInertia3(
const T Mass,
const T Radius);
//! Build an inertia matrix for a disk.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat4x4<T> diskInertia4(
const T Mass,
const T Radius);
//! Build an inertia matrix for a disk.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat4x4<T> diskInertia4(
const T Mass,
const T Radius);
//! Build an inertia matrix for a ball.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat3x3<T> ballInertia3(
const T Mass,
const T Radius);
//! Build an inertia matrix for a ball.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat3x3<T> ballInertia3(
const T Mass,
const T Radius);
//! Build an inertia matrix for a ball.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat4x4<T> ballInertia4(
const T Mass,
const T Radius);
//! Build an inertia matrix for a ball.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat4x4<T> ballInertia4(
const T Mass,
const T Radius);
//! Build an inertia matrix for a sphere.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat3x3<T> sphereInertia3(
const T Mass,
const T Radius);
//! Build an inertia matrix for a sphere.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat3x3<T> sphereInertia3(
const T Mass,
const T Radius);
//! Build an inertia matrix for a sphere.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat4x4<T> sphereInertia4(
const T Mass,
const T Radius);
//! Build an inertia matrix for a sphere.
//! From GLM_GTX_inertia extension.
template <typename T>
detail::tmat4x4<T> sphereInertia4(
const T Mass,
const T Radius);
///@}
}//namespace inertia
}//namespace gtx
}//namespace glm
/// @}
}// namespace inertia
}// namespace gtx
}// namespace glm
#include "inertia.inl"

26
glm/gtx/int_10_10_10_2.hpp
View File

@ -21,25 +21,23 @@
# pragma message("GLM: GLM_GTX_int_10_10_10_2 extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace int_10_10_10_2 ///< GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
{
namespace gtx{
//! GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
namespace int_10_10_10_2
{
using namespace gtx::raw_data;
using namespace gtx::raw_data;
/// \addtogroup gtx_int_10_10_10_2
///@{
/// \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);
//! 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 integer
}//namespace gtx
}//namespace glm
#include "int_10_10_10_2.inl"

45
glm/gtx/integer.hpp
View File

@ -20,36 +20,33 @@
# pragma message("GLM: GLM_GTX_integer extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace integer ///< GLM_GTX_integer extension: Add support for integer for core functions
{
namespace gtx{
//! GLM_GTX_integer extension: Add support for integer for core functions
namespace integer
{
/// \addtogroup gtx_integer
///@{
/// \addtogroup gtx_integer
/// @{
//! Returns x raised to the y power.
//! From GLM_GTX_integer extension.
int pow(int x, int y);
//! Returns x raised to the y power.
//! From GLM_GTX_integer extension.
int pow(int x, int y);
//! Returns the positive square root of x.
//! From GLM_GTX_integer extension.
int sqrt(int x);
//! Returns the positive square root of x.
//! From GLM_GTX_integer extension.
int sqrt(int x);
//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
//! From GLM_GTX_integer extension.
int mod(int x, int y);
//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
//! From GLM_GTX_integer extension.
int mod(int x, int y);
//! Return the factorial value of a number (!12 max, integer only)
//! From GLM_GTX_integer extension.
template <typename genType>
genType factorial(genType const & x);
//! Return the factorial value of a number (!12 max, integer only)
//! From GLM_GTX_integer extension.
template <typename genType>
genType factorial(genType const & x);
///@}
}//namespace integer
}//namespace gtx
/// @}
}//namespace integer
}//namespace gtx
}//namespace glm
#include "integer.inl"

73
glm/gtx/intersect.hpp
View File

@ -22,50 +22,47 @@
# pragma message("GLM: GLM_GTX_closest_point extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace intersect ///< GLM_GTX_intersect extension: Add intersection functions
{
namespace gtx{
//! GLM_GTX_intersect extension: Add intersection functions
namespace intersect
{
/// \addtogroup gtx_intersect
///@{
/// \addtogroup gtx_intersect
/// @{
//! Compute the intersection of a ray and a triangle.
//! From GLM_GTX_intersect extension.
template <typename genType>
bool intersectRayTriangle(
genType const & orig, genType const & dir,
genType const & vert0, genType const & vert1, genType const & vert2,
genType & baryPosition);
//! Compute the intersection of a ray and a triangle.
//! From GLM_GTX_intersect extension.
template <typename genType>
bool intersectRayTriangle(
genType const & orig, genType const & dir,
genType const & vert0, genType const & vert1, genType const & vert2,
genType & baryPosition);
//! Compute the intersection of a line and a triangle.
//! From GLM_GTX_intersect extension.
template <typename genType>
bool intersectLineTriangle(
genType const & orig, genType const & dir,
genType const & vert0, genType const & vert1, genType const & vert2,
genType & position);
//! Compute the intersection of a line and a triangle.
//! From GLM_GTX_intersect extension.
template <typename genType>
bool intersectLineTriangle(
genType const & orig, genType const & dir,
genType const & vert0, genType const & vert1, genType const & vert2,
genType & position);
//! Compute the intersection of a ray and a sphere.
//! From GLM_GTX_intersect extension.
template <typename genType>
bool intersectRaySphere(
genType const & orig, genType const & dir,
genType const & center, typename genType::value_type radius,
genType & position, genType & normal);
//! Compute the intersection of a ray and a sphere.
//! From GLM_GTX_intersect extension.
template <typename genType>
bool intersectRaySphere(
genType const & orig, genType const & dir,
genType const & center, typename genType::value_type radius,
genType & position, genType & normal);
//! Compute the intersection of a line and a sphere.
//! From GLM_GTX_intersect extension
template <typename genType>
bool intersectLineSphere(
genType const & point0, genType const & point1,
genType const & center, typename genType::value_type radius,
genType & position, genType & normal);
//! Compute the intersection of a line and a sphere.
//! From GLM_GTX_intersect extension
template <typename genType>
bool intersectLineSphere(
genType const & point0, genType const & point1,
genType const & center, typename genType::value_type radius,
genType & position, genType & normal);
///@}
}//namespace intersect
/// @}
}//namespace intersect
}//namespace gtx
}//namespace glm

30
glm/gtx/log_base.hpp
View File

@ -20,26 +20,24 @@
# pragma message("GLM: GLM_GTX_log_base extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace log_base ///< GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
{
namespace gtx{
//! GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar.
namespace log_base
{
/// \addtogroup gtx_log_base
///@{
/// \addtogroup gtx_log_base
/// @{
//! Logarithm for any base.
//! From GLM_GTX_log_base.
template <typename genType>
genType log(
genType const & x,
genType const & base);
//! Logarithm for any base.
//! From GLM_GTX_log_base.
template <typename genType>
genType log(
genType const & x,
genType const & base);
///@}
/// @}
}//namespace extend
}//namespace gtx
}//namespace extend
}//namespace gtx
}//namespace glm
#include "log_base.inl"

39
glm/gtx/matrix_cross_product.hpp
View File

@ -20,31 +20,28 @@
# pragma message("GLM: GLM_GTX_matrix_cross_product extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace matrix_cross_product ///< GLM_GTX_matrix_cross_product: Build cross product matrices
{
namespace gtx{
//! GLM_GTX_matrix_cross_product: Build cross product matrices
namespace matrix_cross_product
{
/// \addtogroup gtx_matrix_cross_product
///@{
/// \addtogroup gtx_matrix_cross_product
/// @{
//! Build a cross product matrix.
//! From GLM_GTX_matrix_cross_product extension.
template <typename T>
detail::tmat3x3<T> matrixCross3(
detail::tvec3<T> const & x);
//! Build a cross product matrix.
//! From GLM_GTX_matrix_cross_product extension.
template <typename T>
detail::tmat3x3<T> matrixCross3(
detail::tvec3<T> const & x);
//! Build a cross product matrix.
//! From GLM_GTX_matrix_cross_product extension.
template <typename T>
detail::tmat4x4<T> matrixCross4(
detail::tvec3<T> const & x);
//! Build a cross product matrix.
//! From GLM_GTX_matrix_cross_product extension.
template <typename T>
detail::tmat4x4<T> matrixCross4(
detail::tvec3<T> const & x);
///@}
}//namespace matrix_cross_product
}//namespace gtx
/// @}
}//namespace matrix_cross_product
}//namespace gtx
}//namespace glm
#include "matrix_cross_product.inl"

61
glm/gtx/matrix_interpolation.hpp
View File

@ -23,43 +23,40 @@
# pragma message("GLM: GLM_GTX_matrix_interpolation extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace matrix_interpolation ///< GLM_GTX_matrix_interpolation extension: Add transformation matrices
{
namespace gtx{
//! GLM_GTX_matrix_interpolation extension: Add transformation matrices
namespace matrix_interpolation
{
/// \addtogroup gtx_matrix_interpolation
///@{
/// \addtogroup gtx_matrix_interpolation
/// @{
//! Get the axis and angle of the rotation from a matrix.
//! From GLM_GTX_matrix_interpolation extension.
template <typename T>
void axisAngle(
detail::tmat4x4<T> const & mat,
detail::tvec3<T> & axis,
T & angle);
//! Get the axis and angle of the rotation from a matrix.
//! From GLM_GTX_matrix_interpolation extension.
template <typename T>
void axisAngle(
detail::tmat4x4<T> const & mat,
detail::tvec3<T> & axis,
T & angle);
//! Build a matrix from axis and angle.
//! From GLM_GTX_matrix_interpolation extension.
template <typename T>
detail::tmat4x4<T> axisAngleMatrix(
detail::tvec3<T> const & axis,
T const angle);
//! Build a matrix from axis and angle.
//! From GLM_GTX_matrix_interpolation extension.
template <typename T>
detail::tmat4x4<T> axisAngleMatrix(
detail::tvec3<T> const & axis,
T const angle);
//! Build a interpolation of 4 * 4 matrixes.
//! From GLM_GTX_matrix_interpolation extension.
//! Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.
template <typename T>
detail::tmat4x4<T> interpolate(
detail::tmat4x4<T> const & m1,
detail::tmat4x4<T> const & m2,
T const delta);
//! Build a interpolation of 4 * 4 matrixes.
//! From GLM_GTX_matrix_interpolation extension.
//! Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.
template <typename T>
detail::tmat4x4<T> interpolate(
detail::tmat4x4<T> const & m1,
detail::tmat4x4<T> const & m2,
T const delta);
///@}
}//namespace matrix_interpolation
}//namespace gtx
/// @}
}//namespace matrix_interpolation
}//namespace gtx
}//namespace glm
#include "matrix_interpolation.inl"

163
glm/gtx/matrix_major_storage.hpp
View File

@ -20,103 +20,100 @@
# pragma message("GLM: GLM_GTX_matrix_major_storage extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace matrix_major_storage ///< GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
{
namespace gtx{
//! GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column
namespace matrix_major_storage
{
/// \addtogroup gtx_matrix_major_storage
///@{
/// \addtogroup gtx_matrix_major_storage
/// @{
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat2x2<T> rowMajor2(
const detail::tvec2<T>& v1,
const detail::tvec2<T>& v2);
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat2x2<T> rowMajor2(
const detail::tvec2<T>& v1,
const detail::tvec2<T>& v2);
//! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat2x2<T> rowMajor2(
const detail::tmat2x2<T>& m);
//! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat2x2<T> rowMajor2(
const detail::tmat2x2<T>& m);
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat3x3<T> rowMajor3(
const detail::tvec3<T>& v1,
const detail::tvec3<T>& v2,
const detail::tvec3<T>& v3);
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat3x3<T> rowMajor3(
const detail::tvec3<T>& v1,
const detail::tvec3<T>& v2,
const detail::tvec3<T>& v3);
//! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat3x3<T> rowMajor3(
const detail::tmat3x3<T>& m);
//! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat3x3<T> rowMajor3(
const detail::tmat3x3<T>& m);
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat4x4<T> rowMajor4(
const detail::tvec4<T>& v1,
const detail::tvec4<T>& v2,
const detail::tvec4<T>& v3,
const detail::tvec4<T>& v4);
//! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat4x4<T> rowMajor4(
const detail::tvec4<T>& v1,
const detail::tvec4<T>& v2,
const detail::tvec4<T>& v3,
const detail::tvec4<T>& v4);
//! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat4x4<T> rowMajor4(
const detail::tmat4x4<T>& m);
//! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat4x4<T> rowMajor4(
const detail::tmat4x4<T>& m);
//! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat2x2<T> colMajor2(
const detail::tvec2<T>& v1,
const detail::tvec2<T>& v2);
//! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat2x2<T> colMajor2(
const detail::tvec2<T>& v1,
const detail::tvec2<T>& v2);
//! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat2x2<T> colMajor2(
const detail::tmat2x2<T>& m);
//! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat2x2<T> colMajor2(
const detail::tmat2x2<T>& m);
//! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat3x3<T> colMajor3(
const detail::tvec3<T>& v1,
const detail::tvec3<T>& v2,
const detail::tvec3<T>& v3);
//! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat3x3<T> colMajor3(
const detail::tvec3<T>& v1,
const detail::tvec3<T>& v2,
const detail::tvec3<T>& v3);
//! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat3x3<T> colMajor3(
const detail::tmat3x3<T>& m);
//! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat3x3<T> colMajor3(
const detail::tmat3x3<T>& m);
//! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat4x4<T> colMajor4(
const detail::tvec4<T>& v1,
const detail::tvec4<T>& v2,
const detail::tvec4<T>& v3,
const detail::tvec4<T>& v4);
//! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat4x4<T> colMajor4(
const detail::tvec4<T>& v1,
const detail::tvec4<T>& v2,
const detail::tvec4<T>& v3,
const detail::tvec4<T>& v4);
//! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat4x4<T> colMajor4(
const detail::tmat4x4<T>& m);
//! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension.
template <typename T>
detail::tmat4x4<T> colMajor4(
const detail::tmat4x4<T>& m);
///@}
}//namespace matrix_major_storage
}//namespace gtx
/// @}
}//namespace matrix_major_storage
}//namespace gtx
}//namespace glm
#include "matrix_major_storage.inl"

109
glm/gtx/matrix_operation.hpp
View File

@ -20,73 +20,70 @@
# pragma message("GLM: GLM_GTX_matrix_operation extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace matrix_operation ///< GLM_GTX_matrix_operation: Build diagonal matrices
{
namespace gtx{
//! GLM_GTX_matrix_operation: Build diagonal matrices
namespace matrix_operation
{
/// \addtogroup gtx_matrix_operation
///@{
/// \addtogroup gtx_matrix_operation
/// @{
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat2x2<valType> diagonal2x2(
detail::tvec2<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat2x2<valType> diagonal2x2(
detail::tvec2<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat2x3<valType> diagonal2x3(
detail::tvec2<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat2x3<valType> diagonal2x3(
detail::tvec2<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat2x4<valType> diagonal2x4(
detail::tvec2<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat2x4<valType> diagonal2x4(
detail::tvec2<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat3x2<valType> diagonal3x2(
detail::tvec2<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat3x2<valType> diagonal3x2(
detail::tvec2<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat3x3<valType> diagonal3x3(
detail::tvec3<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat3x3<valType> diagonal3x3(
detail::tvec3<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat3x4<valType> diagonal3x4(
detail::tvec3<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat3x4<valType> diagonal3x4(
detail::tvec3<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat4x2<valType> diagonal4x2(
detail::tvec2<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat4x2<valType> diagonal4x2(
detail::tvec2<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat4x3<valType> diagonal4x3(
detail::tvec3<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat4x3<valType> diagonal4x3(
detail::tvec3<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat4x4<valType> diagonal4x4(
detail::tvec4<valType> const & v);
//! Build a diagonal matrix.
//! From GLM_GTX_matrix_operation extension.
template <typename valType>
detail::tmat4x4<valType> diagonal4x4(
detail::tvec4<valType> const & v);
///@}
}//namespace matrix_operation
}//namespace gtx
/// @}
}//namespace matrix_operation
}//namespace gtx
}//namespace glm
#include "matrix_operation.inl"

114
glm/gtx/matrix_query.hpp
View File

@ -20,74 +20,72 @@
# pragma message("GLM: GLM_GTX_matrix_query extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace matrix_query ///< GLM_GTX_matrix_query: Query to evaluate matrix properties
{
namespace gtx{
//! GLM_GTX_matrix_query: Query to evaluate matrix properties
namespace matrix_query
{
/// \addtogroup gtx_matrix_query
///@{
/// \addtogroup gtx_matrix_query
/// @{
//! Return if a matrix a null matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
bool isNull(
const detail::tmat2x2<T>& m,
const T epsilon = std::numeric_limits<T>::epsilon());
//! Return if a matrix a null matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
bool isNull(
const detail::tmat2x2<T>& m,
const T epsilon = std::numeric_limits<T>::epsilon());
//! Return if a matrix a null matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
bool isNull(
const detail::tmat3x3<T>& m,
const T epsilon = std::numeric_limits<T>::epsilon());
//! Return if a matrix a null matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
bool isNull(
const detail::tmat3x3<T>& m,
const T epsilon = std::numeric_limits<T>::epsilon());
//! Return if a matrix a null matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
bool isNull(
const detail::tmat4x4<T>& m,
const T epsilon = std::numeric_limits<T>::epsilon());
//! Return if a matrix a null matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
bool isNull(
const detail::tmat4x4<T>& m,
const T epsilon = std::numeric_limits<T>::epsilon());
//! Return if a matrix an identity matrix.
//! From GLM_GTX_matrix_query extension.
template<typename genType>
bool isIdentity(
const genType& m,
const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Return if a matrix an identity matrix.
//! From GLM_GTX_matrix_query extension.
template<typename genType>
bool isIdentity(
const genType& m,
const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Return if a matrix a normalized matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
bool isNormalized(
const detail::tmat2x2<T>& m,
const T epsilon = std::numeric_limits<T>::epsilon());
//! Return if a matrix a normalized matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
bool isNormalized(
const detail::tmat2x2<T>& m,
const T epsilon = std::numeric_limits<T>::epsilon());
//! Return if a matrix a normalized matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
bool isNormalized(
const detail::tmat3x3<T>& m,
const T epsilon = std::numeric_limits<T>::epsilon());
//! Return if a matrix a normalized matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
bool isNormalized(
const detail::tmat3x3<T>& m,
const T epsilon = std::numeric_limits<T>::epsilon());
//! Return if a matrix a normalized matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
bool isNormalized(
const detail::tmat4x4<T>& m,
const T epsilon = std::numeric_limits<T>::epsilon());
//! Return if a matrix a normalized matrix.
//! From GLM_GTX_matrix_query extension.
template<typename T>
bool isNormalized(
const detail::tmat4x4<T>& m,
const T epsilon = std::numeric_limits<T>::epsilon());
//! Return if a matrix an orthonormalized matrix.
//! From GLM_GTX_matrix_query extension.
template<typename genType>
bool isOrthogonal(
const genType& m,
const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Return if a matrix an orthonormalized matrix.
//! From GLM_GTX_matrix_query extension.
template<typename genType>
bool isOrthogonal(
const genType& m,
const typename genType::value_type epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
///@}
}//namespace matrix_query
}//namespace gtx
/// @}
}//namespace matrix_query
}//namespace gtx
}//namespace glm
#include "matrix_query.inl"

32
glm/gtx/mixed_product.hpp
View File

@ -20,26 +20,24 @@
# pragma message("GLM: GLM_GTX_mixed_product extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace mixed_product ///< GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
{
namespace gtx{
//! GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
namespace mixed_product
{
/// \addtogroup gtx_mixed_product
///@{
/// \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);
//! \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
/// @}
}// namespace mixed_product
}// namespace gtx
}// namespace glm
#include "mixed_product.inl"

43
glm/gtx/multiple.hpp
View File

@ -20,33 +20,30 @@
# pragma message("GLM: GLM_GTX_multiple extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace multiple ///< GLM_GTX_multiple: Find the closest number of a number multiple of other number.
{
namespace gtx{
//! GLM_GTX_multiple: Find the closest number of a number multiple of other number.
namespace multiple
{
/// \addtogroup gtx_multiple
///@{
/// \addtogroup gtx_multiple
/// @{
//! Higher Multiple number of Source.
//! From GLM_GTX_multiple extension.
template <typename genType>
genType higherMultiple(
genType const & Source,
genType const & Multiple);
//! Higher Multiple number of Source.
//! From GLM_GTX_multiple extension.
template <typename genType>
genType higherMultiple(
genType const & Source,
genType const & Multiple);
//! Lower Multiple number of Source.
//! From GLM_GTX_multiple extension.
template <typename genType>
genType lowerMultiple(
genType const & Source,
genType const & Multiple);
//! Lower Multiple number of Source.
//! From GLM_GTX_multiple extension.
template <typename genType>
genType lowerMultiple(
genType const & Source,
genType const & Multiple);
///@}
}//namespace multiple
}//namespace gtx
/// @}
}//namespace multiple
}//namespace gtx
}//namespace glm
#include "multiple.inl"

51
glm/gtx/noise.hpp
View File

@ -25,38 +25,35 @@
# pragma message("GLM: GLM_GTX_noise extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace noise ///< GLM_GTX_noise extension: Comparison functions for a user defined epsilon values.
{
namespace gtx{
//! GLM_GTX_noise extension: Comparison functions for a user defined epsilon values.
namespace noise
{
/// \addtogroup gtx_noise
///@{
/// \addtogroup gtx_noise
/// @{
//! Classic perlin noise.
//! From GLM_GTX_noise extension.
template <typename T, template<typename> class vecType>
T perlin(
vecType<T> const & p);
//! Classic perlin noise.
//! From GLM_GTX_noise extension.
template <typename T, template<typename> class vecType>
T perlin(
vecType<T> const & p);
//! Periodic perlin noise.
//! From GLM_GTX_noise extension.
template <typename T, template<typename> class vecType>
T perlin(
vecType<T> const & p,
vecType<T> const & rep);
//! Periodic perlin noise.
//! From GLM_GTX_noise extension.
template <typename T, template<typename> class vecType>
T perlin(
vecType<T> const & p,
vecType<T> const & rep);
//! Simplex noise.
//! From GLM_GTX_noise extension.
template <typename T, template<typename> class vecType>
T simplex(
vecType<T> const & p);
//! Simplex noise.
//! From GLM_GTX_noise extension.
template <typename T, template<typename> class vecType>
T simplex(
vecType<T> const & p);
///@}
}//namespace noise
}//namespace gtx
/// @}
}//namespace noise
}//namespace gtx
}//namespace glm
#include "noise.inl"

187
glm/gtx/norm.hpp
View File

@ -25,118 +25,115 @@
# pragma message("GLM: GLM_GTX_norm extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace norm ///< GLM_GTX_norm extension: Various way to compute vector norms.
{
namespace gtx{
//! GLM_GTX_norm extension: Various way to compute vector norms.
namespace norm
{
/// \addtogroup gtx_norm
///@{
/// \addtogroup gtx_norm
/// @{
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename T>
T length2(
const T x);
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename T>
T length2(
const T x);
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename T>
T length2(
const detail::tvec2<T> & x);
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename T>
T length2(
const detail::tvec2<T> & x);
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename T>
T length2(
const detail::tvec3<T>& x);
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename T>
T length2(
const detail::tvec3<T>& x);
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename T>
T length2(
const detail::tvec4<T>& x);
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename T>
T length2(
const detail::tvec4<T>& x);
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename T>
T length2(
const detail::tquat<T>& q);
//! Returns the squared length of x.
//! From GLM_GTX_norm extension.
template <typename T>
T length2(
const detail::tquat<T>& q);
//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
//! From GLM_GTX_norm extension.
template <typename T>
T distance2(
const T p0,
const T p1);
//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
//! From GLM_GTX_norm extension.
template <typename T>
T distance2(
const T p0,
const T p1);
//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
//! From GLM_GTX_norm extension.
template <typename T>
T distance2(
const detail::tvec2<T>& p0,
const detail::tvec2<T>& p1);
//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
//! From GLM_GTX_norm extension.
template <typename T>
T distance2(
const detail::tvec2<T>& p0,
const detail::tvec2<T>& p1);
//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
//! From GLM_GTX_norm extension.
template <typename T>
T distance2(
const detail::tvec3<T>& p0,
const detail::tvec3<T>& p1);
//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
//! From GLM_GTX_norm extension.
template <typename T>
T distance2(
const detail::tvec3<T>& p0,
const detail::tvec3<T>& p1);
//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
//! From GLM_GTX_norm extension.
template <typename T>
T distance2(
const detail::tvec4<T>& p0,
const detail::tvec4<T>& p1);
//! Returns the squared distance between p0 and p1, i.e., length(p0 - p1).
//! From GLM_GTX_norm extension.
template <typename T>
T distance2(
const detail::tvec4<T>& p0,
const detail::tvec4<T>& p1);
//! Returns the L1 norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T>
T l1Norm(
const detail::tvec3<T>& x,
const detail::tvec3<T>& y);
//! Returns the L1 norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T>
T l1Norm(
const detail::tvec3<T>& x,
const detail::tvec3<T>& y);
//! Returns the L1 norm of v.
//! From GLM_GTX_norm extension.
template <typename T>
T l1Norm(
const detail::tvec3<T>& v);
//! Returns the L1 norm of v.
//! From GLM_GTX_norm extension.
template <typename T>
T l1Norm(
const detail::tvec3<T>& v);
//! Returns the L2 norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T>
T l2Norm(
const detail::tvec3<T>& x,
const detail::tvec3<T>& y);
//! Returns the L2 norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T>
T l2Norm(
const detail::tvec3<T>& x,
const detail::tvec3<T>& y);
//! Returns the L2 norm of v.
//! From GLM_GTX_norm extension.
template <typename T>
T l2Norm(
const detail::tvec3<T>& x);
//! Returns the L2 norm of v.
//! From GLM_GTX_norm extension.
template <typename T>
T l2Norm(
const detail::tvec3<T>& x);
//! Returns the L norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T>
T lxNorm(
const detail::tvec3<T>& x,
const detail::tvec3<T>& y,
unsigned int Depth);
//! Returns the L norm between x and y.
//! From GLM_GTX_norm extension.
template <typename T>
T lxNorm(
const detail::tvec3<T>& x,
const detail::tvec3<T>& y,
unsigned int Depth);
//! Returns the L norm of v.
//! From GLM_GTX_norm extension.
template <typename T>
T lxNorm(
const detail::tvec3<T>& x,
unsigned int Depth);
//! Returns the L norm of v.
//! From GLM_GTX_norm extension.
template <typename T>
T lxNorm(
const detail::tvec3<T>& x,
unsigned int Depth);
///@}
}//namespace norm
}//namespace gtx
/// @}
}//namespace norm
}//namespace gtx
}//namespace glm
#include "norm.inl"

33
glm/gtx/normal.hpp
View File

@ -20,27 +20,24 @@
# pragma message("GLM: GLM_GTX_normal extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace normal ///< GLM_GTX_normal extension: Compute the normal of a triangle.
{
namespace gtx{
//! GLM_GTX_normal extension: Compute the normal of a triangle.
namespace normal
{
/// \addtogroup gtx_normal
///@{
/// \addtogroup gtx_normal
/// @{
//! Computes triangle normal from triangle points.
//! From GLM_GTX_normal extension.
template <typename T>
detail::tvec3<T> triangleNormal(
detail::tvec3<T> const & p1,
detail::tvec3<T> const & p2,
detail::tvec3<T> const & p3);
//! Computes triangle normal from triangle points.
//! From GLM_GTX_normal extension.
template <typename T>
detail::tvec3<T> triangleNormal(
detail::tvec3<T> const & p1,
detail::tvec3<T> const & p2,
detail::tvec3<T> const & p3);
///@}
}//namespace normal
}//namespace gtx
/// @}
}//namespace normal
}//namespace gtx
}//namespace glm
#include "normal.inl"

49
glm/gtx/normalize_dot.hpp
View File

@ -22,37 +22,34 @@
# pragma message("GLM: GLM_GTX_normalize_dot extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace normalize_dot ///< GLM_GTX_normalize_dot extension: Dot product of vectors that need to be normalize with a single square root.
{
namespace gtx{
//! GLM_GTX_normalize_dot extension: Dot product of vectors that need to be normalize with a single square root.
namespace normalize_dot
{
using namespace gtx::fast_square_root;
using namespace gtx::fast_square_root;
/// \addtogroup gtx_normalize_dot
///@{
/// \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.
template <typename genType>
typename genType::value_type normalizeDot(
genType const & x,
genType const & y);
//! 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.
template <typename genType>
typename genType::value_type normalizeDot(
genType const & x,
genType const & y);
//! Normalize parameters and returns the dot product of x and y.
//! Faster that dot(fastNormalize(x), fastNormalize(y)).
//! From GLM_GTX_normalize_dot extension.
template <typename genType>
typename genType::value_type fastNormalizeDot(
genType const & x,
genType const & y);
//! Normalize parameters and returns the dot product of x and y.
//! Faster that dot(fastNormalize(x), fastNormalize(y)).
//! From GLM_GTX_normalize_dot extension.
template <typename genType>
typename genType::value_type fastNormalizeDot(
genType const & x,
genType const & y);
///@}
}//namespace normalize_dot
}//namespace gtx
/// @}
}//namespace normalize_dot
}//namespace gtx
}//namespace glm
#include "normalize_dot.inl"

7
glm/gtx/number_precision.hpp
View File

@ -25,8 +25,7 @@
namespace glm{
namespace gtx{
//! GLM_GTX_number_precision extension: Defined size types.
namespace number_precision
namespace number_precision ///< GLM_GTX_number_precision extension: Defined size types.
{
using namespace gtc::type_precision;
@ -34,7 +33,7 @@ namespace number_precision
// Unsigned int vector types
/// \addtogroup gtx_number_precision
///@{
/// @{
typedef u8 u8vec1; //!< \brief 8bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
typedef u16 u16vec1; //!< \brief 16bit unsigned integer scalar. (from GLM_GTX_number_precision extension)
@ -58,7 +57,7 @@ namespace number_precision
typedef f64 f64mat1; //!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
typedef f64 f64mat1x1; //!< \brief Double-precision floating-point scalar. (from GLM_GTX_number_precision extension)
///@}
/// @}
}//namespace number_precision
}//namespace gtx
}//namespace glm

8
glm/gtx/ocl_type.hpp
View File

@ -22,14 +22,13 @@
namespace glm{
namespace gtx{
//! GLM_GTX_ocl_type extension: OpenCL types.
namespace ocl_type
namespace ocl_type ///< GLM_GTX_ocl_type extension: OpenCL types.
{
///////////////////////////
// Scalar types
/// \addtogroup gtx_ocl_type
///@{
/// @{
typedef detail::int8 cl_char; //!< \brief 8bit signed integer. (from GLM_GTX_ocl_type extension)
typedef detail::int16 cl_short; //!< \brief 16bit signed integer. (from GLM_GTX_ocl_type extension)
@ -99,8 +98,7 @@ namespace ocl_type
//typedef detail::tvec4<detail::float16> cl_half4; //!< \brief Half-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
typedef detail::tvec4<detail::float32> cl_float4; //!< \brief Single-precision floating-point scalar. (from GLM_GTX_ocl_type extension)
///@}
/// @}
}//namespace ocl_type
}//namespace gtx
}//namespace glm

67
glm/gtx/optimum_pow.hpp
View File

@ -20,50 +20,47 @@
# pragma message("GLM: GLM_GTX_optimum_pow extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace optimum_pow ///< GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
{
namespace gtx{
//! GLM_GTX_optimum_pow extension: Integer exponentiation of power functions.
namespace optimum_pow
{
/// \addtogroup gtx_optimum_pow
///@{
/// \addtogroup gtx_optimum_pow
/// @{
//! Returns x raised to the power of 2.
//! From GLM_GTX_optimum_pow extension.
template <typename genType>
genType pow2(const genType& x);
//! Returns x raised to the power of 2.
//! From GLM_GTX_optimum_pow extension.
template <typename genType>
genType pow2(const genType& x);
//! Returns x raised to the power of 3.
//! From GLM_GTX_optimum_pow extension.
template <typename genType>
genType pow3(const genType& x);
//! Returns x raised to the power of 3.
//! From GLM_GTX_optimum_pow extension.
template <typename genType>
genType pow3(const genType& x);
//! Returns x raised to the power of 4.
//! From GLM_GTX_optimum_pow extension.
template <typename genType>
genType pow4(const genType& x);
//! Returns x raised to the power of 4.
//! From GLM_GTX_optimum_pow extension.
template <typename genType>
genType pow4(const genType& x);
//! Checks if the parameter is a power of 2 number.
//! From GLM_GTX_optimum_pow extension.
bool powOfTwo(int num);
//! Checks if the parameter is a power of 2 number.
//! From GLM_GTX_optimum_pow extension.
bool powOfTwo(int num);
//! Checks to determine if the parameter component are power of 2 numbers.
//! From GLM_GTX_optimum_pow extension.
detail::tvec2<bool> powOfTwo(const detail::tvec2<int>& x);
//! Checks to determine if the parameter component are power of 2 numbers.
//! From GLM_GTX_optimum_pow extension.
detail::tvec2<bool> powOfTwo(const detail::tvec2<int>& x);
//! Checks to determine if the parameter component are power of 2 numbers.
//! From GLM_GTX_optimum_pow extension.
detail::tvec3<bool> powOfTwo(const detail::tvec3<int>& x);
//! Checks to determine if the parameter component are power of 2 numbers.
//! From GLM_GTX_optimum_pow extension.
detail::tvec3<bool> powOfTwo(const detail::tvec3<int>& x);
//! Checks to determine if the parameter component are power of 2 numbers.
//! From GLM_GTX_optimum_pow extension.
detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
//! Checks to determine if the parameter component are power of 2 numbers.
//! From GLM_GTX_optimum_pow extension.
detail::tvec4<bool> powOfTwo(const detail::tvec4<int>& x);
///@}
}//namespace optimum_pow
}//namespace gtx
/// @}
}//namespace optimum_pow
}//namespace gtx
}//namespace glm
#include "optimum_pow.inl"

41
glm/gtx/orthonormalize.hpp
View File

@ -20,32 +20,29 @@
# pragma message("GLM: GLM_GTX_orthonormalize extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace orthonormalize ///< GLM_GTX_orthonormalize extension: Orthonormalize matrices.
{
namespace gtx{
//! GLM_GTX_orthonormalize extension: Orthonormalize matrices.
namespace orthonormalize
{
/// \addtogroup gtx_orthonormalize
///@{
/// \addtogroup gtx_orthonormalize
/// @{
//! Returns the orthonormalized matrix of m.
//! From GLM_GTX_orthonormalize extension.
template <typename T>
detail::tmat3x3<T> orthonormalize(
const detail::tmat3x3<T>& m);
//! Returns the orthonormalized matrix of m.
//! From GLM_GTX_orthonormalize extension.
template <typename T>
detail::tmat3x3<T> orthonormalize(
const detail::tmat3x3<T>& m);
//! Orthonormalizes x according y.
//! From GLM_GTX_orthonormalize extension.
template <typename T>
detail::tvec3<T> orthonormalize(
const detail::tvec3<T>& x,
const detail::tvec3<T>& y);
//! Orthonormalizes x according y.
//! From GLM_GTX_orthonormalize extension.
template <typename T>
detail::tvec3<T> orthonormalize(
const detail::tvec3<T>& x,
const detail::tvec3<T>& y);
///@}
}//namespace orthonormalize
}//namespace gtx
/// @}
}//namespace orthonormalize
}//namespace gtx
}//namespace glm
#include "orthonormalize.inl"

56
glm/gtx/perpendicular.hpp
View File

@ -22,41 +22,37 @@
# pragma message("GLM: GLM_GTX_perpendicular extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace perpendicular ///< GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
{
namespace gtx{
//! GLM_GTX_perpendicular extension: Perpendicular of a vector from other one
namespace perpendicular
{
/// \addtogroup gtx_perpendicular
///@{
/// \addtogroup gtx_perpendicular
/// @{
//! Projects x a perpendicular axis of Normal.
//! From GLM_GTX_perpendicular extension.
template <typename T>
detail::tvec2<T> perp(
detail::tvec2<T> const & x,
detail::tvec2<T> const & Normal);
//! Projects x a perpendicular axis of Normal.
//! From GLM_GTX_perpendicular extension.
template <typename T>
detail::tvec2<T> perp(
detail::tvec2<T> const & x,
detail::tvec2<T> const & Normal);
//! Projects x a perpendicular axis of Normal.
//! From GLM_GTX_perpendicular extension.
template <typename T>
detail::tvec3<T> perp(
detail::tvec3<T> const & x,
detail::tvec3<T> const & Normal);
//! Projects x a perpendicular axis of Normal.
//! From GLM_GTX_perpendicular extension.
template <typename T>
detail::tvec3<T> perp(
detail::tvec3<T> const & x,
detail::tvec3<T> const & Normal);
//! Projects x a perpendicular axis of Normal.
//! From GLM_GTX_perpendicular extension.
template <typename T>
detail::tvec4<T> perp(
detail::tvec4<T> const & x,
detail::tvec4<T> const & Normal);
//! Projects x a perpendicular axis of Normal.
//! From GLM_GTX_perpendicular extension.
template <typename T>
detail::tvec4<T> perp(
detail::tvec4<T> const & x,
detail::tvec4<T> const & Normal);
///@}
}//namespace perpendicular
}//namespace gtx
/// @}
}//namespace perpendicular
}//namespace gtx
}//namespace glm
#include "perpendicular.inl"

35
glm/gtx/polar_coordinates.hpp
View File

@ -20,29 +20,26 @@
# pragma message("GLM: GLM_GTX_polar_coordinates extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace polar_coordinates ///< GLM_GTX_polar_coordinates extension: Conversion from Euclidean space to polar space and revert.
{
namespace gtx{
//! GLM_GTX_polar_coordinates extension: Conversion from Euclidean space to polar space and revert.
namespace polar_coordinates
{
/// \addtogroup gtx_polar_coordinates
///@{
/// \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>
detail::tvec3<T> polar(const detail::tvec3<T>& euclidean);
//! 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>
detail::tvec3<T> polar(const detail::tvec3<T>& euclidean);
//! Convert Polar to Euclidean coordinates.
//! From GLM_GTX_polar_coordinates extension.
template <typename T>
detail::tvec3<T> euclidean(const detail::tvec3<T>& polar);
//! Convert Polar to Euclidean coordinates.
//! From GLM_GTX_polar_coordinates extension.
template <typename T>
detail::tvec3<T> euclidean(const detail::tvec3<T>& polar);
///@}
}//namespace polar_coordinates
}//namespace gtx
/// @}
}//namespace polar_coordinates
}//namespace gtx
}//namespace glm
#include "polar_coordinates.inl"

55
glm/gtx/projection.hpp
View File

@ -20,40 +20,37 @@
# pragma message("GLM: GLM_GTX_projection extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace projection ///< GLM_GTX_projection extension: Projection of a vector to other one
{
namespace gtx{
//! GLM_GTX_projection extension: Projection of a vector to other one
namespace projection
{
/// \addtogroup gtx_projection
///@{
/// \addtogroup gtx_projection
/// @{
//! Projects x on Normal.
//! From GLM_GTX_projection extension.
template <typename T>
detail::tvec2<T> proj(
detail::tvec2<T> const & x,
detail::tvec2<T> const & Normal);
//! Projects x on Normal.
//! From GLM_GTX_projection extension.
template <typename T>
detail::tvec2<T> proj(
detail::tvec2<T> const & x,
detail::tvec2<T> const & Normal);
//! Projects x on Normal.
//! From GLM_GTX_projection extension.
template <typename T>
detail::tvec3<T> proj(
detail::tvec3<T> const & x,
detail::tvec3<T> const & Normal);
//! Projects x on Normal.
//! From GLM_GTX_projection extension.
template <typename T>
detail::tvec3<T> proj(
detail::tvec3<T> const & x,
detail::tvec3<T> const & Normal);
//! Projects x on Normal.
//! From GLM_GTX_projection extension.
template <typename T>
detail::tvec4<T> proj(
detail::tvec4<T> const & x,
detail::tvec4<T> const & Normal);
//! Projects x on Normal.
//! From GLM_GTX_projection extension.
template <typename T>
detail::tvec4<T> proj(
detail::tvec4<T> const & x,
detail::tvec4<T> const & Normal);
///@}
}//namespace projection
}//namespace gtx
/// @}
}//namespace projection
}//namespace gtx
}//namespace glm
#include "projection.inl"

313
glm/gtx/quaternion.hpp
View File

@ -25,192 +25,189 @@
# pragma message("GLM: GLM_GTX_quaternion extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace quaternion ///< GLM_GTX_quaternion extension: Quaternion types and functions
{
namespace gtx{
//! GLM_GTX_quaternion extension: Quaternion types and functions
namespace quaternion
{
using namespace gtc::quaternion;
using namespace gtc::quaternion;
/// \addtogroup gtx_quaternion
///@{
/// \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(
detail::tquat<valType> const & q,
detail::tvec3<valType> const & v);
//! Compute a cross product between a quaternion and a vector.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tvec3<valType> cross(
detail::tquat<valType> const & q,
detail::tvec3<valType> const & v);
//! Compute a cross product between a vector and a quaternion.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tvec3<valType> cross(
detail::tvec3<valType> const & v,
detail::tquat<valType> const & q);
//! Compute a cross product between a vector and a quaternion.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tvec3<valType> cross(
detail::tvec3<valType> const & v,
detail::tquat<valType> const & q);
//! Compute a point on a path according squad equation.
//! q1 and q2 are control points; s1 and s2 are intermediate control points.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> squad(
detail::tquat<valType> const & q1,
detail::tquat<valType> const & q2,
detail::tquat<valType> const & s1,
detail::tquat<valType> const & s2,
valType const & h);
//! Compute a point on a path according squad equation.
//! q1 and q2 are control points; s1 and s2 are intermediate control points.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> squad(
detail::tquat<valType> const & q1,
detail::tquat<valType> const & q2,
detail::tquat<valType> const & s1,
detail::tquat<valType> const & s2,
valType const & h);
//! Returns an intermediate control point for squad interpolation.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> intermediate(
detail::tquat<valType> const & prev,
detail::tquat<valType> const & curr,
detail::tquat<valType> const & next);
//! Returns an intermediate control point for squad interpolation.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> intermediate(
detail::tquat<valType> const & prev,
detail::tquat<valType> const & curr,
detail::tquat<valType> const & next);
//! Returns a exp of a quaternion.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> exp(
detail::tquat<valType> const & q,
valType const & exponent);
//! Returns a exp of a quaternion.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> exp(
detail::tquat<valType> const & q,
valType const & exponent);
//! Returns a log of a quaternion.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> log(
detail::tquat<valType> const & q);
//! Returns a log of a quaternion.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> log(
detail::tquat<valType> const & q);
//! Returns x raised to the y power.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> pow(
detail::tquat<valType> const & x,
valType const & y);
//! Returns x raised to the y power.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> pow(
detail::tquat<valType> const & x,
valType const & y);
//! Returns quarternion square root.
//! From GLM_GTX_quaternion extension.
//template <typename valType>
//detail::tquat<valType> sqrt(
// detail::tquat<valType> const & q);
//! Returns quarternion square root.
//! From GLM_GTX_quaternion extension.
//template <typename valType>
//detail::tquat<valType> sqrt(
// detail::tquat<valType> const & q);
//! Rotates a 3 components vector by a quaternion.
//! From GLM_GTX_transform extension.
template <typename valType>
detail::tvec3<valType> rotate(
detail::tquat<valType> const & q,
detail::tvec3<valType> const & v);
//! Rotates a 3 components vector by a quaternion.
//! From GLM_GTX_transform extension.
template <typename valType>
detail::tvec3<valType> rotate(
detail::tquat<valType> const & q,
detail::tvec3<valType> const & v);
//! Rotates a 4 components vector by a quaternion.
//! From GLM_GTX_transform extension.
template <typename valType>
detail::tvec4<valType> rotate(
detail::tquat<valType> const & q,
detail::tvec4<valType> const & v);
//! Rotates a 4 components vector by a quaternion.
//! From GLM_GTX_transform extension.
template <typename valType>
detail::tvec4<valType> rotate(
detail::tquat<valType> const & q,
detail::tvec4<valType> const & v);
//! Returns the quaternion rotation angle.
//! From GLM_GTX_quaternion extension.
template <typename valType>
valType angle(
detail::tquat<valType> const & x);
//! Returns the quaternion rotation angle.
//! From GLM_GTX_quaternion extension.
template <typename valType>
valType angle(
detail::tquat<valType> const & x);
//! Returns the q rotation axis.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tvec3<valType> axis(
detail::tquat<valType> const & x);
//! Returns the q rotation axis.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tvec3<valType> axis(
detail::tquat<valType> const & x);
//! Build a quaternion from an angle and a normalized axis.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> angleAxis(
valType const & angle,
valType const & x,
valType const & y,
valType const & z);
//! Build a quaternion from an angle and a normalized axis.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> angleAxis(
valType const & angle,
valType const & x,
valType const & y,
valType const & z);
//! Build a quaternion from an angle and a normalized axis.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> angleAxis(
valType const & angle,
detail::tvec3<valType> const & axis);
//! Build a quaternion from an angle and a normalized axis.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> angleAxis(
valType const & angle,
detail::tvec3<valType> const & axis);
//! Extract the real component of a quaternion.
//! From GLM_GTX_quaternion extension.
template <typename valType>
valType extractRealComponent(
detail::tquat<valType> const & q);
//! Extract the real component of a quaternion.
//! From GLM_GTX_quaternion extension.
template <typename valType>
valType extractRealComponent(
detail::tquat<valType> const & q);
//! Returns roll value of euler angles.
//! From GLM_GTX_quaternion extension.
template <typename valType>
valType roll(
detail::tquat<valType> const & x);
//! Returns roll value of euler angles.
//! From GLM_GTX_quaternion extension.
template <typename valType>
valType roll(
detail::tquat<valType> const & x);
//! Returns pitch value of euler angles.
//! From GLM_GTX_quaternion extension.
template <typename valType>
valType pitch(
detail::tquat<valType> const & x);
//! Returns pitch value of euler angles.
//! From GLM_GTX_quaternion extension.
template <typename valType>
valType pitch(
detail::tquat<valType> const & x);
//! Returns yaw value of euler angles.
//! From GLM_GTX_quaternion extension.
template <typename valType>
valType yaw(
detail::tquat<valType> const & x);
//! Returns yaw value of euler angles.
//! From GLM_GTX_quaternion extension.
template <typename valType>
valType yaw(
detail::tquat<valType> const & x);
//! Returns euler angles, yitch as x, yaw as y, roll as z.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tvec3<valType> eularAngles(
detail::tquat<valType> const & x);
//! Returns euler angles, yitch as x, yaw as y, roll as z.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tvec3<valType> eularAngles(
detail::tquat<valType> const & x);
//! Converts a quaternion to a 3 * 3 matrix.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tmat3x3<valType> toMat3(
detail::tquat<valType> const & x){return gtc::quaternion::mat3_cast(x);}
//! Converts a quaternion to a 3 * 3 matrix.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tmat3x3<valType> toMat3(
detail::tquat<valType> const & x){return gtc::quaternion::mat3_cast(x);}
//! Converts a quaternion to a 4 * 4 matrix.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tmat4x4<valType> toMat4(
detail::tquat<valType> const & x){return gtc::quaternion::mat4_cast(x);}
//! Converts a quaternion to a 4 * 4 matrix.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tmat4x4<valType> toMat4(
detail::tquat<valType> const & x){return gtc::quaternion::mat4_cast(x);}
//! Converts a 3 * 3 matrix to a quaternion.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> toQuat(
detail::tmat3x3<valType> const & x){return gtc::quaternion::quat_cast(x);}
//! Converts a 3 * 3 matrix to a quaternion.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> toQuat(
detail::tmat3x3<valType> const & x){return gtc::quaternion::quat_cast(x);}
//! Converts a 4 * 4 matrix to a quaternion.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> toQuat(
detail::tmat4x4<valType> const & x){return gtc::quaternion::quat_cast(x);}
//! Converts a 4 * 4 matrix to a quaternion.
//! From GLM_GTX_quaternion extension.
template <typename valType>
detail::tquat<valType> toQuat(
detail::tmat4x4<valType> const & x){return gtc::quaternion::quat_cast(x);}
//! Quaternion interpolation using the rotation short path.
//! From GLM_GTX_quaternion extension.
template <typename T>
detail::tquat<T> shortMix(
detail::tquat<T> const & x,
detail::tquat<T> const & y,
T const & a);
//! Quaternion interpolation using the rotation short path.
//! From GLM_GTX_quaternion extension.
template <typename T>
detail::tquat<T> shortMix(
detail::tquat<T> const & x,
detail::tquat<T> const & y,
T const & a);
//! Quaternion normalized linear interpolation.
//! From GLM_GTX_quaternion extension.
template <typename T>
detail::tquat<T> fastMix(
detail::tquat<T> const & x,
detail::tquat<T> const & y,
T const & a);
//! Quaternion normalized linear interpolation.
//! From GLM_GTX_quaternion extension.
template <typename T>
detail::tquat<T> fastMix(
detail::tquat<T> const & x,
detail::tquat<T> const & y,
T const & a);
///@}
}//namespace quaternion
}//namespace gtx
/// @}
}//namespace quaternion
}//namespace gtx
} //namespace glm
#include "quaternion.inl"

5
glm/gtx/random.hpp
View File

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

44
glm/gtx/raw_data.hpp
View File

@ -22,36 +22,34 @@
#endif
namespace glm{
namespace gtx
namespace gtx{
namespace raw_data ///< GLM_GTX_raw_data extension: Projection of a vector to other one
{
//! GLM_GTX_raw_data extension: Projection of a vector to other one
namespace raw_data
{
using namespace gtc::type_precision;
using namespace gtc::type_precision;
/// \addtogroup gtx_raw_data
///@{
/// \addtogroup gtx_raw_data
///@{
//! Type for byte numbers.
//! From GLM_GTX_raw_data extension.
typedef uint8 byte;
//! Type for byte numbers.
//! From GLM_GTX_raw_data extension.
typedef uint8 byte;
//! Type for word numbers.
//! From GLM_GTX_raw_data extension.
typedef uint16 word;
//! Type for word numbers.
//! From GLM_GTX_raw_data extension.
typedef uint16 word;
//! Type for dword numbers.
//! From GLM_GTX_raw_data extension.
typedef uint32 dword;
//! Type for dword numbers.
//! From GLM_GTX_raw_data extension.
typedef uint32 dword;
//! Type for qword numbers.
//! From GLM_GTX_raw_data extension.
typedef uint64 qword;
//! Type for qword numbers.
//! From GLM_GTX_raw_data extension.
typedef uint64 qword;
///@}
}
}//namespace gtx
}//namespace glm
///@}
}// namespace raw_data
}// namespace gtx
}// namespace glm
#include "raw_data.inl"

121
glm/gtx/reciprocal.hpp
View File

@ -17,82 +17,79 @@
# pragma message("GLM: GLM_GTX_reciprocal extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace reciprocal ///< GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
{
namespace gtx{
//! GLM_GTX_reciprocal extension: Define secant, cosecant and cotangent functions.
namespace reciprocal
{
/// \addtogroup gtx_reciprocal
///@{
/// \addtogroup gtx_reciprocal
/// @{
//! Secant function.
//! hypotenuse / adjacent or 1 / cos(x)
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType sec(genType const & angle);
//! Secant function.
//! hypotenuse / adjacent or 1 / cos(x)
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType sec(genType const & angle);
//! Cosecant function.
//! hypotenuse / opposite or 1 / sin(x)
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType csc(genType const & angle);
//! Cosecant function.
//! hypotenuse / opposite or 1 / sin(x)
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType csc(genType const & angle);
//! Cotangent function.
//! adjacent / opposite or 1 / tan(x)
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType cot(genType const & angle);
//! Cotangent function.
//! adjacent / opposite or 1 / tan(x)
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType cot(genType const & angle);
//! Inverse secant function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType asec(genType const & x);
//! Inverse secant function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType asec(genType const & x);
//! Inverse cosecant function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType acsc(genType const & x);
//! Inverse cosecant function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType acsc(genType const & x);
//! Inverse cotangent function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType acot(genType const & x);
//! Inverse cotangent function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType acot(genType const & x);
//! Secant hyperbolic function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType sech(genType const & angle);
//! Secant hyperbolic function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType sech(genType const & angle);
//! Cosecant hyperbolic function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType csch(genType const & angle);
//! Cosecant hyperbolic function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType csch(genType const & angle);
//! Cotangent hyperbolic function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType coth(genType const & angle);
//! Cotangent hyperbolic function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType coth(genType const & angle);
//! Inverse secant hyperbolic function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType asech(genType const & x);
//! Inverse secant hyperbolic function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType asech(genType const & x);
//! Inverse cosecant hyperbolic function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType acsch(genType const & x);
//! Inverse cosecant hyperbolic function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType acsch(genType const & x);
//! Inverse cotangent hyperbolic function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType acoth(genType const & x);
//! Inverse cotangent hyperbolic function.
//! From GLM_GTX_reciprocal extension.
template <typename genType>
genType acoth(genType const & x);
///@}
}//namespace reciprocal
}//namespace gtx
/// @}
}//namespace reciprocal
}//namespace gtx
}//namespace glm
#include "reciprocal.inl"

136
glm/gtx/rotate_vector.hpp
View File

@ -23,88 +23,86 @@
namespace glm{
namespace gtx{
//! GLM_GTX_rotate_vector extension: Function to directly rotate a vector
namespace rotate_vector
namespace rotate_vector ///< GLM_GTX_rotate_vector extension: Function to directly rotate a vector
{
using namespace transform;
using namespace transform;
/// \addtogroup gtx_rotate_vector
///@{
/// \addtogroup gtx_rotate_vector
/// @{
//! Rotate a two dimensional vector.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec2<T> rotate(
detail::tvec2<T> const & v,
T const & angle);
//! Rotate a two dimensional vector.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec2<T> rotate(
detail::tvec2<T> const & v,
T const & angle);
//! Rotate a three dimensional vector around an axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec3<T> rotate(
detail::tvec3<T> const & v,
T const & angle,
detail::tvec3<T> const & normal);
//! Rotate a three dimensional vector around an axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec3<T> rotate(
detail::tvec3<T> const & v,
T const & angle,
detail::tvec3<T> const & normal);
//! Rotate a four dimensional vector around an axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec4<T> rotate(
detail::tvec4<T> const & v,
T const & angle,
detail::tvec3<T> const & normal);
//! Rotate a four dimensional vector around an axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec4<T> rotate(
detail::tvec4<T> const & v,
T const & angle,
detail::tvec3<T> const & normal);
//! Rotate a three dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec3<T> rotateX(
detail::tvec3<T> const & v,
T const & angle);
//! Rotate a three dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec3<T> rotateX(
detail::tvec3<T> const & v,
T const & angle);
//! Rotate a three dimensional vector around the Y axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec3<T> rotateY(
detail::tvec3<T> const & v,
T const & angle);
//! Rotate a three dimensional vector around the Y axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec3<T> rotateY(
detail::tvec3<T> const & v,
T const & angle);
//! Rotate a three dimensional vector around the Z axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec3<T> rotateZ(
detail::tvec3<T> const & v,
T const & angle);
//! Rotate a three dimensional vector around the Z axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec3<T> rotateZ(
detail::tvec3<T> const & v,
T const & angle);
//! Rotate a four dimentionnals vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec4<T> rotateX(
detail::tvec4<T> const & v,
T const & angle);
//! Rotate a four dimentionnals vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec4<T> rotateX(
detail::tvec4<T> const & v,
T const & angle);
//! Rotate a four dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec4<T> rotateY(
detail::tvec4<T> const & v,
T const & angle);
//! Rotate a four dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec4<T> rotateY(
detail::tvec4<T> const & v,
T const & angle);
//! Rotate a four dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec4<T> rotateZ(
detail::tvec4<T> const & v,
T const & angle);
//! Rotate a four dimensional vector around the X axis.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tvec4<T> rotateZ(
detail::tvec4<T> const & v,
T const & angle);
//! Build a rotation matrix from a normal and a up vector.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tmat4x4<T> orientation(
detail::tvec3<T> const & Normal,
detail::tvec3<T> const & Up);
//! Build a rotation matrix from a normal and a up vector.
//! From GLM_GTX_rotate_vector extension.
template <typename T>
detail::tmat4x4<T> orientation(
detail::tvec3<T> const & Normal,
detail::tvec3<T> const & Up);
///@}
/// @}
}//namespace rotate_vector
}//namespace gtx
}//namespace glm

242
glm/gtx/simd_mat4.hpp
View File

@ -28,157 +28,153 @@
# pragma message("GLM: GLM_GTX_simd_mat4 extension included")
#endif
namespace glm
namespace glm{
namespace detail
{
namespace detail
/// 4x4 Matrix implemented using SIMD SEE intrinsics.
/// \ingroup gtx_simd_mat4
GLM_ALIGNED_STRUCT(16) fmat4x4SIMD
{
/// 4x4 Matrix implemented using SIMD SEE intrinsics.
/// \ingroup gtx_simd_mat4
GLM_ALIGNED_STRUCT(16) fmat4x4SIMD
{
enum ctor{null};
enum ctor{null};
typedef float value_type;
typedef fvec4SIMD col_type;
typedef fvec4SIMD row_type;
typedef std::size_t size_type;
static size_type value_size();
static size_type col_size();
static size_type row_size();
static bool is_matrix();
typedef float value_type;
typedef fvec4SIMD col_type;
typedef fvec4SIMD row_type;
typedef std::size_t size_type;
static size_type value_size();
static size_type col_size();
static size_type row_size();
static bool is_matrix();
fvec4SIMD Data[4];
fvec4SIMD Data[4];
//////////////////////////////////////
// Constructors
//////////////////////////////////////
// Constructors
fmat4x4SIMD();
explicit fmat4x4SIMD(float const & s);
explicit fmat4x4SIMD(
float const & x0, float const & y0, float const & z0, float const & w0,
float const & x1, float const & y1, float const & z1, float const & w1,
float const & x2, float const & y2, float const & z2, float const & w2,
float const & x3, float const & y3, float const & z3, float const & w3);
explicit fmat4x4SIMD(
fvec4SIMD const & v0,
fvec4SIMD const & v1,
fvec4SIMD const & v2,
fvec4SIMD const & v3);
explicit fmat4x4SIMD(
tmat4x4<float> const & m);
fmat4x4SIMD();
explicit fmat4x4SIMD(float const & s);
explicit fmat4x4SIMD(
float const & x0, float const & y0, float const & z0, float const & w0,
float const & x1, float const & y1, float const & z1, float const & w1,
float const & x2, float const & y2, float const & z2, float const & w2,
float const & x3, float const & y3, float const & z3, float const & w3);
explicit fmat4x4SIMD(
fvec4SIMD const & v0,
fvec4SIMD const & v1,
fvec4SIMD const & v2,
fvec4SIMD const & v3);
explicit fmat4x4SIMD(
tmat4x4<float> const & m);
// Conversions
//template <typename U>
//explicit tmat4x4(tmat4x4<U> const & m);
// Conversions
//template <typename U>
//explicit tmat4x4(tmat4x4<U> const & m);
//explicit tmat4x4(tmat2x2<T> const & x);
//explicit tmat4x4(tmat3x3<T> const & x);
//explicit tmat4x4(tmat2x3<T> const & x);
//explicit tmat4x4(tmat3x2<T> const & x);
//explicit tmat4x4(tmat2x4<T> const & x);
//explicit tmat4x4(tmat4x2<T> const & x);
//explicit tmat4x4(tmat3x4<T> const & x);
//explicit tmat4x4(tmat4x3<T> const & x);
//explicit tmat4x4(tmat2x2<T> const & x);
//explicit tmat4x4(tmat3x3<T> const & x);
//explicit tmat4x4(tmat2x3<T> const & x);
//explicit tmat4x4(tmat3x2<T> const & x);
//explicit tmat4x4(tmat2x4<T> const & x);
//explicit tmat4x4(tmat4x2<T> const & x);
//explicit tmat4x4(tmat3x4<T> const & x);
//explicit tmat4x4(tmat4x3<T> const & x);
// Accesses
fvec4SIMD & operator[](size_type i);
fvec4SIMD const & operator[](size_type i) const;
// Accesses
fvec4SIMD & operator[](size_type i);
fvec4SIMD const & operator[](size_type i) const;
// Unary updatable operators
fmat4x4SIMD & operator= (fmat4x4SIMD const & m);
fmat4x4SIMD & operator+= (float const & s);
fmat4x4SIMD & operator+= (fmat4x4SIMD const & m);
fmat4x4SIMD & operator-= (float const & s);
fmat4x4SIMD & operator-= (fmat4x4SIMD const & m);
fmat4x4SIMD & operator*= (float const & s);
fmat4x4SIMD & operator*= (fmat4x4SIMD const & m);
fmat4x4SIMD & operator/= (float const & s);
fmat4x4SIMD & operator/= (fmat4x4SIMD const & m);
fmat4x4SIMD & operator++ ();
fmat4x4SIMD & operator-- ();
};
// Unary updatable operators
fmat4x4SIMD & operator= (fmat4x4SIMD const & m);
fmat4x4SIMD & operator+= (float const & s);
fmat4x4SIMD & operator+= (fmat4x4SIMD const & m);
fmat4x4SIMD & operator-= (float const & s);
fmat4x4SIMD & operator-= (fmat4x4SIMD const & m);
fmat4x4SIMD & operator*= (float const & s);
fmat4x4SIMD & operator*= (fmat4x4SIMD const & m);
fmat4x4SIMD & operator/= (float const & s);
fmat4x4SIMD & operator/= (fmat4x4SIMD const & m);
fmat4x4SIMD & operator++ ();
fmat4x4SIMD & operator-- ();
};
// Binary operators
fmat4x4SIMD operator+ (fmat4x4SIMD const & m, float const & s);
fmat4x4SIMD operator+ (float const & s, fmat4x4SIMD const & m);
fmat4x4SIMD operator+ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
// Binary operators
fmat4x4SIMD operator+ (fmat4x4SIMD const & m, float const & s);
fmat4x4SIMD operator+ (float const & s, fmat4x4SIMD const & m);
fmat4x4SIMD operator+ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
fmat4x4SIMD operator- (fmat4x4SIMD const & m, float const & s);
fmat4x4SIMD operator- (float const & s, fmat4x4SIMD const & m);
fmat4x4SIMD operator- (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
fmat4x4SIMD operator- (fmat4x4SIMD const & m, float const & s);
fmat4x4SIMD operator- (float const & s, fmat4x4SIMD const & m);
fmat4x4SIMD operator- (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
fmat4x4SIMD operator* (fmat4x4SIMD const & m, float const & s);
fmat4x4SIMD operator* (float const & s, fmat4x4SIMD const & m);
fmat4x4SIMD operator* (fmat4x4SIMD const & m, float const & s);
fmat4x4SIMD operator* (float const & s, fmat4x4SIMD const & m);
fvec4SIMD operator* (fmat4x4SIMD const & m, fvec4SIMD const & v);
fvec4SIMD operator* (fvec4SIMD const & v, fmat4x4SIMD const & m);
fvec4SIMD operator* (fmat4x4SIMD const & m, fvec4SIMD const & v);
fvec4SIMD operator* (fvec4SIMD const & v, fmat4x4SIMD const & m);
fmat4x4SIMD operator* (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
fmat4x4SIMD operator* (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
fmat4x4SIMD operator/ (fmat4x4SIMD const & m, float const & s);
fmat4x4SIMD operator/ (float const & s, fmat4x4SIMD const & m);
fmat4x4SIMD operator/ (fmat4x4SIMD const & m, float const & s);
fmat4x4SIMD operator/ (float const & s, fmat4x4SIMD const & m);
fvec4SIMD operator/ (fmat4x4SIMD const & m, fvec4SIMD const & v);
fvec4SIMD operator/ (fvec4SIMD const & v, fmat4x4SIMD const & m);
fvec4SIMD operator/ (fmat4x4SIMD const & m, fvec4SIMD const & v);
fvec4SIMD operator/ (fvec4SIMD const & v, fmat4x4SIMD const & m);
fmat4x4SIMD operator/ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
fmat4x4SIMD operator/ (fmat4x4SIMD const & m1, fmat4x4SIMD const & m2);
// Unary constant operators
fmat4x4SIMD const operator- (fmat4x4SIMD const & m);
fmat4x4SIMD const operator-- (fmat4x4SIMD const & m, int);
fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
// Unary constant operators
fmat4x4SIMD const operator- (fmat4x4SIMD const & m);
fmat4x4SIMD const operator-- (fmat4x4SIMD const & m, int);
fmat4x4SIMD const operator++ (fmat4x4SIMD const & m, int);
}//namespace detail
}//namespace detail
namespace gtx{
namespace simd_mat4 ///< GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
{
typedef detail::fmat4x4SIMD simdMat4;
namespace gtx{
//! GLM_GTX_simd_mat4 extension: SIMD implementation of mat4 type.
namespace simd_mat4
{
typedef detail::fmat4x4SIMD simdMat4;
/// \addtogroup gtx_simd_mat4
///@{
/// \addtogroup gtx_simd_mat4
///@{
//! Convert a simdMat4 to a mat4.
//! (From GLM_GTX_simd_mat4 extension)
detail::tmat4x4<float> mat4_cast(
detail::fmat4x4SIMD const & x);
//! Convert a simdMat4 to a mat4.
//! (From GLM_GTX_simd_mat4 extension)
detail::tmat4x4<float> mat4_cast(
detail::fmat4x4SIMD const & x);
//! 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 GLM_GTX_simd_mat4 extension).
detail::fmat4x4SIMD matrixCompMult(
detail::fmat4x4SIMD const & x,
detail::fmat4x4SIMD const & y);
//! 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 GLM_GTX_simd_mat4 extension).
detail::fmat4x4SIMD matrixCompMult(
detail::fmat4x4SIMD const & x,
detail::fmat4x4SIMD const & y);
//! Treats the first parameter c as a column vector
//! and the second parameter r as a row vector
//! and does a linear algebraic matrix multiply c * r.
//! (From GLM_GTX_simd_mat4 extension).
detail::fmat4x4SIMD outerProduct(
detail::fvec4SIMD const & c,
detail::fvec4SIMD const & r);
//! Treats the first parameter c as a column vector
//! and the second parameter r as a row vector
//! and does a linear algebraic matrix multiply c * r.
//! (From GLM_GTX_simd_mat4 extension).
detail::fmat4x4SIMD outerProduct(
detail::fvec4SIMD const & c,
detail::fvec4SIMD const & r);
//! Returns the transposed matrix of x
//! (From GLM_GTX_simd_mat4 extension).
detail::fmat4x4SIMD transpose(
detail::fmat4x4SIMD const & x);
//! Returns the transposed matrix of x
//! (From GLM_GTX_simd_mat4 extension).
detail::fmat4x4SIMD transpose(
detail::fmat4x4SIMD const & x);
//! Return the determinant of a mat4 matrix.
//! (From GLM_GTX_simd_mat4 extension).
float determinant(
detail::fmat4x4SIMD const & m);
//! Return the determinant of a mat4 matrix.
//! (From GLM_GTX_simd_mat4 extension).
float determinant(
detail::fmat4x4SIMD const & m);
//! Return the inverse of a mat4 matrix.
//! (From GLM_GTX_simd_mat4 extension).
detail::fmat4x4SIMD inverse(
detail::fmat4x4SIMD const & m);
//! Return the inverse of a mat4 matrix.
//! (From GLM_GTX_simd_mat4 extension).
detail::fmat4x4SIMD inverse(
detail::fmat4x4SIMD const & m);
///@}
}//namespace simd_mat4
}//namespace gtx
}//namespace glm
/// @}
}// namespace simd_mat4
}// namespace gtx
}// namespace glm
#include "simd_mat4.inl"

873
glm/gtx/simd_vec4.hpp
View File

@ -28,446 +28,443 @@
# pragma message("GLM: GLM_GTX_simd_vec4 extension included")
#endif
namespace glm
namespace glm{
namespace detail
{
namespace detail
/// 4-dimensional vector implemented using SIMD SEE intrinsics.
/// \ingroup gtx_simd_vec4
GLM_ALIGNED_STRUCT(4) fvec4SIMD
{
/// 4-dimensional vector implemented using SIMD SEE intrinsics.
/// \ingroup gtx_simd_vec4
GLM_ALIGNED_STRUCT(4) fvec4SIMD
{
enum ctor{null};
typedef __m128 value_type;
typedef std::size_t size_type;
static size_type value_size();
typedef fvec4SIMD type;
typedef tvec4<bool> bool_type;
__m128 Data;
//////////////////////////////////////
// Implicit basic constructors
fvec4SIMD();
fvec4SIMD(__m128 const & Data);
fvec4SIMD(fvec4SIMD const & v);
//////////////////////////////////////
// Explicit basic constructors
explicit fvec4SIMD(
ctor);
explicit fvec4SIMD(
float const & s);
explicit fvec4SIMD(
float const & x,
float const & y,
float const & z,
float const & w);
explicit fvec4SIMD(
tvec4<float> const & v);
////////////////////////////////////////
//// Convertion vector constructors
fvec4SIMD(vec2 const & v, float const & s1, float const & s2);
fvec4SIMD(float const & s1, vec2 const & v, float const & s2);
fvec4SIMD(float const & s1, float const & s2, vec2 const & v);
fvec4SIMD(vec3 const & v, float const & s);
fvec4SIMD(float const & s, vec3 const & v);
fvec4SIMD(vec2 const & v1, vec2 const & v2);
//fvec4SIMD(ivec4SIMD const & v);
//////////////////////////////////////
// Unary arithmetic operators
fvec4SIMD& operator= (fvec4SIMD const & v);
fvec4SIMD& operator+=(fvec4SIMD const & v);
fvec4SIMD& operator-=(fvec4SIMD const & v);
fvec4SIMD& operator*=(fvec4SIMD const & v);
fvec4SIMD& operator/=(fvec4SIMD const & v);
fvec4SIMD& operator+=(float const & s);
fvec4SIMD& operator-=(float const & s);
fvec4SIMD& operator*=(float const & s);
fvec4SIMD& operator/=(float const & s);
fvec4SIMD& operator++();
fvec4SIMD& operator--();
//////////////////////////////////////
// Swizzle operators
template <comp X, comp Y, comp Z, comp W>
fvec4SIMD& swizzle();
template <comp X, comp Y, comp Z, comp W>
fvec4SIMD swizzle() const;
template <comp X, comp Y, comp Z>
fvec4SIMD swizzle() const;
template <comp X, comp Y>
fvec4SIMD swizzle() const;
template <comp X>
fvec4SIMD swizzle() const;
};
}//namespace detail
namespace gtx{
//! GLM_GTX_simd_vec4 extension: SIMD implementation of vec4 type.
namespace simd_vec4
{
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(
detail::fvec4SIMD const & x);
//! Returns x if x >= 0; otherwise, it returns -x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD abs(detail::fvec4SIMD const & x);
//! Returns 1.0 if x > 0, 0.0 if x = 0, or -1.0 if x < 0.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD sign(detail::fvec4SIMD const & x);
//! Returns a value equal to the nearest integer that is less then or equal to x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD floor(detail::fvec4SIMD const & x);
//! Returns a value equal to the nearest integer to x
//! whose absolute value is not larger than the absolute value of x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD trunc(detail::fvec4SIMD const & x);
//! Returns a value equal to the nearest integer to x.
//! The fraction 0.5 will round in a direction chosen by the
//! implementation, presumably the direction that is fastest.
//! This includes the possibility that round(x) returns the
//! same value as roundEven(x) for all values of x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD round(detail::fvec4SIMD const & x);
//! Returns a value equal to the nearest integer to x.
//! A fractional part of 0.5 will round toward the nearest even
//! integer. (Both 3.5 and 4.5 for x will return 4.0.)
//! (From GLM_GTX_simd_vec4 extension, common function)
//detail::fvec4SIMD roundEven(detail::fvec4SIMD const & x);
//! Returns a value equal to the nearest integer
//! that is greater than or equal to x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD ceil(detail::fvec4SIMD const & x);
//! Return x - floor(x).
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD fract(detail::fvec4SIMD const & x);
//! Modulus. Returns x - y * floor(x / y)
//! for each component in x using the floating point value y.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD mod(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y);
//! Modulus. Returns x - y * floor(x / y)
//! for each component in x using the floating point value y.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD mod(
detail::fvec4SIMD const & x,
float const & y);
//! Returns the fractional part of x and sets i to the integer
//! part (as a whole number floating point value). Both the
//! return value and the output parameter will have the same
//! sign as x.
//! (From GLM_GTX_simd_vec4 extension, common function)
//detail::fvec4SIMD modf(
// detail::fvec4SIMD const & x,
// detail::fvec4SIMD & i);
//! Returns y if y < x; otherwise, it returns x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD min(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y);
detail::fvec4SIMD min(
detail::fvec4SIMD const & x,
float const & y);
//! Returns y if x < y; otherwise, it returns x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD max(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y);
detail::fvec4SIMD max(
detail::fvec4SIMD const & x,
float const & y);
//! Returns min(max(x, minVal), maxVal) for each component in x
//! using the floating-point values minVal and maxVal.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD clamp(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & minVal,
detail::fvec4SIMD const & maxVal);
detail::fvec4SIMD clamp(
detail::fvec4SIMD const & x,
float const & minVal,
float const & maxVal);
//! \return If genTypeU is a floating scalar or vector:
//! 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].
//!
//! \return If genTypeU is a boolean scalar or vector:
//! Selects which vector each returned component comes
//! from. For a component of a that is false, the
//! corresponding component of x is returned. For a
//! component of a that is true, the corresponding
//! component of y is returned. Components of x and y that
//! are not selected are allowed to be invalid floating point
//! values and will have no effect on the results. Thus, this
//! provides different functionality than
//! genType mix(genType x, genType y, genType(a))
//! where a is a Boolean vector.
//!
//! From GLSL 1.30.08 specification, section 8.3
//!
//! \param[in] x Floating point scalar or vector.
//! \param[in] y Floating point scalar or vector.
//! \param[in] a Floating point or boolean scalar or vector.
//!
// \todo Test when 'a' is a boolean.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD mix(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y,
detail::fvec4SIMD const & a);
//! Returns 0.0 if x < edge, otherwise it returns 1.0.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD step(
detail::fvec4SIMD const & edge,
detail::fvec4SIMD const & x);
detail::fvec4SIMD step(
float const & edge,
detail::fvec4SIMD const & x);
//! Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
//! performs smooth Hermite interpolation between 0 and 1
//! when edge0 < x < edge1. This is useful in cases where
//! you would want a threshold function with a smooth
//! transition. This is equivalent to:
//! genType t;
//! t = clamp ((x – edge0) / (edge1 – edge0), 0, 1);
//! return t * t * (3 – 2 * t);
//! Results are undefined if edge0 >= edge1.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD smoothstep(
detail::fvec4SIMD const & edge0,
detail::fvec4SIMD const & edge1,
detail::fvec4SIMD const & x);
detail::fvec4SIMD smoothstep(
float const & edge0,
float const & edge1,
detail::fvec4SIMD const & x);
//! Returns true if x holds a NaN (not a number)
//! representation in the underlying implementation's set of
//! floating point representations. Returns false otherwise,
//! including for implementations with no NaN
//! representations.
//! (From GLM_GTX_simd_vec4 extension, common function)
//bvec4 isnan(detail::fvec4SIMD const & x);
//! Returns true if x holds a positive infinity or negative
//! infinity representation in the underlying implementation's
//! set of floating point representations. Returns false
//! otherwise, including for implementations with no infinity
//! representations.
//! (From GLM_GTX_simd_vec4 extension, common function)
//bvec4 isinf(detail::fvec4SIMD const & x);
//! Returns a signed or unsigned integer value representing
//! the encoding of a floating-point value. The floatingpoint
//! value's bit-level representation is preserved.
//! (From GLM_GTX_simd_vec4 extension, common function)
//detail::ivec4SIMD floatBitsToInt(detail::fvec4SIMD const & value);
//! Returns a floating-point value corresponding to a signed
//! or unsigned integer encoding of a floating-point value.
//! If an inf or NaN is passed in, it will not signal, and the
//! resulting floating point value is unspecified. Otherwise,
//! the bit-level representation is preserved.
//! (From GLM_GTX_simd_vec4 extension, common function)
//detail::fvec4SIMD intBitsToFloat(detail::ivec4SIMD const & value);
//! Computes and returns a * b + c.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD fma(
detail::fvec4SIMD const & a,
detail::fvec4SIMD const & b,
detail::fvec4SIMD const & c);
//! Splits x into a floating-point significand in the range
//! [0.5, 1.0) and an integral exponent of two, such that:
//! x = significand * exp(2, exponent)
//! The significand is returned by the function and the
//! exponent is returned in the parameter exp. For a
//! floating-point value of zero, the significant and exponent
//! are both zero. For a floating-point value that is an
//! infinity or is not a number, the results are undefined.
//! (From GLM_GTX_simd_vec4 extension, common function)
//detail::fvec4SIMD frexp(detail::fvec4SIMD const & x, detail::ivec4SIMD & exp);
//! Builds a floating-point number from x and the
//! corresponding integral exponent of two in exp, returning:
//! significand * exp(2, exponent)
//! If this product is too large to be represented in the
//! floating-point type, the result is undefined.
//! (From GLM_GTX_simd_vec4 extension, common function)
//detail::fvec4SIMD ldexp(detail::fvec4SIMD const & x, detail::ivec4SIMD const & exp);
//! Returns the length of x, i.e., sqrt(x * x).
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
float length(
detail::fvec4SIMD const & x);
//! Returns the length of x, i.e., sqrt(x * x).
//! Less accurate but much faster than simdLength.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
float fastLength(
detail::fvec4SIMD const & x);
//! Returns the length of x, i.e., sqrt(x * x).
//! Slightly more accurate but much slower than simdLength.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
float niceLength(
detail::fvec4SIMD const & x);
//! Returns the length of x, i.e., sqrt(x * x).
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD length4(
detail::fvec4SIMD const & x);
//! Returns the length of x, i.e., sqrt(x * x).
//! Less accurate but much faster than simdLength4.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD fastLength4(
detail::fvec4SIMD const & x);
//! Returns the length of x, i.e., sqrt(x * x).
//! Slightly more accurate but much slower than simdLength4.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD niceLength4(
detail::fvec4SIMD const & x);
//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
float distance(
detail::fvec4SIMD const & p0,
detail::fvec4SIMD const & p1);
//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD distance4(
detail::fvec4SIMD const & p0,
detail::fvec4SIMD const & p1);
//! Returns the dot product of x and y, i.e., result = x * y.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
float simdDot(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y);
//! Returns the dot product of x and y, i.e., result = x * y.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD dot4(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y);
//! Returns the cross product of x and y.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD cross(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y);
//! Returns a vector in the same direction as x but with length of 1.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD normalize(
detail::fvec4SIMD const & x);
//! Returns a vector in the same direction as x but with length of 1.
//! Less accurate but much faster than simdNormalize.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD fastNormalize(
detail::fvec4SIMD const & x);
//! If dot(Nref, I) < 0.0, return N, otherwise, return -N.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD simdFaceforward(
detail::fvec4SIMD const & N,
detail::fvec4SIMD const & I,
detail::fvec4SIMD const & Nref);
//! For the incident vector I and surface orientation N,
//! returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD reflect(
detail::fvec4SIMD const & I,
detail::fvec4SIMD const & N);
//! For the incident vector I and surface normal N,
//! and the ratio of indices of refraction eta,
//! return the refraction vector.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD refract(
detail::fvec4SIMD const & I,
detail::fvec4SIMD const & N,
float const & eta);
//! Returns the positive square root of x.
//! (From GLM_GTX_simd_vec4 extension, exponential function)
detail::fvec4SIMD sqrt(
detail::fvec4SIMD const & x);
//! Returns the positive square root of x with the nicest quality but very slow.
//! Slightly more accurate but much slower than simdSqrt.
//! (From GLM_GTX_simd_vec4 extension, exponential function)
detail::fvec4SIMD niceSqrt(
detail::fvec4SIMD const & x);
//! Returns the positive square root of x
//! Less accurate but much faster than sqrt.
//! (From GLM_GTX_simd_vec4 extension, exponential function)
detail::fvec4SIMD fastSqrt(
detail::fvec4SIMD const & x);
//! Returns the reciprocal of the positive square root of x.
//! (From GLM_GTX_simd_vec4 extension, exponential function)
detail::fvec4SIMD inversesqrt(
detail::fvec4SIMD const & x);
//! Returns the reciprocal of the positive square root of x.
//! Faster than inversesqrt but less accurate.
//! (From GLM_GTX_simd_vec4 extension, exponential function)
detail::fvec4SIMD fastInversesqrt(
detail::fvec4SIMD const & x);
///@}
}//namespace simd_vec4
}//namespace gtx
enum ctor{null};
typedef __m128 value_type;
typedef std::size_t size_type;
static size_type value_size();
typedef fvec4SIMD type;
typedef tvec4<bool> bool_type;
__m128 Data;
//////////////////////////////////////
// Implicit basic constructors
fvec4SIMD();
fvec4SIMD(__m128 const & Data);
fvec4SIMD(fvec4SIMD const & v);
//////////////////////////////////////
// Explicit basic constructors
explicit fvec4SIMD(
ctor);
explicit fvec4SIMD(
float const & s);
explicit fvec4SIMD(
float const & x,
float const & y,
float const & z,
float const & w);
explicit fvec4SIMD(
tvec4<float> const & v);
////////////////////////////////////////
//// Convertion vector constructors
fvec4SIMD(vec2 const & v, float const & s1, float const & s2);
fvec4SIMD(float const & s1, vec2 const & v, float const & s2);
fvec4SIMD(float const & s1, float const & s2, vec2 const & v);
fvec4SIMD(vec3 const & v, float const & s);
fvec4SIMD(float const & s, vec3 const & v);
fvec4SIMD(vec2 const & v1, vec2 const & v2);
//fvec4SIMD(ivec4SIMD const & v);
//////////////////////////////////////
// Unary arithmetic operators
fvec4SIMD& operator= (fvec4SIMD const & v);
fvec4SIMD& operator+=(fvec4SIMD const & v);
fvec4SIMD& operator-=(fvec4SIMD const & v);
fvec4SIMD& operator*=(fvec4SIMD const & v);
fvec4SIMD& operator/=(fvec4SIMD const & v);
fvec4SIMD& operator+=(float const & s);
fvec4SIMD& operator-=(float const & s);
fvec4SIMD& operator*=(float const & s);
fvec4SIMD& operator/=(float const & s);
fvec4SIMD& operator++();
fvec4SIMD& operator--();
//////////////////////////////////////
// Swizzle operators
template <comp X, comp Y, comp Z, comp W>
fvec4SIMD& swizzle();
template <comp X, comp Y, comp Z, comp W>
fvec4SIMD swizzle() const;
template <comp X, comp Y, comp Z>
fvec4SIMD swizzle() const;
template <comp X, comp Y>
fvec4SIMD swizzle() const;
template <comp X>
fvec4SIMD swizzle() const;
};
}//namespace detail
namespace gtx{
namespace simd_vec4 ///< GLM_GTX_simd_vec4 extension: SIMD implementation of vec4 type.
{
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(
detail::fvec4SIMD const & x);
//! Returns x if x >= 0; otherwise, it returns -x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD abs(detail::fvec4SIMD const & x);
//! Returns 1.0 if x > 0, 0.0 if x = 0, or -1.0 if x < 0.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD sign(detail::fvec4SIMD const & x);
//! Returns a value equal to the nearest integer that is less then or equal to x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD floor(detail::fvec4SIMD const & x);
//! Returns a value equal to the nearest integer to x
//! whose absolute value is not larger than the absolute value of x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD trunc(detail::fvec4SIMD const & x);
//! Returns a value equal to the nearest integer to x.
//! The fraction 0.5 will round in a direction chosen by the
//! implementation, presumably the direction that is fastest.
//! This includes the possibility that round(x) returns the
//! same value as roundEven(x) for all values of x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD round(detail::fvec4SIMD const & x);
//! Returns a value equal to the nearest integer to x.
//! A fractional part of 0.5 will round toward the nearest even
//! integer. (Both 3.5 and 4.5 for x will return 4.0.)
//! (From GLM_GTX_simd_vec4 extension, common function)
//detail::fvec4SIMD roundEven(detail::fvec4SIMD const & x);
//! Returns a value equal to the nearest integer
//! that is greater than or equal to x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD ceil(detail::fvec4SIMD const & x);
//! Return x - floor(x).
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD fract(detail::fvec4SIMD const & x);
//! Modulus. Returns x - y * floor(x / y)
//! for each component in x using the floating point value y.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD mod(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y);
//! Modulus. Returns x - y * floor(x / y)
//! for each component in x using the floating point value y.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD mod(
detail::fvec4SIMD const & x,
float const & y);
//! Returns the fractional part of x and sets i to the integer
//! part (as a whole number floating point value). Both the
//! return value and the output parameter will have the same
//! sign as x.
//! (From GLM_GTX_simd_vec4 extension, common function)
//detail::fvec4SIMD modf(
// detail::fvec4SIMD const & x,
// detail::fvec4SIMD & i);
//! Returns y if y < x; otherwise, it returns x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD min(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y);
detail::fvec4SIMD min(
detail::fvec4SIMD const & x,
float const & y);
//! Returns y if x < y; otherwise, it returns x.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD max(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y);
detail::fvec4SIMD max(
detail::fvec4SIMD const & x,
float const & y);
//! Returns min(max(x, minVal), maxVal) for each component in x
//! using the floating-point values minVal and maxVal.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD clamp(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & minVal,
detail::fvec4SIMD const & maxVal);
detail::fvec4SIMD clamp(
detail::fvec4SIMD const & x,
float const & minVal,
float const & maxVal);
//! \return If genTypeU is a floating scalar or vector:
//! 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].
//!
//! \return If genTypeU is a boolean scalar or vector:
//! Selects which vector each returned component comes
//! from. For a component of a that is false, the
//! corresponding component of x is returned. For a
//! component of a that is true, the corresponding
//! component of y is returned. Components of x and y that
//! are not selected are allowed to be invalid floating point
//! values and will have no effect on the results. Thus, this
//! provides different functionality than
//! genType mix(genType x, genType y, genType(a))
//! where a is a Boolean vector.
//!
//! From GLSL 1.30.08 specification, section 8.3
//!
//! \param[in] x Floating point scalar or vector.
//! \param[in] y Floating point scalar or vector.
//! \param[in] a Floating point or boolean scalar or vector.
//!
// \todo Test when 'a' is a boolean.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD mix(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y,
detail::fvec4SIMD const & a);
//! Returns 0.0 if x < edge, otherwise it returns 1.0.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD step(
detail::fvec4SIMD const & edge,
detail::fvec4SIMD const & x);
detail::fvec4SIMD step(
float const & edge,
detail::fvec4SIMD const & x);
//! Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and
//! performs smooth Hermite interpolation between 0 and 1
//! when edge0 < x < edge1. This is useful in cases where
//! you would want a threshold function with a smooth
//! transition. This is equivalent to:
//! genType t;
//! t = clamp ((x – edge0) / (edge1 – edge0), 0, 1);
//! return t * t * (3 – 2 * t);
//! Results are undefined if edge0 >= edge1.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD smoothstep(
detail::fvec4SIMD const & edge0,
detail::fvec4SIMD const & edge1,
detail::fvec4SIMD const & x);
detail::fvec4SIMD smoothstep(
float const & edge0,
float const & edge1,
detail::fvec4SIMD const & x);
//! Returns true if x holds a NaN (not a number)
//! representation in the underlying implementation's set of
//! floating point representations. Returns false otherwise,
//! including for implementations with no NaN
//! representations.
//! (From GLM_GTX_simd_vec4 extension, common function)
//bvec4 isnan(detail::fvec4SIMD const & x);
//! Returns true if x holds a positive infinity or negative
//! infinity representation in the underlying implementation's
//! set of floating point representations. Returns false
//! otherwise, including for implementations with no infinity
//! representations.
//! (From GLM_GTX_simd_vec4 extension, common function)
//bvec4 isinf(detail::fvec4SIMD const & x);
//! Returns a signed or unsigned integer value representing
//! the encoding of a floating-point value. The floatingpoint
//! value's bit-level representation is preserved.
//! (From GLM_GTX_simd_vec4 extension, common function)
//detail::ivec4SIMD floatBitsToInt(detail::fvec4SIMD const & value);
//! Returns a floating-point value corresponding to a signed
//! or unsigned integer encoding of a floating-point value.
//! If an inf or NaN is passed in, it will not signal, and the
//! resulting floating point value is unspecified. Otherwise,
//! the bit-level representation is preserved.
//! (From GLM_GTX_simd_vec4 extension, common function)
//detail::fvec4SIMD intBitsToFloat(detail::ivec4SIMD const & value);
//! Computes and returns a * b + c.
//! (From GLM_GTX_simd_vec4 extension, common function)
detail::fvec4SIMD fma(
detail::fvec4SIMD const & a,
detail::fvec4SIMD const & b,
detail::fvec4SIMD const & c);
//! Splits x into a floating-point significand in the range
//! [0.5, 1.0) and an integral exponent of two, such that:
//! x = significand * exp(2, exponent)
//! The significand is returned by the function and the
//! exponent is returned in the parameter exp. For a
//! floating-point value of zero, the significant and exponent
//! are both zero. For a floating-point value that is an
//! infinity or is not a number, the results are undefined.
//! (From GLM_GTX_simd_vec4 extension, common function)
//detail::fvec4SIMD frexp(detail::fvec4SIMD const & x, detail::ivec4SIMD & exp);
//! Builds a floating-point number from x and the
//! corresponding integral exponent of two in exp, returning:
//! significand * exp(2, exponent)
//! If this product is too large to be represented in the
//! floating-point type, the result is undefined.
//! (From GLM_GTX_simd_vec4 extension, common function)
//detail::fvec4SIMD ldexp(detail::fvec4SIMD const & x, detail::ivec4SIMD const & exp);
//! Returns the length of x, i.e., sqrt(x * x).
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
float length(
detail::fvec4SIMD const & x);
//! Returns the length of x, i.e., sqrt(x * x).
//! Less accurate but much faster than simdLength.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
float fastLength(
detail::fvec4SIMD const & x);
//! Returns the length of x, i.e., sqrt(x * x).
//! Slightly more accurate but much slower than simdLength.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
float niceLength(
detail::fvec4SIMD const & x);
//! Returns the length of x, i.e., sqrt(x * x).
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD length4(
detail::fvec4SIMD const & x);
//! Returns the length of x, i.e., sqrt(x * x).
//! Less accurate but much faster than simdLength4.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD fastLength4(
detail::fvec4SIMD const & x);
//! Returns the length of x, i.e., sqrt(x * x).
//! Slightly more accurate but much slower than simdLength4.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD niceLength4(
detail::fvec4SIMD const & x);
//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
float distance(
detail::fvec4SIMD const & p0,
detail::fvec4SIMD const & p1);
//! Returns the distance betwwen p0 and p1, i.e., length(p0 - p1).
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD distance4(
detail::fvec4SIMD const & p0,
detail::fvec4SIMD const & p1);
//! Returns the dot product of x and y, i.e., result = x * y.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
float simdDot(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y);
//! Returns the dot product of x and y, i.e., result = x * y.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD dot4(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y);
//! Returns the cross product of x and y.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD cross(
detail::fvec4SIMD const & x,
detail::fvec4SIMD const & y);
//! Returns a vector in the same direction as x but with length of 1.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD normalize(
detail::fvec4SIMD const & x);
//! Returns a vector in the same direction as x but with length of 1.
//! Less accurate but much faster than simdNormalize.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD fastNormalize(
detail::fvec4SIMD const & x);
//! If dot(Nref, I) < 0.0, return N, otherwise, return -N.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD simdFaceforward(
detail::fvec4SIMD const & N,
detail::fvec4SIMD const & I,
detail::fvec4SIMD const & Nref);
//! For the incident vector I and surface orientation N,
//! returns the reflection direction : result = I - 2.0 * dot(N, I) * N.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD reflect(
detail::fvec4SIMD const & I,
detail::fvec4SIMD const & N);
//! For the incident vector I and surface normal N,
//! and the ratio of indices of refraction eta,
//! return the refraction vector.
//! (From GLM_GTX_simd_vec4 extension, geometry functions)
detail::fvec4SIMD refract(
detail::fvec4SIMD const & I,
detail::fvec4SIMD const & N,
float const & eta);
//! Returns the positive square root of x.
//! (From GLM_GTX_simd_vec4 extension, exponential function)
detail::fvec4SIMD sqrt(
detail::fvec4SIMD const & x);
//! Returns the positive square root of x with the nicest quality but very slow.
//! Slightly more accurate but much slower than simdSqrt.
//! (From GLM_GTX_simd_vec4 extension, exponential function)
detail::fvec4SIMD niceSqrt(
detail::fvec4SIMD const & x);
//! Returns the positive square root of x
//! Less accurate but much faster than sqrt.
//! (From GLM_GTX_simd_vec4 extension, exponential function)
detail::fvec4SIMD fastSqrt(
detail::fvec4SIMD const & x);
//! Returns the reciprocal of the positive square root of x.
//! (From GLM_GTX_simd_vec4 extension, exponential function)
detail::fvec4SIMD inversesqrt(
detail::fvec4SIMD const & x);
//! Returns the reciprocal of the positive square root of x.
//! Faster than inversesqrt but less accurate.
//! (From GLM_GTX_simd_vec4 extension, exponential function)
detail::fvec4SIMD fastInversesqrt(
detail::fvec4SIMD const & x);
/// @}
}//namespace simd_vec4
}//namespace gtx
}//namespace glm
#include "simd_vec4.inl"

12
glm/gtx/simplex.hpp
View File

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

8
glm/gtx/spline.hpp
View File

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

66
glm/gtx/std_based_type.hpp
View File

@ -21,50 +21,48 @@
# pragma message("GLM: GLM_GTX_std_based_type extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace std_based_type ///< GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
{
namespace gtx{
//! GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
namespace std_based_type
{
typedef detail::tvec2<std::size_t> size2;
typedef detail::tvec3<std::size_t> size3;
typedef detail::tvec4<std::size_t> size4;
typedef detail::tvec2<std::size_t> size2;
typedef detail::tvec3<std::size_t> size3;
typedef detail::tvec4<std::size_t> size4;
typedef detail::tvec2<signed char> scvec2;
typedef detail::tvec3<signed char> scvec3;
typedef detail::tvec4<signed char> scvec4;
typedef detail::tvec2<signed char> scvec2;
typedef detail::tvec3<signed char> scvec3;
typedef detail::tvec4<signed char> scvec4;
typedef detail::tvec2<unsigned char> ucvec2;
typedef detail::tvec3<unsigned char> ucvec3;
typedef detail::tvec4<unsigned char> ucvec4;
typedef detail::tvec2<unsigned char> ucvec2;
typedef detail::tvec3<unsigned char> ucvec3;
typedef detail::tvec4<unsigned char> ucvec4;
typedef detail::tvec2<signed short> ssvec2;
typedef detail::tvec3<signed short> ssvec3;
typedef detail::tvec4<signed short> ssvec4;
typedef detail::tvec2<signed short> ssvec2;
typedef detail::tvec3<signed short> ssvec3;
typedef detail::tvec4<signed short> ssvec4;
typedef detail::tvec2<unsigned short> usvec2;
typedef detail::tvec3<unsigned short> usvec3;
typedef detail::tvec4<unsigned short> usvec4;
typedef detail::tvec2<unsigned short> usvec2;
typedef detail::tvec3<unsigned short> usvec3;
typedef detail::tvec4<unsigned short> usvec4;
typedef detail::tvec2<signed int> sivec2;
typedef detail::tvec3<signed int> sivec3;
typedef detail::tvec4<signed int> sivec4;
typedef detail::tvec2<signed int> sivec2;
typedef detail::tvec3<signed int> sivec3;
typedef detail::tvec4<signed int> sivec4;
typedef detail::tvec2<unsigned int> uivec2;
typedef detail::tvec3<unsigned int> uivec3;
typedef detail::tvec4<unsigned int> uivec4;
typedef detail::tvec2<unsigned int> uivec2;
typedef detail::tvec3<unsigned int> uivec3;
typedef detail::tvec4<unsigned int> uivec4;
typedef detail::tvec2<signed long> slvec2;
typedef detail::tvec3<signed long> slvec3;
typedef detail::tvec4<signed long> slvec4;
typedef detail::tvec2<signed long> slvec2;
typedef detail::tvec3<signed long> slvec3;
typedef detail::tvec4<signed long> slvec4;
typedef detail::tvec2<unsigned long> ulvec2;
typedef detail::tvec3<unsigned long> ulvec3;
typedef detail::tvec4<unsigned long> ulvec4;
typedef detail::tvec2<unsigned long> ulvec2;
typedef detail::tvec3<unsigned long> ulvec3;
typedef detail::tvec4<unsigned long> ulvec4;
}//namespace std_based_type
}//namespace gtx
}//namespace std_based_type
}//namespace gtx
}//namespace glm
#include "std_based_type.inl"

35
glm/gtx/string_cast.hpp
View File

@ -28,29 +28,26 @@
# pragma message("GLM: GLM_GTX_string_cast extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace string_cast ///< GLM_GTX_string_cast extension: Setup strings for GLM type values
{
namespace gtx{
//! GLM_GTX_string_cast extension: Setup strings for GLM type values
namespace string_cast
{
using namespace gtc::half_float;
using namespace gtx::integer;
using namespace gtx::unsigned_int;
using namespace gtx::quaternion;
using namespace gtc::half_float;
using namespace gtx::integer;
using namespace gtx::unsigned_int;
using namespace gtx::quaternion;
/// \addtogroup gtx_string_cast
///@{
/// \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);
//! Create a string from a GLM type value.
//! From GLM_GTX_string_cast extension.
template <typename genType>
std::string to_string(genType const & x);
///@}
}//namespace string_cast
}//namespace gtx
/// @}
}//namespace string_cast
}//namespace gtx
}//namespace glm
#include "string_cast.inl"

123
glm/gtx/transform.hpp
View File

@ -22,81 +22,78 @@
# pragma message("GLM: GLM_GTX_transform extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace transform ///< GLM_GTX_transform extension: Add transformation matrices
{
namespace gtx{
//! GLM_GTX_transform extension: Add transformation matrices
namespace transform
{
using namespace gtc::matrix_transform;
using namespace gtc::matrix_transform;
/// \addtogroup gtx_transform
///@{
/// \addtogroup gtx_transform
/// @{
//! Builds a translation 4 * 4 matrix created from 3 scalars.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> translate(
T x, T y, T z);
//! Builds a translation 4 * 4 matrix created from 3 scalars.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> translate(
T x, T y, T z);
//! Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> translate(
detail::tmat4x4<T> const & m,
T x, T y, T z);
//! Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> translate(
detail::tmat4x4<T> const & m,
T x, T y, T z);
//! Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> translate(
detail::tvec3<T> const & v);
//! Transforms a matrix with a translation 4 * 4 matrix created from 3 scalars.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> translate(
detail::tvec3<T> const & v);
//! Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> rotate(
T angle,
T x, T y, T z);
//! Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> rotate(
T angle,
T x, T y, T z);
//! Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> rotate(
T angle,
detail::tvec3<T> const & v);
//! Builds a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> rotate(
T angle,
detail::tvec3<T> const & v);
//! Transforms a matrix with a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> rotate(
detail::tmat4x4<T> const & m,
T angle,
T x, T y, T z);
//! Transforms a matrix with a rotation 4 * 4 matrix created from an axis of 3 scalars and an angle expressed in degrees.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> rotate(
detail::tmat4x4<T> const & m,
T angle,
T x, T y, T z);
//! Builds a scale 4 * 4 matrix created from 3 scalars.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> scale(
T x, T y, T z);
//! Builds a scale 4 * 4 matrix created from 3 scalars.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> scale(
T x, T y, T z);
//! Transforms a matrix with a scale 4 * 4 matrix created from 3 scalars.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> scale(
detail::tmat4x4<T> const & m,
T x, T y, T z);
//! Transforms a matrix with a scale 4 * 4 matrix created from 3 scalars.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> scale(
detail::tmat4x4<T> const & m,
T x, T y, T z);
//! Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> scale(
detail::tvec3<T> const & v);
//! Transforms a matrix with a scale 4 * 4 matrix created from a vector of 3 components.
//! From GLM_GTX_transform extension.
template <typename T>
detail::tmat4x4<T> scale(
detail::tvec3<T> const & v);
///@}
}//namespace transform
}//namespace gtx
/// @}
}//namespace transform
}//namespace gtx
}//namespace glm
#include "transform.inl"

151
glm/gtx/transform2.hpp
View File

@ -22,97 +22,94 @@
# pragma message("GLM: GLM_GTX_transform2 extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace transform2 ///< GLM_GTX_transform2 extension: Add extra transformation matrices
{
namespace gtx{
//! GLM_GTX_transform2 extension: Add extra transformation matrices
namespace transform2
{
using namespace gtx::transform;
using namespace gtx::transform;
/// \addtogroup gtx_transform2
///@{
/// \addtogroup gtx_transform2
/// @{
//! Transforms a matrix with a shearing on X axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat3x3<T> shearX2D(
detail::tmat3x3<T> const & m,
T y);
//! Transforms a matrix with a shearing on X axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat3x3<T> shearX2D(
detail::tmat3x3<T> const & m,
T y);
//! Transforms a matrix with a shearing on Y axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat3x3<T> shearY2D(
detail::tmat3x3<T> const & m,
T x);
//! Transforms a matrix with a shearing on Y axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat3x3<T> shearY2D(
detail::tmat3x3<T> const & m,
T x);
//! Transforms a matrix with a shearing on X axis
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat4x4<T> shearX3D(
const detail::tmat4x4<T> & m,
T y,
T z);
//! Transforms a matrix with a shearing on X axis
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat4x4<T> shearX3D(
const detail::tmat4x4<T> & m,
T y,
T z);
//! Transforms a matrix with a shearing on Y axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat4x4<T> shearY3D(
const detail::tmat4x4<T> & m,
T x,
T z);
//! Transforms a matrix with a shearing on Y axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat4x4<T> shearY3D(
const detail::tmat4x4<T> & m,
T x,
T z);
//! Transforms a matrix with a shearing on Z axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat4x4<T> shearZ3D(
const detail::tmat4x4<T> & m,
T x,
T y);
//! Transforms a matrix with a shearing on Z axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat4x4<T> shearZ3D(
const detail::tmat4x4<T> & m,
T x,
T y);
//template <typename T> GLM_FUNC_QUALIFIER detail::tmat4x4<T> shear(const detail::tmat4x4<T> & m, shearPlane, planePoint, angle)
// Identity + tan(angle) * cross(Normal, OnPlaneVector) 0
// - dot(PointOnPlane, normal) * OnPlaneVector 1
//template <typename T> GLM_FUNC_QUALIFIER detail::tmat4x4<T> shear(const detail::tmat4x4<T> & m, shearPlane, planePoint, angle)
// Identity + tan(angle) * cross(Normal, OnPlaneVector) 0
// - dot(PointOnPlane, normal) * OnPlaneVector 1
// Reflect functions seem to don't work
//template <typename T> detail::tmat3x3<T> reflect2D(const detail::tmat3x3<T> & m, const detail::tvec3<T>& normal){return reflect2DGTX(m, normal);} //!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
//template <typename T> detail::tmat4x4<T> reflect3D(const detail::tmat4x4<T> & m, const detail::tvec3<T>& normal){return reflect3DGTX(m, normal);} //!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
// Reflect functions seem to don't work
//template <typename T> detail::tmat3x3<T> reflect2D(const detail::tmat3x3<T> & m, const detail::tvec3<T>& normal){return reflect2DGTX(m, normal);} //!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
//template <typename T> detail::tmat4x4<T> reflect3D(const detail::tmat4x4<T> & m, const detail::tvec3<T>& normal){return reflect3DGTX(m, normal);} //!< \brief Build a reflection matrix (from GLM_GTX_transform2 extension)
//! Build planar projection matrix along normal axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat3x3<T> proj2D(
const detail::tmat3x3<T> & m,
const detail::tvec3<T>& normal);
//! Build planar projection matrix along normal axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat3x3<T> proj2D(
const detail::tmat3x3<T> & m,
const detail::tvec3<T>& normal);
//! Build planar projection matrix along normal axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat4x4<T> proj3D(
const detail::tmat4x4<T> & m,
const detail::tvec3<T>& normal);
//! Build planar projection matrix along normal axis.
//! From GLM_GTX_transform2 extension.
template <typename T>
detail::tmat4x4<T> proj3D(
const detail::tmat4x4<T> & m,
const detail::tvec3<T>& normal);
//! Build a scale bias matrix.
//! From GLM_GTX_transform2 extension.
template <typename valType>
detail::tmat4x4<valType> scaleBias(
valType scale,
valType bias);
//! Build a scale bias matrix.
//! From GLM_GTX_transform2 extension.
template <typename valType>
detail::tmat4x4<valType> scaleBias(
valType scale,
valType bias);
//! Build a scale bias matrix.
//! From GLM_GTX_transform2 extension.
template <typename valType>
detail::tmat4x4<valType> scaleBias(
detail::tmat4x4<valType> const & m,
valType scale,
valType bias);
//! Build a scale bias matrix.
//! From GLM_GTX_transform2 extension.
template <typename valType>
detail::tmat4x4<valType> scaleBias(
detail::tmat4x4<valType> const & m,
valType scale,
valType bias);
///@}
}//namespace transform2
}//namespace gtx
}//namespace glm
/// @}
}// namespace transform2
}// namespace gtx
}// namespace glm
#include "transform2.inl"

9
glm/gtx/ulp.hpp
View File

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

5
glm/gtx/unsigned_int.hpp
View File

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

6
glm/gtx/vec1.hpp
View File

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

5
glm/gtx/vector_access.hpp
View File

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

8
glm/gtx/vector_angle.hpp
View File

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

11
glm/gtx/vector_query.hpp
View File

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

10
glm/gtx/verbose_operator.hpp
View File

@ -25,7 +25,7 @@ namespace gtx{
namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to replace operators
{
/// \addtogroup gtx_verbose_operator
///@{
/// @{
//! Addition of two values
//! From GLM_GTX_verbose_operator extension.
@ -52,10 +52,10 @@ namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to
template <typename genTypeT, typename genTypeU, typename genTypeV>
genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
///@}
}//namespace verbose_operator
}//namespace gtx
}//namespace glm
/// @}
}// namespace verbose_operator
}// namespace gtx
}// namespace glm
#include "verbose_operator.inl"

11
glm/gtx/wrap.hpp
View File

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