EBGeometry_Tape.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_TAPE_HPP
#define EBGEOMETRY_TAPE_HPP
 
// Std includes
#include <cstddef>
#include <cstdint>
#include <tuple>
#include <type_traits>
#include <vector>
 
// Our includes
#include "EBGeometry_AnalyticDistanceFunctions.hpp"
#include "EBGeometry_BVHUnion.hpp"
#include "EBGeometry_BoundingVolumes.hpp"
#include "EBGeometry_CSGRayForms.hpp"
#include "EBGeometry_DistanceQuality.hpp"
#include "EBGeometry_Expr.hpp"
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_MeshDistanceFunctions.hpp"
#include "EBGeometry_OffsetRayForms.hpp"
#include "EBGeometry_PODVector.hpp"
#include "EBGeometry_PackedBVH.hpp"
#include "EBGeometry_Pool.hpp"
#include "EBGeometry_PrimitiveRef.hpp"
#include "EBGeometry_Ray.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
struct TapeOptions
{
  uint32_t m_bvhUnionThreshold = 8;
 
  BVH::Construction m_construction = BVH::Construction::SAH;
};
 
namespace TapeFeature {
 
struct Tag
{
};
 
struct ExactOffsets : Tag
{
};
 
} // namespace TapeFeature
 
namespace TapeDetail {
 
enum class Op : uint8_t
{
  Primitive,      
  PushAffine,     
  PushElongate,   
  PopPoint,       
  Negate,         
  Abs,            
  AddConstant,    
  MulConstant,    
  Min,            
  Max,            
  PairInit,       
  PairInsert,     
  PairBlend,      
  Blur,           
  Mollify,        
  Repeat,         
  UnionBVH,       
  SmoothUnionBVH, 
};
 
enum class RayOp : uint8_t
{
  Leaf,         
  Marched,      
  Union,        
  Intersection, 
  Complement,   
  PushAffine,   
  PopAffine,    
  UnionBVH      
};
 
struct RayClause
{
  RayOp m_op = RayOp::Leaf;
 
  uint8_t m_flags = 0;
 
  uint16_t m_type = 0;
 
  uint32_t m_a = 0;
 
  uint32_t m_b = 0;
 
  uint32_t m_c = 0;
};
 
static_assert(sizeof(RayClause) == 16, "TapeDetail::RayClause must be 16 bytes");
 
struct Clause
{
  Op m_op = Op::Primitive;
 
  uint8_t m_flags = 0;
 
  uint16_t m_type = 0;
 
  uint32_t m_a = 0;
 
  uint32_t m_b = 0;
 
  uint32_t m_c = 0;
};
 
static_assert(sizeof(Clause) == 16, "TapeDetail::Clause must be 16 bytes");
 
[[nodiscard]] EBGEOMETRY_HOST_DEVICE
inline Clause
stored(const RayClause& a_clause) noexcept
{
  Clause c;
 
  c.m_op    = static_cast<Op>(a_clause.m_op);
  c.m_flags = a_clause.m_flags;
  c.m_type  = a_clause.m_type;
  c.m_a     = a_clause.m_a;
  c.m_b     = a_clause.m_b;
  c.m_c     = a_clause.m_c;
 
  return c;
}
 
[[nodiscard]] EBGEOMETRY_HOST_DEVICE
inline RayClause
rayClause(const Clause& a_clause) noexcept
{
  RayClause c;
 
  c.m_op    = static_cast<RayOp>(a_clause.m_op);
  c.m_flags = a_clause.m_flags;
  c.m_type  = a_clause.m_type;
  c.m_a     = a_clause.m_a;
  c.m_b     = a_clause.m_b;
  c.m_c     = a_clause.m_c;
 
  return c;
}
 
struct Program
{
  uint32_t m_begin = 0;
 
  uint32_t m_end = 0;
};
 
template <class T, size_t K>
struct UnionBVH
{
  typename BVH::PackedBVH<T, uint32_t, K>::Layout m_bvh;
 
