EBGeometry_Expr.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_EXPR_HPP
#define EBGEOMETRY_EXPR_HPP
 
// Std includes
#include <cstddef>
#include <cstdint>
#include <memory>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <utility>
#include <vector>
 
// Our includes
#include "EBGeometry_Affine.hpp"
#include "EBGeometry_BoundingVolumes.hpp"
#include "EBGeometry_DistanceQuality.hpp"
#include "EBGeometry_Pool.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
enum class BlendKind : uint8_t
{
  Polynomial, 
  Exponential 
};
 
namespace ExprDetail {
 
template <class B>
struct BoxPrecision
{
};
 
template <class T>
struct BoxPrecision<BoundingVolumes::AABBT<T>>
{
  using type = T;
};
 
template <class S, class T, class = void>
struct HasSignedDistance : std::false_type
{
};
 
template <class S, class T>
struct HasSignedDistance<
  S,
  T,
  std::void_t<decltype(std::declval<const S&>().signedDistance(std::declval<const Vec3T<T>&>()))>>
  : std::is_convertible<decltype(std::declval<const S&>().signedDistance(std::declval<const Vec3T<T>&>())), T>
{
};
 
template <class S, class = void>
struct ShapeInfo
{
  static constexpr bool value = false;
};
 
template <class S>
struct ShapeInfo<
  S,
  std::void_t<typename BoxPrecision<std::decay_t<decltype(std::declval<const S&>().computeBoundingVolume())>>::type>>
{
  using precision =
    typename BoxPrecision<std::decay_t<decltype(std::declval<const S&>().computeBoundingVolume())>>::type;
 
  static constexpr bool value = std::is_trivially_copyable_v<S> && HasSignedDistance<S, precision>::value;
};
 
} // namespace ExprDetail
 
template <class S>
inline constexpr bool isShape = ExprDetail::ShapeInfo<S>::value;
 
template <class S>
using ShapePrecision = typename ExprDetail::ShapeInfo<S>::precision;
 
template <class T>
class Expr;
 
namespace ExprDetail {
 
enum class Kind : uint8_t
{
  Primitive,          
  Affine,             
  Elongate,           
  Repeat,             
  Complement,         
  Offset,             
  Annular,            
  Blur,               
  Mollify,            
  Union,              
  Intersection,       
  SmoothUnion,        
  SmoothIntersection, 
};
 
struct Leaf
{
  std::shared_ptr<const void> m_object;
 
  std::type_index m_type = std::type_index(typeid(void));
 
  bool (*m_isAttachedTo)(const void*, const Pool&) = nullptr;
};
 
template <class T>
struct Node
{
  Kind m_kind = Kind::Primitive;
 
  std::vector<Expr<T>> m_children;
 
  Leaf m_leaf;
 
  Affine3T<T> m_map = Affine3T<T>::identity();
 
  Affine3T<T> m_inverse = Affine3T<T>::identity();
 
  T m_valueScale = T(1);
 
  Vec3T<T> m_vec0 = Vec3T<T>::zeros();
 
  Vec3T<T> m_vec1 = Vec3T<T>::zeros();
 
  Vec3T<T> m_vec2 = Vec3T<T>::zeros();
 
  T m_scalar0 = T(0);
 
  T m_scalar1 = T(0);
 
  uint32_t m_count = 0;
 
  BlendKind m_blend = BlendKind::Polynomial;
 
  BoundingVolumes::AABBT<T> m_boundingVolume;
 
  DistanceQuality m_quality = DistanceQuality::Exact;
};
 
template <class A, class = void>
struct ExprLike
{
};
 
template <class T>
struct ExprLike<Expr<T>, void>
{
  using type = T;
};
 
template <class S>
struct ExprLike<S, std::enable_if_t<isShape<S>>>
{
  using type = ShapePrecision<S>;
};
 
} // namespace ExprDetail
 
template <class A>
using ExprPrecision = typename ExprDetail::ExprLike<A>::type;
 
template <class T>
class Expr
{
public:
  static_assert(std::is_floating_point_v<T>, "Expr requires a floating-point type T");
 
