de/d9b/_quat__inl_8h_source.htm

#pragma once


#include <Foundation/Math/Mat4.h>

#include <Foundation/Math/Vec3.h>


template <typename Type>

PL_ALWAYS_INLINE plQuatTemplate<Type>::plQuatTemplate()

{

#if PL_ENABLED(PL_MATH_CHECK_FOR_NAN)

  // Initialize all data to NaN in debug mode to find problems with uninitialized data easier.

  const Type TypeNaN = plMath::NaN<Type>();

  x = TypeNaN;

  y = TypeNaN;

  z = TypeNaN;

  w = TypeNaN;

#endif

}


template <typename Type>


PL_ALWAYS_INLINE plQuatTemplate<Type>::plQuatTemplate(Type inX, Type inY, Type inZ, Type inW)

  : x(inX)

  , y(inY)

  , z(inZ)

  , w(inW)

{

}


template <typename Type>


PL_ALWAYS_INLINE const plQuatTemplate<Type> plQuatTemplate<Type>::MakeIdentity()

{

  return plQuatTemplate(0, 0, 0, 1);

}


template <typename Type>


PL_ALWAYS_INLINE plQuatTemplate<Type> plQuatTemplate<Type>::MakeFromElements(Type inX, Type inY, Type inZ, Type inW)

{

  return plQuatTemplate<Type>(inX, inY, inZ, inW);

}


template <typename Type>


PL_ALWAYS_INLINE void plQuatTemplate<Type>::SetIdentity()

{

  x = (Type)0;

  y = (Type)0;

  z = (Type)0;

  w = (Type)1;

}


template <typename Type>


plQuatTemplate<Type> plQuatTemplate<Type>::MakeFromAxisAndAngle(const plVec3Template<Type>& vRotationAxis, plAngle angle)

{

  const plAngle halfAngle = angle * 0.5f;


  plVec3 v = static_cast<Type>(plMath::Sin(halfAngle)) * vRotationAxis;

  float w = plMath::Cos(halfAngle);


  return plQuatTemplate<Type>(v.x, v.y, v.z, w);

}


template <typename Type>


void plQuatTemplate<Type>::Normalize()

{


  PL_NAN_ASSERT(this);


  Type n = x * x + y * y + z * z + w * w;


  n = plMath::Invert(plMath::Sqrt(n));


  x *= n;

  y *= n;

  z *= n;

  w *= n;

}


template <typename Type>


void plQuatTemplate<Type>::GetRotationAxisAndAngle(plVec3Template<Type>& out_vAxis, plAngle& out_angle, Type fEpsilon) const


{

  PL_NAN_ASSERT(this);


  out_angle = 2 * plMath::ACos(static_cast<float>(w));


  const float s = plMath::Sqrt(1 - w * w);


  if (s < fEpsilon)


  {

    out_vAxis.Set(1, 0, 0);

  }

  else

  {


    const float ds = 1.0f / s;

    out_vAxis.x = x * ds;

    out_vAxis.y = y * ds;

    out_vAxis.z = z * ds;

  }

}


template <typename Type>


PL_FORCE_INLINE void plQuatTemplate<Type>::Invert()


{

  PL_NAN_ASSERT(this);


  *this = GetInverse();

}


template <typename Type>


PL_FORCE_INLINE const plQuatTemplate<Type> plQuatTemplate<Type>::GetInverse() const

{


  PL_NAN_ASSERT(this);


  return (plQuatTemplate(-x, -y, -z, w));


}


template <typename Type>


PL_FORCE_INLINE const plQuatTemplate<Type> plQuatTemplate<Type>::GetNegated() const

{

  PL_NAN_ASSERT(this);


  return (plQuatTemplate(-x, -y, -z, -w));

}


template <typename Type>


PL_FORCE_INLINE Type plQuatTemplate<Type>::Dot(const plQuatTemplate& rhs) const

{

  PL_NAN_ASSERT(this);

  PL_NAN_ASSERT(&rhs);


  return GetVectorPart().Dot(rhs.GetVectorPart()) + w * rhs.w;

}


template <typename Type>


PL_ALWAYS_INLINE plVec3Template<Type> plQuatTemplate<Type>::Rotate(const plVec3Template<Type>& v) const


