Quat.h

#pragma once
 
#include <Foundation/Math/Vec3.h>
 
template <typename Type>
class plQuatTemplate
{
public:
  // Means this object can be copied using memcpy instead of copy construction.
  PL_DECLARE_POD_TYPE();
 
  using ComponentType = Type;
 
  // *** Data ***
public:
  Type x;
  Type y;
  Type z;
  Type w;
 
  // *** Constructors ***
public:
  plQuatTemplate(); // [tested]
 
  plQuatTemplate(Type x, Type y, Type z, Type w); // [tested]
 
#if PL_ENABLED(PL_MATH_CHECK_FOR_NAN)
  void AssertNotNaN() const
  {
    PL_ASSERT_ALWAYS(!IsNaN(), "This object contains NaN values. This can happen when you forgot to initialize it before using it. Please check that "
                               "all code-paths properly initialize this object.");
  }
#endif
 
  [[nodiscard]] static const plQuatTemplate<Type> MakeIdentity(); // [tested]
 
  // *** Functions to create a quaternion ***
public:
  void SetIdentity(); // [tested]
 
  [[nodiscard]] static plQuatTemplate<Type> MakeFromElements(Type x, Type y, Type z, Type w); // [tested]
 
  [[nodiscard]] static plQuatTemplate<Type> MakeFromAxisAndAngle(const plVec3Template<Type>& vRotationAxis, plAngle angle); // [tested]
 
  [[nodiscard]] static plQuatTemplate<Type> MakeShortestRotation(const plVec3Template<Type>& vDirFrom, const plVec3Template<Type>& vDirTo); // [tested]
 
  [[nodiscard]] static plQuatTemplate<Type> MakeFromMat3(const plMat3Template<Type>& m); // [tested]
 
  void ReconstructFromMat3(const plMat3Template<Type>& m);
 
  void ReconstructFromMat4(const plMat4Template<Type>& m);
 
  [[nodiscard]] static plQuatTemplate<Type> MakeSlerp(const plQuatTemplate& qFrom, const plQuatTemplate& qTo, Type t); // [tested]
 
  // *** Common Functions ***
public:
  void Normalize(); // [tested]
 
  const Type* GetData() const { return &x; }
 
  Type* GetData() { return &x; }
 
  void GetRotationAxisAndAngle(plVec3Template<Type>& out_vAxis, plAngle& out_angle, Type fEpsilon = plMath::DefaultEpsilon<Type>()) const; // [tested]
 
  plVec3Template<Type> GetVectorPart() const { return plVec3Template<Type>(x, y, z); }
 
  const plMat3Template<Type> GetAsMat3() const; // [tested]
 
  const plMat4Template<Type> GetAsMat4() const; // [tested]
 
  bool IsValid(Type fEpsilon = plMath::DefaultEpsilon<Type>()) const; // [tested]
 
  bool IsNaN() const; // [tested]
 
  bool IsEqualRotation(const plQuatTemplate& qOther, Type fEpsilon) const; // [tested]
 
  void Invert();
 
  const plQuatTemplate<Type> GetInverse() const; // [tested]
 
  const plQuatTemplate<Type> GetNegated() const;
 
  Type Dot(const plQuatTemplate& rhs) const; // [tested]
 
  plVec3Template<Type> Rotate(const plVec3Template<Type>& v) const;
 
  // *** Euler Angle Conversions ***
public:
  void GetAsEulerAngles(plAngle& out_x, plAngle& out_y, plAngle& out_z) const; // [tested]
 
  [[nodiscard]] static plQuatTemplate<Type> MakeFromEulerAngles(const plAngle& x, const plAngle& y, const plAngle& z); // [tested]
};
 
template <typename Type>
const plVec3Template<Type> operator*(const plQuatTemplate<Type>& q, const plVec3Template<Type>& v); // [tested]
 
template <typename Type>
const plQuatTemplate<Type> operator*(const plQuatTemplate<Type>& q1, const plQuatTemplate<Type>& q2); // [tested]
 
template <typename Type>
bool operator==(const plQuatTemplate<Type>& q1, const plQuatTemplate<Type>& q2);                      // [tested]
 
template <typename Type>
bool operator!=(const plQuatTemplate<Type>& q1, const plQuatTemplate<Type>& q2);                      // [tested]
 
#include <Foundation/Math/Implementation/Quat_inl.h>