EBGeometry_Ray.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Robert Marskar <robert.marskar@sintef.no>
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef EBGEOMETRY_RAY_HPP
#define EBGEOMETRY_RAY_HPP
 
// Std includes
#include <cstdint>
#include <type_traits>
 
// Our includes
#include "EBGeometry_BoundingVolumes.hpp"
#include "EBGeometry_DistanceQuality.hpp"
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Math.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
template <class T>
struct RayT
{
  using Scalar = T;
 
  Vec3T<T> m_origin;
 
  Vec3T<T> m_direction;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Vec3T<T>
  at(T a_t) const noexcept;
};
 
enum class HitStatus : uint8_t
{
  Miss,      
  Hit,       
  Unresolved 
};
 
template <class T>
struct HitT
{
  HitStatus m_status = HitStatus::Miss;
 
  T m_t = Math::Limits<T>::infinity();
 
  Vec3T<T> m_point = Vec3T<T>::zeros();
 
  uint32_t m_primitive = 0;
 
  Vec3T<T> m_normal = Vec3T<T>::zeros();
 
  bool m_entering = false;
 
  bool m_exact = false;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline bool
  hit() const noexcept;
};
 
template <class T>
struct RayOptions
{
  T m_tolerance = T(1e-4);
 
  T m_scale = T(0);
 
  uint32_t m_maxSteps = 512;
 
  T m_step = T(0.005);
 
  bool m_march = false;
};
 
template <class T>
struct SpanEndT
{
  enum Kind : uint8_t
  {
    Open    = 0, 
    Exact   = 1, 
    Marched = 2  
  };
 
  T m_t;
 
  uint32_t m_leaf;
 
  Kind m_kind;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline bool
  crossing() const noexcept;
};
 
template <class T>
struct RaySpansT
{
  static constexpr uint32_t Capacity = 8;
 
  struct Span
  {
    SpanEndT<T> m_in;
 
    SpanEndT<T> m_out;
  };
 
  Span m_spans[Capacity];
 
  uint32_t m_count = 0;
 
  T m_horizon = Math::Limits<T>::infinity();
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  reset(T a_horizon) noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  add(const SpanEndT<T>& a_in, const SpanEndT<T>& a_out) noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  addClipped(T a_in, T a_out, T a_t0, T a_t1) noexcept;
};
 
template <class S, class = void>
struct RayForm
{
};
 
template <class T, class S>
[[nodiscard]] EBGEOMETRY_HOST_DEVICE
inline HitT<T>
firstHit(const S&                 a_shape,
         const RayT<T>&           a_ray,
         typename RayT<T>::Scalar a_tMin,
         typename RayT<T>::Scalar a_tMax,
         const RayOptions<T>&     a_options = RayOptions<T>()) noexcept;
 
template <class T, class S>
[[nodiscard]] EBGEOMETRY_HOST_DEVICE
inline HitT<T>
firstHit(const S&             a_shape,
         const Vec3T<T>&      a_from,
         const Vec3T<T>&      a_to,
         T                    a_tMin    = T(0),
         const RayOptions<T>& a_options = RayOptions<T>()) noexcept;
 
template <class T, class S>
[[nodiscard]] EBGEOMETRY_HOST_DEVICE
inline HitStatus
intersects(const S&                 a_shape,
           const RayT<T>&           a_ray,
           typename RayT<T>::Scalar a_tMin,
           typename RayT<T>::Scalar a_tMax,
           const RayOptions<T>&     a_options = RayOptions<T>()) noexcept;
 
template <class T, class S>
[[nodiscard]] EBGEOMETRY_HOST_DEVICE
inline HitStatus
intersects(const S&             a_shape,
           const Vec3T<T>&      a_from,
           const Vec3T<T>&      a_to,
           T                    a_tMin    = T(0),
           const RayOptions<T>& a_options = RayOptions<T>()) noexcept;
 
} // namespace EBGeometry
 
#include "EBGeometry_RayImplem.hpp"
#include "EBGeometry_RaySpans.hpp"
 
#endif