  using BV = BoundingVolumes::AABBT<T>;
 
  Expr() = delete;
 
  template <class S,
            class = std::enable_if_t<!std::is_same_v<std::decay_t<S>, Expr> &&
                                     !std::is_convertible_v<S, std::shared_ptr<const ExprDetail::Node<T>>>>>
  EBGEOMETRY_HOST
  Expr(const S& a_shape); // NOLINT(google-explicit-constructor): a shape is an expression
 
  EBGEOMETRY_HOST
  explicit Expr(std::shared_ptr<const ExprDetail::Node<T>> a_node) noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  const BV&
  computeBoundingVolume() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  DistanceQuality
  getDistanceQuality() const noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST
  const ExprDetail::Node<T>&
  node() const noexcept;
 
private:
  std::shared_ptr<const ExprDetail::Node<T>> m_node;
};
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
toExpr(const A& a_operand);
 
template <class A, class B>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Union(const A& a_first, const B& a_second);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Union(const std::vector<A>& a_operands);
 
template <class A, class B>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
SmoothUnion(const A&               a_first,
            const B&               a_second,
            const ExprPrecision<A> a_smooth,
            const BlendKind        a_blend = BlendKind::Polynomial);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
SmoothUnion(const std::vector<A>&  a_operands,
            const ExprPrecision<A> a_smooth,
            const BlendKind        a_blend = BlendKind::Polynomial);
 
template <class A, class B>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Intersection(const A& a_first, const B& a_second);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Intersection(const std::vector<A>& a_operands);
 
template <class A, class B>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
SmoothIntersection(const A&               a_first,
                   const B&               a_second,
                   const ExprPrecision<A> a_smooth,
                   const BlendKind        a_blend = BlendKind::Polynomial);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
SmoothIntersection(const std::vector<A>&  a_operands,
                   const ExprPrecision<A> a_smooth,
                   const BlendKind        a_blend = BlendKind::Polynomial);
 
template <class A, class B>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Difference(const A& a_first, const B& a_second);
 
template <class A, class B>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Difference(const A& a_first, const std::vector<B>& a_others);
 
template <class A, class B>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
SmoothDifference(const A&               a_first,
                 const B&               a_second,
                 const ExprPrecision<A> a_smooth,
                 const BlendKind        a_blend = BlendKind::Polynomial);
 
template <class A, class B>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
SmoothDifference(const A&               a_first,
                 const std::vector<B>&  a_others,
                 const ExprPrecision<A> a_smooth,
                 const BlendKind        a_blend = BlendKind::Polynomial);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
FiniteRepetition(const A&                       a_operand,
                 const Vec3T<ExprPrecision<A>>& a_period,
                 const Vec3T<ExprPrecision<A>>& a_repeatLo,
                 const Vec3T<ExprPrecision<A>>& a_repeatHi);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Complement(const A& a_operand);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Translate(const A& a_operand, const Vec3T<ExprPrecision<A>>& a_shift);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Rotate(const A& a_operand, const ExprPrecision<A> a_degrees, const size_t a_axis);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Rotate(const A& a_operand, const ExprPrecision<A> a_degrees, const Vec3T<ExprPrecision<A>>& a_axis);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Scale(const A& a_operand, const ExprPrecision<A> a_factor);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Reflect(const A& a_operand, const size_t a_axis);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Offset(const A& a_operand, const ExprPrecision<A> a_offset);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Annular(const A& a_operand, const ExprPrecision<A> a_delta);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Elongate(const A& a_operand, const Vec3T<ExprPrecision<A>>& a_elongation);
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Blur(const A& a_operand, const ExprPrecision<A> a_blur, const ExprPrecision<A> a_alpha = ExprPrecision<A>(0.5));
 
template <class A>
[[nodiscard]] EBGEOMETRY_HOST
inline Expr<ExprPrecision<A>>
Mollify(const A& a_operand, const ExprPrecision<A> a_dist, const size_t a_samples);
 
} // namespace EBGeometry
 
#include "EBGeometry_ExprImplem.hpp"
 
#endif