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

Fixed CUDA support for functions member of classes

Browse Source
This commit is contained in:
Christophe Riccio 2011-05-07 15:37:51 +01:00
parent d44d87e266
commit 5d09d8342a
15 changed files with 482 additions and 479 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
glm/core/setup.hpp
View File

@ -400,9 +400,11 @@
// User defines: GLM_FORCE_INLINE GLM_FORCE_CUDA
#if(defined(GLM_FORCE_CUDA) || (defined(GLM_COMPILER) && (GLM_COMPILER >= GLM_COMPILER_CUDA30)))
# define GLM_CUDA_QUALIFIER __device__ __host__
# define GLM_CUDA_FUNC_DEF __device__ __host__
# define GLM_CUDA_FUNC_DECL __device__ __host__
#else
# define GLM_CUDA_QUALIFIER
# define GLM_CUDA_FUNC_DEF
# define GLM_CUDA_FUNC_DECL
#endif
#if(defined(GLM_FORCE_INLINE))
@ -417,7 +419,8 @@
# define GLM_INLINE inline
#endif//defined(GLM_FORCE_INLINE)
#define GLM_FUNC_QUALIFIER GLM_CUDA_QUALIFIER GLM_INLINE
#define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL
#define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE
///////////////////////////////////////////////////////////////////////////////////////////////////
// Swizzle operators

26
glm/core/type_half.hpp
View File

