anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Fixed CUDA support for functions member of classes

Browse Source
master
Christophe Riccio ago%!(EXTRA string=15 years)
parent d44d87e266
commit 5d09d8342a
15 changed files with 482 additions and 479 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 9
      glm/core/setup.hpp
  2. 26
      glm/core/type_half.hpp
  3. 64
      glm/core/type_mat2x2.hpp
  4. 56
      glm/core/type_mat2x3.hpp
  5. 60
      glm/core/type_mat2x4.hpp
  6. 60
      glm/core/type_mat3x2.hpp
  7. 64
      glm/core/type_mat3x3.hpp
  8. 56
      glm/core/type_mat3x4.hpp
  9. 60
      glm/core/type_mat4x2.hpp
  10. 56
      glm/core/type_mat4x3.hpp
  11. 64
      glm/core/type_mat4x4.hpp
  12. 90
      glm/core/type_vec1.hpp
  13. 94
      glm/core/type_vec2.hpp
  14. 98
      glm/core/type_vec3.hpp
  15. 104
      glm/core/type_vec4.hpp

9
glm/core/setup.hpp
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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
Unescape 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;

Write Preview
Loading…
Cancel
Save