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

Fixed merge

Browse Source
This commit is contained in:
Christophe Riccio 2011-05-18 15:57:02 +01:00
commit a79b4c2989
75 changed files with 4374 additions and 4701 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
doc/pages.doxy
View File

@ -10,7 +10,7 @@
This library works perfectly with OpenGL but it also ensures interoperability with other third party libraries and SDK. It is a good candidate for software rendering (Raytracing / Rasterisation), image processing, physic simulations and any context that requires a simple and convenient mathematics library.
GLM is written as a platform independent library with no dependence and officially supports the following compilers:
1. Clang 2.0 and higher
1. Clang 2.0 and higher
2. CUDA 3.0 and higher
3. GCC 3.4 and higher
4. LLVM 2.3 through GCC 4.2 front-end and higher

6
doc/src/data.xml
View File

@ -1535,7 +1535,11 @@
This library works perfectly with OpenGL but it also ensures interoperability with other third party libraries and SDKs. It is a good candidate for software rendering (Raytracing / Rasterisation), image processing, physic simulations and any context that requires a simple and convenient mathematics library.
</paragraph>
<list name="GLM is written as a platform independent library with no dependence and officially supports the following compilers:">
<list-element><link href="http://http://gcc.gnu.org/">GCC</link> 3.4 and higher</list-element>
<list-element><link href="http://clang.llvm.org">Clang</link> 2.0 and higher</list-element>
<list-element>
<link href="http://developer.nvidia.com/category/zone/cuda-zone">CUDA</link> 3.0 and higher
</list-element>
<list-element><link href="http://gcc.gnu.org/">GCC</link> 3.4 and higher</list-element>
<list-element><link href="http://llvm.org/">LLVM</link> 2.3 through GCC 4.2 front-end and higher</list-element>
<list-element><link href="http://msdn.microsoft.com/en-us/visualc/default">Visual C++</link> 2005 and higher</list-element>
<list-element>Any C++ compiler following C++98 norm</list-element>

38
glm/core/setup.hpp
View File

@ -24,6 +24,7 @@
// Compiler
// User defines: GLM_FORCE_COMPILER_UNKNOWN
// TODO ? __llvm__
#define GLM_COMPILER_UNKNOWN 0x00000000
@ -81,6 +82,16 @@
#define GLM_COMPILER_CUDA32 0x10000030
#define GLM_COMPILER_CUDA40 0x10000040
// Clang
#define GLM_COMPILER_CLANG 0x20000000
#define GLM_COMPILER_CLANG26 0x20000010
#define GLM_COMPILER_CLANG27 0x20000020
#define GLM_COMPILER_CLANG28 0x20000030
#define GLM_COMPILER_CLANG29 0x20000040
// LLVM GCC
#define GLM_COMPILER_LLVM_GCC 0x40000000
// Build model
#define GLM_MODEL_32 0x00000010
#define GLM_MODEL_64 0x00000020
@ -91,6 +102,8 @@
// CUDA
#elif defined(__CUDACC__)
# define GLM_COMPILER GLM_COMPILER_CUDA
/*
# if CUDA_VERSION < 3000
# error "GLM requires CUDA 3.0 or higher"
# elif CUDA_VERSION == 3000
@ -104,6 +117,7 @@
# else
# define GLM_COMPILER GLM_COMPILER_CUDA
# endif
*/
// Visual C++
#elif defined(_MSC_VER)
@ -131,6 +145,20 @@
# define GLM_COMPILER GLM_COMPILER_VC
# endif//_MSC_VER
#elif defined(__clang__)
# if (__clang_major__ == 2) && (__clang_minor__ == 6)
# define GLM_COMPILER GLM_COMPILER_CLANG26
# elif (__clang_major__ == 2) && (__clang_minor__ == 7)
# define GLM_COMPILER GLM_COMPILER_CLANG27
# elif (__clang_major__ == 2) && (__clang_minor__ == 8)
# define GLM_COMPILER GLM_COMPILER_CLANG28
# elif (__clang_major__ == 2) && (__clang_minor__ == 9)
# define GLM_COMPILER GLM_COMPILER_CLANG29
# endif
#elif defined(__llvm__)
# define GLM_COMPILER GLM_COMPILER_LLVM_GCC
// G++
#elif defined(__GNUC__)
# if (__GNUC__ == 3) && (__GNUC_MINOR__ == 2)
@ -196,8 +224,14 @@
// Report compiler detection
#if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPILER_DISPLAYED))
# define GLM_MESSAGE_COMPILER_DISPLAYED
# if(GLM_COMPILER & GLM_COMPILER_VC)
# if(GLM_COMPILER & GLM_COMPILER_CUDA)
# pragma message("GLM: CUDA compiler detected")
# elif(GLM_COMPILER & GLM_COMPILER_VC)
# pragma message("GLM: Visual C++ compiler detected")
# elif(GLM_COMPILER & GLM_COMPILER_CLANG)
# pragma message("GLM: Clang compiler detected")
# elif(GLM_COMPILER & GLM_COMPILER_LLVM_GCC)
# pragma message("GLM: LLVM GCC compiler detected")
# elif(GLM_COMPILER & GLM_COMPILER_GCC)
# pragma message("GLM: GCC compiler detected")
# elif(GLM_COMPILER & GLM_COMPILER_BC)
@ -402,7 +436,7 @@
// User defines: GLM_FORCE_INLINE GLM_FORCE_CUDA
#if(defined(GLM_FORCE_CUDA) || (defined(__CUDACC__)))
#if(defined(GLM_FORCE_CUDA) || (GLM_COMPILER & GLM_COMPILER_CUDA))
# define GLM_CUDA_FUNC_DEF __device__ __host__
# define GLM_CUDA_FUNC_DECL __device__ __host__
#else

