Modified Ray class

src/simplnx/Common/Ray.hpp

@@ -16,7 +16,7 @@ namespace nx::core
  * simplify and better describe values used in GeometryMath. The rays initial alignment
  * is assumed to be with the Y-axis.
  */
-template <typename T, bool CacheEndV = false>
+template <typename T>
 class Ray
 {
 public:
@@ -46,10 +46,6 @@ class Ray
   , m_Angle(std::move(ang))
   , m_Length(length)
   {
-    if constexpr(CacheEndV)
-    {
-      m_Endpoint = calculateEndpoint();
-    }
   }
 
   /**
@@ -107,21 +103,16 @@ class Ray
    * @brief Sets a new origin point.
    * @param origin
    */
-  void setOrigin(const PointType& origin)
+  virtual void setOrigin(const PointType& origin)
   {
     m_Origin = origin;
-
-    if constexpr(CacheEndV)
-    {
-      m_Endpoint = calculateEndpoint();
-    }
   }
 
   /**
    * @brief Sets a new Euler angle.
    * @param ang
    */
-  void setEuler(const ZXZEulerType& ang)
+  virtual void setEuler(const ZXZEulerType& ang)
   {
     m_Angle = ang;
   }
@@ -139,37 +130,19 @@ class Ray
    * @brief Sets a new ray length.
    * @param length
    */
-  void setLength(LengthType length)
+  virtual void setLength(LengthType length)
   {
     m_Length = length;
-
-    if constexpr(CacheEndV)
-    {
-      m_Endpoint = calculateEndpoint();
-    }
   }
 
   /**
    * @brief Returns the end point determined by the origin point, Euler angle, and length.
    * Based on the assumption the point is initially aligned with the global axis' and the that this vector specifically aligned with the local y-axis.
    * @return PointType
    */
-  PointType getEndPoint() const
-  {
-    if constexpr(CacheEndV)
-    {
-      return m_Endpoint;
-    }
-    else
-    {
-      return calculateEndpoint();
-    }
-  }
-
-  template <bool E = CacheEndV, class = std::enable_if_t<E, bool>>
-  const PointType& getEndPointRef() const
+  virtual PointType getEndPoint() const
   {
-    return m_Endpoint;
+    return calculateEndpoint();
   }
 
   /**
@@ -235,14 +208,10 @@ class Ray
   }
 
 protected:
-private:
   PointType m_Origin;
   ZXZEulerType m_Angle;
   LengthType m_Length;
 
-  // Optional caching for speed
-  PointType m_Endpoint = {};
-
   PointType calculateEndpoint() const
   {
     const auto sin1 = std::sin(m_Angle[0]);
@@ -261,4 +230,103 @@ class Ray
     return m_Origin + (localXRotationVec * m_Length) + (localYRotationVec * m_Length) + (localZRotationVec * m_Length);
   }
 };
+
+template <typename T>
+class CachedRay : public Ray<T>
+{
+public:
+  /**
+   * @brief Creates a Ray from an origin point, ZXZEuler angle, and target length.
+   * @param origin
+   * @param ang
+   * @param length
+   */
+  CachedRay(const Ray<T>::PointType& origin, Ray<T>::ZXZEulerType ang, Ray<T>::LengthType length)
+  : Ray<T>(origin, std::move(ang), length)
+  {
+    m_Endpoint = this->calculateEndpoint();
+  }
+
+  /**
+   * @brief Copy constructor
+   * @param other
+   */
+  CachedRay(const CachedRay& other)
+  : m_Endpoint(other.m_Endpoint)
+  , Ray<T>(other)
+  {
+  }
+
+  /**
+   * @brief Move constructor
+   * @param other
+   */
+  CachedRay(CachedRay&& other) noexcept
+  : m_Endpoint(std::move(other.m_Endpoint))
+  , Ray<T>(std::move(other))
+  {
+  }
+
+  ~CachedRay() = default;
+
+  /**
+   * @brief Copy assignment operator
+   * @param rhs
+   * @return CachedRay&
+   */
+  CachedRay& operator=(const CachedRay& rhs)
+  {
+    this->m_Origin = rhs.m_Origin;
+    this->m_Angle = rhs.m_Angle;
+    this->m_Length = rhs.m_Length;
+    m_Endpoint = rhs.m_Endpoint;
+    return *this;
+  }
+
+  /**
+   * @brief Move assignment operator
+   * @param rhs
+   * @return Ray&
+   */
+  CachedRay& operator=(CachedRay&& rhs) noexcept
+  {
+    this->m_Origin = std::move(rhs.m_Origin);
+    this->m_Angle = std::move(rhs.m_Angle);
+    this->m_Length = std::move(rhs.m_Length);
+    m_Endpoint = std::move(rhs.m_Endpoint);
+    return *this;
+  }
+
+  void setOrigin(const Ray<T>::PointType& origin) override
+  {
+    this->m_Origin = origin;
+    m_Endpoint = Ray<T>::calculateEndpoint();
+  }
+
+  void setLength(Ray<T>::LengthType length) override
+  {
+    this->m_Length = length;
+    m_Endpoint = this->calculateEndpoint();
+  }
+
+  void setEuler(const Ray<T>::ZXZEulerType& ang) override
+  {
+    this->m_Angle = ang;
+    m_Endpoint = this->calculateEndpoint();
+  }
+
+  const Ray<T>::PointType& getEndPointRef() const
+  {
+    return m_Endpoint;
+  }
+
+  Ray<T>::PointType getEndPoint() const override
+  {
+    return m_Endpoint;
+  }
+
+private:
+  // Optional caching for speed
+  Ray<T>::PointType m_Endpoint = {};
+};
 } // namespace nx::core