{

  return *this * v;

}


template <typename Type>

PL_ALWAYS_INLINE const plVec3Template<Type> operator*(const plQuatTemplate<Type>& q, const plVec3Template<Type>& v)


{

  plVec3Template<Type> t = q.GetVectorPart().CrossRH(v) * (Type)2;

  return v + q.w * t + q.GetVectorPart().CrossRH(t);

}


template <typename Type>

PL_ALWAYS_INLINE const plQuatTemplate<Type> operator*(const plQuatTemplate<Type>& q1, const plQuatTemplate<Type>& q2)

{


  plQuatTemplate<Type> q;


  q.w = q1.w * q2.w - (q1.x * q2.x + q1.y * q2.y + q1.z * q2.z);


  const plVec3 v1 = q1.GetVectorPart();

  const plVec3 v2 = q2.GetVectorPart();


  const plVec3 vr = q1.w * v2 + q2.w * v1 + v1.CrossRH(v2);

  q.x = vr.x;

  q.y = vr.y;

  q.z = vr.z;


  return q;

}


template <typename Type>


bool plQuatTemplate<Type>::IsValid(Type fEpsilon) const

{

  if (!GetVectorPart().IsValid())

    return false;

  if (!plMath::IsFinite(w))

    return false;


  Type n = x * x + y * y + z * z + w * w;


  return plMath::IsEqual(n, (Type)1, fEpsilon);

}


template <typename Type>


bool plQuatTemplate<Type>::IsNaN() const

{

  return plMath::IsNaN(x) || plMath::IsNaN(y) || plMath::IsNaN(z) || plMath::IsNaN(w);

}


template <typename Type>


bool plQuatTemplate<Type>::IsEqualRotation(const plQuatTemplate<Type>& qOther, Type fEpsilon) const

{

  if (GetVectorPart().IsEqual(qOther.GetVectorPart(), (Type)0.00001) && plMath::IsEqual(w, qOther.w, (Type)0.00001))

  {

    return true;

  }


  plVec3Template<Type> vA1, vA2;

  plAngle A1, A2;


  GetRotationAxisAndAngle(vA1, A1);

  qOther.GetRotationAxisAndAngle(vA2, A2);


  if ((A1.IsEqualSimple(A2, plAngle::MakeFromDegree(static_cast<float>(fEpsilon)))) && (vA1.IsEqual(vA2, fEpsilon)))

    return true;


  if ((A1.IsEqualSimple(-A2, plAngle::MakeFromDegree(static_cast<float>(fEpsilon)))) && (vA1.IsEqual(-vA2, fEpsilon)))

    return true;


  return false;

}


template <typename Type>


const plMat3Template<Type> plQuatTemplate<Type>::GetAsMat3() const

{

  PL_NAN_ASSERT(this);


  plMat3Template<Type> m;


  const Type fTx = x + x;

  const Type fTy = y + y;

  const Type fTz = z + z;

  const Type fTwx = fTx * w;

  const Type fTwy = fTy * w;

  const Type fTwz = fTz * w;

  const Type fTxx = fTx * x;

  const Type fTxy = fTy * x;

  const Type fTxz = fTz * x;

  const Type fTyy = fTy * y;

  const Type fTyz = fTz * y;

  const Type fTzz = fTz * z;


  m.Element(0, 0) = (Type)1 - (fTyy + fTzz);

  m.Element(1, 0) = fTxy - fTwz;

  m.Element(2, 0) = fTxz + fTwy;

  m.Element(0, 1) = fTxy + fTwz;

  m.Element(1, 1) = (Type)1 - (fTxx + fTzz);

  m.Element(2, 1) = fTyz - fTwx;

  m.Element(0, 2) = fTxz - fTwy;

  m.Element(1, 2) = fTyz + fTwx;

  m.Element(2, 2) = (Type)1 - (fTxx + fTyy);

  return m;

}


template <typename Type>


const plMat4Template<Type> plQuatTemplate<Type>::GetAsMat4() const

