mewin/glm
1
0
Fork 0
Code Releases Activity

Fixed issues with ref types for l-value swizzle operators

Browse Source
This commit is contained in:
Christophe Riccio 2013-08-27 13:50:55 +02:00
parent b3d70c635b
commit 4b7862b314
6 changed files with 204 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
glm/core/type_vec2.hpp
View File

@ -51,14 +51,13 @@ namespace detail
////////////////////////////////////// //////////////////////////////////////
// Data // Data
# if(GLM_LANG & GLM_LANG_CXXMS_FLAG) # if((GLM_LANG & GLM_LANG_CXXMS_FLAG) && defined(GLM_SWIZZLE))
union union
{ {
struct{ value_type x, y; }; struct{ value_type x, y; };
struct{ value_type r, g; }; struct{ value_type r, g; };
struct{ value_type s, t; }; struct{ value_type s, t; };
# if(defined(GLM_SWIZZLE))
_GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, x, y) _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, x, y)
_GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, r, g) _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, r, g)
_GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, s, t) _GLM_SWIZZLE2_2_MEMBERS(T, P, tvec2, s, t)
@ -68,7 +67,6 @@ namespace detail
_GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, x, y) _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, x, y)
_GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, r, g) _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, r, g)
_GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, s, t) _GLM_SWIZZLE2_4_MEMBERS(T, P, tvec4, s, t)
# endif//(defined(GLM_SWIZZLE))
}; };
# else # else
union {value_type x, r, s;}; union {value_type x, r, s;};

4
glm/core/type_vec3.hpp
View File

@ -51,14 +51,13 @@ namespace detail
////////////////////////////////////// //////////////////////////////////////
// Data // Data
# if(GLM_LANG & GLM_LANG_CXXMS_FLAG) # if((GLM_LANG & GLM_LANG_CXXMS_FLAG) && defined(GLM_SWIZZLE))
union union
{ {
struct{ value_type x, y, z; }; struct{ value_type x, y, z; };
struct{ value_type r, g, b; }; struct{ value_type r, g, b; };
struct{ value_type s, t, p; }; struct{ value_type s, t, p; };
# if(defined(GLM_SWIZZLE))
_GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, x, y, z) _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, x, y, z)
_GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, r, g, b) _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, r, g, b)
_GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, s, t, p) _GLM_SWIZZLE3_2_MEMBERS(T, P, tvec2, s, t, p)
@ -68,7 +67,6 @@ namespace detail
_GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, x, y, z) _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, x, y, z)
_GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, r, g, b) _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, r, g, b)
_GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, s, t, p) _GLM_SWIZZLE3_4_MEMBERS(T, P, tvec4, s, t, p)
# endif//(defined(GLM_SWIZZLE))
}; };
# else # else
union { value_type x, r, s; }; union { value_type x, r, s; };

4
glm/core/type_vec4.hpp
View File

@ -51,14 +51,13 @@ namespace detail
////////////////////////////////////// //////////////////////////////////////
// Data // Data
# if(GLM_LANG & GLM_LANG_CXXMS_FLAG) # if((GLM_LANG & GLM_LANG_CXXMS_FLAG) && defined(GLM_SWIZZLE))
union union
{ {
struct { value_type r, g, b, a; }; struct { value_type r, g, b, a; };
struct { value_type s, t, p, q; }; struct { value_type s, t, p, q; };
struct { value_type x, y, z, w;}; struct { value_type x, y, z, w;};
# if(defined(GLM_SWIZZLE))
_GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, x, y, z, w) _GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, x, y, z, w)
_GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, r, g, b, a) _GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, r, g, b, a)
_GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, s, t, p, q) _GLM_SWIZZLE4_2_MEMBERS(T, P, tvec2, s, t, p, q)
@ -68,7 +67,6 @@ namespace detail
_GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, x, y, z, w) _GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, x, y, z, w)
_GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, r, g, b, a) _GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, r, g, b, a)
_GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, s, t, p, q) _GLM_SWIZZLE4_4_MEMBERS(T, P, tvec4, s, t, p, q)
# endif//(defined(GLM_SWIZZLE))
}; };
# else # else
union { value_type x, r, s; }; union { value_type x, r, s; };

97
glm/gtc/swizzle.hpp
View File

