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

- Added GLM_FORCE_UNRESTRICTED_GENTYPE allowing non basic genType #543

Browse Source
This commit is contained in:
Christophe Riccio 2016-09-01 23:32:12 +02:00
parent 1c5fd06c2d
commit 10dc67e2b5
12 changed files with 56 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
glm/detail/setup.hpp
View File

@ -524,11 +524,21 @@
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
// Swizzle operators // Swizzle operators
// User defines: GLM_SWIZZLE // User defines: GLM_FORCE_SWIZZLE
#define GLM_SWIZZLE_ENABLED 1
#define GLM_SWIZZLE_DISABLE 0
#if defined(GLM_FORCE_SWIZZLE) || defined(GLM_SWIZZLE)
#undef GLM_SWIZZLE
#define GLM_SWIZZLE GLM_SWIZZLE_ENABLED
#else
#undef GLM_SWIZZLE
#define GLM_SWIZZLE GLM_SWIZZLE_DISABLE
#endif
#if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED) #if defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_SWIZZLE_DISPLAYED)
# define GLM_MESSAGE_SWIZZLE_DISPLAYED # define GLM_MESSAGE_SWIZZLE_DISPLAYED
# if defined(GLM_SWIZZLE) # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
# pragma message("GLM: Swizzling operators enabled") # pragma message("GLM: Swizzling operators enabled")
# else # else
# pragma message("GLM: Swizzling operators disabled, #define GLM_SWIZZLE to enable swizzle operators") # pragma message("GLM: Swizzling operators disabled, #define GLM_SWIZZLE to enable swizzle operators")
@ -551,6 +561,11 @@
# define GLM_DEPTH_CLIP_SPACE GLM_DEPTH_NEGATIVE_ONE_TO_ONE # define GLM_DEPTH_CLIP_SPACE GLM_DEPTH_NEGATIVE_ONE_TO_ONE
#endif #endif
///////////////////////////////////////////////////////////////////////////////////
// Allows using not basic types as genType
// #define GLM_FORCE_UNRESTRICTED_GENTYPE
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
// Coordinate system, define GLM_FORCE_LEFT_HANDED before including GLM // Coordinate system, define GLM_FORCE_LEFT_HANDED before including GLM
// to use left handed coordinate system by default. // to use left handed coordinate system by default.
@ -617,7 +632,7 @@
# define GLM_VECTOR_CALL # define GLM_VECTOR_CALL
#endif//GLM_COMPILER #endif//GLM_COMPILER
#if GLM_HAS_DEFAULTED_FUNCTIONS #if GLM_HAS_DEFAULTED_FUNCTIONS && !defined(GLM_FORCE_UNRESTRICTED_GENTYPE)
# define GLM_DEFAULT = default # define GLM_DEFAULT = default
# ifdef GLM_FORCE_NO_CTOR_INIT # ifdef GLM_FORCE_NO_CTOR_INIT
# define GLM_DEFAULT_CTOR = default # define GLM_DEFAULT_CTOR = default

10
glm/detail/type_vec1.hpp
View File

