EBGeometry_MeshDistanceFunctions.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 Robert Marskar <robert.marskar@sintef.no>
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef EBGEOMETRY_MESHDISTANCEFUNCTIONS_HPP
#define EBGEOMETRY_MESHDISTANCEFUNCTIONS_HPP
 
// Std includes
#include <cstddef>
#include <cstdint>
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
 
// Our includes
#include "EBGeometry_BVH.hpp"
#include "EBGeometry_BoundingVolumes.hpp"
#include "EBGeometry_DCEL_Mesh.hpp"
#include "EBGeometry_DistanceQuality.hpp"
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Math.hpp"
#include "EBGeometry_Pool.hpp"
#include "EBGeometry_Triangle.hpp"
#include "EBGeometry_TriangleAoSoA.hpp"
#include "EBGeometry_TriangleSoA.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
template <class T>
struct ClosestFace
{
  T        signedDistance = Math::Limits<T>::max(); 
  uint32_t faceId         = UINT32_MAX;             
};
 
template <class T>
class FlatMeshSDF : public PoolHandle
{
  static_assert(std::is_floating_point_v<T>, "FlatMeshSDF requires a floating-point T");
 
public:
  static constexpr DistanceQuality distanceQuality = DistanceQuality::Exact;
 
  using Mesh = EBGeometry::DCEL::MeshT<T>;
 
  FlatMeshSDF() = delete;
 
  struct Layout
  {
    typename Mesh::Layout m_mesh;
  };
 
  EBGEOMETRY_HOST_DEVICE
  FlatMeshSDF(const Layout& a_layout, const PoolLocation& a_location) noexcept
    : PoolHandle(a_location), m_meshLayout(a_layout.m_mesh)
  {}
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  Layout
  layout() const noexcept
  {
    return Layout{m_meshLayout};
  }
 