src/simplnx/Utilities/Math/GeometryMath.hpp

@@ -273,7 +273,7 @@ bool DoesRayIntersectBox(const nx::core::Ray<T>& ray, const nx::core::BoundingBo
  * @return bool
  */
 template <typename T>
-bool DoesRayIntersectBox(const nx::core::Ray<T, true>& ray, const nx::core::BoundingBox3D<T>& bounds)
+bool DoesRayIntersectBox(const nx::core::CachedRay<T>& ray, const nx::core::BoundingBox3D<T>& bounds)
 {
   const auto& origin = ray.getOriginRef();
   const auto& min = bounds.getMinPoint();
@@ -468,7 +468,7 @@ char RayCrossesTriangle(const Ray<T>& ray, const Point3D<T>& p0, const Point3D<T
  * @return bool
  */
 template <typename T>
-char RayCrossesTriangle(const Ray<T, true>& ray, const Point3D<T>& p0, const Point3D<T>& p1, const Point3D<T>& p2)
+char RayCrossesTriangle(const CachedRay<T>& ray, const Point3D<T>& p0, const Point3D<T>& p1, const Point3D<T>& p2)
 {
   T vol0 = FindTetrahedronVolume(ray.getOrigin(), p0, p1, ray.getEndPointRef());
   T vol1 = FindTetrahedronVolume(ray.getOrigin(), p1, p2, ray.getEndPointRef());
@@ -552,7 +552,7 @@ char RayIntersectsPlane(const Ray<T>& ray, const Point3D<T>& p0, const Point3D<T
  * @return bool
  */
 template <typename T>
-char RayIntersectsPlane(const Ray<T, true>& ray, const Point3D<T>& p0, const Point3D<T>& p1, const Point3D<T>& p2)
+char RayIntersectsPlane(const CachedRay<T>& ray, const Point3D<T>& p0, const Point3D<T>& p1, const Point3D<T>& p2)
 {
   Vec3<T> normal = FindPlaneNormalVector(p0, p1, p2);
   T d = FindPlaneCoefficients(p0, normal);
@@ -639,7 +639,7 @@ char RayIntersectsTriangle(const Ray<T>& ray, const nx::core::Point3D<T>& p0, co
  * @return char
  */
 template <typename T>
-char RayIntersectsTriangle(const Ray<T, true>& ray, const nx::core::Point3D<T>& p0, const nx::core::Point3D<T>& p1, const nx::core::Point3D<T>& p2)
+char RayIntersectsTriangle(const CachedRay<T>& ray, const nx::core::Point3D<T>& p0, const nx::core::Point3D<T>& p1, const nx::core::Point3D<T>& p2)
 {
   char code = RayIntersectsPlane(ray, p0, p1, p2);
 
@@ -713,7 +713,7 @@ char IsPointInPolyhedron(const nx::core::TriangleGeom& triangleGeomRef, const st
     eulerAngles[1] = w * std::sin(t);
 
     // Generate and add ray to point to find other end [optimized version with lifetime caching]
-    Ray<T, true> ray(point, ZXZEuler(eulerAngles.data()), radius);
+    CachedRay<T> ray(point, ZXZEuler(eulerAngles.data()), radius);
 
     bool doNextCheck = false;
     for(usize face = 0; face < numFaces; face++)