mirror/glm
1
0
Fork 0
mirror of https://github.com/g-truc/glm.git synced 2024-11-10 04:31:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added fmin, fmax and fclamp to GTX_extended_min_max #372

Browse Source
This commit is contained in:
Christophe Riccio 2017-08-20 18:42:48 +02:00
parent fc53581c68
commit 68a829e7ed
4 changed files with 254 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
glm/gtx/extended_min_max.hpp
View File

@ -130,6 +130,96 @@ namespace glm
C<T> const& z,
C<T> const& w);
/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam genType Floating-point or integer; scalar or vector types.
///
/// @see gtx_extented_min_max
template<typename genType>
GLM_FUNC_DECL genType fmin(genType x, genType y);
/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see gtx_extented_min_max
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fmin(vec<L, T, Q> const& x, T y);
/// Returns y if y < x; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see gtx_extented_min_max
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmin">std::fmin documentation</a>
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fmin(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam genType Floating-point; scalar or vector types.
///
/// @see gtx_extented_min_max
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
template<typename genType>
GLM_FUNC_DECL genType fmax(genType x, genType y);
/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see gtx_extented_min_max
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fmax(vec<L, T, Q> const& x, T y);
/// Returns y if x < y; otherwise, it returns x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see gtx_extented_min_max
/// @see <a href="http://en.cppreference.com/w/cpp/numeric/math/fmax">std::fmax documentation</a>
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fmax(vec<L, T, Q> const& x, vec<L, T, Q> const& y);
/// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam genType Floating-point scalar or vector types.
///
/// @see gtx_extented_min_max
template<typename genType>
GLM_FUNC_DECL genType fclamp(genType x, genType minVal, genType maxVal);
/// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see gtx_extented_min_max
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fclamp(vec<L, T, Q> const& x, T minVal, T maxVal);
/// Returns min(max(x, minVal), maxVal) for each component in x. If one of the two arguments is NaN, the value of the other argument is returned.
///
/// @tparam L Integer between 1 and 4 included that qualify the dimension of the vector
/// @tparam T Floating-point scalar types
/// @tparam Q Value from qualifier enum
///
/// @see gtx_extented_min_max
template<length_t L, typename T, qualifier Q>
GLM_FUNC_DECL vec<L, T, Q> fclamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal);
/// @}
}//namespace glm

79
glm/gtx/extended_min_max.inl
View File

@ -137,4 +137,83 @@ namespace glm
return glm::max(glm::max(x, y), glm::max(z, w));
}
// fmin
# if GLM_HAS_CXX11_STL
using std::fmin;
# else
template<typename genType>
GLM_FUNC_QUALIFIER genType fmin(genType x, genType y)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fmin' only accept floating-point input");
if (isnan(y))
return x;
if (isnan(y))
return x;
return min(x, y);
}
# endif
template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> fmin(vec<L, T, Q> const& a, T b)
{
return detail::functor2<L, T, Q>::call(fmin, a, vec<L, T, Q>(b));
}
template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> fmin(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
{
return detail::functor2<L, T, Q>::call(fmin, a, b);
}
// fmax
# if GLM_HAS_CXX11_STL
using std::fmax;
# else
template<typename genType>
GLM_FUNC_QUALIFIER genType fmax(genType x, genType y)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fmax' only accept floating-point input");
if (isnan(y))
return x;
if (isnan(y))
return x;
return max(x, y);
}
# endif
template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> fmax(vec<L, T, Q> const& a, T b)
{
return detail::functor2<L, T, Q>::call(fmax, a, vec<L, T, Q>(b));
}
template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> fmax(vec<L, T, Q> const& a, vec<L, T, Q> const& b)
{
return detail::functor2<L, T, Q>::call(fmax, a, b);
}
// fclamp
template<typename genType>
GLM_FUNC_QUALIFIER genType fclamp(genType x, genType minVal, genType maxVal)
{
GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'fclamp' only accept floating-point or integer inputs");
return fmin(fmax(x, minVal), maxVal);
}
template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> fclamp(vec<L, T, Q> const& x, T minVal, T maxVal)
{
return fmin(fmax(x, vec<L, T, Q>(minVal)), vec<L, T, Q>(maxVal));
}
template<length_t L, typename T, qualifier Q>
GLM_FUNC_QUALIFIER vec<L, T, Q> fclamp(vec<L, T, Q> const& x, vec<L, T, Q> const& minVal, vec<L, T, Q> const& maxVal)
{
return fmin(fmax(x, minVal), maxVal);
}
}//namespace glm