@ -5,7 +5,7 @@
#include "../fwd.hpp" #include "../fwd.hpp"
#include "type_vec.hpp" #include "type_vec.hpp"
#ifdef GLM_SWIZZLE #if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
# if GLM_HAS_UNRESTRICTED_UNIONS # if GLM_HAS_UNRESTRICTED_UNIONS
# include "_swizzle.hpp" # include "_swizzle.hpp"
# else # else
@ -44,7 +44,7 @@ namespace glm
T r; T r;
T s; T s;
/* /*
# ifdef GLM_SWIZZLE # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
_GLM_SWIZZLE1_2_MEMBERS(T, P, tvec2, x) _GLM_SWIZZLE1_2_MEMBERS(T, P, tvec2, x)
_GLM_SWIZZLE1_2_MEMBERS(T, P, tvec2, r) _GLM_SWIZZLE1_2_MEMBERS(T, P, tvec2, r)
_GLM_SWIZZLE1_2_MEMBERS(T, P, tvec2, s) _GLM_SWIZZLE1_2_MEMBERS(T, P, tvec2, s)
@ -66,7 +66,7 @@ namespace glm
# else # else
union {T x, r, s;}; union {T x, r, s;};
/* /*
# ifdef GLM_SWIZZLE # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
GLM_SWIZZLE_GEN_VEC_FROM_VEC1(T, P, tvec2, tvec2, tvec3, tvec4) GLM_SWIZZLE_GEN_VEC_FROM_VEC1(T, P, tvec2, tvec2, tvec3, tvec4)
# endif//GLM_SWIZZLE*/ # endif//GLM_SWIZZLE*/
# endif # endif
@ -110,13 +110,13 @@ namespace glm
// -- Swizzle constructors -- // -- Swizzle constructors --
/* /*
# if(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)) # if(GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED))
template <int E0> template <int E0>
GLM_FUNC_DECL tvec1(detail::_swizzle<1, T, P, tvec1, E0, -1,-2,-3> const & that) GLM_FUNC_DECL tvec1(detail::_swizzle<1, T, P, tvec1, E0, -1,-2,-3> const & that)
{ {
*this = that(); *this = that();
} }
# endif//(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)) # endif//(GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED))
*/ */
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --

10
glm/detail/type_vec2.hpp
View File