  EBGEOMETRY_HOST
  inline FlatMeshSDF(const Mesh& a_mesh, Pool& a_pool) noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline T
  signedDistance(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline ClosestFace<T>
  getClosestFace(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Mesh
  getMesh() const noexcept
  {
    return Mesh(m_meshLayout, this->location());
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline FlatMeshSDF
  rebasedView(const Pool& a_pool) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline FlatMeshSDF
  deepCopy(Pool& a_dstPool) const;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline EBGeometry::BoundingVolumes::AABBT<T>
  computeBoundingVolume() const noexcept;
 
private:
  typename Mesh::Layout m_meshLayout;
};
 
static_assert(std::is_trivially_copyable_v<FlatMeshSDF<float>>, "FlatMeshSDF<float> must be trivially copyable");
static_assert(std::is_trivially_copyable_v<FlatMeshSDF<double>>, "FlatMeshSDF<double> must be trivially copyable");
 
template <class T, size_t K>
class MeshSDF : public PoolHandle
{
  static_assert(std::is_floating_point_v<T>, "MeshSDF requires a floating-point T");
  static_assert(K >= 2, "MeshSDF requires branching factor K >= 2");
 
public:
  static constexpr DistanceQuality distanceQuality = DistanceQuality::Exact;
 
  using Face = typename EBGeometry::DCEL::FaceT<T>;
 
  using Mesh = typename EBGeometry::DCEL::MeshT<T>;
 
  using Root = EBGeometry::BVH::PackedBVH<T, uint32_t, K>;
 
  using Node = typename Root::Node;
 
  MeshSDF() = delete;
 
  struct Layout
  {
    typename Mesh::Layout m_mesh;
 
    typename Root::Layout m_bvh;
  };
 
  EBGEOMETRY_HOST_DEVICE
  MeshSDF(const Layout& a_layout, const PoolLocation& a_location) noexcept
    : PoolHandle(a_location), m_meshLayout(a_layout.m_mesh), m_bvhLayout(a_layout.m_bvh)
  {}
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  Layout
  layout() const noexcept
  {
    return Layout{m_meshLayout, m_bvhLayout};
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  static inline BVH::ConstructionOptions
  defaultConstructionOptions() noexcept;
 
  EBGEOMETRY_HOST
  inline MeshSDF(const Mesh& a_mesh, Pool& a_pool, const BVH::Construction a_construction);
 
  EBGEOMETRY_HOST
  inline MeshSDF(const Mesh&                     a_mesh,
                 Pool&                           a_pool,
                 const 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 ClosestFace<T>
  getClosestFace(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Root
  getRoot() const noexcept
  {
    return Root(m_bvhLayout, this->location());
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Mesh
  getMesh() const noexcept
  {
    return Mesh(m_meshLayout, this->location());
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline EBGeometry::BoundingVolumes::AABBT<T>
  computeBoundingVolume() const noexcept
  {
    return this->getRoot().getBoundingVolume();
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline MeshSDF
  rebasedView(const Pool& a_pool) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline MeshSDF
  deepCopy(Pool& a_dstPool) const;
 
private:
  [[nodiscard]] EBGEOMETRY_HOST
  static inline Root
  buildBVH(const Mesh&                     a_mesh,
           Pool&                           a_pool,
           const BVH::Construction         a_construction,
           const BVH::ConstructionOptions& a_options);
 
  typename Mesh::Layout m_meshLayout;
 
  typename Root::Layout m_bvhLayout;
};
 
template <class T, size_t K, size_t W>
class TriMeshSDF : public PoolHandle
{
  static_assert(std::is_floating_point_v<T>, "TriMeshSDF<T,K,W> requires a floating-point T");
  static_assert(K >= 2, "TriMeshSDF requires branching factor K >= 2");
  static_assert(W > 0, "TriMeshSDF requires SoA width W > 0");
 
public:
  static constexpr DistanceQuality distanceQuality = DistanceQuality::Exact;
 
  using Mesh = EBGeometry::DCEL::MeshT<T>;
 
  using Tri = typename EBGeometry::Triangle<T>;
 
  using TriAoSoA = TriangleAoSoA<T, W>;
 
  using Root = typename EBGeometry::BVH::PackedBVH<T, TriAoSoA, K>;
 
  TriMeshSDF() = delete;
 
  struct Layout
  {
    typename Root::Layout m_bvh;
  };
 
  EBGEOMETRY_HOST_DEVICE
  TriMeshSDF(const Layout& a_layout, const PoolLocation& a_location) noexcept
    : PoolHandle(a_location), m_bvhLayout(a_layout.m_bvh)
  {}
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  Layout
  layout() const noexcept
  {
    return Layout{m_bvhLayout};
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  static inline BVH::ConstructionOptions
  defaultConstructionOptions(const size_t a_maxLeafGroups) noexcept;
 
  EBGEOMETRY_HOST
  inline TriMeshSDF(const Mesh&             a_mesh,
                    Pool&                   a_pool,
                    const BVH::Construction a_construction,
                    const size_t            a_maxLeafGroups);
 
  EBGEOMETRY_HOST
  inline TriMeshSDF(const std::vector<Tri>& a_triangles,
                    Pool&                   a_pool,
                    const BVH::Construction a_construction,
                    const size_t            a_maxLeafGroups);
 
  EBGEOMETRY_HOST
  inline TriMeshSDF(const Mesh&                     a_mesh,
                    Pool&                           a_pool,
                    const BVH::Construction         a_construction,
                    const BVH::ConstructionOptions& a_options);
 
  EBGEOMETRY_HOST
  inline TriMeshSDF(const std::vector<Tri>&         a_triangles,
                    Pool&                           a_pool,
                    const 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 ClosestFace<T>
  getClosestFace(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Root
  getRoot() const noexcept
  {
    return Root(m_bvhLayout, this->location());
  }
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline EBGeometry::BoundingVolumes::AABBT<T>
  computeBoundingVolume() const noexcept
  {
    return this->getRoot().getBoundingVolume();
  }
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline TriMeshSDF
  rebasedView(const Pool& a_pool) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  inline TriMeshSDF
  deepCopy(Pool& a_dstPool) const;
 
private:
  [[nodiscard]] EBGEOMETRY_HOST
  static inline std::vector<Tri>
  extractTriangles(const Mesh& a_mesh);
 
  [[nodiscard]] EBGEOMETRY_HOST
  static inline Root
  buildBVH(const std::vector<Tri>&         a_triangles,
           Pool&                           a_pool,
           const BVH::Construction         a_construction,
           const BVH::ConstructionOptions& a_options);
 
  [[nodiscard]] EBGEOMETRY_HOST
  static inline Root
  buildClusterSAH(const std::vector<Tri>& a_triangles, Pool& a_pool, const BVH::ClusterSpec& a_spec);
 
  template <class GetTriangle>
  [[nodiscard]] EBGEOMETRY_HOST
  static inline std::vector<TriAoSoA>
  groupTriangles(const GetTriangle& a_getTriangle, uint32_t a_count);
 
  [[nodiscard]] EBGEOMETRY_HOST
  static std::vector<TriAoSoA>
  groupTrianglesIntoSoA(const std::vector<std::shared_ptr<const Tri>>& a_triangles,
                        uint32_t                                       a_offset,
                        uint32_t                                       a_count);
 
  EBGEOMETRY_HOST
  explicit TriMeshSDF(const Root& a_bvh) noexcept : PoolHandle(a_bvh.location()), m_bvhLayout(a_bvh.layout())
  {}
 
  typename Root::Layout m_bvhLayout;
};
 
static_assert(std::is_trivially_copyable_v<MeshSDF<float, 4>>, "MeshSDF<float, 4> must be trivially copyable");
static_assert(std::is_trivially_copyable_v<MeshSDF<double, 4>>, "MeshSDF<double, 4> must be trivially copyable");
static_assert(std::is_trivially_copyable_v<TriMeshSDF<float, 4, 4>>,
              "TriMeshSDF<float, 4, 4> must be trivially copyable");
static_assert(std::is_trivially_copyable_v<TriMeshSDF<double, 4, 4>>,
              "TriMeshSDF<double, 4, 4> must be trivially copyable");
 
} // namespace EBGeometry
 
#include "EBGeometry_MeshDistanceFunctionsImplem.hpp"
 
// Every translation unit that sees TriMeshSDF sees its ray form too, so firstHit() on it is the same
// function everywhere.
#include "EBGeometry_MeshRayForms.hpp"
 
#endif