1
readme.md
View File

@ -62,6 +62,7 @@ glm::mat4 camera(float Translate, glm::vec2 const& Rotate)
- Added packing functions for integer vectors #639
- Added conan packaging configuration #643 #641
- Added quatLookAt to GTX_quaternion #659
- Added fmin, fmax and fclamp to GTX_extended_min_max #372
#### Improvements:
- No more default initialization of vector, matrix and quaternion types

85
test/gtx/gtx_extended_min_max.cpp
View File

@ -1,9 +1,92 @@
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/extended_min_max.hpp>
#include <glm/gtc/vec1.hpp>
#include <glm/gtc/epsilon.hpp>
// This file has divisions by zero to test isnan
#if GLM_COMPILER & GLM_COMPILER_VC
# pragma warning(disable : 4723)
#endif
namespace fmin_
{
static int test()
{
int Error = 0;
float Zero_f = 0.0f;
glm::vec1 A0 = glm::fmin(glm::vec1(1), glm::vec1(Zero_f / 0.0f));
Error += glm::epsilonEqual(A0.x, 1.0f, glm::epsilon<float>()) ? 0 : 1;
glm::vec2 B0 = glm::fmin(glm::vec2(1), glm::vec2(1));
glm::vec2 B1 = glm::fmin(glm::vec2(1), 1.0f);
bool B2 = glm::all(glm::equal(B0, B1));
Error += B2 ? 0 : 1;
glm::vec3 C0 = glm::fmin(glm::vec3(1), glm::vec3(1));
glm::vec3 C1 = glm::fmin(glm::vec3(1), 1.0f);
bool C2 = glm::all(glm::equal(C0, C1));
Error += C2 ? 0 : 1;
glm::vec4 D0 = glm::fmin(glm::vec4(1), glm::vec4(1));
glm::vec4 D1 = glm::fmin(glm::vec4(1), 1.0f);
bool D2 = glm::all(glm::equal(D0, D1));
Error += D2 ? 0 : 1;
return Error;
}
}//namespace fmin_
namespace fmax_
{
static int test()
{
int Error = 0;
float Zero_f = 0.0f;
glm::vec1 A0 = glm::fmax(glm::vec1(1), glm::vec1(Zero_f / 0.0f));
Error += glm::epsilonEqual(A0.x, 1.0f, glm::epsilon<float>()) ? 0 : 1;
glm::vec2 B0 = glm::fmax(glm::vec2(1), glm::vec2(1));
glm::vec2 B1 = glm::fmax(glm::vec2(1), 1.0f);
bool B2 = glm::all(glm::equal(B0, B1));
Error += B2 ? 0 : 1;
glm::vec3 C0 = glm::fmax(glm::vec3(1), glm::vec3(1));
glm::vec3 C1 = glm::fmax(glm::vec3(1), 1.0f);
bool C2 = glm::all(glm::equal(C0, C1));
Error += C2 ? 0 : 1;
glm::vec4 D0 = glm::fmax(glm::vec4(1), glm::vec4(1));
glm::vec4 D1 = glm::fmax(glm::vec4(1), 1.0f);
bool D2 = glm::all(glm::equal(D0, D1));
Error += D2 ? 0 : 1;
return Error;
}
}//namespace fmax_
namespace fclamp_
{
static int test()
{
int Error = 0;
float Zero_f = 0.0f;
glm::vec1 A0 = glm::fclamp(glm::vec1(1), glm::vec1(Zero_f / 0.0f), glm::vec1(2.0f));
Error += glm::epsilonEqual(A0.x, 1.0f, glm::epsilon<float>()) ? 0 : 1;
return Error;
}
}//namespace fclamp_
int main()
{
int Error(0);
int Error = 0;
Error += fmin_::test();
Error += fmax_::test();
Error += fclamp_::test();
return Error;
}