parent
efd4087b1c
commit
899f388921
@ -160,7 +160,7 @@ namespace detail
|
||||
template <typename T, precision P>
|
||||
struct compute_sqrt<detail::tvec1, T, P>
|
||||
{
|
||||
static detail::tvec1<T, P> call(detail::tvec1<T, P> const & x)
|
||||
GLM_FUNC_QUALIFIER static detail::tvec1<T, P> call(detail::tvec1<T, P> const & x)
|
||||
{
|
||||
return detail::tvec1<T, P>(std::sqrt(x.x));
|
||||
}
|
||||
@ -169,7 +169,7 @@ namespace detail
|
||||
template <typename T, precision P>
|
||||
struct compute_sqrt<detail::tvec2, T, P>
|
||||
{
|
||||
static detail::tvec2<T, P> call(detail::tvec2<T, P> const & x)
|
||||
GLM_FUNC_QUALIFIER static detail::tvec2<T, P> call(detail::tvec2<T, P> const & x)
|
||||
{
|
||||
return detail::tvec2<T, P>(std::sqrt(x.x), std::sqrt(x.y));
|
||||
}
|
||||
@ -178,7 +178,7 @@ namespace detail
|
||||
template <typename T, precision P>
|
||||
struct compute_sqrt<detail::tvec3, T, P>
|
||||
{
|
||||
static detail::tvec3<T, P> call(detail::tvec3<T, P> const & x)
|
||||
GLM_FUNC_QUALIFIER static detail::tvec3<T, P> call(detail::tvec3<T, P> const & x)
|
||||
{
|
||||
return detail::tvec3<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z));
|
||||
}
|
||||
@ -187,7 +187,7 @@ namespace detail
|
||||
template <typename T, precision P>
|
||||
struct compute_sqrt<detail::tvec4, T, P>
|
||||
{
|
||||
static detail::tvec4<T, P> call(detail::tvec4<T, P> const & x)
|
||||
GLM_FUNC_QUALIFIER static detail::tvec4<T, P> call(detail::tvec4<T, P> const & x)
|
||||
{
|
||||
return detail::tvec4<T, P>(std::sqrt(x.x), std::sqrt(x.y), std::sqrt(x.z), std::sqrt(x.w));
|
||||
}
|
||||
|
@ -120,7 +120,9 @@
|
||||
#include "./gtx/rotate_vector.hpp"
|
||||
#include "./gtx/spline.hpp"
|
||||
#include "./gtx/std_based_type.hpp"
|
||||
#include "./gtx/string_cast.hpp"
|
||||
#if(!(GLM_COMPILER & GLM_COMPILER_CUDA))
|
||||
# include "./gtx/string_cast.hpp"
|
||||
#endif
|
||||
#include "./gtx/transform.hpp"
|
||||
#include "./gtx/transform2.hpp"
|
||||
#include "./gtx/vec1.hpp"
|
||||
|
@ -44,27 +44,6 @@ namespace glm
|
||||
return Result;
|
||||
}
|
||||
|
||||
|
||||
template <typename T, precision P>
|
||||
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> translate_slow
|
||||
(
|
||||
detail::tmat4x4<T, P> const & m,
|
||||
detail::tvec3<T, P> const & v
|
||||
)
|
||||
{
|
||||
detail::tmat4x4<T, P> Result(T(1));
|
||||
Result[3] = detail::tvec4<T, P>(v, T(1));
|
||||
return m * Result;
|
||||
|
||||
//detail::tmat4x4<valType> Result(m);
|
||||
Result[3] = m[0] * v[0] + m[1] * v[1] + m[2] * v[2] + m[3];
|
||||
//Result[3][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2] + m[3][0];
|
||||
//Result[3][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2] + m[3][1];
|
||||
//Result[3][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
|
||||
//Result[3][3] = m[0][3] * v[0] + m[1][3] * v[1] + m[2][3] * v[2] + m[3][3];
|
||||
//return Result;
|
||||
}
|
||||
|
||||
template <typename T, precision P>
|
||||
GLM_FUNC_QUALIFIER detail::tmat4x4<T, P> rotate
|
||||
(
|
||||
|
@ -194,24 +194,30 @@ namespace detail
|
||||
# pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#if((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
|
||||
# define GLM_NEXT_AFTER_FLT(x, toward) glm::detail::nextafterf((x), (toward))
|
||||
# define GLM_NEXT_AFTER_DBL(x, toward) _nextafter((x), (toward))
|
||||
#else
|
||||
# define GLM_NEXT_AFTER_FLT(x, toward) nextafterf((x), (toward))
|
||||
# define GLM_NEXT_AFTER_DBL(x, toward) nextafter((x), (toward))
|
||||
#endif
|
||||
|
||||
namespace glm
|
||||
{
|
||||
template <>
|
||||
GLM_FUNC_QUALIFIER float next_float(float const & x)
|
||||
{
|
||||
return GLM_NEXT_AFTER_FLT(x, std::numeric_limits<float>::max());
|
||||
# if((GLM_LANG & GLM_LANG_CXX11_FLAG))
|
||||
return std::nextafter(x, std::numeric_limits<float>::max());
|
||||
# elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
|
||||
return detail::nextafterf(x, FLT_MAX);
|
||||
# else
|
||||
return nextafterf(x, FLT_MAX);
|
||||
# endif
|
||||
}
|
||||
|
||||
template <>
|
||||
GLM_FUNC_QUALIFIER double next_float(double const & x)
|
||||
{
|
||||
return GLM_NEXT_AFTER_DBL(x, std::numeric_limits<double>::max());
|
||||
# if((GLM_LANG & GLM_LANG_CXX11_FLAG))
|
||||
return std::nextafter(x, std::numeric_limits<double>::max());
|
||||
# elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
|
||||
return detail::nextafterf(x, std::numeric_limits<float>::max());
|
||||
# else
|
||||
return nextafter(x, DBL_MAX);
|
||||
# endif
|
||||
}
|
||||
|
||||
template<typename T, precision P, template<typename, precision> class vecType>
|
||||
@ -225,12 +231,24 @@ namespace glm
|
||||
|
||||
GLM_FUNC_QUALIFIER float prev_float(float const & x)
|
||||
{
|
||||
return GLM_NEXT_AFTER_FLT(x, std::numeric_limits<float>::min());
|
||||
# if((GLM_LANG & GLM_LANG_CXX11_FLAG))
|
||||
return std::nextafter(x, std::numeric_limits<float>::min());
|
||||
# elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
|
||||
return detail::nextafterf(x, FLT_MIN);
|
||||
# else
|
||||
return nextafterf(x, FLT_MIN);
|
||||
# endif
|
||||
}
|
||||
|
||||
GLM_FUNC_QUALIFIER double prev_float(double const & x)
|
||||
{
|
||||
return GLM_NEXT_AFTER_DBL(x, std::numeric_limits<double>::min());
|
||||
# if((GLM_LANG & GLM_LANG_CXX11_FLAG))
|
||||
return std::nextafter(x, std::numeric_limits<float>::min());
|
||||
# elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
|
||||
return _nextafter(x, DBL_MIN);
|
||||
# else
|
||||
return nextafter(x, DBL_MIN);
|
||||
# endif
|
||||
}
|
||||
|
||||
template<typename T, precision P, template<typename, precision> class vecType>
|
||||
|
@ -312,13 +312,13 @@ namespace glm
|
||||
namespace detail
|
||||
{
|
||||
template <typename PARAM, typename RET>
|
||||
RET bitfieldInterleave(PARAM x, PARAM y);
|
||||
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y);
|
||||
|
||||
template <typename PARAM, typename RET>
|
||||
RET bitfieldInterleave(PARAM x, PARAM y, PARAM z);
|
||||
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z);
|
||||
|
||||
template <typename PARAM, typename RET>
|
||||
RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w);
|
||||
GLM_FUNC_DECL RET bitfieldInterleave(PARAM x, PARAM y, PARAM z, PARAM w);
|
||||
|
||||
/*
|
||||
template <typename PARAM, typename RET>
|
||||
@ -358,7 +358,7 @@ namespace glm
|
||||
}
|
||||
*/
|
||||
template <>
|
||||
inline glm::uint16 bitfieldInterleave(glm::uint8 x, glm::uint8 y)
|
||||
GLM_FUNC_QUALIFIER glm::uint16 bitfieldInterleave(glm::uint8 x, glm::uint8 y)
|
||||
{
|
||||
glm::uint16 REG1(x);
|
||||
glm::uint16 REG2(y);
|
||||
@ -376,7 +376,7 @@ namespace glm
|
||||
}
|
||||
|
||||
template <>
|
||||
inline glm::uint32 bitfieldInterleave(glm::uint16 x, glm::uint16 y)
|
||||
GLM_FUNC_QUALIFIER glm::uint32 bitfieldInterleave(glm::uint16 x, glm::uint16 y)
|
||||
{
|
||||
glm::uint32 REG1(x);
|
||||
glm::uint32 REG2(y);
|
||||
@ -397,7 +397,7 @@ namespace glm
|
||||
}
|
||||
|
||||
template <>
|
||||
inline glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y)
|
||||
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y)
|
||||
{
|
||||
glm::uint64 REG1(x);
|
||||
glm::uint64 REG2(y);
|
||||
@ -421,7 +421,7 @@ namespace glm
|
||||
}
|
||||
|
||||
template <>
|
||||
inline glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y, glm::uint32 z)
|
||||
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint32 x, glm::uint32 y, glm::uint32 z)
|
||||
{
|
||||
glm::uint64 REG1(x);
|
||||
glm::uint64 REG2(y);
|
||||
@ -451,7 +451,7 @@ namespace glm
|
||||
}
|
||||
|
||||
template <>
|
||||
inline glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z, glm::uint16 w)
|
||||
GLM_FUNC_QUALIFIER glm::uint64 bitfieldInterleave(glm::uint16 x, glm::uint16 y, glm::uint16 z, glm::uint16 w)
|
||||
{
|
||||
glm::uint64 REG1(x);
|
||||
glm::uint64 REG2(y);
|
||||
@ -482,7 +482,7 @@ namespace glm
|
||||
}
|
||||
}//namespace detail
|
||||
|
||||
inline int16 bitfieldInterleave(int8 x, int8 y)
|
||||
GLM_FUNC_QUALIFIER int16 bitfieldInterleave(int8 x, int8 y)
|
||||
{
|
||||
union sign8
|
||||
{
|
||||
@ -503,12 +503,12 @@ namespace glm
|
||||
return result.i;
|
||||
}
|
||||
|
||||
inline uint16 bitfieldInterleave(uint8 x, uint8 y)
|
||||
GLM_FUNC_QUALIFIER uint16 bitfieldInterleave(uint8 x, uint8 y)
|
||||
{
|
||||
return detail::bitfieldInterleave<uint8, uint16>(x, y);
|
||||
}
|
||||
|
||||
inline int32 bitfieldInterleave(int16 x, int16 y)
|
||||
GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int16 x, int16 y)
|
||||
{
|
||||
union sign16
|
||||
{
|
||||
@ -529,12 +529,12 @@ namespace glm
|
||||
return result.i;
|
||||
}
|
||||
|
||||
inline uint32 bitfieldInterleave(uint16 x, uint16 y)
|
||||
GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint16 x, uint16 y)
|
||||
{
|
||||
return detail::bitfieldInterleave<uint16, uint32>(x, y);
|
||||
}
|
||||
|
||||
inline int64 bitfieldInterleave(int32 x, int32 y)
|
||||
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y)
|
||||
{
|
||||
union sign32
|
||||
{
|
||||
@ -555,12 +555,12 @@ namespace glm
|
||||
return result.i;
|
||||
}
|
||||
|
||||
inline uint64 bitfieldInterleave(uint32 x, uint32 y)
|
||||
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y)
|
||||
{
|
||||
return detail::bitfieldInterleave<uint32, uint64>(x, y);
|
||||
}
|
||||
|
||||
inline int32 bitfieldInterleave(int8 x, int8 y, int8 z)
|
||||
GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z)
|
||||
{
|
||||
union sign8
|
||||
{
|
||||
@ -582,12 +582,12 @@ namespace glm
|
||||
return result.i;
|
||||
}
|
||||
|
||||
inline uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z)
|
||||
GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z)
|
||||
{
|
||||
return detail::bitfieldInterleave<uint8, uint32>(x, y, z);
|
||||
}
|
||||
|
||||
inline int64 bitfieldInterleave(int16 x, int16 y, int16 z)
|
||||
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z)
|
||||
{
|
||||
union sign16
|
||||
{
|
||||
@ -609,12 +609,12 @@ namespace glm
|
||||
return result.i;
|
||||
}
|
||||
|
||||
inline uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z)
|
||||
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z)
|
||||
{
|
||||
return detail::bitfieldInterleave<uint32, uint64>(x, y, z);
|
||||
}
|
||||
|
||||
inline int64 bitfieldInterleave(int32 x, int32 y, int32 z)
|
||||
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int32 x, int32 y, int32 z)
|
||||
{
|
||||
union sign16
|
||||
{
|
||||
@ -636,12 +636,12 @@ namespace glm
|
||||
return result.i;
|
||||
}
|
||||
|
||||
inline uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z)
|
||||
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint32 x, uint32 y, uint32 z)
|
||||
{
|
||||
return detail::bitfieldInterleave<uint32, uint64>(x, y, z);
|
||||
}
|
||||
|
||||
inline int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w)
|
||||
GLM_FUNC_QUALIFIER int32 bitfieldInterleave(int8 x, int8 y, int8 z, int8 w)
|
||||
{
|
||||
union sign8
|
||||
{
|
||||
@ -659,17 +659,17 @@ namespace glm
|
||||
sign_y.i = y;
|
||||
sign_z.i = z;
|
||||
sign_w.i = w;
|
||||
result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);
|
||||
result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u);
|
||||
|
||||
return result.i;
|
||||
}
|
||||
|
||||
inline uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w)
|
||||
GLM_FUNC_QUALIFIER uint32 bitfieldInterleave(uint8 x, uint8 y, uint8 z, uint8 w)
|
||||
{
|
||||
return detail::bitfieldInterleave<uint8, uint32>(x, y, z, w);
|
||||
}
|
||||
|
||||
inline int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w)
|
||||
GLM_FUNC_QUALIFIER int64 bitfieldInterleave(int16 x, int16 y, int16 z, int16 w)
|
||||
{
|
||||
union sign16
|
||||
{
|
||||
@ -687,12 +687,12 @@ namespace glm
|
||||
sign_y.i = y;
|
||||
sign_z.i = z;
|
||||
sign_w.i = w;
|
||||
result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u);
|
||||
result.u = bitfieldInterleave(sign_x.u, sign_y.u, sign_z.u, sign_w.u);
|
||||
|
||||
return result.i;
|
||||
}
|
||||
|
||||
inline uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w)
|
||||
GLM_FUNC_QUALIFIER uint64 bitfieldInterleave(uint16 x, uint16 y, uint16 z, uint16 w)
|
||||
{
|
||||
return detail::bitfieldInterleave<uint16, uint64>(x, y, z, w);
|
||||
}
|
||||
|
@ -82,10 +82,10 @@ namespace glm
|
||||
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec3<T, P> atan2(const detail::tvec3<T, P>& x, const detail::tvec3<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
|
||||
template <typename T, precision P> GLM_FUNC_QUALIFIER detail::tvec4<T, P> atan2(const detail::tvec4<T, P>& x, const detail::tvec4<T, P>& y){return atan(x, y);} //!< \brief Arc tangent. Returns an angle whose tangent is y/x. The signs of x and y are used to determine what quadrant the angle is in. The range of values returned by this function is [-PI, PI]. Results are undefined if x and y are both 0. (From GLM_GTX_compatibility)
|
||||
|
||||
template <typename genType> bool isfinite(genType const & x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
|
||||
template <typename T, precision P> detail::tvec2<bool, P> isfinite(const detail::tvec2<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
|
||||
template <typename T, precision P> detail::tvec3<bool, P> isfinite(const detail::tvec3<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
|
||||
template <typename T, precision P> detail::tvec4<bool, P> isfinite(const detail::tvec4<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
|
||||
template <typename genType> GLM_FUNC_DECL bool isfinite(genType const & x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
|
||||
template <typename T, precision P> GLM_FUNC_DECL detail::tvec2<bool, P> isfinite(const detail::tvec2<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
|
||||
template <typename T, precision P> GLM_FUNC_DECL detail::tvec3<bool, P> isfinite(const detail::tvec3<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
|
||||
template <typename T, precision P> GLM_FUNC_DECL detail::tvec4<bool, P> isfinite(const detail::tvec4<T, P>& x); //!< \brief Test whether or not a scalar or each vector component is a finite value. (From GLM_GTX_compatibility)
|
||||
|
||||
typedef bool bool1; //!< \brief boolean type with 1 component. (From GLM_GTX_compatibility extension)
|
||||
typedef detail::tvec2<bool, highp> bool2; //!< \brief boolean type with 2 components. (From GLM_GTX_compatibility extension)
|
||||
|
@ -14,16 +14,14 @@ namespace glm
|
||||
GLM_FUNC_QUALIFIER bool isfinite(
|
||||
genType const & x)
|
||||
{
|
||||
# if(GLM_COMPILER & GLM_COMPILER_VC)
|
||||
return _finite(x);
|
||||
# elif(GLM_COMPILER & GLM_COMPILER_GCC)
|
||||
# if(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
|
||||
return _isfinite(x) != 0;
|
||||
# else
|
||||
return std::isfinite(x) != 0;
|
||||
# endif
|
||||
# else
|
||||
# if(GLM_LANG & GLM_LANG_CXX11_FLAG)
|
||||
return std::isfinite(x) != 0;
|
||||
# elif(GLM_COMPILER & GLM_COMPILER_VC)
|
||||
return _finite(x);
|
||||
# elif(GLM_COMPILER & GLM_COMPILER_GCC && GLM_PLATFORM & GLM_PLATFORM_ANDROID)
|
||||
return _isfinite(x) != 0;
|
||||
# else
|
||||
return isfinite(x) != 0;
|
||||
# endif
|
||||
}
|
||||
|
||||
|
@ -142,14 +142,14 @@ namespace detail
|
||||
///
|
||||
/// @see gtc_dual_quaternion
|
||||
template <typename T, precision P>
|
||||
detail::tdualquat<T, P> normalize(
|
||||
GLM_FUNC_DECL detail::tdualquat<T, P> normalize(
|
||||
detail::tdualquat<T, P> const & q);
|
||||
|
||||
/// Returns the linear interpolation of two dual quaternion.
|
||||
///
|
||||
/// @see gtc_dual_quaternion
|
||||
template <typename T, precision P>
|
||||
detail::tdualquat<T, P> lerp(
|
||||
GLM_FUNC_DECL detail::tdualquat<T, P> lerp(
|
||||
detail::tdualquat<T, P> const & x,
|
||||
detail::tdualquat<T, P> const & y,
|
||||
T const & a);
|
||||
@ -158,7 +158,7 @@ namespace detail
|
||||
///
|
||||
/// @see gtc_dual_quaternion
|
||||
template <typename T, precision P>
|
||||
detail::tdualquat<T, P> inverse(
|
||||
GLM_FUNC_DECL detail::tdualquat<T, P> inverse(
|
||||
detail::tdualquat<T, P> const & q);
|
||||
|
||||
/*
|
||||
@ -175,28 +175,28 @@ namespace detail
|
||||
///
|
||||
/// @see gtc_dual_quaternion
|
||||
template <typename T, precision P>
|
||||
detail::tmat2x4<T, P> mat2x4_cast(
|
||||
GLM_FUNC_DECL detail::tmat2x4<T, P> mat2x4_cast(
|
||||
detail::tdualquat<T, P> const & x);
|
||||
|
||||
/// Converts a quaternion to a 3 * 4 matrix.
|
||||
///
|
||||
/// @see gtc_dual_quaternion
|
||||
template <typename T, precision P>
|
||||
detail::tmat3x4<T, P> mat3x4_cast(
|
||||
GLM_FUNC_DECL detail::tmat3x4<T, P> mat3x4_cast(
|
||||
detail::tdualquat<T, P> const & x);
|
||||
|
||||
/// Converts a 2 * 4 matrix (matrix which holds real and dual parts) to a quaternion.
|
||||
///
|
||||
/// @see gtc_dual_quaternion
|
||||
template <typename T, precision P>
|
||||
detail::tdualquat<T, P> dualquat_cast(
|
||||
GLM_FUNC_DECL detail::tdualquat<T, P> dualquat_cast(
|
||||
detail::tmat2x4<T, P> const & x);
|
||||
|
||||
/// Converts a 3 * 4 matrix (augmented matrix rotation + translation) to a quaternion.
|
||||
///
|
||||
/// @see gtc_dual_quaternion
|
||||
template <typename T, precision P>
|
||||
detail::tdualquat<T, P> dualquat_cast(
|
||||
GLM_FUNC_DECL detail::tdualquat<T, P> dualquat_cast(
|
||||
detail::tmat3x4<T, P> const & x);
|
||||
|
||||
|
||||
|
@ -35,7 +35,7 @@
|
||||
namespace glm
|
||||
{
|
||||
//! Deprecated, use packUnorm3x10_1x2 instead.
|
||||
GLM_DEPRECATED dword uint10_10_10_2_cast(glm::vec4 const & v);
|
||||
GLM_DEPRECATED GLM_FUNC_DECL dword uint10_10_10_2_cast(glm::vec4 const & v);
|
||||
|
||||
}//namespace glm
|
||||
|
||||
|
@ -36,6 +36,7 @@
|
||||
/// @brief Setup strings for GLM type values
|
||||
///
|
||||
/// <glm/gtx/string_cast.hpp> need to be included to use these functionalities.
|
||||
/// This extension is not supported with CUDA
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef GLM_GTX_string_cast
|
||||
@ -47,6 +48,10 @@
|
||||
#include "../gtx/quaternion.hpp"
|
||||
#include <string>
|
||||
|
||||
#if(GLM_COMPILER & GLM_COMPILER_CUDA)
|
||||
# error "GLM_GTX_string_cast is not supported on CUDA compiler"
|
||||
#endif
|
||||
|
||||
#if(defined(GLM_MESSAGES) && !defined(GLM_EXT_INCLUDED))
|
||||
# pragma message("GLM: GLM_GTX_string_cast extension included")
|
||||
#endif
|
||||
|
@ -23,11 +23,11 @@ namespace detail
|
||||
return std::string();
|
||||
|
||||
va_start(list, msg);
|
||||
#if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC8))
|
||||
# if((GLM_COMPILER & GLM_COMPILER_VC) && (GLM_COMPILER >= GLM_COMPILER_VC8))
|
||||
vsprintf_s(text, STRING_BUFFER, msg, list);
|
||||
#else//
|
||||
# else//
|
||||
vsprintf(text, msg, list);
|
||||
#endif//
|
||||
# endif//
|
||||
va_end(list);
|
||||
|
||||
return std::string(text);
|
||||
|
@ -156,7 +156,9 @@ namespace detail
|
||||
detail::tvec2<T, P> const & v,
|
||||
T const & epsilon)
|
||||
{
|
||||
|
||||
return detail::tvec2<bool, P>(
|
||||
abs(v.x) < epsilon,
|
||||
abs(v.y) < epsilon);
|
||||
}
|
||||
|
||||
template <typename T, precision P>
|
||||
|
@ -44,6 +44,8 @@ GLM 0.9.5.3: 2014-0X-XX
|
||||
- Fixed GTX_raw_data code dependency
|
||||
- Fixed GCC instruction set detection
|
||||
- Added GLM_GTX_matrix_transform_2d extension (#178, #176)
|
||||
- Fixed CUDA issues (#169, #168, #183, #182)
|
||||
- Added support for all extensions but GTX_string_cast to CUDA
|
||||
|
||||
================================================================================
|
||||
GLM 0.9.5.2: 2014-02-08
|
||||
|
Loading…
Reference in New Issue
Block a user