mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-26 18:24:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Removed multiple component selection code

Browse Source
This commit is contained in:
Christophe Riccio 2013-08-27 11:35:58 +02:00
parent 4dd2b6893e
commit bc72fafdd9
7 changed files with 6 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
glm/core/setup.hpp
View File

@ -605,49 +605,6 @@
# endif//GLM_ARCH # endif//GLM_ARCH
#endif//GLM_MESSAGE #endif//GLM_MESSAGE
///////////////////////////////////////////////////////////////////////////////////////////////////
// Support check macros
#define GLM_SUPPORT_ANONYMOUS_UNION() \
(GLM_LANG & GLM_LANG_CXX98_FLAG)
#define GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() \
((GLM_LANG & GLM_LANG_CXXMS_FLAG) && (GLM_COMPILER & GLM_COMPILER_VC))
#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_ONLY_XYZW 0 // To disable multiple vector component names access.
#define GLM_COMPONENT_CXX98 1 //
#define GLM_COMPONENT_CXXMS 2 // To use anonymous union to provide multiple component names access for class valType. Visual C++ only.
#if(GLM_SUPPORT_ANONYMOUS_UNION_OF_STRUCTURE() && !defined(GLM_FORCE_ONLY_XYZW))
# define GLM_COMPONENT GLM_COMPONENT_CXXMS
#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(defined(GLM_MESSAGES) && !defined(GLM_MESSAGE_COMPONENT_DISPLAYED))
# define GLM_MESSAGE_COMPONENT_DISPLAYED
# 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 component names for all vector types")
# elif(GLM_COMPONENT == GLM_COMPONENT_CXXMS)
# pragma message("GLM: x,y,z,w; r,g,b,a; s,t,p,q component names for all vector types")
# else
# error "GLM: GLM_COMPONENT value unknown"
# endif//GLM_MESSAGE_COMPONENT_DISPLAYED
#endif//GLM_MESSAGE
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
// Radians // Radians
@ -710,10 +667,8 @@
#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(GLM_SUPPORT_SWIZZLE_OPERATOR()) # if defined(GLM_SWIZZLE)
# pragma message("GLM: Swizzling operators enabled") # pragma message("GLM: Swizzling operators enabled")
# elif(GLM_SUPPORT_SWIZZLE_FUNCTION())
# pragma message("GLM: Swizzling operators supported through swizzling functions")
# else # else
# pragma message("GLM: Swizzling operators disabled") # pragma message("GLM: Swizzling operators disabled")
# endif # endif
@ -736,7 +691,7 @@
# define GLM_RESTRICT # define GLM_RESTRICT
# define GLM_RESTRICT_VAR __restrict # define GLM_RESTRICT_VAR __restrict
# define GLM_CONSTEXPR # define GLM_CONSTEXPR
#elif(((GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC)) && (GLM_COMPILER >= GLM_COMPILER_GCC31)) || (GLM_COMPILER & GLM_COMPILER_CLANG)) #elif(((GLM_COMPILER & (GLM_COMPILER_GCC | GLM_COMPILER_LLVM_GCC)) && (GLM_COMPILER >= GLM_COMPILER_GCC34)) || (GLM_COMPILER & GLM_COMPILER_CLANG))
# define GLM_DEPRECATED __attribute__((__deprecated__)) # define GLM_DEPRECATED __attribute__((__deprecated__))
# define GLM_ALIGN(x) __attribute__((aligned(x))) # define GLM_ALIGN(x) __attribute__((aligned(x)))
# define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x))) # define GLM_ALIGNED_STRUCT(x) struct __attribute__((aligned(x)))

7
glm/core/type_vec2.hpp
View File

@ -22,7 +22,7 @@
/// ///
/// @ref core /// @ref core
/// @file glm/core/type_vec2.hpp /// @file glm/core/type_vec2.hpp
/// @date 2008-08-18 / 2011-06-15 /// @date 2008-08-18 / 2013-08-27
/// @author Christophe Riccio /// @author Christophe Riccio
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
@ -54,11 +54,10 @@ namespace detail
union {value_type x, r, s;}; union {value_type x, r, s;};
union {value_type y, g, t;}; union {value_type y, g, t;};
# if(defined(GLM_SWIZZLE)) # ifdef GLM_SWIZZLE
// Defines all he swizzle operator as functions
GLM_SWIZZLE_GEN_REF_FROM_VEC2(value_type, P, detail::tvec2, detail::tref2) GLM_SWIZZLE_GEN_REF_FROM_VEC2(value_type, P, detail::tvec2, detail::tref2)
GLM_SWIZZLE_GEN_VEC_FROM_VEC2(value_type, P, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4) GLM_SWIZZLE_GEN_VEC_FROM_VEC2(value_type, P, detail::tvec2, detail::tvec2, detail::tvec3, detail::tvec4)
# endif//(defined(GLM_SWIZZLE)) # endif//GLM_SWIZZLE
////////////////////////////////////// //////////////////////////////////////
// Accesses // Accesses

