Vec3.h

#pragma once
 
#include <Foundation/Math/Math.h>
#include <Foundation/Math/Vec2.h>
 
template <typename Type>
class plVec3Template
{
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;
 
  // *** Constructors ***
public:
  plVec3Template<Type>(); // [tested]
 
  plVec3Template<Type>(Type x, Type y, Type z); // [tested]
 
  explicit plVec3Template<Type>(Type v); // [tested]
 
  // no copy-constructor and operator= since the default-generated ones will be faster
 
  PL_DECLARE_IF_FLOAT_TYPE
  [[nodiscard]] static plVec3Template<Type> MakeNaN() { return plVec3Template<Type>(plMath::NaN<Type>()); }
 
  [[nodiscard]] static plVec3Template<Type> MakeZero() { return plVec3Template<Type>(0); } // [tested]
 
  [[nodiscard]] static plVec3Template<Type> MakeAxisX() { return plVec3Template<Type>(1, 0, 0); } // [tested]
 
  [[nodiscard]] static plVec3Template<Type> MakeAxisY() { return plVec3Template<Type>(0, 1, 0); } // [tested]
 
  [[nodiscard]] static plVec3Template<Type> MakeAxisZ() { return plVec3Template<Type>(0, 0, 1); } // [tested]
 
  [[nodiscard]] static plVec3Template<Type> Make(Type x, Type y, Type z) { return plVec3Template<Type>(x, y, z); } // [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 plVec4Template<Type> GetAsVec4(Type w) const; // [tested]
 
  const plVec4Template<Type> GetAsPositionVec4() const; // [tested]
 
  const plVec4Template<Type> GetAsDirectionVec4() const; // [tested]
 
  const Type* GetData() const { return &x; }
 
  Type* GetData() { return &x; }
 
  // *** Functions to set the vector to specific values ***
public:
  void Set(Type xyz); // [tested]
 
  void Set(Type x, Type y, Type z); // [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 plVec3Template<Type> GetNormalized() const; // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  void Normalize(); // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  plResult NormalizeIfNotZero(const plVec3Template<Type>& vFallback = plVec3Template<Type>(1, 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 plVec3Template<Type> operator-() const; // [tested]
 
  void operator+=(const plVec3Template<Type>& rhs); // [tested]
 
  void operator-=(const plVec3Template<Type>& rhs); // [tested]
 
  void operator*=(const plVec3Template<Type>& rhs);
 
  void operator/=(const plVec3Template<Type>& rhs);
 
  void operator*=(Type f); // [tested]
 
  void operator/=(Type f); // [tested]
 
  bool IsIdentical(const plVec3Template<Type>& rhs) const; // [tested]
 
  bool IsEqual(const plVec3Template<Type>& rhs, Type fEpsilon) const; // [tested]
 
 
  // *** Common vector operations ***
public:
  plAngle GetAngleBetween(const plVec3Template<Type>& rhs) const; // [tested]
 
  Type Dot(const plVec3Template<Type>& rhs) const; // [tested]
 
 
 
  const plVec3Template<Type> CrossRH(const plVec3Template<Type>& rhs) const; // [tested]
 
  const plVec3Template<Type> CompMin(const plVec3Template<Type>& rhs) const; // [tested]
 
  const plVec3Template<Type> CompMax(const plVec3Template<Type>& rhs) const; // [tested]
 
  const plVec3Template<Type> CompClamp(const plVec3Template<Type>& vLow, const plVec3Template<Type>& vHigh) const; // [tested]
 
  const plVec3Template<Type> CompMul(const plVec3Template<Type>& rhs) const; // [tested]
 
  const plVec3Template<Type> CompDiv(const plVec3Template<Type>& rhs) const; // [tested]
 
  const plVec3Template<Type> Abs() const; // [tested]
 
 
  // *** Other common operations ***
public:
  PL_DECLARE_IF_FLOAT_TYPE
  plResult CalculateNormal(const plVec3Template<Type>& v1, const plVec3Template<Type>& v2, const plVec3Template<Type>& v3); // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  void MakeOrthogonalTo(const plVec3Template<Type>& vNormal); // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  const plVec3Template<Type> GetOrthogonalVector() const; // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  const plVec3Template<Type> GetReflectedVector(const plVec3Template<Type>& vNormal) const; // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  const plVec3Template<Type> GetRefractedVector(const plVec3Template<Type>& vNormal, Type fRefIndex1, Type fRefIndex2) const;
 
  PL_DECLARE_IF_FLOAT_TYPE
  [[nodiscard]] static plVec3Template<Type>
  MakeRandomPointInSphere(plRandom& inout_rng); // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  [[nodiscard]] static plVec3Template<Type>
  MakeRandomDirection(plRandom& inout_rng); // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  [[nodiscard]] static plVec3Template<Type>
  MakeRandomDeviationX(plRandom& inout_rng, const plAngle& maxDeviation); // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  [[nodiscard]] static plVec3Template<Type>
  MakeRandomDeviationY(plRandom& inout_rng, const plAngle& maxDeviation); // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  [[nodiscard]] static plVec3Template<Type>
  MakeRandomDeviationZ(plRandom& inout_rng, const plAngle& maxDeviation); // [tested]
 
  PL_DECLARE_IF_FLOAT_TYPE
  [[nodiscard]] static plVec3Template<Type>
  MakeRandomDeviation(plRandom& inout_rng, const plAngle& maxDeviation, const plVec3Template<Type>& vNormal); // [tested]
};
 
// *** Operators ***
 
template <typename Type>
const plVec3Template<Type> operator+(const plVec3Template<Type>& v1, const plVec3Template<Type>& v2); // [tested]
 
template <typename Type>
const plVec3Template<Type> operator-(const plVec3Template<Type>& v1, const plVec3Template<Type>& v2); // [tested]
 
 
template <typename Type>
const plVec3Template<Type> operator*(Type f, const plVec3Template<Type>& v); // [tested]
 
template <typename Type>
const plVec3Template<Type> operator*(const plVec3Template<Type>& v, Type f); // [tested]
 
 
template <typename Type>
const plVec3Template<Type> operator/(const plVec3Template<Type>& v, Type f); // [tested]
 
 
template <typename Type>
bool operator==(const plVec3Template<Type>& v1, const plVec3Template<Type>& v2); // [tested]
 
template <typename Type>
bool operator!=(const plVec3Template<Type>& v1, const plVec3Template<Type>& v2); // [tested]
 
template <typename Type>
bool operator<(const plVec3Template<Type>& v1, const plVec3Template<Type>& v2); // [tested]
 
#include <Foundation/Math/Implementation/Vec3_inl.h>