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

merge 0.9.5

Browse Source
master
Christophe Riccio ago%!(EXTRA string=11 years)
parent a5ab409ed2 4fa38c7a03
commit b5ffd74c3e
5 changed files with 780 additions and 764 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 320
      glm/gtx/io.hpp
  2. 1149
      glm/gtx/io.inl
  3. 54
      glm/gtx/quaternion.inl
  4. 3
      readme.txt
  5. 4
      test/core/core_func_matrix.cpp

320
glm/gtx/io.hpp
Unescape View File

@ -57,178 +57,168 @@
namespace glm namespace glm
{ {
/// @addtogroup gtx_io /// @addtogroup gtx_io
/// @{ /// @{
namespace io namespace io
{ {
enum order_type { column_major, row_major};
enum order_type { column_major, row_major, }; template <typename CTy>
class format_punct : public std::locale::facet
{
typedef CTy char_type;
template <typename CTy> public:
class format_punct : public std::locale::facet {
typedef CTy char_type; static std::locale::id id;
public: bool formatted;
unsigned precision;
unsigned width;
char_type separator;
char_type delim_left;
char_type delim_right;
char_type space;
char_type newline;
order_type order;
static std::locale::id id; explicit format_punct(size_t a = 0);
explicit format_punct(format_punct const&);
};
bool formatted; template <typename CTy, typename CTr = std::char_traits<CTy> >
unsigned precision; class basic_state_saver {
unsigned width;
char_type separator; public:
char_type delim_left;
char_type delim_right; explicit basic_state_saver(std::basic_ios<CTy,CTr>&);
char_type space; ~basic_state_saver();
char_type newline;
order_type order; private:
explicit format_punct(size_t a = 0); typedef ::std::basic_ios<CTy,CTr> state_type;
explicit format_punct(format_punct const&); typedef typename state_type::char_type char_type;
typedef ::std::ios_base::fmtflags flags_type;
}; typedef ::std::streamsize streamsize_type;
typedef ::std::locale const locale_type;
template <typename CTy, typename CTr = std::char_traits<CTy> >
class basic_state_saver { state_type& state_;
flags_type flags_;
public: streamsize_type precision_;
streamsize_type width_;
explicit basic_state_saver(std::basic_ios<CTy,CTr>&); char_type fill_;
~basic_state_saver(); locale_type locale_;
private: basic_state_saver& operator=(basic_state_saver const&);
};
typedef ::std::basic_ios<CTy,CTr> state_type;
typedef typename state_type::char_type char_type; typedef basic_state_saver<char> state_saver;
typedef ::std::ios_base::fmtflags flags_type; typedef basic_state_saver<wchar_t> wstate_saver;
typedef ::std::streamsize streamsize_type;
typedef ::std::locale const locale_type; template <typename CTy, typename CTr = std::char_traits<CTy> >
class basic_format_saver
state_type& state_; {
flags_type flags_; public:
streamsize_type precision_;
streamsize_type width_; explicit basic_format_saver(std::basic_ios<CTy,CTr>&);
char_type fill_; ~basic_format_saver();
locale_type locale_;
private:
basic_state_saver& operator=(basic_state_saver const&);
basic_state_saver<CTy> const bss_;
};
basic_format_saver& operator=(basic_format_saver const&);
typedef basic_state_saver<char> state_saver; };
typedef basic_state_saver<wchar_t> wstate_saver;
typedef basic_format_saver<char> format_saver;
template <typename CTy, typename CTr = std::char_traits<CTy> > typedef basic_format_saver<wchar_t> wformat_saver;
class basic_format_saver {
struct precision
public: {
unsigned value;
explicit basic_format_saver(std::basic_ios<CTy,CTr>&);
~basic_format_saver(); explicit precision(unsigned);
};
private:
struct width
basic_state_saver<CTy> const bss_; {
unsigned value;
basic_format_saver& operator=(basic_format_saver const&);
explicit width(unsigned);
}; };
typedef basic_format_saver<char> format_saver; template <typename CTy>
typedef basic_format_saver<wchar_t> wformat_saver; struct delimeter
{
struct precision { CTy value[3];
unsigned value; explicit delimeter(CTy /* left */, CTy /* right */, CTy /* separator */ = ',');
};
explicit precision(unsigned);
struct order
}; {
order_type value;
struct width {
explicit order(order_type);
unsigned value; };
explicit width(unsigned); // functions, inlined (inline)
}; template <typename FTy, typename CTy, typename CTr>
FTy const& get_facet(std::basic_ios<CTy,CTr>&);
template <typename CTy> template <typename FTy, typename CTy, typename CTr>
struct delimeter { std::basic_ios<CTy,CTr>& formatted(std::basic_ios<CTy,CTr>&);
template <typename FTy, typename CTy, typename CTr>
CTy value[3]; std::basic_ios<CTy,CTr>& unformattet(std::basic_ios<CTy,CTr>&);
explicit delimeter(CTy /* left */, CTy /* right */, CTy /* separator */ = ','); template <typename CTy, typename CTr>
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, precision const&);
}; template <typename CTy, typename CTr>
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, width const&);
struct order { template <typename CTy, typename CTr>
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, delimeter<CTy> const&);
order_type value; template <typename CTy, typename CTr>
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, order const&);
explicit order(order_type); }//namespace io
}; namespace detail
{
// functions, inlined (inline) template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tquat<T,P> const&);
template <typename FTy, typename CTy, typename CTr> template <typename CTy, typename CTr, typename T, precision P>
FTy const& get_facet(std::basic_ios<CTy,CTr>&); GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec2<T,P> const&);
template <typename FTy, typename CTy, typename CTr> template <typename CTy, typename CTr, typename T, precision P>
std::basic_ios<CTy,CTr>& formatted(std::basic_ios<CTy,CTr>&); GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec3<T,P> const&);
template <typename FTy, typename CTy, typename CTr> template <typename CTy, typename CTr, typename T, precision P>
std::basic_ios<CTy,CTr>& unformattet(std::basic_ios<CTy,CTr>&); GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
template <typename CTy, typename CTr> GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x2<T,P> const&);
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, precision const&); template <typename CTy, typename CTr, typename T, precision P>
template <typename CTy, typename CTr> GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x3<T,P> const&);
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, width const&); template <typename CTy, typename CTr, typename T, precision P>
template <typename CTy, typename CTr> GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x4<T,P> const&);
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, delimeter<CTy> const&); template <typename CTy, typename CTr, typename T, precision P>
template <typename CTy, typename CTr> GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x2<T,P> const&);
std::basic_ostream<CTy, CTr>& operator<<(std::basic_ostream<CTy, CTr>&, order const&); template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x3<T,P> const&);
}//namespace io template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x4<T,P> const&);
namespace detail template <typename CTy, typename CTr, typename T, precision P>
{ GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
template <typename CTy, typename CTr, typename T, precision P> GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x3<T,P> const&);
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tquat<T,P> const&); template <typename CTy, typename CTr, typename T, precision P>
template <typename CTy, typename CTr, typename T, precision P> GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x4<T,P> const&);
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P> template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec3<T,P> const&); GLM_FUNC_DECL std::basic_ostream<CTy,CTr> & operator<<(
template <typename CTy, typename CTr, typename T, precision P> std::basic_ostream<CTy,CTr> &,
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tvec4<T,P> const&); std::pair<tmat4x4<T,P> const,
template <typename CTy, typename CTr, typename T, precision P> tmat4x4<T,P> const> const &);
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x2<T,P> const&); }//namespace detail
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x3<T,P> const&); /// @}
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat2x4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat3x4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x2<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x3<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&, tmat4x4<T,P> const&);
template <typename CTy, typename CTr, typename T, precision P>
GLM_FUNC_DECL std::basic_ostream<CTy,CTr>& operator<<(std::basic_ostream<CTy,CTr>&,
std::pair<tmat4x4<T,P> const,
tmat4x4<T,P> const> const&);
}//namespace detail
/// @}
}//namespace glm }//namespace glm
#include "io.inl" #include "io.inl"

