Mat3.h

#pragma once
 
#include <Foundation/Math/Angle.h>
#include <Foundation/Math/Vec3.h>
 
template <typename Type>
class plMat3Template
{
public:
  PL_DECLARE_POD_TYPE();
 
  using ComponentType = Type;
 
  // *** Data ***
public:
  // The elements are stored in column-major order.
  // That means first is column 0 (with elements of row 0, row 1, row 2),
  // then column 1, then column 2
 
  Type m_fElementsCM[9];
 
  PL_ALWAYS_INLINE Type& Element(plInt32 iColumn, plInt32 iRow) { return m_fElementsCM[iColumn * 3 + iRow]; }
  PL_ALWAYS_INLINE Type Element(plInt32 iColumn, plInt32 iRow) const { return m_fElementsCM[iColumn * 3 + iRow]; }
 
  // *** Constructors ***
public:
  plMat3Template(); // [tested]
 
  [[nodiscard]] static plMat3Template<Type> MakeZero();
 
  [[nodiscard]] static plMat3Template<Type> MakeIdentity();
 
  [[nodiscard]] static plMat3Template<Type> MakeFromRowMajorArray(const Type* const pData);
 
  [[nodiscard]] static plMat3Template<Type> MakeFromColumnMajorArray(const Type* const pData);
 
  [[nodiscard]] static plMat3Template<Type> MakeFromValues(Type c1r1, Type c2r1, Type c3r1, Type c1r2, Type c2r2, Type c3r2, Type c1r3, Type c2r3, Type c3r3);
 
  [[nodiscard]] static plMat3Template<Type> MakeScaling(const plVec3Template<Type>& vScale);
 
  [[nodiscard]] static plMat3Template<Type> MakeRotationX(plAngle angle);
 
  [[nodiscard]] static plMat3Template<Type> MakeRotationY(plAngle angle);
 
  [[nodiscard]] static plMat3Template<Type> MakeRotationZ(plAngle angle);
 
  [[nodiscard]] static plMat3Template<Type> MakeAxisRotation(const plVec3Template<Type>& vAxis, plAngle angle);
 
#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
 
  void GetAsArray(Type* out_pData, plMatrixLayout::Enum layout) const; // [tested]
 
  // *** Special matrix constructors ***
public:
  void SetZero(); // [tested]
 
  void SetIdentity(); // [tested]
 
  // *** Common Matrix Operations ***
public:
  void Transpose(); // [tested]
 
  const plMat3Template<Type> GetTranspose() const; // [tested]
 
  plResult Invert(Type fEpsilon = plMath::SmallEpsilon<Type>()); // [tested]
 
  const plMat3Template<Type> GetInverse(Type fEpsilon = plMath::SmallEpsilon<Type>()) const; // [tested]
 
  // *** Checks ***
public:
  bool IsZero(Type fEpsilon = plMath::DefaultEpsilon<Type>()) const; // [tested]
 
  bool IsIdentity(Type fEpsilon = plMath::DefaultEpsilon<Type>()) const; // [tested]
 
  bool IsValid() const; // [tested]
 
  bool IsNaN() const; // [tested]
 
  // *** Special Accessors ***
public:
  plVec3Template<Type> GetRow(plUInt32 uiRow) const; // [tested]
 
  void SetRow(plUInt32 uiRow, const plVec3Template<Type>& vRow); // [tested]
 
  plVec3Template<Type> GetColumn(plUInt32 uiColumn) const; // [tested]
 
  void SetColumn(plUInt32 uiColumn, const plVec3Template<Type>& vColumn); // [tested]
 
  plVec3Template<Type> GetDiagonal() const; // [tested]
 
  void SetDiagonal(const plVec3Template<Type>& vDiag); // [tested]
 
  const plVec3Template<Type> GetScalingFactors() const; // [tested]
 
  plResult SetScalingFactors(const plVec3Template<Type>& vXYZ, Type fEpsilon = plMath::DefaultEpsilon<Type>()); // [tested]
 
  Type GetDeterminant() const;
 
  // *** Operators ***
public:
  const plVec3Template<Type> TransformDirection(const plVec3Template<Type>& v) const; // [tested]
 
  void operator*=(Type f);
 
  void operator/=(Type f); // [tested]
 
  bool IsIdentical(const plMat3Template<Type>& rhs) const; // [tested]
 
  bool IsEqual(const plMat3Template<Type>& rhs, Type fEpsilon) const; // [tested]
};
 
// *** free functions ***
 
template <typename Type>
const plMat3Template<Type> operator*(const plMat3Template<Type>& m1, const plMat3Template<Type>& m2); // [tested]
 
template <typename Type>
const plVec3Template<Type> operator*(const plMat3Template<Type>& m, const plVec3Template<Type>& v); // [tested]
 
template <typename Type>
const plMat3Template<Type> operator*(const plMat3Template<Type>& m1, Type f); // [tested]
 
template <typename Type>
const plMat3Template<Type> operator*(Type f, const plMat3Template<Type>& m1); // [tested]
 
template <typename Type>
const plMat3Template<Type> operator/(const plMat3Template<Type>& m1, Type f); // [tested]
 
template <typename Type>
const plMat3Template<Type> operator+(const plMat3Template<Type>& m1, const plMat3Template<Type>& m2); // [tested]
 
template <typename Type>
const plMat3Template<Type> operator-(const plMat3Template<Type>& m1, const plMat3Template<Type>& m2); // [tested]
 
template <typename Type>
bool operator==(const plMat3Template<Type>& lhs, const plMat3Template<Type>& rhs); // [tested]
 
template <typename Type>
bool operator!=(const plMat3Template<Type>& lhs, const plMat3Template<Type>& rhs); // [tested]
 
#include <Foundation/Math/Implementation/Mat3_inl.h>