anulax
/
glm
1
0
Fork 0
Code Issues Pull Requests Packages project_board Releases Wiki Activity

Fixed mix function for bool and bvec* type third parameter, issue #59

Browse Source
master
Christophe Riccio ago%!(EXTRA string=12 years)
parent 356e70e653
commit dab66f81e5
6 changed files with 142 additions and 74 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      glm/core/func_common.hpp
  2. 167
      glm/core/func_common.inl
  3. 14
      glm/gtc/half_float.hpp
  4. 11
      glm/gtc/half_float.inl
  5. 3
      readme.txt
  6. 19
      test/core/core_func_common.cpp

2
glm/core/func_common.hpp
Unescape View File

@ -220,7 +220,7 @@ namespace glm
///
/// If genTypeU is a boolean scalar or vector:
/// Selects which vector each returned component comes
/// from. For a component of a that is false, the
/// from. For a component of <a> that is false, the
/// corresponding component of x is returned. For a
/// component of a that is true, the corresponding
/// component of y is returned. Components of x and y that

167
glm/core/func_common.inl
Unescape View File

@ -420,93 +420,87 @@ namespace detail
}
// mix
template <typename genTypeT, typename genTypeU>
GLM_FUNC_QUALIFIER genTypeT mix
template <typename genType>
GLM_FUNC_QUALIFIER genType mix
(
genTypeT const & x,
genTypeT const & y,
genTypeU const & a
genType const & x,
genType const & y,
genType const & a
)
{
// It could be a vector too
//GLM_STATIC_ASSERT(
// detail::type<genTypeT>::is_float &&
// detail::type<genTypeU>::is_float);
GLM_STATIC_ASSERT(detail::type<genType>::is_float , "'genType' is not floating-point type");
//return x + a * (y - x);
return genTypeT(genTypeU(x) + a * genTypeU(y - x));
return x + a * (y - x);
}
template <typename valTypeA, typename valTypeB>
GLM_FUNC_QUALIFIER detail::tvec2<valTypeA> mix
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<valType> mix
(
detail::tvec2<valTypeA> const & x,
detail::tvec2<valTypeA> const & y,
valTypeB const & a
detail::tvec2<valType> const & x,
detail::tvec2<valType> const & y,
valType const & a
)
{
return detail::tvec2<valTypeA>(
detail::tvec2<valTypeB>(x) + a * detail::tvec2<valTypeB>(y - x));
GLM_STATIC_ASSERT(detail::type<valType>::is_float , "'genType' is not floating-point type");
return x + a * (y - x);
}
template <typename valTypeA, typename valTypeB>
GLM_FUNC_QUALIFIER detail::tvec3<valTypeA> mix
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> mix
(
detail::tvec3<valTypeA> const & x,
detail::tvec3<valTypeA> const & y,
valTypeB const & a
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y,
valType const & a
)
{
return detail::tvec3<valTypeA>(
detail::tvec3<valTypeB>(x) + a * detail::tvec3<valTypeB>(y - x));
return x + a * (y - x);
}
template <typename valTypeA, typename valTypeB>
GLM_FUNC_QUALIFIER detail::tvec4<valTypeA> mix
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<valType> mix
(
detail::tvec4<valTypeA> const & x,
detail::tvec4<valTypeA> const & y,
valTypeB const & a
detail::tvec4<valType> const & x,
detail::tvec4<valType> const & y,
valType const & a
)
{
return detail::tvec4<valTypeA>(
detail::tvec4<valTypeB>(x) + a * detail::tvec4<valTypeB>(y - x));
return x + a * (y - x);
}
template <typename valTypeA, typename valTypeB>
GLM_FUNC_QUALIFIER detail::tvec2<valTypeA> mix
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<valType> mix
(
detail::tvec2<valTypeA> const & x,
detail::tvec2<valTypeA> const & y,
detail::tvec2<valTypeB> const & a
detail::tvec2<valType> const & x,
detail::tvec2<valType> const & y,
detail::tvec2<valType> const & a
)
{
return detail::tvec2<valTypeA>(
detail::tvec2<valTypeB>(x) + a * detail::tvec2<valTypeB>(y - x));
return x + a * (y - x);
}
template <typename valTypeA, typename valTypeB>
GLM_FUNC_QUALIFIER detail::tvec3<valTypeA> mix
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<valType> mix
(
detail::tvec3<valTypeA> const & x,
detail::tvec3<valTypeA> const & y,
detail::tvec3<valTypeB> const & a
detail::tvec3<valType> const & x,
detail::tvec3<valType> const & y,
detail::tvec3<valType> const & a
)
{
return detail::tvec3<valTypeA>(
detail::tvec3<valTypeB>(x) + a * detail::tvec3<valTypeB>(y - x));
GLM_STATIC_ASSERT(detail::type<valType>::is_float , "'genType' is not floating-point type");
return x + a * (y - x);
}
template <typename valTypeA, typename valTypeB>
GLM_FUNC_QUALIFIER detail::tvec4<valTypeA> mix
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<valType> mix
(
detail::tvec4<valTypeA> const & x,
detail::tvec4<valTypeA> const & y,
detail::tvec4<valTypeB> const & a
detail::tvec4<valType> const & x,
detail::tvec4<valType> const & y,
detail::tvec4<valType> const & a
)
{
return detail::tvec4<valTypeA>(
detail::tvec4<valTypeB>(x) + a * detail::tvec4<valTypeB>(y - x));
return x + a * (y - x);
}
//template <typename genTypeT>
@ -525,15 +519,63 @@ namespace detail
// return x + a * (y - x);
//}
template <typename genType>
GLM_FUNC_QUALIFIER genType mix
template <>
GLM_FUNC_QUALIFIER float mix
(
genType const & x,
genType const & y,
float const & x,
float const & y,
bool const & a
)
{
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mix' only accept floating-point inputs");
return a ? y : x;
}
template <>
GLM_FUNC_QUALIFIER double mix
(
double const & x,
double const & y,
bool const & a
)
{
return a ? y : x;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec2<T> mix
(
detail::tvec2<T> const & x,
detail::tvec2<T> const & y,
bool a
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
return a ? y : x;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec3<T> mix
(
detail::tvec3<T> const & x,
detail::tvec3<T> const & y,
bool a
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
return a ? y : x;
}
template <typename T>
GLM_FUNC_QUALIFIER detail::tvec4<T> mix
(
detail::tvec4<T> const & x,
detail::tvec4<T> const & y,
bool a
)
{
GLM_STATIC_ASSERT(detail::type<T>::is_float, "'mix' only accept floating-point inputs");
return a ? y : x;
}
@ -552,8 +594,7 @@ namespace detail
for
(
typename detail::tvec2<T>::size_type i = 0;
i < detail::tvec2<T>::value_size();
++i
i < x.length(); ++i
)
{
result[i] = a[i] ? y[i] : x[i];
@ -575,8 +616,7 @@ namespace detail
for
(
typename detail::tvec3<T>::size_type i = 0;
i < detail::tvec3<T>::value_size();
++i
i < x.length(); ++i
)
{
result[i] = a[i] ? y[i] : x[i];
@ -598,8 +638,7 @@ namespace detail
for
(
typename detail::tvec4<T>::size_type i = 0;
i < detail::tvec4<T>::value_size();
++i
i < x.length(); ++i
)
{
result[i] = a[i] ? y[i] : x[i];

14
glm/gtc/half_float.hpp
Unescape View File

@ -432,6 +432,20 @@ namespace detail
/// @see gtc_half_float
hvec4 abs(hvec4 const & x);
/// Selects which vector each returned component comes
/// from. For a component of <a> that is false, the
/// corresponding component of x is returned. For a
/// component of a that is true, the corresponding
/// component of y is returned. Components of x and y that
/// are not selected are allowed to be invalid floating point
/// values and will have no effect on the results. Thus, this
/// provides different functionality than
/// genType mix(genType x, genType y, genType(a))
/// where a is a Boolean vector.
///
/// @see gtc_half_float
half mix(half const & x, half const & y, bool const & a);
/// @}
}// namespace glm

11
glm/gtc/half_float.inl
Unescape View File

@ -1036,4 +1036,15 @@ namespace detail
float(v.w) >= float(0) ? v.w : -v.w);
}
template <>
GLM_FUNC_QUALIFIER glm::half mix
(
glm::half const & x,
glm::half const & y,
bool const & a
)
{
return a ? y : x;
}
}//namespace glm

3
readme.txt
Unescape View File

@ -47,7 +47,8 @@ GLM 0.9.4.3: 2013-03-17
- Added a docx copy of the manual
- Fixed GLM_GTX_matrix_interpolation
- Fixed isnan and isinf on Android with Clang
- Autodetected C++ version using __cplusplus value
- Fixed mix for bool and bvec* third parameter
================================================================================
GLM 0.9.4.2: 2013-02-14

19
test/core/core_func_common.cpp
Unescape View File

@ -189,7 +189,8 @@ namespace test_mix
{glm::vec2(0.0f), glm::vec2(1.0f), glm::bvec2(false), glm::vec2(0.0f)},
{glm::vec2(0.0f), glm::vec2(1.0f), glm::bvec2(true), glm::vec2(1.0f)},
{glm::vec2(-1.0f), glm::vec2(1.0f), glm::bvec2(false), glm::vec2(-1.0f)},
{glm::vec2(-1.0f), glm::vec2(1.0f), glm::bvec2(true), glm::vec2(1.0f)}
{glm::vec2(-1.0f), glm::vec2(1.0f), glm::bvec2(true), glm::vec2(1.0f)},
{glm::vec2(-1.0f), glm::vec2(1.0f), glm::bvec2(true, false), glm::vec2(1.0f, -1.0f)}
};
test<glm::vec3, bool> TestVec3Bool[] =
@ -205,7 +206,8 @@ namespace test_mix
{glm::vec3(0.0f), glm::vec3(1.0f), glm::bvec3(false), glm::vec3(0.0f)},
{glm::vec3(0.0f), glm::vec3(1.0f), glm::bvec3(true), glm::vec3(1.0f)},
{glm::vec3(-1.0f), glm::vec3(1.0f), glm::bvec3(false), glm::vec3(-1.0f)},
{glm::vec3(-1.0f), glm::vec3(1.0f), glm::bvec3(true), glm::vec3(1.0f)}
{glm::vec3(-1.0f), glm::vec3(1.0f), glm::bvec3(true), glm::vec3(1.0f)},
{glm::vec3(1.0f, 2.0f, 3.0f), glm::vec3(4.0f, 5.0f, 6.0f), glm::bvec3(true, false, true), glm::vec3(4.0f, 2.0f, 6.0f)}
};
test<glm::vec4, bool> TestVec4Bool[] =
@ -221,7 +223,8 @@ namespace test_mix
{glm::vec4(0.0f), glm::vec4(1.0f), glm::bvec4(false), glm::vec4(0.0f)},
{glm::vec4(0.0f), glm::vec4(1.0f), glm::bvec4(true), glm::vec4(1.0f)},
{glm::vec4(-1.0f), glm::vec4(1.0f), glm::bvec4(false), glm::vec4(-1.0f)},
{glm::vec4(-1.0f), glm::vec4(1.0f), glm::bvec4(true), glm::vec4(1.0f)}
{glm::vec4(-1.0f), glm::vec4(1.0f), glm::bvec4(true), glm::vec4(1.0f)},
{glm::vec4(1.0f, 2.0f, 3.0f, 4.0f), glm::vec4(5.0f, 6.0f, 7.0f, 8.0f), glm::bvec4(true, false, true, false), glm::vec4(5.0f, 2.0f, 7.0f, 4.0f)}
};
int run()
@ -292,7 +295,7 @@ namespace test_mix
{
for(std::size_t i = 0; i < sizeof(TestVec4Bool) / sizeof(test<glm::vec4, bool>); ++i)
{
glm::vec3 Result = glm::mix(TestVec4Bool[i].x, TestVec4Bool[i].y, TestVec4Bool[i].a);
glm::vec4 Result = glm::mix(TestVec4Bool[i].x, TestVec4Bool[i].y, TestVec4Bool[i].a);
Error += glm::epsilonEqual(Result.x, TestVec4Bool[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
Error += glm::epsilonEqual(Result.y, TestVec4Bool[i].Result.y, glm::epsilon<float>()) ? 0 : 1;
Error += glm::epsilonEqual(Result.z, TestVec4Bool[i].Result.z, glm::epsilon<float>()) ? 0 : 1;
@ -305,10 +308,10 @@ namespace test_mix
for(std::size_t i = 0; i < sizeof(TestBVec4) / sizeof(test<glm::vec4, glm::bvec4>); ++i)
{
glm::vec4 Result = glm::mix(TestBVec4[i].x, TestBVec4[i].y, TestBVec4[i].a);
Error += glm::epsilonEqual(Result.x, TestBVec3[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
Error += glm::epsilonEqual(Result.y, TestBVec3[i].Result.y, glm::epsilon<float>()) ? 0 : 1;
Error += glm::epsilonEqual(Result.z, TestBVec3[i].Result.z, glm::epsilon<float>()) ? 0 : 1;
Error += glm::epsilonEqual(Result.w, TestBVec3[i].Result.w, glm::epsilon<float>()) ? 0 : 1;
Error += glm::epsilonEqual(Result.x, TestBVec4[i].Result.x, glm::epsilon<float>()) ? 0 : 1;
Error += glm::epsilonEqual(Result.y, TestBVec4[i].Result.y, glm::epsilon<float>()) ? 0 : 1;
Error += glm::epsilonEqual(Result.z, TestBVec4[i].Result.z, glm::epsilon<float>()) ? 0 : 1;
Error += glm::epsilonEqual(Result.w, TestBVec4[i].Result.w, glm::epsilon<float>()) ? 0 : 1;
}
}

Write Preview
Loading…
Cancel
Save