Mat4.h

#pragma once
 
#include <Foundation/Math/Angle.h>
#include <Foundation/Math/Math.h>
#include <Foundation/Math/Vec3.h>
#include <Foundation/Math/Vec4.h>
 
template <typename Type>
class plMat4Template
{
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, row 3),
  // then column 1, then column 2 and finally column 3
 
  Type m_fElementsCM[16];
 
  PL_ALWAYS_INLINE Type& Element(plInt32 iColumn, plInt32 iRow) { return m_fElementsCM[iColumn * 4 + iRow]; }
  PL_ALWAYS_INLINE Type Element(plInt32 iColumn, plInt32 iRow) const { return m_fElementsCM[iColumn * 4 + iRow]; }
 
  // *** Constructors ***
public:
  plMat4Template(); // [tested]
 
  plMat4Template(const Type* const pData, plMatrixLayout::Enum layout); // [tested]
 
  plMat4Template(Type c1r1, Type c2r1, Type c3r1, Type c4r1, Type c1r2, Type c2r2, Type c3r2, Type c4r2, Type c1r3, Type c2r3, Type c3r3, Type c4r3,
    Type c1r4, Type c2r4, Type c3r4, Type c4r4); // [tested]
 
  plMat4Template(const plMat3Template<Type>& mRotation, const plVec3Template<Type>& vTranslation); // [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 plMat4Template<Type> MakeZero();
 
  [[nodiscard]] static plMat4Template<Type> MakeIdentity();
 
  [[nodiscard]] static plMat4Template<Type> MakeFromRowMajorArray(const Type* const pData);
 
  [[nodiscard]] static plMat4Template<Type> MakeFromColumnMajorArray(const Type* const pData);
 
  [[nodiscard]] static plMat4Template<Type> MakeFromValues(Type c1r1, Type c2r1, Type c3r1, Type c4r1, Type c1r2, Type c2r2, Type c3r2, Type c4r2, Type c1r3, Type c2r3, Type c3r3, Type c4r3, Type c1r4, Type c2r4, Type c3r4, Type c4r4);
 
  [[nodiscard]] static plMat4Template<Type> MakeTranslation(const plVec3Template<Type>& vTranslation);
 
  [[nodiscard]] static plMat4Template<Type> MakeTransformation(const plMat3Template<Type>& mRotation, const plVec3Template<Type>& vTranslation);
 
  [[nodiscard]] static plMat4Template<Type> MakeScaling(const plVec3Template<Type>& vScale);
 
  [[nodiscard]] static plMat4Template<Type> MakeRotationX(plAngle angle);
 
  [[nodiscard]] static plMat4Template<Type> MakeRotationY(plAngle angle);
 
  [[nodiscard]] static plMat4Template<Type> MakeRotationZ(plAngle angle);
 
  [[nodiscard]] static plMat4Template<Type> MakeAxisRotation(const plVec3Template<Type>& vAxis, plAngle angle);
 
  void GetAsArray(Type* out_pData, plMatrixLayout::Enum layout) const; // [tested]
 
  void SetTransformationMatrix(const plMat3Template<Type>& mRotation, const plVec3Template<Type>& vTranslation); // [tested]
 
  // *** Special matrix constructors ***
public:
  void SetZero(); // [tested]
 
  void SetIdentity(); // [tested]
 
  // *** Common Matrix Operations ***
public:
  void Transpose(); // [tested]
 
  const plMat4Template<Type> GetTranspose() const; // [tested]
 
  plResult Invert(Type fEpsilon = plMath::SmallEpsilon<Type>()); // [tested]
 
  const plMat4Template<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:
  plVec4Template<Type> GetRow(plUInt32 uiRow) const; // [tested]
 
  void SetRow(plUInt32 uiRow, const plVec4Template<Type>& vRow); // [tested]
 
  plVec4Template<Type> GetColumn(plUInt32 uiColumn) const; // [tested]
 
  void SetColumn(plUInt32 uiColumn, const plVec4Template<Type>& vColumn); // [tested]
 
  plVec4Template<Type> GetDiagonal() const; // [tested]
 
  void SetDiagonal(const plVec4Template<Type>& vDiag); // [tested]
 
  const plVec3Template<Type> GetTranslationVector() const; // [tested]
 
  void SetTranslationVector(const plVec3Template<Type>& v); // [tested]
 
  void SetRotationalPart(const plMat3Template<Type>& mRotation); // [tested]
 
  const plMat3Template<Type> GetRotationalPart() const; // [tested]
 
  const plVec3Template<Type> GetScalingFactors() const; // [tested]
 
  plResult SetScalingFactors(const plVec3Template<Type>& vXYZ, Type fEpsilon = plMath::DefaultEpsilon<Type>()); // [tested]
 
  // *** Operators ***
public:
  const plVec3Template<Type> TransformPosition(const plVec3Template<Type>& v) const; // [tested]
 
  void TransformPosition(plVec3Template<Type>* pV, plUInt32 uiNumVectors, plUInt32 uiStride = sizeof(plVec3Template<Type>)) const; // [tested]
 
  const plVec3Template<Type> TransformDirection(const plVec3Template<Type>& v) const; // [tested]
 
  void TransformDirection(plVec3Template<Type>* pV, plUInt32 uiNumVectors, plUInt32 uiStride = sizeof(plVec3Template<Type>)) const; // [tested]
 
  const plVec4Template<Type> Transform(const plVec4Template<Type>& v) const; // [tested]
 
  void Transform(plVec4Template<Type>* pV, plUInt32 uiNumVectors, plUInt32 uiStride = sizeof(plVec4Template<Type>)) const; // [tested]
 
  void operator*=(Type f); // [tested]
 
  void operator/=(Type f); // [tested]
 
  bool IsIdentical(const plMat4Template<Type>& rhs) const; // [tested]
 
  bool IsEqual(const plMat4Template<Type>& rhs, Type fEpsilon) const; // [tested]
};
 
// *** free functions ***
 
template <typename Type>
const plMat4Template<Type> operator*(const plMat4Template<Type>& m1, const plMat4Template<Type>& m2); // [tested]
 
template <typename Type>
const plVec3Template<Type> operator*(const plMat4Template<Type>& m, const plVec3Template<Type>& v); // [tested]
 
template <typename Type>
const plVec4Template<Type> operator*(const plMat4Template<Type>& m, const plVec4Template<Type>& v); // [tested]
 
template <typename Type>
const plMat4Template<Type> operator*(const plMat4Template<Type>& m1, Type f); // [tested]
 
template <typename Type>
const plMat4Template<Type> operator*(Type f, const plMat4Template<Type>& m1); // [tested]
 
template <typename Type>
const plMat4Template<Type> operator/(const plMat4Template<Type>& m1, Type f); // [tested]
 
template <typename Type>
const plMat4Template<Type> operator+(const plMat4Template<Type>& m1, const plMat4Template<Type>& m2); // [tested]
 
template <typename Type>
const plMat4Template<Type> operator-(const plMat4Template<Type>& m1, const plMat4Template<Type>& m2); // [tested]
 
template <typename Type>
bool operator==(const plMat4Template<Type>& lhs, const plMat4Template<Type>& rhs); // [tested]
 
template <typename Type>
bool operator!=(const plMat4Template<Type>& lhs, const plMat4Template<Type>& rhs); // [tested]
 
#include <Foundation/Math/Implementation/Mat4_inl.h>