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

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 // User defines: GLM_FORCE_INLINE GLM_FORCE_CUDA
#if(defined(GLM_FORCE_CUDA) || (defined(GLM_COMPILER) && (GLM_COMPILER >= GLM_COMPILER_CUDA30))) #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 #else
# define GLM_CUDA_QUALIFIER # define GLM_CUDA_FUNC_DEF
# define GLM_CUDA_FUNC_DECL
#endif #endif
#if(defined(GLM_FORCE_INLINE)) #if(defined(GLM_FORCE_INLINE))
@ -417,7 +419,8 @@
# define GLM_INLINE inline # define GLM_INLINE inline
#endif//defined(GLM_FORCE_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 // Swizzle operators

26
glm/core/type_half.hpp
View File

@ -33,30 +33,30 @@ namespace glm
{ {
public: public:
// Constructors // Constructors
thalf(); GLM_FUNC_DECL thalf();
thalf(thalf const & s); GLM_FUNC_DECL thalf(thalf const & s);
template <typename U> template <typename U>
explicit thalf(U const & s); GLM_FUNC_DECL explicit thalf(U const & s);
// Cast // Cast
//operator float(); //operator float();
operator float() const; GLM_FUNC_DECL operator float() const;
//operator double(); //operator double();
//operator double() const; //operator double() const;
// Unary updatable operators // Unary updatable operators
thalf& operator= (thalf const & s); GLM_FUNC_DECL thalf& operator= (thalf const & s);
thalf& operator+=(thalf const & s); GLM_FUNC_DECL thalf& operator+=(thalf const & s);
thalf& operator-=(thalf const & s); GLM_FUNC_DECL thalf& operator-=(thalf const & s);
thalf& operator*=(thalf const & s); GLM_FUNC_DECL thalf& operator*=(thalf const & s);
thalf& operator/=(thalf const & s); GLM_FUNC_DECL thalf& operator/=(thalf const & s);
thalf& operator++(); GLM_FUNC_DECL thalf& operator++();
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: private:
hdata data; hdata data;

64
glm/core/type_mat2x2.hpp
View File

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

56
glm/core/type_mat2x3.hpp
View File

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

60
glm/core/type_mat2x4.hpp
View File

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

60
glm/core/type_mat3x2.hpp
View File

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

64
glm/core/type_mat3x3.hpp
View File

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

56
glm/core/type_mat3x4.hpp
View File

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

60
glm/core/type_mat4x2.hpp
View File

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

56
glm/core/type_mat4x3.hpp
View File

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

64
glm/core/type_mat4x4.hpp
View File

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

90
glm/core/type_vec1.hpp
View File

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

94
glm/core/type_vec2.hpp
View File

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

98
glm/core/type_vec3.hpp
View File

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

104
glm/core/type_vec4.hpp
View File

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