  typename BVH::PackedBVH<T, uint32_t, K>::Layout m_unbounded;
};
 
template <class... Ps>
struct TypeList
{
  static constexpr size_t size = sizeof...(Ps);
};
 
template <size_t I, class List>
struct TypeAt;
 
template <size_t I, class... Ps>
struct TypeAt<I, TypeList<Ps...>>
{
  using type = std::tuple_element_t<I, std::tuple<Ps...>>;
};
 
template <class P, class List>
struct IndexOf;
 
template <class P>
struct IndexOf<P, TypeList<>>
{
  static constexpr size_t value = 0;
};
 
template <class P, class Q, class... Rest>
struct IndexOf<P, TypeList<Q, Rest...>>
{
  static constexpr size_t value = std::is_same_v<P, Q> ? 0 : 1 + IndexOf<P, TypeList<Rest...>>::value;
};
 
template <class... Lists>
struct Concat
{
  using type = TypeList<>;
};
 
template <class... Ps, class... Rest>
struct Concat<TypeList<Ps...>, Rest...>
{
  using type = typename Concat<TypeList<Ps...>, typename Concat<Rest...>::type>::type;
};
 
template <class... Ps, class... Qs>
struct Concat<TypeList<Ps...>, TypeList<Qs...>>
{
  using type = TypeList<Ps..., Qs...>;
};
 
template <class A>
inline constexpr bool IsFeature = std::is_base_of_v<TapeFeature::Tag, A>;
 
template <class... Args>
using FeaturesOf = typename Concat<std::conditional_t<IsFeature<Args>, TypeList<Args>, TypeList<>>...>::type;
 
template <class... Args>
using UserTypesOf = typename Concat<std::conditional_t<IsFeature<Args>, TypeList<>, TypeList<Args>>...>::type;
 
template <class... Ps>
struct PrimitiveStore
{
};
 
template <class P, class... Ps>
struct PrimitiveStore<P, Ps...>
{
  PODVector<CSGDetail::Stored<P>> m_head;
 
  PrimitiveStore<Ps...> m_tail;
};
 
template <class List>
struct StoreOf;
 
template <class... Ps>
struct StoreOf<TypeList<Ps...>>
{
  using type = PrimitiveStore<Ps...>;
};
 
template <size_t I, class P, class... Ps>
[[nodiscard]] EBGEOMETRY_HOST_DEVICE
inline const auto&
storeAt(const PrimitiveStore<P, Ps...>& a_store) noexcept
{
  if constexpr (I == 0) {
    return a_store.m_head;
  }
  else {
    return storeAt<I - 1>(a_store.m_tail);
  }
}
 
template <size_t I, class P, class... Ps>
[[nodiscard]] EBGEOMETRY_HOST_DEVICE
inline auto&
storeAt(PrimitiveStore<P, Ps...>& a_store) noexcept
{
  if constexpr (I == 0) {
    return a_store.m_head;
  }
  else {
    return storeAt<I - 1>(a_store.m_tail);
  }
}
 
template <class T, class... UserPrimitives>
using Primitives =
  typename Concat<TypeList<PlaneSDF<T>,
                           SphereSDF<T>,
                           BoxSDF<T>,
                           TorusSDF<T>,
                           CylinderSDF<T>,
                           InfiniteCylinderSDF<T>,
                           CapsuleSDF<T>,
                           InfiniteConeSDF<T>,
                           ConeSDF<T>,
                           RoundedBoxSDF<T>,
                           RoundedCylinderSDF<T>,
                           PerlinSDF<T>,
                           FlatMeshSDF<T>,
                           MeshSDF<T, BVH::DefaultBranchingRatio<T>()>,
                           TriMeshSDF<T, BVH::DefaultBranchingRatio<T>(), TriangleSoA::DefaultWidth<T>()>>,
                  UserTypesOf<UserPrimitives...>>::type;
 
template <class T, class List>
struct UserTypes;
 
template <class T, class... Ps>
struct UserTypes<T, TypeList<Ps...>>
{
  static constexpr bool shapes = (isShape<Ps> && ...);
 
  static constexpr bool precision = (std::is_same_v<ShapePrecision<Ps>, T> && ...);
};
 
template <class T, size_t K, class List>
struct Staging;
 
} // namespace TapeDetail
 
template <class T, class... UserPrimitives>
class Tape : public PoolHandle
{
public:
  static_assert(std::is_floating_point_v<T>, "Tape requires a floating-point type T");
  static_assert(TapeDetail::UserTypes<T, TapeDetail::UserTypesOf<UserPrimitives...>>::shapes,
                "Tape: every user primitive type must be a shape (see isShape)");
  static_assert(TapeDetail::UserTypes<T, TapeDetail::UserTypesOf<UserPrimitives...>>::precision,
                "Tape: every user primitive type must have the tape's precision");
 
  using Features = TapeDetail::FeaturesOf<UserPrimitives...>;
 
  template <class F>
  static constexpr bool hasFeature = TapeDetail::IndexOf<F, Features>::value < Features::size;
 