1149
glm/gtx/io.inl
View File

File diff suppressed because it is too large Load Diff

54
glm/gtx/quaternion.inl
Unescape View File

@ -8,6 +8,7 @@
/////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////
#include <limits> #include <limits>
#include "../gtc/constants.hpp"
namespace glm namespace glm
{ {
@ -40,7 +41,7 @@ namespace glm
detail::tquat<T, P> const & s2, detail::tquat<T, P> const & s2,
T const & h) T const & h)
{ {
return mix(mix(q1, q2, h), mix(s1, s2, h), T(2) * (T(1) - h) * h); return mix(mix(q1, q2, h), mix(s1, s2, h), static_cast<T>(2) * (static_cast<T>(1) - h) * h);
} }
template <typename T, precision P> template <typename T, precision P>
@ -52,7 +53,7 @@ namespace glm
) )
{ {
detail::tquat<T, P> invQuat = inverse(curr); detail::tquat<T, P> invQuat = inverse(curr);
return exp((log(next + invQuat) + log(prev + invQuat)) / T(-4)) * curr; return exp((log(next + invQuat) + log(prev + invQuat)) / static_cast<T>(-4)) * curr;
} }
template <typename T, precision P> template <typename T, precision P>
@ -62,7 +63,10 @@ namespace glm
) )
{ {
detail::tvec3<T, P> u(q.x, q.y, q.z); detail::tvec3<T, P> u(q.x, q.y, q.z);
float Angle = glm::length(u); T Angle = glm::length(u);
if (Angle < epsilon<T>())
return detail::tquat<T, P>();
detail::tvec3<T, P> v(u / Angle); detail::tvec3<T, P> v(u / Angle);
return detail::tquat<T, P>(cos(Angle), sin(Angle) * v); return detail::tquat<T, P>(cos(Angle), sin(Angle) * v);
} }
@ -73,18 +77,20 @@ namespace glm
detail::tquat<T, P> const & q detail::tquat<T, P> const & q
) )
{ {
if((q.x == static_cast<T>(0)) && (q.y == static_cast<T>(0)) && (q.z == static_cast<T>(0))) detail::tvec3<T, P> u(q.x, q.y, q.z);
T Vec3Len = length(u);
if (Vec3Len < epsilon<T>())
{ {
if(q.w > T(0)) if(q.w > static_cast<T>(0))
return detail::tquat<T, P>(log(q.w), T(0), T(0), T(0)); return detail::tquat<T, P>(log(q.w), static_cast<T>(0), static_cast<T>(0), static_cast<T>(0));
else if(q.w < T(0)) else if(q.w < static_cast<T>(0))
return detail::tquat<T, P>(log(-q.w), T(3.1415926535897932384626433832795), T(0),T(0)); return detail::tquat<T, P>(log(-q.w), pi<T>(), static_cast<T>(0), static_cast<T>(0));
else else
return detail::tquat<T, P>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity()); return detail::tquat<T, P>(std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity(), std::numeric_limits<T>::infinity());
} }
else else
{ {
T Vec3Len = sqrt(q.x * q.x + q.y * q.y + q.z * q.z);
T QuatLen = sqrt(Vec3Len * Vec3Len + q.w * q.w); T QuatLen = sqrt(Vec3Len * Vec3Len + q.w * q.w);
T t = atan(Vec3Len, T(q.w)) / Vec3Len; T t = atan(Vec3Len, T(q.w)) / Vec3Len;
return detail::tquat<T, P>(log(QuatLen), t * q.x, t * q.y, t * q.z); return detail::tquat<T, P>(log(QuatLen), t * q.x, t * q.y, t * q.z);
@ -98,11 +104,11 @@ namespace glm
T const & y T const & y
) )
{ {
if(abs(x.w) > T(0.9999)) if(abs(x.w) > (static_cast<T>(1) - epsilon<T>()))
return x; return x;
float Angle = acos(y); T Angle = acos(y);
float NewAngle = Angle * y; T NewAngle = Angle * y;
float Div = sin(NewAngle) / sin(Angle); T Div = sin(NewAngle) / sin(Angle);
return detail::tquat<T, P>( return detail::tquat<T, P>(
cos(NewAngle), cos(NewAngle),
x.x * Div, x.x * Div,
@ -146,7 +152,7 @@ namespace glm
detail::tquat<T, P> const & q detail::tquat<T, P> const & q
) )
{ {
T w = static_cast<T>(1.0) - q.x * q.x - q.y * q.y - q.z * q.z; T w = static_cast<T>(1) - q.x * q.x - q.y * q.y - q.z * q.z;
if(w < T(0)) if(w < T(0))
return T(0); return T(0);
else else
@ -170,12 +176,12 @@ namespace glm
T const & a T const & a
) )
{ {
if(a <= T(0)) return x; if(a <= static_cast<T>(0)) return x;
if(a >= T(1)) return y; if(a >= static_cast<T>(1)) return y;
T fCos = dot(x, y); T fCos = dot(x, y);
detail::tquat<T, P> y2(y); //BUG!!! tquat<T> y2; detail::tquat<T, P> y2(y); //BUG!!! tquat<T> y2;
if(fCos < T(0)) if(fCos < static_cast<T>(0))
{ {
y2 = -y; y2 = -y;
fCos = -fCos; fCos = -fCos;
@ -183,7 +189,7 @@ namespace glm
//if(fCos > 1.0f) // problem //if(fCos > 1.0f) // problem
T k0, k1; T k0, k1;
if(fCos > T(0.9999)) if(fCos > (static_cast<T>(1) - epsilon<T>()))
{ {
k0 = static_cast<T>(1) - a; k0 = static_cast<T>(1) - a;
k1 = static_cast<T>(0) + a; //BUG!!! 1.0f + a; k1 = static_cast<T>(0) + a; //BUG!!! 1.0f + a;
@ -193,8 +199,8 @@ namespace glm
T fSin = sqrt(T(1) - fCos * fCos); T fSin = sqrt(T(1) - fCos * fCos);
T fAngle = atan(fSin, fCos); T fAngle = atan(fSin, fCos);
T fOneOverSin = static_cast<T>(1) / fSin; T fOneOverSin = static_cast<T>(1) / fSin;
k0 = sin((T(1) - a) * fAngle) * fOneOverSin; k0 = sin((static_cast<T>(1) - a) * fAngle) * fOneOverSin;
k1 = sin((T(0) + a) * fAngle) * fOneOverSin; k1 = sin((static_cast<T>(0) + a) * fAngle) * fOneOverSin;
} }
return detail::tquat<T, P>( return detail::tquat<T, P>(
@ -212,7 +218,7 @@ namespace glm
T const & a T const & a
) )
{ {
return glm::normalize(x * (T(1) - a) + (y * a)); return glm::normalize(x * (static_cast<T>(1) - a) + (y * a));
} }
template <typename T, precision P> template <typename T, precision P>
@ -225,7 +231,7 @@ namespace glm
T cosTheta = dot(orig, dest); T cosTheta = dot(orig, dest);
detail::tvec3<T, P> rotationAxis; detail::tvec3<T, P> rotationAxis;
if(cosTheta < T(-1) + epsilon<T>()) if(cosTheta < static_cast<T>(-1) + epsilon<T>())
{ {
// special case when vectors in opposite directions : // special case when vectors in opposite directions :
// there is no "ideal" rotation axis // there is no "ideal" rotation axis
@ -243,11 +249,11 @@ namespace glm
// Implementation from Stan Melax's Game Programming Gems 1 article // Implementation from Stan Melax's Game Programming Gems 1 article
rotationAxis = cross(orig, dest); rotationAxis = cross(orig, dest);
T s = sqrt((T(1) + cosTheta) * T(2)); T s = sqrt((T(1) + cosTheta) * static_cast<T>(2));
T invs = static_cast<T>(1) / s; T invs = static_cast<T>(1) / s;
return detail::tquat<T, P>( return detail::tquat<T, P>(
s * T(0.5f), s * static_cast<T>(0.5f),
rotationAxis.x * invs, rotationAxis.x * invs,
rotationAxis.y * invs, rotationAxis.y * invs,
rotationAxis.z * invs); rotationAxis.z * invs);

3
readme.txt
Unescape View File

@ -45,7 +45,7 @@ GLM 0.9.6.0: 2014-XX-XX
- Added move contructors and assignment operators (#141) - Added move contructors and assignment operators (#141)
================================================================================ ================================================================================
GLM 0.9.5.4: 2014-0X-XX GLM 0.9.5.4: 2014-06-21
-------------------------------------------------------------------------------- --------------------------------------------------------------------------------
- Fixed non-utf8 character #196 - Fixed non-utf8 character #196
- Added FindGLM install for CMake #189 - Added FindGLM install for CMake #189
@ -64,6 +64,7 @@ GLM 0.9.5.4: 2014-0X-XX
- Fixed std::copy and std::vector with GLM types #214 - Fixed std::copy and std::vector with GLM types #214
- Fixed strict aliasing issues #212, #152 - Fixed strict aliasing issues #212, #152
- Fixed std::nextafter not supported with C++11 on Android #213 - Fixed std::nextafter not supported with C++11 on Android #213
- Fixed corner cases in exp and log functions for quaternions #199
================================================================================ ================================================================================
GLM 0.9.5.3: 2014-04-02 GLM 0.9.5.3: 2014-04-02

4
test/core/core_func_matrix.cpp
Unescape View File

@ -228,10 +228,10 @@ int test_inverse_perf(std::size_t Instance, char const * Message)
//glm::uint Ulp = 0; //glm::uint Ulp = 0;
//Ulp = glm::max(glm::float_distance(*Dst, *Src), Ulp); //Ulp = glm::max(glm::float_distance(*Dst, *Src), Ulp);
printf("inverse<%s>(%f): %d\n", Message, Diff, EndTime - StartTime); printf("inverse<%s>(%f): %lu\n", Message, Diff, EndTime - StartTime);
return 0; return 0;
}; }
int main() int main()
{ {

Write Preview
Loading…
Cancel
Save