EBGeometry_TriangleSoA.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2024 Robert Marskar <robert.marskar@sintef.no>
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef EBGEOMETRY_TRIANGLESOA_HPP
#define EBGEOMETRY_TRIANGLESOA_HPP
 
// Std includes
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
// Our includes
#include "EBGeometry_Array.hpp"
#include "EBGeometry_SIMD.hpp"
#include "EBGeometry_Triangle.hpp"
#include "EBGeometry_TriangleDistance.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
namespace TriangleSoA {
 
template <typename T>
[[nodiscard]] constexpr size_t
HostWidth() noexcept
{
  static_assert(std::is_floating_point_v<T>, "EBGeometry::TriangleSoA::HostWidth requires a floating-point T");
#if defined(__AVX512F__)
  if constexpr (std::is_same_v<T, double>) {
    return 8;
  }
  else {
    return 16;
  }
#elif defined(__AVX__)
  if constexpr (std::is_same_v<T, double>) {
    return 4;
  }
  else {
    return 8;
  }
#else
  return 4;
#endif
}
 
template <typename T>
[[nodiscard]] constexpr size_t
DefaultWidth() noexcept
{
  static_assert(std::is_floating_point_v<T>, "EBGeometry::TriangleSoA::DefaultWidth requires a floating-point T");
 
#if defined(EBGEOMETRY_HOST_TUNED_DEFAULTS)
  return HostWidth<T>();
#else
  return 4;
#endif
}
 
} // namespace TriangleSoA
 
template <class T, size_t W>
struct TriangleSoAT
{
  static_assert(W > 0, "W must be positive");
  static_assert(std::is_floating_point_v<T>, "TriangleSoAT requires a floating-point type T");
 
public:
  EBGEOMETRY_HOST
  void
  pack(const Triangle<T>* tris, uint32_t count) noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T
  signedDistance(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  Array<T, W>
  signedDistances(const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  uint32_t
  nearestLane(const Vec3T<T>& a_point, T& a_d2) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T
  signedDistanceAt(uint32_t a_lane, const Vec3T<T>& a_point) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T
  rayCrossing(
    const Vec3T<T>& a_origin, const Vec3T<T>& a_direction, T a_tMin, T a_tMax, uint32_t& a_lane) const noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  void
  rayCrossings(
    const Vec3T<T>& a_origin, const Vec3T<T>& a_direction, T a_tMin, T a_tMax, T* a_crossings) const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  Vec3T<T>
  getNormal(uint32_t a_lane) const noexcept;
 
  template <class BV>
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  BV
  computeBoundingVolume() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Vec3T<T>
  getVertex(size_t a_lane, size_t a_vertex) const noexcept
  {
    return Vec3T<T>(m_vx[a_vertex][a_lane], m_vy[a_vertex][a_lane], m_vz[a_vertex][a_lane]);
  }
 
protected:
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  T
  signedDistanceLane(uint32_t a_lane, const Vec3T<T>& a_point) const noexcept;
 
  template <class V>
  struct LaneSource
  {
    const TriangleSoAT* m_group;
 
    size_t m_offset;
 
    [[nodiscard]] EBGEOMETRY_HOST_DEVICE
    V
    fetch(const T* a_lanes) const noexcept
    {
      if constexpr (std::is_same_v<V, T>) {
        return a_lanes[m_offset];
      }
      else {
        return V::load(a_lanes + m_offset);
      }
    }
 
    [[nodiscard]] EBGEOMETRY_HOST_DEVICE
    TriangleDistance::Vec3V<V>
    vertex(const size_t a_k) const noexcept
    {
      return {fetch(m_group->m_vx[a_k]), fetch(m_group->m_vy[a_k]), fetch(m_group->m_vz[a_k])};
    }
 
    [[nodiscard]] EBGEOMETRY_HOST_DEVICE
    TriangleDistance::Vec3V<V>
    normal() const noexcept
    {
      return {fetch(m_group->m_nx), fetch(m_group->m_ny), fetch(m_group->m_nz)};
    }
 
    [[nodiscard]] EBGEOMETRY_HOST_DEVICE
    TriangleDistance::Vec3V<V>
    vertexNormal(const size_t a_k) const noexcept
    {
      return {fetch(m_group->m_vnx[a_k]), fetch(m_group->m_vny[a_k]), fetch(m_group->m_vnz[a_k])};
    }
 
    [[nodiscard]] EBGEOMETRY_HOST_DEVICE
    TriangleDistance::Vec3V<V>
    edgeNormal(const size_t a_k) const noexcept
    {
      return {fetch(m_group->m_enx[a_k]), fetch(m_group->m_eny[a_k]), fetch(m_group->m_enz[a_k])};
    }
  };
 
  template <size_t N>
  EBGEOMETRY_HOST
  void
  signedDistancesSIMD(const Vec3T<T>& a_point, T* a_distances) const noexcept;
 
  template <size_t N>
  EBGEOMETRY_HOST
  void
  unsignedDistances2SIMD(const Vec3T<T>& a_point, T* a_d2) const noexcept;
 
  template <size_t N>
  EBGEOMETRY_HOST
  void
  rayCrossingsSIMD(
    const Vec3T<T>& a_origin, const Vec3T<T>& a_direction, T a_tMin, T a_tMax, T* a_crossings) const noexcept;
 
  alignas(W * sizeof(T)) T m_vx[3][W];
 
  T m_vy[3][W];
 
  T m_vz[3][W];
 
  alignas(W * sizeof(T)) T m_nx[W];
 
  T m_ny[W];
 
  T m_nz[W];
 
  alignas(W * sizeof(T)) T m_vnx[3][W];
 
  T m_vny[3][W];
 
  T m_vnz[3][W];
 
  alignas(W * sizeof(T)) T m_enx[3][W];
 
  T m_eny[3][W];
 
  T m_enz[3][W];
 
  uint32_t m_validCount = 0;
};
 
static_assert(std::is_trivially_copyable_v<TriangleSoAT<float, 4>>, "TriangleSoAT<float> must be trivially copyable");
static_assert(std::is_trivially_copyable_v<TriangleSoAT<double, 4>>, "TriangleSoAT<double> must be trivially copyable");
 
} // namespace EBGeometry
 
#include "EBGeometry_TriangleSoAImplem.hpp"
 
#endif