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

Fixed defaulted constructor and fixed anonymous struct detection and use

Browse Source
This commit is contained in:
Christophe Riccio 2018-07-23 16:02:21 +02:00
parent ba4a4c6014
commit 508d0bcbb1
15 changed files with 103 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
glm/detail/qualifier.hpp
View File

@ -15,7 +15,7 @@ namespace glm
packed_mediump, ///< Typed data is tightly packed in memory and operations are executed with medium precision in term of ULPs for higher performance packed_mediump, ///< Typed data is tightly packed in memory and operations are executed with medium precision in term of ULPs for higher performance
packed_lowp, ///< Typed data is tightly packed in memory and operations are executed with low precision in term of ULPs to maximize performance packed_lowp, ///< Typed data is tightly packed in memory and operations are executed with low precision in term of ULPs to maximize performance
# if GLM_HAS_ANONYMOUS_STRUCT # if (GLM_USE_ALIGNED_GENTYPES == GLM_ENABLE)
aligned_highp, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs aligned_highp, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs
aligned_mediump, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs for higher performance aligned_mediump, ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs for higher performance
aligned_lowp, // ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs to maximize performance aligned_lowp, // ///< Typed data is aligned in memory allowing SIMD optimizations and operations are executed with high precision in term of ULPs to maximize performance
@ -27,7 +27,7 @@ namespace glm
lowp = packed_lowp, ///< By default lowp qualifier is also packed lowp = packed_lowp, ///< By default lowp qualifier is also packed
packed = packed_highp, ///< By default packed qualifier is also high precision packed = packed_highp, ///< By default packed qualifier is also high precision
# if GLM_HAS_ANONYMOUS_STRUCT && defined(GLM_FORCE_ALIGNED) # if (GLM_USE_ALIGNED_GENTYPES == GLM_ENABLE) && defined(GLM_FORCE_DEFAULT_ALIGNED_GENTYPES)
defaultp = aligned_highp defaultp = aligned_highp
# else # else
defaultp = highp defaultp = highp
@ -47,7 +47,7 @@ namespace detail
static const bool value = false; static const bool value = false;
}; };
# if GLM_HAS_ANONYMOUS_STRUCT # if GLM_USE_ALIGNED_GENTYPES == GLM_ENABLE
template<> template<>
struct is_aligned<glm::aligned_lowp> struct is_aligned<glm::aligned_lowp>
{ {
@ -65,7 +65,7 @@ namespace detail
{ {
static const bool value = true; static const bool value = true;
}; };
# endif//GLM_HAS_ANONYMOUS_STRUCT # endif
template<length_t L, typename T, bool is_aligned> template<length_t L, typename T, bool is_aligned>
struct storage struct storage
@ -75,7 +75,7 @@ namespace detail
} type; } type;
}; };
# if GLM_LANG & GLM_LANG_CXX11_FLAG # if GLM_HAS_ALIGNOF
template<length_t L, typename T> template<length_t L, typename T>
struct storage<L, T, true> struct storage<L, T, true>
{ {

26
glm/detail/setup.hpp
View File

@ -370,10 +370,6 @@
((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14) && (GLM_ARCH & GLM_ARCH_X86_BIT)))) ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14) && (GLM_ARCH & GLM_ARCH_X86_BIT))))
#endif #endif
///////////////////////////////////////////////////////////////////////////////////
#define GLM_HAS_ANONYMOUS_STRUCT (GLM_LANG & GLM_LANG_CXXMS_FLAG)
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
// OpenMP // OpenMP
#ifdef _OPENMP #ifdef _OPENMP
@ -482,7 +478,7 @@
#define GLM_SWIZZLE_OPERATOR 1 #define GLM_SWIZZLE_OPERATOR 1
#define GLM_SWIZZLE_FUNCTION 2 #define GLM_SWIZZLE_FUNCTION 2
#if defined(GLM_FORCE_SWIZZLE) && GLM_HAS_ANONYMOUS_STRUCT #if defined(GLM_FORCE_SWIZZLE) && (GLM_LANG & GLM_LANG_CXXMS_FLAG)
# define GLM_SWIZZLE GLM_SWIZZLE_OPERATOR # define GLM_SWIZZLE GLM_SWIZZLE_OPERATOR
#elif defined(GLM_FORCE_SWIZZLE) #elif defined(GLM_FORCE_SWIZZLE)
# define GLM_SWIZZLE GLM_SWIZZLE_FUNCTION # define GLM_SWIZZLE GLM_SWIZZLE_FUNCTION
@ -582,8 +578,10 @@
#endif #endif
#if GLM_HAS_DEFAULTED_FUNCTIONS && !defined(GLM_FORCE_CTOR_INIT) #if GLM_HAS_DEFAULTED_FUNCTIONS && !defined(GLM_FORCE_CTOR_INIT)
# define GLM_USE_DEFAULTED_FUNCTIONS GLM_ENABLE
# define GLM_DEFAULT = default # define GLM_DEFAULT = default
#else #else
# define GLM_USE_DEFAULTED_FUNCTIONS GLM_DISABLE
# define GLM_DEFAULT # define GLM_DEFAULT
#endif #endif
@ -638,6 +636,24 @@ namespace glm
# error "GLM error: A different version of GLM is already included. Define GLM_FORCE_IGNORE_VERSION before including GLM headers to ignore this error." # error "GLM error: A different version of GLM is already included. Define GLM_FORCE_IGNORE_VERSION before including GLM headers to ignore this error."
#elif GLM_SETUP_INCLUDED == GLM_VERSION #elif GLM_SETUP_INCLUDED == GLM_VERSION
///////////////////////////////////////////////////////////////////////////////////
// Enable aligned gentypes
#if defined(GLM_FORCE_ALIGNED_GENTYPES) && GLM_HAS_ALIGNOF
# define GLM_USE_ALIGNED_GENTYPES GLM_ENABLE
#else
# define GLM_USE_ALIGNED_GENTYPES GLM_DISABLE
#endif
///////////////////////////////////////////////////////////////////////////////////
// Implementation detail
#if (((GLM_LANG & GLM_LANG_CXXMS_FLAG) && (GLM_ARCH & GLM_ARCH_SIMD_BIT)) || (GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR) || (GLM_USE_ALIGNED_GENTYPES == GLM_ENABLE))
# define GLM_USE_ANONYMOUS_STRUCT GLM_ENABLE
#else
# define GLM_USE_ANONYMOUS_STRUCT GLM_DISABLE
#endif
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
// Messages // Messages

