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

Added missing template parameters, removed GLM_DEFAULT_CTOR

Browse Source
This commit is contained in:
Christophe Riccio 2018-07-23 12:02:55 +02:00
parent 7e3f42eeda
commit ba4a4c6014
17 changed files with 136 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
glm/detail/setup.hpp
View File

@ -575,21 +575,16 @@
# define GLM_VECTOR_CALL
#endif//GLM_COMPILER
#if GLM_HAS_DEFAULTED_FUNCTIONS
///////////////////////////////////////////////////////////////////////////////////
#ifdef GLM_FORCE_NO_CTOR_INIT
# undef GLM_FORCE_CTOR_INIT
#endif
#if GLM_HAS_DEFAULTED_FUNCTIONS && !defined(GLM_FORCE_CTOR_INIT)
# define GLM_DEFAULT = default
# ifdef GLM_FORCE_NO_CTOR_INIT
# undef GLM_FORCE_CTOR_INIT
# endif
# ifdef GLM_FORCE_CTOR_INIT
# define GLM_DEFAULT_CTOR
# else
# define GLM_DEFAULT_CTOR = default
# endif
#else
# define GLM_DEFAULT
# define GLM_DEFAULT_CTOR
#endif
///////////////////////////////////////////////////////////////////////////////////

2
glm/detail/type_mat2x2.hpp
View File

@ -34,7 +34,7 @@ namespace glm
// -- Constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat(mat<2, 2, T, P> const& m);

2
glm/detail/type_mat2x3.hpp
View File

@ -35,7 +35,7 @@ namespace glm
// -- Constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat(mat<2, 3, T, P> const& m);

2
glm/detail/type_mat2x4.hpp
View File

@ -35,7 +35,7 @@ namespace glm
// -- Constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat(mat<2, 4, T, P> const& m);

2
glm/detail/type_mat3x2.hpp
View File

@ -35,7 +35,7 @@ namespace glm
// -- Constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat(mat<3, 2, T, P> const& m);

2
glm/detail/type_mat3x3.hpp
View File

@ -34,7 +34,7 @@ namespace glm
// -- Constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat(mat<3, 3, T, P> const& m);

2
glm/detail/type_mat3x4.hpp
View File

@ -35,7 +35,7 @@ namespace glm
// -- Constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat(mat<3, 4, T, P> const& m);

2
glm/detail/type_mat4x2.hpp
View File

@ -35,7 +35,7 @@ namespace glm
// -- Constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat(mat<4, 2, T, P> const& m);

2
glm/detail/type_mat4x3.hpp
View File

@ -35,7 +35,7 @@ namespace glm
// -- Constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat(mat<4, 3, T, P> const& m);

2
glm/detail/type_mat4x4.hpp
View File

@ -34,7 +34,7 @@ namespace glm
// -- Constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat() GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 mat(mat<4, 4, T, P> const& m);

74
glm/detail/type_vec2.hpp
View File