{

  PL_NAN_ASSERT(this);


  plMat4Template<Type> m;


  const Type fTx = x + x;

  const Type fTy = y + y;

  const Type fTz = z + z;

  const Type fTwx = fTx * w;

  const Type fTwy = fTy * w;

  const Type fTwz = fTz * w;

  const Type fTxx = fTx * x;

  const Type fTxy = fTy * x;

  const Type fTxz = fTz * x;

  const Type fTyy = fTy * y;

  const Type fTyz = fTz * y;

  const Type fTzz = fTz * z;


  m.Element(0, 0) = (Type)1 - (fTyy + fTzz);

  m.Element(1, 0) = fTxy - fTwz;

  m.Element(2, 0) = fTxz + fTwy;

  m.Element(3, 0) = (Type)0;

  m.Element(0, 1) = fTxy + fTwz;

  m.Element(1, 1) = (Type)1 - (fTxx + fTzz);

  m.Element(2, 1) = fTyz - fTwx;

  m.Element(3, 1) = (Type)0;

  m.Element(0, 2) = fTxz - fTwy;

  m.Element(1, 2) = fTyz + fTwx;

  m.Element(2, 2) = (Type)1 - (fTxx + fTyy);

  m.Element(3, 2) = (Type)0;

  m.Element(0, 3) = (Type)0;

  m.Element(1, 3) = (Type)0;

  m.Element(2, 3) = (Type)0;

  m.Element(3, 3) = (Type)1;

  return m;

}


template <typename Type>


plQuatTemplate<Type> plQuatTemplate<Type>::MakeFromMat3(const plMat3Template<Type>& m)

{

  PL_NAN_ASSERT(&m);


  const Type trace = m.Element(0, 0) + m.Element(1, 1) + m.Element(2, 2);

  const Type half = (Type)0.5;


  Type val[4];


  if (trace > (Type)0)

  {

    Type s = plMath::Sqrt(trace + (Type)1);

    Type t = half / s;


    val[0] = (m.Element(1, 2) - m.Element(2, 1)) * t;

    val[1] = (m.Element(2, 0) - m.Element(0, 2)) * t;

    val[2] = (m.Element(0, 1) - m.Element(1, 0)) * t;


    val[3] = half * s;

  }

  else

  {

    const plInt32 next[] = {1, 2, 0};

    plInt32 i = 0;


    if (m.Element(1, 1) > m.Element(0, 0))

      i = 1;


    if (m.Element(2, 2) > m.Element(i, i))

      i = 2;


    plInt32 j = next[i];

    plInt32 k = next[j];


    Type s = plMath::Sqrt(m.Element(i, i) - (m.Element(j, j) + m.Element(k, k)) + (Type)1);

    Type t = half / s;


    val[i] = half * s;

    val[3] = (m.Element(j, k) - m.Element(k, j)) * t;

    val[j] = (m.Element(i, j) + m.Element(j, i)) * t;

    val[k] = (m.Element(i, k) + m.Element(k, i)) * t;

  }


  plQuatTemplate<Type> q;

  q.x = val[0];

  q.y = val[1];

  q.z = val[2];

  q.w = val[3];

  return q;

}


template <typename Type>


void plQuatTemplate<Type>::ReconstructFromMat3(const plMat3Template<Type>& mMat)

{

  const plVec3 x = (mMat * plVec3(1, 0, 0)).GetNormalized();

  const plVec3 y = (mMat * plVec3(0, 1, 0)).GetNormalized();

  const plVec3 z = x.CrossRH(y);


  plMat3 m;

  m.SetColumn(0, x);

  m.SetColumn(1, y);

  m.SetColumn(2, z);


  *this = plQuat::MakeFromMat3(m);

}


template <typename Type>


void plQuatTemplate<Type>::ReconstructFromMat4(const plMat4Template<Type>& mMat)

{

  const plVec3 x = mMat.TransformDirection(plVec3(1, 0, 0)).GetNormalized();

  const plVec3 y = mMat.TransformDirection(plVec3(0, 1, 0)).GetNormalized();

  const plVec3 z = x.CrossRH(y);


  plMat3 m;

  m.SetColumn(0, x);

  m.SetColumn(1, y);

  m.SetColumn(2, z);


  *this = plQuat::MakeFromMat3(m);

}


template <typename Type>


