EBGeometry_BVHUnion.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2022 Robert Marskar <robert.marskar@sintef.no>
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef EBGEOMETRY_BVHUNION_HPP
#define EBGEOMETRY_BVHUNION_HPP
 
// Std includes
#include <cstddef>
#include <type_traits>
#include <utility>
#include <vector>
 
// Our includes
#include "EBGeometry_BVH.hpp"
#include "EBGeometry_Blend.hpp"
#include "EBGeometry_DistanceQuality.hpp"
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Macros.hpp"
#include "EBGeometry_Math.hpp"
#include "EBGeometry_Pool.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
namespace CSGDetail {
 
template <class P, bool = isPoolHandle<P>>
struct StoredAs
{
  using type = P;
};
 
template <class P>
struct StoredAs<P, true>
{
  using type = typename P::Layout;
};
 
template <class P>
using Stored = typename StoredAs<P>::type;
 
template <class P>
[[nodiscard]] EBGEOMETRY_HOST
inline Stored<P>
toStored(const P& a_primitive) noexcept
{
  if constexpr (isPoolHandle<P>) {
    return a_primitive.layout();
  }
  else {
    return a_primitive;
  }
}
 
template <class P>
[[nodiscard]] EBGEOMETRY_HOST_DEVICE
inline P
fromStored(const Stored<P>& a_stored, [[maybe_unused]] const PoolLocation& a_location) noexcept
{
  if constexpr (isPoolHandle<P>) {
    return P(a_stored, a_location);
  }
  else {
    return a_stored;
  }
}
 
template <class T, class P, size_t K>
struct UnionParts
{
  BVH::PackedBVH<T, Stored<P>, K> bvh;
 
  BVH::PackedBVH<T, Stored<P>, K> unbounded;
};
 
} // namespace CSGDetail
 
template <class T, class P, size_t K>
class BVHUnion : public PoolHandle
{
public:
  static_assert(std::is_floating_point_v<T>, "BVHUnion requires a floating-point type T");
  static_assert(std::is_trivially_copyable_v<P>, "BVHUnion requires a trivially copyable primitive type");
  static_assert(K > 1, "BVHUnion BVH branching factor K must be at least 2");
 
  static constexpr DistanceQuality distanceQuality =
    distanceQualityOf<P> == DistanceQuality::NotADistance ? DistanceQuality::NotADistance : DistanceQuality::Bound;
 
  using Root = BVH::PackedBVH<T, CSGDetail::Stored<P>, K>;
 
  using BV = BoundingVolumes::AABBT<T>;
 
  BVHUnion() = delete;
 
  [[nodiscard]] EBGEOMETRY_HOST
  static BVH::ConstructionOptions
  defaultConstructionOptions() noexcept
  {
    return Root::defaultConstructionOptions();
  }
 
  EBGEOMETRY_HOST
  BVHUnion(Pool&                  a_pool,
           const std::vector<P>&  a_primitives,
           const std::vector<BV>& a_boundingVolumes,
           BVH::Construction      a_construction = BVH::Construction::SAH);
 
  EBGEOMETRY_HOST
  BVHUnion(Pool&                           a_pool,
           const std::vector<P>&           a_primitives,
           const std::vector<BV>&          a_boundingVolumes,
           BVH::Construction               a_construction,
           const BVH::ConstructionOptions& a_options);
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  signedDistance(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline BV
  computeBoundingVolume() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Root
  getBVH() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline PODSpan<const CSGDetail::Stored<P>>
  getUnboundedPrimitives() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline BVHUnion
  rebasedView(const Pool& a_pool) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline BVHUnion
  deepCopy(Pool& a_dstPool) const;
 
  struct Layout
  {
    typename Root::Layout m_bvh;
 
    typename Root::Layout m_unbounded;
  };
 
  EBGEOMETRY_HOST_DEVICE
  BVHUnion(const Layout& a_layout, const PoolLocation& a_location) noexcept
    : PoolHandle(a_location), m_bvh(a_layout.m_bvh), m_unbounded(a_layout.m_unbounded)
  {}
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  Layout
  layout() const noexcept
  {
    return Layout{m_bvh, m_unbounded};
  }
 
private:
  EBGEOMETRY_HOST
  explicit BVHUnion(const CSGDetail::UnionParts<T, P, K>& a_parts) noexcept
    : PoolHandle(a_parts.bvh.location()), m_bvh(a_parts.bvh.layout()), m_unbounded(a_parts.unbounded.layout())
  {}
 
  typename Root::Layout m_bvh;
 
  typename Root::Layout m_unbounded;
};
 
template <class T, class P, size_t K, class Blend = SmoothMinOp<T>>
class BVHSmoothUnion : public PoolHandle
{
public:
  static_assert(std::is_floating_point_v<T>, "BVHSmoothUnion requires a floating-point type T");
  static_assert(std::is_trivially_copyable_v<P>, "BVHSmoothUnion requires a trivially copyable primitive type");
  static_assert(std::is_trivially_copyable_v<Blend>, "BVHSmoothUnion requires a trivially copyable blend operator");
  static_assert(K > 1, "BVHSmoothUnion BVH branching factor K must be at least 2");
 