  using BV = BoundingVolumes::AABBT<T>;
 
  static constexpr size_t BranchingRatio = 4;
 
  static constexpr unsigned MaxCallDepth = 4;
 
  static constexpr uint32_t ValueStackSize = 16;
 
  static constexpr uint32_t PointStackSize = 8;
 
  static constexpr uint32_t RayStackSize = 4;
 
  using Primitives = TapeDetail::Primitives<T, UserPrimitives...>;
 
  using UnionRoot = BVH::PackedBVH<T, uint32_t, BranchingRatio>;
 
  struct Layout
  {
    typename TapeDetail::StoreOf<Primitives>::type m_primitives;
 
    PODVector<TapeDetail::Clause> m_clauses;
 
    PODVector<TapeDetail::Program> m_programs;
 
    PODVector<T> m_params;
 
    PODVector<TapeDetail::UnionBVH<T, BranchingRatio>> m_unions;
 
    BV m_boundingVolume;
 
    DistanceQuality m_quality = DistanceQuality::NotADistance;
 
    uint32_t m_callDepth = 0;
 
    uint32_t m_numPrograms = 0;
 
    uint32_t m_rayPrograms = 0;
  };
 
  Tape() = delete;
 
  EBGEOMETRY_HOST
  Tape(Pool& a_pool, const Expr<T>& a_expr, const TapeOptions& a_options = TapeOptions());
 