plQuatTemplate<Type> plQuatTemplate<Type>::MakeShortestRotation(const plVec3Template<Type>& vDirFrom, const plVec3Template<Type>& vDirTo)

{

  const plVec3Template<Type> v0 = vDirFrom.GetNormalized();

  const plVec3Template<Type> v1 = vDirTo.GetNormalized();


  const Type fDot = v0.Dot(v1);


  // if both vectors are identical -> no rotation needed

  if (plMath::IsEqual(fDot, (Type)1, (Type)0.0000001))

  {

    return MakeIdentity();

  }

  else if (plMath::IsEqual(fDot, (Type)-1, (Type)0.0000001)) // if both vectors are opposing

  {

    // find an axis, that is not identical and not opposing, plVec3Template::Cross-product to find perpendicular vector, rotate around that

    if (plMath::Abs(v0.Dot(plVec3Template<Type>(1, 0, 0))) < (Type)0.8)

      return MakeFromAxisAndAngle(v0.CrossRH(plVec3Template<Type>(1, 0, 0)).GetNormalized(), plAngle::MakeFromRadian(plMath::Pi<float>()));

    else

      return MakeFromAxisAndAngle(v0.CrossRH(plVec3Template<Type>(0, 1, 0)).GetNormalized(), plAngle::MakeFromRadian(plMath::Pi<float>()));

  }


  const plVec3Template<Type> c = v0.CrossRH(v1);

  const Type d = v0.Dot(v1);

  const Type s = plMath::Sqrt(((Type)1 + d) * (Type)2);


  PL_ASSERT_DEBUG(c.IsValid(), "SetShortestRotation failed.");


  const Type fOneDivS = 1.0f / s;


  plQuatTemplate<Type> q;

  q.x = c.x * fOneDivS;

  q.y = c.y * fOneDivS;

  q.z = c.z * fOneDivS;

  q.w = s / (Type)2;

  q.Normalize();


  return q;

}


template <typename Type>


plQuatTemplate<Type> plQuatTemplate<Type>::MakeSlerp(const plQuatTemplate<Type>& qFrom, const plQuatTemplate<Type>& qTo, Type t)

{

  PL_ASSERT_DEBUG((t >= (Type)0) && (t <= (Type)1), "Invalid lerp factor.");


  const Type one = 1;

  const Type qdelta = (Type)1 - (Type)0.001;


  const Type fDot = (qFrom.x * qTo.x + qFrom.y * qTo.y + qFrom.z * qTo.z + qFrom.w * qTo.w);


  Type cosTheta = fDot;


  bool bFlipSign = false;

  if (cosTheta < (Type)0)

  {

    bFlipSign = true;

    cosTheta = -cosTheta;

  }


  Type t0, t1;


  if (cosTheta < qdelta)

  {

    plAngle theta = plMath::ACos((float)cosTheta);


    // use sqrtInv(1+c^2) instead of 1.0/sin(theta)

    const Type iSinTheta = (Type)1 / plMath::Sqrt(one - (cosTheta * cosTheta));

    const plAngle tTheta = static_cast<float>(t) * theta;


    Type s0 = plMath::Sin(theta - tTheta);

    Type s1 = plMath::Sin(tTheta);


    t0 = s0 * iSinTheta;

    t1 = s1 * iSinTheta;

  }

  else

  {

    // If q0 is nearly the same as q1 we just linearly interpolate

    t0 = one - t;

    t1 = t;

  }


  if (bFlipSign)

    t1 = -t1;


  plQuatTemplate<Type> q;


  q.x = t0 * qFrom.x;

  q.y = t0 * qFrom.y;

  q.z = t0 * qFrom.z;

  q.w = t0 * qFrom.w;


  q.x += t1 * qTo.x;

  q.y += t1 * qTo.y;

  q.z += t1 * qTo.z;

  q.w += t1 * qTo.w;


  q.Normalize();


  return q;

}


template <typename Type>

PL_ALWAYS_INLINE bool operator==(const plQuatTemplate<Type>& q1, const plQuatTemplate<Type>& q2)

{

  return q1.x == q2.x && q1.y == q2.y && q1.z == q2.z && q1.w == q2.w;

}


template <typename Type>