@ -65,7 +65,7 @@ namespace glm
// -- Implicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec() GLM_DEFAULT;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec(vec const& v) GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec(vec<2, T, P> const& v);
@ -114,80 +114,80 @@ namespace glm
// -- Unary arithmetic operators --
GLM_FUNC_DECL vec& operator=(vec const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator=(vec const& v);
template<typename U>
GLM_FUNC_DECL vec& operator=(vec<2, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator=(vec<2, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec& operator+=(U scalar);
GLM_FUNC_DECL vec<2, T, Q> & operator+=(U scalar);
template<typename U>
GLM_FUNC_DECL vec& operator+=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator+=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec& operator+=(vec<2, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator+=(vec<2, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec& operator-=(U scalar);
GLM_FUNC_DECL vec<2, T, Q> & operator-=(U scalar);
template<typename U>
GLM_FUNC_DECL vec& operator-=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator-=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec& operator-=(vec<2, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator-=(vec<2, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec& operator*=(U scalar);
GLM_FUNC_DECL vec<2, T, Q> & operator*=(U scalar);
template<typename U>
GLM_FUNC_DECL vec& operator*=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator*=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec& operator*=(vec<2, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator*=(vec<2, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec& operator/=(U scalar);
GLM_FUNC_DECL vec<2, T, Q> & operator/=(U scalar);
template<typename U>
GLM_FUNC_DECL vec& operator/=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator/=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec& operator/=(vec<2, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator/=(vec<2, U, Q> const& v);
// -- Increment and decrement operators --
GLM_FUNC_DECL vec & operator++();
GLM_FUNC_DECL vec & operator--();
GLM_FUNC_DECL vec operator++(int);
GLM_FUNC_DECL vec operator--(int);
GLM_FUNC_DECL vec<2, T, Q> & operator++();
GLM_FUNC_DECL vec<2, T, Q> & operator--();
GLM_FUNC_DECL vec<2, T, Q> operator++(int);
GLM_FUNC_DECL vec<2, T, Q> operator--(int);
// -- Unary bit operators --
template<typename U>
GLM_FUNC_DECL vec & operator%=(U scalar);
GLM_FUNC_DECL vec<2, T, Q> & operator%=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator%=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator%=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator%=(vec<2, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator%=(vec<2, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator&=(U scalar);
GLM_FUNC_DECL vec<2, T, Q> & operator&=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator&=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator&=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator&=(vec<2, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator&=(vec<2, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator|=(U scalar);
GLM_FUNC_DECL vec<2, T, Q> & operator|=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator|=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator|=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator|=(vec<2, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator|=(vec<2, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator^=(U scalar);
GLM_FUNC_DECL vec<2, T, Q> & operator^=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator^=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator^=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator^=(vec<2, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator^=(vec<2, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator<<=(U scalar);
GLM_FUNC_DECL vec<2, T, Q> & operator<<=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator<<=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator<<=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator<<=(vec<2, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator<<=(vec<2, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator>>=(U scalar);
GLM_FUNC_DECL vec<2, T, Q> & operator>>=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator>>=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator>>=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator>>=(vec<2, U, Q> const& v);
GLM_FUNC_DECL vec<2, T, Q> & operator>>=(vec<2, U, Q> const& v);
};
// -- Unary operators --

74
glm/detail/type_vec3.hpp
View File

@ -66,7 +66,7 @@ namespace glm
// -- Implicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec() GLM_DEFAULT;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec(vec const& v) GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec(vec<3, T, P> const& v);
@ -144,80 +144,80 @@ namespace glm
// -- Unary arithmetic operators --
GLM_FUNC_DECL vec & operator=(vec const& v);
GLM_FUNC_DECL vec<3, T, Q>& operator=(vec<3, T, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator=(vec<3, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator=(vec<3, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator+=(U scalar);
GLM_FUNC_DECL vec<3, T, Q> & operator+=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator+=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator+=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator+=(vec<3, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator+=(vec<3, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator-=(U scalar);
GLM_FUNC_DECL vec<3, T, Q> & operator-=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator-=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator-=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator-=(vec<3, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator-=(vec<3, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator*=(U scalar);
GLM_FUNC_DECL vec<3, T, Q> & operator*=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator*=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator*=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator*=(vec<3, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator*=(vec<3, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator/=(U scalar);
GLM_FUNC_DECL vec<3, T, Q> & operator/=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator/=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator/=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator/=(vec<3, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator/=(vec<3, U, Q> const& v);
// -- Increment and decrement operators --
GLM_FUNC_DECL vec & operator++();
GLM_FUNC_DECL vec & operator--();
GLM_FUNC_DECL vec operator++(int);
GLM_FUNC_DECL vec operator--(int);
GLM_FUNC_DECL vec<3, T, Q> & operator++();
GLM_FUNC_DECL vec<3, T, Q> & operator--();
GLM_FUNC_DECL vec<3, T, Q> operator++(int);
GLM_FUNC_DECL vec<3, T, Q> operator--(int);
// -- Unary bit operators --
template<typename U>
GLM_FUNC_DECL vec & operator%=(U scalar);
GLM_FUNC_DECL vec<3, T, Q> & operator%=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator%=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator%=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator%=(vec<3, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator%=(vec<3, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator&=(U scalar);
GLM_FUNC_DECL vec<3, T, Q> & operator&=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator&=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator&=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator&=(vec<3, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator&=(vec<3, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator|=(U scalar);
GLM_FUNC_DECL vec<3, T, Q> & operator|=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator|=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator|=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator|=(vec<3, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator|=(vec<3, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator^=(U scalar);
GLM_FUNC_DECL vec<3, T, Q> & operator^=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator^=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator^=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator^=(vec<3, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator^=(vec<3, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator<<=(U scalar);
GLM_FUNC_DECL vec<3, T, Q> & operator<<=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator<<=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator<<=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator<<=(vec<3, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator<<=(vec<3, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator>>=(U scalar);
GLM_FUNC_DECL vec<3, T, Q> & operator>>=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator>>=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator>>=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator>>=(vec<3, U, Q> const& v);
GLM_FUNC_DECL vec<3, T, Q> & operator>>=(vec<3, U, Q> const& v);
};
// -- Unary operators --

2
glm/detail/type_vec4.hpp
View File

@ -67,7 +67,7 @@ namespace glm
// -- Implicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec() GLM_DEFAULT;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec(vec<4, T, Q> const& v) GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec(vec<4, T, P> const& v);

54
glm/ext/vec1.hpp
View File

@ -83,7 +83,7 @@ namespace glm
// -- Implicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec() GLM_DEFAULT;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec(vec const& v) GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec(vec<1, T, P> const& v);
@ -120,60 +120,60 @@ namespace glm
*/
// -- Unary arithmetic operators --
GLM_FUNC_DECL vec & operator=(vec const& v);
GLM_FUNC_DECL vec<1, T, Q> & operator=(vec const& v);
template<typename U>
GLM_FUNC_DECL vec & operator=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<1, T, Q> & operator=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator+=(U scalar);
GLM_FUNC_DECL vec<1, T, Q> & operator+=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator+=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<1, T, Q> & operator+=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator-=(U scalar);
GLM_FUNC_DECL vec<1, T, Q> & operator-=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator-=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<1, T, Q> & operator-=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator*=(U scalar);
GLM_FUNC_DECL vec<1, T, Q> & operator*=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator*=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<1, T, Q> & operator*=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator/=(U scalar);
GLM_FUNC_DECL vec<1, T, Q> & operator/=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator/=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<1, T, Q> & operator/=(vec<1, U, Q> const& v);
// -- Increment and decrement operators --
GLM_FUNC_DECL vec & operator++();
GLM_FUNC_DECL vec & operator--();
GLM_FUNC_DECL vec operator++(int);
GLM_FUNC_DECL vec operator--(int);
GLM_FUNC_DECL vec<1, T, Q> & operator++();
GLM_FUNC_DECL vec<1, T, Q> & operator--();
GLM_FUNC_DECL vec<1, T, Q> operator++(int);
GLM_FUNC_DECL vec<1, T, Q> operator--(int);
// -- Unary bit operators --
template<typename U>
GLM_FUNC_DECL vec & operator%=(U scalar);
GLM_FUNC_DECL vec<1, T, Q> & operator%=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator%=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<1, T, Q> & operator%=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator&=(U scalar);
GLM_FUNC_DECL vec<1, T, Q> & operator&=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator&=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<1, T, Q> & operator&=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator|=(U scalar);
GLM_FUNC_DECL vec<1, T, Q> & operator|=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator|=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<1, T, Q> & operator|=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator^=(U scalar);
GLM_FUNC_DECL vec<1, T, Q> & operator^=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator^=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<1, T, Q> & operator^=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator<<=(U scalar);
GLM_FUNC_DECL vec<1, T, Q> & operator<<=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator<<=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<1, T, Q> & operator<<=(vec<1, U, Q> const& v);
template<typename U>
GLM_FUNC_DECL vec & operator>>=(U scalar);
GLM_FUNC_DECL vec<1, T, Q> & operator>>=(U scalar);
template<typename U>
GLM_FUNC_DECL vec & operator>>=(vec<1, U, Q> const& v);
GLM_FUNC_DECL vec<1, T, Q> & operator>>=(vec<1, U, Q> const& v);
};
// -- Unary operators --

2
glm/gtc/quaternion.hpp
View File

@ -59,7 +59,7 @@ namespace glm
// -- Implicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 tquat() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 tquat() GLM_DEFAULT;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 tquat(tquat<T, Q> const& q) GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 tquat(tquat<T, P> const& q);

18
glm/gtx/dual_quaternion.hpp
View File

@ -56,24 +56,24 @@ namespace glm
// -- Implicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 tdualquat() GLM_DEFAULT_CTOR;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 tdualquat(tdualquat<T, Q> const& d) GLM_DEFAULT;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 tdualquat() GLM_DEFAULT;
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 tdualquat(tdualquat<T, Q> const& d) GLM_DEFAULT;
template<qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 tdualquat(tdualquat<T, P> const& d);
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 tdualquat(tdualquat<T, P> const& d);
// -- Explicit basic constructors --
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 tdualquat(tquat<T, Q> const& real);
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 tdualquat(tquat<T, Q> const& orientation, vec<3, T, Q> const& translation);
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 tdualquat(tquat<T, Q> const& real, tquat<T, Q> const& dual);
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 tdualquat(tquat<T, Q> const& real);
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 tdualquat(tquat<T, Q> const& orientation, vec<3, T, Q> const& translation);
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 tdualquat(tquat<T, Q> const& real, tquat<T, Q> const& dual);
// -- Conversion constructors --
template<typename U, qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 GLM_EXPLICIT tdualquat(tdualquat<U, P> const& q);
GLM_FUNC_DECL GLM_CONSTEXPR_CXX14 GLM_EXPLICIT tdualquat(tdualquat<U, P> const& q);
GLM_FUNC_DECL GLM_EXPLICIT tdualquat(mat<2, 4, T, Q> const& holder_mat);
GLM_FUNC_DECL GLM_EXPLICIT tdualquat(mat<3, 4, T, Q> const& aug_mat);
GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR_CXX14 tdualquat(mat<2, 4, T, Q> const& holder_mat);
GLM_FUNC_DECL GLM_EXPLICIT GLM_CONSTEXPR_CXX14 tdualquat(mat<3, 4, T, Q> const& aug_mat);
// -- Unary arithmetic operators --

16
glm/gtx/dual_quaternion.inl
View File

@ -36,7 +36,7 @@ namespace glm
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 tdualquat<T, Q>::tdualquat(tdualquat<T, Q> const& d)
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX14 tdualquat<T, Q>::tdualquat(tdualquat<T, Q> const& d)
: real(d.real)
, dual(d.dual)
{}
@ -44,7 +44,7 @@ namespace glm
template<typename T, qualifier Q>
template<qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 tdualquat<T, Q>::tdualquat(tdualquat<T, P> const& d)
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX14 tdualquat<T, Q>::tdualquat(tdualquat<T, P> const& d)
: real(d.real)
, dual(d.dual)
{}
@ -52,12 +52,12 @@ namespace glm
// -- Explicit basic constructors --
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 tdualquat<T, Q>::tdualquat(tquat<T, Q> const& r)
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX14 tdualquat<T, Q>::tdualquat(tquat<T, Q> const& r)
: real(r), dual(tquat<T, Q>(0, 0, 0, 0))
{}
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 tdualquat<T, Q>::tdualquat(tquat<T, Q> const& q, vec<3, T, Q> const& p)
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX14 tdualquat<T, Q>::tdualquat(tquat<T, Q> const& q, vec<3, T, Q> const& p)
: real(q), dual(
T(-0.5) * ( p.x*q.x + p.y*q.y + p.z*q.z),
T(+0.5) * ( p.x*q.w + p.y*q.z - p.z*q.y),
@ -66,7 +66,7 @@ namespace glm
{}
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 tdualquat<T, Q>::tdualquat(tquat<T, Q> const& r, tquat<T, Q> const& d)
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX14 tdualquat<T, Q>::tdualquat(tquat<T, Q> const& r, tquat<T, Q> const& d)
: real(r), dual(d)
{}
@ -74,19 +74,19 @@ namespace glm
template<typename T, qualifier Q>
template<typename U, qualifier P>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 tdualquat<T, Q>::tdualquat(tdualquat<U, P> const& q)
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX14 tdualquat<T, Q>::tdualquat(tdualquat<U, P> const& q)
: real(q.real)
, dual(q.dual)
{}
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER tdualquat<T, Q>::tdualquat(mat<2, 4, T, Q> const& m)
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX14 tdualquat<T, Q>::tdualquat(mat<2, 4, T, Q> const& m)
{
*this = dualquat_cast(m);
}
template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER tdualquat<T, Q>::tdualquat(mat<3, 4, T, Q> const& m)
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX14 tdualquat<T, Q>::tdualquat(mat<3, 4, T, Q> const& m)
{
*this = dualquat_cast(m);
}