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

Merge branch '0.9.2' of ssh://ogl-math.git.sourceforge.net/gitroot/ogl-math/ogl-math into 0.9.2

Browse Source
This commit is contained in:
Christophe Riccio 2011-05-18 23:12:17 +01:00
commit 7febaa193d
70 changed files with 4402 additions and 4771 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

661
glm/gtc/half_float.hpp
View File

@ -17,351 +17,346 @@
# pragma message("GLM: GLM_GTC_half_float extension included") # pragma message("GLM: GLM_GTC_half_float extension included")
#endif #endif
namespace glm namespace glm{
namespace detail
{ {
namespace test{
bool main_gtc_half_float();
}//namespace
namespace detail
{
#ifndef _MSC_EXTENSIONS #ifndef _MSC_EXTENSIONS
template <> template <>
struct tvec2<thalf> struct tvec2<thalf>
{
enum ctor{null};
typedef thalf value_type;
typedef std::size_t size_type;
static size_type value_size();
typedef tvec2<thalf> type;
typedef tvec2<bool> bool_type;
//////////////////////////////////////
// Data
thalf x, y;
//////////////////////////////////////
// Accesses
thalf & operator[](size_type i);
thalf const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
tvec2();
tvec2(tvec2<thalf> const & v);
//////////////////////////////////////
// Explicit basic constructors
explicit tvec2(ctor);
explicit tvec2(
thalf const & s);
explicit tvec2(
thalf const & s1,
thalf const & s2);
//////////////////////////////////////
// Swizzle constructors
tvec2(tref2<thalf> const & r);
//////////////////////////////////////
// Convertion scalar constructors
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec2(U const & x);
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, typename V>
explicit tvec2(U const & x, V const & y);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec2(tvec2<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec2(tvec3<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec2(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec2<thalf>& operator= (tvec2<thalf> const & v);
tvec2<thalf>& operator+=(thalf const & s);
tvec2<thalf>& operator+=(tvec2<thalf> const & v);
tvec2<thalf>& operator-=(thalf const & s);
tvec2<thalf>& operator-=(tvec2<thalf> const & v);
tvec2<thalf>& operator*=(thalf const & s);
tvec2<thalf>& operator*=(tvec2<thalf> const & v);
tvec2<thalf>& operator/=(thalf const & s);
tvec2<thalf>& operator/=(tvec2<thalf> const & v);
tvec2<thalf>& operator++();
tvec2<thalf>& operator--();
//////////////////////////////////////
// Swizzle operators
thalf swizzle(comp X) const;
tvec2<thalf> swizzle(comp X, comp Y) const;
tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
tref2<thalf> swizzle(comp X, comp Y);
};
template <>
struct tvec3<thalf>
{
enum ctor{null};
typedef thalf value_type;
typedef std::size_t size_type;
static size_type value_size();
typedef tvec3<thalf> type;
typedef tvec3<bool> bool_type;
//////////////////////////////////////
// Data
thalf x, y, z;
//////////////////////////////////////
// Accesses
thalf & operator[](size_type i);
thalf const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
tvec3();
tvec3(tvec3<thalf> const & v);
//////////////////////////////////////
// Explicit basic constructors
explicit tvec3(ctor);
explicit tvec3(
thalf const & s);
explicit tvec3(
thalf const & s1,
thalf const & s2,
thalf const & s3);
//////////////////////////////////////
// Swizzle constructors
tvec3(tref3<thalf> const & r);
//////////////////////////////////////
// Convertion scalar constructors
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec3(U const & x);
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, typename V, typename W>
explicit tvec3(U const & x, V const & y, W const & z);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec3(tvec2<A> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec3(A const & s, tvec2<B> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec3(tvec3<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec3(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec3<thalf>& operator= (tvec3<thalf> const & v);
tvec3<thalf>& operator+=(thalf const & s);
tvec3<thalf>& operator+=(tvec3<thalf> const & v);
tvec3<thalf>& operator-=(thalf const & s);
tvec3<thalf>& operator-=(tvec3<thalf> const & v);
tvec3<thalf>& operator*=(thalf const & s);
tvec3<thalf>& operator*=(tvec3<thalf> const & v);
tvec3<thalf>& operator/=(thalf const & s);
tvec3<thalf>& operator/=(tvec3<thalf> const & v);
tvec3<thalf>& operator++();
tvec3<thalf>& operator--();
//////////////////////////////////////
// Swizzle operators
thalf swizzle(comp X) const;
tvec2<thalf> swizzle(comp X, comp Y) const;
tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
tref3<thalf> swizzle(comp X, comp Y, comp Z);
};
template <>
struct tvec4<thalf>
{
enum ctor{null};
typedef thalf value_type;
typedef std::size_t size_type;
static size_type value_size();
typedef tvec4<thalf> type;
typedef tvec4<bool> bool_type;
//////////////////////////////////////
// Data
thalf x, y, z, w;
//////////////////////////////////////
// Accesses
thalf & operator[](size_type i);
thalf const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
tvec4();
tvec4(tvec4<thalf> const & v);
//////////////////////////////////////
// Explicit basic constructors
explicit tvec4(ctor);
explicit tvec4(
thalf const & s);
explicit tvec4(
thalf const & s0,
thalf const & s1,
thalf const & s2,
thalf const & s3);
//////////////////////////////////////
// Swizzle constructors
tvec4(tref4<thalf> const & r);
//////////////////////////////////////
// Convertion scalar constructors
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec4(U const & x);
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C, typename D>
explicit tvec4(A const & x, B const & y, C const & z, D const & w);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec4(tvec3<A> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec4(A const & s, tvec3<B> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec4(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec4<thalf>& operator= (tvec4<thalf> const & v);
tvec4<thalf>& operator+=(thalf const & s);
tvec4<thalf>& operator+=(tvec4<thalf> const & v);
tvec4<thalf>& operator-=(thalf const & s);
tvec4<thalf>& operator-=(tvec4<thalf> const & v);
tvec4<thalf>& operator*=(thalf const & s);
tvec4<thalf>& operator*=(tvec4<thalf> const & v);
tvec4<thalf>& operator/=(thalf const & s);
tvec4<thalf>& operator/=(tvec4<thalf> const & v);
tvec4<thalf>& operator++();
tvec4<thalf>& operator--();
//////////////////////////////////////
// Swizzle operators
thalf swizzle(comp X) const;
tvec2<thalf> swizzle(comp X, comp Y) const;
tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
tref4<thalf> swizzle(comp X, comp Y, comp Z, comp W);
};
#endif//_MSC_EXTENSIONS
}
//namespace detail
namespace gtc{
//! GLM_GTC_half_float extension: Add support for half precision floating-point types
namespace half_float
{ {
/// \addtogroup gtc_half_float enum ctor{null};
///@{ typedef thalf value_type;
typedef std::size_t size_type;
static size_type value_size();
//! Type for half-precision floating-point numbers. typedef tvec2<thalf> type;
//! From GLM_GTC_half_float extension. typedef tvec2<bool> bool_type;
typedef detail::thalf half;
//! Vector of 2 half-precision floating-point numbers. //////////////////////////////////////
//! From GLM_GTC_half_float extension. // Data
typedef detail::tvec2<detail::thalf> hvec2;
//! Vector of 3 half-precision floating-point numbers. thalf x, y;
//! From GLM_GTC_half_float extension.
typedef detail::tvec3<detail::thalf> hvec3;
//! Vector of 4 half-precision floating-point numbers. //////////////////////////////////////
//! From GLM_GTC_half_float extension. // Accesses
typedef detail::tvec4<detail::thalf> hvec4;
//! 2 * 2 matrix of half-precision floating-point numbers. thalf & operator[](size_type i);
//! From GLM_GTC_half_float extension. thalf const & operator[](size_type i) const;
typedef detail::tmat2x2<detail::thalf> hmat2;
//! 3 * 3 matrix of half-precision floating-point numbers. //////////////////////////////////////
//! From GLM_GTC_half_float extension. // Implicit basic constructors
typedef detail::tmat3x3<detail::thalf> hmat3;
//! 4 * 4 matrix of half-precision floating-point numbers. tvec2();
//! From GLM_GTC_half_float extension. tvec2(tvec2<thalf> const & v);
typedef detail::tmat4x4<detail::thalf> hmat4;
///@} //////////////////////////////////////
// Explicit basic constructors
}//namespace half_float explicit tvec2(ctor);
}//namespace gtc explicit tvec2(
}//namespace glm thalf const & s);
explicit tvec2(
thalf const & s1,
thalf const & s2);
//////////////////////////////////////
// Swizzle constructors
tvec2(tref2<thalf> const & r);
//////////////////////////////////////
// Convertion scalar constructors
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec2(U const & x);
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, typename V>
explicit tvec2(U const & x, V const & y);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec2(tvec2<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec2(tvec3<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec2(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec2<thalf>& operator= (tvec2<thalf> const & v);
tvec2<thalf>& operator+=(thalf const & s);
tvec2<thalf>& operator+=(tvec2<thalf> const & v);
tvec2<thalf>& operator-=(thalf const & s);
tvec2<thalf>& operator-=(tvec2<thalf> const & v);
tvec2<thalf>& operator*=(thalf const & s);
tvec2<thalf>& operator*=(tvec2<thalf> const & v);
tvec2<thalf>& operator/=(thalf const & s);
tvec2<thalf>& operator/=(tvec2<thalf> const & v);
tvec2<thalf>& operator++();
tvec2<thalf>& operator--();
//////////////////////////////////////
// Swizzle operators
thalf swizzle(comp X) const;
tvec2<thalf> swizzle(comp X, comp Y) const;
tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
tref2<thalf> swizzle(comp X, comp Y);
};
template <>
struct tvec3<thalf>
{
enum ctor{null};
typedef thalf value_type;
typedef std::size_t size_type;
static size_type value_size();
typedef tvec3<thalf> type;
typedef tvec3<bool> bool_type;
//////////////////////////////////////
// Data
thalf x, y, z;
//////////////////////////////////////
// Accesses
thalf & operator[](size_type i);
thalf const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
tvec3();
tvec3(tvec3<thalf> const & v);
//////////////////////////////////////
// Explicit basic constructors
explicit tvec3(ctor);
explicit tvec3(
thalf const & s);
explicit tvec3(
thalf const & s1,
thalf const & s2,
thalf const & s3);
//////////////////////////////////////
// Swizzle constructors
tvec3(tref3<thalf> const & r);
//////////////////////////////////////
// Convertion scalar constructors
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec3(U const & x);
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, typename V, typename W>
explicit tvec3(U const & x, V const & y, W const & z);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec3(tvec2<A> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec3(A const & s, tvec2<B> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec3(tvec3<U> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec3(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec3<thalf>& operator= (tvec3<thalf> const & v);
tvec3<thalf>& operator+=(thalf const & s);
tvec3<thalf>& operator+=(tvec3<thalf> const & v);
tvec3<thalf>& operator-=(thalf const & s);
tvec3<thalf>& operator-=(tvec3<thalf> const & v);
tvec3<thalf>& operator*=(thalf const & s);
tvec3<thalf>& operator*=(tvec3<thalf> const & v);
tvec3<thalf>& operator/=(thalf const & s);
tvec3<thalf>& operator/=(tvec3<thalf> const & v);
tvec3<thalf>& operator++();
tvec3<thalf>& operator--();
//////////////////////////////////////
// Swizzle operators
thalf swizzle(comp X) const;
tvec2<thalf> swizzle(comp X, comp Y) const;
tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
tref3<thalf> swizzle(comp X, comp Y, comp Z);
};
template <>
struct tvec4<thalf>
{
enum ctor{null};
typedef thalf value_type;
typedef std::size_t size_type;
static size_type value_size();
typedef tvec4<thalf> type;
typedef tvec4<bool> bool_type;
//////////////////////////////////////
// Data
thalf x, y, z, w;
//////////////////////////////////////
// Accesses
thalf & operator[](size_type i);
thalf const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
tvec4();
tvec4(tvec4<thalf> const & v);
//////////////////////////////////////
// Explicit basic constructors
explicit tvec4(ctor);
explicit tvec4(
thalf const & s);
explicit tvec4(
thalf const & s0,
thalf const & s1,
thalf const & s2,
thalf const & s3);
//////////////////////////////////////
// Swizzle constructors
tvec4(tref4<thalf> const & r);
//////////////////////////////////////
// Convertion scalar constructors
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec4(U const & x);
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C, typename D>
explicit tvec4(A const & x, B const & y, C const & z, D const & w);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
explicit tvec4(tvec2<A> const & v, B const & s1, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
explicit tvec4(A const & s1, tvec2<B> const & v, C const & s2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B, typename C>
explicit tvec4(A const & s1, B const & s2, tvec2<C> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec4(tvec3<A> const & v, B const & s);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec4(A const & s, tvec3<B> const & v);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename A, typename B>
explicit tvec4(tvec2<A> const & v1, tvec2<B> const & v2);
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec4(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec4<thalf>& operator= (tvec4<thalf> const & v);
tvec4<thalf>& operator+=(thalf const & s);
tvec4<thalf>& operator+=(tvec4<thalf> const & v);
tvec4<thalf>& operator-=(thalf const & s);
tvec4<thalf>& operator-=(tvec4<thalf> const & v);
tvec4<thalf>& operator*=(thalf const & s);
tvec4<thalf>& operator*=(tvec4<thalf> const & v);
tvec4<thalf>& operator/=(thalf const & s);
tvec4<thalf>& operator/=(tvec4<thalf> const & v);
tvec4<thalf>& operator++();
tvec4<thalf>& operator--();
//////////////////////////////////////
// Swizzle operators
thalf swizzle(comp X) const;
tvec2<thalf> swizzle(comp X, comp Y) const;
tvec3<thalf> swizzle(comp X, comp Y, comp Z) const;
tvec4<thalf> swizzle(comp X, comp Y, comp Z, comp W) const;
tref4<thalf> swizzle(comp X, comp Y, comp Z, comp W);
};
#endif//_MSC_EXTENSIONS
}
//namespace detail
namespace gtc{
namespace half_float ///< GLM_GTC_half_float extension: Add support for half precision floating-point types
{
/// \addtogroup gtc_half_float
///@{
/// Type for half-precision floating-point numbers.
/// From GLM_GTC_half_float extension.
typedef detail::thalf half;
/// Vector of 2 half-precision floating-point numbers.
/// From GLM_GTC_half_float extension.
typedef detail::tvec2<detail::thalf> hvec2;
/// Vector of 3 half-precision floating-point numbers.
/// From GLM_GTC_half_float extension.
typedef detail::tvec3<detail::thalf> hvec3;
/// Vector of 4 half-precision floating-point numbers.
/// From GLM_GTC_half_float extension.
typedef detail::tvec4<detail::thalf> hvec4;
/// 2 * 2 matrix of half-precision floating-point numbers.
/// From GLM_GTC_half_float extension.
typedef detail::tmat2x2<detail::thalf> hmat2;
/// 3 * 3 matrix of half-precision floating-point numbers.
/// From GLM_GTC_half_float extension.
typedef detail::tmat3x3<detail::thalf> hmat3;
/// 4 * 4 matrix of half-precision floating-point numbers.
/// From GLM_GTC_half_float extension.
typedef detail::tmat4x4<detail::thalf> hmat4;
/// @}
}// namespace half_float
}// namespace gtc
}// namespace glm
#include "half_float.inl" #include "half_float.inl"

3
glm/gtc/matrix_access.hpp
View File

@ -22,8 +22,7 @@
namespace glm{ namespace glm{
namespace gtc{ namespace gtc{
//! GLM_GTC_matrix_access extension: Set a column or a row of a matrix namespace matrix_access ///< GLM_GTC_matrix_access extension: Set a column or a row of a matrix
namespace matrix_access
{ {
/// \addtogroup gtc_matrix_access /// \addtogroup gtc_matrix_access
///@{ ///@{

310
glm/gtc/matrix_integer.hpp
View File

@ -20,189 +20,183 @@
# pragma message("GLM: GLM_GTC_matrix_integer extension included") # pragma message("GLM: GLM_GTC_matrix_integer extension included")
#endif #endif
namespace glm namespace glm{
namespace gtc{
namespace matrix_integer ///< GLM_GTC_matrix_integer extension: Add integer matrices
{ {
namespace test{ /// \addtogroup gtc_matrix_integer
bool main_gtc_matrix_integer(); ///@{
}//namespace test
namespace gtc{ typedef detail::tmat2x2<highp_int> highp_imat2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
//! GLM_GTC_matrix_integer extension: Add integer matrices typedef detail::tmat3x3<highp_int> highp_imat3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
namespace matrix_integer typedef detail::tmat4x4<highp_int> highp_imat4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
{
/// \addtogroup gtc_matrix_integer
///@{
typedef detail::tmat2x2<highp_int> highp_imat2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x2<highp_int> highp_imat2x2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<highp_int> highp_imat3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x3<highp_int> highp_imat2x3; //!< \brief High-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<highp_int> highp_imat4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x4<highp_int> highp_imat2x4; //!< \brief High-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x2<highp_int> highp_imat3x2; //!< \brief High-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<highp_int> highp_imat3x3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x4<highp_int> highp_imat3x4; //!< \brief High-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x2<highp_int> highp_imat4x2; //!< \brief High-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x3<highp_int> highp_imat4x3; //!< \brief High-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<highp_int> highp_imat4x4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<highp_int> highp_imat2x2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x2<mediump_int> mediump_imat2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x3<highp_int> highp_imat2x3; //!< \brief High-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat3x3<mediump_int> mediump_imat3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x4<highp_int> highp_imat2x4; //!< \brief High-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat4x4<mediump_int> mediump_imat4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x2<highp_int> highp_imat3x2; //!< \brief High-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<highp_int> highp_imat3x3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x4<highp_int> highp_imat3x4; //!< \brief High-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x2<highp_int> highp_imat4x2; //!< \brief High-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x3<highp_int> highp_imat4x3; //!< \brief High-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<highp_int> highp_imat4x4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<mediump_int> mediump_imat2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x2<mediump_int> mediump_imat2x2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<mediump_int> mediump_imat3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x3<mediump_int> mediump_imat2x3; //!< \brief Medium-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<mediump_int> mediump_imat4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x4<mediump_int> mediump_imat2x4; //!< \brief Medium-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x2<mediump_int> mediump_imat3x2; //!< \brief Medium-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<mediump_int> mediump_imat3x3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x4<mediump_int> mediump_imat3x4; //!< \brief Medium-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x2<mediump_int> mediump_imat4x2; //!< \brief Medium-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x3<mediump_int> mediump_imat4x3; //!< \brief Medium-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<mediump_int> mediump_imat4x4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<mediump_int> mediump_imat2x2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x2<lowp_int> lowp_imat2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x3<mediump_int> mediump_imat2x3; //!< \brief Medium-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat3x3<lowp_int> lowp_imat3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x4<mediump_int> mediump_imat2x4; //!< \brief Medium-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat4x4<lowp_int> lowp_imat4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x2<mediump_int> mediump_imat3x2; //!< \brief Medium-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<mediump_int> mediump_imat3x3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x4<mediump_int> mediump_imat3x4; //!< \brief Medium-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x2<mediump_int> mediump_imat4x2; //!< \brief Medium-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x3<mediump_int> mediump_imat4x3; //!< \brief Medium-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<mediump_int> mediump_imat4x4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<lowp_int> lowp_imat2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x2<lowp_int> lowp_imat2x2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<lowp_int> lowp_imat3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x3<lowp_int> lowp_imat2x3; //!< \brief Low-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<lowp_int> lowp_imat4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x4<lowp_int> lowp_imat2x4; //!< \brief Low-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x2<lowp_int> lowp_imat3x2; //!< \brief Low-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<lowp_int> lowp_imat3x3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x4<lowp_int> lowp_imat3x4; //!< \brief Low-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x2<lowp_int> lowp_imat4x2; //!< \brief Low-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x3<lowp_int> lowp_imat4x3; //!< \brief Low-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<lowp_int> lowp_imat4x4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<lowp_int> lowp_imat2x2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x2<highp_uint> highp_umat2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x3<lowp_int> lowp_imat2x3; //!< \brief Low-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat3x3<highp_uint> highp_umat3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x4<lowp_int> lowp_imat2x4; //!< \brief Low-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat4x4<highp_uint> highp_umat4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x2<lowp_int> lowp_imat3x2; //!< \brief Low-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<lowp_int> lowp_imat3x3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x4<lowp_int> lowp_imat3x4; //!< \brief Low-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x2<lowp_int> lowp_imat4x2; //!< \brief Low-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x3<lowp_int> lowp_imat4x3; //!< \brief Low-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<lowp_int> lowp_imat4x4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<highp_uint> highp_umat2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x2<highp_uint> highp_umat2x2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<highp_uint> highp_umat3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x3<highp_uint> highp_umat2x3; //!< \brief High-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<highp_uint> highp_umat4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x4<highp_uint> highp_umat2x4; //!< \brief High-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x2<highp_uint> highp_umat3x2; //!< \brief High-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<highp_uint> highp_umat3x3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x4<highp_uint> highp_umat3x4; //!< \brief High-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x2<highp_uint> highp_umat4x2; //!< \brief High-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x3<highp_uint> highp_umat4x3; //!< \brief High-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<highp_uint> highp_umat4x4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<highp_uint> highp_umat2x2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x2<mediump_uint> mediump_umat2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x3<highp_uint> highp_umat2x3; //!< \brief High-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat3x3<mediump_uint> mediump_umat3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x4<highp_uint> highp_umat2x4; //!< \brief High-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat4x4<mediump_uint> mediump_umat4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x2<highp_uint> highp_umat3x2; //!< \brief High-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<highp_uint> highp_umat3x3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x4<highp_uint> highp_umat3x4; //!< \brief High-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x2<highp_uint> highp_umat4x2; //!< \brief High-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x3<highp_uint> highp_umat4x3; //!< \brief High-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<highp_uint> highp_umat4x4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<mediump_uint> mediump_umat2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x2<mediump_uint> mediump_umat2x2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<mediump_uint> mediump_umat3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x3<mediump_uint> mediump_umat2x3; //!< \brief Medium-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<mediump_uint> mediump_umat4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x4<mediump_uint> mediump_umat2x4; //!< \brief Medium-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x2<mediump_uint> mediump_umat3x2; //!< \brief Medium-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<mediump_uint> mediump_umat3x3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x4<mediump_uint> mediump_umat3x4; //!< \brief Medium-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x2<mediump_uint> mediump_umat4x2; //!< \brief Medium-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x3<mediump_uint> mediump_umat4x3; //!< \brief Medium-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<mediump_uint> mediump_umat4x4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<mediump_uint> mediump_umat2x2; //!< \brief Medium-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x2<lowp_uint> lowp_umat2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x3<mediump_uint> mediump_umat2x3; //!< \brief Medium-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat3x3<lowp_uint> lowp_umat3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x4<mediump_uint> mediump_umat2x4; //!< \brief Medium-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat4x4<lowp_uint> lowp_umat4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x2<mediump_uint> mediump_umat3x2; //!< \brief Medium-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<mediump_uint> mediump_umat3x3; //!< \brief Medium-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x4<mediump_uint> mediump_umat3x4; //!< \brief Medium-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x2<mediump_uint> mediump_umat4x2; //!< \brief Medium-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x3<mediump_uint> mediump_umat4x3; //!< \brief Medium-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<mediump_uint> mediump_umat4x4; //!< \brief Medium-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<lowp_uint> lowp_umat2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x2<lowp_uint> lowp_umat2x2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<lowp_uint> lowp_umat3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x3<lowp_uint> lowp_umat2x3; //!< \brief Low-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<lowp_uint> lowp_umat4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat2x4<lowp_uint> lowp_umat2x4; //!< \brief Low-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x2<lowp_uint> lowp_umat3x2; //!< \brief Low-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<lowp_uint> lowp_umat2x2; //!< \brief Low-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat3x3<lowp_uint> lowp_umat3x3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x3<lowp_uint> lowp_umat2x3; //!< \brief Low-precision signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat3x4<lowp_uint> lowp_umat3x4; //!< \brief Low-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x4<lowp_uint> lowp_umat2x4; //!< \brief Low-precision signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat4x2<lowp_uint> lowp_umat4x2; //!< \brief Low-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x2<lowp_uint> lowp_umat3x2; //!< \brief Low-precision signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat4x3<lowp_uint> lowp_umat4x3; //!< \brief Low-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<lowp_uint> lowp_umat3x3; //!< \brief Low-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef detail::tmat4x4<lowp_uint> lowp_umat4x4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x4<lowp_uint> lowp_umat3x4; //!< \brief Low-precision signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x2<lowp_uint> lowp_umat4x2; //!< \brief Low-precision signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x3<lowp_uint> lowp_umat4x3; //!< \brief Low-precision signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<lowp_uint> lowp_umat4x4; //!< \brief Low-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#if(defined(GLM_PRECISION_HIGHP_INT)) #if(defined(GLM_PRECISION_HIGHP_INT))
typedef highp_imat2 imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_imat2 imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat3 imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_imat3 imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat4 imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_imat4 imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat2x2 imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_imat2x2 imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat2x3 imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_imat2x3 imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat2x4 imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_imat2x4 imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat3x2 imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_imat3x2 imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat3x3 imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_imat3x3 imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat3x4 imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_imat3x4 imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat4x2 imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_imat4x2 imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat4x3 imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_imat4x3 imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_imat4x4 imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_imat4x4 imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#elif(defined(GLM_PRECISION_LOWP_INT)) #elif(defined(GLM_PRECISION_LOWP_INT))
typedef lowp_imat2 imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_imat2 imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat3 imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_imat3 imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat4 imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_imat4 imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat2x2 imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_imat2x2 imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat2x3 imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_imat2x3 imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat2x4 imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_imat2x4 imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat3x2 imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_imat3x2 imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat3x3 imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_imat3x3 imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat3x4 imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_imat3x4 imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat4x2 imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_imat4x2 imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat4x3 imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_imat4x3 imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_imat4x4 imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_imat4x4 imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#else //if(defined(GLM_PRECISION_MEDIUMP_INT)) #else //if(defined(GLM_PRECISION_MEDIUMP_INT))
typedef mediump_imat2 imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_imat2 imat2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat3 imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_imat3 imat3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat4 imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_imat4 imat4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat2x2 imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_imat2x2 imat2x2; //!< \brief Signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat2x3 imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_imat2x3 imat2x3; //!< \brief Signed integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat2x4 imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_imat2x4 imat2x4; //!< \brief Signed integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat3x2 imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_imat3x2 imat3x2; //!< \brief Signed integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat3x3 imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_imat3x3 imat3x3; //!< \brief Signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat3x4 imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_imat3x4 imat3x4; //!< \brief Signed integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat4x2 imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_imat4x2 imat4x2; //!< \brief Signed integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat4x3 imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_imat4x3 imat4x3; //!< \brief Signed integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_imat4x4 imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_imat4x4 imat4x4; //!< \brief Signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#endif//GLM_PRECISION #endif//GLM_PRECISION
#if(defined(GLM_PRECISION_HIGHP_UINT)) #if(defined(GLM_PRECISION_HIGHP_UINT))
typedef highp_umat2 umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_umat2 umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat3 umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_umat3 umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat4 umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_umat4 umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat2x2 umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_umat2x2 umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat2x3 umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_umat2x3 umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat2x4 umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_umat2x4 umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat3x2 umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_umat3x2 umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat3x3 umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_umat3x3 umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat3x4 umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_umat3x4 umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat4x2 umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_umat4x2 umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat4x3 umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_umat4x3 umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef highp_umat4x4 umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef highp_umat4x4 umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#elif(defined(GLM_PRECISION_LOWP_UINT)) #elif(defined(GLM_PRECISION_LOWP_UINT))
typedef lowp_umat2 umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_umat2 umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat3 umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_umat3 umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat4 umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_umat4 umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat2x2 umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_umat2x2 umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat2x3 umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_umat2x3 umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat2x4 umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_umat2x4 umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat3x2 umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_umat3x2 umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat3x3 umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_umat3x3 umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat3x4 umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_umat3x4 umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat4x2 umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_umat4x2 umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat4x3 umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_umat4x3 umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef lowp_umat4x4 umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef lowp_umat4x4 umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#else //if(defined(GLM_PRECISION_MEDIUMP_UINT)) #else //if(defined(GLM_PRECISION_MEDIUMP_UINT))
typedef mediump_umat2 umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_umat2 umat2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat3 umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_umat3 umat3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat4 umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_umat4 umat4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat2x2 umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_umat2x2 umat2x2; //!< \brief Unsigned integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat2x3 umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_umat2x3 umat2x3; //!< \brief Unsigned integer 2x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat2x4 umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_umat2x4 umat2x4; //!< \brief Unsigned integer 2x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat3x2 umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_umat3x2 umat3x2; //!< \brief Unsigned integer 3x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat3x3 umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_umat3x3 umat3x3; //!< \brief Unsigned integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat3x4 umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_umat3x4 umat3x4; //!< \brief Unsigned integer 3x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat4x2 umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_umat4x2 umat4x2; //!< \brief Unsigned integer 4x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat4x3 umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_umat4x3 umat4x3; //!< \brief Unsigned integer 4x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef mediump_umat4x4 umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension) typedef mediump_umat4x4 umat4x4; //!< \brief Unsigned integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
#endif//GLM_PRECISION #endif//GLM_PRECISION
///@} ///@}
}//namespace matrix_integer }//namespace matrix_integer
}//namespace gtc }//namespace gtc
}//namespace glm }//namespace glm
namespace glm{using namespace gtc::matrix_integer;} namespace glm{using namespace gtc::matrix_integer;}

3
glm/gtc/matrix_inverse.hpp
View File

@ -22,8 +22,7 @@
namespace glm{ namespace glm{
namespace gtc{ namespace gtc{
//! GLM_GTC_matrix_inverse extension: Inverse matrix functions namespace matrix_inverse ///< GLM_GTC_matrix_inverse extension: Inverse matrix functions
namespace matrix_inverse
{ {
/// \addtogroup gtc_matrix_inverse /// \addtogroup gtc_matrix_inverse
///@{ ///@{

230
glm/gtc/matrix_transform.hpp
View File

@ -21,140 +21,134 @@
# pragma message("GLM: GLM_GTC_matrix_transform extension included") # pragma message("GLM: GLM_GTC_matrix_transform extension included")
#endif #endif
namespace glm namespace glm{
namespace gtc{
namespace matrix_transform ///< GLM_GTC_matrix_transform extension: Add transformation matrices
{ {
namespace test{ /// \addtogroup gtc_matrix_transform
bool main_gtc_matrix_transform(); ///@{
}//namespace test
namespace gtc{ //! Builds a translation 4 * 4 matrix created from a vector of 3 components.
//! GLM_GTC_matrix_transform extension: Add transformation matrices //! From GLM_GTC_matrix_transform extension.
namespace matrix_transform template <typename T>
{ detail::tmat4x4<T> translate(
/// \addtogroup gtc_matrix_transform detail::tmat4x4<T> const & m,
///@{ detail::tvec3<T> const & v);
//! Builds a translation 4 * 4 matrix created from a vector of 3 components.
//! From GLM_GTC_matrix_transform extension.
template <typename T>
detail::tmat4x4<T> translate(
detail::tmat4x4<T> const & m,
detail::tvec3<T> const & v);
//! Builds a rotation 4 * 4 matrix created from an axis vector and an angle expressed in degrees. //! Builds a rotation 4 * 4 matrix created from an axis vector and an angle expressed in degrees.
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename T> template <typename T>
detail::tmat4x4<T> rotate( detail::tmat4x4<T> rotate(
detail::tmat4x4<T> const & m, detail::tmat4x4<T> const & m,
T const & angle, T const & angle,
detail::tvec3<T> const & v); detail::tvec3<T> const & v);
//! Builds a scale 4 * 4 matrix created from 3 scalars. //! Builds a scale 4 * 4 matrix created from 3 scalars.
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename T> template <typename T>
detail::tmat4x4<T> scale( detail::tmat4x4<T> scale(
detail::tmat4x4<T> const & m, detail::tmat4x4<T> const & m,
detail::tvec3<T> const & v); detail::tvec3<T> const & v);
//! Creates a matrix for an orthographic parallel viewing volume. //! Creates a matrix for an orthographic parallel viewing volume.
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename T> template <typename T>
detail::tmat4x4<T> ortho( detail::tmat4x4<T> ortho(
T const & left, T const & left,
T const & right, T const & right,
T const & bottom, T const & bottom,
T const & top, T const & top,
T const & zNear, T const & zNear,
T const & zFar); T const & zFar);
//! Creates a matrix for projecting two-dimensional coordinates onto the screen. //! Creates a matrix for projecting two-dimensional coordinates onto the screen.
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename T> template <typename T>
detail::tmat4x4<T> ortho( detail::tmat4x4<T> ortho(
T const & left, T const & left,
T const & right, T const & right,
T const & bottom, T const & bottom,
T const & top); T const & top);
//! Creates a frustum matrix. //! Creates a frustum matrix.
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename T> template <typename T>
detail::tmat4x4<T> frustum( detail::tmat4x4<T> frustum(
T const & left, T const & left,
T const & right, T const & right,
T const & bottom, T const & bottom,
T const & top, T const & top,
T const & nearVal, T const & nearVal,
T const & farVal); T const & farVal);
//! Creates a matrix for a symetric perspective-view frustum. //! Creates a matrix for a symetric perspective-view frustum.
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename T> template <typename T>
detail::tmat4x4<T> perspective( detail::tmat4x4<T> perspective(
T const & fovy, T const & fovy,
T const & aspect, T const & aspect,
T const & zNear, T const & zNear,
T const & zFar); T const & zFar);
//! Builds a perspective projection matrix based on a field of view //! Builds a perspective projection matrix based on a field of view
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename valType> template <typename valType>
detail::tmat4x4<valType> perspectiveFov( detail::tmat4x4<valType> perspectiveFov(
valType const & fov, valType const & fov,
valType const & width, valType const & width,
valType const & height, valType const & height,
valType const & zNear, valType const & zNear,
valType const & zFar); valType const & zFar);
//! Creates a matrix for a symmetric perspective-view frustum with far plane at infinite . //! Creates a matrix for a symmetric perspective-view frustum with far plane at infinite .
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename T> template <typename T>
detail::tmat4x4<T> infinitePerspective( detail::tmat4x4<T> infinitePerspective(
T fovy, T aspect, T zNear); T fovy, T aspect, T zNear);
//! Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping. //! Creates a matrix for a symmetric perspective-view frustum with far plane at infinite for graphics hardware that doesn't support depth clamping.
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename T> template <typename T>
detail::tmat4x4<T> tweakedInfinitePerspective( detail::tmat4x4<T> tweakedInfinitePerspective(
T fovy, T aspect, T zNear); T fovy, T aspect, T zNear);
//! Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates. //! Map the specified object coordinates (obj.x, obj.y, obj.z) into window coordinates.
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename T, typename U> template <typename T, typename U>
detail::tvec3<T> project( detail::tvec3<T> project(
detail::tvec3<T> const & obj, detail::tvec3<T> const & obj,
detail::tmat4x4<T> const & model, detail::tmat4x4<T> const & model,
detail::tmat4x4<T> const & proj, detail::tmat4x4<T> const & proj,
detail::tvec4<U> const & viewport); detail::tvec4<U> const & viewport);
//! Map the specified window coordinates (win.x, win.y, win.z) into object coordinates. //! Map the specified window coordinates (win.x, win.y, win.z) into object coordinates.
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename T, typename U> template <typename T, typename U>
detail::tvec3<T> unProject( detail::tvec3<T> unProject(
detail::tvec3<T> const & win, detail::tvec3<T> const & win,
detail::tmat4x4<T> const & model, detail::tmat4x4<T> const & model,
detail::tmat4x4<T> const & proj, detail::tmat4x4<T> const & proj,
detail::tvec4<U> const & viewport); detail::tvec4<U> const & viewport);
//! Define a picking region //! Define a picking region
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename T, typename U> template <typename T, typename U>
detail::tmat4x4<T> pickMatrix( detail::tmat4x4<T> pickMatrix(
detail::tvec2<T> const & center, detail::tvec2<T> const & center,
detail::tvec2<T> const & delta, detail::tvec2<T> const & delta,
detail::tvec4<U> const & viewport); detail::tvec4<U> const & viewport);
//! Build a look at view matrix. //! Build a look at view matrix.
//! From GLM_GTC_matrix_transform extension. //! From GLM_GTC_matrix_transform extension.
template <typename T> template <typename T>
detail::tmat4x4<T> lookAt( detail::tmat4x4<T> lookAt(
detail::tvec3<T> const & eye, detail::tvec3<T> const & eye,
detail::tvec3<T> const & center, detail::tvec3<T> const & center,
detail::tvec3<T> const & up); detail::tvec3<T> const & up);
///@} ///@}
}//namespace matrix_transform }//namespace matrix_transform
}//namespace gtc }//namespace gtc
}//namespace glm }//namespace glm
#include "matrix_transform.inl" #include "matrix_transform.inl"

322
glm/gtc/quaternion.hpp
View File

@ -26,206 +26,200 @@
# pragma message("GLM: GLM_GTC_quaternion extension included") # pragma message("GLM: GLM_GTC_quaternion extension included")
#endif #endif
namespace glm namespace glm{
namespace detail
{ {
namespace test{ //! \brief Template for quaternion.
bool main_gtc_quaternion(); //! From GLM_GTC_quaternion extension.
}//namespace test /// \ingroup gtc_quaternion
template <typename T>
namespace detail struct tquat// : public genType<T, tquat>
{ {
//! \brief Template for quaternion. typedef T value_type;
//! From GLM_GTC_quaternion extension.
/// \ingroup gtc_quaternion
template <typename T>
struct tquat// : public genType<T, tquat>
{
typedef T value_type;
public: public:
value_type x, y, z, w; value_type x, y, z, w;
// Constructors // Constructors
tquat(); tquat();
explicit tquat( explicit tquat(
value_type const & s, value_type const & s,
tvec3<T> const & v); tvec3<T> const & v);
explicit tquat( explicit tquat(
value_type const & w, value_type const & w,
value_type const & x, value_type const & x,
value_type const & y, value_type const & y,
value_type const & z); value_type const & z);
// Convertions // Convertions
//explicit tquat(valType const & pitch, valType const & yaw, valType const & roll); //explicit tquat(valType const & pitch, valType const & yaw, valType const & roll);
//! pitch, yaw, roll //! pitch, yaw, roll
explicit tquat( explicit tquat(
tvec3<T> const & eulerAngles); tvec3<T> const & eulerAngles);
explicit tquat( explicit tquat(
tmat3x3<T> const & m); tmat3x3<T> const & m);
explicit tquat( explicit tquat(
tmat4x4<T> const & m); tmat4x4<T> const & m);
// Accesses // Accesses
value_type & operator[](int i); value_type & operator[](int i);
value_type const & operator[](int i) const; value_type const & operator[](int i) const;
// Operators // Operators
tquat<T> & operator*=(value_type const & s); tquat<T> & operator*=(value_type const & s);
tquat<T> & operator/=(value_type const & s); tquat<T> & operator/=(value_type const & s);
}; };
template <typename T> template <typename T>
detail::tquat<T> operator- ( detail::tquat<T> operator- (
detail::tquat<T> const & q); detail::tquat<T> const & q);
template <typename T> template <typename T>
detail::tquat<T> operator* ( detail::tquat<T> operator* (
detail::tquat<T> const & q, detail::tquat<T> const & q,
detail::tquat<T> const & p); detail::tquat<T> const & p);
template <typename T> template <typename T>
detail::tvec3<T> operator* ( detail::tvec3<T> operator* (
detail::tquat<T> const & q, detail::tquat<T> const & q,
detail::tvec3<T> const & v); detail::tvec3<T> const & v);
template <typename T> template <typename T>
detail::tvec3<T> operator* ( detail::tvec3<T> operator* (
detail::tvec3<T> const & v, detail::tvec3<T> const & v,
detail::tquat<T> const & q); detail::tquat<T> const & q);
template <typename T> template <typename T>
detail::tvec4<T> operator* ( detail::tvec4<T> operator* (
detail::tquat<T> const & q, detail::tquat<T> const & q,
detail::tvec4<T> const & v); detail::tvec4<T> const & v);
template <typename T> template <typename T>
detail::tvec4<T> operator* ( detail::tvec4<T> operator* (
detail::tvec4<T> const & v, detail::tvec4<T> const & v,
detail::tquat<T> const & q); detail::tquat<T> const & q);
template <typename T> template <typename T>
detail::tquat<T> operator* ( detail::tquat<T> operator* (
detail::tquat<T> const & q, detail::tquat<T> const & q,
typename detail::tquat<T>::value_type const & s); typename detail::tquat<T>::value_type const & s);
template <typename T> template <typename T>
detail::tquat<T> operator* ( detail::tquat<T> operator* (
typename detail::tquat<T>::value_type const & s, typename detail::tquat<T>::value_type const & s,
detail::tquat<T> const & q); detail::tquat<T> const & q);
template <typename T> template <typename T>
detail::tquat<T> operator/ ( detail::tquat<T> operator/ (
detail::tquat<T> const & q, detail::tquat<T> const & q,
typename detail::tquat<T>::value_type const & s); typename detail::tquat<T>::value_type const & s);
} //namespace detail } //namespace detail
namespace gtc{ namespace gtc{
//! GLM_GTC_quaternion extension: Quaternion types and functions namespace quaternion ///< GLM_GTC_quaternion extension: Quaternion types and functions
namespace quaternion {
{ /// \addtogroup gtc_quaternion
/// \addtogroup gtc_quaternion ///@{
///@{
//! Returns the length of the quaternion x. //! Returns the length of the quaternion x.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
template <typename T> template <typename T>
typename detail::tquat<T>::value_type length( typename detail::tquat<T>::value_type length(
detail::tquat<T> const & q); detail::tquat<T> const & q);
//! Returns the normalized quaternion of from x. //! Returns the normalized quaternion of from x.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
template <typename T> template <typename T>
detail::tquat<T> normalize( detail::tquat<T> normalize(
detail::tquat<T> const & q); detail::tquat<T> const & q);
//! Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ... //! Returns dot product of q1 and q2, i.e., q1[0] * q2[0] + q1[1] * q2[1] + ...
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
template <typename T> template <typename T>
typename detail::tquat<T>::value_type dot( typename detail::tquat<T>::value_type dot(
detail::tquat<T> const & q1, detail::tquat<T> const & q1,
detail::tquat<T> const & q2); detail::tquat<T> const & q2);
//! Returns the cross product of q1 and q2. //! Returns the cross product of q1 and q2.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
template <typename T> template <typename T>
GLM_DEPRECATED detail::tquat<T> cross( GLM_DEPRECATED detail::tquat<T> cross(
detail::tquat<T> const & q1, detail::tquat<T> const & q1,
detail::tquat<T> const & q2); detail::tquat<T> const & q2);
//! Returns a SLERP interpolated quaternion of x and y according a. //! Returns a SLERP interpolated quaternion of x and y according a.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
template <typename T> template <typename T>
detail::tquat<T> mix( detail::tquat<T> mix(
detail::tquat<T> const & x, detail::tquat<T> const & x,
detail::tquat<T> const & y, detail::tquat<T> const & y,
typename detail::tquat<T>::value_type const & a); typename detail::tquat<T>::value_type const & a);
//! Returns the q conjugate. //! Returns the q conjugate.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
template <typename T> template <typename T>
detail::tquat<T> conjugate( detail::tquat<T> conjugate(
detail::tquat<T> const & q); detail::tquat<T> const & q);
//! Returns the q inverse. //! Returns the q inverse.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
template <typename T> template <typename T>
detail::tquat<T> inverse( detail::tquat<T> inverse(
detail::tquat<T> const & q); detail::tquat<T> const & q);
//! Rotates a quaternion from an vector of 3 components axis and an angle expressed in degrees. //! Rotates a quaternion from an vector of 3 components axis and an angle expressed in degrees.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
template <typename T> template <typename T>
detail::tquat<T> rotate( detail::tquat<T> rotate(
detail::tquat<T> const & q, detail::tquat<T> const & q,
typename detail::tquat<T>::value_type const & angle, typename detail::tquat<T>::value_type const & angle,
detail::tvec3<T> const & v); detail::tvec3<T> const & v);
//! Converts a quaternion to a 3 * 3 matrix. //! Converts a quaternion to a 3 * 3 matrix.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
template <typename T> template <typename T>
detail::tmat3x3<T> mat3_cast( detail::tmat3x3<T> mat3_cast(
detail::tquat<T> const & x); detail::tquat<T> const & x);
//! Converts a quaternion to a 4 * 4 matrix. //! Converts a quaternion to a 4 * 4 matrix.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
template <typename T> template <typename T>
detail::tmat4x4<T> mat4_cast( detail::tmat4x4<T> mat4_cast(
detail::tquat<T> const & x); detail::tquat<T> const & x);
//! Converts a 3 * 3 matrix to a quaternion. //! Converts a 3 * 3 matrix to a quaternion.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
template <typename T> template <typename T>
detail::tquat<T> quat_cast( detail::tquat<T> quat_cast(
detail::tmat3x3<T> const & x); detail::tmat3x3<T> const & x);
//! Converts a 4 * 4 matrix to a quaternion. //! Converts a 4 * 4 matrix to a quaternion.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
template <typename T> template <typename T>
detail::tquat<T> quat_cast( detail::tquat<T> quat_cast(
detail::tmat4x4<T> const & x); detail::tmat4x4<T> const & x);
//! Quaternion of floating-point numbers. //! Quaternion of floating-point numbers.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
typedef detail::tquat<float> quat; typedef detail::tquat<float> quat;
//! Quaternion of half-precision floating-point numbers. //! Quaternion of half-precision floating-point numbers.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
typedef detail::tquat<detail::thalf> hquat; typedef detail::tquat<detail::thalf> hquat;
//! Quaternion of single-precision floating-point numbers. //! Quaternion of single-precision floating-point numbers.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
typedef detail::tquat<float> fquat; typedef detail::tquat<float> fquat;
//! Quaternion of double-precision floating-point numbers. //! Quaternion of double-precision floating-point numbers.
//! From GLM_GTC_quaternion extension. //! From GLM_GTC_quaternion extension.
typedef detail::tquat<double> dquat; typedef detail::tquat<double> dquat;
///@} ///@}
}//namespace quaternion } //namespace quaternion
}//namespace gtc } //namespace gtc
} //namespace glm } //namespace glm
#include "quaternion.inl" #include "quaternion.inl"

546
glm/gtc/swizzle.hpp
View File

@ -21,333 +21,327 @@
# pragma message("GLM: GLM_GTC_swizzle extension included") # pragma message("GLM: GLM_GTC_swizzle extension included")
#endif #endif
namespace glm namespace glm{
namespace gtc{
namespace swizzle ///< GLM_GTC_swizzle extension
{ {
namespace test{ using namespace gtc::half_float;
void main_gtc_swizzle();
}//namespace test
namespace gtc{ template <typename T, template <typename> class vecType>
//! GLM_GTC_swizzle extension T const & swizzle(
namespace swizzle vecType<T> const & v,
{ comp x);
using namespace gtc::half_float;
template <typename T, template <typename> class vecType> template <typename T, template <typename> class vecType>
T const & swizzle( detail::tvec2<T> const & swizzle(
vecType<T> const & v, vecType<T> const & v,
comp x); comp x, comp y);
template <typename T, template <typename> class vecType> template <typename T, template <typename> class vecType>
detail::tvec2<T> const & swizzle( detail::tvec3<T> const & swizzle(
vecType<T> const & v, vecType<T> const & v,
comp x, comp y); comp x, comp y, comp z);
template <typename T, template <typename> class vecType> template <typename T, template <typename> class vecType>
detail::tvec3<T> const & swizzle( detail::tvec4<T> const & swizzle(
vecType<T> const & v, vecType<T> const & v,
comp x, comp y, comp z); comp x, comp y, comp z, comp w);
template <typename T, template <typename> class vecType> template <typename T, template <typename> class vecType>
detail::tvec4<T> const & swizzle( T & swizzle(
vecType<T> const & v, vecType<T> & v,
comp x, comp y, comp z, comp w); comp x);
template <typename T, template <typename> class vecType> template <typename T, template <typename> class vecType>
T & swizzle( detail::tref2<T> swizzle(
vecType<T> & v, vecType<T> & v,
comp x); comp x, comp y);
template <typename T, template <typename> class vecType> template <typename T, template <typename> class vecType>
detail::tref2<T> swizzle( detail::tref3<T> swizzle(
vecType<T> & v, vecType<T> & v,
comp x, comp y); comp x, comp y, comp z);
template <typename T, template <typename> class vecType> template <typename T, template <typename> class vecType>
detail::tref3<T> swizzle( detail::tref4<T> swizzle(
vecType<T> & v, vecType<T> & v,
comp x, comp y, comp z); comp x, comp y, comp z, comp w);
template <typename T, template <typename> class vecType>
detail::tref4<T> swizzle(
vecType<T> & v,
comp x, comp y, comp z, comp w);
# define static_swizzle1(TYPE, SIZE) \ # define static_swizzle1(TYPE, SIZE) \
template <comp x> \ template <comp x> \
GLM_FUNC_QUALIFIER TYPE swizzle(detail::tvec##SIZE<TYPE> const & v) \ GLM_FUNC_QUALIFIER TYPE swizzle(detail::tvec##SIZE<TYPE> const & v) \
{return v[x];} \ {return v[x];} \
\ \
template <comp x> \ template <comp x> \
GLM_FUNC_QUALIFIER TYPE& swizzle(detail::tvec##SIZE<TYPE> & v) \ GLM_FUNC_QUALIFIER TYPE& swizzle(detail::tvec##SIZE<TYPE> & v) \
{return v[x];} {return v[x];}
static_swizzle1(detail::float16, 2) static_swizzle1(detail::float16, 2)
static_swizzle1(detail::float16, 3) static_swizzle1(detail::float16, 3)
static_swizzle1(detail::float16, 4) static_swizzle1(detail::float16, 4)
static_swizzle1(detail::float32, 2) static_swizzle1(detail::float32, 2)
static_swizzle1(detail::float32, 3) static_swizzle1(detail::float32, 3)
static_swizzle1(detail::float32, 4) static_swizzle1(detail::float32, 4)
static_swizzle1(detail::float64, 2) static_swizzle1(detail::float64, 2)
static_swizzle1(detail::float64, 3) static_swizzle1(detail::float64, 3)
static_swizzle1(detail::float64, 4) static_swizzle1(detail::float64, 4)
static_swizzle1(detail::int8, 2) static_swizzle1(detail::int8, 2)
static_swizzle1(detail::int8, 3) static_swizzle1(detail::int8, 3)
static_swizzle1(detail::int8, 4) static_swizzle1(detail::int8, 4)
static_swizzle1(detail::int16, 2) static_swizzle1(detail::int16, 2)
static_swizzle1(detail::int16, 3) static_swizzle1(detail::int16, 3)
static_swizzle1(detail::int16, 4) static_swizzle1(detail::int16, 4)
static_swizzle1(detail::int32, 2) static_swizzle1(detail::int32, 2)
static_swizzle1(detail::int32, 3) static_swizzle1(detail::int32, 3)
static_swizzle1(detail::int32, 4) static_swizzle1(detail::int32, 4)
static_swizzle1(detail::int64, 2) static_swizzle1(detail::int64, 2)
static_swizzle1(detail::int64, 3) static_swizzle1(detail::int64, 3)
static_swizzle1(detail::int64, 4) static_swizzle1(detail::int64, 4)
static_swizzle1(detail::uint8, 2) static_swizzle1(detail::uint8, 2)
static_swizzle1(detail::uint8, 3) static_swizzle1(detail::uint8, 3)
static_swizzle1(detail::uint8, 4) static_swizzle1(detail::uint8, 4)
static_swizzle1(detail::uint16, 2) static_swizzle1(detail::uint16, 2)
static_swizzle1(detail::uint16, 3) static_swizzle1(detail::uint16, 3)
static_swizzle1(detail::uint16, 4) static_swizzle1(detail::uint16, 4)
static_swizzle1(detail::uint32, 2) static_swizzle1(detail::uint32, 2)
static_swizzle1(detail::uint32, 3) static_swizzle1(detail::uint32, 3)
static_swizzle1(detail::uint32, 4) static_swizzle1(detail::uint32, 4)
static_swizzle1(detail::uint64, 2) static_swizzle1(detail::uint64, 2)
static_swizzle1(detail::uint64, 3) static_swizzle1(detail::uint64, 3)
static_swizzle1(detail::uint64, 4) static_swizzle1(detail::uint64, 4)
# define static_swizzle2_const(TYPE) \ # define static_swizzle2_const(TYPE) \
template <comp x, comp y> \ template <comp x, comp y> \
GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \ GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
{return TYPE(v[x], v[y]);} {return TYPE(v[x], v[y]);}
# define static_swizzle3_const(TYPE) \ # define static_swizzle3_const(TYPE) \
template <comp x, comp y, comp z> \ template <comp x, comp y, comp z> \
GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \ GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
{return TYPE(v[x], v[y], v[z]);} {return TYPE(v[x], v[y], v[z]);}
# define static_swizzle4_const(TYPE) \ # define static_swizzle4_const(TYPE) \
template <comp x, comp y, comp z, comp w> \ template <comp x, comp y, comp z, comp w> \
GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \ GLM_FUNC_QUALIFIER TYPE swizzle(TYPE const & v) \
{return TYPE(v[x], v[y], v[z], v[w]);} {return TYPE(v[x], v[y], v[z], v[w]);}
/* /*
# define static_swizzle2_const(TYPE, SIZE) \ # define static_swizzle2_const(TYPE, SIZE) \
template <comp x, comp y> \ template <comp x, comp y> \
GLM_FUNC_QUALIFIER detail::tvec2<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v) \ GLM_FUNC_QUALIFIER detail::tvec2<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v) \
{return detail::tvec2<TYPE>(v[x], v[y]);} {return detail::tvec2<TYPE>(v[x], v[y]);}
# define static_swizzle3_const(TYPE, SIZE) \ # define static_swizzle3_const(TYPE, SIZE) \
template <comp x, comp y, comp z> \ template <comp x, comp y, comp z> \
GLM_FUNC_QUALIFIER detail::tvec3<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v) \ GLM_FUNC_QUALIFIER detail::tvec3<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v) \
{return detail::tvec3<TYPE>(v[x], v[y], v[z]);} {return detail::tvec3<TYPE>(v[x], v[y], v[z]);}
# define static_swizzle4_const(TYPE, SIZE) \ # define static_swizzle4_const(TYPE, SIZE) \
template <comp x, comp y, comp z, comp w> \ template <comp x, comp y, comp z, comp w> \
GLM_FUNC_QUALIFIER detail::tvec4<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v) \ GLM_FUNC_QUALIFIER detail::tvec4<TYPE> swizzle(detail::tvec##SIZE<TYPE> const & v) \
{return detail::tvec4<TYPE>(v[x], v[y], v[z], v[w]);} {return detail::tvec4<TYPE>(v[x], v[y], v[z], v[w]);}
*/ */
static_swizzle2_const(glm::f16vec2) static_swizzle2_const(glm::f16vec2)
static_swizzle2_const(glm::f16vec3) static_swizzle2_const(glm::f16vec3)
static_swizzle2_const(glm::f16vec4) static_swizzle2_const(glm::f16vec4)
static_swizzle2_const(glm::f32vec2) static_swizzle2_const(glm::f32vec2)
static_swizzle2_const(glm::f32vec3) static_swizzle2_const(glm::f32vec3)
static_swizzle2_const(glm::f32vec4) static_swizzle2_const(glm::f32vec4)
static_swizzle2_const(glm::f64vec2) static_swizzle2_const(glm::f64vec2)
static_swizzle2_const(glm::f64vec3) static_swizzle2_const(glm::f64vec3)
static_swizzle2_const(glm::f64vec4) static_swizzle2_const(glm::f64vec4)
static_swizzle2_const(glm::i8vec2) static_swizzle2_const(glm::i8vec2)
static_swizzle2_const(glm::i8vec3) static_swizzle2_const(glm::i8vec3)
static_swizzle2_const(glm::i8vec4) static_swizzle2_const(glm::i8vec4)
static_swizzle2_const(glm::i16vec2) static_swizzle2_const(glm::i16vec2)
static_swizzle2_const(glm::i16vec3) static_swizzle2_const(glm::i16vec3)
static_swizzle2_const(glm::i16vec4) static_swizzle2_const(glm::i16vec4)
static_swizzle2_const(glm::i32vec2) static_swizzle2_const(glm::i32vec2)
static_swizzle2_const(glm::i32vec3) static_swizzle2_const(glm::i32vec3)
static_swizzle2_const(glm::i32vec4) static_swizzle2_const(glm::i32vec4)
static_swizzle2_const(glm::i64vec2) static_swizzle2_const(glm::i64vec2)
static_swizzle2_const(glm::i64vec3) static_swizzle2_const(glm::i64vec3)
static_swizzle2_const(glm::i64vec4) static_swizzle2_const(glm::i64vec4)
static_swizzle2_const(glm::u8vec2) static_swizzle2_const(glm::u8vec2)
static_swizzle2_const(glm::u8vec3) static_swizzle2_const(glm::u8vec3)
static_swizzle2_const(glm::u8vec4) static_swizzle2_const(glm::u8vec4)
static_swizzle2_const(glm::u16vec2) static_swizzle2_const(glm::u16vec2)
static_swizzle2_const(glm::u16vec3) static_swizzle2_const(glm::u16vec3)
static_swizzle2_const(glm::u16vec4) static_swizzle2_const(glm::u16vec4)
static_swizzle2_const(glm::u32vec2) static_swizzle2_const(glm::u32vec2)
static_swizzle2_const(glm::u32vec3) static_swizzle2_const(glm::u32vec3)
static_swizzle2_const(glm::u32vec4) static_swizzle2_const(glm::u32vec4)
static_swizzle2_const(glm::u64vec2) static_swizzle2_const(glm::u64vec2)
static_swizzle2_const(glm::u64vec3) static_swizzle2_const(glm::u64vec3)
static_swizzle2_const(glm::u64vec4) static_swizzle2_const(glm::u64vec4)
static_swizzle3_const(glm::f16vec2) static_swizzle3_const(glm::f16vec2)
static_swizzle3_const(glm::f16vec3) static_swizzle3_const(glm::f16vec3)
static_swizzle3_const(glm::f16vec4) static_swizzle3_const(glm::f16vec4)
static_swizzle3_const(glm::f32vec2) static_swizzle3_const(glm::f32vec2)
static_swizzle3_const(glm::f32vec3) static_swizzle3_const(glm::f32vec3)
static_swizzle3_const(glm::f32vec4) static_swizzle3_const(glm::f32vec4)
static_swizzle3_const(glm::f64vec2) static_swizzle3_const(glm::f64vec2)
static_swizzle3_const(glm::f64vec3) static_swizzle3_const(glm::f64vec3)
static_swizzle3_const(glm::f64vec4) static_swizzle3_const(glm::f64vec4)
static_swizzle3_const(glm::i8vec2) static_swizzle3_const(glm::i8vec2)
static_swizzle3_const(glm::i8vec3) static_swizzle3_const(glm::i8vec3)
static_swizzle3_const(glm::i8vec4) static_swizzle3_const(glm::i8vec4)
static_swizzle3_const(glm::i16vec2) static_swizzle3_const(glm::i16vec2)
static_swizzle3_const(glm::i16vec3) static_swizzle3_const(glm::i16vec3)
static_swizzle3_const(glm::i16vec4) static_swizzle3_const(glm::i16vec4)
static_swizzle3_const(glm::i32vec2) static_swizzle3_const(glm::i32vec2)
static_swizzle3_const(glm::i32vec3) static_swizzle3_const(glm::i32vec3)
static_swizzle3_const(glm::i32vec4) static_swizzle3_const(glm::i32vec4)
static_swizzle3_const(glm::i64vec2) static_swizzle3_const(glm::i64vec2)
static_swizzle3_const(glm::i64vec3) static_swizzle3_const(glm::i64vec3)
static_swizzle3_const(glm::i64vec4) static_swizzle3_const(glm::i64vec4)
static_swizzle3_const(glm::u8vec2) static_swizzle3_const(glm::u8vec2)
static_swizzle3_const(glm::u8vec3) static_swizzle3_const(glm::u8vec3)
static_swizzle3_const(glm::u8vec4) static_swizzle3_const(glm::u8vec4)
static_swizzle3_const(glm::u16vec2) static_swizzle3_const(glm::u16vec2)
static_swizzle3_const(glm::u16vec3) static_swizzle3_const(glm::u16vec3)
static_swizzle3_const(glm::u16vec4) static_swizzle3_const(glm::u16vec4)
static_swizzle3_const(glm::u32vec2) static_swizzle3_const(glm::u32vec2)
static_swizzle3_const(glm::u32vec3) static_swizzle3_const(glm::u32vec3)
static_swizzle3_const(glm::u32vec4) static_swizzle3_const(glm::u32vec4)
static_swizzle3_const(glm::u64vec2) static_swizzle3_const(glm::u64vec2)
static_swizzle3_const(glm::u64vec3) static_swizzle3_const(glm::u64vec3)
static_swizzle3_const(glm::u64vec4) static_swizzle3_const(glm::u64vec4)
static_swizzle4_const(glm::f16vec2) static_swizzle4_const(glm::f16vec2)
static_swizzle4_const(glm::f16vec3) static_swizzle4_const(glm::f16vec3)
static_swizzle4_const(glm::f16vec4) static_swizzle4_const(glm::f16vec4)
static_swizzle4_const(glm::f32vec2) static_swizzle4_const(glm::f32vec2)
static_swizzle4_const(glm::f32vec3) static_swizzle4_const(glm::f32vec3)
static_swizzle4_const(glm::f32vec4) static_swizzle4_const(glm::f32vec4)
static_swizzle4_const(glm::f64vec2) static_swizzle4_const(glm::f64vec2)
static_swizzle4_const(glm::f64vec3) static_swizzle4_const(glm::f64vec3)
static_swizzle4_const(glm::f64vec4) static_swizzle4_const(glm::f64vec4)
static_swizzle4_const(glm::i8vec2) static_swizzle4_const(glm::i8vec2)
static_swizzle4_const(glm::i8vec3) static_swizzle4_const(glm::i8vec3)
static_swizzle4_const(glm::i8vec4) static_swizzle4_const(glm::i8vec4)
static_swizzle4_const(glm::i16vec2) static_swizzle4_const(glm::i16vec2)
static_swizzle4_const(glm::i16vec3) static_swizzle4_const(glm::i16vec3)
static_swizzle4_const(glm::i16vec4) static_swizzle4_const(glm::i16vec4)
static_swizzle4_const(glm::i32vec2) static_swizzle4_const(glm::i32vec2)
static_swizzle4_const(glm::i32vec3) static_swizzle4_const(glm::i32vec3)
static_swizzle4_const(glm::i32vec4) static_swizzle4_const(glm::i32vec4)
static_swizzle4_const(glm::i64vec2) static_swizzle4_const(glm::i64vec2)
static_swizzle4_const(glm::i64vec3) static_swizzle4_const(glm::i64vec3)
static_swizzle4_const(glm::i64vec4) static_swizzle4_const(glm::i64vec4)
static_swizzle4_const(glm::u8vec2) static_swizzle4_const(glm::u8vec2)
static_swizzle4_const(glm::u8vec3) static_swizzle4_const(glm::u8vec3)
static_swizzle4_const(glm::u8vec4) static_swizzle4_const(glm::u8vec4)
static_swizzle4_const(glm::u16vec2) static_swizzle4_const(glm::u16vec2)
static_swizzle4_const(glm::u16vec3) static_swizzle4_const(glm::u16vec3)
static_swizzle4_const(glm::u16vec4) static_swizzle4_const(glm::u16vec4)
static_swizzle4_const(glm::u32vec2) static_swizzle4_const(glm::u32vec2)
static_swizzle4_const(glm::u32vec3) static_swizzle4_const(glm::u32vec3)
static_swizzle4_const(glm::u32vec4) static_swizzle4_const(glm::u32vec4)
static_swizzle4_const(glm::u64vec2) static_swizzle4_const(glm::u64vec2)
static_swizzle4_const(glm::u64vec3) static_swizzle4_const(glm::u64vec3)
static_swizzle4_const(glm::u64vec4) static_swizzle4_const(glm::u64vec4)
# define static_swizzle2_ref(TYPE) \ # define static_swizzle2_ref(TYPE) \
template <glm::comp x, glm::comp y> \ template <glm::comp x, glm::comp y> \
GLM_FUNC_QUALIFIER glm::detail::tref2<typename TYPE::value_type> swizzle(TYPE & v) \ GLM_FUNC_QUALIFIER glm::detail::tref2<typename TYPE::value_type> swizzle(TYPE & v) \
{return glm::detail::tref2<typename TYPE::value_type>(v[x], v[y]);} {return glm::detail::tref2<typename TYPE::value_type>(v[x], v[y]);}
# define static_swizzle3_ref(TYPE) \ # define static_swizzle3_ref(TYPE) \
template <glm::comp x, glm::comp y, glm::comp z> \ template <glm::comp x, glm::comp y, glm::comp z> \
GLM_FUNC_QUALIFIER glm::detail::tref3<typename TYPE::value_type> swizzle(TYPE & v) \ GLM_FUNC_QUALIFIER glm::detail::tref3<typename TYPE::value_type> swizzle(TYPE & v) \
{return glm::detail::tref3<typename TYPE::value_type>(v[x], v[y], v[z]);} {return glm::detail::tref3<typename TYPE::value_type>(v[x], v[y], v[z]);}
# define static_swizzle4_ref(TYPE) \ # define static_swizzle4_ref(TYPE) \
template <glm::comp x, glm::comp y, glm::comp z, glm::comp w> \ template <glm::comp x, glm::comp y, glm::comp z, glm::comp w> \
GLM_FUNC_QUALIFIER glm::detail::tref4<typename TYPE::value_type> swizzle(TYPE & v) \ GLM_FUNC_QUALIFIER glm::detail::tref4<typename TYPE::value_type> swizzle(TYPE & v) \
{return glm::detail::tref4<typename TYPE::value_type>(v[x], v[y], v[z], v[w]);} {return glm::detail::tref4<typename TYPE::value_type>(v[x], v[y], v[z], v[w]);}
static_swizzle2_ref(glm::f16vec2) static_swizzle2_ref(glm::f16vec2)
static_swizzle2_ref(glm::f16vec3) static_swizzle2_ref(glm::f16vec3)
static_swizzle2_ref(glm::f16vec4) static_swizzle2_ref(glm::f16vec4)
static_swizzle2_ref(glm::f32vec2) static_swizzle2_ref(glm::f32vec2)
static_swizzle2_ref(glm::f32vec3) static_swizzle2_ref(glm::f32vec3)
static_swizzle2_ref(glm::f32vec4) static_swizzle2_ref(glm::f32vec4)
static_swizzle2_ref(glm::f64vec2) static_swizzle2_ref(glm::f64vec2)
static_swizzle2_ref(glm::f64vec3) static_swizzle2_ref(glm::f64vec3)
static_swizzle2_ref(glm::f64vec4) static_swizzle2_ref(glm::f64vec4)
static_swizzle2_ref(glm::i8vec2) static_swizzle2_ref(glm::i8vec2)
static_swizzle2_ref(glm::i8vec3) static_swizzle2_ref(glm::i8vec3)
static_swizzle2_ref(glm::i8vec4) static_swizzle2_ref(glm::i8vec4)
static_swizzle2_ref(glm::i16vec2) static_swizzle2_ref(glm::i16vec2)
static_swizzle2_ref(glm::i16vec3) static_swizzle2_ref(glm::i16vec3)
static_swizzle2_ref(glm::i16vec4) static_swizzle2_ref(glm::i16vec4)
static_swizzle2_ref(glm::i32vec2) static_swizzle2_ref(glm::i32vec2)
static_swizzle2_ref(glm::i32vec3) static_swizzle2_ref(glm::i32vec3)
static_swizzle2_ref(glm::i32vec4) static_swizzle2_ref(glm::i32vec4)
static_swizzle2_ref(glm::i64vec2) static_swizzle2_ref(glm::i64vec2)
static_swizzle2_ref(glm::i64vec3) static_swizzle2_ref(glm::i64vec3)
static_swizzle2_ref(glm::i64vec4) static_swizzle2_ref(glm::i64vec4)
static_swizzle2_ref(glm::u8vec2) static_swizzle2_ref(glm::u8vec2)
static_swizzle2_ref(glm::u8vec3) static_swizzle2_ref(glm::u8vec3)
static_swizzle2_ref(glm::u8vec4) static_swizzle2_ref(glm::u8vec4)
static_swizzle2_ref(glm::u16vec2) static_swizzle2_ref(glm::u16vec2)
static_swizzle2_ref(glm::u16vec3) static_swizzle2_ref(glm::u16vec3)
static_swizzle2_ref(glm::u16vec4) static_swizzle2_ref(glm::u16vec4)
static_swizzle2_ref(glm::u32vec2) static_swizzle2_ref(glm::u32vec2)
static_swizzle2_ref(glm::u32vec3) static_swizzle2_ref(glm::u32vec3)
static_swizzle2_ref(glm::u32vec4) static_swizzle2_ref(glm::u32vec4)
static_swizzle2_ref(glm::u64vec2) static_swizzle2_ref(glm::u64vec2)
static_swizzle2_ref(glm::u64vec3) static_swizzle2_ref(glm::u64vec3)
static_swizzle2_ref(glm::u64vec4) static_swizzle2_ref(glm::u64vec4)
static_swizzle3_ref(glm::f16vec3) static_swizzle3_ref(glm::f16vec3)
static_swizzle3_ref(glm::f16vec4) static_swizzle3_ref(glm::f16vec4)
static_swizzle3_ref(glm::f32vec3) static_swizzle3_ref(glm::f32vec3)
static_swizzle3_ref(glm::f32vec4) static_swizzle3_ref(glm::f32vec4)
static_swizzle3_ref(glm::f64vec3) static_swizzle3_ref(glm::f64vec3)
static_swizzle3_ref(glm::f64vec4) static_swizzle3_ref(glm::f64vec4)
static_swizzle3_ref(glm::i8vec3) static_swizzle3_ref(glm::i8vec3)
static_swizzle3_ref(glm::i8vec4) static_swizzle3_ref(glm::i8vec4)
static_swizzle3_ref(glm::i16vec3) static_swizzle3_ref(glm::i16vec3)
static_swizzle3_ref(glm::i16vec4) static_swizzle3_ref(glm::i16vec4)
static_swizzle3_ref(glm::i32vec3) static_swizzle3_ref(glm::i32vec3)
static_swizzle3_ref(glm::i32vec4) static_swizzle3_ref(glm::i32vec4)
static_swizzle3_ref(glm::i64vec3) static_swizzle3_ref(glm::i64vec3)
static_swizzle3_ref(glm::i64vec4) static_swizzle3_ref(glm::i64vec4)
static_swizzle3_ref(glm::u8vec3) static_swizzle3_ref(glm::u8vec3)
static_swizzle3_ref(glm::u8vec4) static_swizzle3_ref(glm::u8vec4)
static_swizzle3_ref(glm::u16vec3) static_swizzle3_ref(glm::u16vec3)
static_swizzle3_ref(glm::u16vec4) static_swizzle3_ref(glm::u16vec4)
static_swizzle3_ref(glm::u32vec3) static_swizzle3_ref(glm::u32vec3)
static_swizzle3_ref(glm::u32vec4) static_swizzle3_ref(glm::u32vec4)
static_swizzle3_ref(glm::u64vec3) static_swizzle3_ref(glm::u64vec3)
static_swizzle3_ref(glm::u64vec4) static_swizzle3_ref(glm::u64vec4)
static_swizzle4_ref(glm::f16vec4) static_swizzle4_ref(glm::f16vec4)
static_swizzle4_ref(glm::f32vec4) static_swizzle4_ref(glm::f32vec4)
static_swizzle4_ref(glm::f64vec4) static_swizzle4_ref(glm::f64vec4)
static_swizzle4_ref(glm::i8vec4) static_swizzle4_ref(glm::i8vec4)
static_swizzle4_ref(glm::i16vec4) static_swizzle4_ref(glm::i16vec4)
static_swizzle4_ref(glm::i32vec4) static_swizzle4_ref(glm::i32vec4)
static_swizzle4_ref(glm::i64vec4) static_swizzle4_ref(glm::i64vec4)
static_swizzle4_ref(glm::u8vec4) static_swizzle4_ref(glm::u8vec4)
static_swizzle4_ref(glm::u16vec4) static_swizzle4_ref(glm::u16vec4)
static_swizzle4_ref(glm::u32vec4) static_swizzle4_ref(glm::u32vec4)
static_swizzle4_ref(glm::u64vec4) static_swizzle4_ref(glm::u64vec4)
}//namespace swizzle }//namespace swizzle
}//namespace gtc }//namespace gtc
}//namespace glm }//namespace glm
#include "swizzle.inl" #include "swizzle.inl"

306
glm/gtc/type_precision.hpp
View File

@ -24,199 +24,193 @@
# pragma message("GLM: GLM_GTC_type_precision extension included") # pragma message("GLM: GLM_GTC_type_precision extension included")
#endif #endif
namespace glm namespace glm{
namespace gtc{
namespace type_precision ///< GLM_GTC_type_precision extension: Defined types with specific size.
{ {
namespace test{ ///////////////////////////
bool main_gtc_type_precision(); // Dependences
}//namespace test
namespace gtc{ using namespace gtc::half_float;
//! GLM_GTC_type_precision extension: Defined types with specific size. using namespace gtc::quaternion;
namespace type_precision
{
///////////////////////////
// Dependences
using namespace gtc::half_float; ///////////////////////////
using namespace gtc::quaternion; // Signed int vector types
/////////////////////////// /// \addtogroup gtc_type_precision
// Signed int vector types ///@{
/// \addtogroup gtc_type_precision typedef detail::int8 int8; //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
///@{ typedef detail::int16 int16; //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
typedef detail::int32 int32; //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
typedef detail::int64 int64; //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension)
typedef detail::int8 int8; //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension) typedef int8 i8; //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
typedef detail::int16 int16; //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension) typedef int16 i16; //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
typedef detail::int32 int32; //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension) typedef int32 i32; //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
typedef detail::int64 int64; //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension) typedef int64 i64; //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension)
typedef int8 i8; //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension) //typedef i8 i8vec1; //!< \brief 8bit signed integer scalar. (from GLM_GTC_type_precision extension)
typedef int16 i16; //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension) typedef detail::tvec2<i8> i8vec2; //!< \brief 8bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
typedef int32 i32; //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension) typedef detail::tvec3<i8> i8vec3; //!< \brief 8bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
typedef int64 i64; //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension) typedef detail::tvec4<i8> i8vec4; //!< \brief 8bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
//typedef i8 i8vec1; //!< \brief 8bit signed integer scalar. (from GLM_GTC_type_precision extension) //typedef i16 i16vec1; //!< \brief 16bit signed integer scalar. (from GLM_GTC_type_precision extension)
typedef detail::tvec2<i8> i8vec2; //!< \brief 8bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension) typedef detail::tvec2<i16> i16vec2; //!< \brief 16bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec3<i8> i8vec3; //!< \brief 8bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension) typedef detail::tvec3<i16> i16vec3; //!< \brief 16bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<i8> i8vec4; //!< \brief 8bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension) typedef detail::tvec4<i16> i16vec4; //!< \brief 16bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
//typedef i16 i16vec1; //!< \brief 16bit signed integer scalar. (from GLM_GTC_type_precision extension) //typedef i32 i32vec1; //!< \brief 32bit signed integer scalar. (from GLM_GTC_type_precision extension)
typedef detail::tvec2<i16> i16vec2; //!< \brief 16bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension) typedef detail::tvec2<i32> i32vec2; //!< \brief 32bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec3<i16> i16vec3; //!< \brief 16bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension) typedef detail::tvec3<i32> i32vec3; //!< \brief 32bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<i16> i16vec4; //!< \brief 16bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension) typedef detail::tvec4<i32> i32vec4; //!< \brief 32bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
//typedef i32 i32vec1; //!< \brief 32bit signed integer scalar. (from GLM_GTC_type_precision extension) //typedef i64 i64vec1; //!< \brief 32bit signed integer scalar. (from GLM_GTC_type_precision extension)
typedef detail::tvec2<i32> i32vec2; //!< \brief 32bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension) typedef detail::tvec2<i64> i64vec2; //!< \brief 64bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec3<i32> i32vec3; //!< \brief 32bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension) typedef detail::tvec3<i64> i64vec3; //!< \brief 64bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<i32> i32vec4; //!< \brief 32bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension) typedef detail::tvec4<i64> i64vec4; //!< \brief 64bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
//typedef i64 i64vec1; //!< \brief 32bit signed integer scalar. (from GLM_GTC_type_precision extension) /////////////////////////////
typedef detail::tvec2<i64> i64vec2; //!< \brief 64bit signed integer vector of 2 components. (from GLM_GTC_type_precision extension) // Unsigned int vector types
typedef detail::tvec3<i64> i64vec3; //!< \brief 64bit signed integer vector of 3 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<i64> i64vec4; //!< \brief 64bit signed integer vector of 4 components. (from GLM_GTC_type_precision extension)
///////////////////////////// typedef detail::uint8 uint8; //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension)
// Unsigned int vector types typedef detail::uint16 uint16; //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
typedef detail::uint32 uint32; //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension)
typedef detail::uint64 uint64; //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension)
typedef detail::uint8 uint8; //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension) typedef uint8 u8; //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension)
typedef detail::uint16 uint16; //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension) typedef uint16 u16; //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
typedef detail::uint32 uint32; //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension) typedef uint32 u32; //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension)
typedef detail::uint64 uint64; //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension) typedef uint64 u64; //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension)
typedef uint8 u8; //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension) //typedef u8 u8vec1; //!< \brief 8bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
typedef uint16 u16; //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension) typedef detail::tvec2<u8> u8vec2; //!< \brief 8bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
typedef uint32 u32; //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension) typedef detail::tvec3<u8> u8vec3; //!< \brief 8bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
typedef uint64 u64; //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension) typedef detail::tvec4<u8> u8vec4; //!< \brief 8bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
//typedef u8 u8vec1; //!< \brief 8bit unsigned integer scalar. (from GLM_GTC_type_precision extension) //typedef u16 u16vec1; //!< \brief 16bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
typedef detail::tvec2<u8> u8vec2; //!< \brief 8bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension) typedef detail::tvec2<u16> u16vec2; //!< \brief 16bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec3<u8> u8vec3; //!< \brief 8bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension) typedef detail::tvec3<u16> u16vec3; //!< \brief 16bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<u8> u8vec4; //!< \brief 8bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension) typedef detail::tvec4<u16> u16vec4; //!< \brief 16bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
//typedef u16 u16vec1; //!< \brief 16bit unsigned integer scalar. (from GLM_GTC_type_precision extension) //typedef u32 u32vec1; //!< \brief 32bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
typedef detail::tvec2<u16> u16vec2; //!< \brief 16bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension) typedef detail::tvec2<u32> u32vec2; //!< \brief 32bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec3<u16> u16vec3; //!< \brief 16bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension) typedef detail::tvec3<u32> u32vec3; //!< \brief 32bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<u16> u16vec4; //!< \brief 16bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension) typedef detail::tvec4<u32> u32vec4; //!< \brief 32bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
//typedef u32 u32vec1; //!< \brief 32bit unsigned integer scalar. (from GLM_GTC_type_precision extension) //typedef u64 u64vec1; //!< \brief 64bit unsigned integer scalar. (from GLM_GTC_type_precision extension)
typedef detail::tvec2<u32> u32vec2; //!< \brief 32bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension) typedef detail::tvec2<u64> u64vec2; //!< \brief 64bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec3<u32> u32vec3; //!< \brief 32bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension) typedef detail::tvec3<u64> u64vec3; //!< \brief 64bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<u32> u32vec4; //!< \brief 32bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension) typedef detail::tvec4<u64> u64vec4; //!< \brief 64bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
//typedef u64 u64vec1; //!< \brief 64bit unsigned integer scalar. (from GLM_GTC_type_precision extension) //////////////////////
typedef detail::tvec2<u64> u64vec2; //!< \brief 64bit unsigned integer vector of 2 components. (from GLM_GTC_type_precision extension) // Float vector types
typedef detail::tvec3<u64> u64vec3; //!< \brief 64bit unsigned integer vector of 3 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<u64> u64vec4; //!< \brief 64bit unsigned integer vector of 4 components. (from GLM_GTC_type_precision extension)
////////////////////// typedef detail::float16 float16; //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
// Float vector types typedef detail::float32 float32; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::float64 float64; //!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::float16 float16; //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension) typedef float16 f16; //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::float32 float32; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension) typedef float32 f32; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::float64 float64; //!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension) typedef float64 f64; //!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef float16 f16; //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension) typedef detail::tvec2<float> fvec2; //!< Vector of 2 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
typedef float32 f32; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension) typedef detail::tvec3<float> fvec3; //!< Vector of 3 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
typedef float64 f64; //!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension) typedef detail::tvec4<float> fvec4; //!< Vector of 4 single-precision floating-point numbers. (from GLM_GTC_type_precision extension)
typedef detail::tvec2<float> fvec2; //!< Vector of 2 single-precision floating-point numbers. (from GLM_GTC_type_precision extension) //typedef f16 f16vec1; //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::tvec3<float> fvec3; //!< Vector of 3 single-precision floating-point numbers. (from GLM_GTC_type_precision extension) typedef detail::tvec2<f16> f16vec2; //!< \brief Half-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<float> fvec4; //!< Vector of 4 single-precision floating-point numbers. (from GLM_GTC_type_precision extension) typedef detail::tvec3<f16> f16vec3; //!< \brief Half-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<f16> f16vec4; //!< \brief Half-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
//typedef f16 f16vec1; //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension) //typedef f32 f32vec1; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::tvec2<f16> f16vec2; //!< \brief Half-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension) typedef detail::tvec2<f32> f32vec2; //!< \brief Single-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec3<f16> f16vec3; //!< \brief Half-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension) typedef detail::tvec3<f32> f32vec3; //!< \brief Single-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<f16> f16vec4; //!< \brief Half-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension) typedef detail::tvec4<f32> f32vec4; //!< \brief Single-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
//typedef f32 f32vec1; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension) //typedef f64 f64vec1; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::tvec2<f32> f32vec2; //!< \brief Single-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension) typedef detail::tvec2<f64> f64vec2; //!< \brief Double-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec3<f32> f32vec3; //!< \brief Single-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension) typedef detail::tvec3<f64> f64vec3; //!< \brief Double-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<f32> f32vec4; //!< \brief Single-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension) typedef detail::tvec4<f64> f64vec4; //!< \brief Double-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
//typedef f64 f64vec1; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension) //////////////////////
typedef detail::tvec2<f64> f64vec2; //!< \brief Double-precision floating-point vector of 2 components. (from GLM_GTC_type_precision extension) // Float matrix types
typedef detail::tvec3<f64> f64vec3; //!< \brief Double-precision floating-point vector of 3 components. (from GLM_GTC_type_precision extension)
typedef detail::tvec4<f64> f64vec4; //!< \brief Double-precision floating-point vector of 4 components. (from GLM_GTC_type_precision extension)
////////////////////// //typedef f32 fmat1; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
// Float matrix types typedef detail::tmat2x2<f32> fmat2; //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f32> fmat3; //!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f32> fmat4; //!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
//typedef f32 fmat1; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension) //typedef f32 fmat1x1; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x2<f32> fmat2; //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x2<f32> fmat2x2; //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f32> fmat3; //!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x3<f32> fmat2x3; //!< \brief Single-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f32> fmat4; //!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x4<f32> fmat2x4; //!< \brief Single-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x2<f32> fmat3x2; //!< \brief Single-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f32> fmat3x3; //!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x4<f32> fmat3x4; //!< \brief Single-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x2<f32> fmat4x2; //!< \brief Single-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x3<f32> fmat4x3; //!< \brief Single-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f32> fmat4x4; //!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
//typedef f32 fmat1x1; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension) //typedef f16 f16mat1; //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x2<f32> fmat2x2; //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x2<f16> f16mat2; //!< \brief Half-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x3<f32> fmat2x3; //!< \brief Single-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat3x3<f16> f16mat3; //!< \brief Half-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x4<f32> fmat2x4; //!< \brief Single-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat4x4<f16> f16mat4; //!< \brief Half-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x2<f32> fmat3x2; //!< \brief Single-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f32> fmat3x3; //!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x4<f32> fmat3x4; //!< \brief Single-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x2<f32> fmat4x2; //!< \brief Single-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x3<f32> fmat4x3; //!< \brief Single-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f32> fmat4x4; //!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
//typedef f16 f16mat1; //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension) //typedef f16 f16mat1x1; //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x2<f16> f16mat2; //!< \brief Half-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x2<f16> f16mat2x2; //!< \brief Half-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f16> f16mat3; //!< \brief Half-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x3<f16> f16mat2x3; //!< \brief Half-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f16> f16mat4; //!< \brief Half-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x4<f16> f16mat2x4; //!< \brief Half-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x2<f16> f16mat3x2; //!< \brief Half-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f16> f16mat3x3; //!< \brief Half-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x4<f16> f16mat3x4; //!< \brief Half-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x2<f16> f16mat4x2; //!< \brief Half-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x3<f16> f16mat4x3; //!< \brief Half-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f16> f16mat4x4; //!< \brief Half-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
//typedef f16 f16mat1x1; //!< \brief Half-precision floating-point scalar. (from GLM_GTC_type_precision extension) //typedef f32 f32mat1; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x2<f16> f16mat2x2; //!< \brief Half-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x2<f32> f32mat2; //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x3<f16> f16mat2x3; //!< \brief Half-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat3x3<f32> f32mat3; //!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x4<f16> f16mat2x4; //!< \brief Half-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat4x4<f32> f32mat4; //!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x2<f16> f16mat3x2; //!< \brief Half-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f16> f16mat3x3; //!< \brief Half-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x4<f16> f16mat3x4; //!< \brief Half-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x2<f16> f16mat4x2; //!< \brief Half-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x3<f16> f16mat4x3; //!< \brief Half-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f16> f16mat4x4; //!< \brief Half-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
//typedef f32 f32mat1; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension) //typedef f32 f32mat1x1; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x2<f32> f32mat2; //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x2<f32> f32mat2x2; //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f32> f32mat3; //!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x3<f32> f32mat2x3; //!< \brief Single-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f32> f32mat4; //!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x4<f32> f32mat2x4; //!< \brief Single-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x2<f32> f32mat3x2; //!< \brief Single-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f32> f32mat3x3; //!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x4<f32> f32mat3x4; //!< \brief Single-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x2<f32> f32mat4x2; //!< \brief Single-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x3<f32> f32mat4x3; //!< \brief Single-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f32> f32mat4x4; //!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
//typedef f32 f32mat1x1; //!< \brief Single-precision floating-point scalar. (from GLM_GTC_type_precision extension) //typedef f64 f64mat1; //!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x2<f32> f32mat2x2; //!< \brief Single-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x2<f64> f64mat2; //!< \brief Double-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x3<f32> f32mat2x3; //!< \brief Single-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat3x3<f64> f64mat3; //!< \brief Double-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x4<f32> f32mat2x4; //!< \brief Single-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat4x4<f64> f64mat4; //!< \brief Double-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x2<f32> f32mat3x2; //!< \brief Single-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f32> f32mat3x3; //!< \brief Single-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x4<f32> f32mat3x4; //!< \brief Single-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x2<f32> f32mat4x2; //!< \brief Single-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x3<f32> f32mat4x3; //!< \brief Single-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f32> f32mat4x4; //!< \brief Single-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
//typedef f64 f64mat1; //!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension) //typedef f64 f64mat1x1; //!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x2<f64> f64mat2; //!< \brief Double-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x2<f64> f64mat2x2; //!< \brief Double-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f64> f64mat3; //!< \brief Double-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x3<f64> f64mat2x3; //!< \brief Double-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f64> f64mat4; //!< \brief Double-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension) typedef detail::tmat2x4<f64> f64mat2x4; //!< \brief Double-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x2<f64> f64mat3x2; //!< \brief Double-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f64> f64mat3x3; //!< \brief Double-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x4<f64> f64mat3x4; //!< \brief Double-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x2<f64> f64mat4x2; //!< \brief Double-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x3<f64> f64mat4x3; //!< \brief Double-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f64> f64mat4x4; //!< \brief Double-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
//typedef f64 f64mat1x1; //!< \brief Double-precision floating-point scalar. (from GLM_GTC_type_precision extension) //////////////////////////
typedef detail::tmat2x2<f64> f64mat2x2; //!< \brief Double-precision floating-point 2x2 matrix. (from GLM_GTC_type_precision extension) // Float quaternion types
typedef detail::tmat2x3<f64> f64mat2x3; //!< \brief Double-precision floating-point 2x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat2x4<f64> f64mat2x4; //!< \brief Double-precision floating-point 2x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x2<f64> f64mat3x2; //!< \brief Double-precision floating-point 3x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x3<f64> f64mat3x3; //!< \brief Double-precision floating-point 3x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat3x4<f64> f64mat3x4; //!< \brief Double-precision floating-point 3x4 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x2<f64> f64mat4x2; //!< \brief Double-precision floating-point 4x2 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x3<f64> f64mat4x3; //!< \brief Double-precision floating-point 4x3 matrix. (from GLM_GTC_type_precision extension)
typedef detail::tmat4x4<f64> f64mat4x4; //!< \brief Double-precision floating-point 4x4 matrix. (from GLM_GTC_type_precision extension)
////////////////////////// typedef detail::tquat<f16> f16quat; //!< \brief Half-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
// Float quaternion types typedef detail::tquat<f32> f32quat; //!< \brief Single-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
typedef detail::tquat<f64> f64quat; //!< \brief Double-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
typedef detail::tquat<f16> f16quat; //!< \brief Half-precision floating-point quaternion. (from GLM_GTC_type_precision extension) ///@}
typedef detail::tquat<f32> f32quat; //!< \brief Single-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
typedef detail::tquat<f64> f64quat; //!< \brief Double-precision floating-point quaternion. (from GLM_GTC_type_precision extension)
///@} }//namespace type_precision
}//namespace gtc
}//namespace type_precision
}//namespace gtc
}//namespace glm }//namespace glm
#include "type_precision.inl" #include "type_precision.inl"

755
glm/gtc/type_ptr.hpp
View File

@ -21,429 +21,424 @@
# pragma message("GLM: GLM_GTC_type_ptr extension included") # pragma message("GLM: GLM_GTC_type_ptr extension included")
#endif #endif
namespace glm namespace glm{
{ namespace gtc{
namespace test{ namespace type_ptr ///< GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
void main_gtc_type_ptr(); {
}//namespace test
namespace gtc{ /// \addtogroup gtc_type_ptr
//! GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address. ///@{
namespace type_ptr{
/// \addtogroup gtc_type_ptr //! Get the const address of the vector content.
///@{ //! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tvec2<T> const & vec
)
{
return &(vec.x);
}
//! Get the const address of the vector content. //! Get the address of the vector content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr GLM_FUNC_QUALIFIER T * value_ptr
( (
detail::tvec2<T> const & vec detail::tvec2<T> & vec
) )
{ {
return &(vec.x); return &(vec.x);
} }
//! Get the address of the vector content. //! Get the const address of the vector content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr GLM_FUNC_QUALIFIER T const * value_ptr
( (
detail::tvec2<T> & vec detail::tvec3<T> const & vec
) )
{ {
return &(vec.x); return &(vec.x);
} }
//! Get the const address of the vector content. //! Get the address of the vector content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr GLM_FUNC_QUALIFIER T * value_ptr
( (
detail::tvec3<T> const & vec detail::tvec3<T> & vec
) )
{ {
return &(vec.x); return &(vec.x);
} }
//! Get the address of the vector content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tvec3<T> & vec
)
{
return &(vec.x);
}
//! Get the const address of the vector content. //! Get the const address of the vector content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr GLM_FUNC_QUALIFIER T const * value_ptr
( (
detail::tvec4<T> const & vec detail::tvec4<T> const & vec
) )
{ {
return &(vec.x); return &(vec.x);
} }
//! Get the address of the vector content. //! Get the address of the vector content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr GLM_FUNC_QUALIFIER T * value_ptr
( (
detail::tvec4<T> & vec detail::tvec4<T> & vec
) )
{ {
return &(vec.x); return &(vec.x);
} }
//! Get the const address of the matrix content. //! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr GLM_FUNC_QUALIFIER T const * value_ptr
( (
detail::tmat2x2<T> const & mat detail::tmat2x2<T> const & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the address of the matrix content. //! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr GLM_FUNC_QUALIFIER T * value_ptr
( (
detail::tmat2x2<T> & mat detail::tmat2x2<T> & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the const address of the matrix content. //! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr GLM_FUNC_QUALIFIER T const * value_ptr
( (
detail::tmat3x3<T> const & mat detail::tmat3x3<T> const & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the address of the matrix content. //! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr GLM_FUNC_QUALIFIER T * value_ptr
( (
detail::tmat3x3<T> & mat detail::tmat3x3<T> & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the const address of the matrix content. //! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr GLM_FUNC_QUALIFIER T const * value_ptr
( (
detail::tmat4x4<T> const & mat detail::tmat4x4<T> const & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the address of the matrix content. //! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr GLM_FUNC_QUALIFIER T * value_ptr
( (
detail::tmat4x4<T> & mat detail::tmat4x4<T> & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the const address of the matrix content. //! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr GLM_FUNC_QUALIFIER T const * value_ptr
( (
detail::tmat2x3<T> const & mat detail::tmat2x3<T> const & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the address of the matrix content. //! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr GLM_FUNC_QUALIFIER T * value_ptr
( (
detail::tmat2x3<T> & mat detail::tmat2x3<T> & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the const address of the matrix content. //! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr GLM_FUNC_QUALIFIER T const * value_ptr
( (
detail::tmat3x2<T> const & mat detail::tmat3x2<T> const & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the address of the matrix content. //! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr GLM_FUNC_QUALIFIER T * value_ptr
( (
detail::tmat3x2<T> & mat detail::tmat3x2<T> & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the const address of the matrix content. //! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr GLM_FUNC_QUALIFIER T const * value_ptr
( (
detail::tmat2x4<T> const & mat detail::tmat2x4<T> const & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the address of the matrix content. //! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr GLM_FUNC_QUALIFIER T * value_ptr
( (
detail::tmat2x4<T> & mat detail::tmat2x4<T> & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the const address of the matrix content. //! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr GLM_FUNC_QUALIFIER T const * value_ptr
( (
detail::tmat4x2<T> const & mat detail::tmat4x2<T> const & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the address of the matrix content. //! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr GLM_FUNC_QUALIFIER T * value_ptr
( (
detail::tmat4x2<T> & mat detail::tmat4x2<T> & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the const address of the matrix content. //! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr GLM_FUNC_QUALIFIER T const * value_ptr
( (
detail::tmat3x4<T> const & mat detail::tmat3x4<T> const & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the address of the matrix content. //! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr GLM_FUNC_QUALIFIER T * value_ptr
( (
detail::tmat3x4<T> & mat detail::tmat3x4<T> & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the const address of the matrix content. //! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr GLM_FUNC_QUALIFIER T const * value_ptr
( (
detail::tmat4x3<T> const & mat detail::tmat4x3<T> const & mat
) )
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Get the address of the matrix content. //! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat) GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat)
{ {
return &(mat[0].x); return &(mat[0].x);
} }
//! Build a vector from a pointer. //! Build a vector from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr) GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr)
{ {
detail::tvec2<T> Result; detail::tvec2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>)); memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>));
return Result; return Result;
} }
//! Build a vector from a pointer. //! Build a vector from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr) GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr)
{ {
detail::tvec3<T> Result; detail::tvec3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>)); memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>));
return Result; return Result;
} }
//! Build a vector from a pointer. //! Build a vector from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr) GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr)
{ {
detail::tvec4<T> Result; detail::tvec4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>)); memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>));
return Result; return Result;
} }
//! Build a matrix from a pointer. //! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr) GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr)
{ {
detail::tmat2x2<T> Result; detail::tmat2x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>)); memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>));
return Result; return Result;
} }
//! Build a matrix from a pointer. //! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr) GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr)
{ {
detail::tmat2x3<T> Result; detail::tmat2x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>)); memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>));
return Result; return Result;
} }
//! Build a matrix from a pointer. //! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr) GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr)
{ {
detail::tmat2x4<T> Result; detail::tmat2x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>)); memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>));
return Result; return Result;
} }
//! Build a matrix from a pointer. //! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr) GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr)
{ {
detail::tmat3x2<T> Result; detail::tmat3x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>)); memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>));
return Result; return Result;
} }
//! Build a matrix from a pointer. //! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr) GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr)
{ {
detail::tmat3x3<T> Result; detail::tmat3x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>)); memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>));
return Result; return Result;
} }
//! Build a matrix from a pointer. //! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr) GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr)
{ {
detail::tmat3x4<T> Result; detail::tmat3x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>)); memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>));
return Result; return Result;
} }
//! Build a matrix from a pointer. //! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr) GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr)
{ {
detail::tmat4x2<T> Result; detail::tmat4x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>)); memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>));
return Result; return Result;
} }
//! Build a matrix from a pointer. //! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr) GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr)
{ {
detail::tmat4x3<T> Result; detail::tmat4x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>)); memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>));
return Result; return Result;
} }
//! Build a matrix from a pointer. //! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr) GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr)
{ {
detail::tmat4x4<T> Result; detail::tmat4x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>)); memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>));
return Result; return Result;
} }
//! Build a matrix from a pointer. //! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr) GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr)
{ {
return make_mat2x2(ptr); return make_mat2x2(ptr);
} }
//! Build a matrix from a pointer. //! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr) GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr)
{ {
return make_mat3x3(ptr); return make_mat3x3(ptr);
} }
//! Build a matrix from a pointer. //! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension. //! From GLM_GTC_type_ptr extension.
template<typename T> template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr) GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr)
{ {
return make_mat4x4(ptr); return make_mat4x4(ptr);
} }
///@} ///@}
}//namespace type_ptr }//namespace type_ptr
}//namespace gtc }//namespace gtc
}//namespace glm }//namespace glm
#include "type_ptr.inl" #include "type_ptr.inl"

99
glm/gtx/associated_min_max.hpp
View File

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

129
glm/gtx/bit.hpp
View File

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

26
glm/gtx/closest_point.hpp
View File

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

122
glm/gtx/color_cast.hpp
View File

@ -22,88 +22,82 @@
# pragma message("GLM: GLM_GTX_color_cast extension included") # pragma message("GLM: GLM_GTX_color_cast extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace color_cast ///< GLM_GTX_color_cast extension: Conversion between two color types
{ {
namespace test{ using namespace gtx::number_precision;
void main_ext_gtx_color_cast();
}//namespace test
namespace gtx{ /// \addtogroup gtx_color_cast
//! GLM_GTX_color_cast extension: Conversion between two color types ///@{
namespace color_cast
{
using namespace gtx::number_precision;
/// \addtogroup gtx_color_cast //! Conversion of a floating value into a 8bit unsigned int value.
///@{ //! From GLM_GTX_color_cast extension.
template <typename valType> gtc::type_precision::uint8 u8channel_cast(valType a);
//! Conversion of a floating value into a 8bit unsigned int value. //! Conversion of a floating value into a 16bit unsigned int value.
//! From GLM_GTX_color_cast extension. //! From GLM_GTX_color_cast extension.
template <typename valType> gtc::type_precision::uint8 u8channel_cast(valType a); template <typename valType> gtc::type_precision::uint16 u16channel_cast(valType a);
//! Conversion of a floating value into a 16bit unsigned int value. 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)
//! 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 valType> gtc::type_precision::uint16 u16channel_cast(valType a); 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_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_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_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_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_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_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_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::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::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::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::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::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::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_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_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_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_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_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_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_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_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> 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::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> 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::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::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::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::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::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::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_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> 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::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> 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::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::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::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::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::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::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_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> 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::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> 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::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::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::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::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::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::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_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) }//namespace color_space
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) }//namespace gtx
template <typename T> gtc::type_precision::f64vec4 f64_abgr_cast(T c); //!< \brief Conversion of a u32 or u64 color into 4 components floating color. (From GLM_GTX_color_cast extension)
///@}
}//namespace color_space
}//namespace gtx
}//namespace glm }//namespace glm
#include "color_cast.inl" #include "color_cast.inl"

87
glm/gtx/color_space.hpp
View File

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

66
glm/gtx/color_space_YCoCg.hpp
View File

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

217
glm/gtx/compatibility.hpp
View File

@ -28,136 +28,129 @@
#include <cmath> #include <cmath>
#endif//GLM_COMPILER #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 test{ /// \addtogroup gtx_compatibility
void main_gtx_compatibility(); ///@{
}//namespace test
namespace gtx{ 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)
//! GLM_GTX_compatibility extension: Provide functions to increase the compatibility with Cg and HLSL languages 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)
namespace 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)
/// \addtogroup 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 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> 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::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> 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::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> 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::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 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 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> 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::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> 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::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> 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 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 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 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 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 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 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 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 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 genType> bool isinf(genType const & x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
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 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 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 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 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> 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> 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> 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::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> 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::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> isinf(const detail::tvec4<genType>& x); //!< \brief Determines whether the given floating-point value is infinite. (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) typedef bool bool1; //!< \brief boolean type with 1 component. (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) typedef detail::tvec2<bool> bool2; //!< \brief boolean type with 2 components. (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) typedef detail::tvec3<bool> bool3; //!< \brief boolean type with 3 components. (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 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 bool bool1x1; //!< \brief boolean matrix with 1 x 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::tmat2x2<bool> bool2x2; //!< \brief boolean matrix with 2 x 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::tmat2x3<bool> bool2x3; //!< \brief boolean matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<bool> bool4; //!< \brief boolean type with 4 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 int int1; //!< \brief integer vector with 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::tvec2<int> int2; //!< \brief integer vector with 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::tvec3<int> int3; //!< \brief integer vector with 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::tvec4<int> int4; //!< \brief integer vector with 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 int int1x1; //!< \brief integer matrix 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::tmat2x2<int> int2x2; //!< \brief integer matrix with 2 x 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::tmat2x3<int> int2x3; //!< \brief integer matrix with 2 x 3 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec4<int> int4; //!< \brief integer vector with 4 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 gtc::half_float::half half1; //!< \brief half-precision floating-point vector 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::tvec2<gtc::half_float::half> half2; //!< \brief half-precision floating-point vector with 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::tvec3<gtc::half_float::half> half3; //!< \brief half-precision floating-point vector with 2 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::tvec4<gtc::half_float::half> half4; //!< \brief half-precision floating-point vector with 2 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 gtc::half_float::half half1x1; //!< \brief half-precision floating-point matrix 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::tmat2x2<gtc::half_float::half> half2x2; //!< \brief half-precision floating-point matrix with 2 x 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::tmat2x3<gtc::half_float::half> half2x3; //!< \brief half-precision floating-point matrix with 2 x 3 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 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 float float1; //!< \brief single-precision floating-point vector 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::tvec2<float> float2; //!< \brief single-precision floating-point vector with 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::tvec3<float> float3; //!< \brief single-precision floating-point vector with 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::tvec4<float> float4; //!< \brief single-precision floating-point vector with 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 float float1x1; //!< \brief single-precision floating-point matrix 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::tmat2x2<float> float2x2; //!< \brief single-precision floating-point matrix with 2 x 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::tmat2x3<float> float2x3; //!< \brief single-precision floating-point matrix with 2 x 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 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 double double1; //!< \brief double-precision floating-point vector 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::tvec2<double> double2; //!< \brief double-precision floating-point vector with 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::tvec3<double> double3; //!< \brief double-precision floating-point vector with 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::tvec4<double> double4; //!< \brief double-precision floating-point vector with 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 double double1x1; //!< \brief double-precision floating-point matrix 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::tmat2x2<double> double2x2; //!< \brief double-precision floating-point matrix with 2 x 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::tmat2x3<double> double2x3; //!< \brief double-precision floating-point matrix with 2 x 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 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) }//namespace compatibility
typedef detail::tmat2x3<double> double2x3; //!< \brief double-precision floating-point matrix with 2 x 3 components. (From GLM_GTX_compatibility extension) }//namespace gtx
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 glm }//namespace glm
#include "compatibility.inl" #include "compatibility.inl"

63
glm/gtx/component_wise.hpp
View File

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

51
glm/gtx/epsilon.hpp
View File

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

180
glm/gtx/euler_angles.hpp
View File

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

37
glm/gtx/extend.hpp
View File

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

267
glm/gtx/extented_min_max.hpp
View File

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

89
glm/gtx/fast_exponential.hpp
View File

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

65
glm/gtx/fast_square_root.hpp
View File

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

93
glm/gtx/fast_trigonometry.hpp
View File

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

44
glm/gtx/gradient_paint.hpp
View File

@ -21,34 +21,32 @@
# pragma message("GLM: GLM_GTX_gradient_paint extension included") # pragma message("GLM: GLM_GTX_gradient_paint extension included")
#endif #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 test{ using namespace gtx::optimum_pow;
void main_gtx_gradient_paint();
}//namespace test
namespace gtx{ /// \addtogroup gtx_gradient_paint
//! 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;
template <typename valType> template <typename valType>
valType radialGradient( valType radialGradient(
glm::detail::tvec2<valType> const & Center, glm::detail::tvec2<valType> const & Center,
valType const & Radius, valType const & Radius,
glm::detail::tvec2<valType> const & Focal, glm::detail::tvec2<valType> const & Focal,
glm::detail::tvec2<valType> const & Position); glm::detail::tvec2<valType> const & Position);
template <typename valType> template <typename valType>
valType linearGradient( valType linearGradient(
glm::detail::tvec2<valType> const & Point0, glm::detail::tvec2<valType> const & Point0,
glm::detail::tvec2<valType> const & Point1, glm::detail::tvec2<valType> const & Point1,
glm::detail::tvec2<valType> const & Position); glm::detail::tvec2<valType> const & Position);
}//namespace gradient_paint /// @}
}//namespace gtx }// namespace gradient_paint
}//namespace glm }// namespace gtx
}// namespace glm
#include "gradient_paint.inl" #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") # pragma message("GLM: GLM_GTX_handed_coordinate_space extension included")
#endif #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{ /// \addtogroup gtx_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 handed_coordinate_space
{
/// \addtogroup gtx_handed_coordinate_space
///@{
//! Return if a trihedron right handed or not. //! Return if a trihedron right handed or not.
//! From GLM_GTX_handed_coordinate_space extension. //! From GLM_GTX_handed_coordinate_space extension.
template <typename T> template <typename T>
bool rightHanded( bool rightHanded(
detail::tvec3<T> const & tangent, detail::tvec3<T> const & tangent,
detail::tvec3<T> const & binormal, detail::tvec3<T> const & binormal,
detail::tvec3<T> const & normal); detail::tvec3<T> const & normal);
//! Return if a trihedron left handed or not. //! Return if a trihedron left handed or not.
//! From GLM_GTX_handed_coordinate_space extension. //! From GLM_GTX_handed_coordinate_space extension.
template <typename T> template <typename T>
bool leftHanded( bool leftHanded(
detail::tvec3<T> const & tangent, detail::tvec3<T> const & tangent,
detail::tvec3<T> const & binormal, detail::tvec3<T> const & binormal,
detail::tvec3<T> const & normal); detail::tvec3<T> const & normal);
///@} /// @}
}// namespace handed_coordinate_space
}//namespace handed_coordinate_space }// namespace gtx
}//namespace gtx }// namespace glm
}//namespace glm
#include "handed_coordinate_space.inl" #include "handed_coordinate_space.inl"

117
glm/gtx/inertia.hpp
View File

@ -20,76 +20,73 @@
# pragma message("GLM: GLM_GTX_inertia extension included") # pragma message("GLM: GLM_GTX_inertia extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace inertia ///< GLM_GTX_inertia extension: Create inertia matrices
{ {
namespace gtx{ /// \addtogroup gtx_inertia
//! GLM_GTX_inertia extension: Create inertia matrices /// @{
namespace inertia
{
/// \addtogroup gtx_inertia
///@{
//! Build an inertia matrix for a box. //! Build an inertia matrix for a box.
//! From GLM_GTX_inertia extension. //! From GLM_GTX_inertia extension.
template <typename T> template <typename T>
detail::tmat3x3<T> boxInertia3( detail::tmat3x3<T> boxInertia3(
const T Mass, const T Mass,
const detail::tvec3<T>& Scale); const detail::tvec3<T>& Scale);
//! Build an inertia matrix for a box. //! Build an inertia matrix for a box.
//! From GLM_GTX_inertia extension. //! From GLM_GTX_inertia extension.
template <typename T> template <typename T>
detail::tmat4x4<T> boxInertia4( detail::tmat4x4<T> boxInertia4(
const T Mass, const T Mass,
const detail::tvec3<T>& Scale); const detail::tvec3<T>& Scale);
//! Build an inertia matrix for a disk. //! Build an inertia matrix for a disk.
//! From GLM_GTX_inertia extension. //! From GLM_GTX_inertia extension.
template <typename T> template <typename T>
detail::tmat3x3<T> diskInertia3( detail::tmat3x3<T> diskInertia3(
const T Mass, const T Mass,
const T Radius); const T Radius);
//! Build an inertia matrix for a disk. //! Build an inertia matrix for a disk.
//! From GLM_GTX_inertia extension. //! From GLM_GTX_inertia extension.
template <typename T> template <typename T>
detail::tmat4x4<T> diskInertia4( detail::tmat4x4<T> diskInertia4(
const T Mass, const T Mass,
const T Radius); const T Radius);
//! Build an inertia matrix for a ball. //! Build an inertia matrix for a ball.
//! From GLM_GTX_inertia extension. //! From GLM_GTX_inertia extension.
template <typename T> template <typename T>
detail::tmat3x3<T> ballInertia3( detail::tmat3x3<T> ballInertia3(
const T Mass, const T Mass,
const T Radius); const T Radius);
//! Build an inertia matrix for a ball. //! Build an inertia matrix for a ball.
//! From GLM_GTX_inertia extension. //! From GLM_GTX_inertia extension.
template <typename T> template <typename T>
detail::tmat4x4<T> ballInertia4( detail::tmat4x4<T> ballInertia4(
const T Mass, const T Mass,
const T Radius); const T Radius);
//! Build an inertia matrix for a sphere. //! Build an inertia matrix for a sphere.
//! From GLM_GTX_inertia extension. //! From GLM_GTX_inertia extension.
template <typename T> template <typename T>
detail::tmat3x3<T> sphereInertia3( detail::tmat3x3<T> sphereInertia3(
const T Mass, const T Mass,
const T Radius); const T Radius);
//! Build an inertia matrix for a sphere. //! Build an inertia matrix for a sphere.
//! From GLM_GTX_inertia extension. //! From GLM_GTX_inertia extension.
template <typename T> template <typename T>
detail::tmat4x4<T> sphereInertia4( detail::tmat4x4<T> sphereInertia4(
const T Mass, const T Mass,
const T Radius); const T Radius);
///@} /// @}
}// namespace inertia
}//namespace inertia }// namespace gtx
}//namespace gtx }// namespace glm
}//namespace glm
#include "inertia.inl" #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") # pragma message("GLM: GLM_GTX_int_10_10_10_2 extension included")
#endif #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{ using namespace gtx::raw_data;
//! GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
namespace int_10_10_10_2
{
using namespace gtx::raw_data;
/// \addtogroup gtx_int_10_10_10_2 /// \addtogroup gtx_int_10_10_10_2
///@{ ///@{
//! From GLM_GTX_int_10_10_10_2 extension. //! From GLM_GTX_int_10_10_10_2 extension.
//! Cast a vec4 to an u_10_10_10_2. //! Cast a vec4 to an u_10_10_10_2.
dword uint10_10_10_2_cast(glm::vec4 const & v); dword uint10_10_10_2_cast(glm::vec4 const & v);
///@} ///@}
}//namespace integer }//namespace integer
}//namespace gtx }//namespace gtx
}//namespace glm }//namespace glm
#include "int_10_10_10_2.inl" #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") # pragma message("GLM: GLM_GTX_integer extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace integer ///< GLM_GTX_integer extension: Add support for integer for core functions
{ {
namespace gtx{ /// \addtogroup gtx_integer
//! GLM_GTX_integer extension: Add support for integer for core functions /// @{
namespace integer
{
/// \addtogroup gtx_integer
///@{
//! Returns x raised to the y power. //! Returns x raised to the y power.
//! From GLM_GTX_integer extension. //! From GLM_GTX_integer extension.
int pow(int x, int y); int pow(int x, int y);
//! Returns the positive square root of x. //! Returns the positive square root of x.
//! From GLM_GTX_integer extension. //! From GLM_GTX_integer extension.
int sqrt(int x); int sqrt(int x);
//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
//! From GLM_GTX_integer extension. //! From GLM_GTX_integer extension.
int mod(int x, int y); int mod(int x, int y);
//! Return the factorial value of a number (!12 max, integer only) //! Return the factorial value of a number (!12 max, integer only)
//! From GLM_GTX_integer extension. //! From GLM_GTX_integer extension.
template <typename genType> template <typename genType>
genType factorial(genType const & x); genType factorial(genType const & x);
///@} /// @}
}//namespace integer
}//namespace integer }//namespace gtx
}//namespace gtx
}//namespace glm }//namespace glm
#include "integer.inl" #include "integer.inl"

77
glm/gtx/intersect.hpp
View File

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

34
glm/gtx/log_base.hpp
View File

@ -20,30 +20,24 @@
# pragma message("GLM: GLM_GTX_log_base extension included") # pragma message("GLM: GLM_GTX_log_base extension included")
#endif #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 test{ /// \addtogroup gtx_log_base
void main_ext_gtx_log_base(); /// @{
}//namespace test
namespace gtx{ //! Logarithm for any base.
//! GLM_GTX_log_base extension: Logarithm for any base. base can be a vector or a scalar. //! From GLM_GTX_log_base.
namespace log_base template <typename genType>
{ genType log(
/// \addtogroup gtx_log_base 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 }//namespace glm
#include "log_base.inl" #include "log_base.inl"

43
glm/gtx/matrix_cross_product.hpp
View File

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

65
glm/gtx/matrix_interpolation.hpp
View File

@ -23,47 +23,40 @@
# pragma message("GLM: GLM_GTX_matrix_interpolation extension included") # pragma message("GLM: GLM_GTX_matrix_interpolation extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace matrix_interpolation ///< GLM_GTX_matrix_interpolation extension: Add transformation matrices
{ {
namespace test{ /// \addtogroup gtx_matrix_interpolation
void main_gtx_transform(); /// @{
}//namespace test
namespace gtx{ //! Get the axis and angle of the rotation from a matrix.
//! GLM_GTX_matrix_interpolation extension: Add transformation matrices //! From GLM_GTX_matrix_interpolation extension.
namespace matrix_interpolation template <typename T>
{ void axisAngle(
/// \addtogroup gtx_matrix_interpolation detail::tmat4x4<T> const & mat,
///@{ detail::tvec3<T> & axis,
T & angle);
//! Get the axis and angle of the rotation from a matrix. //! Build a matrix from axis and angle.
//! From GLM_GTX_matrix_interpolation extension. //! From GLM_GTX_matrix_interpolation extension.
template <typename T> template <typename T>
void axisAngle( detail::tmat4x4<T> axisAngleMatrix(
detail::tmat4x4<T> const & mat, detail::tvec3<T> const & axis,
detail::tvec3<T> & axis, T const angle);
T & angle);
//! Build a matrix from axis and angle. //! Build a interpolation of 4 * 4 matrixes.
//! From GLM_GTX_matrix_interpolation extension. //! From GLM_GTX_matrix_interpolation extension.
template <typename T> //! Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results.
detail::tmat4x4<T> axisAngleMatrix( template <typename T>
detail::tvec3<T> const & axis, detail::tmat4x4<T> interpolate(
T const angle); 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. }//namespace matrix_interpolation
//! Warning! works only with rotation and/or translation matrixes, scale will generate unexpected results. }//namespace gtx
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 glm }//namespace glm
#include "matrix_interpolation.inl" #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") # pragma message("GLM: GLM_GTX_matrix_major_storage extension included")
#endif #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{ /// \addtogroup gtx_matrix_major_storage
//! GLM_GTX_matrix_major_storage: Build matrices with specific matrix order, row or column /// @{
namespace matrix_major_storage
{
/// \addtogroup gtx_matrix_major_storage
///@{
//! Build a row major matrix from row vectors. //! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension. //! From GLM_GTX_matrix_major_storage extension.
template <typename T> template <typename T>
detail::tmat2x2<T> rowMajor2( detail::tmat2x2<T> rowMajor2(
const detail::tvec2<T>& v1, const detail::tvec2<T>& v1,
const detail::tvec2<T>& v2); const detail::tvec2<T>& v2);
//! Build a row major matrix from other matrix. //! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension. //! From GLM_GTX_matrix_major_storage extension.
template <typename T> template <typename T>
detail::tmat2x2<T> rowMajor2( detail::tmat2x2<T> rowMajor2(
const detail::tmat2x2<T>& m); const detail::tmat2x2<T>& m);
//! Build a row major matrix from row vectors. //! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension. //! From GLM_GTX_matrix_major_storage extension.
template <typename T> template <typename T>
detail::tmat3x3<T> rowMajor3( detail::tmat3x3<T> rowMajor3(
const detail::tvec3<T>& v1, const detail::tvec3<T>& v1,
const detail::tvec3<T>& v2, const detail::tvec3<T>& v2,
const detail::tvec3<T>& v3); const detail::tvec3<T>& v3);
//! Build a row major matrix from other matrix. //! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension. //! From GLM_GTX_matrix_major_storage extension.
template <typename T> template <typename T>
detail::tmat3x3<T> rowMajor3( detail::tmat3x3<T> rowMajor3(
const detail::tmat3x3<T>& m); const detail::tmat3x3<T>& m);
//! Build a row major matrix from row vectors. //! Build a row major matrix from row vectors.
//! From GLM_GTX_matrix_major_storage extension. //! From GLM_GTX_matrix_major_storage extension.
template <typename T> template <typename T>
detail::tmat4x4<T> rowMajor4( detail::tmat4x4<T> rowMajor4(
const detail::tvec4<T>& v1, const detail::tvec4<T>& v1,
const detail::tvec4<T>& v2, const detail::tvec4<T>& v2,
const detail::tvec4<T>& v3, const detail::tvec4<T>& v3,
const detail::tvec4<T>& v4); const detail::tvec4<T>& v4);
//! Build a row major matrix from other matrix. //! Build a row major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension. //! From GLM_GTX_matrix_major_storage extension.
template <typename T> template <typename T>
detail::tmat4x4<T> rowMajor4( detail::tmat4x4<T> rowMajor4(
const detail::tmat4x4<T>& m); const detail::tmat4x4<T>& m);
//! Build a column major matrix from column vectors. //! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension. //! From GLM_GTX_matrix_major_storage extension.
template <typename T> template <typename T>
detail::tmat2x2<T> colMajor2( detail::tmat2x2<T> colMajor2(
const detail::tvec2<T>& v1, const detail::tvec2<T>& v1,
const detail::tvec2<T>& v2); const detail::tvec2<T>& v2);
//! Build a column major matrix from other matrix. //! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension. //! From GLM_GTX_matrix_major_storage extension.
template <typename T> template <typename T>
detail::tmat2x2<T> colMajor2( detail::tmat2x2<T> colMajor2(
const detail::tmat2x2<T>& m); const detail::tmat2x2<T>& m);
//! Build a column major matrix from column vectors. //! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension. //! From GLM_GTX_matrix_major_storage extension.
template <typename T> template <typename T>
detail::tmat3x3<T> colMajor3( detail::tmat3x3<T> colMajor3(
const detail::tvec3<T>& v1, const detail::tvec3<T>& v1,
const detail::tvec3<T>& v2, const detail::tvec3<T>& v2,
const detail::tvec3<T>& v3); const detail::tvec3<T>& v3);
//! Build a column major matrix from other matrix. //! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension. //! From GLM_GTX_matrix_major_storage extension.
template <typename T> template <typename T>
detail::tmat3x3<T> colMajor3( detail::tmat3x3<T> colMajor3(
const detail::tmat3x3<T>& m); const detail::tmat3x3<T>& m);
//! Build a column major matrix from column vectors. //! Build a column major matrix from column vectors.
//! From GLM_GTX_matrix_major_storage extension. //! From GLM_GTX_matrix_major_storage extension.
template <typename T> template <typename T>
detail::tmat4x4<T> colMajor4( detail::tmat4x4<T> colMajor4(
const detail::tvec4<T>& v1, const detail::tvec4<T>& v1,
const detail::tvec4<T>& v2, const detail::tvec4<T>& v2,
const detail::tvec4<T>& v3, const detail::tvec4<T>& v3,
const detail::tvec4<T>& v4); const detail::tvec4<T>& v4);
//! Build a column major matrix from other matrix. //! Build a column major matrix from other matrix.
//! From GLM_GTX_matrix_major_storage extension. //! From GLM_GTX_matrix_major_storage extension.
template <typename T> template <typename T>
detail::tmat4x4<T> colMajor4( detail::tmat4x4<T> colMajor4(
const detail::tmat4x4<T>& m); const detail::tmat4x4<T>& m);
///@} /// @}
}//namespace matrix_major_storage
}//namespace matrix_major_storage }//namespace gtx
}//namespace gtx
}//namespace glm }//namespace glm
#include "matrix_major_storage.inl" #include "matrix_major_storage.inl"

113
glm/gtx/matrix_operation.hpp
View File

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

118
glm/gtx/matrix_query.hpp
View File

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

36
glm/gtx/mixed_product.hpp
View File

@ -20,30 +20,24 @@
# pragma message("GLM: GLM_GTX_mixed_product extension included") # pragma message("GLM: GLM_GTX_mixed_product extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace mixed_product ///< GLM_GTX_mixed_product extension: Mixed product of 3 vectors.
{ {
namespace test{ /// \addtogroup gtx_mixed_product
void main_gtx_matrix_selection(); /// @{
}//namespace test
namespace gtx{ //! \brief Mixed product of 3 vectors (from GLM_GTX_mixed_product extension)
//! GLM_GTX_mixed_product extension: Mixed product of 3 vectors. template <typename valType>
namespace mixed_product valType mixedProduct(
{ detail::tvec3<valType> const & v1,
/// \addtogroup gtx_mixed_product 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> }// namespace mixed_product
valType mixedProduct( }// namespace gtx
detail::tvec3<valType> const & v1, }// namespace glm
detail::tvec3<valType> const & v2,
detail::tvec3<valType> const & v3);
///@}
}//namespace mixed_product
}//namespace gtx
}//namespace glm
#include "mixed_product.inl" #include "mixed_product.inl"

47
glm/gtx/multiple.hpp
View File

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

55
glm/gtx/noise.hpp
View File

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

191
glm/gtx/norm.hpp
View File

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

37
glm/gtx/normal.hpp
View File

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

49
glm/gtx/normalize_dot.hpp
View File

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

7
glm/gtx/number_precision.hpp
View File

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

8
glm/gtx/ocl_type.hpp
View File

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

71
glm/gtx/optimum_pow.hpp
View File

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

45
glm/gtx/orthonormalize.hpp
View File

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

60
glm/gtx/perpendicular.hpp
View File

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

35
glm/gtx/polar_coordinates.hpp
View File

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

59
glm/gtx/projection.hpp
View File

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

313
glm/gtx/quaternion.hpp
View File

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

5
glm/gtx/random.hpp
View File

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

44
glm/gtx/raw_data.hpp
View File

@ -22,36 +22,34 @@
#endif #endif
namespace glm{ 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 using namespace gtc::type_precision;
namespace raw_data
{
using namespace gtc::type_precision;
/// \addtogroup gtx_raw_data /// \addtogroup gtx_raw_data
///@{ ///@{
//! Type for byte numbers. //! Type for byte numbers.
//! From GLM_GTX_raw_data extension. //! From GLM_GTX_raw_data extension.
typedef uint8 byte; typedef uint8 byte;
//! Type for word numbers. //! Type for word numbers.
//! From GLM_GTX_raw_data extension. //! From GLM_GTX_raw_data extension.
typedef uint16 word; typedef uint16 word;
//! Type for dword numbers. //! Type for dword numbers.
//! From GLM_GTX_raw_data extension. //! From GLM_GTX_raw_data extension.
typedef uint32 dword; typedef uint32 dword;
//! Type for qword numbers. //! Type for qword numbers.
//! From GLM_GTX_raw_data extension. //! From GLM_GTX_raw_data extension.
typedef uint64 qword; typedef uint64 qword;
///@} ///@}
} }// namespace raw_data
}//namespace gtx }// namespace gtx
}//namespace glm }// namespace glm
#include "raw_data.inl" #include "raw_data.inl"

125
glm/gtx/reciprocal.hpp
View File

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

136
glm/gtx/rotate_vector.hpp
View File

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

242
glm/gtx/simd_mat4.hpp
View File

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

75
glm/gtx/simplex.hpp
View File

@ -20,50 +20,47 @@
# pragma message("GLM: GLM_GTX_simplex extension included") # pragma message("GLM: GLM_GTX_simplex extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace spline ///< GLM_GTX_simplex extension: Spline functions
{ {
namespace gtx{ /// \addtogroup gtx_spline
//! GLM_GTX_simplex extension: Spline functions ///@{
namespace spline
{
/// \addtogroup gtx_spline
///@{
//! Return a point from a catmull rom curve. //! Return a point from a catmull rom curve.
//! From GLM_GTX_spline extension. //! From GLM_GTX_spline extension.
template <typename genType> template <typename genType>
genType catmullRom( genType catmullRom(
genType const & v1, genType const & v1,
genType const & v2, genType const & v2,
genType const & v3, genType const & v3,
genType const & v4, genType const & v4,
typename genType::value_type const & s); typename genType::value_type const & s);
//! Return a point from a hermite curve. //! Return a point from a hermite curve.
//! From GLM_GTX_spline extension. //! From GLM_GTX_spline extension.
template <typename genType> template <typename genType>
genType hermite( genType hermite(
genType const & v1, genType const & v1,
genType const & t1, genType const & t1,
genType const & v2, genType const & v2,
genType const & t2, genType const & t2,
typename genType::value_type const & s); typename genType::value_type const & s);
//! Return a point from a cubic curve. //! Return a point from a cubic curve.
//! From GLM_GTX_spline extension. //! From GLM_GTX_spline extension.
template <typename genType> template <typename genType>
genType cubic( genType cubic(
genType const & v1, genType const & v1,
genType const & v2, genType const & v2,
genType const & v3, genType const & v3,
genType const & v4, genType const & v4,
typename genType::value_type const & s); typename genType::value_type const & s);
///@} /// @}
}// namespace simplex
}//namespace simplex }// namespace gtx
}//namespace gtx }// namespace glm
}//namespace glm
#include "simplex.inl" #include "simplex.inl"

75
glm/gtx/spline.hpp
View File

@ -21,51 +21,48 @@
# pragma message("GLM: GLM_GTX_spline extension included") # pragma message("GLM: GLM_GTX_spline extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace spline ///< GLM_GTX_spline extension: Spline functions
{ {
namespace gtx{ using namespace gtx::optimum_pow;
//! GLM_GTX_spline extension: Spline functions
namespace spline
{
using namespace gtx::optimum_pow;
/// \addtogroup gtx_spline /// \addtogroup gtx_spline
///@{ /// @{
//! Return a point from a catmull rom curve. //! Return a point from a catmull rom curve.
//! From GLM_GTX_spline extension. //! From GLM_GTX_spline extension.
template <typename genType> template <typename genType>
genType catmullRom( genType catmullRom(
genType const & v1, genType const & v1,
genType const & v2, genType const & v2,
genType const & v3, genType const & v3,
genType const & v4, genType const & v4,
typename genType::value_type const & s); typename genType::value_type const & s);
//! Return a point from a hermite curve. //! Return a point from a hermite curve.
//! From GLM_GTX_spline extension. //! From GLM_GTX_spline extension.
template <typename genType> template <typename genType>
genType hermite( genType hermite(
genType const & v1, genType const & v1,
genType const & t1, genType const & t1,
genType const & v2, genType const & v2,
genType const & t2, genType const & t2,
typename genType::value_type const & s); typename genType::value_type const & s);
//! Return a point from a cubic curve. //! Return a point from a cubic curve.
//! From GLM_GTX_spline extension. //! From GLM_GTX_spline extension.
template <typename genType> template <typename genType>
genType cubic( genType cubic(
genType const & v1, genType const & v1,
genType const & v2, genType const & v2,
genType const & v3, genType const & v3,
genType const & v4, genType const & v4,
typename genType::value_type const & s); typename genType::value_type const & s);
///@} /// @}
}//namespace spline
}//namespace spline }//namespace gtx
}//namespace gtx
}//namespace glm }//namespace glm
#include "spline.inl" #include "spline.inl"

70
glm/gtx/std_based_type.hpp
View File

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

39
glm/gtx/string_cast.hpp
View File

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

127
glm/gtx/transform.hpp
View File

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

155
glm/gtx/transform2.hpp
View File

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

69
glm/gtx/ulp.hpp
View File

@ -20,50 +20,47 @@
# pragma message("GLM: GLM_GTX_ulp extension included") # pragma message("GLM: GLM_GTX_ulp extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace ulp ///< GLM_GTX_ulp extension: Precision calculation functions
{ {
namespace gtx{ /// \addtogroup gtx_ulp
//! GLM_GTX_ulp extension: Precision calculation functions /// @{
namespace ulp
{
/// \addtogroup gtx_ulp
///@{
//! Return the next ULP value(s) after the input value(s). //! Return the next ULP value(s) after the input value(s).
//! From GLM_GTX_ulp extension. //! From GLM_GTX_ulp extension.
template <typename genType> template <typename genType>
genType next_float(genType const & x); genType next_float(genType const & x);
//! Return the previous ULP value(s) before the input value(s). //! Return the previous ULP value(s) before the input value(s).
//! From GLM_GTX_ulp extension. //! From GLM_GTX_ulp extension.
template <typename genType> template <typename genType>
genType prev_float(genType const & x); genType prev_float(genType const & x);
//! Return the value(s) ULP distance after the input value(s). //! Return the value(s) ULP distance after the input value(s).
//! From GLM_GTX_ulp extension. //! From GLM_GTX_ulp extension.
template <typename genType> template <typename genType>
genType next_float(genType const & x, uint const & Distance); genType next_float(genType const & x, uint const & Distance);
//! Return the value(s) ULP distance before the input value(s). //! Return the value(s) ULP distance before the input value(s).
//! From GLM_GTX_ulp extension. //! From GLM_GTX_ulp extension.
template <typename genType> template <typename genType>
genType prev_float(genType const & x, uint const & Distance); genType prev_float(genType const & x, uint const & Distance);
//! Return the distance in the number of ULP between 2 scalars. //! Return the distance in the number of ULP between 2 scalars.
//! From GLM_GTX_ulp extension. //! From GLM_GTX_ulp extension.
template <typename T> template <typename T>
uint float_distance(T const & x, T const & y); uint float_distance(T const & x, T const & y);
//! Return the distance in the number of ULP between 2 vectors. //! Return the distance in the number of ULP between 2 vectors.
//! From GLM_GTX_ulp extension. //! From GLM_GTX_ulp extension.
template<typename T, template<typename> class vecType> template<typename T, template<typename> class vecType>
vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y); vecType<uint> float_distance(vecType<T> const & x, vecType<T> const & y);
///@} ///@}
}// namespace ulp
}//namespace ulp }// namespace gtx
}//namespace gtx }// namespace glm
}//namespace glm
#include "ulp.inl" #include "ulp.inl"

49
glm/gtx/unsigned_int.hpp
View File

@ -22,41 +22,34 @@
# pragma message("GLM: GLM_GTX_unsigned_int extension included") # pragma message("GLM: GLM_GTX_unsigned_int extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace unsigned_int ///< GLM_GTX_unsigned_int extension: Add support for unsigned integer for core functions
{ {
namespace test{ using namespace gtx::integer;
void main_gtx_unsigned_int();
}//namespace test
namespace gtx{ /// \addtogroup gtx_unsigned_int
//! GLM_GTX_unsigned_int extension: Add support for unsigned integer for core functions /// @{
namespace unsigned_int
{
using namespace gtx::integer;
/// \addtogroup gtx_unsigned_int //! 32bit signed integer.
///@{ //! From GLM_GTX_unsigned_int extension.
typedef signed int sint;
//! 32bit signed integer. //! Returns x raised to the y power.
//! From GLM_GTX_unsigned_int extension. //! From GLM_GTX_unsigned_int extension.
typedef signed int sint; uint pow(uint x, uint y);
//! Returns x raised to the y power. //! Returns the positive square root of x.
//! From GLM_GTX_unsigned_int extension. //! From GLM_GTX_unsigned_int extension.
uint pow(uint x, uint y); uint sqrt(uint x);
//! Returns the positive square root of x. //! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y.
//! From GLM_GTX_unsigned_int extension. //! From GLM_GTX_unsigned_int extension.
uint sqrt(uint x); uint mod(uint x, uint y);
//! Modulus. Returns x - y * floor(x / y) for each component in x using the floating point value y. /// @}
//! From GLM_GTX_unsigned_int extension. }//namespace unsigned_int
uint mod(uint x, uint y); }//namespace gtx
///@}
}//namespace unsigned_int
}//namespace gtx
}//namespace glm }//namespace glm
#include "unsigned_int.inl" #include "unsigned_int.inl"

141
glm/gtx/vec1.hpp
View File

@ -21,104 +21,97 @@
# pragma message("GLM: GLM_GTX_vec1 extension included") # pragma message("GLM: GLM_GTX_vec1 extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace vector1{ ///< GLM_GTX_vec1 extension: 1 component vector.
namespace precision
{ {
namespace test{ //! 1 component vector of high precision floating-point numbers.
void main_gtx_vector1(); //! There is no guarantee on the actual precision.
}//namespace test //! From GLM_GTX_vec1 extension.
typedef detail::highp_vec1_t highp_vec1;
//! 1 component vector of medium precision floating-point numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::mediump_vec1_t mediump_vec1;
//! 1 component vector of low precision floating-point numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_vec1_t lowp_vec1;
namespace gtx{ //! 1 component vector of high precision signed integer numbers.
//! GLM_GTX_vector1 extension: 1 component vector. //! There is no guarantee on the actual precision.
namespace vector1 //! From GLM_GTX_vec1 extension.
{ typedef detail::highp_ivec1_t highp_ivec1;
namespace precision //! 1 component vector of medium precision signed integer numbers.
{ //! There is no guarantee on the actual precision.
//! 1 component vector of high precision floating-point numbers. //! From GLM_GTX_vec1 extension.
//! There is no guarantee on the actual precision. typedef detail::mediump_ivec1_t mediump_ivec1;
//! From GLM_GTX_vec1 extension. //! 1 component vector of low precision signed integer numbers.
typedef detail::highp_vec1_t highp_vec1; //! There is no guarantee on the actual precision.
//! 1 component vector of medium precision floating-point numbers. //! From GLM_GTX_vec1 extension.
//! There is no guarantee on the actual precision. typedef detail::lowp_ivec1_t lowp_ivec1;
//! From GLM_GTX_vec1 extension.
typedef detail::mediump_vec1_t mediump_vec1;
//! 1 component vector of low precision floating-point numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_vec1_t lowp_vec1;
//! 1 component vector of high precision signed integer numbers. //! 1 component vector of high precision unsigned integer numbers.
//! There is no guarantee on the actual precision. //! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension. //! From GLM_GTX_vec1 extension.
typedef detail::highp_ivec1_t highp_ivec1; typedef detail::highp_uvec1_t highp_uvec1;
//! 1 component vector of medium precision signed integer numbers. //! 1 component vector of medium precision unsigned integer numbers.
//! There is no guarantee on the actual precision. //! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension. //! From GLM_GTX_vec1 extension.
typedef detail::mediump_ivec1_t mediump_ivec1; typedef detail::mediump_uvec1_t mediump_uvec1;
//! 1 component vector of low precision signed integer numbers. //! 1 component vector of low precision unsigned integer numbers.
//! There is no guarantee on the actual precision. //! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension. //! From GLM_GTX_vec1 extension.
typedef detail::lowp_ivec1_t lowp_ivec1; typedef detail::lowp_uvec1_t lowp_uvec1;
}//namespace precision
//! 1 component vector of high precision unsigned integer numbers. //////////////////////////
//! There is no guarantee on the actual precision. // vec1 definition
//! From GLM_GTX_vec1 extension.
typedef detail::highp_uvec1_t highp_uvec1;
//! 1 component vector of medium precision unsigned integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::mediump_uvec1_t mediump_uvec1;
//! 1 component vector of low precision unsigned integer numbers.
//! There is no guarantee on the actual precision.
//! From GLM_GTX_vec1 extension.
typedef detail::lowp_uvec1_t lowp_uvec1;
}//namespace precision
////////////////////////// //! 1 component vector of boolean.
// vec1 definition //! From GLM_GTX_vec1 extension.
typedef detail::tvec1<bool> bvec1;
//! 1 component vector of boolean.
//! From GLM_GTX_vec1 extension.
typedef detail::tvec1<bool> bvec1;
#if(defined(GLM_PRECISION_HIGHP_FLOAT)) #if(defined(GLM_PRECISION_HIGHP_FLOAT))
typedef precision::highp_vec1 vec1; typedef precision::highp_vec1 vec1;
#elif(defined(GLM_PRECISION_MEDIUMP_FLOAT)) #elif(defined(GLM_PRECISION_MEDIUMP_FLOAT))
typedef precision::mediump_vec1 vec1; typedef precision::mediump_vec1 vec1;
#elif(defined(GLM_PRECISION_LOWP_FLOAT)) #elif(defined(GLM_PRECISION_LOWP_FLOAT))
typedef precision::lowp_vec1 vec1; typedef precision::lowp_vec1 vec1;
#else #else
//! 1 component vector of floating-point numbers. //! 1 component vector of floating-point numbers.
//! From GLM_GTX_vec1 extension. //! From GLM_GTX_vec1 extension.
typedef precision::mediump_vec1 vec1; typedef precision::mediump_vec1 vec1;
#endif//GLM_PRECISION #endif//GLM_PRECISION
#if(defined(GLM_PRECISION_HIGHP_INT)) #if(defined(GLM_PRECISION_HIGHP_INT))
typedef precision::highp_ivec1 ivec1; typedef precision::highp_ivec1 ivec1;
#elif(defined(GLM_PRECISION_MEDIUMP_INT)) #elif(defined(GLM_PRECISION_MEDIUMP_INT))
typedef precision::mediump_ivec1 ivec1; typedef precision::mediump_ivec1 ivec1;
#elif(defined(GLM_PRECISION_LOWP_INT)) #elif(defined(GLM_PRECISION_LOWP_INT))
typedef precision::lowp_ivec1 ivec1; typedef precision::lowp_ivec1 ivec1;
#else #else
//! 1 component vector of signed integer numbers. //! 1 component vector of signed integer numbers.
//! From GLM_GTX_vec1 extension. //! From GLM_GTX_vec1 extension.
typedef precision::mediump_ivec1 ivec1; typedef precision::mediump_ivec1 ivec1;
#endif//GLM_PRECISION #endif//GLM_PRECISION
#if(defined(GLM_PRECISION_HIGHP_UINT)) #if(defined(GLM_PRECISION_HIGHP_UINT))
typedef precision::highp_uvec1 uvec1; typedef precision::highp_uvec1 uvec1;
#elif(defined(GLM_PRECISION_MEDIUMP_UINT)) #elif(defined(GLM_PRECISION_MEDIUMP_UINT))
typedef precision::mediump_uvec1 uvec1; typedef precision::mediump_uvec1 uvec1;
#elif(defined(GLM_PRECISION_LOWP_UINT)) #elif(defined(GLM_PRECISION_LOWP_UINT))
typedef precision::lowp_uvec1 uvec1; typedef precision::lowp_uvec1 uvec1;
#else #else
//! 1 component vector of unsigned integer numbers. //! 1 component vector of unsigned integer numbers.
//! From GLM_GTX_vec1 extension. //! From GLM_GTX_vec1 extension.
typedef precision::mediump_uvec1 uvec1; typedef precision::mediump_uvec1 uvec1;
#endif//GLM_PRECISION #endif//GLM_PRECISION
}//namespace vec1 }// namespace vec1
}//namespace gtx }// namespace gtx
}//namespace glm }// namespace glm
#include "vec1.inl" #include "vec1.inl"

71
glm/gtx/vector_access.hpp
View File

@ -20,50 +20,43 @@
# pragma message("GLM: GLM_GTX_vector_access extension included") # pragma message("GLM: GLM_GTX_vector_access extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace vector_access ///< GLM_GTX_vector_access extension: Function to set values to vectors
{ {
namespace test{ /// \addtogroup gtx_vector_access
void main_gtx_vector_access(); /// @{
}//namespace test
namespace gtx{ //! Set values to a 2 components vector.
//! GLM_GTX_vector_access extension: Function to set values to vectors //! From GLM_GTX_vector_access extension.
namespace vector_access template <typename valType>
{ void set(
/// \addtogroup gtx_vector_access detail::tvec2<valType> & v,
///@{ valType const & x,
valType const & y);
//! Set values to a 2 components vector. //! Set values to a 3 components vector.
//! From GLM_GTX_vector_access extension. //! From GLM_GTX_vector_access extension.
template <typename valType> template <typename valType>
void set( void set(
detail::tvec2<valType> & v, detail::tvec3<valType> & v,
valType const & x, valType const & x,
valType const & y); valType const & y,
valType const & z);
//! Set values to a 3 components vector. //! Set values to a 4 components vector.
//! From GLM_GTX_vector_access extension. //! From GLM_GTX_vector_access extension.
template <typename valType> template <typename valType>
void set( void set(
detail::tvec3<valType> & v, detail::tvec4<valType> & v,
valType const & x, valType const & x,
valType const & y, valType const & y,
valType const & z); valType const & z,
valType const & w);
//! Set values to a 4 components vector. /// @}
//! From GLM_GTX_vector_access extension. }//namespace vector_access
template <typename valType> }//namespace gtx
void set(
detail::tvec4<valType> & v,
valType const & x,
valType const & y,
valType const & z,
valType const & w);
///@}
}//namespace vector_access
}//namespace gtx
}//namespace glm }//namespace glm
#include "vector_access.inl" #include "vector_access.inl"

11
glm/gtx/vector_angle.hpp
View File

@ -27,8 +27,7 @@
namespace glm{ namespace glm{
namespace gtx{ namespace gtx{
//! GLM_GTX_vector_angle extension: Compute angle between vectors namespace vector_angle ///< GLM_GTX_vector_angle extension: Compute angle between vectors
namespace vector_angle
{ {
using namespace quaternion; using namespace quaternion;
using namespace epsilon; using namespace epsilon;
@ -61,10 +60,10 @@ namespace vector_angle
detail::tvec3<T> const & y, detail::tvec3<T> const & y,
detail::tvec3<T> const & ref); detail::tvec3<T> const & ref);
///@} /// @}
}//namespace vector_angle }// namespace vector_angle
}//namespace gtx }// namespace gtx
}//namespace glm }// namespace glm
#include "vector_angle.inl" #include "vector_angle.inl"

119
glm/gtx/vector_query.hpp
View File

@ -22,78 +22,71 @@
# pragma message("GLM: GLM_GTX_vector_query extension included") # pragma message("GLM: GLM_GTX_vector_query extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace vector_query ///< GLM_GTX_vector_query extension: Query informations of vector types
{ {
namespace test{ /// \addtogroup gtx_vector_query
void main_ext_gtx_vector_query(); /// @{
}//namespace test
namespace gtx{ //! Check if two vectors are collinears.
//! GLM_GTX_vector_query extension: Query informations of vector types //! From GLM_GTX_vector_query extensions.
namespace vector_query template <typename genType>
{ bool areCollinear(
/// \addtogroup gtx_vector_query genType const & v0,
///@{ genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are collinears.
//! From GLM_GTX_vector_query extensions.
template <typename genType>
bool areCollinear(
genType const & v0,
genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are opposites. //! Check if two vectors are opposites.
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool areOpposite( bool areOpposite(
genType const & v0, genType const & v0,
genType const & v1, genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are orthogonals. //! Check if two vectors are orthogonals.
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool areOrthogonal( bool areOrthogonal(
genType const & v0, genType const & v0,
genType const & v1, genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if a vector is normalized. //! Check if a vector is normalized.
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool isNormalized( bool isNormalized(
genType const & v, genType const & v,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if a vector is null. //! Check if a vector is null.
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool isNull( bool isNull(
genType const & v, genType const & v,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are orthonormal. //! Check if two vectors are orthonormal.
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool areOrthonormal( bool areOrthonormal(
genType const & v0, genType const & v0,
genType const & v1, genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
//! Check if two vectors are similar. //! Check if two vectors are similar.
//! From GLM_GTX_vector_query extensions. //! From GLM_GTX_vector_query extensions.
template <typename genType> template <typename genType>
bool areSimilar( bool areSimilar(
genType const & v0, genType const & v0,
genType const & v1, genType const & v1,
typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon()); typename genType::value_type const & epsilon = std::numeric_limits<typename genType::value_type>::epsilon());
///@} /// @}
}// namespace vector_query
}//namespace vector_query }// namespace gtx
}//namespace gtx }// namespace glm
}//namespace glm
#include "vector_query.inl" #include "vector_query.inl"

64
glm/gtx/verbose_operator.hpp
View File

@ -20,48 +20,42 @@
# pragma message("GLM: GLM_GTX_verbose_operator extension included") # pragma message("GLM: GLM_GTX_verbose_operator extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace verbose_operator ///< GLM_GTX_verbose_operator extension: Use words to replace operators
{ {
namespace test{ /// \addtogroup gtx_verbose_operator
void main_ext_gtx_verbose_operator(); /// @{
}//namespace test
namespace gtx{ //! Addition of two values
//! GLM_GTX_verbose_operator extension: Use words to replace operators //! From GLM_GTX_verbose_operator extension.
namespace verbose_operator template <typename genTypeT, typename genTypeU>
{ genTypeT add(genTypeT const & a, genTypeU const & b);
/// \addtogroup gtx_verbose_operator
///@{
//! Addition of two values //! Substration of two values
//! From GLM_GTX_verbose_operator extension. //! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU> template <typename genTypeT, typename genTypeU>
genTypeT add(genTypeT const & a, genTypeU const & b); genTypeT sub(genTypeT const & a, genTypeU const & b);
//! Substration of two values //! Multiplication of two values
//! From GLM_GTX_verbose_operator extension. //! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU> template <typename genTypeT, typename genTypeU>
genTypeT sub(genTypeT const & a, genTypeU const & b); genTypeT mul(genTypeT const & a, genTypeU const & b);
//! Multiplication of two values //! Division of two values
//! From GLM_GTX_verbose_operator extension. //! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU> template <typename genTypeT, typename genTypeU>
genTypeT mul(genTypeT const & a, genTypeU const & b); genTypeT div(genTypeT const & a, genTypeU const & b);
//! Division of two values //! Multiplication and addition of three values
//! From GLM_GTX_verbose_operator extension. //! From GLM_GTX_verbose_operator extension.
template <typename genTypeT, typename genTypeU> template <typename genTypeT, typename genTypeU, typename genTypeV>
genTypeT div(genTypeT const & a, genTypeU const & b); genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c);
//! Multiplication and addition of three values /// @}
//! From GLM_GTX_verbose_operator extension. }// namespace verbose_operator
template <typename genTypeT, typename genTypeU, typename genTypeV> }// namespace gtx
genTypeT mad(genTypeT const & a, genTypeU const & b, genTypeV const & c); }// namespace glm
///@}
}//namespace verbose_operator
}//namespace gtx
}//namespace glm
#include "verbose_operator.inl" #include "verbose_operator.inl"

49
glm/gtx/wrap.hpp
View File

@ -20,39 +20,32 @@
# pragma message("GLM: GLM_GTX_wrap extension included") # pragma message("GLM: GLM_GTX_wrap extension included")
#endif #endif
namespace glm namespace glm{
namespace gtx{
namespace wrap ///< GLM_GTX_wrap: Wrapping mode using my texture samping.
{ {
namespace test{ /// \addtogroup gtx_wrap
bool main_gtx_wrap(); /// @{
}//namespace test
namespace gtx{ //! Simulate GL_CLAMP OpenGL wrap mode
//! GLM_GTX_wrap: Wrapping mode using my texture samping. //! From GLM_GTX_wrap extension.
namespace wrap template <typename genType>
{ genType clamp(genType const & Texcoord);
/// \addtogroup gtx_wrap
///@{
//! Simulate GL_CLAMP OpenGL wrap mode //! Simulate GL_REPEAT OpenGL wrap mode
//! From GLM_GTX_wrap extension. //! From GLM_GTX_wrap extension.
template <typename genType> template <typename genType>
genType clamp(genType const & Texcoord); genType repeat(genType const & Texcoord);
//! Simulate GL_REPEAT OpenGL wrap mode //! Simulate GL_MIRROR_REPEAT OpenGL wrap mode
//! From GLM_GTX_wrap extension. //! From GLM_GTX_wrap extension.
template <typename genType> template <typename genType>
genType repeat(genType const & Texcoord); genType mirrorRepeat(genType const & Texcoord);
//! Simulate GL_MIRROR_REPEAT OpenGL wrap mode /// @}
//! From GLM_GTX_wrap extension. }// namespace wrap
template <typename genType> }// namespace gtx
genType mirrorRepeat(genType const & Texcoord); }// namespace glm
///@}
}//namespace wrap
}//namespace gtx
}//namespace glm
#include "wrap.inl" #include "wrap.inl"