PL_ALWAYS_INLINE bool operator!=(const plQuatTemplate<Type>& q1, const plQuatTemplate<Type>& q2)

{

  return !(q1 == q2);

}


template <typename Type>


void plQuatTemplate<Type>::GetAsEulerAngles(plAngle& out_x, plAngle& out_y, plAngle& out_z) const

{

  // Taken from https://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles

  // and http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToEuler/

  // adapted to our convention (yaw->pitch->roll, ZYX order or 3-2-1 order)


  auto& yaw = out_z;

  auto& pitch = out_y;

  auto& roll = out_x;


  const double fSingularityTest = w * y - z * x;

  const double fSingularityThreshold = 0.4999995;


  if (fSingularityTest > fSingularityThreshold) // singularity at north pole

  {

    yaw = -2.0f * plMath::ATan2(x, w);

    pitch = plAngle::MakeFromDegree(90.0f);

    roll = plAngle::MakeFromDegree(0.0f);

  }

  else if (fSingularityTest < -fSingularityThreshold) // singularity at south pole

  {

    yaw = 2.0f * plMath::ATan2(x, w);

    pitch = plAngle::MakeFromDegree(-90.0f);

    roll = plAngle::MakeFromDegree(0.0f);

  }

  else

  {

    // yaw (z-axis rotation)

    const double siny = 2.0 * (w * z + x * y);

    const double cosy = 1.0 - 2.0 * (y * y + z * z);

    yaw = plMath::ATan2((float)siny, (float)cosy);


    // pitch (y-axis rotation)

    pitch = plMath::ASin(2.0f * (float)fSingularityTest);


    // roll (x-axis rotation)

    const double sinr = 2.0 * (w * x + y * z);

    const double cosr = 1.0 - 2.0 * (x * x + y * y);

    roll = plMath::ATan2((float)sinr, (float)cosr);

  }

}


template <typename Type>


plQuatTemplate<Type> plQuatTemplate<Type>::MakeFromEulerAngles(const plAngle& x, const plAngle& y, const plAngle& z)

{

  const auto& yaw = z;

  const auto& pitch = y;

  const auto& roll = x;

  const double cy = plMath::Cos(yaw * 0.5);

  const double sy = plMath::Sin(yaw * 0.5);

  const double cp = plMath::Cos(pitch * 0.5);

  const double sp = plMath::Sin(pitch * 0.5);

  const double cr = plMath::Cos(roll * 0.5);

  const double sr = plMath::Sin(roll * 0.5);


  plQuatTemplate<Type> q;

  q.w = (float)(cy * cp * cr + sy * sp * sr);

  q.x = (float)(cy * cp * sr - sy * sp * cr);

  q.y = (float)(cy * sp * cr + sy * cp * sr);

  q.z = (float)(sy * cp * cr - cy * sp * sr);

  return q;

}


plAngle
Float wrapper struct for a safe usage and conversions of angles.
Definition Angle.h:10

plAngle::IsEqualSimple
bool IsEqualSimple(plAngle rhs, plAngle epsilon) const
Equality check with epsilon. Simple check without normalization. 360 degree will equal 0 degree,...
Definition Angle_inl.h:60

plAngle::MakeFromDegree
static constexpr plAngle MakeFromDegree(float fDegree)
Creates an instance of plAngle that was initialized from degree. (Performs a conversion)
Definition Angle_inl.h:33

plAngle::MakeFromRadian
static constexpr plAngle MakeFromRadian(float fRadian)
Creates an instance of plAngle that was initialized from radian. (No need for any conversion)
Definition Angle_inl.h:38

plMat3Template
A 3x3 component matrix class.
Definition Mat3.h:9

plMat3Template::SetColumn
void SetColumn(plUInt32 uiColumn, const plVec3Template< Type > &vColumn)
Sets all 3 components of the i-th column.
Definition Mat3_inl.h:218

plMat4Template
A 4x4 component matrix class.
Definition Mat4.h:11

plMat4Template::TransformDirection
const plVec3Template< Type > TransformDirection(const plVec3Template< Type > &v) const
Matrix-vector multiplication, assuming the 4th component of the vector is zero. So,...
Definition Mat4_inl.h:374