  static constexpr DistanceQuality distanceQuality =
    distanceQualityOf<P> == DistanceQuality::NotADistance ? DistanceQuality::NotADistance : DistanceQuality::Bound;
 
  using Root = BVH::PackedBVH<T, CSGDetail::Stored<P>, K>;
 
  using BV = BoundingVolumes::AABBT<T>;
 
  BVHSmoothUnion() = delete;
 
  [[nodiscard]] EBGEOMETRY_HOST
  static BVH::ConstructionOptions
  defaultConstructionOptions() noexcept
  {
    return Root::defaultConstructionOptions();
  }
 
  EBGEOMETRY_HOST
  BVHSmoothUnion(Pool&                  a_pool,
                 const std::vector<P>&  a_primitives,
                 const std::vector<BV>& a_boundingVolumes,
                 T                      a_smoothLen,
                 Blend                  a_blend        = Blend{},
                 BVH::Construction      a_construction = BVH::Construction::SAH);
 
  EBGEOMETRY_HOST
  BVHSmoothUnion(Pool&                           a_pool,
                 const std::vector<P>&           a_primitives,
                 const std::vector<BV>&          a_boundingVolumes,
                 T                               a_smoothLen,
                 Blend                           a_blend,
                 BVH::Construction               a_construction,
                 const BVH::ConstructionOptions& a_options);
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  signedDistance(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline BV
  computeBoundingVolume() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Root
  getBVH() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline PODSpan<const CSGDetail::Stored<P>>
  getUnboundedPrimitives() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline BVHSmoothUnion
  rebasedView(const Pool& a_pool) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline BVHSmoothUnion
  deepCopy(Pool& a_dstPool) const;
 
  struct Layout
  {
    typename Root::Layout m_bvh;
 
    typename Root::Layout m_unbounded;
 
    T m_smoothLen;
 
    Blend m_blend;
  };
 
  EBGEOMETRY_HOST_DEVICE
  BVHSmoothUnion(const Layout& a_layout, const PoolLocation& a_location) noexcept
    : PoolHandle(a_location),
      m_bvh(a_layout.m_bvh),
      m_unbounded(a_layout.m_unbounded),
      m_smoothLen(a_layout.m_smoothLen),
      m_blend(a_layout.m_blend)
  {}
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  Layout
  layout() const noexcept
  {
    return Layout{m_bvh, m_unbounded, m_smoothLen, m_blend};
  }
 
private:
  EBGEOMETRY_HOST
  BVHSmoothUnion(const CSGDetail::UnionParts<T, P, K>& a_parts, T a_smoothLen, Blend a_blend) noexcept
    : PoolHandle(a_parts.bvh.location()),
      m_bvh(a_parts.bvh.layout()),
      m_unbounded(a_parts.unbounded.layout()),
      m_smoothLen(Math::max(a_smoothLen, Math::Limits<T>::min())),
      m_blend(a_blend)
  {}
 
  typename Root::Layout m_bvh;
 
  typename Root::Layout m_unbounded;
 
  T m_smoothLen;
 
  Blend m_blend;
};
 
} // namespace EBGeometry
 
#include "EBGeometry_BVHUnionImplem.hpp"
 
// The ray forms, through the fused operations: firstHit() is a template, and a file that included this header
// without them would march a BVH union that another file traces exactly, two definitions of one function.
// Included last, after the classes they specialize for, since those headers include this one.
#include "EBGeometry_Fused.hpp"
 
#endif