  EBGEOMETRY_HOST_DEVICE
  Tape(const Layout& a_layout, const PoolLocation& a_location) noexcept : PoolHandle(a_location), m_layout(a_layout)
  {}
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  signedDistance(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline PrimitiveRef<T>
  closestPrimitive(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline HitT<T>
  firstHit(const RayT<T>& a_ray, T a_tMin, T a_tMax, const RayOptions<T>& a_options = RayOptions<T>()) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline HitT<T>
  firstHit(const Vec3T<T>&      a_from,
           const Vec3T<T>&      a_to,
           T                    a_tMin    = T(0),
           const RayOptions<T>& a_options = RayOptions<T>()) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline HitStatus
  intersects(const RayT<T>& a_ray, T a_tMin, T a_tMax, const RayOptions<T>& a_options = RayOptions<T>()) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline HitStatus
  intersects(const Vec3T<T>&      a_from,
             const Vec3T<T>&      a_to,
             T                    a_tMin    = T(0),
             const RayOptions<T>& a_options = RayOptions<T>()) const noexcept;
 
  template <class P>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline bool
  isPrimitive(const PrimitiveRef<T>& a_ref) const noexcept;
 
  template <class P>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline P
  primitive(const PrimitiveRef<T>& a_ref) const noexcept;
 
  template <class F>
  EBGEOMETRY_HOST_DEVICE
  inline void
  visitPrimitive(const PrimitiveRef<T>& a_ref, F&& a_f) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline BV
  computeBoundingVolume() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline DistanceQuality
  getDistanceQuality() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline uint32_t
  getNumPrograms() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline uint32_t
  getNumClauses() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline uint32_t
  getNumBVHUnions() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline uint32_t
  getCallDepth() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline const Layout&
  layout() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline Tape
  rebasedView(const Pool& a_pool) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline Tape
  deepCopy(Pool& a_dstPool) const;
 
private:
  friend struct RayForm<Tape>;
 
  static constexpr uint32_t MarchedLeaf = UINT32_MAX;
 
  static constexpr uint32_t LevelLeaf = UINT32_MAX - 1;
 
  Layout m_layout;
 
  template <unsigned D>
  struct Subtree
  {
    const Tape* m_tape;
 
    uint32_t m_program;
 
    BV m_box;
 
    DistanceQuality m_quality;
 
    const void* m_base;
 
    PoolLocation m_location;
 
    [[nodiscard]] EBGEOMETRY_HOST_DEVICE
    inline T
    signedDistance(const Vec3T<T>& a_point) const noexcept
    {
      return m_tape->template evaluate<D>(m_program, a_point, m_base, m_location);
    }
 
    [[nodiscard]] EBGEOMETRY_HOST_DEVICE
    inline BV
    computeBoundingVolume() const noexcept
    {
      return m_box;
    }
 
    [[nodiscard]] EBGEOMETRY_HOST_DEVICE
    inline DistanceQuality
    getDistanceQuality() const noexcept
    {
      return m_quality;
    }
  };
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline HitT<T>
  traceRay(const RayT<T>& a_ray, T a_tMin, T a_tMax, const RayOptions<T>& a_options) const noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  raySpans(const RayT<T>&       a_ray,
           T                    a_tMin,
           T                    a_tMax,
           const RayOptions<T>& a_options,
           bool                 a_firstOnly,
           RaySpansT<T>&        a_spans) const noexcept;
 
  template <unsigned D>
  EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_DEVICE_NOINLINE
  inline void
  rayEvaluate(uint32_t             a_program,
              const RayT<T>&       a_ray,
              T                    a_t0,
              T                    a_t1,
              const RayOptions<T>& a_options,
              bool                 a_all,
              const void*          a_base,
              const PoolLocation&  a_location,
              RaySpansT<T>&        a_spans) const noexcept;
 
  template <unsigned D, bool Level = false>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_DEVICE_NOINLINE
  inline HitT<T>
  rayLeafHit(uint32_t             a_program,
             const RayT<T>&       a_ray,
             T                    a_t,
             uint32_t             a_clause,
             const RayOptions<T>& a_options,
             const void*          a_base,
             const PoolLocation&  a_location) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_DEVICE_NOINLINE
  inline HitT<T>
  primitiveLeafHit(const TapeDetail::RayClause& a_clause,
                   const RayT<T>&               a_ray,
                   T                            a_t,
                   const RayOptions<T>&         a_options,
                   const void*                  a_base,
                   const PoolLocation&          a_location) const noexcept;
 
  template <size_t I>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline HitT<T>
  dispatchLeafHit(const TapeDetail::RayClause& a_clause,
                  const RayT<T>&               a_ray,
                  T                            a_t,
                  const RayOptions<T>&         a_options,
                  const void*                  a_base,
                  const PoolLocation&          a_location) const noexcept;
 
  template <unsigned D>
  EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_DEVICE_NOINLINE
  inline void
  rayMarchedWithin(const TapeDetail::RayClause& a_clause,
                   const RayT<T>&               a_ray,
                   const RayOptions<T>&         a_options,
                   bool                         a_firstOnly,
                   const RaySpansT<T>&          a_within,
                   const void*                  a_base,
                   const PoolLocation&          a_location,
                   RaySpansT<T>&                a_spans) const noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_DEVICE_NOINLINE
  inline void
  rayLeaf(const TapeDetail::RayClause& a_clause,
          const RayT<T>&               a_ray,
          T                            a_t0,
          T                            a_t1,
          const RayOptions<T>&         a_options,
          bool                         a_firstOnly,
          const void*                  a_base,
          const PoolLocation&          a_location,
          RaySpansT<T>&                a_spans) const noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_DEVICE_NOINLINE
  EBGEOMETRY_HOST_NOINLINE
  void
  rayLevelLeaf(const TapeDetail::RayClause& a_clause,
               const RayT<T>&               a_ray,
               T                            a_t0,
               T                            a_t1,
               const RayOptions<T>&         a_options,
               bool                         a_firstOnly,
               const void*                  a_base,
               const PoolLocation&          a_location,
               RaySpansT<T>&                a_spans) const noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_DEVICE_NOINLINE
  EBGEOMETRY_HOST_NOINLINE
  void
  rayLevelWithin(const TapeDetail::RayClause& a_clause,
                 const RayT<T>&               a_ray,
                 const RayOptions<T>&         a_options,
                 bool                         a_firstOnly,
                 const RaySpansT<T>&          a_within,
                 const void*                  a_base,
                 const PoolLocation&          a_location,
                 RaySpansT<T>&                a_spans) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_DEVICE_NOINLINE
  EBGEOMETRY_HOST_NOINLINE
  HitT<T>
  levelClauseHit(const TapeDetail::RayClause& a_clause,
                 const RayT<T>&               a_ray,
                 T                            a_t,
                 const RayOptions<T>&         a_options,
                 const void*                  a_base,
                 const PoolLocation&          a_location) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_DEVICE_NOINLINE
  EBGEOMETRY_HOST_NOINLINE
  HitT<T>
  resolveLevelHit(uint32_t             a_clause,
                  const RayT<T>&       a_ray,
                  T                    a_t,
                  const RayOptions<T>& a_options,
                  const void*          a_base,
                  const PoolLocation&  a_location) const noexcept;
 
  template <size_t I, bool MeshOnly, class Visit>
  EBGEOMETRY_HOST_DEVICE
  inline void
  visitLevelPrimitive(const TapeDetail::RayClause& a_clause,
                      const void*                  a_base,
                      const PoolLocation&          a_location,
                      const Visit&                 a_visit) const noexcept;
 
  template <size_t I>
  EBGEOMETRY_HOST_DEVICE
  inline void
  dispatchRayLeaf(const TapeDetail::RayClause& a_clause,
                  const RayT<T>&               a_ray,
                  T                            a_t0,
                  T                            a_t1,
                  const RayOptions<T>&         a_options,
                  bool                         a_firstOnly,
                  const void*                  a_base,
                  const PoolLocation&          a_location,
                  RaySpansT<T>&                a_spans) const noexcept;
 
  template <unsigned D>
  EBGEOMETRY_HOST_DEVICE
  inline void
  rayUnion(const TapeDetail::RayClause& a_clause,
           const RayT<T>&               a_ray,
           T                            a_t0,
           T                            a_t1,
           const RayOptions<T>&         a_options,
           bool                         a_all,
           const void*                  a_base,
           const PoolLocation&          a_location,
           RaySpansT<T>&                a_spans) const noexcept;
 
  template <unsigned D, class V = T>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_DEVICE_NOINLINE
  inline V
  evaluate(const uint32_t      a_program,
           const Vec3T<T>&     a_point,
           const void*         a_base,
           const PoolLocation& a_location) const noexcept;
 
  template <unsigned D, class V = T>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline V
  evaluateBody(const uint32_t      a_program,
               const Vec3T<T>&     a_point,
               const void*         a_base,
               const PoolLocation& a_location) const noexcept;
 
  template <size_t I, class F>
  EBGEOMETRY_HOST_DEVICE
  inline void
  dispatchVisit(const PrimitiveRef<T>& a_ref, F&& a_f) const noexcept;
 
  template <size_t I, bool Handles>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  dispatchPrimitive(const uint32_t      a_type,
                    const uint32_t      a_index,
                    const Vec3T<T>&     a_point,
                    const void*         a_base,
                    const PoolLocation& a_location) const noexcept;
 
  static constexpr size_t DispatchSplit = 6;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_HOST_NOINLINE
  T
  dispatchRest(const uint32_t      a_type,
               const uint32_t      a_index,
               const Vec3T<T>&     a_point,
               const void*         a_base,
               const PoolLocation& a_location) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  evaluatePrimitive(const uint32_t      a_type,
                    const uint32_t      a_index,
                    const Vec3T<T>&     a_point,
                    const void*         a_base,
                    const PoolLocation& a_location) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_DEVICE_NOINLINE
  inline T
  evaluateHandle(const uint32_t      a_type,
                 const uint32_t      a_index,
                 const Vec3T<T>&     a_point,
                 const void*         a_base,
                 const PoolLocation& a_location) const noexcept;
 
  template <unsigned D, class V = T>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  EBGEOMETRY_DEVICE_NOINLINE
  inline V
  evaluateBlur(const TapeDetail::Clause& a_clause,
               const Vec3T<T>&           a_point,
               const T*                  a_params,
               const void*               a_base,
               const PoolLocation&       a_location) const noexcept;
 
  template <unsigned D, class V = T>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline V
  evaluateRepeat(const TapeDetail::Clause& a_clause,
                 const Vec3T<T>&           a_point,
                 const T*                  a_params,
                 const void*               a_base,
                 const PoolLocation&       a_location) const noexcept;
 
  template <unsigned D, class V = T>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline V
  evaluateUnion(const TapeDetail::Clause& a_clause,
                const Vec3T<T>&           a_point,
                const T*                  a_params,
                const void*               a_base,
                const PoolLocation&       a_location) const noexcept;
 
  EBGEOMETRY_HOST
  void
  finalize(Pool& a_pool, const TapeDetail::Staging<T, BranchingRatio, Primitives>& a_staging);
};
 
template <class T, class... UserPrimitives>
struct RayForm<Tape<T, UserPrimitives...>>
{
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  static inline HitT<T>
  firstHit(const Tape<T, UserPrimitives...>& a_shape,
           const RayT<T>&                    a_ray,
           T                                 a_tMin,
           T                                 a_tMax,
           const RayOptions<T>&              a_options) noexcept
  {
    return a_shape.traceRay(a_ray, a_tMin, a_tMax, a_options);
  }
 
  EBGEOMETRY_HOST_DEVICE
  static inline void
  spans(const Tape<T, UserPrimitives...>& 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
  {
    a_shape.raySpans(a_ray, a_tMin, a_tMax, a_options, a_firstOnly, a_spans);
  }
};
 
} // namespace EBGeometry
 
#include "EBGeometry_TapeImplem.hpp"
 
#endif