From 5050bfacf766637bd66ec020c76d886d6eb19abe Mon Sep 17 00:00:00 2001 From: Christophe Riccio Date: Thu, 20 Oct 2011 14:03:08 +0100 Subject: [PATCH] Fixed setup options --- glm/core/func_common.inl | 2 +- glm/core/setup.hpp | 95 +++++++++++++++++---------------- glm/core/type_half.inl | 24 ++++----- glm/core/type_vec2.hpp | 28 +++++----- glm/core/type_vec3.hpp | 28 +++++----- glm/core/type_vec4.hpp | 28 +++++----- glm/gtx/string_cast.inl | 2 +- test/core/core_func_swizzle.cpp | 5 +- test/core/core_type_half.cpp | 12 ++--- test/core/core_type_vec1.cpp | 2 +- test/core/core_type_vec2.cpp | 2 +- test/core/core_type_vec3.cpp | 26 ++++----- test/core/core_type_vec4.cpp | 6 +-- 13 files changed, 132 insertions(+), 128 deletions(-) diff --git a/glm/core/func_common.inl b/glm/core/func_common.inl index 430708bb..e449714d 100644 --- a/glm/core/func_common.inl +++ b/glm/core/func_common.inl @@ -100,7 +100,7 @@ namespace detail template <> GLM_FUNC_QUALIFIER detail::thalf floor(detail::thalf const & x) { - return detail::thalf(::std::floor(x.toFloat())); + return detail::thalf(::std::floor(float(x))); } template diff --git a/glm/core/setup.hpp b/glm/core/setup.hpp index 8d2a83f3..1a135dc2 100644 --- a/glm/core/setup.hpp +++ b/glm/core/setup.hpp @@ -300,13 +300,13 @@ // User defines: GLM_FORCE_CXX98 -#define GLM_LANG_CXX 0 -#define GLM_LANG_CXX98 1 -#define GLM_LANG_CXX03 2 -#define GLM_LANG_CXX0X 3 -#define GLM_LANG_CXX11 4 -#define GLM_LANG_CXXMS 5 -#define GLM_LANG_CXXGNU 6 +#define GLM_LANG_CXX (0 << 0) +#define GLM_LANG_CXX98 ((1 << 1) | GLM_LANG_CXX) +#define GLM_LANG_CXX03 ((1 << 2) | GLM_LANG_CXX98) +#define GLM_LANG_CXX0X ((1 << 3) | GLM_LANG_CXX03) +#define GLM_LANG_CXX11 ((1 << 4) | GLM_LANG_CXX11) +#define GLM_LANG_CXXMS (1 << 5) +#define GLM_LANG_CXXGNU (1 << 6) #if(defined(GLM_FORCE_CXX11)) # define GLM_LANG GLM_LANG_CXX11 @@ -314,20 +314,22 @@ # define GLM_LANG GLM_LANG_CXX03 #elif(defined(GLM_FORCE_CXX98)) # define GLM_LANG GLM_LANG_CXX98 -#elif(((GLM_COMPILER & GLM_COMPILER_GCC) == GLM_COMPILER_GCC) && defined(__STRICT_ANSI__)) -# define GLM_LANG GLM_LANG_CXX98 -#elif(((GLM_COMPILER & GLM_COMPILER_GCC) == GLM_COMPILER_GCC) && defined(__GXX_EXPERIMENTAL_CXX0X__)) // -std=c++0x or -std=gnu++0x -# define GLM_LANG GLM_LANG_CXX0X -#elif(((GLM_COMPILER & GLM_COMPILER_VC) == GLM_COMPILER_VC) && defined(_MSC_EXTENSIONS)) -# define GLM_LANG GLM_LANG_CXXMS -#elif(((GLM_COMPILER & GLM_COMPILER_VC) == GLM_COMPILER_VC) && !defined(_MSC_EXTENSIONS)) -# if(GLM_COMPILER >= GLM_COMPILER_VC2010) -# define GLM_LANG GLM_LANG_CXX0X -# else -# define GLM_LANG GLM_LANG_CXX98 -# endif//(GLM_COMPILER == GLM_COMPILER_VC2010) #else -# define GLM_LANG GLM_LANG_CXX +# if(((GLM_COMPILER & GLM_COMPILER_GCC) == GLM_COMPILER_GCC) && defined(__STRICT_ANSI__)) +# define GLM_LANG GLM_LANG_CXX98 +# elif(((GLM_COMPILER & GLM_COMPILER_GCC) == GLM_COMPILER_GCC) && defined(__GXX_EXPERIMENTAL_CXX0X__)) // -std=c++0x or -std=gnu++0x +# define GLM_LANG GLM_LANG_CXX0X +# elif(((GLM_COMPILER & GLM_COMPILER_VC) == GLM_COMPILER_VC) && defined(_MSC_EXTENSIONS)) +# define GLM_LANG GLM_LANG_CXXMS +# elif(((GLM_COMPILER & GLM_COMPILER_VC) == GLM_COMPILER_VC) && !defined(_MSC_EXTENSIONS)) +# if(GLM_COMPILER >= GLM_COMPILER_VC2010) +# define GLM_LANG GLM_LANG_CXX0X +# else +# define GLM_LANG GLM_LANG_CXX98 +# endif//(GLM_COMPILER == GLM_COMPILER_VC2010) +# else +# define GLM_LANG GLM_LANG_CXX +# endif #endif #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_LANG_DISPLAYED)) @@ -430,38 +432,46 @@ # endif//GLM_ARCH #endif//GLM_MESSAGE +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Support check macros + +#define GLM_SUPPORT_ANONYMOUS_UNION() \ + ((GLM_LANG & GLM_LANG_CXX98) == GLM_LANG_CXX98) + +#define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() \ + (((GLM_LANG & GLM_LANG_CXX11) == GLM_LANG_CXX11) || ((GLM_LANG & GLM_LANG_CXXMS) == GLM_LANG_CXXMS) || ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_LANG == GLM_LANG_CXX0X))) + +#define GLM_SUPPORT_SWIZZLE_OPERATOR() \ + (defined(GLM_SWIZZLE) && GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE()) + +#define GLM_SUPPORT_SWIZZLE_FUNCTION() defined(GLM_SWIZZLE) + /////////////////////////////////////////////////////////////////////////////////////////////////// // Components //#define GLM_FORCE_ONLY_XYZW -#define GLM_COMPONENT_GLSL_NAMES 0 -#define GLM_COMPONENT_ONLY_XYZW 1 // To disable multiple vector component names access. -#define GLM_COMPONENT_MS_EXT 2 // To use anonymous union to provide multiple component names access for class valType. Visual C++ only. +#define GLM_COMPONENT_ONLY_XYZW 0 // To disable multiple vector component names access. +#define GLM_COMPONENT_CXX98 1 // +#define GLM_COMPONENT_CXX11 2 // To use anonymous union to provide multiple component names access for class valType. Visual C++ only. -#ifndef GLM_FORCE_ONLY_XYZW -# if((GLM_COMPILER & GLM_COMPILER_VC) && defined(_MSC_EXTENSIONS)) -# define GLM_COMPONENT GLM_COMPONENT_MS_EXT -# else -# define GLM_COMPONENT GLM_COMPONENT_GLSL_NAMES -# endif +#if(GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() && !defined(GLM_FORCE_ONLY_XYZW)) +# define GLM_COMPONENT GLM_COMPONENT_CXX11 +#elif(GLM_SUPPORT_ANONYMOUS_UNION() && !defined(GLM_FORCE_ONLY_XYZW)) +# define GLM_COMPONENT GLM_COMPONENT_CXX98 #else # define GLM_COMPONENT GLM_COMPONENT_ONLY_XYZW #endif -#if((GLM_COMPONENT == GLM_COMPONENT_MS_EXT) && !(GLM_COMPILER & GLM_COMPILER_VC)) -# error "GLM_COMPONENT value is GLM_COMPONENT_MS_EXT but this is not allowed with the current compiler." -#endif - #if(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPONENT_DISPLAYED)) # define GLM_MESSAGE_COMPONENT_DISPLAYED -# if(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES) -# pragma message("GLM: GLSL multiple vector component names") +# if(GLM_COMPONENT == GLM_COMPONENT_CXX98) +# pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names except of half based vector types") # elif(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW) -# pragma message("GLM: x,y,z,w vector component names only") -# elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT) -# pragma message("GLM: Multiple vector component names through Visual C++ language extensions") +# pragma message("GLM: x,y,z,w component names for all vector types") +# elif(GLM_COMPONENT == GLM_COMPONENT_CXX11) +# pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names for all vector types") # else -# error "GLM_COMPONENT value unknown" +# error "GLM: GLM_COMPONENT value unknown" # endif//GLM_MESSAGE_COMPONENT_DISPLAYED #endif//GLM_MESSAGE @@ -513,13 +523,6 @@ #define GLM_FUNC_DECL GLM_CUDA_FUNC_DECL #define GLM_FUNC_QUALIFIER GLM_CUDA_FUNC_DEF GLM_INLINE -/////////////////////////////////////////////////////////////////////////////////////////////////// -// Support check macros - -#define GLM_SUPPORT_SWIZZLE_OPERATOR() (defined(GLM_SWIZZLE) && \ - ((GLM_LANG == GLM_LANG_CXX11) || (GLM_LANG == GLM_LANG_CXXMS) || ((GLM_COMPILER & GLM_COMPILER_GCC) && (GLM_LANG == GLM_LANG_CXX0X)))) -#define GLM_SUPPORT_SWIZZLE_FUNCTION() defined(GLM_SWIZZLE) - /////////////////////////////////////////////////////////////////////////////////////////////////// // Swizzle operators diff --git a/glm/core/type_half.inl b/glm/core/type_half.inl index 5d482ef2..50b62025 100644 --- a/glm/core/type_half.inl +++ b/glm/core/type_half.inl @@ -272,7 +272,7 @@ namespace detail template GLM_FUNC_QUALIFIER thalf::operator U() const { - return static_cast(this->toFloat()); + return static_cast(toFloat32(this->data)); } // Unary updatable operators @@ -325,38 +325,38 @@ namespace detail GLM_FUNC_QUALIFIER detail::thalf operator+ (detail::thalf const & s1, detail::thalf const & s2) { - return detail::thalf(s1.toFloat() + s2.toFloat()); + return detail::thalf(float(s1) + float(s2)); } GLM_FUNC_QUALIFIER detail::thalf operator- (detail::thalf const & s1, detail::thalf const & s2) { - return detail::thalf(s1.toFloat() - s2.toFloat()); + return detail::thalf(float(s1) - float(s2)); } GLM_FUNC_QUALIFIER detail::thalf operator* (detail::thalf const & s1, detail::thalf const & s2) { - return detail::thalf(s1.toFloat() * s2.toFloat()); + return detail::thalf(float(s1) * float(s2)); } GLM_FUNC_QUALIFIER detail::thalf operator/ (detail::thalf const & s1, detail::thalf const & s2) { - return detail::thalf(s1.toFloat() / s2.toFloat()); + return detail::thalf(float(s1) / float(s2)); } // Unary constant operators GLM_FUNC_QUALIFIER detail::thalf operator- (detail::thalf const & s) { - return detail::thalf(-s.toFloat()); + return detail::thalf(-float(s)); } GLM_FUNC_QUALIFIER detail::thalf operator-- (detail::thalf const & s, int) { - return detail::thalf(s.toFloat() - 1.0f); + return detail::thalf(float(s) - 1.0f); } GLM_FUNC_QUALIFIER detail::thalf operator++ (detail::thalf const & s, int) { - return detail::thalf(s.toFloat() + 1.0f); + return detail::thalf(float(s) + 1.0f); } GLM_FUNC_QUALIFIER bool operator== @@ -383,7 +383,7 @@ namespace detail detail::thalf const & y ) { - return x.toFloat() < y.toFloat(); + return float(x) < float(y); } GLM_FUNC_QUALIFIER bool operator<= @@ -392,7 +392,7 @@ namespace detail detail::thalf const & y ) { - return x.toFloat() <= y.toFloat(); + return float(x) <= float(y); } GLM_FUNC_QUALIFIER bool operator> @@ -401,7 +401,7 @@ namespace detail detail::thalf const & y ) { - return x.toFloat() > y.toFloat(); + return float(x) > float(y); } GLM_FUNC_QUALIFIER bool operator>= @@ -410,7 +410,7 @@ namespace detail detail::thalf const & y ) { - return x.toFloat() >= y.toFloat(); + return float(x) >= float(y); } }//namespace detail diff --git a/glm/core/type_vec2.hpp b/glm/core/type_vec2.hpp index b17f0b21..0bd8e990 100644 --- a/glm/core/type_vec2.hpp +++ b/glm/core/type_vec2.hpp @@ -62,18 +62,10 @@ namespace detail ////////////////////////////////////// // Data -# if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW) - value_type x, y; - -# if(GLM_SUPPORT_SWIZZLE_FUNCTION()) - // Defines all he swizzle operator as functions - GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(value_type, detail::tvec2, detail::tref2, x, y) - GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(value_type, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4, x, y) -# endif//GLM_SUPPORT_SWIZZLE_FUNCTION() -# elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT) +# if(GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() && !defined(GLM_FORCE_ONLY_XYZW)) union { -# if(GLM_SUPPORT_SWIZZLE_OPERATOR()) +# if(defined(GLM_SWIZZLE)) _GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2, x, y) _GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2, r, g) _GLM_SWIZZLE2_2_MEMBERS(value_type, glm::detail::tvec2, s, t) @@ -83,21 +75,29 @@ namespace detail _GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4, x, y) _GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4, r, g) _GLM_SWIZZLE2_4_MEMBERS(value_type, glm::detail::tvec4, s, t) -# endif//(GLM_SUPPORT_SWIZZLE_OPERATOR()) +# endif//(defined(GLM_SWIZZLE)) struct{value_type r, g;}; struct{value_type s, t;}; struct{value_type x, y;}; }; -# else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES) +# elif(GLM_SUPPORT_ANONYMOUS_UNION() && !defined(GLM_FORCE_ONLY_XYZW)) union {value_type x, r, s;}; union {value_type y, g, t;}; -# if(GLM_SUPPORT_SWIZZLE_FUNCTION()) +# if(defined(GLM_SWIZZLE)) // Defines all he swizzle operator as functions GLM_SWIZZLE_GEN_REF_FROM_VEC2(value_type, detail::tvec2, detail::tref2) GLM_SWIZZLE_GEN_VEC_FROM_VEC2(value_type, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4) -# endif//GLM_SUPPORT_SWIZZLE_FUNCTION() +# endif//(defined(GLM_SWIZZLE)) +# else + value_type x, y; + +# if(defined(GLM_SWIZZLE)) + // Defines all he swizzle operator as functions + GLM_SWIZZLE_GEN_REF2_FROM_VEC2_SWIZZLE(value_type, detail::tvec2, detail::tref2, x, y) + GLM_SWIZZLE_GEN_VEC_FROM_VEC2_COMP(value_type, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4, x, y) +# endif//(defined(GLM_SWIZZLE)) # endif//GLM_COMPONENT ////////////////////////////////////// diff --git a/glm/core/type_vec3.hpp b/glm/core/type_vec3.hpp index 1b2fe983..ea4c49e9 100644 --- a/glm/core/type_vec3.hpp +++ b/glm/core/type_vec3.hpp @@ -62,18 +62,10 @@ namespace detail ////////////////////////////////////// // Data -# if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW) - value_type x, y, z; - -# if(GLM_SUPPORT_SWIZZLE_FUNCTION()) - // Defines all he swizzle operator as functions - GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, detail::tvec3, detail::tref2, detail::tref3, x, y, z) - GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z) -# endif//GLM_SUPPORT_SWIZZLE_FUNCTION() -# elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT) +# if(GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() && !defined(GLM_FORCE_ONLY_XYZW)) union { -# if(GLM_SUPPORT_SWIZZLE_OPERATOR()) +# if(defined(GLM_SWIZZLE)) _GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2, x, y, z) _GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2, r, g, b) _GLM_SWIZZLE3_2_MEMBERS(value_type, glm::detail::tvec2, s, t, p) @@ -83,22 +75,30 @@ namespace detail _GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4, x, y, z) _GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4, r, g, b) _GLM_SWIZZLE3_4_MEMBERS(value_type, glm::detail::tvec4, s, t, p) -# endif//(GLM_SUPPORT_SWIZZLE_OPERATOR()) +# endif//(defined(GLM_SWIZZLE)) struct{value_type r, g, b;}; struct{value_type s, t, p;}; struct{value_type x, y, z;}; }; -# else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES) +# elif(GLM_SUPPORT_ANONYMOUS_UNION() && !defined(GLM_FORCE_ONLY_XYZW)) union {value_type x, r, s;}; union {value_type y, g, t;}; union {value_type z, b, p;}; -# if(GLM_SUPPORT_SWIZZLE_FUNCTION()) +# if(defined(GLM_SWIZZLE)) // Defines all he swizzle operator as functions GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, detail::tvec3, detail::tref2, detail::tref3) GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4) -# endif//GLM_SUPPORT_SWIZZLE_FUNCTION() +# endif//(defined(GLM_SWIZZLE)) +# else + value_type x, y, z; + +# if(defined(GLM_SWIZZLE)) + // Defines all he swizzle operator as functions + GLM_SWIZZLE_GEN_REF_FROM_VEC3_COMP(T, detail::tvec3, detail::tref2, detail::tref3, x, y, z) + GLM_SWIZZLE_GEN_VEC_FROM_VEC3_COMP(T, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z) +# endif//(defined(GLM_SWIZZLE)) # endif//GLM_COMPONENT ////////////////////////////////////// diff --git a/glm/core/type_vec4.hpp b/glm/core/type_vec4.hpp index f8cdc2dc..440af9ea 100644 --- a/glm/core/type_vec4.hpp +++ b/glm/core/type_vec4.hpp @@ -62,18 +62,10 @@ namespace detail ////////////////////////////////////// // Data -# if(GLM_COMPONENT == GLM_COMPONENT_ONLY_XYZW) - value_type x, y, z, w; - -# if(GLM_SUPPORT_SWIZZLE_FUNCTION()) - // Defines all he swizzle operator as functions - GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4, x, y, z, w) - GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z, w) -# endif//GLM_SUPPORT_SWIZZLE_FUNCTION() -# elif(GLM_COMPONENT == GLM_COMPONENT_MS_EXT) +# if(GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() && !defined(GLM_FORCE_ONLY_XYZW)) union { -# if(GLM_SUPPORT_SWIZZLE_OPERATOR()) +# if(defined(GLM_SWIZZLE)) _GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2, x, y, z, w) _GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2, r, g, b, a) _GLM_SWIZZLE4_2_MEMBERS(value_type, glm::detail::tvec2, s, t, p, q) @@ -83,23 +75,31 @@ namespace detail _GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4, x, y, z, w) _GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4, r, g, b, a) _GLM_SWIZZLE4_4_MEMBERS(value_type, glm::detail::tvec4, s, t, p, q) -# endif//(GLM_SUPPORT_SWIZZLE_OPERATOR()) +# endif//(defined(GLM_SWIZZLE)) struct{value_type r, g, b, a;}; struct{value_type s, t, p, q;}; struct{value_type x, y, z, w;}; }; -# else//(GLM_COMPONENT == GLM_COMPONENT_GLSL_NAMES) +# elif(GLM_SUPPORT_ANONYMOUS_UNION() && !defined(GLM_FORCE_ONLY_XYZW)) union {value_type x, r, s;}; union {value_type y, g, t;}; union {value_type z, b, p;}; union {value_type w, a, q;}; -# if(GLM_SUPPORT_SWIZZLE_FUNCTION()) +# if(defined(GLM_SWIZZLE)) // Defines all he swizzle operator as functions GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4) GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4) -# endif//GLM_SUPPORT_SWIZZLE_FUNCTION() +# endif//(defined(GLM_SWIZZLE)) +# else + value_type x, y, z, w; + +# if(defined(GLM_SWIZZLE)) + // Defines all he swizzle operator as functions + GLM_SWIZZLE_GEN_REF_FROM_VEC4_COMP(T, detail::tvec4, detail::tref2, detail::tref3, detail::tref4, x, y, z, w) + GLM_SWIZZLE_GEN_VEC_FROM_VEC4_COMP(T, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4, x, y, z, w) +# endif//(defined(GLM_SWIZZLE)) # endif//GLM_COMPONENT ////////////////////////////////////// diff --git a/glm/gtx/string_cast.inl b/glm/gtx/string_cast.inl index caffdd5e..ffd17d3a 100644 --- a/glm/gtx/string_cast.inl +++ b/glm/gtx/string_cast.inl @@ -43,7 +43,7 @@ namespace detail GLM_FUNC_QUALIFIER std::string to_string(detail::thalf const & x) { - return detail::format("half(%2.4f)", x.toFloat()); + return detail::format("half(%2.4f)", float(x)); } GLM_FUNC_QUALIFIER std::string to_string(float x) diff --git a/test/core/core_func_swizzle.cpp b/test/core/core_func_swizzle.cpp index 4ce2192d..d0281a46 100644 --- a/test/core/core_func_swizzle.cpp +++ b/test/core/core_func_swizzle.cpp @@ -8,9 +8,10 @@ /////////////////////////////////////////////////////////////////////////////////////////////////// //#define GLM_FORCE_ONLY_XYZW +//#define GLM_FORCE_PURE #define GLM_MESSAGES -#define GLM_SWIZZLE_OPERATOR -#define GLM_FORCE_CXX98 +#define GLM_SWIZZLE +//#define GLM_FORCE_CXX98 #include int test_vec2_swizzle() diff --git a/test/core/core_type_half.cpp b/test/core/core_type_half.cpp index 07679679..0598ab4d 100644 --- a/test/core/core_type_half.cpp +++ b/test/core/core_type_half.cpp @@ -15,13 +15,13 @@ int test_half_ctor() int Error = 0; glm::half A(1.0f); - Error += A.toFloat() == 1.0f ? 0 : 1; + Error += float(A) == 1.0f ? 0 : 1; glm::half B = glm::half(1.0f); - Error += B.toFloat() == 1.0f ? 0 : 1; + Error += float(B) == 1.0f ? 0 : 1; glm::half C = B; - Error += C.toFloat() == 1.0f ? 0 : 1; + Error += float(C) == 1.0f ? 0 : 1; return Error; } @@ -31,13 +31,13 @@ int test_half_cast() int Error = 0; glm::half A(2.0f); - Error += A.toFloat() == 2.0f ? 0 : 1; + Error += float(A) == 2.0f ? 0 : 1; glm::half B(2.0); - Error += B.toFloat() == 2.0f ? 0 : 1; + Error += float(B) == 2.0f ? 0 : 1; glm::half C(2); - Error += C.toFloat() == 2.0f ? 0 : 1; + Error += float(C) == 2.0f ? 0 : 1; float D(A); Error += D == 2.0f ? 0 : 1; diff --git a/test/core/core_type_vec1.cpp b/test/core/core_type_vec1.cpp index a3687699..3921bc93 100644 --- a/test/core/core_type_vec1.cpp +++ b/test/core/core_type_vec1.cpp @@ -7,7 +7,7 @@ // File : test/core/type_vec1.cpp /////////////////////////////////////////////////////////////////////////////////////////////////// -#define GLM_SWIZZLE_OPERATOR +#define GLM_SWIZZLE #include static int test_operators() diff --git a/test/core/core_type_vec2.cpp b/test/core/core_type_vec2.cpp index c2bd37f6..b67c99c6 100644 --- a/test/core/core_type_vec2.cpp +++ b/test/core/core_type_vec2.cpp @@ -7,7 +7,7 @@ // File : test/core/type_vec2.cpp /////////////////////////////////////////////////////////////////////////////////////////////////// -#define GLM_SWIZZLE_OPERATOR +#define GLM_SWIZZLE #include int test_vec2_operators() diff --git a/test/core/core_type_vec3.cpp b/test/core/core_type_vec3.cpp index 38a39a6c..46b79e49 100644 --- a/test/core/core_type_vec3.cpp +++ b/test/core/core_type_vec3.cpp @@ -7,7 +7,7 @@ // File : test/core/type_vec3.cpp /////////////////////////////////////////////////////////////////////////////////////////////////// -#define GLM_SWIZZLE_OPERATOR +#define GLM_SWIZZLE #include #include #include @@ -280,29 +280,29 @@ int test_vec3_swizzle_half() u = v; - Error += (u.x.toFloat() == 1.0f && u.y.toFloat() == 2.0f && u.z.toFloat() == 3.0f) ? 0 : 1; + Error += (u.x == glm::half(1.0f) && u.y == glm::half(2.0f) && u.z == glm::half(3.0f)) ? 0 : 1; #if(GLM_SUPPORT_SWIZZLE_OPERATOR()) u = v.xyz; - Error += (u.x.toFloat() == 1.0f && u.y.toFloat() == 2.0f && u.z.toFloat() == 3.0f) ? 0 : 1; + Error += (u.x == glm::half(1.0f) && u.y == glm::half(2.0f) && u.z == glm::half(3.0f)) ? 0 : 1; u = v.zyx; - Error += (u.x.toFloat() == 3.0f && u.y.toFloat() == 2.0f && u.z.toFloat() == 1.0f) ? 0 : 1; + Error += (u.x == glm::half(3.0f) && u.y == glm::half(2.0f) && u.z == glm::half(1.0f)) ? 0 : 1; u.zyx = v; - Error += (u.x.toFloat() == 3.0f && u.y.toFloat() == 2.0f && u.z.toFloat() == 1.0f) ? 0 : 1; + Error += (u.x == glm::half(3.0f) && u.y == glm::half(2.0f) && u.z == glm::half(1.0f)) ? 0 : 1; u = v.rgb; - Error += (u.x.toFloat() == 1.0f && u.y.toFloat() == 2.0f && u.z.toFloat() == 3.0f) ? 0 : 1; + Error += (u.x == glm::half(1.0f) && u.y == glm::half(2.0f) && u.z == glm::half(3.0f)) ? 0 : 1; u = v.bgr; - Error += (u.x.toFloat() == 3.0f && u.y.toFloat() == 2.0f && u.z.toFloat() == 1.0f) ? 0 : 1; + Error += (u.x == glm::half(3.0f) && u.y == glm::half(2.0f) && u.z == glm::half(1.0f)) ? 0 : 1; u.bgr = v; - Error += (u.x.toFloat() == 3.0f && u.y.toFloat() == 2.0f && u.z.toFloat() == 1.0f) ? 0 : 1; + Error += (u.x == glm::half(3.0f) && u.y == glm::half(2.0f) && u.z == glm::half(1.0f)) ? 0 : 1; u = v.stp; - Error += (u.x.toFloat() == 1.0f && u.y.toFloat() == 2.0f && u.z.toFloat() == 3.0f) ? 0 : 1; + Error += (u.x == glm::half(1.0f) && u.y == glm::half(2.0f) && u.z == glm::half(3.0f)) ? 0 : 1; u = v.pts; - Error += (u.x.toFloat() == 3.0f && u.y.toFloat() == 2.0f && u.z.toFloat() == 1.0f) ? 0 : 1; + Error += (u.x == glm::half(3.0f) && u.y == glm::half(2.0f) && u.z == glm::half(1.0f)) ? 0 : 1; u.pts = v; - Error += (u.x.toFloat() == 3.0f && u.y.toFloat() == 2.0f && u.z.toFloat() == 1.0f) ? 0 : 1; + Error += (u.x == glm::half(3.0f) && u.y == glm::half(2.0f) && u.z == glm::half(1.0f)) ? 0 : 1; #endif//(GLM_SUPPORT_SWIZZLE_OPERATOR()) return Error; @@ -361,9 +361,9 @@ int test_vec3_swizzle_functions() // glm::dot(u.xy(), v.xy()); <--- Compiles correctly // +#if(GLM_SUPPORT_SWIZZLE_OPERATOR()) float r; -#if(GLM_SUPPORT_SWIZZLE_OPERATOR()) // vec2 glm::vec2 a(1, 2); glm::vec2 b(10, 20); @@ -397,9 +397,9 @@ int test_vec3_swizzle_partial() { int Error = 0; +#if(GLM_SUPPORT_SWIZZLE_OPERATOR()) glm::vec3 A(1, 2, 3); -#if(GLM_SUPPORT_SWIZZLE_OPERATOR()) { glm::vec3 B(A.xy, 3.0f); Error += A == B ? 0 : 1; diff --git a/test/core/core_type_vec4.cpp b/test/core/core_type_vec4.cpp index 0c304cbe..f4038f04 100644 --- a/test/core/core_type_vec4.cpp +++ b/test/core/core_type_vec4.cpp @@ -7,7 +7,7 @@ // File : test/core/type_vec4.cpp /////////////////////////////////////////////////////////////////////////////////////////////////// -#define GLM_SWIZZLE_OPERATOR +#define GLM_SWIZZLE #include #include #include @@ -220,7 +220,7 @@ int test_vec4_swizzle_partial() glm::vec4 A(1, 2, 3, 4); -#if((GLM_LANG == GLM_LANG_CXX11) || (GLM_LANG == GLM_LANG_CXXMS)) +#if(GLM_SUPPORT_SWIZZLE_OPERATOR()) { glm::vec4 B(A.xy, A.zw); Error += A == B ? 0 : 1; @@ -246,7 +246,7 @@ int test_vec4_swizzle_partial() glm::vec4 B(1.0f, A.yzw); Error += A == B ? 0 : 1; } -#endif//((GLM_LANG == GLM_LANG_CXX11) || (GLM_LANG == GLM_LANG_CXXMS)) +#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR()) return Error; }