BoundingSphere.h

#pragma once
 
#include <Foundation/Math/Vec3.h>
 
template <typename Type>
class plBoundingSphereTemplate
{
public:
  // Means this object can be copied using memcpy instead of copy construction.
  PL_DECLARE_POD_TYPE();
 
  using ComponentType = Type;
 
public:
  plBoundingSphereTemplate();
 
 
  [[nodiscard]] static plBoundingSphereTemplate<Type> MakeZero();
 
  [[nodiscard]] static plBoundingSphereTemplate<Type> MakeInvalid(const plVec3Template<Type>& vCenter = plVec3Template<Type>::MakeZero());
 
  [[nodiscard]] static plBoundingSphereTemplate<Type> MakeFromCenterAndRadius(const plVec3Template<Type>& vCenter, Type fRadius);
 
  [[nodiscard]] static plBoundingSphereTemplate<Type> MakeFromPoints(const plVec3Template<Type>* pPoints, plUInt32 uiNumPoints, plUInt32 uiStride = sizeof(plVec3Template<Type>));
 
#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
 
  bool IsZero(Type fEpsilon = plMath::DefaultEpsilon<Type>()) const; // [tested]
 
  bool IsValid() const; // [tested]
 
  bool IsNaN() const; // [tested]
 
  void ExpandToInclude(const plVec3Template<Type>& vPoint); // [tested]
 
  void ExpandToInclude(const plVec3Template<Type>* pPoints, plUInt32 uiNumPoints, plUInt32 uiStride = sizeof(plVec3Template<Type>)); // [tested]
 
  void ExpandToInclude(const plBoundingSphereTemplate& rhs); // [tested]
 
  void ExpandToInclude(const plBoundingBoxTemplate<Type>& rhs); // [tested]
 
  void Grow(Type fDiff); // [tested]
 
  bool IsIdentical(const plBoundingSphereTemplate& rhs) const; // [tested]
 
  bool IsEqual(const plBoundingSphereTemplate& rhs, Type fEpsilon = plMath::DefaultEpsilon<Type>()) const; // [tested]
 
  void Translate(const plVec3Template<Type>& vTranslation); // [tested]
 
  void ScaleFromCenter(Type fScale); // [tested]
 
  void ScaleFromOrigin(const plVec3Template<Type>& vScale); // [tested]
 
  void TransformFromOrigin(const plMat4Template<Type>& mTransform); // [tested]
 
  void TransformFromCenter(const plMat4Template<Type>& mTransform); // [tested]
 
  Type GetDistanceTo(const plVec3Template<Type>& vPoint) const; // [tested]
 
  Type GetDistanceTo(const plBoundingSphereTemplate& rhs) const; // [tested]
 
  Type GetDistanceTo(const plBoundingBoxTemplate<Type>& rhs) const; // [tested]
 
  Type GetDistanceTo(const plVec3Template<Type>* pPoints, plUInt32 uiNumPoints, plUInt32 uiStride = sizeof(plVec3Template<Type>)) const; // [tested]
 
  bool Contains(const plVec3Template<Type>& vPoint) const; // [tested]
 
  bool Contains(const plVec3Template<Type>* pPoints, plUInt32 uiNumPoints, plUInt32 uiStride = sizeof(plVec3Template<Type>)) const; // [tested]
 
  bool Contains(const plBoundingSphereTemplate& rhs) const; // [tested]
 
  bool Contains(const plBoundingBoxTemplate<Type>& rhs) const; // [tested]
 
  bool Overlaps(const plVec3Template<Type>* pPoints, plUInt32 uiNumPoints, plUInt32 uiStride = sizeof(plVec3Template<Type>)) const; // [tested]
 
  bool Overlaps(const plBoundingSphereTemplate& rhs) const; // [tested]
 
  bool Overlaps(const plBoundingBoxTemplate<Type>& rhs) const; // [tested]
 
  const plBoundingBoxTemplate<Type> GetBoundingBox() const; // [tested]
 
  [[nodiscard]] const plVec3Template<Type> GetClampedPoint(const plVec3Template<Type>& vPoint); // [tested]
 
  [[nodiscard]] bool GetRayIntersection(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]
 
 
public:
  plVec3Template<Type> m_vCenter;
  Type m_fRadius;
};
 
template <typename Type>
bool operator==(const plBoundingSphereTemplate<Type>& lhs, const plBoundingSphereTemplate<Type>& rhs); // [tested]
 
template <typename Type>
bool operator!=(const plBoundingSphereTemplate<Type>& lhs, const plBoundingSphereTemplate<Type>& rhs); // [tested]
 
 
#include <Foundation/Math/Implementation/BoundingSphere_inl.h>