661
glm/gtc/half_float.hpp
View File

@ -17,351 +17,346 @@
# pragma message("GLM: GLM_GTC_half_float extension included")
#endif
namespace glm
namespace glm{
namespace detail
{
namespace test{
bool main_gtc_half_float();
}//namespace
namespace detail
{
#ifndef _MSC_EXTENSIONS
template <>
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
template <>
struct tvec2<thalf>
{
/// \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.
//! From GLM_GTC_half_float extension.
typedef detail::thalf half;
typedef tvec2<thalf> type;
typedef tvec2<bool> bool_type;
//! Vector of 2 half-precision floating-point numbers.
//! From GLM_GTC_half_float extension.
typedef detail::tvec2<detail::thalf> hvec2;
//////////////////////////////////////
// Data
//! Vector of 3 half-precision floating-point numbers.
//! From GLM_GTC_half_float extension.
typedef detail::tvec3<detail::thalf> hvec3;
thalf x, y;
//! Vector of 4 half-precision floating-point numbers.
//! From GLM_GTC_half_float extension.
typedef detail::tvec4<detail::thalf> hvec4;
//////////////////////////////////////
// Accesses
//! 2 * 2 matrix of half-precision floating-point numbers.
//! From GLM_GTC_half_float extension.
typedef detail::tmat2x2<detail::thalf> hmat2;
thalf & operator[](size_type i);
thalf const & operator[](size_type i) const;
//! 3 * 3 matrix of half-precision floating-point numbers.
//! From GLM_GTC_half_float extension.
typedef detail::tmat3x3<detail::thalf> hmat3;
//////////////////////////////////////
// Implicit basic constructors
//! 4 * 4 matrix of half-precision floating-point numbers.
//! From GLM_GTC_half_float extension.
typedef detail::tmat4x4<detail::thalf> hmat4;
tvec2();
tvec2(tvec2<thalf> const & v);
///@}
//////////////////////////////////////
// Explicit basic constructors
}//namespace half_float
}//namespace gtc
}//namespace glm
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{
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"

3
glm/gtc/matrix_access.hpp
View File

@ -22,8 +22,7 @@
namespace glm{
namespace gtc{
//! GLM_GTC_matrix_access extension: Set a column or a row of a matrix
namespace matrix_access
namespace matrix_access ///< GLM_GTC_matrix_access extension: Set a column or a row of a matrix
{
/// \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")
#endif
namespace glm
namespace glm{
namespace gtc{
namespace matrix_integer ///< GLM_GTC_matrix_integer extension: Add integer matrices
{
namespace test{
bool main_gtc_matrix_integer();
}//namespace test
/// \addtogroup gtc_matrix_integer
///@{
namespace gtc{
//! GLM_GTC_matrix_integer extension: Add integer matrices
namespace matrix_integer
{
/// \addtogroup gtc_matrix_integer
///@{
typedef detail::tmat2x2<highp_int> highp_imat2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<highp_int> highp_imat3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<highp_int> highp_imat4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<highp_int> highp_imat2; //!< \brief High-precision signed integer 2x2 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat3x3<highp_int> highp_imat3; //!< \brief High-precision signed integer 3x3 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat4x4<highp_int> highp_imat4; //!< \brief High-precision signed integer 4x4 matrix. (from GLM_GTC_matrix_integer extension)
typedef detail::tmat2x2<highp_int> highp_imat2x2; //!< \brief High-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::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::tmat2x3<highp_int> highp_imat2x3; //!< \brief High-precision signed integer 2x3 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<mediump_int> mediump_imat2; //!< \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::tmat4x4<mediump_int> mediump_imat4; //!< \brief Medium-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::tmat3x3<mediump_int> mediump_imat3; //!< \brief Medium-precision signed integer 3x3 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::tmat2x2<mediump_int> mediump_imat2x2; //!< \brief Medium-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::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::tmat2x3<mediump_int> mediump_imat2x3; //!< \brief Medium-precision signed integer 2x3 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<lowp_int> lowp_imat2; //!< \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::tmat4x4<lowp_int> lowp_imat4; //!< \brief Low-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::tmat3x3<lowp_int> lowp_imat3; //!< \brief Low-precision signed integer 3x3 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::tmat2x2<lowp_int> lowp_imat2x2; //!< \brief Low-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::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::tmat2x3<lowp_int> lowp_imat2x3; //!< \brief Low-precision signed integer 2x3 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<highp_uint> highp_umat2; //!< \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::tmat4x4<highp_uint> highp_umat4; //!< \brief High-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::tmat3x3<highp_uint> highp_umat3; //!< \brief High-precision signed integer 3x3 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::tmat2x2<highp_uint> highp_umat2x2; //!< \brief High-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::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::tmat2x3<highp_uint> highp_umat2x3; //!< \brief High-precision signed integer 2x3 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<mediump_uint> mediump_umat2; //!< \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::tmat4x4<mediump_uint> mediump_umat4; //!< \brief Medium-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::tmat3x3<mediump_uint> mediump_umat3; //!< \brief Medium-precision signed integer 3x3 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::tmat2x2<mediump_uint> mediump_umat2x2; //!< \brief Medium-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::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::tmat2x3<mediump_uint> mediump_umat2x3; //!< \brief Medium-precision signed integer 2x3 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<lowp_uint> lowp_umat2; //!< \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::tmat4x4<lowp_uint> lowp_umat4; //!< \brief Low-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::tmat3x3<lowp_uint> lowp_umat3; //!< \brief Low-precision signed integer 3x3 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::tmat2x2<lowp_uint> lowp_umat2x2; //!< \brief Low-precision signed integer 2x2 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::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::tmat3x3<lowp_uint> lowp_umat3x3; //!< \brief Low-precision signed integer 3x3 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)
typedef detail::tmat2x2<lowp_uint> lowp_umat2x2; //!< \brief Low-precision signed integer 2x2 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::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::tmat3x3<lowp_uint> lowp_umat3x3; //!< \brief Low-precision signed integer 3x3 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))
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_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_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_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_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_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_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_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_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_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_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_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)
#elif(defined(GLM_PRECISION_LOWP_INT))
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_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_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_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_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_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_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_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_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_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_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_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)
#else //if(defined(GLM_PRECISION_MEDIUMP_INT))
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_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_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_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_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_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_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_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_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_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_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_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)
#endif//GLM_PRECISION
#if(defined(GLM_PRECISION_HIGHP_UINT))
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_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_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_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_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_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_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_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_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_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_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_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)
#elif(defined(GLM_PRECISION_LOWP_UINT))
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_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_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_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_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_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_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_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_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_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_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_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)
#else //if(defined(GLM_PRECISION_MEDIUMP_UINT))
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_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_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_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_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_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_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_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_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_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_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_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)
#endif//GLM_PRECISION
///@}
///@}
}//namespace matrix_integer
}//namespace gtc
}//namespace matrix_integer
}//namespace gtc
}//namespace glm
namespace glm{using namespace gtc::matrix_integer;}