@ -91,16 +91,26 @@ namespace glm
vecType<T, P> & v, vecType<T, P> & v,
comp x, comp y, comp z, comp w); comp x, comp y, comp z, comp w);
# define static_swizzle1_const(TYPE, SIZE) \ # define static_swizzle1_const_precision(TYPE, SIZE, PRECISION) \
template <comp x> \ template <comp x> \
GLM_FUNC_QUALIFIER TYPE swizzle(detail::tvec##SIZE<TYPE, defaultp> const & v) \ GLM_FUNC_QUALIFIER TYPE swizzle(detail::tvec##SIZE<TYPE, PRECISION> const & v) \
{return v[x];} {return v[x];}
# define static_swizzle1_ref(TYPE, SIZE) \ # define static_swizzle1_ref_precision(TYPE, SIZE, PRECISION) \
template <comp x> \ template <comp x> \
GLM_FUNC_QUALIFIER TYPE& swizzle(detail::tvec##SIZE<TYPE, defaultp> & v) \ GLM_FUNC_QUALIFIER TYPE& swizzle(detail::tvec##SIZE<TYPE, PRECISION> & v) \
{return v[x];} {return v[x];}
# define static_swizzle1_const(TYPE, SIZE) \
static_swizzle1_const_precision(TYPE, SIZE, glm::highp) \
static_swizzle1_const_precision(TYPE, SIZE, glm::mediump) \
static_swizzle1_const_precision(TYPE, SIZE, glm::lowp)
# define static_swizzle1_ref(TYPE, SIZE) \
static_swizzle1_ref_precision(TYPE, SIZE, glm::highp) \
static_swizzle1_ref_precision(TYPE, SIZE, glm::mediump) \
static_swizzle1_ref_precision(TYPE, SIZE, glm::lowp)
static_swizzle1_ref(detail::float32, 2) static_swizzle1_ref(detail::float32, 2)
static_swizzle1_ref(detail::float32, 3) static_swizzle1_ref(detail::float32, 3)
static_swizzle1_ref(detail::float32, 4) static_swizzle1_ref(detail::float32, 4)
@ -150,24 +160,38 @@ namespace glm
{return TYPE(v[x], v[y], v[z], v[w]);} {return TYPE(v[x], v[y], v[z], v[w]);}
*/ */
# define static_swizzle2_const(TYPE, SIZE) \ # define static_swizzle2_const_precision(TYPE, SIZE, PRECISION) \
template <comp x, comp y> \ template <comp x, comp y> \
GLM_FUNC_QUALIFIER detail::tvec2<TYPE, defaultp> swizzle( \ GLM_FUNC_QUALIFIER detail::tvec2<TYPE, PRECISION> swizzle( \
detail::tvec##SIZE<TYPE, defaultp> const & v) \ detail::tvec##SIZE<TYPE, PRECISION> const & v) \
{return detail::tvec2<TYPE, defaultp>(v[x], v[y]);} {return detail::tvec2<TYPE, PRECISION>(v[x], v[y]); }
# define static_swizzle3_const_precision(TYPE, SIZE, PRECISION) \
template <comp x, comp y, comp z> \
GLM_FUNC_QUALIFIER detail::tvec3<TYPE, PRECISION> swizzle( \
detail::tvec##SIZE<TYPE, PRECISION> const & v) \
{return detail::tvec3<TYPE, PRECISION>(v[x], v[y], v[z]); }
# define static_swizzle4_const_precision(TYPE, SIZE, PRECISION) \
template <comp x, comp y, comp z, comp w> \
GLM_FUNC_QUALIFIER detail::tvec4<TYPE, PRECISION> swizzle( \
detail::tvec##SIZE<TYPE, PRECISION> const & v) \
{return detail::tvec4<TYPE, PRECISION>(v[x], v[y], v[z], v[w]); }
# define static_swizzle2_const(TYPE, SIZE) \
static_swizzle2_const_precision(TYPE, SIZE, glm::highp) \
static_swizzle2_const_precision(TYPE, SIZE, glm::mediump) \
static_swizzle2_const_precision(TYPE, SIZE, glm::lowp)
# define static_swizzle3_const(TYPE, SIZE) \ # define static_swizzle3_const(TYPE, SIZE) \
template <comp x, comp y, comp z> \ static_swizzle3_const_precision(TYPE, SIZE, glm::highp) \
GLM_FUNC_QUALIFIER detail::tvec3<TYPE, defaultp> swizzle( \ static_swizzle3_const_precision(TYPE, SIZE, glm::mediump) \
detail::tvec##SIZE<TYPE, defaultp> const & v) \ static_swizzle3_const_precision(TYPE, SIZE, glm::lowp)
{return detail::tvec3<TYPE, defaultp>(v[x], v[y], v[z]);}
# define static_swizzle4_const(TYPE, SIZE) \ # define static_swizzle4_const(TYPE, SIZE) \
template <comp x, comp y, comp z, comp w> \ static_swizzle4_const_precision(TYPE, SIZE, glm::highp) \
GLM_FUNC_QUALIFIER detail::tvec4<TYPE, defaultp> swizzle( \ static_swizzle4_const_precision(TYPE, SIZE, glm::mediump) \
detail::tvec##SIZE<TYPE, defaultp> const & v) \ static_swizzle4_const_precision(TYPE, SIZE, glm::lowp)
{return detail::tvec4<TYPE, defaultp>(v[x], v[y], v[z], v[w]);}
static_swizzle2_const(glm::f32, 2) static_swizzle2_const(glm::f32, 2)
static_swizzle2_const(glm::f32, 3) static_swizzle2_const(glm::f32, 3)
@ -268,23 +292,38 @@ namespace glm
static_swizzle4_const(glm::u64, 3) static_swizzle4_const(glm::u64, 3)
static_swizzle4_const(glm::u64, 4) static_swizzle4_const(glm::u64, 4)
# define static_swizzle2_ref(TYPE, SIZE) \ # define static_swizzle2_ref_precision(TYPE, SIZE, PRECISION) \
template <glm::comp x, glm::comp y> \ template <glm::comp x, glm::comp y> \
GLM_FUNC_QUALIFIER glm::detail::tref2<TYPE, defaultp> swizzle( \ GLM_FUNC_QUALIFIER glm::detail::tref2<TYPE, PRECISION> swizzle( \
detail::tvec##SIZE<TYPE, defaultp> & v) \ detail::tvec##SIZE<TYPE, PRECISION> & v) \
{return glm::detail::tref2<TYPE, defaultp>(v[x], v[y]);} {return glm::detail::tref2<TYPE, PRECISION>(v[x], v[y]); }
# define static_swizzle3_ref_precision(TYPE, SIZE, PRECISION) \
template <glm::comp x, glm::comp y, glm::comp z> \
GLM_FUNC_QUALIFIER glm::detail::tref3<TYPE, PRECISION> swizzle( \
detail::tvec##SIZE<TYPE, PRECISION> & v) \
{return glm::detail::tref3<TYPE, PRECISION>(v[x], v[y], v[z]); }
# define static_swizzle4_ref_precision(TYPE, SIZE, PRECISION) \
template <glm::comp x, glm::comp y, glm::comp z, glm::comp w> \
GLM_FUNC_QUALIFIER glm::detail::tref4<TYPE, PRECISION> swizzle( \
detail::tvec##SIZE<TYPE, PRECISION> & v) \
{return glm::detail::tref4<TYPE, PRECISION>(v[x], v[y], v[z], v[w]); }
# define static_swizzle2_ref(TYPE, SIZE) \
static_swizzle2_ref_precision(TYPE, SIZE, glm::highp) \
static_swizzle2_ref_precision(TYPE, SIZE, glm::mediump) \
static_swizzle2_ref_precision(TYPE, SIZE, glm::lowp)
# define static_swizzle3_ref(TYPE, SIZE) \ # define static_swizzle3_ref(TYPE, SIZE) \
template <glm::comp x, glm::comp y, glm::comp z> \ static_swizzle3_ref_precision(TYPE, SIZE, glm::highp) \
GLM_FUNC_QUALIFIER glm::detail::tref3<TYPE, defaultp> swizzle( \ static_swizzle3_ref_precision(TYPE, SIZE, glm::mediump) \
detail::tvec##SIZE<TYPE, defaultp> & v) \ static_swizzle3_ref_precision(TYPE, SIZE, glm::lowp)
{return glm::detail::tref3<TYPE, defaultp>(v[x], v[y], v[z]);}
# define static_swizzle4_ref(TYPE, SIZE) \ # define static_swizzle4_ref(TYPE, SIZE) \
template <glm::comp x, glm::comp y, glm::comp z, glm::comp w> \ static_swizzle4_ref_precision(TYPE, SIZE, glm::highp) \
GLM_FUNC_QUALIFIER glm::detail::tref4<TYPE, defaultp> swizzle( \ static_swizzle4_ref_precision(TYPE, SIZE, glm::mediump) \
detail::tvec##SIZE<TYPE, defaultp> & v) \ static_swizzle4_ref_precision(TYPE, SIZE, glm::lowp)
{return glm::detail::tref4<TYPE, defaultp>(v[x], v[y], v[z], v[w]);}
static_swizzle2_ref(glm::f32, 2) static_swizzle2_ref(glm::f32, 2)
static_swizzle2_ref(glm::f32, 3) static_swizzle2_ref(glm::f32, 3)

12
test/core/core_type_vec3.cpp
View File

@ -2,7 +2,7 @@
// OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net) // OpenGL Mathematics Copyright (c) 2005 - 2013 G-Truc Creation (www.g-truc.net)
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
// Created : 2008-08-31 // Created : 2008-08-31
// Updated : 2011-09-19 // Updated : 2013-08-27
// Licence : This source is under MIT License // Licence : This source is under MIT License
// File : test/core/type_vec3.cpp // File : test/core/type_vec3.cpp
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
@ -192,6 +192,7 @@ int test_vec3_swizzle3_2()
glm::vec3 v(1, 2, 3); glm::vec3 v(1, 2, 3);
glm::vec2 u; glm::vec2 u;
# if(GLM_LANG & GLM_LANG_CXXMS_FLAG)
// Can not assign a vec3 swizzle to a vec2 // Can not assign a vec3 swizzle to a vec2
//u = v.xyz; //Illegal //u = v.xyz; //Illegal
//u = v.rgb; //Illegal //u = v.rgb; //Illegal
@ -230,7 +231,6 @@ int test_vec3_swizzle3_2()
//u = v.rx; //Illegal //u = v.rx; //Illegal
//u = v.sy; //Illegal //u = v.sy; //Illegal
u = glm::vec2(1, 2); u = glm::vec2(1, 2);
v = glm::vec3(1, 2, 3); v = glm::vec3(1, 2, 3);
//v.xx = u; //Illegal //v.xx = u; //Illegal
@ -243,6 +243,8 @@ int test_vec3_swizzle3_2()
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_LANG
return Error; return Error;
} }
@ -253,6 +255,7 @@ int test_vec3_swizzle3_3()
glm::vec3 v(1, 2, 3); glm::vec3 v(1, 2, 3);
glm::vec3 u; glm::vec3 u;
# if(GLM_LANG & GLM_LANG_CXXMS_FLAG)
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;
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;
@ -266,6 +269,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_LANG
return Error; return Error;
} }
@ -279,6 +283,7 @@ 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_LANG & GLM_LANG_CXXMS_FLAG)
// 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;
@ -300,6 +305,7 @@ 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_LANG
// Compile errors // Compile errors
//q = (u.yz * v.xyz); //q = (u.yz * v.xyz);
@ -355,6 +361,7 @@ int test_vec3_swizzle_partial()
glm::vec3 A(1, 2, 3); glm::vec3 A(1, 2, 3);
# if(GLM_LANG & GLM_LANG_CXXMS_FLAG)
{ {
glm::vec3 B(A.xy, 3.0f); glm::vec3 B(A.xy, 3.0f);
Error += A == B ? 0 : 1; Error += A == B ? 0 : 1;
@ -369,6 +376,7 @@ 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_LANG
return Error; return Error;
} }

2
test/core/core_type_vec4.cpp
View File

@ -216,6 +216,7 @@ int test_vec4_swizzle_partial()
glm::vec4 A(1, 2, 3, 4); glm::vec4 A(1, 2, 3, 4);
# if((GLM_LANG & GLM_LANG_CXXMS_FLAG) && defined(GLM_SWIZZLE))
{ {
glm::vec4 B(A.xy, A.zw); glm::vec4 B(A.xy, A.zw);
Error += A == B ? 0 : 1; Error += A == B ? 0 : 1;
@ -241,6 +242,7 @@ 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_LANG
return Error; return Error;
} }