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

Merge branch '0.9.3' of github.com:Groovounet/glm into 0.9.3

Browse Source
This commit is contained in:
Christophe Riccio 2012-05-08 20:58:01 +01:00
commit ff3ad788df
8 changed files with 105 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
glm/core/func_common.inl
View File

@ -804,20 +804,21 @@ namespace detail
} }
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER typename genType::bool_type isnan GLM_FUNC_QUALIFIER bool isnan(genType const & x)
(
genType const & x
)
{ {
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'mix' only accept floating-point inputs"); GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'isnan' only accept floating-point inputs");
#if(GLM_COMPILER & GLM_COMPILER_VC) # if(GLM_COMPILER & GLM_COMPILER_VC)
return typename genType::bool_type(_isnan(x)); return _isnan(x);
#elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) # elif(GLM_COMPILER & GLM_COMPILER_GCC)
return typename genType::bool_type(::isnanf(x)); # if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
#else return _isnan(x) != 0;
return typename genType::bool_type(std::isnan(x)); # else
#endif return std::isnan(x) != 0;
# endif
# else
return std::isnan(x) != 0;
# endif
} }
template <typename T> template <typename T>
@ -857,20 +858,22 @@ namespace detail
} }
template <typename genType> template <typename genType>
GLM_FUNC_QUALIFIER typename genType::bool_type isinf GLM_FUNC_QUALIFIER bool isinf(
( genType const & x)
genType const & x
)
{ {
GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'isinf' only accept floating-point inputs"); GLM_STATIC_ASSERT(detail::type<genType>::is_float, "'isinf' only accept floating-point inputs");
#if(GLM_COMPILER & GLM_COMPILER_VC) # if(GLM_COMPILER & GLM_COMPILER_VC)
return typename genType::bool_type(_fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF); return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
#elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID) # elif(GLM_COMPILER & GLM_COMPILER_GCC)
return typename genType::bool_type(::__isinf(x)); # if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
#else return _isinf(x) != 0;
return typename genType::bool_type(std::isinf(x)); # else
#endif return std::isinf(x) != 0;
# endif
# else
return std::isinf(x) != 0;
# endif
} }
template <typename T> template <typename T>

2
glm/core/setup.hpp
View File

@ -58,7 +58,7 @@
# define GLM_PLATFORM GLM_PLATFORM_WINDOWS # define GLM_PLATFORM GLM_PLATFORM_WINDOWS
#elif defined(__native_client__) #elif defined(__native_client__)
# define GLM_PLATFORM GLM_PLATFORM_CHROME_NACL # define GLM_PLATFORM GLM_PLATFORM_CHROME_NACL
#elif defined(ANDROID) #elif defined(__ANDROID__)
# define GLM_PLATFORM GLM_PLATFORM_ANDROID # define GLM_PLATFORM GLM_PLATFORM_ANDROID
#elif defined(__linux) #elif defined(__linux)
# define GLM_PLATFORM GLM_PLATFORM_LINUX # define GLM_PLATFORM GLM_PLATFORM_LINUX

10
glm/gtx/compatibility.hpp
View File