3
glm/gtc/matrix_inverse.hpp
View File

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

7
glm/gtc/matrix_transform.hpp
View File

@ -41,13 +41,8 @@
#endif
namespace glm{
namespace test{
bool main_gtc_matrix_transform();
}//namespace test
namespace gtc{
/// GLM_GTC_matrix_transform extension: Add transformation matrices
namespace matrix_transform
namespace matrix_transform ///< GLM_GTC_matrix_transform extension: Add transformation matrices
{
/// @addtogroup gtc_matrix_transform
/// @{

322
glm/gtc/quaternion.hpp
View File

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

546
glm/gtc/swizzle.hpp
View File

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

306
glm/gtc/type_precision.hpp
View File

@ -24,199 +24,193 @@
# pragma message("GLM: GLM_GTC_type_precision extension included")
#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();
}//namespace test
///////////////////////////
// Dependences
namespace gtc{
//! GLM_GTC_type_precision extension: Defined types with specific size.
namespace type_precision
{
///////////////////////////
// Dependences
using namespace gtc::half_float;
using namespace gtc::quaternion;
using namespace gtc::half_float;
using namespace gtc::quaternion;
///////////////////////////
// Signed int vector types
///////////////////////////
// Signed int vector types
/// \addtogroup gtc_type_precision
///@{
/// \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 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 int8 i8; //!< \brief 8bit signed integer. (from GLM_GTC_type_precision extension)
typedef int16 i16; //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
typedef int32 i32; //!< \brief 32bit 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 int16 i16; //!< \brief 16bit signed integer. (from GLM_GTC_type_precision extension)
typedef int32 i32; //!< \brief 32bit signed integer. (from GLM_GTC_type_precision extension)
typedef int64 i64; //!< \brief 64bit signed integer. (from GLM_GTC_type_precision extension)
//typedef i8 i8vec1; //!< \brief 8bit 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::tvec3<i8> i8vec3; //!< \brief 8bit 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 i8 i8vec1; //!< \brief 8bit 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::tvec3<i8> i8vec3; //!< \brief 8bit 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 i16 i16vec1; //!< \brief 16bit 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::tvec3<i16> i16vec3; //!< \brief 16bit 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 i16 i16vec1; //!< \brief 16bit 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::tvec3<i16> i16vec3; //!< \brief 16bit 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 i32 i32vec1; //!< \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::tvec3<i32> i32vec3; //!< \brief 32bit 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 i32 i32vec1; //!< \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::tvec3<i32> i32vec3; //!< \brief 32bit 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 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)
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 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)
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)
/////////////////////////////
// Unsigned int vector types
/////////////////////////////
// Unsigned int vector types
typedef detail::uint8 uint8; //!< \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 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 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 uint8 u8; //!< \brief 8bit unsigned integer. (from GLM_GTC_type_precision extension)
typedef uint16 u16; //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
typedef uint32 u32; //!< \brief 32bit 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 uint16 u16; //!< \brief 16bit unsigned integer. (from GLM_GTC_type_precision extension)
typedef uint32 u32; //!< \brief 32bit unsigned integer. (from GLM_GTC_type_precision extension)
typedef uint64 u64; //!< \brief 64bit unsigned integer. (from GLM_GTC_type_precision extension)
//typedef u8 u8vec1; //!< \brief 8bit 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::tvec3<u8> u8vec3; //!< \brief 8bit 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 u8 u8vec1; //!< \brief 8bit 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::tvec3<u8> u8vec3; //!< \brief 8bit 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 u16 u16vec1; //!< \brief 16bit 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::tvec3<u16> u16vec3; //!< \brief 16bit 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 u16 u16vec1; //!< \brief 16bit 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::tvec3<u16> u16vec3; //!< \brief 16bit 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 u32 u32vec1; //!< \brief 32bit 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::tvec3<u32> u32vec3; //!< \brief 32bit 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 u32 u32vec1; //!< \brief 32bit 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::tvec3<u32> u32vec3; //!< \brief 32bit 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 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)
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 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)
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)
//////////////////////
// Float vector types
//////////////////////
// Float vector types
typedef detail::float16 float16; //!< \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 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 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 float16 f16; //!< \brief Half-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 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 float32 f32; //!< \brief Single-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 detail::tvec2<float> fvec2; //!< Vector of 2 single-precision floating-point numbers. (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::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 detail::tvec3<float> fvec3; //!< Vector of 3 single-precision floating-point numbers. (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 f16 f16vec1; //!< \brief Half-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::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 detail::tvec2<f16> f16vec2; //!< \brief Half-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::tvec4<f16> f16vec4; //!< \brief Half-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 detail::tvec2<f32> f32vec2; //!< \brief Single-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::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 detail::tvec2<f32> f32vec2; //!< \brief Single-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::tvec4<f32> f32vec4; //!< \brief Single-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)
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 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)
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)
//////////////////////
// Float matrix types
//////////////////////
// Float matrix types
//typedef f32 fmat1; //!< \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::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 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 fmat1x1; //!< \brief Single-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::tmat2x3<f32> fmat2x3; //!< \brief Single-precision floating-point 2x3 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 detail::tmat2x2<f32> fmat2x2; //!< \brief Single-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::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 f16 f16mat1; //!< \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::tmat3x3<f16> f16mat3; //!< \brief Half-precision floating-point 3x3 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 f16 f16mat1; //!< \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::tmat3x3<f16> f16mat3; //!< \brief Half-precision floating-point 3x3 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 f16 f16mat1x1; //!< \brief Half-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::tmat2x3<f16> f16mat2x3; //!< \brief Half-precision floating-point 2x3 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 detail::tmat2x2<f16> f16mat2x2; //!< \brief Half-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::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 f32 f32mat1; //!< \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::tmat3x3<f32> f32mat3; //!< \brief Single-precision floating-point 3x3 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 f32 f32mat1; //!< \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::tmat3x3<f32> f32mat3; //!< \brief Single-precision floating-point 3x3 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 f32 f32mat1x1; //!< \brief Single-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::tmat2x3<f32> f32mat2x3; //!< \brief Single-precision floating-point 2x3 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 detail::tmat2x2<f32> f32mat2x2; //!< \brief Single-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::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 f64 f64mat1; //!< \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::tmat3x3<f64> f64mat3; //!< \brief Double-precision floating-point 3x3 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 f64 f64mat1; //!< \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::tmat3x3<f64> f64mat3; //!< \brief Double-precision floating-point 3x3 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 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)
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 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)
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)
//////////////////////////
// Float quaternion types
//////////////////////////
// Float quaternion types
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)
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
#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")
#endif
namespace glm
{
namespace test{
void main_gtc_type_ptr();
}//namespace test
namespace glm{
namespace gtc{
namespace type_ptr ///< GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
{
namespace gtc{
//! GLM_GTC_type_ptr extension: Get access to vectors & matrices value type address.
namespace type_ptr{
/// \addtogroup gtc_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.
//! 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 address of the vector content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tvec2<T> & vec
)
{
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::tvec2<T> & vec
)
{
return &(vec.x);
}
//! 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::tvec3<T> const & vec
)
{
return &(vec.x);
}
//! 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::tvec3<T> const & vec
)
{
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 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.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tvec4<T> const & vec
)
{
return &(vec.x);
}
//! 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::tvec4<T> const & vec
)
{
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::tvec4<T> & vec
)
{
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::tvec4<T> & vec
)
{
return &(vec.x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x2<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x2<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x2<T> & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x2<T> & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x3<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x3<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x3<T> & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x3<T> & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x4<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x4<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat4x4<T> & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat4x4<T> & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x3<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x3<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x3<T> & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x3<T> & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x2<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x2<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x2<T> & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x2<T> & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x4<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat2x4<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x4<T> & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat2x4<T> & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x2<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x2<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat4x2<T> & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat4x2<T> & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x4<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat3x4<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x4<T> & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr
(
detail::tmat3x4<T> & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x3<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the const address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T const * value_ptr
(
detail::tmat4x3<T> const & mat
)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat)
{
return &(mat[0].x);
}
//! Get the address of the matrix content.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER T * value_ptr(detail::tmat4x3<T> & mat)
{
return &(mat[0].x);
}
//! Build a vector from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr)
{
detail::tvec2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>));
return Result;
}
//! Build a vector from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> make_vec2(T const * const ptr)
{
detail::tvec2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec2<T>));
return Result;
}
//! Build a vector from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr)
{
detail::tvec3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>));
return Result;
}
//! Build a vector from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> make_vec3(T const * const ptr)
{
detail::tvec3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec3<T>));
return Result;
}
//! Build a vector from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr)
{
detail::tvec4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>));
return Result;
}
//! Build a vector from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> make_vec4(T const * const ptr)
{
detail::tvec4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tvec4<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr)
{
detail::tmat2x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2x2(T const * const ptr)
{
detail::tmat2x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x2<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr)
{
detail::tmat2x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x3<T> make_mat2x3(T const * const ptr)
{
detail::tmat2x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x3<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr)
{
detail::tmat2x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x4<T> make_mat2x4(T const * const ptr)
{
detail::tmat2x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat2x4<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr)
{
detail::tmat3x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x2<T> make_mat3x2(T const * const ptr)
{
detail::tmat3x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x2<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr)
{
detail::tmat3x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3x3(T const * const ptr)
{
detail::tmat3x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x3<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr)
{
detail::tmat3x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x4<T> make_mat3x4(T const * const ptr)
{
detail::tmat3x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat3x4<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr)
{
detail::tmat4x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x2<T> make_mat4x2(T const * const ptr)
{
detail::tmat4x2<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x2<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr)
{
detail::tmat4x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x3<T> make_mat4x3(T const * const ptr)
{
detail::tmat4x3<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x3<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr)
{
detail::tmat4x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4x4(T const * const ptr)
{
detail::tmat4x4<T> Result;
memcpy(value_ptr(Result), ptr, sizeof(detail::tmat4x4<T>));
return Result;
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr)
{
return make_mat2x2(ptr);
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat2x2<T> make_mat2(T const * const ptr)
{
return make_mat2x2(ptr);
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr)
{
return make_mat3x3(ptr);
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat3x3<T> make_mat3(T const * const ptr)
{
return make_mat3x3(ptr);
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr)
{
return make_mat4x4(ptr);
}
//! Build a matrix from a pointer.
//! From GLM_GTC_type_ptr extension.
template<typename T>
GLM_FUNC_QUALIFIER detail::tmat4x4<T> make_mat4(T const * const ptr)
{
return make_mat4x4(ptr);
}
///@}
///@}
}//namespace type_ptr
}//namespace gtc
}//namespace type_ptr
}//namespace gtc
}//namespace glm
#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")
#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{
void main_gtx_associated_min_max();
}//namespace test
/// \addtogroup gtx_associated_min_max
///@{
namespace gtx
{
//! GLM_GTX_associated_min_max extension: Min and max functions that return associated values not the compared onces.
namespace associated_min_max
{
/// \addtogroup gtx_associated_min_max
///@{
//! \brief Min comparison between 2 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b);
//! \brief Min comparison between 2 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b);
//! \brief Min comparison between 3 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c);
//! \brief Min comparison between 3 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c);
//! \brief Min comparison between 4 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d);
//! \brief Min comparison between 4 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMin(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d);
//! \brief Max comparison between 2 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b);
//! \brief Max comparison between 2 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b);
//! \brief Max comparison between 3 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c);
//! \brief Max comparison between 3 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c);
//! \brief Max comparison between 4 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d);
//! \brief Max comparison between 4 variables
template<typename genTypeT, typename genTypeU>
genTypeU associatedMax(
const genTypeT& x, const genTypeU& a,
const genTypeT& y, const genTypeU& b,
const genTypeT& z, const genTypeU& c,
const genTypeT& w, const genTypeU& d);
///@}
}//namespace associated_min_max
bool test();
}//namespace gtx
}//namespace glm
///@}
} //namespace associated_min_max
} //namespace gtx
} //namespace glm
#include "associated_min_max.inl"

159
glm/gtx/bit.hpp
View File

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

26
glm/gtx/closest_point.hpp
View File

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

122
glm/gtx/color_cast.hpp
View File

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

87
glm/gtx/color_space.hpp
View File

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

66
glm/gtx/color_space_YCoCg.hpp
View File

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

217
glm/gtx/compatibility.hpp
View File

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

63
glm/gtx/component_wise.hpp
View File

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

51
glm/gtx/epsilon.hpp
View File

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

180
glm/gtx/euler_angles.hpp
View File

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

37
glm/gtx/extend.hpp
View File

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

267
glm/gtx/extented_min_max.hpp
View File

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

89
glm/gtx/fast_exponential.hpp
View File

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

65
glm/gtx/fast_square_root.hpp
View File

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

93
glm/gtx/fast_trigonometry.hpp
View File

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

44
glm/gtx/gradient_paint.hpp
View File

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

49
glm/gtx/handed_coordinate_space.hpp
View File

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

117
glm/gtx/inertia.hpp
View File

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

26
glm/gtx/int_10_10_10_2.hpp
View File

@ -21,25 +21,23 @@
# pragma message("GLM: GLM_GTX_int_10_10_10_2 extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace int_10_10_10_2 ///< GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
{
namespace gtx{
//! GLM_GTX_int_10_10_10_2 extension: Add support for integer for core functions
namespace int_10_10_10_2
{
using namespace gtx::raw_data;
using namespace gtx::raw_data;
/// \addtogroup gtx_int_10_10_10_2
///@{
/// \addtogroup gtx_int_10_10_10_2
///@{
//! From GLM_GTX_int_10_10_10_2 extension.
//! Cast a vec4 to an u_10_10_10_2.
dword uint10_10_10_2_cast(glm::vec4 const & v);
//! From GLM_GTX_int_10_10_10_2 extension.
//! Cast a vec4 to an u_10_10_10_2.
dword uint10_10_10_2_cast(glm::vec4 const & v);
///@}
///@}
}//namespace integer
}//namespace gtx
}//namespace integer
}//namespace gtx
}//namespace glm
#include "int_10_10_10_2.inl"

