From 61e68f26679c4a225a87985573a91aae8da87d70 Mon Sep 17 00:00:00 2001 From: Christophe Riccio Date: Sat, 14 Jul 2018 19:56:13 +0200 Subject: [PATCH] Fixed swizzle functions and operators tests --- glm/detail/_swizzle.hpp | 40 ++++++------ glm/detail/type_vec4_simd.inl | 4 +- glm/ext/vec1.hpp | 3 +- test/core/core_force_pure.cpp | 8 +-- test/core/core_func_swizzle.cpp | 52 ++++++++++------ test/core/core_type_vec1.cpp | 4 +- test/core/core_type_vec2.cpp | 8 ++- test/core/core_type_vec3.cpp | 104 +++++++++++++++++--------------- test/core/core_type_vec4.cpp | 12 ++-- 9 files changed, 129 insertions(+), 106 deletions(-) diff --git a/glm/detail/_swizzle.hpp b/glm/detail/_swizzle.hpp index 2609e797..ae88f347 100644 --- a/glm/detail/_swizzle.hpp +++ b/glm/detail/_swizzle.hpp @@ -187,48 +187,48 @@ namespace detail // // Wrapper for a operand between a swizzle and a binary (e.g. 1.0f - u.xyz) // -#define GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \ - GLM_SWIZZLE_TEMPLATE1 \ - GLM_FUNC_QUALIFIER vec operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const T& b) \ - { \ - return a() OPERAND b; \ - } \ - GLM_SWIZZLE_TEMPLATE1 \ - GLM_FUNC_QUALIFIER vec operator OPERAND ( const T& a, const GLM_SWIZZLE_TYPE1& b) \ - { \ - return a OPERAND b(); \ +#define GLM_SWIZZLE_SCALAR_BINARY_OPERATOR_IMPLEMENTATION(OPERAND) \ + GLM_SWIZZLE_TEMPLATE1 \ + GLM_FUNC_QUALIFIER vec operator OPERAND ( const GLM_SWIZZLE_TYPE1& a, const T& b) \ + { \ + return a() OPERAND b; \ + } \ + GLM_SWIZZLE_TEMPLATE1 \ + GLM_FUNC_QUALIFIER vec operator OPERAND ( const T& a, const GLM_SWIZZLE_TYPE1& b) \ + { \ + return a OPERAND b(); \ } // // Macro for wrapping a function taking one argument (e.g. abs()) // -#define GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION) \ - GLM_SWIZZLE_TEMPLATE1 \ - GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a) \ - { \ - return FUNCTION(a()); \ +#define GLM_SWIZZLE_FUNCTION_1_ARGS(RETURN_TYPE,FUNCTION) \ + GLM_SWIZZLE_TEMPLATE1 \ + GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a) \ + { \ + return FUNCTION(a()); \ } // // Macro for wrapping a function taking two vector arguments (e.g. dot()). // -#define GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION) \ - GLM_SWIZZLE_TEMPLATE2 \ +#define GLM_SWIZZLE_FUNCTION_2_ARGS(RETURN_TYPE,FUNCTION) \ + GLM_SWIZZLE_TEMPLATE2 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE2& b) \ { \ return FUNCTION(a(), b()); \ } \ - GLM_SWIZZLE_TEMPLATE1 \ + GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const GLM_SWIZZLE_TYPE1& b) \ { \ return FUNCTION(a(), b()); \ } \ - GLM_SWIZZLE_TEMPLATE1 \ + GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const GLM_SWIZZLE_TYPE1& a, const typename V& b) \ { \ return FUNCTION(a(), b); \ } \ - GLM_SWIZZLE_TEMPLATE1 \ + GLM_SWIZZLE_TEMPLATE1 \ GLM_FUNC_QUALIFIER typename GLM_SWIZZLE_TYPE1::RETURN_TYPE FUNCTION(const V& a, const GLM_SWIZZLE_TYPE1& b) \ { \ return FUNCTION(a, b()); \ diff --git a/glm/detail/type_vec4_simd.inl b/glm/detail/type_vec4_simd.inl index e08e845b..db0eb3b2 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_ENABLE +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR 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_ENABLE +# endif// GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR template struct compute_vec4_add diff --git a/glm/ext/vec1.hpp b/glm/ext/vec1.hpp index a8ccdee9..2162cf02 100644 --- a/glm/ext/vec1.hpp +++ b/glm/ext/vec1.hpp @@ -65,10 +65,11 @@ namespace glm }; # else union {T x, r, s;}; - +/* # if GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION GLM_SWIZZLE_GEN_VEC_FROM_VEC1(T, Q) # endif +*/ # endif // -- Component accesses -- diff --git a/test/core/core_force_pure.cpp b/test/core/core_force_pure.cpp index e641a1f2..a362faa4 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_ENABLE && GLM_HAS_ANONYMOUS_STRUCT +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR { glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = A.xyzw; @@ -79,7 +79,7 @@ int test_vec4_ctor() Error += glm::all(glm::equal(A, L)) ? 0 : 1; Error += glm::all(glm::equal(A, M)) ? 0 : 1; } -# elif GLM_SWIZZLE == GLM_ENABLE +# elif GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR { glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = A.xyzw(); @@ -108,7 +108,7 @@ 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_ENABLE +# endif//GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR { glm::vec4 A(1); @@ -340,7 +340,7 @@ int test_vec4_swizzle_partial() glm::vec4 A(1, 2, 3, 4); -# if GLM_HAS_ANONYMOUS_STRUCT && GLM_SWIZZLE == GLM_ENABLE +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR { 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 66837eca..c3a5fac7 100644 --- a/test/core/core_func_swizzle.cpp +++ b/test/core/core_func_swizzle.cpp @@ -6,7 +6,7 @@ static int test_ivec2_swizzle() { int Error = 0; -# if GLM_SWIZZLE +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION { glm::ivec2 A(1, 2); glm::ivec2 B = A.yx(); @@ -47,7 +47,7 @@ int test_ivec3_swizzle() { int Error = 0; -# if GLM_SWIZZLE == GLM_ENABLE +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION { glm::ivec3 A(1, 2, 3); glm::ivec3 B = A.zyx(); @@ -56,7 +56,7 @@ int test_ivec3_swizzle() Error += A != B ? 0 : 1; Error += A == C ? 0 : 1; } -# endif//GLM_SWIZZLE == GLM_ENABLE +# endif # if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR { @@ -94,8 +94,16 @@ int test_ivec3_swizzle() glm::ivec3 const I = A.xxx / A.xxx; Error += I == glm::ivec3(1) ? 0 : 1; + + glm::ivec3 J(1, 2, 3); + J.xyz += glm::ivec3(1); + Error += J == glm::ivec3(2, 3, 4) ? 0 : 1; + + glm::ivec3 K(1, 2, 3); + K.xyz += A.xyz; + Error += K == glm::ivec3(2, 4, 6) ? 0 : 1; } -# endif//GLM_SWIZZLE +# endif return Error; } @@ -104,14 +112,16 @@ int test_ivec4_swizzle() { int Error = 0; -#if GLM_SWIZZLE == GLM_ENABLE - glm::ivec4 A(1, 2, 3, 4); - glm::ivec4 B = A.wzyx(); - glm::ivec4 C = B.wzyx(); +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION + { + 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_ENABLE + Error += A != B ? 0 : 1; + Error += A == C ? 0 : 1; + } +# endif return Error; } @@ -120,17 +130,19 @@ int test_vec4_swizzle() { int Error = 0; -#if GLM_SWIZZLE == GLM_ENABLE - glm::vec4 A(1, 2, 3, 4); - glm::vec4 B = A.wzyx(); - glm::vec4 C = B.wzyx(); +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION + { + glm::vec4 A(1, 2, 3, 4); + glm::vec4 B = A.wzyx(); + glm::vec4 C = B.wzyx(); - Error += A != B ? 0 : 1; - Error += A == C ? 0 : 1; + Error += A != B ? 0 : 1; + Error += A == C ? 0 : 1; - float f = glm::dot(C.wzyx(), C.xyzw()); - Error += glm::abs(f - 20.f) < 0.01f ? 0 : 1; -#endif//GLM_SWIZZLE == GLM_ENABLE + float f = glm::dot(C.wzyx(), C.xyzw()); + Error += glm::abs(f - 20.f) < 0.01f ? 0 : 1; + } +# endif return Error; } diff --git a/test/core/core_type_vec1.cpp b/test/core/core_type_vec1.cpp index a5be3aaa..d741b0c5 100644 --- a/test/core/core_type_vec1.cpp +++ b/test/core/core_type_vec1.cpp @@ -129,7 +129,7 @@ static int test_swizzle() { int Error = 0; -#if GLM_HAS_ANONYMOUS_STRUCT && GLM_SWIZZLE == GLM_ENABLE +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR { glm::vec1 A = glm::vec1(1.0f); //glm::vec1 B = A.x; @@ -138,7 +138,7 @@ static int test_swizzle() //Error += glm::all(glm::equal(A, B)) ? 0 : 1; Error += glm::all(glm::equal(A, C)) ? 0 : 1; } -#endif//GLM_SWIZZLE == GLM_ENABLE +# endif//GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR return Error; } diff --git a/test/core/core_type_vec2.cpp b/test/core/core_type_vec2.cpp index 8fe85ced..3d32d9cb 100644 --- a/test/core/core_type_vec2.cpp +++ b/test/core/core_type_vec2.cpp @@ -348,7 +348,7 @@ static int test_swizzle() { int Error = 0; -# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR { glm::vec2 A = glm::vec2(1.0f, 2.0f); glm::vec2 B = A.xy; @@ -359,7 +359,9 @@ static int test_swizzle() Error += glm::all(glm::equal(A, C)) ? 0 : 1; Error += glm::all(glm::equal(A, D)) ? 0 : 1; } -# elif GLM_SWIZZLE == GLM_ENABLE +# endif//GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR + +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION { glm::vec2 A = glm::vec2(1.0f, 2.0f); glm::vec2 B = A.xy(); @@ -368,7 +370,7 @@ static int test_swizzle() Error += glm::all(glm::equal(A, B)) ? 0 : 1; Error += glm::all(glm::equal(A, C)) ? 0 : 1; } -# endif//GLM_SWIZZLE == GLM_ENABLE +# endif//GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION return Error; } diff --git a/test/core/core_type_vec3.cpp b/test/core/core_type_vec3.cpp index 8a7d3486..f43ce2fa 100644 --- a/test/core/core_type_vec3.cpp +++ b/test/core/core_type_vec3.cpp @@ -317,8 +317,8 @@ int test_vec3_swizzle3_2() { int Error = 0; -# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT - +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR + { glm::vec3 v(1, 2, 3); glm::vec2 u; @@ -371,8 +371,8 @@ int test_vec3_swizzle3_2() v.zx = u; Error += (v.x == 2.0f && v.y == 1.0f && v.z == 1.0f) ? 0 : 1; v.zy = u; Error += (v.x == 2.0f && v.y == 2.0f && v.z == 1.0f) ? 0 : 1; //v.zz = u; //Illegal - -# endif//GLM_LANG + } +# endif//GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR return Error; } @@ -381,9 +381,10 @@ int test_vec3_swizzle3_3() { int Error = 0; -# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT - glm::vec3 v(1, 2, 3); - glm::vec3 u; +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR + { + glm::vec3 v(1, 2, 3); + glm::vec3 u; u = v; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1; @@ -398,6 +399,7 @@ int test_vec3_swizzle3_3() u = v.stp; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1; u = v.pts; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1; u.pts = v; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1; + } # endif//GLM_LANG return Error; @@ -410,7 +412,8 @@ int test_vec3_swizzle_operators() glm::vec3 u = glm::vec3(1, 2, 3); glm::vec3 v = glm::vec3(10, 20, 30); -# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR + { glm::vec3 q; // Swizzle, swizzle binary operators @@ -434,6 +437,7 @@ int test_vec3_swizzle_operators() q = (u.xyz * v); Error += (q == (u * v)) ? 0 : 1; q = (u.xxx * v); Error += (q == u.x * v) ? 0 : 1; q = (u.xyz / v); Error += (q == (u / v)) ? 0 : 1; + } # endif//GLM_LANG // Compile errors @@ -447,41 +451,41 @@ int test_vec3_swizzle_functions() { int Error = 0; -# if GLM_SWIZZLE == GLM_ENABLE +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION + { + // NOTE: template functions cannot pick up the implicit conversion from + // a swizzle to the unswizzled type, therefore the operator() must be + // used. E.g.: + // + // glm::dot(u.xy, v.xy); <--- Compile error + // glm::dot(u.xy(), v.xy()); <--- Compiles correctly - // NOTE: template functions cannot pick up the implicit conversion from - // a swizzle to the unswizzled type, therefore the operator() must be - // used. E.g.: - // - // glm::dot(u.xy, v.xy); <--- Compile error - // glm::dot(u.xy(), v.xy()); <--- Compiles correctly + float r; - float r; + // vec2 + glm::vec2 a(1, 2); + glm::vec2 b(10, 20); + r = glm::dot(a, b); Error += (int(r) == 50) ? 0 : 1; + r = glm::dot(glm::vec2(a.xy()), glm::vec2(b.xy())); Error += (int(r) == 50) ? 0 : 1; + r = glm::dot(glm::vec2(a.xy()), glm::vec2(b.yy())); Error += (int(r) == 60) ? 0 : 1; - // vec2 - glm::vec2 a(1, 2); - glm::vec2 b(10, 20); - r = glm::dot(a, b); Error += (int(r) == 50) ? 0 : 1; - r = glm::dot(glm::vec2(a.xy()), glm::vec2(b.xy())); Error += (int(r) == 50) ? 0 : 1; - r = glm::dot(glm::vec2(a.xy()), glm::vec2(b.yy())); Error += (int(r) == 60) ? 0 : 1; + // vec3 + glm::vec3 u = glm::vec3(1, 2, 3); + glm::vec3 v = glm::vec3(10, 20, 30); + r = glm::dot(u, v); Error += (int(r) == 140) ? 0 : 1; + r = glm::dot(u.xyz(), v.zyz()); Error += (int(r) == 160) ? 0 : 1; + r = glm::dot(u, v.zyx()); Error += (int(r) == 100) ? 0 : 1; + r = glm::dot(u.xyz(), v); Error += (int(r) == 140) ? 0 : 1; + r = glm::dot(u.xy(), v.xy()); Error += (int(r) == 50) ? 0 : 1; - // vec3 - glm::vec3 u = glm::vec3(1, 2, 3); - glm::vec3 v = glm::vec3(10, 20, 30); - r = glm::dot(u, v); Error += (int(r) == 140) ? 0 : 1; - r = glm::dot(u.xyz(), v.zyz()); Error += (int(r) == 160) ? 0 : 1; - r = glm::dot(u, v.zyx()); Error += (int(r) == 100) ? 0 : 1; - r = glm::dot(u.xyz(), v); Error += (int(r) == 140) ? 0 : 1; - r = glm::dot(u.xy(), v.xy()); Error += (int(r) == 50) ? 0 : 1; - - // vec4 - glm::vec4 s = glm::vec4(1, 2, 3, 4); - glm::vec4 t = glm::vec4(10, 20, 30, 40); - r = glm::dot(s, t); Error += (int(r) == 300) ? 0 : 1; - 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_ENABLE + // vec4 + glm::vec4 s = glm::vec4(1, 2, 3, 4); + glm::vec4 t = glm::vec4(10, 20, 30, 40); + r = glm::dot(s, t); Error += (int(r) == 300) ? 0 : 1; + 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_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION return Error; } @@ -490,25 +494,25 @@ 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_SWIZZLE == GLM_SWIZZLE_OPERATOR { + glm::vec3 const A(1, 2, 3); glm::vec3 B(A.xy, 3.0f); Error += A == B ? 0 : 1; } { - glm::vec3 B(1.0f, A.yz); + glm::vec3 const A(1, 2, 3); + glm::vec3 const B(1.0f, A.yz); Error += A == B ? 0 : 1; } { - glm::vec3 B(A.xyz); + glm::vec3 const A(1, 2, 3); + glm::vec3 const B(A.xyz); Error += A == B ? 0 : 1; } -# endif//GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT +# endif//GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR return Error; } @@ -544,7 +548,7 @@ static int test_swizzle() { int Error = 0; -# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR { glm::vec3 A = glm::vec3(1.0f, 2.0f, 3.0f); glm::vec3 B = A.xyz; @@ -563,7 +567,9 @@ static int test_swizzle() Error += glm::all(glm::equal(A, G)) ? 0 : 1; Error += glm::all(glm::equal(A, H)) ? 0 : 1; } -# elif GLM_SWIZZLE == GLM_ENABLE +# endif//GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR + +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION { glm::vec3 A = glm::vec3(1.0f, 2.0f, 3.0f); glm::vec3 B = A.xyz(); @@ -582,7 +588,7 @@ static int test_swizzle() Error += glm::all(glm::equal(A, G)) ? 0 : 1; Error += glm::all(glm::equal(A, H)) ? 0 : 1; } -# endif//GLM_SWIZZLE == GLM_ENABLE +# endif//GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION return Error; } diff --git a/test/core/core_type_vec4.cpp b/test/core/core_type_vec4.cpp index b126b61a..b2e32951 100644 --- a/test/core/core_type_vec4.cpp +++ b/test/core/core_type_vec4.cpp @@ -485,7 +485,7 @@ static int test_swizzle_partial() glm::vec4 A(1, 2, 3, 4); -# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR { glm::vec4 B(A.xy, A.zw); Error += A == B ? 0 : 1; @@ -511,7 +511,7 @@ static int test_swizzle_partial() glm::vec4 B(1.0f, A.yzw); Error += A == B ? 0 : 1; } -# endif//GLM_SWIZZLE == GLM_ENABLE +# endif//GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION return Error; } @@ -520,7 +520,7 @@ static int test_swizzle() { int Error = 0; -# if GLM_SWIZZLE == GLM_ENABLE && GLM_HAS_ANONYMOUS_STRUCT +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR { glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = A.xyzw; @@ -549,7 +549,9 @@ static int test_swizzle() Error += glm::all(glm::equal(A, L)) ? 0 : 1; Error += glm::all(glm::equal(A, M)) ? 0 : 1; } -# elif GLM_SWIZZLE == GLM_ENABLE +# endif//GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR + +# if GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION { glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 B = A.xyzw(); @@ -578,7 +580,7 @@ static int test_swizzle() 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 +# endif//GLM_SWIZZLE == GLM_SWIZZLE_OPERATOR || GLM_SWIZZLE == GLM_SWIZZLE_FUNCTION return Error; }