20
glm/detail/type_vec1.inl
View File

@ -5,21 +5,19 @@ namespace glm
{ {
// -- Implicit basic constructors -- // -- Implicit basic constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS || defined(GLM_FORCE_CTOR_INIT) # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_DISABLE
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<1, T, Q>::vec() GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<1, T, Q>::vec()
# ifdef GLM_FORCE_CTOR_INIT # ifdef GLM_FORCE_CTOR_INIT
: x(0) : x(0)
# endif # endif
{} {}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS || defined(GLM_FORCE_CTOR_INIT)
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<1, T, Q>::vec(vec<1, T, Q> const& v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<1, T, Q>::vec(vec<1, T, Q> const& v)
: x(v.x) : x(v.x)
{} {}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS # endif
template<typename T, qualifier Q> template<typename T, qualifier Q>
template<qualifier P> template<qualifier P>
@ -78,12 +76,14 @@ namespace glm
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
template<typename T, qualifier Q> # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_DISABLE
GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, T, Q> const& v) template<typename T, qualifier Q>
{ GLM_FUNC_QUALIFIER vec<1, T, Q> & vec<1, T, Q>::operator=(vec<1, T, Q> const& v)
this->x = v.x; {
return *this; this->x = v.x;
} return *this;
}
# endif
template<typename T, qualifier Q> template<typename T, qualifier Q>
template<typename U> template<typename U>

4
glm/detail/type_vec2.hpp
View File

@ -24,7 +24,7 @@ namespace glm
// -- Data -- // -- Data --
# if GLM_HAS_ANONYMOUS_STRUCT # if GLM_USE_ANONYMOUS_STRUCT == GLM_ENABLE
union union
{ {
struct{ T x, y; }; struct{ T x, y; };
@ -114,7 +114,7 @@ namespace glm
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
GLM_FUNC_DECL vec<2, T, Q> & operator=(vec const& v); GLM_FUNC_DECL vec<2, T, Q> & operator=(vec const& v) GLM_DEFAULT;
template<typename U> template<typename U>
GLM_FUNC_DECL vec<2, T, Q> & operator=(vec<2, U, Q> const& v); GLM_FUNC_DECL vec<2, T, Q> & operator=(vec<2, U, Q> const& v);

22
glm/detail/type_vec2.inl
View File

@ -7,21 +7,19 @@ namespace glm
{ {
// -- Implicit basic constructors -- // -- Implicit basic constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS || defined(GLM_FORCE_CTOR_INIT) # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_DISABLE
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<2, T, Q>::vec() GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<2, T, Q>::vec()
# ifdef GLM_FORCE_CTOR_INIT # ifdef GLM_FORCE_CTOR_INIT
: x(0), y(0) : x(0), y(0)
# endif # endif
{} {}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS || defined(GLM_FORCE_CTOR_INIT)
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<2, T, Q>::vec(vec<2, T, Q> const& v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<2, T, Q>::vec(vec<2, T, Q> const& v)
: x(v.x), y(v.y) : x(v.x), y(v.y)
{} {}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS # endif
template<typename T, qualifier Q> template<typename T, qualifier Q>
template<qualifier P> template<qualifier P>
@ -119,13 +117,15 @@ namespace glm
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
template<typename T, qualifier Q> # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_DISABLE
GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, T, Q> const& v) template<typename T, qualifier Q>
{ GLM_FUNC_QUALIFIER vec<2, T, Q> & vec<2, T, Q>::operator=(vec<2, T, Q> const& v)
this->x = v.x; {
this->y = v.y; this->x = v.x;
return *this; this->y = v.y;
} return *this;
}
# endif
template<typename T, qualifier Q> template<typename T, qualifier Q>
template<typename U> template<typename U>

6
glm/detail/type_vec3.hpp
View File

@ -24,7 +24,7 @@ namespace glm
// -- Data -- // -- Data --
# if GLM_HAS_ANONYMOUS_STRUCT # if GLM_USE_ANONYMOUS_STRUCT == GLM_ENABLE
union union
{ {
struct{ T x, y, z; }; struct{ T x, y, z; };
@ -81,7 +81,7 @@ namespace glm
template<typename U, qualifier P> template<typename U, qualifier P>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 explicit vec(vec<1, U, P> const& v); GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 explicit vec(vec<1, U, P> const& v);
/// Explicit converions (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 X, typename Y, typename Z> template<typename X, typename Y, typename Z>
GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec(X x, Y y, Z z); GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 vec(X x, Y y, Z z);
template<typename X, typename Y, typename Z> template<typename X, typename Y, typename Z>
@ -144,7 +144,7 @@ namespace glm
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
GLM_FUNC_DECL vec<3, T, Q>& operator=(vec<3, T, Q> const& v); GLM_FUNC_DECL vec<3, T, Q>& operator=(vec<3, T, Q> const& v) GLM_DEFAULT;
template<typename U> template<typename U>
GLM_FUNC_DECL vec<3, T, Q> & operator=(vec<3, U, Q> const& v); GLM_FUNC_DECL vec<3, T, Q> & operator=(vec<3, U, Q> const& v);

24
glm/detail/type_vec3.inl
View File

@ -5,21 +5,19 @@ namespace glm
{ {
// -- Implicit basic constructors -- // -- Implicit basic constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS || defined(GLM_FORCE_CTOR_INIT) # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_DISABLE
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<3, T, Q>::vec() GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<3, T, Q>::vec()
# ifdef GLM_FORCE_CTOR_INIT # ifdef GLM_FORCE_CTOR_INIT
: x(0), y(0), z(0) : x(0), y(0), z(0)
# endif # endif
{} {}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS || defined(GLM_FORCE_CTOR_INIT)
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<3, T, Q>::vec(vec<3, T, Q> const& v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<3, T, Q>::vec(vec<3, T, Q> const& v)
: x(v.x), y(v.y), z(v.z) : x(v.x), y(v.y), z(v.z)
{} {}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS # endif
template<typename T, qualifier Q> template<typename T, qualifier Q>
template<qualifier P> template<qualifier P>
@ -181,14 +179,16 @@ namespace glm
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
template<typename T, qualifier Q> # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_DISABLE
GLM_FUNC_QUALIFIER vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, T, Q> const& v) template<typename T, qualifier Q>
{ GLM_FUNC_QUALIFIER vec<3, T, Q>& vec<3, T, Q>::operator=(vec<3, T, Q> const& v)
this->x = v.x; {
this->y = v.y; this->x = v.x;
this->z = v.z; this->y = v.y;
return *this; this->z = v.z;
} return *this;
}
# endif
template<typename T, qualifier Q> template<typename T, qualifier Q>
template<typename U> template<typename U>

4
glm/detail/type_vec4.hpp
View File

@ -24,7 +24,7 @@ namespace glm
// -- Data -- // -- Data --
# if GLM_HAS_ANONYMOUS_STRUCT # if GLM_USE_ANONYMOUS_STRUCT == GLM_ENABLE
union union
{ {
struct { T x, y, z, w; }; struct { T x, y, z, w; };
@ -219,7 +219,7 @@ namespace glm
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
GLM_FUNC_DECL vec<4, T, Q>& operator=(vec<4, T, Q> const& v); GLM_FUNC_DECL vec<4, T, Q>& operator=(vec<4, T, Q> const& v) GLM_DEFAULT;
template<typename U> template<typename U>
GLM_FUNC_DECL vec<4, T, Q>& operator=(vec<4, U, Q> const& v); GLM_FUNC_DECL vec<4, T, Q>& operator=(vec<4, U, Q> const& v);

26
glm/detail/type_vec4.inl
View File

@ -158,21 +158,19 @@ namespace detail
// -- Implicit basic constructors -- // -- Implicit basic constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS || defined(GLM_FORCE_CTOR_INIT) # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_DISABLE
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<4, T, Q>::vec() GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<4, T, Q>::vec()
# ifdef GLM_FORCE_CTOR_INIT # ifdef GLM_FORCE_CTOR_INIT
: x(0), y(0), z(0), w(0) : x(0), y(0), z(0), w(0)
# endif # endif
{} {}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS || defined(GLM_FORCE_CTOR_INIT)
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<4, T, Q>::vec(vec<4, T, Q> const& v) GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 vec<4, T, Q>::vec(vec<4, T, Q> const& v)
: x(v.x), y(v.y), z(v.z), w(v.w) : x(v.x), y(v.y), z(v.z), w(v.w)
{} {}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS # endif
template<typename T, qualifier Q> template<typename T, qualifier Q>
template<qualifier P> template<qualifier P>
@ -520,15 +518,17 @@ namespace detail
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
template<typename T, qualifier Q> # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_DISABLE
GLM_FUNC_QUALIFIER vec<4, T, Q>& vec<4, T, Q>::operator=(vec<4, T, Q> const& v) template<typename T, qualifier Q>
{ GLM_FUNC_QUALIFIER vec<4, T, Q>& vec<4, T, Q>::operator=(vec<4, T, Q> const& v)
this->x = v.x; {
this->y = v.y; this->x = v.x;
this->z = v.z; this->y = v.y;
this->w = v.w; this->z = v.z;
return *this; this->w = v.w;
} return *this;
}
# endif
template<typename T, qualifier Q> template<typename T, qualifier Q>
template<typename U> template<typename U>

4
glm/ext/vec1.hpp
View File

@ -41,7 +41,7 @@ namespace glm
// -- Data -- // -- Data --
# if GLM_HAS_ANONYMOUS_STRUCT # if GLM_USE_ANONYMOUS_STRUCT == GLM_ENABLE
union union
{ {
T x; T x;
@ -120,7 +120,7 @@ namespace glm
*/ */
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
GLM_FUNC_DECL vec<1, T, Q> & operator=(vec const& v); GLM_FUNC_DECL vec<1, T, Q> & operator=(vec const& v) GLM_DEFAULT;
template<typename U> template<typename U>
GLM_FUNC_DECL vec<1, T, Q> & operator=(vec<1, U, Q> const& v); GLM_FUNC_DECL vec<1, T, Q> & operator=(vec<1, U, Q> const& v);

10
glm/gtc/quaternion.inl
View File

@ -84,21 +84,19 @@ namespace detail
// -- Implicit basic constructors -- // -- Implicit basic constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS || defined(GLM_FORCE_CTOR_INIT) # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_DISABLE
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 tquat<T, Q>::tquat() GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 tquat<T, Q>::tquat()
# ifdef GLM_FORCE_CTOR_INIT # ifdef GLM_FORCE_CTOR_INIT
: x(0), y(0), z(0), w(1) : x(0), y(0), z(0), w(1)
# endif # endif
{} {}
# endif
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 tquat<T, Q>::tquat(tquat<T, Q> const& q) GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 tquat<T, Q>::tquat(tquat<T, Q> const& q)
: x(q.x), y(q.y), z(q.z), w(q.w) : x(q.x), y(q.y), z(q.z), w(q.w)
{} {}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS # endif
template<typename T, qualifier Q> template<typename T, qualifier Q>
template<qualifier P> template<qualifier P>
@ -223,7 +221,7 @@ namespace detail
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_DISABLE
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER tquat<T, Q> & tquat<T, Q>::operator=(tquat<T, Q> const& q) GLM_FUNC_QUALIFIER tquat<T, Q> & tquat<T, Q>::operator=(tquat<T, Q> const& q)
{ {
@ -233,7 +231,7 @@ namespace detail
this->z = q.z; this->z = q.z;
return *this; return *this;
} }
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS # endif
template<typename T, qualifier Q> template<typename T, qualifier Q>
template<typename U> template<typename U>

5
glm/gtc/type_aligned.hpp
View File

@ -12,9 +12,10 @@
#pragma once #pragma once
#if !GLM_HAS_ANONYMOUS_STRUCT #if !GLM_USE_ANONYMOUS_STRUCT
# error "GLM: Aligned types are not supported on this platform" # error "GLM: Aligned gentypes require to enable C++ language extensions and to define GLM_FORCE_ALIGNED_GENTYPES before including GLM headers."
#endif #endif
#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED) #if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_EXT_INCLUDED)
# pragma message("GLM: GLM_GTC_type_aligned extension included") # pragma message("GLM: GLM_GTC_type_aligned extension included")
#endif #endif

10
glm/gtx/dual_quaternion.inl
View File

@ -24,7 +24,7 @@ namespace glm
// -- Implicit basic constructors -- // -- Implicit basic constructors --
# if !GLM_HAS_DEFAULTED_FUNCTIONS || defined(GLM_FORCE_CTOR_INIT) # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_DISABLE
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 tdualquat<T, Q>::tdualquat() GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX11 tdualquat<T, Q>::tdualquat()
# ifdef GLM_FORCE_CTOR_INIT # ifdef GLM_FORCE_CTOR_INIT
@ -32,15 +32,13 @@ namespace glm
, dual(tquat<T, Q>(0, 0, 0, 0)) , dual(tquat<T, Q>(0, 0, 0, 0))
# endif # endif
{} {}
# endif
# if !GLM_HAS_DEFAULTED_FUNCTIONS
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER GLM_CONSTEXPR_CXX14 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) : real(d.real)
, dual(d.dual) , dual(d.dual)
{} {}
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS # endif
template<typename T, qualifier Q> template<typename T, qualifier Q>
template<qualifier P> template<qualifier P>
@ -93,7 +91,7 @@ namespace glm
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --
# if !GLM_HAS_DEFAULTED_FUNCTIONS # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_DISABLE
template<typename T, qualifier Q> template<typename T, qualifier Q>
GLM_FUNC_QUALIFIER tdualquat<T, Q> & tdualquat<T, Q>::operator=(tdualquat<T, Q> const& q) GLM_FUNC_QUALIFIER tdualquat<T, Q> & tdualquat<T, Q>::operator=(tdualquat<T, Q> const& q)
{ {
@ -101,7 +99,7 @@ namespace glm
this->dual = q.dual; this->dual = q.dual;
return *this; return *this;
} }
# endif//!GLM_HAS_DEFAULTED_FUNCTIONS # endif
template<typename T, qualifier Q> template<typename T, qualifier Q>
template<typename U> template<typename U>

16
test/core/core_type_ctor.cpp
View File

@ -6,7 +6,7 @@ static int test_vec1_ctor()
{ {
int Error = 0; int Error = 0;
# if GLM_HAS_DEFAULTED_FUNCTIONS # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_ENABLE
{ {
union pack union pack
{ {
@ -20,7 +20,7 @@ static int test_vec1_ctor()
B.f = glm::vec1(1); B.f = glm::vec1(1);
Error += glm::all(glm::equal(B.i, glm::ivec1(1065353216))) ? 0 : 1; Error += glm::all(glm::equal(B.i, glm::ivec1(1065353216))) ? 0 : 1;
} }
# endif//GLM_HAS_DEFAULTED_FUNCTIONS # endif//GLM_USE_DEFAULTED_FUNCTIONS == GLM_ENABLE
return Error; return Error;
} }
@ -29,7 +29,7 @@ static int test_vec2_ctor()
{ {
int Error = 0; int Error = 0;
# if GLM_HAS_DEFAULTED_FUNCTIONS # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_ENABLE
{ {
union pack union pack
{ {
@ -43,7 +43,7 @@ static int test_vec2_ctor()
B.f = glm::vec2(1); B.f = glm::vec2(1);
Error += glm::all(glm::equal(B.i, glm::ivec2(1065353216))) ? 0 : 1; Error += glm::all(glm::equal(B.i, glm::ivec2(1065353216))) ? 0 : 1;
} }
# endif//GLM_HAS_DEFAULTED_FUNCTIONS # endif
return Error; return Error;
} }
@ -52,7 +52,7 @@ static int test_vec3_ctor()
{ {
int Error = 0; int Error = 0;
# if GLM_HAS_DEFAULTED_FUNCTIONS # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_ENABLE
{ {
union pack union pack
{ {
@ -66,7 +66,7 @@ static int test_vec3_ctor()
B.f = glm::vec3(1); B.f = glm::vec3(1);
Error += glm::all(glm::equal(B.i, glm::ivec3(1065353216))) ? 0 : 1; Error += glm::all(glm::equal(B.i, glm::ivec3(1065353216))) ? 0 : 1;
} }
# endif//GLM_HAS_DEFAULTED_FUNCTIONS # endif
return Error; return Error;
} }
@ -75,7 +75,7 @@ static int test_vec4_ctor()
{ {
int Error = 0; int Error = 0;
# if GLM_HAS_DEFAULTED_FUNCTIONS # if GLM_USE_DEFAULTED_FUNCTIONS == GLM_ENABLE
{ {
union pack union pack
{ {
@ -89,7 +89,7 @@ static int test_vec4_ctor()
B.f = glm::vec4(1); B.f = glm::vec4(1);
Error += glm::all(glm::equal(B.i, glm::ivec4(1065353216))) ? 0 : 1; Error += glm::all(glm::equal(B.i, glm::ivec4(1065353216))) ? 0 : 1;
} }
# endif//GLM_HAS_DEFAULTED_FUNCTIONS # endif
return Error; return Error;
} }

5
test/gtc/gtc_type_aligned.cpp
View File

@ -1,7 +1,8 @@
#define GLM_FORCE_MESSAGES #define GLM_FORCE_MESSAGES
#define GLM_FORCE_ALIGNED_GENTYPES
#include <glm/glm.hpp> #include <glm/glm.hpp>
#if GLM_HAS_ANONYMOUS_STRUCT #if GLM_USE_ALIGNED_GENTYPES == GLM_ENABLE
#include <glm/gtc/type_aligned.hpp> #include <glm/gtc/type_aligned.hpp>
GLM_STATIC_ASSERT(glm::detail::is_aligned<glm::aligned_lowp>::value, "aligned_lowp is not aligned"); GLM_STATIC_ASSERT(glm::detail::is_aligned<glm::aligned_lowp>::value, "aligned_lowp is not aligned");
@ -143,4 +144,4 @@ int main()
return 0; return 0;
} }
#endif//GLM_HAS_ANONYMOUS_STRUCT #endif//GLM_USE_ANONYMOUS_STRUCT