Plane.h

#pragma once
 
#include <Foundation/Math/Vec3.h>
#include <Foundation/Math/Vec4.h>
 
struct plPositionOnPlane
{
  enum Enum
  {
    Back,     
    Front,    
    OnPlane,  
    Spanning, 
  };
};
 
template <typename Type>
struct plPlaneTemplate
{
public:
  // Means this object can be copied using memcpy instead of copy construction.
  PL_DECLARE_POD_TYPE();
 
  using ComponentType = Type;
 
  // *** Data ***
public:
  plVec3Template<Type> m_vNormal;
  Type m_fNegDistance;
 
 
  // *** Constructors ***
public:
  plPlaneTemplate(); // [tested]
 
  [[nodiscard]] static plPlaneTemplate<Type> MakeInvalid();
 
  [[nodiscard]] static plPlaneTemplate<Type> MakeFromNormalAndPoint(const plVec3Template<Type>& vNormal, const plVec3Template<Type>& vPointOnPlane);
 
  [[nodiscard]] static plPlaneTemplate<Type> MakeFromPoints(const plVec3Template<Type>& v1, const plVec3Template<Type>& v2, const plVec3Template<Type>& v3);
 
#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
 
  plVec4Template<Type> GetAsVec4() const;
 
  plResult SetFromPoints(const plVec3Template<Type>& v1, const plVec3Template<Type>& v2, const plVec3Template<Type>& v3); // [tested]
 
  plResult SetFromPoints(const plVec3Template<Type>* const pVertices); // [tested]
 
  plResult SetFromPoints(const plVec3Template<Type>* const pVertices, plUInt32 uiMaxVertices); // [tested]
 
  plResult SetFromDirections(const plVec3Template<Type>& vTangent1, const plVec3Template<Type>& vTangent2, const plVec3Template<Type>& vPointOnPlane); // [tested]
 
  // *** Distance and Position ***
public:
  Type GetDistanceTo(const plVec3Template<Type>& vPoint) const; // [tested]
 
  Type GetMinimumDistanceTo(const plVec3Template<Type>* pPoints, plUInt32 uiNumPoints, plUInt32 uiStride = sizeof(plVec3Template<Type>)) const; // [tested]
 
  Type GetMinimumDistanceTo(const plBoundingBoxTemplate<Type>& box) const; // [tested]
 
  Type GetMaximumDistanceTo(const plBoundingBoxTemplate<Type>& box) const; // [tested]
 
  void GetMinMaxDistanceTo(Type& out_fMin, Type& out_fMax, const plVec3Template<Type>* pPoints, plUInt32 uiNumPoints, plUInt32 uiStride = sizeof(plVec3Template<Type>)) const; // [tested]
 
  plPositionOnPlane::Enum GetPointPosition(const plVec3Template<Type>& vPoint) const; // [tested]
 
  plPositionOnPlane::Enum GetPointPosition(const plVec3Template<Type>& vPoint, Type fPlaneHalfWidth) const; // [tested]
 
  plPositionOnPlane::Enum GetObjectPosition(const plVec3Template<Type>* const pPoints, plUInt32 uiVertices) const; // [tested]
 
  plPositionOnPlane::Enum GetObjectPosition(const plVec3Template<Type>* const pPoints, plUInt32 uiVertices, Type fPlaneHalfWidth) const; // [tested]
 
  plPositionOnPlane::Enum GetObjectPosition(const plBoundingSphereTemplate<Type>& sphere) const; // [tested]
 
  plPositionOnPlane::Enum GetObjectPosition(const plBoundingBoxTemplate<Type>& box) const; // [tested]
 
  [[nodiscard]] const plVec3Template<Type> ProjectOntoPlane(const plVec3Template<Type>& vPoint) const; // [tested]
 
  [[nodiscard]] const plVec3Template<Type> Mirror(const plVec3Template<Type>& vPoint) const; // [tested]
 
  const plVec3Template<Type> GetCoplanarDirection(const plVec3Template<Type>& vDirection) const; // [tested]
 
  // *** Comparisons ***
public:
  bool IsIdentical(const plPlaneTemplate<Type>& rhs) const; // [tested]
 
  bool IsEqual(const plPlaneTemplate<Type>& rhs, Type fEpsilon = plMath::DefaultEpsilon<Type>()) const; // [tested]
 
  bool IsValid() const; // [tested]
 
  bool IsNaN() const; // [tested]
 
  bool IsFinite() const; // [tested]
 
  // *** Modifications ***
public:
  void Transform(const plMat3Template<Type>& m); // [tested]
 
  void Transform(const plMat4Template<Type>& m); // [tested]
 
  void Flip(); // [tested]
 
  bool FlipIfNecessary(const plVec3Template<Type>& vPoint, bool bPlaneShouldFacePoint = true); // [tested]
 
  // *** Intersection Tests ***
public:
  [[nodiscard]] bool GetRayIntersection(const plVec3Template<Type>& vRayStartPos, const plVec3Template<Type>& vRayDir, Type* out_pIntersectionDinstance = nullptr, plVec3Template<Type>* out_pIntersection = nullptr) const; // [tested]
 
  [[nodiscard]] bool GetRayIntersectionBiDirectional(const plVec3Template<Type>& vRayStartPos, const plVec3Template<Type>& vRayDir, Type* out_pIntersectionDistance = nullptr, plVec3Template<Type>* out_pIntersection = nullptr) const; // [tested]
 
  [[nodiscard]] bool GetLineSegmentIntersection(const plVec3Template<Type>& vLineStartPos, const plVec3Template<Type>& vLineEndPos, Type* out_pHitFraction = nullptr, plVec3Template<Type>* out_pIntersection = nullptr) const; // [tested]
 
  static plResult GetPlanesIntersectionPoint(const plPlaneTemplate<Type>& p0, const plPlaneTemplate<Type>& p1, const plPlaneTemplate<Type>& p2, plVec3Template<Type>& out_vResult); // [tested]
 
  // *** Helper Functions ***
public:
  static plResult FindSupportPoints(const plVec3Template<Type>* const pVertices, plInt32 iMaxVertices, plInt32& out_i1, plInt32& out_i2, plInt32& out_i3); // [tested]
};
 
template <typename Type>
bool operator==(const plPlaneTemplate<Type>& lhs, const plPlaneTemplate<Type>& rhs); // [tested]
 
template <typename Type>
bool operator!=(const plPlaneTemplate<Type>& lhs, const plPlaneTemplate<Type>& rhs); // [tested]
 
#include <Foundation/Math/Implementation/Plane_inl.h>