EBGeometry_SphereCloudRayForm.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_SPHERECLOUDRAYFORM_HPP
#define EBGEOMETRY_SPHERECLOUDRAYFORM_HPP
 
// Std includes
#include <cstddef>
#include <cstdint>
 
// Our includes
#include "EBGeometry_Ray.hpp"
#include "EBGeometry_SphereCloudBVH.hpp"
 
namespace EBGeometry {
 
template <class T, size_t K, size_t W>
struct RayForm<SphereCloudBVH<T, K, W>>
{
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  static inline HitT<T>
  firstHit(const SphereCloudBVH<T, K, W>& a_shape,
           const RayT<T>&                 a_ray,
           T                              a_tMin,
           T                              a_tMax,
           const RayOptions<T>&           a_options) noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  static inline CrossingT<T>
  firstCrossing(const SphereCloudBVH<T, K, W>& a_shape,
                const RayT<T>&                 a_ray,
                T                              a_tMin,
                T                              a_tMax,
                const RayOptions<T>&           a_options) noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  static inline void
  spans(const SphereCloudBVH<T, K, W>& a_shape,
        const RayT<T>&                 a_ray,
        T                              a_tMin,
        T                              a_tMax,
        const RayOptions<T>&           a_options,
        bool                           a_firstOnly,
        RaySpansT<T>&                  a_spans) noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  static inline HitT<T>
  leafHit(const SphereCloudBVH<T, K, W>& a_shape,
          const RayT<T>&                 a_ray,
          T                              a_t,
          uint32_t                       a_sphere,
          const RayOptions<T>&           a_options) noexcept;
};
 
template <class T, size_t K, size_t W>
EBGEOMETRY_HOST_DEVICE
inline HitT<T>
RayForm<SphereCloudBVH<T, K, W>>::firstHit(const SphereCloudBVH<T, K, W>& a_shape,
                                           const RayT<T>&                 a_ray,
                                           const T                        a_tMin,
                                           const T                        a_tMax,
                                           const RayOptions<T>&           a_options) noexcept
{
  const auto trace =
    [&a_shape, &a_ray, &a_options](const T a_t0, const T a_t1, const bool a_all, RaySpansT<T>& a_spans) noexcept {
      spans(a_shape, a_ray, a_t0, a_t1, a_options, !a_all, a_spans);
    };
 
  const auto resolve = [&a_shape, &a_ray, &a_options](const T a_t, const uint32_t a_sphere) noexcept {
    return leafHit(a_shape, a_ray, a_t, a_sphere, a_options);
  };
 
  return RayDetail::traceSpans(trace, resolve, a_ray, a_tMin, a_tMax);
}
 
template <class T, size_t K, size_t W>
EBGEOMETRY_HOST_DEVICE
inline CrossingT<T>
RayForm<SphereCloudBVH<T, K, W>>::firstCrossing(const SphereCloudBVH<T, K, W>& a_shape,
                                                const RayT<T>&                 a_ray,
                                                const T                        a_tMin,
                                                const T                        a_tMax,
                                                const RayOptions<T>&           a_options) noexcept
{
  const auto trace =
    [&a_shape, &a_ray, &a_options](const T a_t0, const T a_t1, const bool a_all, RaySpansT<T>& a_spans) noexcept {
      spans(a_shape, a_ray, a_t0, a_t1, a_options, !a_all, a_spans);
    };
 
  return RayDetail::traceCrossing(trace, a_ray, a_tMin, a_tMax);
}
 
template <class T, size_t K, size_t W>
EBGEOMETRY_HOST_DEVICE
inline void
RayForm<SphereCloudBVH<T, K, W>>::spans(const SphereCloudBVH<T, K, W>& a_shape,
                                        const RayT<T>&                 a_ray,
                                        const T                        a_tMin,
                                        const T                        a_tMax,
                                        const RayOptions<T>& /*a_options*/,
                                        const bool    a_firstOnly,
                                        RaySpansT<T>& a_spans) noexcept
{
  a_spans.reset(a_tMax);
 
  if (a_shape.numSpheres() == 0U) {
    return;
  }
 
  const auto bvh    = a_shape.getBVH();
  const auto groups = bvh.getPrimitives();
 
  // One sphere's span at a time, united into the list. Each is cut to what the union so far is known up to, beyond
  // which it can change nothing known.
  RaySpansT<T> operand;
 
  const auto leaf = [&groups, &a_ray, a_tMin, a_firstOnly, &operand](
                      RaySpansT<T>& a_union, const size_t a_offset, const size_t a_count) noexcept {
    for (size_t g = a_offset; g < a_offset + a_count; g++) {
      const auto& group = groups[static_cast<uint32_t>(g)];
 
      Array<T, W> entry;
      Array<T, W> exit;
 
      group.rayIntervals(a_ray.m_origin, a_ray.m_direction, entry, exit);
 
      for (uint32_t lane = 0; lane < W; lane++) {
        if (entry[lane] <= exit[lane] && exit[lane] >= a_tMin && entry[lane] <= a_union.m_horizon) {
          operand.reset(a_union.m_horizon);
          operand.addClipped(entry[lane], exit[lane], a_tMin, a_union.m_horizon);
 
          RayDetail::nameLeaf(group.getSphereId(lane), operand);
          RayDetail::uniteInto(a_union, operand);
 
          if (a_firstOnly) {
            RayDetail::keepFirst(a_union);
          }
        }
      }
    }
  };
 
  // A box the ray enters beyond what the union is known up to can change nothing known.
  const auto bound = [](const RaySpansT<T>& a_union) noexcept -> T { return a_union.m_horizon; };
 
  bvh.traverse(BVH::RayQuery<T>(a_ray.m_origin, a_ray.m_direction, a_tMin), a_spans, leaf, bound);
}
 
template <class T, size_t K, size_t W>
EBGEOMETRY_HOST_DEVICE
inline HitT<T>
RayForm<SphereCloudBVH<T, K, W>>::leafHit(const SphereCloudBVH<T, K, W>& a_shape,
                                          const RayT<T>&                 a_ray,
                                          const T                        a_t,
                                          const uint32_t                 a_sphere,
                                          const RayOptions<T>& /*a_options*/) noexcept
{
  const SphereCloud::Sphere<T> sphere = a_shape.sphere(a_sphere);
 
  HitT<T> hit;
 
  hit.m_status    = HitStatus::Hit;
  hit.m_t         = a_t;
  hit.m_point     = a_ray.at(a_t);
  hit.m_primitive = a_sphere;
  hit.m_normal    = (sphere.m_radius > T(0)) ? (hit.m_point - sphere.m_center) / sphere.m_radius : Vec3T<T>::zeros();
  hit.m_entering  = dot(a_ray.m_direction, hit.m_normal) < T(0);
  hit.m_exact     = true;
 
  return hit;
}
 
} // namespace EBGeometry
 
#endif