Vec4.h

#pragma once
 
#include <Foundation/Math/Math.h>
#include <Foundation/Math/Vec3.h>
 
template <typename Type>
class plVec4Template
{
public:
  // Means that vectors can be copied using memcpy instead of copy construction.
  PL_DECLARE_POD_TYPE();
 
  using ComponentType = Type;
 
  // *** Data ***
public:
  Type x, y, z, w;
 
  // *** Constructors ***
public:
  plVec4Template(); // [tested]
 
  plVec4Template(Type x, Type y, Type z, Type w); // [tested]
 
  plVec4Template(plVec3Template<Type> vXyz, Type w);
 
  explicit plVec4Template(Type v); // [tested]
  // no copy-constructor and operator= since the default-generated ones will be faster
 
  PL_DECLARE_IF_FLOAT_TYPE
  [[nodiscard]] static plVec4Template<Type>
  MakeNaN() { return plVec4Template<Type>(plMath::NaN<Type>()); }
 
  [[nodiscard]] static plVec4Template<Type> MakeZero() { return plVec4Template<Type>(0); } // [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
 
  // *** Conversions ***
public:
  const plVec2Template<Type> GetAsVec2() const; // [tested]
 
  const plVec3Template<Type> GetAsVec3() const; // [tested]
 
  const Type* GetData() const { return &x; }
 
  Type* GetData() { return &x; }
 
  // *** Functions to set the vector to specific values ***
public:
  void Set(Type xyzw); // [tested]
 
  void Set(Type x, Type y, Type z, Type w); // [tested]
 
  void SetZero(); // [tested]
 
  // *** Functions dealing with length ***
public:
  PL_DECLARE_IF_FLOAT_TYPE
  Type GetLength() const; // [tested]
 
  Type GetLengthSquared() const; // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  Type GetLengthAndNormalize(); // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  const plVec4Template<Type> GetNormalized() const; // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  void Normalize(); // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  plResult NormalizeIfNotZero(const plVec4Template<Type>& vFallback = plVec4Template<Type>(1, 0, 0, 0), Type fEpsilon = plMath::SmallEpsilon<Type>()); // [tested]
 
  bool IsZero() const; // [tested]
 
  bool IsZero(Type fEpsilon) const; // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  bool IsNormalized(Type fEpsilon = plMath::HugeEpsilon<Type>()) const; // [tested]
 
  bool IsNaN() const; // [tested]
 
  bool IsValid() const; // [tested]
 
 
  // *** Operators ***
public:
  const plVec4Template<Type> operator-() const; // [tested]
 
  void operator+=(const plVec4Template<Type>& vCc); // [tested]
 
  void operator-=(const plVec4Template<Type>& vCc); // [tested]
 
  void operator*=(Type f); // [tested]
 
  void operator/=(Type f); // [tested]
 
  bool IsIdentical(const plVec4Template<Type>& rhs) const; // [tested]
 
  bool IsEqual(const plVec4Template<Type>& rhs, Type fEpsilon) const; // [tested]
 
 
  // *** Common vector operations ***
public:
  Type Dot(const plVec4Template<Type>& rhs) const; // [tested]
 
  const plVec4Template<Type> CompMin(const plVec4Template<Type>& rhs) const; // [tested]
 
  const plVec4Template<Type> CompMax(const plVec4Template<Type>& rhs) const; // [tested]
 
  const plVec4Template<Type> CompClamp(const plVec4Template<Type>& vLow, const plVec4Template<Type>& vHigh) const; // [tested]
 
  const plVec4Template<Type> CompMul(const plVec4Template<Type>& rhs) const; // [tested]
 
  const plVec4Template<Type> CompDiv(const plVec4Template<Type>& rhs) const; // [tested]
 
  const plVec4Template<Type> Abs() const; // [tested]
};
 
// *** Operators ***
 
template <typename Type>
const plVec4Template<Type> operator+(const plVec4Template<Type>& v1, const plVec4Template<Type>& v2); // [tested]
 
template <typename Type>
const plVec4Template<Type> operator-(const plVec4Template<Type>& v1, const plVec4Template<Type>& v2); // [tested]
 
 
template <typename Type>
const plVec4Template<Type> operator*(Type f, const plVec4Template<Type>& v); // [tested]
 
template <typename Type>
const plVec4Template<Type> operator*(const plVec4Template<Type>& v, Type f); // [tested]
 
 
template <typename Type>
const plVec4Template<Type> operator/(const plVec4Template<Type>& v, Type f); // [tested]
 
 
template <typename Type>
bool operator==(const plVec4Template<Type>& v1, const plVec4Template<Type>& v2); // [tested]
 
template <typename Type>
bool operator!=(const plVec4Template<Type>& v1, const plVec4Template<Type>& v2); // [tested]
 
template <typename Type>
bool operator<(const plVec4Template<Type>& v1, const plVec4Template<Type>& v2); // [tested]
 
#include <Foundation/Math/Implementation/Vec4_inl.h>