1
glm/core/type_vec3.hpp
View File

@ -56,7 +56,6 @@ namespace detail
union {value_type z, b, p;}; union {value_type z, b, p;};
# if(defined(GLM_SWIZZLE)) # if(defined(GLM_SWIZZLE))
// Defines all he swizzle operator as functions
GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, P, detail::tvec3, detail::tref2, detail::tref3) GLM_SWIZZLE_GEN_REF_FROM_VEC3(T, P, detail::tvec3, detail::tref2, detail::tref3)
GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4) GLM_SWIZZLE_GEN_VEC_FROM_VEC3(T, P, detail::tvec3, detail::tvec2, detail::tvec3, detail::tvec4)
# endif//(defined(GLM_SWIZZLE)) # endif//(defined(GLM_SWIZZLE))

1
glm/core/type_vec4.hpp
View File

@ -57,7 +57,6 @@ namespace detail
union {value_type w, a, q;}; union {value_type w, a, q;};
# if(defined(GLM_SWIZZLE)) # if(defined(GLM_SWIZZLE))
// Defines all he swizzle operator as functions
GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, P, detail::tvec4, detail::tref2, detail::tref3, detail::tref4) GLM_SWIZZLE_GEN_REF_FROM_VEC4(T, P, detail::tvec4, detail::tref2, detail::tref3, detail::tref4)
GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4) GLM_SWIZZLE_GEN_VEC_FROM_VEC4(T, P, detail::tvec4, detail::tvec2, detail::tvec3, detail::tvec4)
# endif//(defined(GLM_SWIZZLE)) # endif//(defined(GLM_SWIZZLE))

1
glm/glm.hpp
View File

