From 2877f4eda3d1b0c7431039e3142ecf1a282a34b1 Mon Sep 17 00:00:00 2001 From: LaG1924 <12997935+LaG1924@users.noreply.github.com> Date: Tue, 21 Aug 2018 20:40:38 +0500 Subject: Update glm to 0.9.9.0 --- external/include/glm/gtx/quaternion.inl | 158 ++++++++++++++++++++------------ 1 file changed, 100 insertions(+), 58 deletions(-) (limited to 'external/include/glm/gtx/quaternion.inl') diff --git a/external/include/glm/gtx/quaternion.inl b/external/include/glm/gtx/quaternion.inl index c86ec18..fde7a8f 100644 --- a/external/include/glm/gtx/quaternion.inl +++ b/external/include/glm/gtx/quaternion.inl @@ -6,84 +6,90 @@ namespace glm { - template - GLM_FUNC_QUALIFIER tvec3 cross(tvec3 const& v, tquat const& q) + template + GLM_FUNC_QUALIFIER tquat quat_identity() + { + return tquat(static_cast(1), static_cast(0), static_cast(0), static_cast(0)); + } + + template + GLM_FUNC_QUALIFIER vec<3, T, Q> cross(vec<3, T, Q> const& v, tquat const& q) { return inverse(q) * v; } - template - GLM_FUNC_QUALIFIER tvec3 cross(tquat const& q, tvec3 const& v) + template + GLM_FUNC_QUALIFIER vec<3, T, Q> cross(tquat const& q, vec<3, T, Q> const& v) { return q * v; } - template - GLM_FUNC_QUALIFIER tquat squad + template + GLM_FUNC_QUALIFIER tquat squad ( - tquat const & q1, - tquat const & q2, - tquat const & s1, - tquat const & s2, - T const & h) + tquat const& q1, + tquat const& q2, + tquat const& s1, + tquat const& s2, + T const& h) { return mix(mix(q1, q2, h), mix(s1, s2, h), static_cast(2) * (static_cast(1) - h) * h); } - template - GLM_FUNC_QUALIFIER tquat intermediate + template + GLM_FUNC_QUALIFIER tquat intermediate ( - tquat const & prev, - tquat const & curr, - tquat const & next + tquat const& prev, + tquat const& curr, + tquat const& next ) { - tquat invQuat = inverse(curr); + tquat invQuat = inverse(curr); return exp((log(next + invQuat) + log(prev + invQuat)) / static_cast(-4)) * curr; } - template - GLM_FUNC_QUALIFIER tquat exp(tquat const& q) + template + GLM_FUNC_QUALIFIER tquat exp(tquat const& q) { - tvec3 u(q.x, q.y, q.z); + vec<3, T, Q> u(q.x, q.y, q.z); T const Angle = glm::length(u); if (Angle < epsilon()) - return tquat(); + return tquat(); - tvec3 const v(u / Angle); - return tquat(cos(Angle), sin(Angle) * v); + vec<3, T, Q> const v(u / Angle); + return tquat(cos(Angle), sin(Angle) * v); } - template - GLM_FUNC_QUALIFIER tquat log(tquat const& q) + template + GLM_FUNC_QUALIFIER tquat log(tquat const& q) { - tvec3 u(q.x, q.y, q.z); + vec<3, T, Q> u(q.x, q.y, q.z); T Vec3Len = length(u); if (Vec3Len < epsilon()) { if(q.w > static_cast(0)) - return tquat(log(q.w), static_cast(0), static_cast(0), static_cast(0)); + return tquat(log(q.w), static_cast(0), static_cast(0), static_cast(0)); else if(q.w < static_cast(0)) - return tquat(log(-q.w), pi(), static_cast(0), static_cast(0)); + return tquat(log(-q.w), pi(), static_cast(0), static_cast(0)); else - return tquat(std::numeric_limits::infinity(), std::numeric_limits::infinity(), std::numeric_limits::infinity(), std::numeric_limits::infinity()); + return tquat(std::numeric_limits::infinity(), std::numeric_limits::infinity(), std::numeric_limits::infinity(), std::numeric_limits::infinity()); } else { T t = atan(Vec3Len, T(q.w)) / Vec3Len; T QuatLen2 = Vec3Len * Vec3Len + q.w * q.w; - return tquat(static_cast(0.5) * log(QuatLen2), t * q.x, t * q.y, t * q.z); + return tquat(static_cast(0.5) * log(QuatLen2), t * q.x, t * q.y, t * q.z); } } - template - GLM_FUNC_QUALIFIER tquat pow(tquat const & x, T const & y) + template + GLM_FUNC_QUALIFIER tquat pow(tquat const& x, T const& y) { //Raising to the power of 0 should yield 1 //Needed to prevent a division by 0 error later on if(y > -epsilon() && y < epsilon()) - return tquat(1,0,0,0); + return tquat(1,0,0,0); //To deal with non-unit quaternions T magnitude = sqrt(x.x * x.x + x.y * x.y + x.z * x.z + x.w *x.w); @@ -91,30 +97,30 @@ namespace glm //Equivalent to raising a real number to a power //Needed to prevent a division by 0 error later on if(abs(x.w / magnitude) > static_cast(1) - epsilon() && abs(x.w / magnitude) < static_cast(1) + epsilon()) - return tquat(pow(x.w, y),0,0,0); + return tquat(pow(x.w, y),0,0,0); T Angle = acos(x.w / magnitude); T NewAngle = Angle * y; T Div = sin(NewAngle) / sin(Angle); T Mag = pow(magnitude, y - static_cast(1)); - return tquat(cos(NewAngle) * magnitude * Mag, x.x * Div * Mag, x.y * Div * Mag, x.z * Div * Mag); + return tquat(cos(NewAngle) * magnitude * Mag, x.x * Div * Mag, x.y * Div * Mag, x.z * Div * Mag); } - template - GLM_FUNC_QUALIFIER tvec3 rotate(tquat const& q, tvec3 const& v) + template + GLM_FUNC_QUALIFIER vec<3, T, Q> rotate(tquat const& q, vec<3, T, Q> const& v) { return q * v; } - template - GLM_FUNC_QUALIFIER tvec4 rotate(tquat const& q, tvec4 const& v) + template + GLM_FUNC_QUALIFIER vec<4, T, Q> rotate(tquat const& q, vec<4, T, Q> const& v) { return q * v; } - template - GLM_FUNC_QUALIFIER T extractRealComponent(tquat const& q) + template + GLM_FUNC_QUALIFIER T extractRealComponent(tquat const& q) { T w = static_cast(1) - q.x * q.x - q.y * q.y - q.z * q.z; if(w < T(0)) @@ -123,20 +129,20 @@ namespace glm return -sqrt(w); } - template - GLM_FUNC_QUALIFIER T length2(tquat const& q) + template + GLM_FUNC_QUALIFIER T length2(tquat const& q) { return q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w; } - template - GLM_FUNC_QUALIFIER tquat shortMix(tquat const& x, tquat const& y, T const& a) + template + GLM_FUNC_QUALIFIER tquat shortMix(tquat const& x, tquat const& y, T const& a) { if(a <= static_cast(0)) return x; if(a >= static_cast(1)) return y; T fCos = dot(x, y); - tquat y2(y); //BUG!!! tquat y2; + tquat y2(y); //BUG!!! tquat y2; if(fCos < static_cast(0)) { y2 = -y; @@ -159,27 +165,29 @@ namespace glm k1 = sin((static_cast(0) + a) * fAngle) * fOneOverSin; } - return tquat( + return tquat( k0 * x.w + k1 * y2.w, k0 * x.x + k1 * y2.x, k0 * x.y + k1 * y2.y, k0 * x.z + k1 * y2.z); } - template - GLM_FUNC_QUALIFIER tquat fastMix(tquat const& x, tquat const& y, T const & a) + template + GLM_FUNC_QUALIFIER tquat fastMix(tquat const& x, tquat const& y, T const& a) { return glm::normalize(x * (static_cast(1) - a) + (y * a)); } - template - GLM_FUNC_QUALIFIER tquat rotation(tvec3 const& orig, tvec3 const& dest) + template + GLM_FUNC_QUALIFIER tquat rotation(vec<3, T, Q> const& orig, vec<3, T, Q> const& dest) { T cosTheta = dot(orig, dest); - tvec3 rotationAxis; + vec<3, T, Q> rotationAxis; - if(cosTheta >= static_cast(1) - epsilon()) - return quat(); + if(cosTheta >= static_cast(1) - epsilon()) { + // orig and dest point in the same direction + return quat_identity(); + } if(cosTheta < static_cast(-1) + epsilon()) { @@ -188,9 +196,9 @@ namespace glm // So guess one; any will do as long as it's perpendicular to start // This implementation favors a rotation around the Up axis (Y), // since it's often what you want to do. - rotationAxis = cross(tvec3(0, 0, 1), orig); + rotationAxis = cross(vec<3, T, Q>(0, 0, 1), orig); if(length2(rotationAxis) < epsilon()) // bad luck, they were parallel, try again! - rotationAxis = cross(tvec3(1, 0, 0), orig); + rotationAxis = cross(vec<3, T, Q>(1, 0, 0), orig); rotationAxis = normalize(rotationAxis); return angleAxis(pi(), rotationAxis); @@ -202,11 +210,45 @@ namespace glm T s = sqrt((T(1) + cosTheta) * static_cast(2)); T invs = static_cast(1) / s; - return tquat( - s * static_cast(0.5f), + return tquat( + s * static_cast(0.5f), rotationAxis.x * invs, rotationAxis.y * invs, rotationAxis.z * invs); } + template + GLM_FUNC_QUALIFIER tquat quatLookAt(vec<3, T, Q> const& direction, vec<3, T, Q> const& up) + { +# if GLM_COORDINATE_SYSTEM == GLM_LEFT_HANDED + return quatLookAtLH(direction, up); +# else + return quatLookAtRH(direction, up); +# endif + } + + template + GLM_FUNC_QUALIFIER tquat quatLookAtRH(vec<3, T, Q> const& direction, vec<3, T, Q> const& up) + { + mat<3, 3, T, Q> Result; + + Result[2] = -direction; + Result[0] = normalize(cross(up, Result[2])); + Result[1] = cross(Result[2], Result[0]); + + return quat_cast(Result); + } + + template + GLM_FUNC_QUALIFIER tquat quatLookAtLH(vec<3, T, Q> const& direction, vec<3, T, Q> const& up) + { + mat<3, 3, T, Q> Result; + + Result[2] = direction; + Result[0] = normalize(cross(up, Result[2])); + Result[1] = cross(Result[2], Result[0]); + + return quat_cast(Result); + } + }//namespace glm -- cgit v1.2.3