BinaryNode.h

Go to the documentation of this file.

#ifndef PBAT_GEOMETRY_SDF_BINARYNODE_H
#define PBAT_GEOMETRY_SDF_BINARYNODE_H
 
#include "pbat/HostDevice.h"
#include "pbat/common/Concepts.h"
 
#include <algorithm>
#include <cmath>
 
namespace pbat::geometry::sdf {

struct BinaryNode
{
};

template <common::CArithmetic TScalar>
struct Union : public BinaryNode
{
    using ScalarType = TScalar; 
    PBAT_HOST_DEVICE ScalarType Eval(ScalarType sd1, ScalarType sd2) const
    {
        using namespace std;
        return min(sd1, sd2);
    }
};

template <common::CArithmetic TScalar>
struct Difference : public BinaryNode
{
    using ScalarType = TScalar; 
    PBAT_HOST_DEVICE ScalarType Eval(ScalarType sd1, ScalarType sd2) const
    {
        using namespace std;
        return max(-sd2, sd1);
    }
};

template <common::CArithmetic TScalar>
struct Intersection : public BinaryNode
{
    using ScalarType = TScalar; 
    PBAT_HOST_DEVICE ScalarType Eval(ScalarType sd1, ScalarType sd2) const
    {
        using namespace std;
        return max(sd1, sd2);
    }
};

template <common::CArithmetic TScalar>
struct ExclusiveOr : public BinaryNode
{
    using ScalarType = TScalar; 
    PBAT_HOST_DEVICE ScalarType Eval(ScalarType sd1, ScalarType sd2) const
    {
        using namespace std;
        return max(min(sd1, sd2), -max(sd1, sd2));
    }
};

template <common::CArithmetic TScalar>
struct SmoothUnion : public BinaryNode
{
    using ScalarType = TScalar;  
    ScalarType k{TScalar(0.25)}; 
    SmoothUnion() = default;
    explicit SmoothUnion(ScalarType k_) : k(k_) {}
    PBAT_HOST_DEVICE ScalarType Eval(ScalarType sd1, ScalarType sd2) const
    {
        using namespace std;
        ScalarType kk = 4 * k;
        ScalarType h  = max(kk - abs(sd1 - sd2), ScalarType(0));
        return min(sd1, sd2) - h * h * ScalarType(0.25) / kk;
    }
};

template <common::CArithmetic TScalar>
struct SmoothDifference : public BinaryNode
{
    using ScalarType = TScalar;  
    ScalarType k{TScalar(0.25)}; 
    SmoothDifference() = default;
    explicit SmoothDifference(ScalarType k_) : k(k_) {}
    PBAT_HOST_DEVICE ScalarType Eval(ScalarType sd1, ScalarType sd2) const
    {
        SmoothUnion<TScalar> U{};
        U.k = k;
        return -U.Eval(sd2, -sd1);
    }
};

template <common::CArithmetic TScalar>
struct SmoothIntersection : public BinaryNode
{
    using ScalarType = TScalar;  
    ScalarType k{TScalar(0.25)}; 
    SmoothIntersection() = default;
    explicit SmoothIntersection(ScalarType k_) : k(k_) {}
    PBAT_HOST_DEVICE ScalarType Eval(ScalarType sd1, ScalarType sd2) const
    {
        SmoothUnion<TScalar> U{};
        U.k = k;
        return -U.Eval(-sd1, -sd2);
    }
};
 
} // namespace pbat::geometry::sdf
 
#endif // PBAT_GEOMETRY_SDF_BINARYNODE_H