plQuatTemplate
Quaternions can be used to represent rotations in 3D space.
Definition Quat.h:19

plQuatTemplate::ReconstructFromMat4
void ReconstructFromMat4(const plMat4Template< Type > &m)
Reconstructs a rotation quaternion from a matrix that may contain scaling and mirroring.
Definition Quat_inl.h:342

plQuatTemplate::SetIdentity
void SetIdentity()
Sets the Quaternion to the identity.
Definition Quat_inl.h:41

plQuatTemplate::GetVectorPart
plVec3Template< Type > GetVectorPart() const
Returns the x,y,z components as a vector.
Definition Quat.h:102

plQuatTemplate::MakeSlerp
static plQuatTemplate< Type > MakeSlerp(const plQuatTemplate &qFrom, const plQuatTemplate &qTo, Type t)
Returns a quaternion that is the spherical linear interpolation of the other two.
Definition Quat_inl.h:403

plQuatTemplate::MakeFromMat3
static plQuatTemplate< Type > MakeFromMat3(const plMat3Template< Type > &m)
Creates a quaternion from the given matrix.
Definition Quat_inl.h:275

plQuatTemplate::GetInverse
const plQuatTemplate< Type > GetInverse() const
Returns a quaternion that represents the negative / inverted rotation. E.g. the one that would rotate...
Definition Quat_inl.h:106

plQuatTemplate::GetNegated
const plQuatTemplate< Type > GetNegated() const
Returns the Quaternion with all 4 components negated. This is not the same as the inverted rotation!
Definition Quat_inl.h:114

plQuatTemplate::Normalize
void Normalize()
Normalizes the quaternion to unit length. ALL rotation-quaternions should be normalized at all times ...
Definition Quat_inl.h:61

plQuatTemplate::IsEqualRotation
bool IsEqualRotation(const plQuatTemplate &qOther, Type fEpsilon) const
Determines whether this and qOther represent the same rotation. This is a rather slow operation.
Definition Quat_inl.h:181

plQuatTemplate::MakeFromElements
static plQuatTemplate< Type > MakeFromElements(Type x, Type y, Type z, Type w)
Sets the individual elements of the quaternion directly. Note that x,y,z do NOT represent a rotation ...
Definition Quat_inl.h:35

plQuatTemplate::GetRotationAxisAndAngle
void GetRotationAxisAndAngle(plVec3Template< Type > &out_vAxis, plAngle &out_angle, Type fEpsilon=plMath::DefaultEpsilon< Type >()) const
Returns the rotation-axis and angle, that this quaternion rotates around.
Definition Quat_inl.h:76

plQuatTemplate::MakeFromEulerAngles
static plQuatTemplate< Type > MakeFromEulerAngles(const plAngle &x, const plAngle &y, const plAngle &z)
Sets the quaternion from Euler angles.
Definition Quat_inl.h:520

plQuatTemplate::Rotate
plVec3Template< Type > Rotate(const plVec3Template< Type > &v) const
Returns v rotated by the quaternion. Same as operator*.
Definition Quat_inl.h:131

plQuatTemplate::IsNaN
bool IsNaN() const
Checks whether any component is NaN.
Definition Quat_inl.h:175

plQuatTemplate::GetAsMat4
const plMat4Template< Type > GetAsMat4() const
Returns the Quaternion as a matrix.
Definition Quat_inl.h:236

plQuatTemplate::MakeIdentity
static const plQuatTemplate< Type > MakeIdentity()
Static function that returns a quaternion that represents the identity rotation (none).
Definition Quat_inl.h:29

plQuatTemplate::ReconstructFromMat3
void ReconstructFromMat3(const plMat3Template< Type > &m)
Reconstructs a rotation quaternion from a matrix that may contain scaling and mirroring.
Definition Quat_inl.h:327

plQuatTemplate::MakeShortestRotation
static plQuatTemplate< Type > MakeShortestRotation(const plVec3Template< Type > &vDirFrom, const plVec3Template< Type > &vDirTo)
Creates a quaternion, that rotates through the shortest arc from "vDirFrom" to "vDirTo".
Definition Quat_inl.h:363