45
glm/gtx/integer.hpp
View File

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

77
glm/gtx/intersect.hpp
View File

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

34
glm/gtx/log_base.hpp
View File

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

43
glm/gtx/matrix_cross_product.hpp
View File

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

65
glm/gtx/matrix_interpolation.hpp
View File

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

163
glm/gtx/matrix_major_storage.hpp
View File

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

113
glm/gtx/matrix_operation.hpp
View File

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

118
glm/gtx/matrix_query.hpp
View File

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

36
glm/gtx/mixed_product.hpp
View File

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

47
glm/gtx/multiple.hpp
View File

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

55
glm/gtx/noise.hpp
View File

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

191
glm/gtx/norm.hpp
View File

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

37
glm/gtx/normal.hpp
View File

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

49
glm/gtx/normalize_dot.hpp
View File

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

7
glm/gtx/number_precision.hpp
View File

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

8
glm/gtx/ocl_type.hpp
View File

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

71
glm/gtx/optimum_pow.hpp
View File

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

45
glm/gtx/orthonormalize.hpp
View File

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

60
glm/gtx/perpendicular.hpp
View File

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

35
glm/gtx/polar_coordinates.hpp
View File

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

59
glm/gtx/projection.hpp
View File

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

313
glm/gtx/quaternion.hpp
View File

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