@ -33,30 +33,30 @@ namespace glm
{
public:
// Constructors
thalf();
thalf(thalf const & s);
GLM_FUNC_DECL thalf();
GLM_FUNC_DECL thalf(thalf const & s);
template <typename U>
explicit thalf(U const & s);
GLM_FUNC_DECL explicit thalf(U const & s);
// Cast
//operator float();
operator float() const;
GLM_FUNC_DECL operator float() const;
//operator double();
//operator double() const;
// Unary updatable operators
thalf& operator= (thalf const & s);
thalf& operator+=(thalf const & s);
thalf& operator-=(thalf const & s);
thalf& operator*=(thalf const & s);
thalf& operator/=(thalf const & s);
thalf& operator++();
thalf& operator--();
GLM_FUNC_DECL thalf& operator= (thalf const & s);
GLM_FUNC_DECL thalf& operator+=(thalf const & s);
GLM_FUNC_DECL thalf& operator-=(thalf const & s);
GLM_FUNC_DECL thalf& operator*=(thalf const & s);
GLM_FUNC_DECL thalf& operator/=(thalf const & s);
GLM_FUNC_DECL thalf& operator++();
GLM_FUNC_DECL thalf& operator--();
float toFloat() const{return toFloat32(data);}
GLM_FUNC_DECL float toFloat() const{return toFloat32(data);}
hdata _data() const{return data;}
GLM_FUNC_DECL hdata _data() const{return data;}
private:
hdata data;

64
glm/core/type_mat2x2.hpp
View File

@ -45,15 +45,15 @@ namespace glm
typedef std::size_t size_type;
typedef tvec2<T> col_type;
typedef tvec2<T> row_type;
static size_type col_size();
static size_type row_size();
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
typedef tmat2x2<T> type;
typedef tmat2x2<T> transpose_type;
public:
// Implementation detail
tmat2x2<T> _inverse() const;
GLM_FUNC_DECL tmat2x2<T> _inverse() const;
private:
// Data
@ -61,62 +61,62 @@ namespace glm
public:
// Constructors
tmat2x2();
tmat2x2(
GLM_FUNC_DECL tmat2x2();
GLM_FUNC_DECL tmat2x2(
tmat2x2 const & m);
explicit tmat2x2(
GLM_FUNC_DECL explicit tmat2x2(
ctor Null);
explicit tmat2x2(
GLM_FUNC_DECL explicit tmat2x2(
value_type const & x);
explicit tmat2x2(
GLM_FUNC_DECL explicit tmat2x2(
value_type const & x1, value_type const & y1,
value_type const & x2, value_type const & y2);
explicit tmat2x2(
GLM_FUNC_DECL explicit tmat2x2(
col_type const & v1,
col_type const & v2);
// Conversions
template <typename U>
explicit tmat2x2(tmat2x2<U> const & m);
GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U> const & m);
explicit tmat2x2(tmat3x3<T> const & x);
explicit tmat2x2(tmat4x4<T> const & x);
explicit tmat2x2(tmat2x3<T> const & x);
explicit tmat2x2(tmat3x2<T> const & x);
explicit tmat2x2(tmat2x4<T> const & x);
explicit tmat2x2(tmat4x2<T> const & x);
explicit tmat2x2(tmat3x4<T> const & x);
explicit tmat2x2(tmat4x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat4x3<T> const & x);
//////////////////////////////////////
// Accesses
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat2x2<T> & operator=(tmat2x2<T> const & m);
GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<T> const & m);
template <typename U>
tmat2x2<T> & operator=(tmat2x2<U> const & m);
GLM_FUNC_DECL tmat2x2<T> & operator=(tmat2x2<U> const & m);
template <typename U>
tmat2x2<T> & operator+=(U const & s);
GLM_FUNC_DECL tmat2x2<T> & operator+=(U const & s);
template <typename U>
tmat2x2<T> & operator+=(tmat2x2<U> const & m);
GLM_FUNC_DECL tmat2x2<T> & operator+=(tmat2x2<U> const & m);
template <typename U>
tmat2x2<T> & operator-=(U const & s);
GLM_FUNC_DECL tmat2x2<T> & operator-=(U const & s);
template <typename U>
tmat2x2<T> & operator-=(tmat2x2<U> const & m);
GLM_FUNC_DECL tmat2x2<T> & operator-=(tmat2x2<U> const & m);
template <typename U>
tmat2x2<T> & operator*=(U const & s);
GLM_FUNC_DECL tmat2x2<T> & operator*=(U const & s);
template <typename U>
tmat2x2<T> & operator*=(tmat2x2<U> const & m);
GLM_FUNC_DECL tmat2x2<T> & operator*=(tmat2x2<U> const & m);
template <typename U>
tmat2x2<T> & operator/=(U const & s);
GLM_FUNC_DECL tmat2x2<T> & operator/=(U const & s);
template <typename U>
tmat2x2<T> & operator/=(tmat2x2<U> const & m);
tmat2x2<T> & operator++();
tmat2x2<T> & operator--();
GLM_FUNC_DECL tmat2x2<T> & operator/=(tmat2x2<U> const & m);
GLM_FUNC_DECL tmat2x2<T> & operator++();
GLM_FUNC_DECL tmat2x2<T> & operator--();
};
// Binary operators

56
glm/core/type_mat2x3.hpp
View File

@ -45,8 +45,8 @@ namespace glm
typedef std::size_t size_type;
typedef tvec3<T> col_type;
typedef tvec2<T> row_type;
static size_type col_size();
static size_type row_size();
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
typedef tmat2x3<T> type;
typedef tmat3x2<T> transpose_type;
@ -57,58 +57,58 @@ namespace glm
public:
// Constructors
tmat2x3();
tmat2x3(tmat2x3 const & m);
GLM_FUNC_DECL tmat2x3();
GLM_FUNC_DECL tmat2x3(tmat2x3 const & m);
explicit tmat2x3(
GLM_FUNC_DECL explicit tmat2x3(
ctor);
explicit tmat2x3(
GLM_FUNC_DECL explicit tmat2x3(
value_type const & s);
explicit tmat2x3(
GLM_FUNC_DECL explicit tmat2x3(
value_type const & x0, value_type const & y0, value_type const & z0,
value_type const & x1, value_type const & y1, value_type const & z1);
explicit tmat2x3(
GLM_FUNC_DECL explicit tmat2x3(
col_type const & v0,
col_type const & v1);
// Conversion
template <typename U>
explicit tmat2x3(tmat2x3<U> const & m);
GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U> const & m);
explicit tmat2x3(tmat2x2<T> const & x);
explicit tmat2x3(tmat3x3<T> const & x);
explicit tmat2x3(tmat4x4<T> const & x);
explicit tmat2x3(tmat2x4<T> const & x);
explicit tmat2x3(tmat3x2<T> const & x);
explicit tmat2x3(tmat3x4<T> const & x);
explicit tmat2x3(tmat4x2<T> const & x);
explicit tmat2x3(tmat4x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat4x3<T> const & x);
// Accesses
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat2x3<T> & operator= (tmat2x3<T> const & m);
GLM_FUNC_DECL tmat2x3<T> & operator= (tmat2x3<T> const & m);
template <typename U>
tmat2x3<T> & operator= (tmat2x3<U> const & m);
GLM_FUNC_DECL tmat2x3<T> & operator= (tmat2x3<U> const & m);
template <typename U>
tmat2x3<T> & operator+= (U const & s);
GLM_FUNC_DECL tmat2x3<T> & operator+= (U const & s);
template <typename U>
tmat2x3<T> & operator+= (tmat2x3<U> const & m);
GLM_FUNC_DECL tmat2x3<T> & operator+= (tmat2x3<U> const & m);
template <typename U>
tmat2x3<T> & operator-= (U const & s);
GLM_FUNC_DECL tmat2x3<T> & operator-= (U const & s);
template <typename U>
tmat2x3<T> & operator-= (tmat2x3<U> const & m);
GLM_FUNC_DECL tmat2x3<T> & operator-= (tmat2x3<U> const & m);
template <typename U>
tmat2x3<T> & operator*= (U const & s);
GLM_FUNC_DECL tmat2x3<T> & operator*= (U const & s);
template <typename U>
tmat2x3<T> & operator*= (tmat2x3<U> const & m);
GLM_FUNC_DECL tmat2x3<T> & operator*= (tmat2x3<U> const & m);
template <typename U>
tmat2x3<T> & operator/= (U const & s);
GLM_FUNC_DECL tmat2x3<T> & operator/= (U const & s);
tmat2x3<T> & operator++ ();
tmat2x3<T> & operator-- ();
GLM_FUNC_DECL tmat2x3<T> & operator++ ();
GLM_FUNC_DECL tmat2x3<T> & operator-- ();
};
// Binary operators

60
glm/core/type_mat2x4.hpp
View File

@ -45,8 +45,8 @@ namespace glm
typedef std::size_t size_type;
typedef tvec4<T> col_type;
typedef tvec2<T> row_type;
static size_type col_size();
static size_type row_size();
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
typedef tmat2x4<T> type;
typedef tmat4x2<T> transpose_type;
@ -57,58 +57,58 @@ namespace glm
public:
// Constructors
tmat2x4();
tmat2x4(tmat2x4 const & m);
GLM_FUNC_DECL tmat2x4();
GLM_FUNC_DECL tmat2x4(tmat2x4 const & m);
explicit tmat2x4(
GLM_FUNC_DECL explicit tmat2x4(
ctor);
explicit tmat2x4(
GLM_FUNC_DECL explicit tmat2x4(
value_type const & s);
explicit tmat2x4(
GLM_FUNC_DECL explicit tmat2x4(
value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1);
explicit tmat2x4(
GLM_FUNC_DECL explicit tmat2x4(
col_type const & v0,
col_type const & v1);
// Conversion
template <typename U>
explicit tmat2x4(tmat2x4<U> const & m);
GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U> const & m);
explicit tmat2x4(tmat2x2<T> const & x);
explicit tmat2x4(tmat3x3<T> const & x);
explicit tmat2x4(tmat4x4<T> const & x);
explicit tmat2x4(tmat2x3<T> const & x);
explicit tmat2x4(tmat3x2<T> const & x);
explicit tmat2x4(tmat3x4<T> const & x);
explicit tmat2x4(tmat4x2<T> const & x);
explicit tmat2x4(tmat4x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat4x3<T> const & x);
// Accesses
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat2x4<T>& operator= (tmat2x4<T> const & m);
GLM_FUNC_DECL tmat2x4<T>& operator= (tmat2x4<T> const & m);
template <typename U>
tmat2x4<T>& operator= (tmat2x4<U> const & m);
GLM_FUNC_DECL tmat2x4<T>& operator= (tmat2x4<U> const & m);
template <typename U>
tmat2x4<T>& operator+= (U const & s);
GLM_FUNC_DECL tmat2x4<T>& operator+= (U const & s);
template <typename U>
tmat2x4<T>& operator+= (tmat2x4<U> const & m);
GLM_FUNC_DECL tmat2x4<T>& operator+= (tmat2x4<U> const & m);
template <typename U>
tmat2x4<T>& operator-= (U const & s);
GLM_FUNC_DECL tmat2x4<T>& operator-= (U const & s);
template <typename U>
tmat2x4<T>& operator-= (tmat2x4<U> const & m);
GLM_FUNC_DECL tmat2x4<T>& operator-= (tmat2x4<U> const & m);
template <typename U>
tmat2x4<T>& operator*= (U const & s);
GLM_FUNC_DECL tmat2x4<T>& operator*= (U const & s);
template <typename U>
tmat2x4<T>& operator*= (tmat2x4<U> const & m);
GLM_FUNC_DECL tmat2x4<T>& operator*= (tmat2x4<U> const & m);
template <typename U>
tmat2x4<T>& operator/= (U const & s);
GLM_FUNC_DECL tmat2x4<T>& operator/= (U const & s);
tmat2x4<T>& operator++ ();
tmat2x4<T>& operator-- ();
GLM_FUNC_DECL tmat2x4<T>& operator++ ();
GLM_FUNC_DECL tmat2x4<T>& operator-- ();
};
// Binary operators

60
glm/core/type_mat3x2.hpp
View File

@ -45,8 +45,8 @@ namespace glm
typedef std::size_t size_type;
typedef tvec2<T> col_type;
typedef tvec3<T> row_type;
static size_type col_size();
static size_type row_size();
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
typedef tmat3x2<T> type;
typedef tmat2x3<T> transpose_type;
@ -57,60 +57,60 @@ namespace glm
public:
// Constructors
tmat3x2();
tmat3x2(tmat3x2 const & m);
GLM_FUNC_DECL tmat3x2();
GLM_FUNC_DECL tmat3x2(tmat3x2 const & m);
explicit tmat3x2(
GLM_FUNC_DECL explicit tmat3x2(
ctor);
explicit tmat3x2(
GLM_FUNC_DECL explicit tmat3x2(
value_type const & s);
explicit tmat3x2(
GLM_FUNC_DECL explicit tmat3x2(
value_type const & x0, value_type const & y0,
value_type const & x1, value_type const & y1,
value_type const & x2, value_type const & y2);
explicit tmat3x2(
GLM_FUNC_DECL explicit tmat3x2(
col_type const & v0,
col_type const & v1,
col_type const & v2);
// Conversion
template <typename U>
explicit tmat3x2(tmat3x2<U> const & m);
GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U> const & m);
explicit tmat3x2(tmat2x2<T> const & x);
explicit tmat3x2(tmat3x3<T> const & x);
explicit tmat3x2(tmat4x4<T> const & x);
explicit tmat3x2(tmat2x3<T> const & x);
explicit tmat3x2(tmat2x4<T> const & x);
explicit tmat3x2(tmat3x4<T> const & x);
explicit tmat3x2(tmat4x2<T> const & x);
explicit tmat3x2(tmat4x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat4x3<T> const & x);
// Accesses
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat3x2<T> & operator= (tmat3x2<T> const & m);
GLM_FUNC_DECL tmat3x2<T> & operator= (tmat3x2<T> const & m);
template <typename U>
tmat3x2<T> & operator= (tmat3x2<U> const & m);
GLM_FUNC_DECL tmat3x2<T> & operator= (tmat3x2<U> const & m);
template <typename U>
tmat3x2<T> & operator+= (U const & s);
GLM_FUNC_DECL tmat3x2<T> & operator+= (U const & s);
template <typename U>
tmat3x2<T> & operator+= (tmat3x2<U> const & m);
GLM_FUNC_DECL tmat3x2<T> & operator+= (tmat3x2<U> const & m);
template <typename U>
tmat3x2<T> & operator-= (U const & s);
GLM_FUNC_DECL tmat3x2<T> & operator-= (U const & s);
template <typename U>
tmat3x2<T> & operator-= (tmat3x2<U> const & m);
GLM_FUNC_DECL tmat3x2<T> & operator-= (tmat3x2<U> const & m);
template <typename U>
tmat3x2<T> & operator*= (U const & s);
GLM_FUNC_DECL tmat3x2<T> & operator*= (U const & s);
template <typename U>
tmat3x2<T> & operator*= (tmat3x2<U> const & m);
GLM_FUNC_DECL tmat3x2<T> & operator*= (tmat3x2<U> const & m);
template <typename U>
tmat3x2<T> & operator/= (U const & s);
GLM_FUNC_DECL tmat3x2<T> & operator/= (U const & s);
tmat3x2<T> & operator++ ();
tmat3x2<T> & operator-- ();
GLM_FUNC_DECL tmat3x2<T> & operator++ ();
GLM_FUNC_DECL tmat3x2<T> & operator-- ();
};
// Binary operators

64
glm/core/type_mat3x3.hpp
View File

@ -45,15 +45,15 @@ namespace glm
typedef std::size_t size_type;
typedef tvec3<T> col_type;
typedef tvec3<T> row_type;
static size_type col_size();
static size_type row_size();
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
typedef tmat3x3<T> type;
typedef tmat3x3<T> transpose_type;
public:
// Implementation detail
tmat3x3<T> _inverse() const;
GLM_FUNC_DECL tmat3x3<T> _inverse() const;
private:
// Data
@ -61,61 +61,61 @@ namespace glm
public:
// Constructors
tmat3x3();
tmat3x3(tmat3x3 const & m);
GLM_FUNC_DECL tmat3x3();
GLM_FUNC_DECL tmat3x3(tmat3x3 const & m);
explicit tmat3x3(
GLM_FUNC_DECL explicit tmat3x3(
ctor Null);
explicit tmat3x3(
GLM_FUNC_DECL explicit tmat3x3(
value_type const & s);
explicit tmat3x3(
GLM_FUNC_DECL explicit tmat3x3(
value_type const & x0, value_type const & y0, value_type const & z0,
value_type const & x1, value_type const & y1, value_type const & z1,
value_type const & x2, value_type const & y2, value_type const & z2);
explicit tmat3x3(
GLM_FUNC_DECL explicit tmat3x3(
col_type const & v0,
col_type const & v1,
col_type const & v2);
// Conversions
template <typename U>
explicit tmat3x3(tmat3x3<U> const & m);
GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U> const & m);
explicit tmat3x3(tmat2x2<T> const & x);
explicit tmat3x3(tmat4x4<T> const & x);
explicit tmat3x3(tmat2x3<T> const & x);
explicit tmat3x3(tmat3x2<T> const & x);
explicit tmat3x3(tmat2x4<T> const & x);
explicit tmat3x3(tmat4x2<T> const & x);
explicit tmat3x3(tmat3x4<T> const & x);
explicit tmat3x3(tmat4x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat4x3<T> const & x);
// Accesses
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat3x3<T>& operator= (tmat3x3<T> const & m);
GLM_FUNC_DECL tmat3x3<T>& operator= (tmat3x3<T> const & m);
template <typename U>
tmat3x3<T>& operator= (tmat3x3<U> const & m);
GLM_FUNC_DECL tmat3x3<T>& operator= (tmat3x3<U> const & m);
template <typename U>
tmat3x3<T>& operator+= (U const & s);
GLM_FUNC_DECL tmat3x3<T>& operator+= (U const & s);
template <typename U>
tmat3x3<T>& operator+= (tmat3x3<U> const & m);
GLM_FUNC_DECL tmat3x3<T>& operator+= (tmat3x3<U> const & m);
template <typename U>
tmat3x3<T>& operator-= (U const & s);
GLM_FUNC_DECL tmat3x3<T>& operator-= (U const & s);
template <typename U>
tmat3x3<T>& operator-= (tmat3x3<U> const & m);
GLM_FUNC_DECL tmat3x3<T>& operator-= (tmat3x3<U> const & m);
template <typename U>
tmat3x3<T>& operator*= (U const & s);
GLM_FUNC_DECL tmat3x3<T>& operator*= (U const & s);
template <typename U>
tmat3x3<T>& operator*= (tmat3x3<U> const & m);
GLM_FUNC_DECL tmat3x3<T>& operator*= (tmat3x3<U> const & m);
template <typename U>
tmat3x3<T>& operator/= (U const & s);
GLM_FUNC_DECL tmat3x3<T>& operator/= (U const & s);
template <typename U>
tmat3x3<T>& operator/= (tmat3x3<U> const & m);
tmat3x3<T>& operator++ ();
tmat3x3<T>& operator-- ();
GLM_FUNC_DECL tmat3x3<T>& operator/= (tmat3x3<U> const & m);
GLM_FUNC_DECL tmat3x3<T>& operator++ ();
GLM_FUNC_DECL tmat3x3<T>& operator-- ();
};
// Binary operators

56
glm/core/type_mat3x4.hpp
View File

@ -45,8 +45,8 @@ namespace glm
typedef std::size_t size_type;
typedef tvec4<T> col_type;
typedef tvec3<T> row_type;
static size_type col_size();
static size_type row_size();
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
typedef tmat3x4<T> type;
typedef tmat4x3<T> transpose_type;
@ -57,60 +57,60 @@ namespace glm
public:
// Constructors
tmat3x4();
tmat3x4(tmat3x4 const & m);
GLM_FUNC_DECL tmat3x4();
GLM_FUNC_DECL tmat3x4(tmat3x4 const & m);
explicit tmat3x4(
GLM_FUNC_DECL explicit tmat3x4(
ctor Null);
explicit tmat3x4(
GLM_FUNC_DECL explicit tmat3x4(
value_type const & s);
explicit tmat3x4(
GLM_FUNC_DECL explicit tmat3x4(
value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2);
explicit tmat3x4(
GLM_FUNC_DECL explicit tmat3x4(
col_type const & v0,
col_type const & v1,
col_type const & v2);
// Conversion
template <typename U>
explicit tmat3x4(tmat3x4<U> const & m);
GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U> const & m);
explicit tmat3x4(tmat2x2<T> const & x);
explicit tmat3x4(tmat3x3<T> const & x);
explicit tmat3x4(tmat4x4<T> const & x);
explicit tmat3x4(tmat2x3<T> const & x);
explicit tmat3x4(tmat3x2<T> const & x);
explicit tmat3x4(tmat2x4<T> const & x);
explicit tmat3x4(tmat4x2<T> const & x);
explicit tmat3x4(tmat4x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat4x3<T> const & x);
// Accesses
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat3x4<T> & operator= (tmat3x4<T> const & m);
GLM_FUNC_DECL tmat3x4<T> & operator= (tmat3x4<T> const & m);
template <typename U>
tmat3x4<T> & operator= (tmat3x4<U> const & m);
GLM_FUNC_DECL tmat3x4<T> & operator= (tmat3x4<U> const & m);
template <typename U>
tmat3x4<T> & operator+= (U const & s);
GLM_FUNC_DECL tmat3x4<T> & operator+= (U const & s);
template <typename U>
tmat3x4<T> & operator+= (tmat3x4<U> const & m);
GLM_FUNC_DECL tmat3x4<T> & operator+= (tmat3x4<U> const & m);
template <typename U>
tmat3x4<T> & operator-= (U const & s);
GLM_FUNC_DECL tmat3x4<T> & operator-= (U const & s);
template <typename U>
tmat3x4<T> & operator-= (tmat3x4<U> const & m);
GLM_FUNC_DECL tmat3x4<T> & operator-= (tmat3x4<U> const & m);
template <typename U>
tmat3x4<T> & operator*= (U const & s);
GLM_FUNC_DECL tmat3x4<T> & operator*= (U const & s);
template <typename U>
tmat3x4<T> & operator*= (tmat3x4<U> const & m);
GLM_FUNC_DECL tmat3x4<T> & operator*= (tmat3x4<U> const & m);
template <typename U>
tmat3x4<T> & operator/= (U const & s);
GLM_FUNC_DECL tmat3x4<T> & operator/= (U const & s);
tmat3x4<T> & operator++ ();
tmat3x4<T> & operator-- ();
GLM_FUNC_DECL tmat3x4<T> & operator++ ();
GLM_FUNC_DECL tmat3x4<T> & operator-- ();
};
// Binary operators

60
glm/core/type_mat4x2.hpp
View File

@ -45,8 +45,8 @@ namespace glm
typedef std::size_t size_type;
typedef tvec2<T> col_type;
typedef tvec4<T> row_type;
static size_type col_size();
static size_type row_size();
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
typedef tmat4x2<T> type;
typedef tmat2x4<T> transpose_type;
@ -57,19 +57,19 @@ namespace glm
public:
// Constructors
tmat4x2();
tmat4x2(tmat4x2 const & m);
GLM_FUNC_DECL tmat4x2();
GLM_FUNC_DECL tmat4x2(tmat4x2 const & m);
explicit tmat4x2(
GLM_FUNC_DECL explicit tmat4x2(
ctor Null);
explicit tmat4x2(
GLM_FUNC_DECL explicit tmat4x2(
value_type const & x);
explicit tmat4x2(
GLM_FUNC_DECL explicit tmat4x2(
value_type const & x0, value_type const & y0,
value_type const & x1, value_type const & y1,
value_type const & x2, value_type const & y2,
value_type const & x3, value_type const & y3);
explicit tmat4x2(
GLM_FUNC_DECL explicit tmat4x2(
col_type const & v0,
col_type const & v1,
col_type const & v2,
@ -77,42 +77,42 @@ namespace glm
// Conversions
template <typename U>
explicit tmat4x2(tmat4x2<U> const & m);
GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U> const & m);
explicit tmat4x2(tmat2x2<T> const & x);
explicit tmat4x2(tmat3x3<T> const & x);
explicit tmat4x2(tmat4x4<T> const & x);
explicit tmat4x2(tmat2x3<T> const & x);
explicit tmat4x2(tmat3x2<T> const & x);
explicit tmat4x2(tmat2x4<T> const & x);
explicit tmat4x2(tmat4x3<T> const & x);
explicit tmat4x2(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat4x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat3x4<T> const & x);
// Accesses
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat4x2<T>& operator= (tmat4x2<T> const & m);
GLM_FUNC_DECL tmat4x2<T>& operator= (tmat4x2<T> const & m);
template <typename U>
tmat4x2<T>& operator= (tmat4x2<U> const & m);
GLM_FUNC_DECL tmat4x2<T>& operator= (tmat4x2<U> const & m);
template <typename U>
tmat4x2<T>& operator+= (U const & s);
GLM_FUNC_DECL tmat4x2<T>& operator+= (U const & s);
template <typename U>
tmat4x2<T>& operator+= (tmat4x2<U> const & m);
GLM_FUNC_DECL tmat4x2<T>& operator+= (tmat4x2<U> const & m);
template <typename U>
tmat4x2<T>& operator-= (U const & s);
GLM_FUNC_DECL tmat4x2<T>& operator-= (U const & s);
template <typename U>
tmat4x2<T>& operator-= (tmat4x2<U> const & m);
GLM_FUNC_DECL tmat4x2<T>& operator-= (tmat4x2<U> const & m);
template <typename U>
tmat4x2<T>& operator*= (U const & s);
GLM_FUNC_DECL tmat4x2<T>& operator*= (U const & s);
template <typename U>
tmat4x2<T>& operator*= (tmat4x2<U> const & m);
GLM_FUNC_DECL tmat4x2<T>& operator*= (tmat4x2<U> const & m);
template <typename U>
tmat4x2<T>& operator/= (U const & s);
GLM_FUNC_DECL tmat4x2<T>& operator/= (U const & s);
tmat4x2<T>& operator++ ();
tmat4x2<T>& operator-- ();
GLM_FUNC_DECL tmat4x2<T>& operator++ ();
GLM_FUNC_DECL tmat4x2<T>& operator-- ();
};
// Binary operators

56
glm/core/type_mat4x3.hpp
View File

@ -45,8 +45,8 @@ namespace glm
typedef std::size_t size_type;
typedef tvec3<T> col_type;
typedef tvec4<T> row_type;
static size_type col_size();
static size_type row_size();
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
typedef tmat4x3<T> type;
typedef tmat3x4<T> transpose_type;
@ -57,19 +57,19 @@ namespace glm
public:
// Constructors
tmat4x3();
tmat4x3(tmat4x3 const & m);
GLM_FUNC_DECL tmat4x3();
GLM_FUNC_DECL tmat4x3(tmat4x3 const & m);
explicit tmat4x3(
GLM_FUNC_DECL explicit tmat4x3(
ctor Null);
explicit tmat4x3(
GLM_FUNC_DECL explicit tmat4x3(
value_type const & x);
explicit tmat4x3(
GLM_FUNC_DECL explicit tmat4x3(
value_type const & x0, value_type const & y0, value_type const & z0,
value_type const & x1, value_type const & y1, value_type const & z1,
value_type const & x2, value_type const & y2, value_type const & z2,
value_type const & x3, value_type const & y3, value_type const & z3);
explicit tmat4x3(
GLM_FUNC_DECL explicit tmat4x3(
col_type const & v0,
col_type const & v1,
col_type const & v2,
@ -77,42 +77,42 @@ namespace glm
// Conversion
template <typename U>
explicit tmat4x3(tmat4x3<U> const & m);
GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U> const & m);
explicit tmat4x3(tmat2x2<T> const & x);
explicit tmat4x3(tmat3x3<T> const & x);
explicit tmat4x3(tmat4x4<T> const & x);
explicit tmat4x3(tmat2x3<T> const & x);
explicit tmat4x3(tmat3x2<T> const & x);
explicit tmat4x3(tmat2x4<T> const & x);
explicit tmat4x3(tmat4x2<T> const & x);
explicit tmat4x3(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat4x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat3x4<T> const & x);
// Accesses
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat4x3<T> & operator= (tmat4x3<T> const & m);
GLM_FUNC_DECL tmat4x3<T> & operator= (tmat4x3<T> const & m);
template <typename U>
tmat4x3<T> & operator= (tmat4x3<U> const & m);
GLM_FUNC_DECL tmat4x3<T> & operator= (tmat4x3<U> const & m);
template <typename U>
tmat4x3<T> & operator+= (U const & s);
GLM_FUNC_DECL tmat4x3<T> & operator+= (U const & s);
template <typename U>
tmat4x3<T> & operator+= (tmat4x3<U> const & m);
GLM_FUNC_DECL tmat4x3<T> & operator+= (tmat4x3<U> const & m);
template <typename U>
tmat4x3<T> & operator-= (U const & s);
GLM_FUNC_DECL tmat4x3<T> & operator-= (U const & s);
template <typename U>
tmat4x3<T> & operator-= (tmat4x3<U> const & m);
GLM_FUNC_DECL tmat4x3<T> & operator-= (tmat4x3<U> const & m);
template <typename U>
tmat4x3<T> & operator*= (U const & s);
GLM_FUNC_DECL tmat4x3<T> & operator*= (U const & s);
template <typename U>
tmat4x3<T> & operator*= (tmat4x3<U> const & m);
GLM_FUNC_DECL tmat4x3<T> & operator*= (tmat4x3<U> const & m);
template <typename U>
tmat4x3<T> & operator/= (U const & s);
GLM_FUNC_DECL tmat4x3<T> & operator/= (U const & s);
tmat4x3<T> & operator++ ();
tmat4x3<T> & operator-- ();
GLM_FUNC_DECL tmat4x3<T> & operator++ ();
GLM_FUNC_DECL tmat4x3<T> & operator-- ();
};
// Binary operators

64
glm/core/type_mat4x4.hpp
View File

@ -45,15 +45,15 @@ namespace glm
typedef std::size_t size_type;
typedef tvec4<T> col_type;
typedef tvec4<T> row_type;
static size_type col_size();
static size_type row_size();
static GLM_FUNC_DECL size_type col_size();
static GLM_FUNC_DECL size_type row_size();
typedef tmat4x4<T> type;
typedef tmat4x4<T> transpose_type;
public:
// Implementation detail
tmat4x4<T> _inverse() const;
GLM_FUNC_DECL tmat4x4<T> _inverse() const;
private:
// Data
@ -61,19 +61,19 @@ namespace glm
public:
// Constructors
tmat4x4();
tmat4x4(tmat4x4 const & m);
GLM_FUNC_DECL tmat4x4();
GLM_FUNC_DECL tmat4x4(tmat4x4 const & m);
explicit tmat4x4(
GLM_FUNC_DECL explicit tmat4x4(
ctor Null);
explicit tmat4x4(
GLM_FUNC_DECL explicit tmat4x4(
value_type const & x);
explicit tmat4x4(
GLM_FUNC_DECL explicit tmat4x4(
value_type const & x0, value_type const & y0, value_type const & z0, value_type const & w0,
value_type const & x1, value_type const & y1, value_type const & z1, value_type const & w1,
value_type const & x2, value_type const & y2, value_type const & z2, value_type const & w2,
value_type const & x3, value_type const & y3, value_type const & z3, value_type const & w3);
explicit tmat4x4(
GLM_FUNC_DECL explicit tmat4x4(
col_type const & v0,
col_type const & v1,
col_type const & v2,
@ -81,43 +81,43 @@ namespace glm
// Conversions
template <typename U>
explicit tmat4x4(tmat4x4<U> const & m);
GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U> const & m);
explicit tmat4x4(tmat2x2<T> const & x);
explicit tmat4x4(tmat3x3<T> const & x);
explicit tmat4x4(tmat2x3<T> const & x);
explicit tmat4x4(tmat3x2<T> const & x);
explicit tmat4x4(tmat2x4<T> const & x);
explicit tmat4x4(tmat4x2<T> const & x);
explicit tmat4x4(tmat3x4<T> const & x);
explicit tmat4x4(tmat4x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat2x3<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat3x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat2x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat4x2<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat3x4<T> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat4x3<T> const & x);
// Accesses
col_type & operator[](size_type i);
col_type const & operator[](size_type i) const;
GLM_FUNC_DECL col_type & operator[](size_type i);
GLM_FUNC_DECL col_type const & operator[](size_type i) const;
// Unary updatable operators
tmat4x4<T> & operator= (tmat4x4<T> const & m);
GLM_FUNC_DECL tmat4x4<T> & operator= (tmat4x4<T> const & m);
template <typename U>
tmat4x4<T> & operator= (tmat4x4<U> const & m);
GLM_FUNC_DECL tmat4x4<T> & operator= (tmat4x4<U> const & m);
template <typename U>
tmat4x4<T> & operator+= (U const & s);
GLM_FUNC_DECL tmat4x4<T> & operator+= (U const & s);
template <typename U>
tmat4x4<T> & operator+= (tmat4x4<U> const & m);
GLM_FUNC_DECL tmat4x4<T> & operator+= (tmat4x4<U> const & m);
template <typename U>
tmat4x4<T> & operator-= (U const & s);
GLM_FUNC_DECL tmat4x4<T> & operator-= (U const & s);
template <typename U>
tmat4x4<T> & operator-= (tmat4x4<U> const & m);
GLM_FUNC_DECL tmat4x4<T> & operator-= (tmat4x4<U> const & m);
template <typename U>
tmat4x4<T> & operator*= (U const & s);
GLM_FUNC_DECL tmat4x4<T> & operator*= (U const & s);
template <typename U>
tmat4x4<T> & operator*= (tmat4x4<U> const & m);
GLM_FUNC_DECL tmat4x4<T> & operator*= (tmat4x4<U> const & m);
template <typename U>
tmat4x4<T> & operator/= (U const & s);
GLM_FUNC_DECL tmat4x4<T> & operator/= (U const & s);
template <typename U>
tmat4x4<T> & operator/= (tmat4x4<U> const & m);
tmat4x4<T> & operator++ ();
tmat4x4<T> & operator-- ();
GLM_FUNC_DECL tmat4x4<T> & operator/= (tmat4x4<U> const & m);
GLM_FUNC_DECL tmat4x4<T> & operator++ ();
GLM_FUNC_DECL tmat4x4<T> & operator-- ();
};
// Binary operators

90
glm/core/type_vec1.hpp
View File

@ -41,7 +41,7 @@ namespace glm
typedef T value_type;
typedef std::size_t size_type;
static size_type value_size();
static GLM_FUNC_DECL size_type value_size();
typedef tvec1<T> type;
typedef tvec1<bool> bool_type;
@ -58,99 +58,99 @@ namespace glm
//////////////////////////////////////
// Accesses
value_type & operator[](size_type i);
value_type const & operator[](size_type i) const;
GLM_FUNC_DECL value_type & operator[](size_type i);
GLM_FUNC_DECL value_type const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
tvec1();
tvec1(tvec1<T> const & v);
GLM_FUNC_DECL tvec1();
GLM_FUNC_DECL tvec1(tvec1<T> const & v);
//////////////////////////////////////
// Explicit basic constructors
explicit tvec1(
GLM_FUNC_DECL explicit tvec1(
ctor);
explicit tvec1(
GLM_FUNC_DECL explicit tvec1(
value_type const & s);
//////////////////////////////////////
// Swizzle constructors
tvec1(tref1<T> const & r);
GLM_FUNC_DECL tvec1(tref1<T> 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 tvec1(U const & s);
GLM_FUNC_DECL explicit tvec1(U const & s);
//////////////////////////////////////
// Convertion vector constructors
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec1(tvec2<U> const & v);
GLM_FUNC_DECL explicit tvec1(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 tvec1(tvec3<U> const & v);
GLM_FUNC_DECL explicit tvec1(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 tvec1(tvec4<U> const & v);
GLM_FUNC_DECL explicit tvec1(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec1<T> & operator= (tvec1<T> const & v);
GLM_FUNC_DECL tvec1<T> & operator= (tvec1<T> const & v);
tvec1<T> & operator+=(value_type const & s);
tvec1<T> & operator+=(tvec1<T> const & v);
tvec1<T> & operator-=(value_type const & s);
tvec1<T> & operator-=(tvec1<T> const & v);
tvec1<T> & operator*=(value_type const & s);
tvec1<T> & operator*=(tvec1<T> const & v);
tvec1<T> & operator/=(value_type const & s);
tvec1<T> & operator/=(tvec1<T> const & v);
tvec1<T> & operator++();
tvec1<T> & operator--();
GLM_FUNC_DECL tvec1<T> & operator+=(value_type const & s);
GLM_FUNC_DECL tvec1<T> & operator+=(tvec1<T> const & v);
GLM_FUNC_DECL tvec1<T> & operator-=(value_type const & s);
GLM_FUNC_DECL tvec1<T> & operator-=(tvec1<T> const & v);
GLM_FUNC_DECL tvec1<T> & operator*=(value_type const & s);
GLM_FUNC_DECL tvec1<T> & operator*=(tvec1<T> const & v);
GLM_FUNC_DECL tvec1<T> & operator/=(value_type const & s);
GLM_FUNC_DECL tvec1<T> & operator/=(tvec1<T> const & v);
GLM_FUNC_DECL tvec1<T> & operator++();
GLM_FUNC_DECL tvec1<T> & operator--();
//////////////////////////////////////
// Unary bit operators
tvec1<T> & operator%=(value_type const & s);
tvec1<T> & operator%=(tvec1<T> const & v);
tvec1<T> & operator&=(value_type const & s);
tvec1<T> & operator&=(tvec1<T> const & v);
tvec1<T> & operator|=(value_type const & s);
tvec1<T> & operator|=(tvec1<T> const & v);
tvec1<T> & operator^=(value_type const & s);
tvec1<T> & operator^=(tvec1<T> const & v);
tvec1<T> & operator<<=(value_type const & s);
tvec1<T> & operator<<=(tvec1<T> const & v);
tvec1<T> & operator>>=(value_type const & s);
tvec1<T> & operator>>=(tvec1<T> const & v);
GLM_FUNC_DECL tvec1<T> & operator%=(value_type const & s);
GLM_FUNC_DECL tvec1<T> & operator%=(tvec1<T> const & v);
GLM_FUNC_DECL tvec1<T> & operator&=(value_type const & s);
GLM_FUNC_DECL tvec1<T> & operator&=(tvec1<T> const & v);
GLM_FUNC_DECL tvec1<T> & operator|=(value_type const & s);
GLM_FUNC_DECL tvec1<T> & operator|=(tvec1<T> const & v);
GLM_FUNC_DECL tvec1<T> & operator^=(value_type const & s);
GLM_FUNC_DECL tvec1<T> & operator^=(tvec1<T> const & v);
GLM_FUNC_DECL tvec1<T> & operator<<=(value_type const & s);
GLM_FUNC_DECL tvec1<T> & operator<<=(tvec1<T> const & v);
GLM_FUNC_DECL tvec1<T> & operator>>=(value_type const & s);
GLM_FUNC_DECL tvec1<T> & operator>>=(tvec1<T> const & v);
//////////////////////////////////////
// Swizzle operators
value_type swizzle(comp X) const;
tvec2<T> swizzle(comp X, comp Y) const;
tvec3<T> swizzle(comp X, comp Y, comp Z) const;
tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
tref1<T> swizzle(comp X);
GLM_FUNC_DECL value_type swizzle(comp X) const;
GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref1<T> swizzle(comp X);
};
template <typename T>
struct tref1
{
tref1(T & x);
tref1(tref1<T> const & r);
tref1(tvec1<T> const & v);
GLM_FUNC_DECL tref1(T & x);
GLM_FUNC_DECL tref1(tref1<T> const & r);
GLM_FUNC_DECL tref1(tvec1<T> const & v);
tref1<T> & operator= (tref1<T> const & r);
tref1<T> & operator= (tvec1<T> const & v);
GLM_FUNC_DECL tref1<T> & operator= (tref1<T> const & r);
GLM_FUNC_DECL tref1<T> & operator= (tvec1<T> const & v);
T& x;
};

94
glm/core/type_vec2.hpp
View File

@ -41,7 +41,7 @@ namespace glm
typedef T value_type;
typedef std::size_t size_type;
static size_type value_size();
static GLM_FUNC_DECL size_type value_size();
typedef tvec2<T> type;
typedef tvec2<bool> bool_type;
@ -66,23 +66,23 @@ namespace glm
//////////////////////////////////////
// Accesses
value_type & operator[](size_type i);
value_type const & operator[](size_type i) const;
GLM_FUNC_DECL value_type & operator[](size_type i);
GLM_FUNC_DECL value_type const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
tvec2();
tvec2(tvec2<T> const & v);
GLM_FUNC_DECL tvec2();
GLM_FUNC_DECL tvec2(tvec2<T> const & v);
//////////////////////////////////////
// Explicit basic constructors
explicit tvec2(
GLM_FUNC_DECL explicit tvec2(
ctor);
explicit tvec2(
GLM_FUNC_DECL explicit tvec2(
value_type const & s);
explicit tvec2(
GLM_FUNC_DECL explicit tvec2(
value_type const & s1,
value_type const & s2);
@ -96,11 +96,11 @@ namespace glm
//! Explicit converions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U>
explicit tvec2(
GLM_FUNC_DECL 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(
GLM_FUNC_DECL explicit tvec2(
U const & x,
V const & y);
@ -109,87 +109,87 @@ namespace glm
//! 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);
GLM_FUNC_DECL 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);
GLM_FUNC_DECL 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);
GLM_FUNC_DECL explicit tvec2(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec2<T> & operator= (tvec2<T> const & v);
GLM_FUNC_DECL tvec2<T> & operator= (tvec2<T> const & v);
template <typename U>
tvec2<T> & operator= (tvec2<U> const & v);
GLM_FUNC_DECL tvec2<T> & operator= (tvec2<U> const & v);
template <typename U>
tvec2<T> & operator+=(U const & s);
GLM_FUNC_DECL tvec2<T> & operator+=(U const & s);
template <typename U>
tvec2<T> & operator+=(tvec2<U> const & v);
GLM_FUNC_DECL tvec2<T> & operator+=(tvec2<U> const & v);
template <typename U>
tvec2<T> & operator-=(U const & s);
GLM_FUNC_DECL tvec2<T> & operator-=(U const & s);
template <typename U>
tvec2<T> & operator-=(tvec2<U> const & v);
GLM_FUNC_DECL tvec2<T> & operator-=(tvec2<U> const & v);
template <typename U>
tvec2<T> & operator*=(U const & s);
GLM_FUNC_DECL tvec2<T> & operator*=(U const & s);
template <typename U>
tvec2<T> & operator*=(tvec2<U> const & v);
GLM_FUNC_DECL tvec2<T> & operator*=(tvec2<U> const & v);
template <typename U>
tvec2<T> & operator/=(U const & s);
GLM_FUNC_DECL tvec2<T> & operator/=(U const & s);
template <typename U>
tvec2<T> & operator/=(tvec2<U> const & v);
tvec2<T> & operator++();
tvec2<T> & operator--();
GLM_FUNC_DECL tvec2<T> & operator/=(tvec2<U> const & v);
GLM_FUNC_DECL tvec2<T> & operator++();
GLM_FUNC_DECL tvec2<T> & operator--();
//////////////////////////////////////
// Unary bit operators
template <typename U>
tvec2<T> & operator%= (U const & s);
GLM_FUNC_DECL tvec2<T> & operator%= (U const & s);
template <typename U>
tvec2<T> & operator%= (tvec2<U> const & v);
GLM_FUNC_DECL tvec2<T> & operator%= (tvec2<U> const & v);
template <typename U>
tvec2<T> & operator&= (U const & s);
GLM_FUNC_DECL tvec2<T> & operator&= (U const & s);
template <typename U>
tvec2<T> & operator&= (tvec2<U> const & v);
GLM_FUNC_DECL tvec2<T> & operator&= (tvec2<U> const & v);
template <typename U>
tvec2<T> & operator|= (U const & s);
GLM_FUNC_DECL tvec2<T> & operator|= (U const & s);
template <typename U>
tvec2<T> & operator|= (tvec2<U> const & v);
GLM_FUNC_DECL tvec2<T> & operator|= (tvec2<U> const & v);
template <typename U>
tvec2<T> & operator^= (U const & s);
GLM_FUNC_DECL tvec2<T> & operator^= (U const & s);
template <typename U>
tvec2<T> & operator^= (tvec2<U> const & v);
GLM_FUNC_DECL tvec2<T> & operator^= (tvec2<U> const & v);
template <typename U>
tvec2<T> & operator<<=(U const & s);
GLM_FUNC_DECL tvec2<T> & operator<<=(U const & s);
template <typename U>
tvec2<T> & operator<<=(tvec2<U> const & v);
GLM_FUNC_DECL tvec2<T> & operator<<=(tvec2<U> const & v);
template <typename U>
tvec2<T> & operator>>=(U const & s);
GLM_FUNC_DECL tvec2<T> & operator>>=(U const & s);
template <typename U>
tvec2<T> & operator>>=(tvec2<U> const & v);
GLM_FUNC_DECL tvec2<T> & operator>>=(tvec2<U> const & v);
//////////////////////////////////////
// Swizzle operators
value_type swizzle(comp X) const;
tvec2<T> swizzle(comp X, comp Y) const;
tvec3<T> swizzle(comp X, comp Y, comp Z) const;
tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
tref2<T> swizzle(comp X, comp Y);
GLM_FUNC_DECL value_type swizzle(comp X) const;
GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref2<T> swizzle(comp X, comp Y);
};
template <typename T>
struct tref2
{
tref2(T & x, T & y);
tref2(tref2<T> const & r);
tref2(tvec2<T> const & v);
GLM_FUNC_DECL tref2(T & x, T & y);
GLM_FUNC_DECL tref2(tref2<T> const & r);
GLM_FUNC_DECL tref2(tvec2<T> const & v);
tref2<T> & operator= (tref2<T> const & r);
tref2<T> & operator= (tvec2<T> const & v);
GLM_FUNC_DECL tref2<T> & operator= (tref2<T> const & r);
GLM_FUNC_DECL tref2<T> & operator= (tvec2<T> const & v);
T& x;
T& y;

98
glm/core/type_vec3.hpp
View File

@ -40,7 +40,7 @@ namespace glm
typedef T value_type;
typedef std::size_t size_type;
static size_type value_size();
static GLM_FUNC_DECL size_type value_size();
typedef tvec3<T> type;
typedef tvec3<bool> bool_type;
@ -66,23 +66,23 @@ namespace glm
//////////////////////////////////////
// Accesses
value_type & operator[](size_type i);
value_type const & operator[](size_type i) const;
GLM_FUNC_DECL value_type & operator[](size_type i);
GLM_FUNC_DECL value_type const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
tvec3();
tvec3(tvec3<T> const & v);
GLM_FUNC_DECL tvec3();
GLM_FUNC_DECL tvec3(tvec3<T> const & v);
//////////////////////////////////////
// Explicit basic constructors
explicit tvec3(
GLM_FUNC_DECL explicit tvec3(
ctor);
explicit tvec3(
GLM_FUNC_DECL explicit tvec3(
value_type const & s);
explicit tvec3(
GLM_FUNC_DECL explicit tvec3(
value_type const & s1,
value_type const & s2,
value_type const & s3);
@ -90,18 +90,18 @@ namespace glm
//////////////////////////////////////
// Swizzle constructors
tvec3(tref3<T> const & r);
GLM_FUNC_DECL tvec3(tref3<T> 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(
GLM_FUNC_DECL 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(
GLM_FUNC_DECL explicit tvec3(
U const & x,
V const & y,
W const & z);
@ -111,90 +111,90 @@ namespace glm
//! 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);
GLM_FUNC_DECL 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);
GLM_FUNC_DECL 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);
GLM_FUNC_DECL 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);
GLM_FUNC_DECL explicit tvec3(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec3<T> & operator= (tvec3<T> const & v);
GLM_FUNC_DECL tvec3<T> & operator= (tvec3<T> const & v);
template <typename U>
tvec3<T> & operator= (tvec3<U> const & v);
GLM_FUNC_DECL tvec3<T> & operator= (tvec3<U> const & v);
template <typename U>
tvec3<T> & operator+=(U const & s);
GLM_FUNC_DECL tvec3<T> & operator+=(U const & s);
template <typename U>
tvec3<T> & operator+=(tvec3<U> const & v);
GLM_FUNC_DECL tvec3<T> & operator+=(tvec3<U> const & v);
template <typename U>
tvec3<T> & operator-=(U const & s);
GLM_FUNC_DECL tvec3<T> & operator-=(U const & s);
template <typename U>
tvec3<T> & operator-=(tvec3<U> const & v);
GLM_FUNC_DECL tvec3<T> & operator-=(tvec3<U> const & v);
template <typename U>
tvec3<T> & operator*=(U const & s);
GLM_FUNC_DECL tvec3<T> & operator*=(U const & s);
template <typename U>
tvec3<T> & operator*=(tvec3<U> const & v);
GLM_FUNC_DECL tvec3<T> & operator*=(tvec3<U> const & v);
template <typename U>
tvec3<T> & operator/=(U const & s);
GLM_FUNC_DECL tvec3<T> & operator/=(U const & s);
template <typename U>
tvec3<T> & operator/=(tvec3<U> const & v);
tvec3<T> & operator++();
tvec3<T> & operator--();
GLM_FUNC_DECL tvec3<T> & operator/=(tvec3<U> const & v);
GLM_FUNC_DECL tvec3<T> & operator++();
GLM_FUNC_DECL tvec3<T> & operator--();
//////////////////////////////////////
// Unary bit operators
template <typename U>
tvec3<T> & operator%= (U const & s);
GLM_FUNC_DECL tvec3<T> & operator%= (U const & s);
template <typename U>
tvec3<T> & operator%= (tvec3<U> const & v);
GLM_FUNC_DECL tvec3<T> & operator%= (tvec3<U> const & v);
template <typename U>
tvec3<T> & operator&= (U const & s);
GLM_FUNC_DECL tvec3<T> & operator&= (U const & s);
template <typename U>
tvec3<T> & operator&= (tvec3<U> const & v);
GLM_FUNC_DECL tvec3<T> & operator&= (tvec3<U> const & v);
template <typename U>
tvec3<T> & operator|= (U const & s);
GLM_FUNC_DECL tvec3<T> & operator|= (U const & s);
template <typename U>
tvec3<T> & operator|= (tvec3<U> const & v);
GLM_FUNC_DECL tvec3<T> & operator|= (tvec3<U> const & v);
template <typename U>
tvec3<T> & operator^= (U const & s);
GLM_FUNC_DECL tvec3<T> & operator^= (U const & s);
template <typename U>
tvec3<T> & operator^= (tvec3<U> const & v);
GLM_FUNC_DECL tvec3<T> & operator^= (tvec3<U> const & v);
template <typename U>
tvec3<T> & operator<<=(U const & s);
GLM_FUNC_DECL tvec3<T> & operator<<=(U const & s);
template <typename U>
tvec3<T> & operator<<=(tvec3<U> const & v);
GLM_FUNC_DECL tvec3<T> & operator<<=(tvec3<U> const & v);
template <typename U>
tvec3<T> & operator>>=(U const & s);
GLM_FUNC_DECL tvec3<T> & operator>>=(U const & s);
template <typename U>
tvec3<T> & operator>>=(tvec3<U> const & v);
GLM_FUNC_DECL tvec3<T> & operator>>=(tvec3<U> const & v);
//////////////////////////////////////
// Swizzle operators
value_type swizzle(comp X) const;
tvec2<T> swizzle(comp X, comp Y) const;
tvec3<T> swizzle(comp X, comp Y, comp Z) const;
tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
tref3<T> swizzle(comp X, comp Y, comp Z);
GLM_FUNC_DECL value_type swizzle(comp X) const;
GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref3<T> swizzle(comp X, comp Y, comp Z);
};
template <typename T>
struct tref3
{
tref3(T & x, T & y, T & z);
tref3(tref3<T> const & r);
tref3(tvec3<T> const & v);
GLM_FUNC_DECL tref3(T & x, T & y, T & z);
GLM_FUNC_DECL tref3(tref3<T> const & r);
GLM_FUNC_DECL tref3(tvec3<T> const & v);
tref3<T> & operator= (tref3<T> const & r);
tref3<T> & operator= (tvec3<T> const & v);
GLM_FUNC_DECL tref3<T> & operator= (tref3<T> const & r);
GLM_FUNC_DECL tref3<T> & operator= (tvec3<T> const & v);
T & x;
T & y;

104
glm/core/type_vec4.hpp
View File

@ -40,7 +40,7 @@ namespace glm
typedef T value_type;
typedef std::size_t size_type;
static size_type value_size();
static GLM_FUNC_DECL size_type value_size();
typedef tvec4<T> type;
typedef tvec4<bool> bool_type;
@ -67,23 +67,23 @@ namespace glm
//////////////////////////////////////
// Accesses
value_type & operator[](size_type i);
value_type const & operator[](size_type i) const;
GLM_FUNC_DECL value_type & operator[](size_type i);
GLM_FUNC_DECL value_type const & operator[](size_type i) const;
//////////////////////////////////////
// Implicit basic constructors
tvec4();
tvec4(type const & v);
GLM_FUNC_DECL tvec4();
GLM_FUNC_DECL tvec4(type const & v);
//////////////////////////////////////
// Explicit basic constructors
explicit tvec4(
GLM_FUNC_DECL explicit tvec4(
ctor);
explicit tvec4(
GLM_FUNC_DECL explicit tvec4(
value_type const & s);
explicit tvec4(
GLM_FUNC_DECL explicit tvec4(
value_type const & s0,
value_type const & s1,
value_type const & s2,
@ -92,18 +92,18 @@ namespace glm
//////////////////////////////////////
// Swizzle constructors
tvec4(tref4<T> const & r);
GLM_FUNC_DECL tvec4(tref4<T> 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(
GLM_FUNC_DECL 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(
GLM_FUNC_DECL explicit tvec4(
A const & x,
B const & y,
C const & z,
@ -114,99 +114,99 @@ namespace glm
//! 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);
GLM_FUNC_DECL 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);
GLM_FUNC_DECL 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);
GLM_FUNC_DECL 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);
GLM_FUNC_DECL 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);
GLM_FUNC_DECL 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);
GLM_FUNC_DECL 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);
GLM_FUNC_DECL explicit tvec4(tvec4<U> const & v);
//////////////////////////////////////
// Unary arithmetic operators
tvec4<T> & operator= (tvec4<T> const & v);
GLM_FUNC_DECL tvec4<T> & operator= (tvec4<T> const & v);
template <typename U>
tvec4<T> & operator= (tvec4<U> const & v);
GLM_FUNC_DECL tvec4<T> & operator= (tvec4<U> const & v);
template <typename U>
tvec4<T> & operator+=(U const & s);
GLM_FUNC_DECL tvec4<T> & operator+=(U const & s);
template <typename U>
tvec4<T> & operator+=(tvec4<U> const & v);
GLM_FUNC_DECL tvec4<T> & operator+=(tvec4<U> const & v);
template <typename U>
tvec4<T> & operator-=(U const & s);
GLM_FUNC_DECL tvec4<T> & operator-=(U const & s);
template <typename U>
tvec4<T> & operator-=(tvec4<U> const & v);
GLM_FUNC_DECL tvec4<T> & operator-=(tvec4<U> const & v);
template <typename U>
tvec4<T> & operator*=(U const & s);
GLM_FUNC_DECL tvec4<T> & operator*=(U const & s);
template <typename U>
tvec4<T> & operator*=(tvec4<U> const & v);
GLM_FUNC_DECL tvec4<T> & operator*=(tvec4<U> const & v);
template <typename U>
tvec4<T> & operator/=(U const & s);
GLM_FUNC_DECL tvec4<T> & operator/=(U const & s);
template <typename U>
tvec4<T> & operator/=(tvec4<U> const & v);
tvec4<T> & operator++();
tvec4<T> & operator--();
GLM_FUNC_DECL tvec4<T> & operator/=(tvec4<U> const & v);
GLM_FUNC_DECL tvec4<T> & operator++();
GLM_FUNC_DECL tvec4<T> & operator--();
//////////////////////////////////////
// Unary bit operators
template <typename U>
tvec4<T> & operator%= (U const & s);
GLM_FUNC_DECL tvec4<T> & operator%= (U const & s);
template <typename U>
tvec4<T> & operator%= (tvec4<U> const & v);
GLM_FUNC_DECL tvec4<T> & operator%= (tvec4<U> const & v);
template <typename U>
tvec4<T> & operator&= (U const & s);
GLM_FUNC_DECL tvec4<T> & operator&= (U const & s);
template <typename U>
tvec4<T> & operator&= (tvec4<U> const & v);
GLM_FUNC_DECL tvec4<T> & operator&= (tvec4<U> const & v);
template <typename U>
tvec4<T> & operator|= (U const & s);
GLM_FUNC_DECL tvec4<T> & operator|= (U const & s);
template <typename U>
tvec4<T> & operator|= (tvec4<U> const & v);
GLM_FUNC_DECL tvec4<T> & operator|= (tvec4<U> const & v);
template <typename U>
tvec4<T> & operator^= (U const & s);
GLM_FUNC_DECL tvec4<T> & operator^= (U const & s);
template <typename U>
tvec4<T> & operator^= (tvec4<U> const & v);
GLM_FUNC_DECL tvec4<T> & operator^= (tvec4<U> const & v);
template <typename U>
tvec4<T> & operator<<=(U const & s);
GLM_FUNC_DECL tvec4<T> & operator<<=(U const & s);
template <typename U>
tvec4<T> & operator<<=(tvec4<U> const & v);
GLM_FUNC_DECL tvec4<T> & operator<<=(tvec4<U> const & v);
template <typename U>
tvec4<T> & operator>>=(U const & s);
GLM_FUNC_DECL tvec4<T> & operator>>=(U const & s);
template <typename U>
tvec4<T> & operator>>=(tvec4<U> const & v);
GLM_FUNC_DECL tvec4<T> & operator>>=(tvec4<U> const & v);
//////////////////////////////////////
// Swizzle operators
value_type swizzle(comp X) const;
tvec2<T> swizzle(comp X, comp Y) const;
tvec3<T> swizzle(comp X, comp Y, comp Z) const;
tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
GLM_FUNC_DECL value_type swizzle(comp X) const;
GLM_FUNC_DECL tvec2<T> swizzle(comp X, comp Y) const;
GLM_FUNC_DECL tvec3<T> swizzle(comp X, comp Y, comp Z) const;
GLM_FUNC_DECL tvec4<T> swizzle(comp X, comp Y, comp Z, comp W) const;
GLM_FUNC_DECL tref4<T> swizzle(comp X, comp Y, comp Z, comp W);
};
template <typename T>
struct tref4
{
tref4(T & x, T & y, T & z, T & w);
tref4(tref4<T> const & r);
tref4(tvec4<T> const & v);
GLM_FUNC_DECL tref4(T & x, T & y, T & z, T & w);
GLM_FUNC_DECL tref4(tref4<T> const & r);
GLM_FUNC_DECL tref4(tvec4<T> const & v);
tref4<T> & operator= (tref4<T> const & r);
tref4<T> & operator= (tvec4<T> const & v);
GLM_FUNC_DECL tref4<T> & operator= (tref4<T> const & r);
GLM_FUNC_DECL tref4<T> & operator= (tvec4<T> const & v);
T & x;
T & y;