@ -134,7 +134,6 @@
//////////////////// ////////////////////
// check type sizes // check type sizes
#ifndef GLM_STATIC_ASSERT_NULL #ifndef GLM_STATIC_ASSERT_NULL
GLM_STATIC_ASSERT(sizeof(glm::float16) == 2, "float16 size isn't 2 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::float32) == 4, "float32 size isn't 4 bytes on this platform"); GLM_STATIC_ASSERT(sizeof(glm::float32) == 4, "float32 size isn't 4 bytes on this platform");
GLM_STATIC_ASSERT(sizeof(glm::float64) == 8, "float64 size isn't 8 bytes on this platform"); GLM_STATIC_ASSERT(sizeof(glm::float64) == 8, "float64 size isn't 8 bytes on this platform");
#endif//GLM_STATIC_ASSERT_NULL #endif//GLM_STATIC_ASSERT_NULL

11
test/core/core_type_vec3.cpp
View File

@ -197,7 +197,6 @@ int test_vec3_swizzle3_2()
//u = v.rgb; //Illegal //u = v.rgb; //Illegal
//u = v.stp; //Illegal //u = v.stp; //Illegal
#if(GLM_SUPPORT_SWIZZLE_OPERATOR())
u = v.xx; Error += (u.x == 1.0f && u.y == 1.0f) ? 0 : 1; u = v.xx; Error += (u.x == 1.0f && u.y == 1.0f) ? 0 : 1;
u = v.xy; Error += (u.x == 1.0f && u.y == 2.0f) ? 0 : 1; u = v.xy; Error += (u.x == 1.0f && u.y == 2.0f) ? 0 : 1;
u = v.xz; Error += (u.x == 1.0f && u.y == 3.0f) ? 0 : 1; u = v.xz; Error += (u.x == 1.0f && u.y == 3.0f) ? 0 : 1;
@ -243,7 +242,6 @@ int test_vec3_swizzle3_2()
v.zx = u; Error += (v.x == 2.0f && v.y == 1.0f && v.z == 1.0f) ? 0 : 1; 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.zy = u; Error += (v.x == 2.0f && v.y == 2.0f && v.z == 1.0f) ? 0 : 1;
//v.zz = u; //Illegal //v.zz = u; //Illegal
#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
return Error; return Error;
} }
@ -257,7 +255,6 @@ int test_vec3_swizzle3_3()
u = v; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1; u = v; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1;
#if(GLM_SUPPORT_SWIZZLE_OPERATOR())
u = v.xyz; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1; u = v.xyz; Error += (u.x == 1.0f && u.y == 2.0f && u.z == 3.0f) ? 0 : 1;
u = v.zyx; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1; u = v.zyx; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
u.zyx = v; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1; u.zyx = v; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
@ -269,7 +266,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.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 = 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; u.pts = v; Error += (u.x == 3.0f && u.y == 2.0f && u.z == 1.0f) ? 0 : 1;
#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
return Error; return Error;
} }
@ -282,7 +279,6 @@ int test_vec3_swizzle_operators()
u = glm::vec3(1, 2, 3); u = glm::vec3(1, 2, 3);
v = glm::vec3(10, 20, 30); v = glm::vec3(10, 20, 30);
#if(GLM_SUPPORT_SWIZZLE_OPERATOR())
// Swizzle, swizzle binary operators // Swizzle, swizzle binary operators
q = u.xyz + v.xyz; Error += (q == (u + v)) ? 0 : 1; q = u.xyz + v.xyz; Error += (q == (u + v)) ? 0 : 1;
q = (u.zyx + v.zyx).zyx; Error += (q == (u + v)) ? 0 : 1; q = (u.zyx + v.zyx).zyx; Error += (q == (u + v)) ? 0 : 1;
@ -304,7 +300,6 @@ int test_vec3_swizzle_operators()
q = (u.xyz * v); Error += (q == (u * v)) ? 0 : 1; q = (u.xyz * v); Error += (q == (u * v)) ? 0 : 1;
q = (u.xxx * v); Error += (q == u.x * v) ? 0 : 1; q = (u.xxx * v); Error += (q == u.x * v) ? 0 : 1;
q = (u.xyz / v); Error += (q == (u / v)) ? 0 : 1; q = (u.xyz / v); Error += (q == (u / v)) ? 0 : 1;
#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
// Compile errors // Compile errors
//q = (u.yz * v.xyz); //q = (u.yz * v.xyz);
@ -324,7 +319,6 @@ int test_vec3_swizzle_functions()
// glm::dot(u.xy, v.xy); <--- Compile error // glm::dot(u.xy, v.xy); <--- Compile error
// glm::dot(u.xy(), v.xy()); <--- Compiles correctly // glm::dot(u.xy(), v.xy()); <--- Compiles correctly
#if(GLM_SUPPORT_SWIZZLE_OPERATOR())
float r; float r;
// vec2 // vec2
@ -351,7 +345,6 @@ int test_vec3_swizzle_functions()
r = glm::dot(s, t); Error += (int(r) == 300) ? 0 : 1; 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.xyzw(), t.xyzw()); Error += (int(r) == 300) ? 0 : 1;
r = glm::dot(s.xyz(), t.xyz()); Error += (int(r) == 140) ? 0 : 1; r = glm::dot(s.xyz(), t.xyz()); Error += (int(r) == 140) ? 0 : 1;
#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
return Error; return Error;
} }
@ -360,7 +353,6 @@ int test_vec3_swizzle_partial()
{ {
int Error = 0; int Error = 0;
#if(GLM_SUPPORT_SWIZZLE_OPERATOR())
glm::vec3 A(1, 2, 3); glm::vec3 A(1, 2, 3);
{ {
@ -377,7 +369,6 @@ int test_vec3_swizzle_partial()
glm::vec3 B(A.xyz); glm::vec3 B(A.xyz);
Error += A == B ? 0 : 1; Error += A == B ? 0 : 1;
} }
#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
return Error; return Error;
} }

2
test/core/core_type_vec4.cpp
View File

@ -216,7 +216,6 @@ int test_vec4_swizzle_partial()
glm::vec4 A(1, 2, 3, 4); glm::vec4 A(1, 2, 3, 4);
#if(GLM_SUPPORT_SWIZZLE_OPERATOR())
{ {
glm::vec4 B(A.xy, A.zw); glm::vec4 B(A.xy, A.zw);
Error += A == B ? 0 : 1; Error += A == B ? 0 : 1;
@ -242,7 +241,6 @@ int test_vec4_swizzle_partial()
glm::vec4 B(1.0f, A.yzw); glm::vec4 B(1.0f, A.yzw);
Error += A == B ? 0 : 1; Error += A == B ? 0 : 1;
} }
#endif//(GLM_SUPPORT_SWIZZLE_OPERATOR())
return Error; return Error;
} }