5
glm/gtx/random.hpp
View File

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

44
glm/gtx/raw_data.hpp
View File

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

125
glm/gtx/reciprocal.hpp
View File

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

136
glm/gtx/rotate_vector.hpp
View File

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

242
glm/gtx/simd_mat4.hpp
View File

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

873
glm/gtx/simd_vec4.hpp
View File

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

75
glm/gtx/simplex.hpp
View File

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

75
glm/gtx/spline.hpp
View File

@ -21,51 +21,48 @@
# pragma message("GLM: GLM_GTX_spline extension included")
#endif
namespace glm
namespace glm{
namespace gtx{
namespace spline ///< GLM_GTX_spline extension: Spline functions
{
namespace gtx{
//! GLM_GTX_spline extension: Spline functions
namespace spline
{
using namespace gtx::optimum_pow;
using namespace gtx::optimum_pow;
/// \addtogroup gtx_spline
///@{
/// \addtogroup gtx_spline
/// @{
//! Return a point from a catmull rom curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType catmullRom(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s);
//! Return a point from a catmull rom curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType catmullRom(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s);
//! Return a point from a hermite curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType hermite(
genType const & v1,
genType const & t1,
genType const & v2,
genType const & t2,
typename genType::value_type const & s);
//! Return a point from a hermite curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType hermite(
genType const & v1,
genType const & t1,
genType const & v2,
genType const & t2,
typename genType::value_type const & s);
//! Return a point from a cubic curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType cubic(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s);
//! Return a point from a cubic curve.
//! From GLM_GTX_spline extension.
template <typename genType>
genType cubic(
genType const & v1,
genType const & v2,
genType const & v3,
genType const & v4,
typename genType::value_type const & s);
///@}
}//namespace spline
}//namespace gtx
/// @}
}//namespace spline
}//namespace gtx
}//namespace glm
#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")
#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{
void main_gtx_std_based_type();
}//namespace test
typedef detail::tvec2<std::size_t> size2;
typedef detail::tvec3<std::size_t> size3;
typedef detail::tvec4<std::size_t> size4;
namespace gtx{
//! GLM_GTX_std_based_type extension: Add support vector types based on C++ standard type
namespace std_based_type
{
typedef detail::tvec2<std::size_t> size2;
typedef detail::tvec3<std::size_t> size3;
typedef detail::tvec4<std::size_t> size4;
typedef detail::tvec2<signed char> scvec2;
typedef detail::tvec3<signed char> scvec3;
typedef detail::tvec4<signed char> scvec4;
typedef detail::tvec2<signed char> scvec2;
typedef detail::tvec3<signed char> scvec3;
typedef detail::tvec4<signed char> scvec4;
typedef detail::tvec2<unsigned char> ucvec2;
typedef detail::tvec3<unsigned char> ucvec3;
typedef detail::tvec4<unsigned char> ucvec4;
typedef detail::tvec2<unsigned char> ucvec2;
typedef detail::tvec3<unsigned char> ucvec3;
typedef detail::tvec4<unsigned char> ucvec4;
typedef detail::tvec2<signed short> ssvec2;
typedef detail::tvec3<signed short> ssvec3;
typedef detail::tvec4<signed short> ssvec4;
typedef detail::tvec2<signed short> ssvec2;
typedef detail::tvec3<signed short> ssvec3;
typedef detail::tvec4<signed short> ssvec4;
typedef detail::tvec2<unsigned short> usvec2;
typedef detail::tvec3<unsigned short> usvec3;
typedef detail::tvec4<unsigned short> usvec4;
typedef detail::tvec2<unsigned short> usvec2;
typedef detail::tvec3<unsigned short> usvec3;
typedef detail::tvec4<unsigned short> usvec4;
typedef detail::tvec2<signed int> sivec2;
typedef detail::tvec3<signed int> sivec3;
typedef detail::tvec4<signed int> sivec4;
typedef detail::tvec2<signed int> sivec2;
typedef detail::tvec3<signed int> sivec3;
typedef detail::tvec4<signed int> sivec4;
typedef detail::tvec2<unsigned int> uivec2;
typedef detail::tvec3<unsigned int> uivec3;
typedef detail::tvec4<unsigned int> uivec4;
typedef detail::tvec2<unsigned int> uivec2;
typedef detail::tvec3<unsigned int> uivec3;
typedef detail::tvec4<unsigned int> uivec4;
typedef detail::tvec2<signed long> slvec2;
typedef detail::tvec3<signed long> slvec3;
typedef detail::tvec4<signed long> slvec4;
typedef detail::tvec2<signed long> slvec2;
typedef detail::tvec3<signed long> slvec3;
typedef detail::tvec4<signed long> slvec4;
typedef detail::tvec2<unsigned long> ulvec2;
typedef detail::tvec3<unsigned long> ulvec3;
typedef detail::tvec4<unsigned long> ulvec4;
typedef detail::tvec2<unsigned long> ulvec2;
typedef detail::tvec3<unsigned long> ulvec3;
typedef detail::tvec4<unsigned long> ulvec4;
}//namespace std_based_type
}//namespace gtx
}//namespace std_based_type
}//namespace gtx
}//namespace glm
#include "std_based_type.inl"

