EBGeometry_BVHQuery.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_BVHQUERY_HPP
#define EBGEOMETRY_BVHQUERY_HPP
 
// Std includes
#include <cstddef>
#include <cstdint>
#include <type_traits>
#include <utility>
 
// Our includes
#include "EBGeometry_Array.hpp"
#include "EBGeometry_BoundingVolumes.hpp"
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Math.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
namespace BVH {
 
template <class T, size_t K>
struct ChildBoxes
{
  static constexpr size_t RowAlignment =
    (((sizeof(T) * K) & ((sizeof(T) * K) - 1)) == 0) ? (sizeof(T) * K) : alignof(T);
 
  alignas(RowAlignment) T m_lo[3][K];
 
  alignas(RowAlignment) T m_hi[3][K];
};
 
struct NearestFirst
{
};
 
struct FarthestFirst
{
};
 
struct AsStored
{
};
 
struct DescendAll
{
  template <class... Args>
  EBGEOMETRY_HOST_DEVICE
  constexpr bool
  operator()(const Args&... a_args) const noexcept
  {
    ((void)a_args, ...);
 
    return true;
  }
};
 
template <class Q, class = void>
struct QueryKey
{
  using type = typename Q::Scalar;
};
 
template <class Q>
struct QueryKey<Q, std::void_t<typename Q::Key>>
{
  using type = typename Q::Key;
};
 
template <class Q, class = void>
struct QueryLanes
{
  static constexpr uint32_t value = 1;
};
 
template <class Q>
struct QueryLanes<Q, std::void_t<decltype(Q::Lanes)>>
{
  static constexpr uint32_t value = Q::Lanes;
};
 
template <class Q, class = void>
struct IsQuery : std::false_type
{
};
 
template <class Q>
struct IsQuery<Q,
               std::void_t<typename Q::Scalar,
                           decltype(std::declval<const Q&>().key(
                             std::declval<const BoundingVolumes::AABBT<typename Q::Scalar>&>()))>> : std::true_type
{
};
 
template <class T>
struct PointQuery
{
  using Scalar = T;
 
  using Key = T;
 
  Vec3T<T> m_point;
 
  template <size_t K>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Array<T, K>
  keys(const ChildBoxes<T, K>& a_row) const noexcept;
 
  template <size_t K>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  key(const ChildBoxes<T, K>& a_row, size_t a_k) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  key(const BoundingVolumes::AABBT<T>& a_box) const noexcept;
};
 
template <class T>
PointQuery(Vec3T<T>) -> PointQuery<T>;
 
template <class T>
struct RayQuery
{
  using Scalar = T;
 
  using Key = T;
 
  Vec3T<T> m_origin;
 
  Vec3T<T> m_inverseDirection;
 
  T m_tMin;
 
  EBGEOMETRY_HOST_DEVICE
  inline RayQuery(const Vec3T<T>& a_origin, const Vec3T<T>& a_direction, T a_tMin = T(0)) noexcept;
 
  template <size_t K>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Array<T, K>
  keys(const ChildBoxes<T, K>& a_row) const noexcept;
 
  template <size_t K>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  key(const ChildBoxes<T, K>& a_row, size_t a_k) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  key(const BoundingVolumes::AABBT<T>& a_box) const noexcept;
};
 
} // namespace BVH
 
} // namespace EBGeometry
 
#include "EBGeometry_BVHQueryImplem.hpp"
 
#endif