Vec2.h

#pragma once
 
#include <Foundation/Math/Math.h>
 
#if PL_ENABLED(PL_MATH_CHECK_FOR_NAN)
#  define PL_VEC2_CHECK_FOR_NAN(obj) (obj)->AssertNotNaN();
#else
#  define PL_VEC2_CHECK_FOR_NAN(obj)
#endif
 
template <typename Type>
class plVec2Template
{
public:
  // Means that vectors can be copied using memcpy instead of copy construction.
  PL_DECLARE_POD_TYPE();
 
  using ComponentType = Type;
 
 
  // *** Data ***
public:
  Type x;
  Type y;
 
  // *** Constructors ***
public:
  plVec2Template(); // [tested]
 
  plVec2Template(Type x, Type y); // [tested]
 
  explicit plVec2Template(Type v); // [tested]
 
  // no copy-constructor and operator= since the default-generated ones will be faster
 
  PL_DECLARE_IF_FLOAT_TYPE
  [[nodiscard]] static const plVec2Template<Type>
  MakeNaN()
  {
    return plVec2Template<Type>(plMath::NaN<Type>());
  }
 
  [[nodiscard]] static constexpr plVec2Template<Type> MakeZero() { return plVec2Template(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 plVec3Template<Type> GetAsVec3(Type z) const; // [tested]
 
  const plVec4Template<Type> GetAsVec4(Type z, Type w) const; // [tested]
 
  const Type* GetData() const { return &x; }
 
  Type* GetData() { return &x; }
 
  // *** Functions to set the vector to specific values ***
public:
  void Set(Type xy); // [tested]
 
  void Set(Type x, Type y); // [tested]
 
  void SetZero(); // [tested]
 
  // *** Functions dealing with length ***
public:
  PL_DECLARE_IF_FLOAT_TYPE
  Type GetLength() const; // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  plResult SetLength(Type fNewLength, Type fEpsilon = plMath::DefaultEpsilon<Type>()); // [tested]
 
  Type GetLengthSquared() const; // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  Type GetLengthAndNormalize(); // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  const plVec2Template<Type> GetNormalized() const; // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  void Normalize(); // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  plResult NormalizeIfNotZero(const plVec2Template<Type>& vFallback = plVec2Template<Type>(1, 0), Type fEpsilon = plMath::DefaultEpsilon<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 plVec2Template<Type> operator-() const; // [tested]
 
  void operator+=(const plVec2Template<Type>& vCc); // [tested]
 
  void operator-=(const plVec2Template<Type>& vCc); // [tested]
 
  void operator*=(Type f); // [tested]
 
  void operator/=(Type f); // [tested]
 
  bool IsIdentical(const plVec2Template<Type>& rhs) const; // [tested]
 
  bool IsEqual(const plVec2Template<Type>& rhs, Type fEpsilon) const; // [tested]
 
 
  // *** Common vector operations ***
public:
  plAngle GetAngleBetween(const plVec2Template<Type>& rhs) const; // [tested]
 
  Type Dot(const plVec2Template<Type>& rhs) const; // [tested]
 
  const plVec2Template<Type> CompMin(const plVec2Template<Type>& rhs) const; // [tested]
 
  const plVec2Template<Type> CompMax(const plVec2Template<Type>& rhs) const; // [tested]
 
  const plVec2Template<Type> CompClamp(const plVec2Template<Type>& vLow, const plVec2Template<Type>& vHigh) const; // [tested]
 
  const plVec2Template<Type> CompMul(const plVec2Template<Type>& rhs) const; // [tested]
 
  const plVec2Template<Type> CompDiv(const plVec2Template<Type>& rhs) const; // [tested]
 
  const plVec2Template<Type> Abs() const; // [tested]
 
 
  // *** Other common operations ***
public:
  PL_DECLARE_IF_FLOAT_TYPE
  void MakeOrthogonalTo(const plVec2Template<Type>& vNormal); // [tested]
 
  const plVec2Template<Type> GetOrthogonalVector() const; // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  const plVec2Template<Type> GetReflectedVector(const plVec2Template<Type>& vNormal) const; // [tested]
};
 
// *** Operators ***
 
template <typename Type>
const plVec2Template<Type> operator+(const plVec2Template<Type>& v1, const plVec2Template<Type>& v2); // [tested]
 
template <typename Type>
const plVec2Template<Type> operator-(const plVec2Template<Type>& v1, const plVec2Template<Type>& v2); // [tested]
 
template <typename Type>
const plVec2Template<Type> operator*(Type f, const plVec2Template<Type>& v); // [tested]
 
template <typename Type>
const plVec2Template<Type> operator*(const plVec2Template<Type>& v, Type f); // [tested]
 
template <typename Type>
const plVec2Template<Type> operator/(const plVec2Template<Type>& v, Type f); // [tested]
 
template <typename Type>
bool operator==(const plVec2Template<Type>& v1, const plVec2Template<Type>& v2); // [tested]
 
template <typename Type>
bool operator!=(const plVec2Template<Type>& v1, const plVec2Template<Type>& v2); // [tested]
 
template <typename Type>
bool operator<(const plVec2Template<Type>& v1, const plVec2Template<Type>& v2);
 
#include <Foundation/Math/Implementation/Vec2_inl.h>