39
glm/gtx/string_cast.hpp
View File

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

147
glm/gtx/transform.hpp
View File

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

155
glm/gtx/transform2.hpp
View File

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

69
glm/gtx/ulp.hpp
View File

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

49
glm/gtx/unsigned_int.hpp
View File

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

141
glm/gtx/vec1.hpp
View File

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

71
glm/gtx/vector_access.hpp
View File

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

17
glm/gtx/vector_angle.hpp
View File

@ -27,8 +27,7 @@
namespace glm{
namespace gtx{
//! GLM_GTX_vector_angle extension: Compute angle between vectors
namespace vector_angle
namespace vector_angle ///< GLM_GTX_vector_angle extension: Compute angle between vectors
{
using namespace quaternion;
using namespace epsilon;
@ -40,7 +39,7 @@ namespace vector_angle
//! Parameters need to be normalized.
//! From GLM_GTX_vector_angle extension
template <typename vecType>
typename vecType::value_type angle(
GLM_FUNC_QUALIFIER typename vecType::value_type angle(
vecType const & x,
vecType const & y);
@ -48,7 +47,7 @@ namespace vector_angle
//! Parameters need to be normalized.
//! From GLM_GTX_vector_angle extension.
template <typename T>
typename T orientedAngle(
GLM_FUNC_QUALIFIER T orientedAngle(
detail::tvec2<T> const & x,
detail::tvec2<T> const & y);
@ -56,15 +55,15 @@ namespace vector_angle
//! Parameters need to be normalized.
//! From GLM_GTX_vector_angle extension.
template <typename T>
typename vecType<T> orientedAngle(
GLM_FUNC_QUALIFIER T orientedAngle(
detail::tvec3<T> const & x,
detail::tvec3<T> const & y,
detail::tvec3<T> const & ref);
///@}
}//namespace vector_angle
}//namespace gtx
}//namespace glm
/// @}
}// namespace vector_angle
}// namespace gtx
}// namespace glm
#include "vector_angle.inl"