@ -87,16 +87,6 @@ namespace glm
template <typename valType> detail::tvec3<bool> isfinite(const detail::tvec3<valType>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) template <typename valType> detail::tvec3<bool> isfinite(const detail::tvec3<valType>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename valType> detail::tvec4<bool> isfinite(const detail::tvec4<valType>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility) template <typename valType> detail::tvec4<bool> isfinite(const detail::tvec4<valType>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
template <typename genType> bool isinf(genType const & x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec2<bool> isinf(const detail::tvec2<genType>& x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec3<bool> isinf(const detail::tvec3<genType>& x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec4<bool> isinf(const detail::tvec4<genType>& x); //!< \brief Determines whether the given floating-point value is infinite. (From GLM_GTX_compatibility extension)
template <typename genType> bool isnan(genType const & x); //!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec2<bool> isnan(const detail::tvec2<genType>& x); //!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec3<bool> isnan(const detail::tvec3<genType>& x); //!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
template <typename genType> detail::tvec4<bool> isnan(const detail::tvec4<genType>& x); //!< \brief Checks given floating-point value for not a number (NAN) (From GLM_GTX_compatibility extension)
typedef bool bool1; //!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension) typedef bool bool1; //!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
typedef detail::tvec2<bool> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension) typedef detail::tvec2<bool> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
typedef detail::tvec3<bool> bool3; //!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension) typedef detail::tvec3<bool> bool3; //!< \brief boolean type with 3 components. (From GLM_GTX_compatibility extension)

94
glm/gtx/compatibility.inl
View File

@ -58,98 +58,4 @@ namespace glm
isfinite(x.w)); isfinite(x.w));
} }
// isinf
template <typename genType>
GLM_FUNC_QUALIFIER bool isinf(
genType const & x)
{
# if(GLM_COMPILER & GLM_COMPILER_VC)
return _fpclass(x) == _FPCLASS_NINF || _fpclass(x) == _FPCLASS_PINF;
# elif(GLM_COMPILER & GLM_COMPILER_GCC)
# if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
return _isinf(x) != 0;
# else
return std::isinf(x) != 0;
# endif
# else
return std::isinf(x) != 0;
# endif
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> isinf(
detail::tvec2<valType> const & x)
{
return detail::tvec2<bool>(
isinf(x.x),
isinf(x.y));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> isinf(
detail::tvec3<valType> const & x)
{
return detail::tvec3<bool>(
isinf(x.x),
isinf(x.y),
isinf(x.z));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> isinf(
detail::tvec4<valType> const & x)
{
return detail::tvec4<bool>(
isinf(x.x),
isinf(x.y),
isinf(x.z),
isinf(x.w));
}
// isnan
template <typename genType>
GLM_FUNC_QUALIFIER bool isnan(genType const & x)
{
# if(GLM_COMPILER & GLM_COMPILER_VC)
return _isnan(x);
# elif(GLM_COMPILER & GLM_COMPILER_GCC)
# if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
return _isnan(x) != 0;
# else
return std::isnan(x) != 0;
# endif
# else
return std::isnan(x) != 0;
# endif
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec2<bool> isnan(
detail::tvec2<valType> const & x)
{
return detail::tvec2<bool>(
isnan(x.x),
isnan(x.y));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec3<bool> isnan(
detail::tvec3<valType> const & x)
{
return detail::tvec3<bool>(
isnan(x.x),
isnan(x.y),
isnan(x.z));
}
template <typename valType>
GLM_FUNC_QUALIFIER detail::tvec4<bool> isnan(
detail::tvec4<valType> const & x)
{
return detail::tvec4<bool>(
isnan(x.x),
isnan(x.y),
isnan(x.z),
isnan(x.w));
}
}//namespace glm }//namespace glm

4
glm/virtrev/xstream.hpp
View File

@ -47,7 +47,8 @@
# pragma message("GLM: GLM_VIRTREV_xstream extension included") # pragma message("GLM: GLM_VIRTREV_xstream extension included")
#endif #endif
namespace glm namespace glm{
namespace detail
{ {
template<typename T> template<typename T>
std::ostream & operator << (std::ostream & stream, glm::detail::tvec2<T> const & vec) std::ostream & operator << (std::ostream & stream, glm::detail::tvec2<T> const & vec)
@ -159,6 +160,7 @@ namespace glm
return stream; return stream;
} }
}//namespace detail
}//namespace glm }//namespace glm
#endif//GLM_VIRTREV_xstream #endif//GLM_VIRTREV_xstream

58
test/core/core_func_common.cpp
View File

@ -352,6 +352,62 @@ int test_roundEven()
return Error; return Error;
} }
int test_isnan()
{
int Error = 0;
float Zero_f = 0.0;
double Zero_d = 0.0;
{
Error += true == glm::isnan(0.0/Zero_d) ? 0 : 1;
Error += true == glm::any(glm::isnan(glm::dvec2(0.0f/Zero_f))) ? 0 : 1;
Error += true == glm::any(glm::isnan(glm::dvec3(0.0f/Zero_f))) ? 0 : 1;
Error += true == glm::any(glm::isnan(glm::dvec4(0.0f/Zero_f))) ? 0 : 1;
}
{
Error += true == glm::isnan(0.0f/Zero_f) ? 0 : 1;
Error += true == glm::any(glm::isnan(glm::vec2(0.0f/Zero_f))) ? 0 : 1;
Error += true == glm::any(glm::isnan(glm::vec3(0.0f/Zero_f))) ? 0 : 1;
Error += true == glm::any(glm::isnan(glm::vec4(0.0f/Zero_f))) ? 0 : 1;
}
return Error;
}
int test_isinf()
{
int Error = 0;
float Zero_f = 0.0;
double Zero_d = 0.0;
{
Error += true == glm::isinf( 1.0/Zero_d) ? 0 : 1;
Error += true == glm::isinf(-1.0/Zero_d) ? 0 : 1;
Error += true == glm::any(glm::isinf(glm::dvec2( 1.0/Zero_d))) ? 0 : 1;
Error += true == glm::any(glm::isinf(glm::dvec2(-1.0/Zero_d))) ? 0 : 1;
Error += true == glm::any(glm::isinf(glm::dvec3( 1.0/Zero_d))) ? 0 : 1;
Error += true == glm::any(glm::isinf(glm::dvec3(-1.0/Zero_d))) ? 0 : 1;
Error += true == glm::any(glm::isinf(glm::dvec4( 1.0/Zero_d))) ? 0 : 1;
Error += true == glm::any(glm::isinf(glm::dvec4(-1.0/Zero_d))) ? 0 : 1;
}
{
Error += true == glm::isinf( 1.0f/Zero_f) ? 0 : 1;
Error += true == glm::isinf(-1.0f/Zero_f) ? 0 : 1;
Error += true == glm::any(glm::isinf(glm::vec2( 1.0f/Zero_f))) ? 0 : 1;
Error += true == glm::any(glm::isinf(glm::vec2(-1.0f/Zero_f))) ? 0 : 1;
Error += true == glm::any(glm::isinf(glm::vec3( 1.0f/Zero_f))) ? 0 : 1;
Error += true == glm::any(glm::isinf(glm::vec3(-1.0f/Zero_f))) ? 0 : 1;
Error += true == glm::any(glm::isinf(glm::vec4( 1.0f/Zero_f))) ? 0 : 1;
Error += true == glm::any(glm::isinf(glm::vec4(-1.0f/Zero_f))) ? 0 : 1;
}
return Error;
}
int main() int main()
{ {
int Error(0); int Error(0);
@ -362,6 +418,8 @@ int main()
Error += test_mix(); Error += test_mix();
Error += test_round(); Error += test_round();
Error += test_roundEven(); Error += test_roundEven();
Error += test_isnan();
Error += test_isinf();
return Error; return Error;
} }

20
test/core/core_func_swizzle.cpp
View File

@ -7,11 +7,21 @@
// File : test/core/core_func_swizzle.cpp // File : test/core/core_func_swizzle.cpp
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
#define GLM_FORCE_ONLY_XYZW #ifndef GLM_FORCE_ONLY_XYZW
//#define GLM_FORCE_PURE # define GLM_FORCE_ONLY_XYZW
#define GLM_MESSAGES #endif
#define GLM_SWIZZLE //#ifndef GLM_FORCE_PURE
#define GLM_FORCE_CXX98 //# define GLM_FORCE_PURE
//#endif
#ifndef GLM_MESSAGES
# define GLM_MESSAGES
#endif
#ifndef GLM_SWIZZLE
# define GLM_SWIZZLE
#endif
#ifndef GLM_FORCE_CXX98
# define GLM_FORCE_CXX98
#endif
#include <glm/glm.hpp> #include <glm/glm.hpp>
int test_vec2_swizzle() int test_vec2_swizzle()

4
test/gtx/gtx_integer.cpp
View File

@ -53,8 +53,8 @@ int test_nlz()
{ {
int Error = 0; int Error = 0;
for(std::size_t i = 1; i < 33; ++i) for(glm::uint i = 1; i < glm::uint(33); ++i)
Error += glm::nlz(i) == 31u - glm::findMSB(i) ? 0 : 1; Error += glm::nlz(i) == glm::uint(31u) - glm::findMSB(i) ? 0 : 1;
//printf("%d, %d\n", glm::nlz(i), 31u - glm::findMSB(i)); //printf("%d, %d\n", glm::nlz(i), 31u - glm::findMSB(i));
return Error; return Error;