mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-26 02:04: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. 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: 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 2. CUDA 3.0 and higher
3. GCC 3.4 and higher 3. GCC 3.4 and higher
4. LLVM 2.3 through GCC 4.2 front-end 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. 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> </paragraph>
<list name="GLM is written as a platform independent library with no dependence and officially supports the following compilers:"> <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://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><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> <list-element>Any C++ compiler following C++98 norm</list-element>

38
glm/core/setup.hpp
View File

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

661
glm/gtc/half_float.hpp
View File

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

3
glm/gtc/matrix_access.hpp
View File

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

310
glm/gtc/matrix_integer.hpp
View File

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

3
glm/gtc/matrix_inverse.hpp
View File

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

7
glm/gtc/matrix_transform.hpp
View File

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

322
glm/gtc/quaternion.hpp
View File

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

546
glm/gtc/swizzle.hpp
View File

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

306
glm/gtc/type_precision.hpp
View File

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

755
glm/gtc/type_ptr.hpp
View File

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

99
glm/gtx/associated_min_max.hpp
View File

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

159
glm/gtx/bit.hpp
View File

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

26
glm/gtx/closest_point.hpp
View File

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

122
glm/gtx/color_cast.hpp
View File

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

87
glm/gtx/color_space.hpp
View File

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

66
glm/gtx/color_space_YCoCg.hpp
View File

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

217
glm/gtx/compatibility.hpp
View File

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

63
glm/gtx/component_wise.hpp
View File

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

51
glm/gtx/epsilon.hpp
View File

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

180
glm/gtx/euler_angles.hpp
View File

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

37
glm/gtx/extend.hpp
View File

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

267
glm/gtx/extented_min_max.hpp
View File

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

89
glm/gtx/fast_exponential.hpp
View File

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

65
glm/gtx/fast_square_root.hpp
View File

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

93
glm/gtx/fast_trigonometry.hpp
View File

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

44
glm/gtx/gradient_paint.hpp
View File

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

49
glm/gtx/handed_coordinate_space.hpp
View File

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

117
glm/gtx/inertia.hpp
View File

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

26
glm/gtx/int_10_10_10_2.hpp
View File

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

45
glm/gtx/integer.hpp
View File

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

77
glm/gtx/intersect.hpp
View File

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

34
glm/gtx/log_base.hpp
View File

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

43
glm/gtx/matrix_cross_product.hpp
View File

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

65
glm/gtx/matrix_interpolation.hpp
View File

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

163
glm/gtx/matrix_major_storage.hpp
View File

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

113
glm/gtx/matrix_operation.hpp
View File

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

118
glm/gtx/matrix_query.hpp
View File

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

36
glm/gtx/mixed_product.hpp
View File

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

47
glm/gtx/multiple.hpp
View File

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

55
glm/gtx/noise.hpp
View File

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

191
glm/gtx/norm.hpp
View File

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

37
glm/gtx/normal.hpp
View File

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

49
glm/gtx/normalize_dot.hpp
View File

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

7
glm/gtx/number_precision.hpp
View File

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

8
glm/gtx/ocl_type.hpp
View File

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

71
glm/gtx/optimum_pow.hpp
View File

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

45
glm/gtx/orthonormalize.hpp
View File

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

60
glm/gtx/perpendicular.hpp
View File

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

35
glm/gtx/polar_coordinates.hpp
View File

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

59
glm/gtx/projection.hpp
View File

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

313
glm/gtx/quaternion.hpp
View File

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

5
glm/gtx/random.hpp
View File

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

44
glm/gtx/raw_data.hpp
View File

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

125
glm/gtx/reciprocal.hpp
View File

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

136
glm/gtx/rotate_vector.hpp
View File

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

242
glm/gtx/simd_mat4.hpp
View File

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

873
glm/gtx/simd_vec4.hpp
View File

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

75
glm/gtx/simplex.hpp
View File

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

75
glm/gtx/spline.hpp
View File

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

70
glm/gtx/std_based_type.hpp
View File

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

39
glm/gtx/string_cast.hpp
View File

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

147
glm/gtx/transform.hpp
View File

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

155
glm/gtx/transform2.hpp
View File

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

69
glm/gtx/ulp.hpp
View File

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

49
glm/gtx/unsigned_int.hpp
View File

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

141
glm/gtx/vec1.hpp
View File

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

71
glm/gtx/vector_access.hpp
View File

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

17
glm/gtx/vector_angle.hpp
View File

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

119
glm/gtx/vector_query.hpp
View File

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

64
glm/gtx/verbose_operator.hpp
View File

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

49
glm/gtx/wrap.hpp
View File

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

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 GLM 0.9.2.1: 2010-05-20
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
- Automatically detect CUDA support - Automatically detect CUDA support
- Improved Clang detection
- Fixed errors and warnings in VC with C++ extensions disabled - Fixed errors and warnings in VC with C++ extensions disabled
- Fixed and tested GLM_GTX_vector_angle - Fixed and tested GLM_GTX_vector_angle
- Fixed and tested GLM_GTX_rotate_vector - Fixed and tested GLM_GTX_rotate_vector

22
test/gtx/gtx_vector_angle.cpp
View File

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