plQuatTemplate::GetAsMat3
const plMat3Template< Type > GetAsMat3() const
Returns the Quaternion as a matrix.
Definition Quat_inl.h:204

plQuatTemplate::MakeFromAxisAndAngle
static plQuatTemplate< Type > MakeFromAxisAndAngle(const plVec3Template< Type > &vRotationAxis, plAngle angle)
Creates a quaternion from a rotation-axis and an angle.
Definition Quat_inl.h:50

plQuatTemplate::Dot
Type Dot(const plQuatTemplate &rhs) const
Returns the dot-product of the two quaternions (commutative, order does not matter).
Definition Quat_inl.h:122

plQuatTemplate::GetAsEulerAngles
void GetAsEulerAngles(plAngle &out_x, plAngle &out_y, plAngle &out_z) const
Converts the quaternion to Euler angles.
Definition Quat_inl.h:477

plQuatTemplate::IsValid
bool IsValid(Type fEpsilon=plMath::DefaultEpsilon< Type >()) const
Checks whether all components are neither NaN nor infinite and that the quaternion is normalized.
Definition Quat_inl.h:162

plQuatTemplate::Invert
void Invert()
Inverts the rotation, so instead of rotating N degrees around an axis, the quaternion will rotate -N ...
Definition Quat_inl.h:98

plVec3Template
A 3-component vector class.
Definition Vec3.h:9

plVec3Template::Set
void Set(Type xyz)
Sets all 3 components to this value.
Definition Vec3_inl.h:32

plVec3Template::CrossRH
const plVec3Template< Type > CrossRH(const plVec3Template< Type > &rhs) const
Returns the Cross-product of the two vectors (NOT commutative, order DOES matter)
Definition Vec3_inl.h:299

plVec3Template::IsValid
bool IsValid() const
Checks that all components are finite numbers.
Definition Vec3_inl.h:157

plVec3Template::IsEqual
bool IsEqual(const plVec3Template< Type > &rhs, Type fEpsilon) const
Equality Check with epsilon.
Definition Vec3_inl.h:431

plVec3Template::GetNormalized
PL_DECLARE_IF_FLOAT_TYPE const plVec3Template< Type > GetNormalized() const
Returns a normalized version of this vector, leaves the vector itself unchanged.
Definition Vec3_inl.h:86

plVec3Template::Dot
Type Dot(const plVec3Template< Type > &rhs) const
Returns the Dot-product of the two vectors (commutative, order does not matter)
Definition Vec3_inl.h:290

plMath::Pi
constexpr TYPE Pi()
Returns the natural constant Pi.

plMath::ASin
PL_ALWAYS_INLINE plAngle ASin(float f)
Returns the arcus sinus of f.
Definition MathFloat_inl.h:77

plMath::ACos
PL_ALWAYS_INLINE plAngle ACos(float f)
Returns the arcus cosinus of f.
Definition MathFloat_inl.h:82

plMath::Sin
PL_ALWAYS_INLINE float Sin(plAngle a)
***** Trigonometric Functions *****
Definition MathFloat_inl.h:62

plMath::ATan2
PL_ALWAYS_INLINE plAngle ATan2(float y, float x)
Returns the atan2 of x and y.
Definition MathFloat_inl.h:92

plMath::Invert
constexpr Type Invert(Type f)
Returns 1 / f.
Definition Math_inl.h:63

plMath::NaN
constexpr TYPE NaN()
Returns the value for NaN as the template type. Returns zero, if the type does not support NaN.
Definition Constants_inl.h:58

plMath::Sqrt
PL_ALWAYS_INLINE double Sqrt(double f)
Returns the square root of f.
Definition MathDouble_inl.h:99

plMath::IsEqual
constexpr bool IsEqual(Type lhs, Type rhs, Type fEpsilon)
Checks, whether fValue is in the range [fDesired - fMaxImprecision; fDesired + fMaxImprecision].
Definition Math_inl.h:276

plMath::Abs
constexpr PL_ALWAYS_INLINE T Abs(T f)
Returns the absolute value of f.
Definition Math_inl.h:21

plMath::Cos
PL_ALWAYS_INLINE float Cos(plAngle a)
Takes an angle, returns its cosine.
Definition MathFloat_inl.h:67