From c7b6cf56e39fc2814c7a43d39dd1cad7cd934ede Mon Sep 17 00:00:00 2001 From: Groove Date: Thu, 12 Jul 2018 00:36:59 +0200 Subject: [PATCH] Fixed swizzle functions and tests --- CMakeLists.txt | 7 ++- glm/detail/setup.hpp | 81 ++++++++++++------------- glm/detail/type_vec2.hpp | 21 +++---- glm/detail/type_vec3.hpp | 23 +++---- glm/detail/type_vec4.hpp | 21 +++---- glm/detail/type_vec4_simd.inl | 4 +- glm/ext/vec1.hpp | 17 +++--- test/core/core_force_pure.cpp | 35 ++++++++++- test/core/core_func_swizzle.cpp | 30 ++++----- test/core/core_type_vec1.cpp | 31 ++++++---- test/core/core_type_vec2.cpp | 43 +++++++++---- test/core/core_type_vec3.cpp | 104 ++++++++++++++++++++------------ test/core/core_type_vec4.cpp | 103 +++++++++++++++++++++---------- test/gtx/gtx_io.cpp | 10 +++ 14 files changed, 319 insertions(+), 211 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index fab76a99..c809cc33 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -59,10 +59,15 @@ option(GLM_TEST_ENABLE_LANG_EXTENSIONS "Enable language extensions" OFF) if(GLM_TEST_ENABLE_LANG_EXTENSIONS) set(CMAKE_CXX_EXTENSIONS ON) - + if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + add_compile_options(/Ze) + endif() message(STATUS "GLM: Build with C++ language extensions") else() set(CMAKE_CXX_EXTENSIONS OFF) + if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC") + add_compile_options(/Za) + endif() endif() option(GLM_TEST_ENABLE_FAST_MATH "Enable fast math optimizations" OFF) diff --git a/glm/detail/setup.hpp b/glm/detail/setup.hpp index 8c951b62..bb5ec687 100644 --- a/glm/detail/setup.hpp +++ b/glm/detail/setup.hpp @@ -3,31 +3,30 @@ #ifndef GLM_SETUP_INCLUDED +#include +#include + #define GLM_VERSION_MAJOR 0 #define GLM_VERSION_MINOR 9 #define GLM_VERSION_PATCH 9 -#define GLM_VERSION_REVISION 0 -#define GLM_VERSION 990 +#define GLM_VERSION_REVISION 1 +#define GLM_VERSION 991 #define GLM_SETUP_INCLUDED GLM_VERSION -#if defined(GLM_FORCE_SWIZZLE) && defined(GLM_FORCE_UNRESTRICTED_GENTYPE) -# error "Both GLM_FORCE_SWIZZLE and GLM_FORCE_UNRESTRICTED_GENTYPE can't be defined at the same time" -#endif +/////////////////////////////////////////////////////////////////////////////////// +// Active states -#include -#include +#define GLM_DISABLE 0 +#define GLM_ENABLE 1 /////////////////////////////////////////////////////////////////////////////////// // Messages -#define GLM_MESSAGES_ENABLED 1 -#define GLM_MESSAGES_DISABLE 0 - #if defined(GLM_FORCE_MESSAGES) -# define GLM_MESSAGES GLM_MESSAGES_ENABLED +# define GLM_MESSAGES GLM_ENABLE #else -# define GLM_MESSAGES GLM_MESSAGES_DISABLE +# define GLM_MESSAGES GLM_DISABLE #endif /////////////////////////////////////////////////////////////////////////////////// @@ -38,13 +37,13 @@ /////////////////////////////////////////////////////////////////////////////////// // Version -#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_VERSION_DISPLAYED) +#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_VERSION_DISPLAYED) # define GLM_MESSAGE_VERSION_DISPLAYED -# pragma message ("GLM: version 0.9.9.0") +# pragma message ("GLM: version 0.9.9.1") #endif//GLM_MESSAGES // Report compiler detection -#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_COMPILER_DISPLAYED) +#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_COMPILER_DISPLAYED) # define GLM_MESSAGE_COMPILER_DISPLAYED # if GLM_COMPILER & GLM_COMPILER_CUDA # pragma message("GLM: CUDA compiler detected") @@ -61,6 +60,13 @@ # endif #endif//GLM_MESSAGES +/////////////////////////////////////////////////////////////////////////////////// +// Incompatible GLM_FORCE defines + +#if defined(GLM_FORCE_SWIZZLE) && defined(GLM_FORCE_UNRESTRICTED_GENTYPE) +# error "Both GLM_FORCE_SWIZZLE and GLM_FORCE_UNRESTRICTED_GENTYPE can't be defined at the same time" +#endif + /////////////////////////////////////////////////////////////////////////////////// // Build model @@ -76,7 +82,7 @@ # error "GLM_MODEL undefined, your compiler may not be supported by GLM. Add #define GLM_MODEL 0 to ignore this message." #endif//GLM_MODEL -#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_MODEL_DISPLAYED) +#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_MODEL_DISPLAYED) # define GLM_MESSAGE_MODEL_DISPLAYED # if(GLM_MODEL == GLM_MODEL_64) # pragma message("GLM: 64 bits model") @@ -85,7 +91,7 @@ # endif//GLM_MODEL #endif//GLM_MESSAGES -#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_ARCH_DISPLAYED) +#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_ARCH_DISPLAYED) # define GLM_MESSAGE_ARCH_DISPLAYED # if(GLM_ARCH == GLM_ARCH_PURE) # pragma message("GLM: Platform independent code") @@ -158,14 +164,14 @@ #endif #if defined(GLM_FORCE_CXX2A) -# if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_FORCE_CXX2A_DISPLAYED) +# if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_FORCE_CXX2A_DISPLAYED) # define GLM_MESSAGE_FORCE_CXX2A_DISPLAYED # pragma message("GLM: Force the use of C++2a only") # endif//GLM_MESSAGES # define GLM_LANG (GLM_LANG_CXX2A | GLM_MSC_EXT) # define GLM_LANG_STL11_FORCED #elif defined(GLM_FORCE_CXX17) -# if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_FORCE_CXX17_DISPLAYED) +# if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_FORCE_CXX17_DISPLAYED) # define GLM_MESSAGE_FORCE_CXX17_DISPLAYED # if (__cplusplus >= 201703L) || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15_7)) || ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC80)) || ((GLM_COMPILER & GLM_COMPILER_CLANG) && (GLM_COMPILER >= GLM_COMPILER_CLANG50)) # pragma message("GLM: Force the use of C++17 only") @@ -176,7 +182,7 @@ # define GLM_LANG (GLM_LANG_CXX17 | GLM_MSC_EXT) # define GLM_LANG_STL11_FORCED #elif defined(GLM_FORCE_CXX14) -# if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_FORCE_CXX14_DISPLAYED) +# if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_FORCE_CXX14_DISPLAYED) # define GLM_MESSAGE_FORCE_CXX14_DISPLAYED # if (__cplusplus >= 201402L) || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC15)) || ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC50)) || ((GLM_COMPILER & GLM_COMPILER_CLANG) && (GLM_COMPILER >= GLM_COMPILER_CLANG34)) # pragma message("GLM: Force the use of C++14 only") @@ -187,7 +193,7 @@ # define GLM_LANG (GLM_LANG_CXX14 | GLM_MSC_EXT) # define GLM_LANG_STL11_FORCED #elif defined(GLM_FORCE_CXX11) -# if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_FORCE_CXX11_DISPLAYED) +# if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_FORCE_CXX11_DISPLAYED) # define GLM_MESSAGE_FORCE_CXX11_DISPLAYED # if (__cplusplus >= 201103L) || ((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC14)) || ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER >= GLM_COMPILER_GCC49)) || ((GLM_COMPILER & GLM_COMPILER_CLANG) && (GLM_COMPILER >= GLM_COMPILER_CLANG33)) # pragma message("GLM: Force the use of C++11 only") @@ -217,7 +223,7 @@ # endif #endif -#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_LANG_DISPLAYED) +#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_LANG_DISPLAYED) # define GLM_MESSAGE_LANG_DISPLAYED # if GLM_LANG & GLM_LANG_CXX17_FLAG @@ -237,7 +243,7 @@ # endif//GLM_LANG # if GLM_LANG & (GLM_LANG_CXXGNU_FLAG | GLM_LANG_CXXMS_FLAG) -# pragma message("GLM: Language extensions enabled") +# pragma message("GLM: C++ language extensions enabled") # endif//GLM_LANG #endif//GLM_MESSAGES @@ -416,12 +422,6 @@ # define GLM_CONSTEXPR_CXX14 #endif -// -#define GLM_HAS_ONLY_XYZW ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_COMPILER < GLM_COMPILER_GCC46)) -#if GLM_HAS_ONLY_XYZW -# pragma message("GLM: GCC older than 4.6 has a bug presenting the use of rgba and stpq components") -#endif - // #if GLM_LANG & GLM_LANG_CXX11_FLAG # define GLM_HAS_ASSIGNABLE 1 @@ -555,18 +555,15 @@ // User defines: GLM_FORCE_SWIZZLE -#define GLM_SWIZZLE_ENABLED 1 -#define GLM_SWIZZLE_DISABLE 0 - -#if defined(GLM_FORCE_SWIZZLE) && (GLM_LANG & GLM_LANG_CXXMS_FLAG) -# define GLM_SWIZZLE GLM_SWIZZLE_ENABLED +#if defined(GLM_FORCE_SWIZZLE) +# define GLM_SWIZZLE GLM_ENABLE #else -# define GLM_SWIZZLE GLM_SWIZZLE_DISABLE +# define GLM_SWIZZLE GLM_DISABLE #endif -#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED) +#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED) # define GLM_MESSAGE_SWIZZLE_DISPLAYED -# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_SWIZZLE == GLM_ENABLE # pragma message("GLM: Swizzling operators enabled") # else # pragma message("GLM: Swizzling operators disabled, #define GLM_FORCE_SWIZZLE to enable swizzle operators") @@ -584,7 +581,7 @@ # define GLM_UNRESTRICTED_GENTYPE 0 #endif -#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_UNRESTRICTED_GENTYPE_DISPLAYED) +#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_UNRESTRICTED_GENTYPE_DISPLAYED) # define GLM_MESSAGE_UNRESTRICTED_GENTYPE_DISPLAYED # ifdef GLM_FORCE_UNRESTRICTED_GENTYPE # pragma message("GLM: Use unrestricted genType") @@ -594,7 +591,7 @@ /////////////////////////////////////////////////////////////////////////////////// // Force single only (remove explicit float64 types) -#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_SINGLE_ONLY_DISPLAYED) +#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_SINGLE_ONLY_DISPLAYED) # define GLM_MESSAGE_SINGLE_ONLY_DISPLAYED # ifdef GLM_FORCE_SINGLE_ONLY # pragma message("GLM: Using only single precision floating-point types") @@ -613,7 +610,7 @@ # define GLM_DEPTH_CLIP_SPACE GLM_DEPTH_NEGATIVE_ONE_TO_ONE #endif -#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_DEPTH_DISPLAYED) +#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_DEPTH_DISPLAYED) # define GLM_MESSAGE_DEPTH_DISPLAYED # if GLM_DEPTH_CLIP_SPACE == GLM_DEPTH_ZERO_TO_ONE # pragma message("GLM: Depth clip space: Zero to one") @@ -635,7 +632,7 @@ # define GLM_COORDINATE_SYSTEM GLM_RIGHT_HANDED #endif -#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_HANDED_DISPLAYED) +#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_HANDED_DISPLAYED) # define GLM_MESSAGE_HANDED_DISPLAYED # if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED # pragma message("GLM: Coordinate system: left handed") @@ -739,7 +736,7 @@ namespace glm # endif }//namespace glm -#if GLM_MESSAGES == GLM_MESSAGES_ENABLED && !defined(GLM_MESSAGE_FORCE_SIZE_T_LENGTH) +#if GLM_MESSAGES == GLM_ENABLE && !defined(GLM_MESSAGE_FORCE_SIZE_T_LENGTH) # define GLM_MESSAGE_FORCE_SIZE_T_LENGTH # if defined GLM_FORCE_SIZE_T_LENGTH # pragma message("GLM: .length() returns glm::length_t, a typedef of std::size_t") diff --git a/glm/detail/type_vec2.hpp b/glm/detail/type_vec2.hpp index a8b69b3d..8ab22ffe 100644 --- a/glm/detail/type_vec2.hpp +++ b/glm/detail/type_vec2.hpp @@ -4,8 +4,8 @@ #pragma once #include "type_vec.hpp" -#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED -# if GLM_LANG & GLM_LANG_CXXMS_FLAG +#if GLM_SWIZZLE == GLM_ENABLE +# if GLM_HAS_ANONYMOUS_STRUCT # include "_swizzle.hpp" # else # include "_swizzle_func.hpp" @@ -26,10 +26,7 @@ namespace glm // -- Data -- -# if GLM_HAS_ONLY_XYZW - T x, y; - -# elif GLM_LANG & GLM_LANG_CXXMS_FLAG +# if GLM_HAS_ANONYMOUS_STRUCT union { struct{ T x, y; }; @@ -38,7 +35,7 @@ namespace glm typename detail::storage<2, T, detail::is_aligned::value>::type data; -# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_SWIZZLE == GLM_ENABLE GLM_SWIZZLE2_2_MEMBERS(T, Q, x, y) GLM_SWIZZLE2_2_MEMBERS(T, Q, r, g) GLM_SWIZZLE2_2_MEMBERS(T, Q, s, t) @@ -54,9 +51,9 @@ namespace glm union {T x, r, s;}; union {T y, g, t;}; -//# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED -// GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, Q) -//# endif//GLM_SWIZZLE +# if GLM_SWIZZLE == GLM_ENABLE + GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, Q) +# endif//GLM_SWIZZLE # endif // -- Component accesses -- @@ -109,13 +106,13 @@ namespace glm GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 GLM_EXPLICIT vec(vec<2, U, P> const& v); // -- Swizzle constructors -- -# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_HAS_ANONYMOUS_STRUCT && GLM_SWIZZLE == GLM_ENABLE template GLM_FUNC_DECL vec(detail::_swizzle<2, T, Q, E0, E1,-1,-2> const& that) { *this = that(); } -# endif//GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# endif//GLM_SWIZZLE == GLM_ENABLE // -- Unary arithmetic operators -- diff --git a/glm/detail/type_vec3.hpp b/glm/detail/type_vec3.hpp index 0e854879..bfad68d8 100644 --- a/glm/detail/type_vec3.hpp +++ b/glm/detail/type_vec3.hpp @@ -4,13 +4,13 @@ #pragma once #include "type_vec.hpp" -#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED -# if GLM_LANG & GLM_LANG_CXXMS_FLAG +#if GLM_SWIZZLE == GLM_ENABLE +# if GLM_HAS_ANONYMOUS_STRUCT # include "_swizzle.hpp" # else # include "_swizzle_func.hpp" # endif -#endif //GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +#endif //GLM_SWIZZLE == GLM_ENABLE #include namespace glm @@ -26,10 +26,7 @@ namespace glm // -- Data -- -# if GLM_HAS_ONLY_XYZW - T x, y, z; - -# elif GLM_LANG & GLM_LANG_CXXMS_FLAG +# if GLM_HAS_ANONYMOUS_STRUCT union { struct{ T x, y, z; }; @@ -38,7 +35,7 @@ namespace glm typename detail::storage<3, T, detail::is_aligned::value>::type data; -# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_SWIZZLE == GLM_ENABLE GLM_SWIZZLE3_2_MEMBERS(T, Q, x, y, z) GLM_SWIZZLE3_2_MEMBERS(T, Q, r, g, b) GLM_SWIZZLE3_2_MEMBERS(T, Q, s, t, p) @@ -55,9 +52,9 @@ namespace glm union { T y, g, t; }; union { T z, b, p; }; -//# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED -// GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, Q) -//# endif//GLM_SWIZZLE +# if GLM_SWIZZLE == GLM_ENABLE + GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, Q) +# endif//GLM_SWIZZLE # endif//GLM_LANG // -- Component accesses -- @@ -127,7 +124,7 @@ namespace glm GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 GLM_EXPLICIT vec(vec<3, U, P> const& v); // -- Swizzle constructors -- -# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_HAS_ANONYMOUS_STRUCT && GLM_SWIZZLE == GLM_ENABLE template GLM_FUNC_DECL vec(detail::_swizzle<3, T, Q, E0, E1, E2, -1> const& that) { @@ -145,7 +142,7 @@ namespace glm { *this = vec(scalar, v()); } -# endif//GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# endif//GLM_HAS_ANONYMOUS_STRUCT && GLM_SWIZZLE == GLM_ENABLE // -- Unary arithmetic operators -- diff --git a/glm/detail/type_vec4.hpp b/glm/detail/type_vec4.hpp index 2de274cf..d8251e8a 100644 --- a/glm/detail/type_vec4.hpp +++ b/glm/detail/type_vec4.hpp @@ -4,8 +4,8 @@ #pragma once #include "type_vec.hpp" -#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED -# if GLM_LANG & GLM_LANG_CXXMS_FLAG +#if GLM_SWIZZLE == GLM_ENABLE +# if GLM_HAS_ANONYMOUS_STRUCT # include "_swizzle.hpp" # else # include "_swizzle_func.hpp" @@ -26,10 +26,7 @@ namespace glm // -- Data -- -# if GLM_HAS_ONLY_XYZW - T x, y, z, w; - -# elif GLM_HAS_ANONYMOUS_STRUCT +# if GLM_HAS_ANONYMOUS_STRUCT union { struct { T x, y, z, w; }; @@ -38,7 +35,7 @@ namespace glm typename detail::storage<4, T, detail::is_aligned::value>::type data; -# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_SWIZZLE == GLM_ENABLE GLM_SWIZZLE4_2_MEMBERS(T, Q, x, y, z, w) GLM_SWIZZLE4_2_MEMBERS(T, Q, r, g, b, a) GLM_SWIZZLE4_2_MEMBERS(T, Q, s, t, p, q) @@ -56,9 +53,9 @@ namespace glm union { T z, b, p; }; union { T w, a, q; }; -//# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED -// GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, Q) -//# endif//GLM_SWIZZLE +# if GLM_SWIZZLE == GLM_ENABLE + GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, Q) +# endif//GLM_SWIZZLE # endif // -- Component accesses -- @@ -178,7 +175,7 @@ namespace glm GLM_FUNC_DECL GLM_CONSTEXPR_CXX11 GLM_EXPLICIT vec(vec<4, U, P> const& v); // -- Swizzle constructors -- -# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_HAS_ANONYMOUS_STRUCT && GLM_SWIZZLE == GLM_ENABLE template GLM_FUNC_DECL vec(detail::_swizzle<4, T, Q, E0, E1, E2, E3> const& that) { @@ -220,7 +217,7 @@ namespace glm { *this = vec<4, T, Q>(x, v()); } -# endif//GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# endif//GLM_HAS_ANONYMOUS_STRUCT && GLM_SWIZZLE == GLM_ENABLE // -- Unary arithmetic operators -- diff --git a/glm/detail/type_vec4_simd.inl b/glm/detail/type_vec4_simd.inl index c4c6c768..9ce66c03 100644 --- a/glm/detail/type_vec4_simd.inl +++ b/glm/detail/type_vec4_simd.inl @@ -6,7 +6,7 @@ namespace glm{ namespace detail { -# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_SWIZZLE == GLM_ENABLE template struct _swizzle_base1<4, float, Q, E0,E1,E2,E3, true> : public _swizzle_base0 { @@ -49,7 +49,7 @@ namespace detail return Result; } }; -# endif// GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# endif// GLM_SWIZZLE == GLM_ENABLE template struct compute_vec4_add diff --git a/glm/ext/vec1.hpp b/glm/ext/vec1.hpp index 2379e590..a39ae34f 100644 --- a/glm/ext/vec1.hpp +++ b/glm/ext/vec1.hpp @@ -14,8 +14,8 @@ #include "../fwd.hpp" #include "../detail/type_vec.hpp" -#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED -# if GLM_LANG & GLM_LANG_CXXMS_FLAG +#if GLM_SWIZZLE == GLM_ENABLE +# if GLM_HAS_ANONYMOUS_STRUCT # include "../detail/_swizzle.hpp" # else # include "../detail/_swizzle_func.hpp" @@ -43,10 +43,7 @@ namespace glm // -- Data -- -# if GLM_HAS_ONLY_XYZW - T x; - -# elif GLM_LANG & GLM_LANG_CXXMS_FLAG +# if GLM_HAS_ANONYMOUS_STRUCT union { T x; @@ -55,7 +52,7 @@ namespace glm typename detail::storage<1, T, detail::is_aligned::value>::type data; /* -# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_SWIZZLE == GLM_ENABLE _GLM_SWIZZLE1_2_MEMBERS(T, Q, tvec2, x) _GLM_SWIZZLE1_2_MEMBERS(T, Q, tvec2, r) _GLM_SWIZZLE1_2_MEMBERS(T, Q, tvec2, s) @@ -70,7 +67,7 @@ namespace glm # else union {T x, r, s;}; /* -# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_SWIZZLE == GLM_ENABLE GLM_SWIZZLE_GEN_VEC_FROM_VEC1(T, Q, tvec2, tvec2, tvec3, tvec4) # endif//GLM_SWIZZLE*/ # endif @@ -113,13 +110,13 @@ namespace glm // -- Swizzle constructors -- /* -# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_HAS_ANONYMOUS_STRUCT && GLM_SWIZZLE == GLM_ENABLE template GLM_FUNC_DECL tvec(detail::_swizzle<1, T, Q, tvec1, E0, -1,-2,-3> const& that) { *this = that(); } -# endif//GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# endif//GLM_SWIZZLE == GLM_ENABLE */ // -- Unary arithmetic operators -- diff --git a/test/core/core_force_pure.cpp b/test/core/core_force_pure.cpp index 50c74752..e641a1f2 100644 --- a/test/core/core_force_pure.cpp +++ b/test/core/core_force_pure.cpp @@ -50,7 +50,7 @@ int test_vec4_ctor() } #endif -#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT { glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = A.xyzw; @@ -79,7 +79,36 @@ int test_vec4_ctor() Error += glm::all(glm::equal(A, L)) ? 0 : 1; Error += glm::all(glm::equal(A, M)) ? 0 : 1; } -#endif//GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# elif GLM_SWIZZLE == GLM_ENABLE + { + glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B = A.xyzw(); + glm::vec4 C(A.xyzw()); + glm::vec4 D(A.xyzw()); + glm::vec4 E(A.x, A.yzw()); + glm::vec4 F(A.x, A.yzw()); + glm::vec4 G(A.xyz(), A.w); + glm::vec4 H(A.xyz(), A.w); + glm::vec4 I(A.xy(), A.zw()); + glm::vec4 J(A.xy(), A.zw()); + glm::vec4 K(A.x, A.y, A.zw()); + glm::vec4 L(A.x, A.yz(), A.w); + glm::vec4 M(A.xy(), A.z, A.w); + + Error += glm::all(glm::equal(A, B)) ? 0 : 1; + Error += glm::all(glm::equal(A, C)) ? 0 : 1; + Error += glm::all(glm::equal(A, D)) ? 0 : 1; + Error += glm::all(glm::equal(A, E)) ? 0 : 1; + Error += glm::all(glm::equal(A, F)) ? 0 : 1; + Error += glm::all(glm::equal(A, G)) ? 0 : 1; + Error += glm::all(glm::equal(A, H)) ? 0 : 1; + Error += glm::all(glm::equal(A, I)) ? 0 : 1; + Error += glm::all(glm::equal(A, J)) ? 0 : 1; + Error += glm::all(glm::equal(A, K)) ? 0 : 1; + Error += glm::all(glm::equal(A, L)) ? 0 : 1; + Error += glm::all(glm::equal(A, M)) ? 0 : 1; + } +# endif//GLM_SWIZZLE == GLM_ENABLE { glm::vec4 A(1); @@ -311,7 +340,7 @@ int test_vec4_swizzle_partial() glm::vec4 A(1, 2, 3, 4); -# if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE_RELAX) +# if GLM_HAS_ANONYMOUS_STRUCT && GLM_SWIZZLE == GLM_ENABLE { glm::vec4 B(A.xy, A.zw); Error += A == B ? 0 : 1; diff --git a/test/core/core_func_swizzle.cpp b/test/core/core_func_swizzle.cpp index d0c107af..00334dbe 100644 --- a/test/core/core_func_swizzle.cpp +++ b/test/core/core_func_swizzle.cpp @@ -2,20 +2,18 @@ #define GLM_FORCE_SWIZZLE #include -#if !GLM_HAS_ONLY_XYZW - static int test_ivec2_swizzle() { int Error = 0; -#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +#if GLM_SWIZZLE == GLM_ENABLE glm::ivec2 A(1, 2); glm::ivec2 B = A.yx(); glm::ivec2 C = B.yx(); Error += A != B ? 0 : 1; Error += A == C ? 0 : 1; -#endif//GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +#endif//GLM_SWIZZLE == GLM_ENABLE return Error; } @@ -24,14 +22,14 @@ int test_ivec3_swizzle() { int Error = 0; -#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +#if GLM_SWIZZLE == GLM_ENABLE glm::ivec3 A(1, 2, 3); glm::ivec3 B = A.zyx(); glm::ivec3 C = B.zyx(); Error += A != B ? 0 : 1; Error += A == C ? 0 : 1; -#endif//GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +#endif//GLM_SWIZZLE == GLM_ENABLE return Error; } @@ -40,14 +38,14 @@ int test_ivec4_swizzle() { int Error = 0; -#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +#if GLM_SWIZZLE == GLM_ENABLE glm::ivec4 A(1, 2, 3, 4); glm::ivec4 B = A.wzyx(); glm::ivec4 C = B.wzyx(); Error += A != B ? 0 : 1; Error += A == C ? 0 : 1; -#endif//GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +#endif//GLM_SWIZZLE == GLM_ENABLE return Error; } @@ -56,7 +54,7 @@ int test_vec4_swizzle() { int Error = 0; -#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +#if GLM_SWIZZLE == GLM_ENABLE glm::vec4 A(1, 2, 3, 4); glm::vec4 B = A.wzyx(); glm::vec4 C = B.wzyx(); @@ -66,23 +64,19 @@ int test_vec4_swizzle() float f = glm::dot(C.wzyx(), C.xyzw()); Error += glm::abs(f - 20.f) < 0.01f ? 0 : 1; -#endif//GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +#endif//GLM_SWIZZLE == GLM_ENABLE return Error; } -#endif//!GLM_HAS_ONLY_XYZW int main() { int Error = 0; -# if !GLM_HAS_ONLY_XYZW - Error += test_ivec2_swizzle(); - Error += test_ivec3_swizzle(); - Error += test_ivec4_swizzle(); - - Error += test_vec4_swizzle(); -# endif//!GLM_HAS_ONLY_XYZW + Error += test_ivec2_swizzle(); + Error += test_ivec3_swizzle(); + Error += test_ivec4_swizzle(); + Error += test_vec4_swizzle(); return Error; } diff --git a/test/core/core_type_vec1.cpp b/test/core/core_type_vec1.cpp index 8f65465a..a5be3aaa 100644 --- a/test/core/core_type_vec1.cpp +++ b/test/core/core_type_vec1.cpp @@ -69,18 +69,6 @@ int test_vec1_ctor() } #endif */ -#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED - { - glm::vec2 A = glm::vec2(1.0f, 2.0f); - glm::vec2 B = A.xy; - glm::vec2 C(A.xy); - glm::vec2 D(A.xy()); - - Error += glm::all(glm::equal(A, B)) ? 0 : 1; - Error += glm::all(glm::equal(A, C)) ? 0 : 1; - Error += glm::all(glm::equal(A, D)) ? 0 : 1; - } -#endif//GLM_SWIZZLE == GLM_SWIZZLE_ENABLED { glm::vec2 A = glm::vec2(2.0f); @@ -137,6 +125,24 @@ static int test_vec1_operator_increment() return Error; } +static int test_swizzle() +{ + int Error = 0; + +#if GLM_HAS_ANONYMOUS_STRUCT && GLM_SWIZZLE == GLM_ENABLE + { + glm::vec1 A = glm::vec1(1.0f); + //glm::vec1 B = A.x; + glm::vec1 C(A.x); + + //Error += glm::all(glm::equal(A, B)) ? 0 : 1; + Error += glm::all(glm::equal(A, C)) ? 0 : 1; + } +#endif//GLM_SWIZZLE == GLM_ENABLE + + return Error; +} + static int test_constexpr() { #if GLM_HAS_CONSTEXPR_CXX14 @@ -155,6 +161,7 @@ int main() Error += test_vec1_ctor(); Error += test_vec1_operators(); Error += test_vec1_operator_increment(); + Error += test_swizzle(); Error += test_constexpr(); return Error; diff --git a/test/core/core_type_vec2.cpp b/test/core/core_type_vec2.cpp index d2832f5b..8fe85ced 100644 --- a/test/core/core_type_vec2.cpp +++ b/test/core/core_type_vec2.cpp @@ -236,19 +236,6 @@ static int test_ctor() } #endif -#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED - { - glm::vec2 A = glm::vec2(1.0f, 2.0f); - glm::vec2 B = A.xy; - glm::vec2 C(A.xy); - glm::vec2 D(A.xy()); - - Error += glm::all(glm::equal(A, B)) ? 0 : 1; - Error += glm::all(glm::equal(A, C)) ? 0 : 1; - Error += glm::all(glm::equal(A, D)) ? 0 : 1; - } -#endif//GLM_SWIZZLE == GLM_SWIZZLE_ENABLED - { glm::vec2 A = glm::vec2(2.0f); glm::vec2 B = glm::vec2(2.0f, 3.0f); @@ -357,6 +344,35 @@ static int test_constexpr() return 0; } +static int test_swizzle() +{ + int Error = 0; + +# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT + { + glm::vec2 A = glm::vec2(1.0f, 2.0f); + glm::vec2 B = A.xy; + glm::vec2 C(A.xy); + glm::vec2 D(A.xy()); + + Error += glm::all(glm::equal(A, B)) ? 0 : 1; + Error += glm::all(glm::equal(A, C)) ? 0 : 1; + Error += glm::all(glm::equal(A, D)) ? 0 : 1; + } +# elif GLM_SWIZZLE == GLM_ENABLE + { + glm::vec2 A = glm::vec2(1.0f, 2.0f); + glm::vec2 B = A.xy(); + glm::vec2 C(A.xy()); + + Error += glm::all(glm::equal(A, B)) ? 0 : 1; + Error += glm::all(glm::equal(A, C)) ? 0 : 1; + } +# endif//GLM_SWIZZLE == GLM_ENABLE + + return Error; +} + int main() { int Error = 0; @@ -365,6 +381,7 @@ int main() Error += test_ctor(); Error += test_operators(); Error += test_operator_increment(); + Error += test_swizzle(); Error += test_constexpr(); return Error; diff --git a/test/core/core_type_vec3.cpp b/test/core/core_type_vec3.cpp index 0fe2efe7..8a7d3486 100644 --- a/test/core/core_type_vec3.cpp +++ b/test/core/core_type_vec3.cpp @@ -27,7 +27,7 @@ int test_vec3_ctor() Error += std::is_copy_constructible::value ? 0 : 1; # endif -#if (GLM_HAS_INITIALIZER_LISTS) +# if GLM_HAS_INITIALIZER_LISTS { glm::vec3 a{ 0, 1, 2 }; std::vector v = { @@ -43,28 +43,7 @@ int test_vec3_ctor() {4, 5, 6}, {8, 9, 0}}; } -#endif - -#if(GLM_LANG & GLM_LANG_CXXMS_FLAG && defined(GLM_FORCE_SWIZZLE)) - { - glm::vec3 A = glm::vec3(1.0f, 2.0f, 3.0f); - glm::vec3 B = A.xyz; - glm::vec3 C(A.xyz); - glm::vec3 D(A.xyz()); - glm::vec3 E(A.x, A.yz); - glm::vec3 F(A.x, A.yz()); - glm::vec3 G(A.xy, A.z); - glm::vec3 H(A.xy(), A.z); - - Error += glm::all(glm::equal(A, B)) ? 0 : 1; - Error += glm::all(glm::equal(A, C)) ? 0 : 1; - Error += glm::all(glm::equal(A, D)) ? 0 : 1; - Error += glm::all(glm::equal(A, E)) ? 0 : 1; - Error += glm::all(glm::equal(A, F)) ? 0 : 1; - Error += glm::all(glm::equal(A, G)) ? 0 : 1; - Error += glm::all(glm::equal(A, H)) ? 0 : 1; - } -#endif//(GLM_LANG & GLM_LANG_CXXMS_FLAG && defined(GLM_FORCE_SWIZZLE)) +# endif { glm::vec3 A(1); @@ -338,7 +317,7 @@ int test_vec3_swizzle3_2() { int Error = 0; -# if(GLM_LANG & GLM_LANG_CXXMS_FLAG) +# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT glm::vec3 v(1, 2, 3); glm::vec2 u; @@ -402,7 +381,7 @@ int test_vec3_swizzle3_3() { int Error = 0; -# if(GLM_LANG & GLM_LANG_CXXMS_FLAG) +# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT glm::vec3 v(1, 2, 3); glm::vec3 u; @@ -424,7 +403,6 @@ int test_vec3_swizzle3_3() return Error; } -#if !GLM_HAS_ONLY_XYZW int test_vec3_swizzle_operators() { int Error = 0; @@ -432,7 +410,7 @@ int test_vec3_swizzle_operators() glm::vec3 u = glm::vec3(1, 2, 3); glm::vec3 v = glm::vec3(10, 20, 30); -# if(GLM_LANG & GLM_LANG_CXXMS_FLAG) +# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT glm::vec3 q; // Swizzle, swizzle binary operators @@ -469,7 +447,7 @@ int test_vec3_swizzle_functions() { int Error = 0; -# if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +# if GLM_SWIZZLE == GLM_ENABLE // NOTE: template functions cannot pick up the implicit conversion from // a swizzle to the unswizzled type, therefore the operator() must be @@ -503,7 +481,7 @@ int test_vec3_swizzle_functions() r = glm::dot(s.xyzw(), t.xyzw()); Error += (int(r) == 300) ? 0 : 1; r = glm::dot(s.xyz(), t.xyz()); Error += (int(r) == 140) ? 0 : 1; -#endif//GLM_SWIZZLE == GLM_SWIZZLE_ENABLED +#endif//GLM_SWIZZLE == GLM_ENABLE return Error; } @@ -512,9 +490,10 @@ int test_vec3_swizzle_partial() { int Error = 0; +# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT + glm::vec3 A(1, 2, 3); -# if(GLM_LANG & GLM_LANG_CXXMS_FLAG) { glm::vec3 B(A.xy, 3.0f); Error += A == B ? 0 : 1; @@ -529,15 +508,14 @@ int test_vec3_swizzle_partial() glm::vec3 B(A.xyz); Error += A == B ? 0 : 1; } -# endif//GLM_LANG +# endif//GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT return Error; } -#endif//!GLM_HAS_ONLY_XYZW static int test_operator_increment() { - int Error(0); + int Error = 0; glm::ivec3 v0(1); glm::ivec3 v1(v0); @@ -562,6 +540,53 @@ static int test_operator_increment() return Error; } +static int test_swizzle() +{ + int Error = 0; + +# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT + { + glm::vec3 A = glm::vec3(1.0f, 2.0f, 3.0f); + glm::vec3 B = A.xyz; + glm::vec3 C(A.xyz); + glm::vec3 D(A.xyz()); + glm::vec3 E(A.x, A.yz); + glm::vec3 F(A.x, A.yz()); + glm::vec3 G(A.xy, A.z); + glm::vec3 H(A.xy(), A.z); + + Error += glm::all(glm::equal(A, B)) ? 0 : 1; + Error += glm::all(glm::equal(A, C)) ? 0 : 1; + Error += glm::all(glm::equal(A, D)) ? 0 : 1; + Error += glm::all(glm::equal(A, E)) ? 0 : 1; + Error += glm::all(glm::equal(A, F)) ? 0 : 1; + Error += glm::all(glm::equal(A, G)) ? 0 : 1; + Error += glm::all(glm::equal(A, H)) ? 0 : 1; + } +# elif GLM_SWIZZLE == GLM_ENABLE + { + glm::vec3 A = glm::vec3(1.0f, 2.0f, 3.0f); + glm::vec3 B = A.xyz(); + glm::vec3 C(A.xyz()); + glm::vec3 D(A.xyz()); + glm::vec3 E(A.x, A.yz()); + glm::vec3 F(A.x, A.yz()); + glm::vec3 G(A.xy(), A.z); + glm::vec3 H(A.xy(), A.z); + + Error += glm::all(glm::equal(A, B)) ? 0 : 1; + Error += glm::all(glm::equal(A, C)) ? 0 : 1; + Error += glm::all(glm::equal(A, D)) ? 0 : 1; + Error += glm::all(glm::equal(A, E)) ? 0 : 1; + Error += glm::all(glm::equal(A, F)) ? 0 : 1; + Error += glm::all(glm::equal(A, G)) ? 0 : 1; + Error += glm::all(glm::equal(A, H)) ? 0 : 1; + } +# endif//GLM_SWIZZLE == GLM_ENABLE + + return Error; +} + static int test_constexpr() { #if GLM_HAS_CONSTEXPR_CXX14 @@ -583,16 +608,15 @@ int main() Error += test_bvec3_ctor(); Error += test_vec3_operators(); Error += test_vec3_size(); - Error += test_vec3_swizzle3_2(); - Error += test_vec3_swizzle3_3(); Error += test_operator_increment(); Error += test_constexpr(); -# if !GLM_HAS_ONLY_XYZW - Error += test_vec3_swizzle_partial(); - Error += test_vec3_swizzle_operators(); - Error += test_vec3_swizzle_functions(); -# endif//!GLM_HAS_ONLY_XYZW + Error += test_swizzle(); + Error += test_vec3_swizzle3_2(); + Error += test_vec3_swizzle3_3(); + Error += test_vec3_swizzle_partial(); + Error += test_vec3_swizzle_operators(); + Error += test_vec3_swizzle_functions(); return Error; } diff --git a/test/core/core_type_vec4.cpp b/test/core/core_type_vec4.cpp index b12ecfe3..36e35953 100644 --- a/test/core/core_type_vec4.cpp +++ b/test/core/core_type_vec4.cpp @@ -74,37 +74,6 @@ static int test_vec4_ctor() } #endif -#if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED - { - glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); - glm::vec4 B = A.xyzw; - glm::vec4 C(A.xyzw); - glm::vec4 D(A.xyzw()); - glm::vec4 E(A.x, A.yzw); - glm::vec4 F(A.x, A.yzw()); - glm::vec4 G(A.xyz, A.w); - glm::vec4 H(A.xyz(), A.w); - glm::vec4 I(A.xy, A.zw); - glm::vec4 J(A.xy(), A.zw()); - glm::vec4 K(A.x, A.y, A.zw); - glm::vec4 L(A.x, A.yz, A.w); - glm::vec4 M(A.xy, A.z, A.w); - - Error += glm::all(glm::equal(A, B)) ? 0 : 1; - Error += glm::all(glm::equal(A, C)) ? 0 : 1; - Error += glm::all(glm::equal(A, D)) ? 0 : 1; - Error += glm::all(glm::equal(A, E)) ? 0 : 1; - Error += glm::all(glm::equal(A, F)) ? 0 : 1; - Error += glm::all(glm::equal(A, G)) ? 0 : 1; - Error += glm::all(glm::equal(A, H)) ? 0 : 1; - Error += glm::all(glm::equal(A, I)) ? 0 : 1; - Error += glm::all(glm::equal(A, J)) ? 0 : 1; - Error += glm::all(glm::equal(A, K)) ? 0 : 1; - Error += glm::all(glm::equal(A, L)) ? 0 : 1; - Error += glm::all(glm::equal(A, M)) ? 0 : 1; - } -#endif// GLM_SWIZZLE == GLM_SWIZZLE_ENABLED - { glm::vec4 A(1); glm::vec4 B(1, 1, 1, 1); @@ -516,7 +485,7 @@ static int test_swizzle_partial() glm::vec4 A(1, 2, 3, 4); -# if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE_RELAX) +# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT { glm::vec4 B(A.xy, A.zw); Error += A == B ? 0 : 1; @@ -542,7 +511,74 @@ static int test_swizzle_partial() glm::vec4 B(1.0f, A.yzw); Error += A == B ? 0 : 1; } -# endif +# endif//GLM_SWIZZLE == GLM_ENABLE + + return Error; +} + +static int test_swizzle() +{ + int Error = 0; + +# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT + { + glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B = A.xyzw; + glm::vec4 C(A.xyzw); + glm::vec4 D(A.xyzw()); + glm::vec4 E(A.x, A.yzw); + glm::vec4 F(A.x, A.yzw()); + glm::vec4 G(A.xyz, A.w); + glm::vec4 H(A.xyz(), A.w); + glm::vec4 I(A.xy, A.zw); + glm::vec4 J(A.xy(), A.zw()); + glm::vec4 K(A.x, A.y, A.zw); + glm::vec4 L(A.x, A.yz, A.w); + glm::vec4 M(A.xy, A.z, A.w); + + Error += glm::all(glm::equal(A, B)) ? 0 : 1; + Error += glm::all(glm::equal(A, C)) ? 0 : 1; + Error += glm::all(glm::equal(A, D)) ? 0 : 1; + Error += glm::all(glm::equal(A, E)) ? 0 : 1; + Error += glm::all(glm::equal(A, F)) ? 0 : 1; + Error += glm::all(glm::equal(A, G)) ? 0 : 1; + Error += glm::all(glm::equal(A, H)) ? 0 : 1; + Error += glm::all(glm::equal(A, I)) ? 0 : 1; + Error += glm::all(glm::equal(A, J)) ? 0 : 1; + Error += glm::all(glm::equal(A, K)) ? 0 : 1; + Error += glm::all(glm::equal(A, L)) ? 0 : 1; + Error += glm::all(glm::equal(A, M)) ? 0 : 1; + } +# elif GLM_SWIZZLE == GLM_ENABLE + { + glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); + glm::vec4 B = A.xyzw(); + glm::vec4 C(A.xyzw()); + glm::vec4 D(A.xyzw()); + glm::vec4 E(A.x, A.yzw()); + glm::vec4 F(A.x, A.yzw()); + glm::vec4 G(A.xyz(), A.w); + glm::vec4 H(A.xyz(), A.w); + glm::vec4 I(A.xy(), A.zw()); + glm::vec4 J(A.xy(), A.zw()); + glm::vec4 K(A.x, A.y, A.zw()); + glm::vec4 L(A.x, A.yz(), A.w); + glm::vec4 M(A.xy(), A.z, A.w); + + Error += glm::all(glm::equal(A, B)) ? 0 : 1; + Error += glm::all(glm::equal(A, C)) ? 0 : 1; + Error += glm::all(glm::equal(A, D)) ? 0 : 1; + Error += glm::all(glm::equal(A, E)) ? 0 : 1; + Error += glm::all(glm::equal(A, F)) ? 0 : 1; + Error += glm::all(glm::equal(A, G)) ? 0 : 1; + Error += glm::all(glm::equal(A, H)) ? 0 : 1; + Error += glm::all(glm::equal(A, I)) ? 0 : 1; + Error += glm::all(glm::equal(A, J)) ? 0 : 1; + Error += glm::all(glm::equal(A, K)) ? 0 : 1; + Error += glm::all(glm::equal(A, L)) ? 0 : 1; + Error += glm::all(glm::equal(A, M)) ? 0 : 1; + } +# endif//GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT return Error; } @@ -782,6 +818,7 @@ int main() Error += test_size(); Error += test_operators(); Error += test_equal(); + Error += test_swizzle(); Error += test_swizzle_partial(); Error += test_simd(); Error += test_operator_increment(); diff --git a/test/gtx/gtx_io.cpp b/test/gtx/gtx_io.cpp index fb50482d..13c8722d 100644 --- a/test/gtx/gtx_io.cpp +++ b/test/gtx/gtx_io.cpp @@ -1,4 +1,6 @@ #define GLM_ENABLE_EXPERIMENTAL +#include +#if GLM_LANG & GLM_LANG_CXXMS_FLAG #include #include #include @@ -174,3 +176,11 @@ int main() return Error; } +#else + +int main() +{ + return 0; +} + +#endif// GLM_LANG & GLM_LANG_CXXMS_FLAG \ No newline at end of file