119
glm/gtx/vector_query.hpp
View File

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

64
glm/gtx/verbose_operator.hpp
View File

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

49
glm/gtx/wrap.hpp
View File

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

1
readme.txt
View File

@ -17,6 +17,7 @@ http://glm.g-truc.net/glm-0.9.2.pdf
GLM 0.9.2.1: 2010-05-20
--------------------------------------------------------------------------------
- Automatically detect CUDA support
- Improved Clang detection
- Fixed errors and warnings in VC with C++ extensions disabled
- Fixed and tested GLM_GTX_vector_angle
- Fixed and tested GLM_GTX_rotate_vector

22
test/gtx/gtx_vector_angle.cpp
View File

@ -12,16 +12,18 @@
#include <iostream>
#include <limits>
int test_vector_angle_calls()
int test_angle()
{
int Error = 0;
float AngleA = glm::angle(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0));
float AngleB = glm::orientedAngle(glm::vec2(1, 0), glm::normalize(glm::vec2(1, 1)));
float AngleC = glm::orientedAngle(glm::vec2(0, 1), glm::normalize(glm::vec2(1, 1)));
float AngleD = glm::orientedAngle(glm::vec3(1, 0, 0), glm::vec3(0, 1, 0), glm::vec3(0, 0, 1));
return Error;
int Error = 0;
float AngleA = glm::angle(glm::vec2(1, 0), glm::normalize(glm::vec2(1, 1)));
Error += glm::equalEpsilon(AngleA, 45.f, 0.01f) ? 0 : 1;
float AngleB = glm::angle(glm::vec3(1, 0, 0), glm::normalize(glm::vec3(1, 1, 0)));
Error += glm::equalEpsilon(AngleB, 45.f, 0.01f) ? 0 : 1;
float AngleC = glm::angle(glm::vec4(1, 0, 0, 0), glm::normalize(glm::vec4(1, 1, 0, 0)));
Error += glm::equalEpsilon(AngleC, 45.f, 0.01f) ? 0 : 1;
return Error;
}
int test_orientedAngle_vec2()
@ -55,9 +57,9 @@ int test_orientedAngle_vec3()
int main()
{
int Error = 0;
Error += test_angle();
Error += test_orientedAngle_vec2();
Error += test_orientedAngle_vec3();
Error += test_vector_angle_calls();
return Error;
}