@ -4,7 +4,7 @@
#pragma once #pragma once
#include "type_vec.hpp" #include "type_vec.hpp"
#ifdef GLM_SWIZZLE #if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
# if GLM_HAS_UNRESTRICTED_UNIONS # if GLM_HAS_UNRESTRICTED_UNIONS
# include "_swizzle.hpp" # include "_swizzle.hpp"
# else # else
@ -43,7 +43,7 @@ namespace glm
struct{ T r, g; }; struct{ T r, g; };
struct{ T s, t; }; struct{ T s, t; };
# ifdef GLM_SWIZZLE # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
_GLM_SWIZZLE2_2_MEMBERS(T, P, glm::tvec2, x, y) _GLM_SWIZZLE2_2_MEMBERS(T, P, glm::tvec2, x, y)
_GLM_SWIZZLE2_2_MEMBERS(T, P, glm::tvec2, r, g) _GLM_SWIZZLE2_2_MEMBERS(T, P, glm::tvec2, r, g)
_GLM_SWIZZLE2_2_MEMBERS(T, P, glm::tvec2, s, t) _GLM_SWIZZLE2_2_MEMBERS(T, P, glm::tvec2, s, t)
@ -67,7 +67,7 @@ namespace glm
union {T x, r, s;}; union {T x, r, s;};
union {T y, g, t;}; union {T y, g, t;};
# ifdef GLM_SWIZZLE # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P, tvec2, tvec2, tvec3, tvec4) GLM_SWIZZLE_GEN_VEC_FROM_VEC2(T, P, tvec2, tvec2, tvec3, tvec4)
# endif//GLM_SWIZZLE # endif//GLM_SWIZZLE
# endif # endif
@ -116,13 +116,13 @@ namespace glm
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec2(tvec2<U, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec2(tvec2<U, Q> const & v);
// -- Swizzle constructors -- // -- Swizzle constructors --
# if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE) # if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
template <int E0, int E1> template <int E0, int E1>
GLM_FUNC_DECL tvec2(detail::_swizzle<2, T, P, glm::tvec2, E0, E1,-1,-2> const& that) GLM_FUNC_DECL tvec2(detail::_swizzle<2, T, P, glm::tvec2, E0, E1,-1,-2> const& that)
{ {
*this = that(); *this = that();
} }
# endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE) # endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --

12
glm/detail/type_vec3.hpp
View File

@ -4,13 +4,13 @@
#pragma once #pragma once
#include "type_vec.hpp" #include "type_vec.hpp"
#ifdef GLM_SWIZZLE #if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
# if GLM_HAS_UNRESTRICTED_UNIONS # if GLM_HAS_UNRESTRICTED_UNIONS
# include "_swizzle.hpp" # include "_swizzle.hpp"
# else # else
# include "_swizzle_func.hpp" # include "_swizzle_func.hpp"
# endif # endif
#endif //GLM_SWIZZLE #endif //GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
#include <cstddef> #include <cstddef>
namespace glm namespace glm
@ -43,7 +43,7 @@ namespace glm
struct{ T r, g, b; }; struct{ T r, g, b; };
struct{ T s, t, p; }; struct{ T s, t, p; };
# ifdef GLM_SWIZZLE # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
_GLM_SWIZZLE3_2_MEMBERS(T, P, glm::tvec2, x, y, z) _GLM_SWIZZLE3_2_MEMBERS(T, P, glm::tvec2, x, y, z)
_GLM_SWIZZLE3_2_MEMBERS(T, P, glm::tvec2, r, g, b) _GLM_SWIZZLE3_2_MEMBERS(T, P, glm::tvec2, r, g, b)
_GLM_SWIZZLE3_2_MEMBERS(T, P, glm::tvec2, s, t, p) _GLM_SWIZZLE3_2_MEMBERS(T, P, glm::tvec2, s, t, p)
@ -67,7 +67,7 @@ namespace glm
union { T y, g, t; }; union { T y, g, t; };
union { T z, b, p; }; union { T z, b, p; };
# ifdef GLM_SWIZZLE # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P, tvec3, tvec2, tvec3, tvec4) GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P, tvec3, tvec2, tvec3, tvec4)
# endif//GLM_SWIZZLE # endif//GLM_SWIZZLE
# endif//GLM_LANG # endif//GLM_LANG
@ -125,7 +125,7 @@ namespace glm
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec3(tvec3<U, Q> const & v); GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec3(tvec3<U, Q> const & v);
// -- Swizzle constructors -- // -- Swizzle constructors --
# if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE) # if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
template <int E0, int E1, int E2> template <int E0, int E1, int E2>
GLM_FUNC_DECL tvec3(detail::_swizzle<3, T, P, glm::tvec3, E0, E1, E2, -1> const & that) GLM_FUNC_DECL tvec3(detail::_swizzle<3, T, P, glm::tvec3, E0, E1, E2, -1> const & that)
{ {
@ -143,7 +143,7 @@ namespace glm
{ {
*this = tvec3<T, P>(scalar, v()); *this = tvec3<T, P>(scalar, v());
} }
# endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE) # endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --

10
glm/detail/type_vec4.hpp
View File

@ -4,7 +4,7 @@
#pragma once #pragma once
#include "type_vec.hpp" #include "type_vec.hpp"
#ifdef GLM_SWIZZLE #if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
# if GLM_HAS_UNRESTRICTED_UNIONS # if GLM_HAS_UNRESTRICTED_UNIONS
# include "_swizzle.hpp" # include "_swizzle.hpp"
# else # else
@ -45,7 +45,7 @@ namespace glm
typename detail::storage<T, sizeof(T) * 4, detail::is_aligned<P>::value>::type data; typename detail::storage<T, sizeof(T) * 4, detail::is_aligned<P>::value>::type data;
# ifdef GLM_SWIZZLE # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
_GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, x, y, z, w) _GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, x, y, z, w)
_GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, r, g, b, a) _GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, r, g, b, a)
_GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, s, t, p, q) _GLM_SWIZZLE4_2_MEMBERS(T, P, glm::tvec2, s, t, p, q)
@ -70,7 +70,7 @@ namespace glm
union { T z, b, p; }; union { T z, b, p; };
union { T w, a, q; }; union { T w, a, q; };
# ifdef GLM_SWIZZLE # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, tvec4, tvec2, tvec3, tvec4) GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, tvec4, tvec2, tvec3, tvec4)
# endif//GLM_SWIZZLE # endif//GLM_SWIZZLE
# endif # endif
@ -146,7 +146,7 @@ namespace glm
GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec4(tvec4<U, Q> const& v); GLM_FUNC_DECL GLM_CONSTEXPR GLM_EXPLICIT tvec4(tvec4<U, Q> const& v);
// -- Swizzle constructors -- // -- Swizzle constructors --
# if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE) # if GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
template <int E0, int E1, int E2, int E3> template <int E0, int E1, int E2, int E3>
GLM_FUNC_DECL tvec4(detail::_swizzle<4, T, P, glm::tvec4, E0, E1, E2, E3> const & that) GLM_FUNC_DECL tvec4(detail::_swizzle<4, T, P, glm::tvec4, E0, E1, E2, E3> const & that)
{ {
@ -188,7 +188,7 @@ namespace glm
{ {
*this = tvec4<T, P>(x, v()); *this = tvec4<T, P>(x, v());
} }
# endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE) # endif// GLM_HAS_UNRESTRICTED_UNIONS && (GLM_SWIZZLE == GLM_SWIZZLE_ENABLED)
// -- Unary arithmetic operators -- // -- Unary arithmetic operators --

4
glm/detail/type_vec4_simd.inl
View File

@ -6,7 +6,7 @@
namespace glm{ namespace glm{
namespace detail namespace detail
{ {
# ifdef GLM_SWIZZLE # if GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
template <precision P, int E0, int E1, int E2, int E3> template <precision P, int E0, int E1, int E2, int E3>
struct _swizzle_base1<4, float, P, glm::tvec4, E0,E1,E2,E3, true> : public _swizzle_base0<float, 4> struct _swizzle_base1<4, float, P, glm::tvec4, E0,E1,E2,E3, true> : public _swizzle_base0<float, 4>
{ {
@ -49,7 +49,7 @@ namespace detail
return Result; return Result;
} }
}; };
# endif//GLM_SWIZZLE # endif// GLM_SWIZZLE == GLM_SWIZZLE_ENABLED
template <precision P> template <precision P>
struct compute_vec4_add<float, P, true> struct compute_vec4_add<float, P, true>

2
readme.md
View File

@ -68,6 +68,7 @@ glm::mat4 camera(float Translate, glm::vec2 const & Rotate)
- Added GTC_functions extension - Added GTC_functions extension
- Added quaternion version of isnan and isinf #521 - Added quaternion version of isnan and isinf #521
- Added lowestBitValue to GTX_bit #536 - Added lowestBitValue to GTX_bit #536
- Added GLM_FORCE_UNRESTRICTED_GENTYPE allowing non basic genType #543
##### Improvements: ##### Improvements:
- Improved SIMD and swizzle operators interactions with GCC and Clang #474 - Improved SIMD and swizzle operators interactions with GCC and Clang #474
@ -99,6 +100,7 @@ glm::mat4 camera(float Translate, glm::vec2 const & Rotate)
- Deprecated GLM_GTX_simd_vec4 extension - Deprecated GLM_GTX_simd_vec4 extension
- Deprecated GLM_GTX_simd_mat4 extension - Deprecated GLM_GTX_simd_mat4 extension
- Deprecated GLM_GTX_simd_quat extension - Deprecated GLM_GTX_simd_quat extension
- Deprecated GLM_SWIZZLE, use GLM_FORCE_SWIZZLE instead
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
#### [GLM 0.9.7.6](https://github.com/g-truc/glm/releases/tag/0.9.7.6) - 2016-07-16 #### [GLM 0.9.7.6](https://github.com/g-truc/glm/releases/tag/0.9.7.6) - 2016-07-16

2
test/core/core_func_swizzle.cpp
View File

@ -1,5 +1,5 @@
#define GLM_MESSAGES #define GLM_MESSAGES
#define GLM_SWIZZLE #define GLM_FORCE_SWIZZLE
#include <glm/glm.hpp> #include <glm/glm.hpp>
int test_ivec2_swizzle() int test_ivec2_swizzle()

6
test/core/core_type_vec1.cpp
View File

@ -1,4 +1,4 @@
#define GLM_SWIZZLE #define GLM_FORCE_SWIZZLE
#include <glm/vector_relational.hpp> #include <glm/vector_relational.hpp>
#include <glm/gtc/vec1.hpp> #include <glm/gtc/vec1.hpp>
#include <vector> #include <vector>
@ -65,7 +65,7 @@ int test_vec1_ctor()
} }
#endif #endif
*/ */
#if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE) #if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
{ {
glm::vec2 A = glm::vec2(1.0f, 2.0f); glm::vec2 A = glm::vec2(1.0f, 2.0f);
glm::vec2 B = A.xy; glm::vec2 B = A.xy;
@ -76,7 +76,7 @@ int test_vec1_ctor()
Error += glm::all(glm::equal(A, C)) ? 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, D)) ? 0 : 1;
} }
#endif//GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE) #endif//GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
{ {
glm::vec2 A = glm::vec2(2.0f); glm::vec2 A = glm::vec2(2.0f);

6
test/core/core_type_vec2.cpp
View File

@ -1,4 +1,4 @@
#define GLM_SWIZZLE #define GLM_FORCE_SWIZZLE
#include <glm/vector_relational.hpp> #include <glm/vector_relational.hpp>
#include <glm/vec2.hpp> #include <glm/vec2.hpp>
#include <vector> #include <vector>
@ -230,7 +230,7 @@ int test_vec2_ctor()
} }
#endif #endif
#if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE) #if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
{ {
glm::vec2 A = glm::vec2(1.0f, 2.0f); glm::vec2 A = glm::vec2(1.0f, 2.0f);
glm::vec2 B = A.xy; glm::vec2 B = A.xy;
@ -241,7 +241,7 @@ int test_vec2_ctor()
Error += glm::all(glm::equal(A, C)) ? 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, D)) ? 0 : 1;
} }
#endif//GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE) #endif//GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
{ {
glm::vec2 A = glm::vec2(2.0f); glm::vec2 A = glm::vec2(2.0f);

6
test/core/core_type_vec3.cpp
View File

@ -1,4 +1,4 @@
#define GLM_SWIZZLE #define GLM_FORCE_SWIZZLE
#include <glm/vector_relational.hpp> #include <glm/vector_relational.hpp>
#include <glm/geometric.hpp> #include <glm/geometric.hpp>
#include <glm/vec2.hpp> #include <glm/vec2.hpp>
@ -40,7 +40,7 @@ int test_vec3_ctor()
} }
#endif #endif
#if(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)) #if(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE))
{ {
glm::vec3 A = glm::vec3(1.0f, 2.0f, 3.0f); glm::vec3 A = glm::vec3(1.0f, 2.0f, 3.0f);
glm::vec3 B = A.xyz; glm::vec3 B = A.xyz;
@ -59,7 +59,7 @@ int test_vec3_ctor()
Error += glm::all(glm::equal(A, G)) ? 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, H)) ? 0 : 1;
} }
#endif//(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE)) #endif//(GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE))
{ {
glm::vec3 A(1); glm::vec3 A(1);

6
test/core/core_type_vec4.cpp
View File

@ -1,5 +1,5 @@
#define GLM_FORCE_ALIGNED #define GLM_FORCE_ALIGNED
#define GLM_SWIZZLE #define GLM_FORCE_SWIZZLE
#include <glm/vector_relational.hpp> #include <glm/vector_relational.hpp>
#include <glm/vec2.hpp> #include <glm/vec2.hpp>
#include <glm/vec3.hpp> #include <glm/vec3.hpp>
@ -68,7 +68,7 @@ int test_vec4_ctor()
} }
#endif #endif
#if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE) #if GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
{ {
glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f); glm::vec4 A = glm::vec4(1.0f, 2.0f, 3.0f, 4.0f);
glm::vec4 B = A.xyzw; glm::vec4 B = A.xyzw;
@ -97,7 +97,7 @@ int test_vec4_ctor()
Error += glm::all(glm::equal(A, L)) ? 0 : 1; Error += glm::all(glm::equal(A, L)) ? 0 : 1;
Error += glm::all(glm::equal(A, M)) ? 0 : 1; Error += glm::all(glm::equal(A, M)) ? 0 : 1;
} }
#endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_SWIZZLE) #endif// GLM_HAS_UNRESTRICTED_UNIONS && defined(GLM_FORCE_SWIZZLE)
{ {
glm::vec4 A(1); glm::vec4 A(1);