mewin/glm
1
0
Fork 0
Code Releases Activity

Merge pull request #358 from JesseTG/jtg/preprocessor-cleanup

Browse Source 
Simplify some preprocessor declarations #358
This commit is contained in:
Christophe R. 2015-07-24 01:52:26 +02:00
commit 1b9872138d
19 changed files with 119 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
glm/detail/setup.hpp
View File

@ -925,8 +925,16 @@
#if GLM_HAS_CONSTEXPR #if GLM_HAS_CONSTEXPR
# define GLM_CONSTEXPR constexpr # define GLM_CONSTEXPR constexpr
# define GLM_CONSTEXPR_MAYBE constexpr
#else #else
# define GLM_CONSTEXPR # define GLM_CONSTEXPR
# define GLM_CONSTEXPR_MAYBE const
#endif
#ifdef GLM_FORCE_EXPLICIT_CTOR
# define GLM_EXPLICIT_CTOR_MAYBE explicit
#else
# define GLM_EXPLICIT_CTOR_MAYBE
#endif #endif
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////

24
glm/detail/type_mat2x2.hpp
View File

@ -55,17 +55,10 @@ namespace glm
friend tvec2<U, Q> operator/(tvec2<U, Q> const & v, tmat2x2<U, Q> const & m); friend tvec2<U, Q> operator/(tvec2<U, Q> const & v, tmat2x2<U, Q> const & m);
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 2;
static GLM_CONSTEXPR length_t components = 2; static GLM_CONSTEXPR_MAYBE length_t columns = 2;
static GLM_CONSTEXPR length_t columns = 2; static GLM_CONSTEXPR_MAYBE length_t rows = 2;
static GLM_CONSTEXPR length_t rows = 2; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 2;
static const length_t columns = 2;
static const length_t rows = 2;
static const precision prec = P;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
private: private:
@ -105,13 +98,8 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Matrix conversions // Matrix conversions
# ifdef GLM_FORCE_EXPLICIT_CTOR template <typename U, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tmat2x2(tmat2x2<U, Q> const & m);
GLM_FUNC_DECL explicit tmat2x2(tmat2x2<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat2x2(tmat2x2<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat2x2(tmat3x3<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T, P> const & x); GLM_FUNC_DECL explicit tmat2x2(tmat4x4<T, P> const & x);

24
glm/detail/type_mat2x3.hpp
View File

@ -51,17 +51,10 @@ namespace glm
typedef T value_type; typedef T value_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 2;
static GLM_CONSTEXPR length_t components = 2; static GLM_CONSTEXPR_MAYBE length_t cols = 3;
static GLM_CONSTEXPR length_t cols = 3; static GLM_CONSTEXPR_MAYBE length_t rows = 2;
static GLM_CONSTEXPR length_t rows = 2; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 2;
static const length_t cols = 3;
static const length_t rows = 2;
static const precision prec = P;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
private: private:
@ -101,13 +94,8 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Matrix conversion // Matrix conversion
# ifdef GLM_FORCE_EXPLICIT_CTOR template <typename U, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tmat2x3(tmat2x3<U, Q> const & m);
GLM_FUNC_DECL explicit tmat2x3(tmat2x3<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat2x3(tmat2x3<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat2x3(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat2x3(tmat3x3<T, P> const & x);

24
glm/detail/type_mat2x4.hpp
View File

@ -51,17 +51,10 @@ namespace glm
typedef T value_type; typedef T value_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 2;
static GLM_CONSTEXPR length_t components = 2; static GLM_CONSTEXPR_MAYBE length_t cols = 4;
static GLM_CONSTEXPR length_t cols = 4; static GLM_CONSTEXPR_MAYBE length_t rows = 2;
static GLM_CONSTEXPR length_t rows = 2; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 2;
static const length_t cols = 4;
static const length_t rows = 2;
static const precision prec = P;
# endif
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
private: private:
@ -102,13 +95,8 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Matrix conversions // Matrix conversions
# ifdef GLM_FORCE_EXPLICIT_CTOR template <typename U, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tmat2x4(tmat2x4<U, Q> const & m);
GLM_FUNC_DECL explicit tmat2x4(tmat2x4<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat2x4(tmat2x4<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat2x4(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat2x4(tmat3x3<T, P> const & x);

24
glm/detail/type_mat3x2.hpp
View File

@ -51,17 +51,10 @@ namespace glm
typedef T value_type; typedef T value_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 3;
static GLM_CONSTEXPR length_t components = 3; static GLM_CONSTEXPR_MAYBE length_t cols = 2;
static GLM_CONSTEXPR length_t cols = 2; static GLM_CONSTEXPR_MAYBE length_t rows = 3;
static GLM_CONSTEXPR length_t rows = 3; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 3;
static const length_t cols = 2;
static const length_t rows = 3;
static const precision prec = P;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
private: private:
@ -108,13 +101,8 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Matrix conversions // Matrix conversions
# ifdef GLM_FORCE_EXPLICIT_CTOR template <typename U, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tmat3x2(tmat3x2<U, Q> const & m);
GLM_FUNC_DECL explicit tmat3x2(tmat3x2<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat3x2(tmat3x2<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat3x2(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat3x2(tmat3x3<T, P> const & x);

26
glm/detail/type_mat3x3.hpp
View File

@ -49,17 +49,12 @@ namespace glm
typedef tmat3x3<T, P> transpose_type; typedef tmat3x3<T, P> transpose_type;
typedef T value_type; typedef T value_type;
# if GLM_HAS_CONSTEXPR # ifdef GLM_META_PROG_HELPERS
static GLM_CONSTEXPR length_t components = 3; static GLM_CONSTEXPR_MAYBE length_t components = 3;
static GLM_CONSTEXPR length_t cols = 3; static GLM_CONSTEXPR_MAYBE length_t cols = 3;
static GLM_CONSTEXPR length_t rows = 3; static GLM_CONSTEXPR_MAYBE length_t rows = 3;
static GLM_CONSTEXPR precision prec = P; static GLM_CONSTEXPR_MAYBE precision prec = P;
# else # endif//GLM_META_PROG_HELPERS
static const length_t components = 3;
static const length_t cols = 3;
static const length_t rows = 3;
static const precision prec = P;
# endif
template <typename U, precision Q> template <typename U, precision Q>
friend tvec3<U, Q> operator/(tmat3x3<U, Q> const & m, tvec3<U, Q> const & v); friend tvec3<U, Q> operator/(tmat3x3<U, Q> const & m, tvec3<U, Q> const & v);
@ -110,13 +105,8 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Matrix conversions // Matrix conversions
# ifdef GLM_FORCE_EXPLICIT_CTOR template <typename U, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tmat3x3(tmat3x3<U, Q> const & m);
GLM_FUNC_DECL explicit tmat3x3(tmat3x3<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat3x3(tmat3x3<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat3x3(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T, P> const & x); GLM_FUNC_DECL explicit tmat3x3(tmat4x4<T, P> const & x);

24
glm/detail/type_mat3x4.hpp
View File

@ -51,17 +51,10 @@ namespace glm
typedef T value_type; typedef T value_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 3;
static GLM_CONSTEXPR length_t components = 3; static GLM_CONSTEXPR_MAYBE length_t cols = 4;
static GLM_CONSTEXPR length_t cols = 4; static GLM_CONSTEXPR_MAYBE length_t rows = 3;
static GLM_CONSTEXPR length_t rows = 3; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 3;
static const length_t cols = 4;
static const length_t rows = 3;
static const precision prec = P;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
private: private:
@ -107,13 +100,8 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Matrix conversion // Matrix conversion
# ifdef GLM_FORCE_EXPLICIT_CTOR template <typename U, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tmat3x4(tmat3x4<U, Q> const & m);
GLM_FUNC_DECL explicit tmat3x4(tmat3x4<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat3x4(tmat3x4<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat3x4(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat3x4(tmat3x3<T, P> const & x);

24
glm/detail/type_mat4x2.hpp
View File

@ -51,17 +51,10 @@ namespace glm
typedef T value_type; typedef T value_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 4;
static GLM_CONSTEXPR length_t components = 4; static GLM_CONSTEXPR_MAYBE length_t cols = 2;
static GLM_CONSTEXPR length_t cols = 2; static GLM_CONSTEXPR_MAYBE length_t rows = 4;
static GLM_CONSTEXPR length_t rows = 4; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 4;
static const length_t cols = 2;
static const length_t rows = 4;
static const precision prec = P;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
private: private:
@ -113,13 +106,8 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Matrix conversions // Matrix conversions
# ifdef GLM_FORCE_EXPLICIT_CTOR template <typename U, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tmat4x2(tmat4x2<U, Q> const & m);
GLM_FUNC_DECL explicit tmat4x2(tmat4x2<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat4x2(tmat4x2<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat4x2(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat4x2(tmat3x3<T, P> const & x);

24
glm/detail/type_mat4x3.hpp
View File

@ -51,17 +51,10 @@ namespace glm
typedef T value_type; typedef T value_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 4;
static GLM_CONSTEXPR length_t components = 4; static GLM_CONSTEXPR_MAYBE length_t cols = 3;
static GLM_CONSTEXPR length_t cols = 3; static GLM_CONSTEXPR_MAYBE length_t rows = 4;
static GLM_CONSTEXPR length_t rows = 4; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 4;
static const length_t cols = 3;
static const length_t rows = 4;
static const precision prec = P;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
private: private:
@ -112,13 +105,8 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Matrix conversions // Matrix conversions
# ifdef GLM_FORCE_EXPLICIT_CTOR template <typename U, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tmat4x3(tmat4x3<U, Q> const & m);
GLM_FUNC_DECL explicit tmat4x3(tmat4x3<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat4x3(tmat4x3<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat4x3(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat4x3(tmat3x3<T, P> const & x);

24
glm/detail/type_mat4x4.hpp
View File

@ -50,17 +50,10 @@ namespace glm
typedef T value_type; typedef T value_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 4;
static GLM_CONSTEXPR length_t components = 4; static GLM_CONSTEXPR_MAYBE length_t cols = 4;
static GLM_CONSTEXPR length_t cols = 4; static GLM_CONSTEXPR_MAYBE length_t rows = 4;
static GLM_CONSTEXPR length_t rows = 4; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 4;
static const length_t cols = 4;
static const length_t rows = 4;
static const precision prec = P;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
template <typename U, precision Q> template <typename U, precision Q>
@ -117,13 +110,8 @@ namespace glm
////////////////////////////////////// //////////////////////////////////////
// Matrix conversions // Matrix conversions
# ifdef GLM_FORCE_EXPLICIT_CTOR template <typename U, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tmat4x4(tmat4x4<U, Q> const & m);
GLM_FUNC_DECL explicit tmat4x4(tmat4x4<U, Q> const & m);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tmat4x4(tmat4x4<U, Q> const & m);
# endif
GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T, P> const & x); GLM_FUNC_DECL explicit tmat4x4(tmat2x2<T, P> const & x);
GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T, P> const & x); GLM_FUNC_DECL explicit tmat4x4(tmat3x3<T, P> const & x);

21
glm/detail/type_vec1.hpp
View File

@ -56,13 +56,8 @@ namespace glm
typedef T value_type; typedef T value_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 1;
static GLM_CONSTEXPR length_t components = 1; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 1;
static const precision prec = P;
# endif
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
////////////////////////////////////// //////////////////////////////////////
@ -141,15 +136,9 @@ namespace glm
template <typename U, precision Q> template <typename U, precision Q>
GLM_FUNC_DECL explicit tvec1(tvec4<U, Q> const & v); GLM_FUNC_DECL explicit tvec1(tvec4<U, Q> const & v);
# ifdef GLM_FORCE_EXPLICIT_CTOR //! 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, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tvec1(tvec1<U, Q> const & v);
GLM_FUNC_DECL explicit tvec1(tvec1<U, Q> const & v);
# else
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, precision Q>
GLM_FUNC_DECL tvec1(tvec1<U, Q> const & v);
# endif
////////////////////////////////////// //////////////////////////////////////
// Swizzle constructors // Swizzle constructors

21
glm/detail/type_vec2.hpp
View File

@ -56,13 +56,8 @@ namespace glm
typedef T value_type; typedef T value_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 2;
static GLM_CONSTEXPR length_t components = 2; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 2;
static const precision prec = P;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
////////////////////////////////////// //////////////////////////////////////
@ -149,15 +144,9 @@ namespace glm
template <typename U, precision Q> template <typename U, precision Q>
GLM_FUNC_DECL explicit tvec2(tvec4<U, Q> const & v); GLM_FUNC_DECL explicit tvec2(tvec4<U, Q> const & v);
# ifdef GLM_FORCE_EXPLICIT_CTOR //! 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, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tvec2(tvec2<U, Q> const & v);
GLM_FUNC_DECL explicit tvec2(tvec2<U, Q> const & v);
# else
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, precision Q>
GLM_FUNC_DECL tvec2(tvec2<U, Q> const & v);
# endif
////////////////////////////////////// //////////////////////////////////////
// Swizzle constructors // Swizzle constructors

21
glm/detail/type_vec3.hpp
View File

@ -56,13 +56,8 @@ namespace glm
typedef T value_type; typedef T value_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 3;
static GLM_CONSTEXPR length_t components = 3; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 3;
static const precision prec = P;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
////////////////////////////////////// //////////////////////////////////////
@ -159,15 +154,9 @@ namespace glm
template <typename U, precision Q> template <typename U, precision Q>
GLM_FUNC_DECL explicit tvec3(tvec4<U, Q> const & v); GLM_FUNC_DECL explicit tvec3(tvec4<U, Q> const & v);
# ifdef GLM_FORCE_EXPLICIT_CTOR //! 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, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tvec3(tvec3<U, Q> const & v);
GLM_FUNC_DECL explicit tvec3(tvec3<U, Q> const & v);
# else
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, precision Q>
GLM_FUNC_DECL tvec3(tvec3<U, Q> const & v);
# endif
////////////////////////////////////// //////////////////////////////////////
// Swizzle constructors // Swizzle constructors

21
glm/detail/type_vec4.hpp
View File

@ -110,13 +110,8 @@ namespace detail
typedef T value_type; typedef T value_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 4;
static GLM_CONSTEXPR length_t components = 4; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 4;
static const precision prec = P;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
////////////////////////////////////// //////////////////////////////////////
@ -235,15 +230,9 @@ namespace detail
template <typename A, typename B, precision Q> template <typename A, typename B, precision Q>
GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & a, tvec2<B, Q> const & b); GLM_FUNC_DECL explicit tvec4(tvec2<A, Q> const & a, tvec2<B, Q> const & b);
# ifdef GLM_FORCE_EXPLICIT_CTOR //! 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, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tvec4(tvec4<U, Q> const & v);
GLM_FUNC_DECL explicit tvec4(tvec4<U, Q> const & v);
# else
//! Explicit conversions (From section 5.4.1 Conversion and scalar constructors of GLSL 1.30.08 specification)
template <typename U, precision Q>
GLM_FUNC_DECL tvec4(tvec4<U, Q> const & v);
# endif
////////////////////////////////////// //////////////////////////////////////
// Swizzle constructors // Swizzle constructors

20
glm/gtc/quaternion.hpp
View File

@ -66,13 +66,8 @@ namespace glm
typedef T value_type; typedef T value_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 4;
static GLM_CONSTEXPR length_t components = 4; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 4;
static const precision prec = P;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
public: public:
@ -113,15 +108,10 @@ namespace glm
GLM_FUNC_DECL tquat(T const & w, T const & x, T const & y, T const & z); GLM_FUNC_DECL tquat(T const & w, T const & x, T const & y, T const & z);
////////////////////////////////////// //////////////////////////////////////
// Convertions // Conversions
# ifdef GLM_FORCE_EXPLICIT_CTOR template <typename U, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tquat(tquat<U, Q> const & q);
GLM_FUNC_DECL explicit tquat(tquat<U, Q> const & q);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tquat(tquat<U, Q> const & q);
# endif
// explicit conversion operators // explicit conversion operators
# if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS # if GLM_HAS_EXPLICIT_CONVERSION_OPERATORS

18
glm/gtx/dual_quaternion.hpp
View File

@ -65,13 +65,8 @@ namespace glm
typedef glm::tquat<T, P> part_type; typedef glm::tquat<T, P> part_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 8;
static GLM_CONSTEXPR length_t components = 8; static GLM_CONSTEXPR_MAYBE precision prec = P;
static GLM_CONSTEXPR precision prec = P;
# else
static const length_t components = 8;
static const precision prec = P;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
public: public:
@ -115,13 +110,8 @@ namespace glm
////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////
// tdualquat conversions // tdualquat conversions
# ifdef GLM_FORCE_EXPLICIT_CTOR template <typename U, precision Q>
template <typename U, precision Q> GLM_FUNC_DECL GLM_EXPLICIT_CTOR_MAYBE tdualquat(tdualquat<U, Q> const & q);
GLM_FUNC_DECL explicit tdualquat(tdualquat<U, Q> const & q);
# else
template <typename U, precision Q>
GLM_FUNC_DECL tdualquat(tdualquat<U, Q> const & q);
# endif
GLM_FUNC_DECL explicit tdualquat(tmat2x4<T, P> const & holder_mat); GLM_FUNC_DECL explicit tdualquat(tmat2x4<T, P> const & holder_mat);
GLM_FUNC_DECL explicit tdualquat(tmat3x4<T, P> const & aug_mat); GLM_FUNC_DECL explicit tdualquat(tmat3x4<T, P> const & aug_mat);

15
glm/gtx/simd_mat4.hpp
View File

@ -72,17 +72,10 @@ namespace detail
typedef fmat4x4SIMD transpose_type; typedef fmat4x4SIMD transpose_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 4;
static GLM_CONSTEXPR length_t components = 4; static GLM_CONSTEXPR_MAYBE length_t cols = 4;
static GLM_CONSTEXPR length_t cols = 4; static GLM_CONSTEXPR_MAYBE length_t rows = 4;
static GLM_CONSTEXPR length_t rows = 4; static GLM_CONSTEXPR_MAYBE precision prec = defaultp;
static GLM_CONSTEXPR precision prec = defaultp;
# else
static const length_t components = 4;
static const length_t cols = 4;
static const length_t rows = 4;
static const precision prec = defaultp;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
GLM_FUNC_DECL length_t length() const; GLM_FUNC_DECL length_t length() const;

9
glm/gtx/simd_quat.hpp
View File

@ -77,13 +77,8 @@ namespace detail
typedef tquat<bool, defaultp> bool_type; typedef tquat<bool, defaultp> bool_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 4;
static GLM_CONSTEXPR length_t components = 4; static GLM_CONSTEXPR_MAYBE precision prec = defaultp;
static GLM_CONSTEXPR precision prec = defaultp;
# else
static const length_t components = 4;
static const precision prec = defaultp;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
#ifdef GLM_SIMD_ENABLE_XYZW_UNION #ifdef GLM_SIMD_ENABLE_XYZW_UNION

9
glm/gtx/simd_vec4.hpp
View File

@ -100,13 +100,8 @@ namespace detail
typedef tvec4<bool, highp> bool_type; typedef tvec4<bool, highp> bool_type;
# ifdef GLM_META_PROG_HELPERS # ifdef GLM_META_PROG_HELPERS
# if GLM_HAS_CONSTEXPR static GLM_CONSTEXPR_MAYBE length_t components = 4;
static GLM_CONSTEXPR length_t components = 4; static GLM_CONSTEXPR_MAYBE precision prec = defaultp;
static GLM_CONSTEXPR precision prec = defaultp;
# else
static const length_t components = 4;
static const precision prec = defaultp;
# endif//GLM_HAS_CONSTEXPR
# endif//GLM_META_PROG_HELPERS # endif//GLM_META_PROG_HELPERS
#ifdef GLM_SIMD_ENABLE_XYZW_UNION #ifdef GLM_SIMD_ENABLE_XYZW_UNION