GEO_ImplicitBasicSurfaces.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        GEO_ImplicitBasicSurfaces.h
 *
 * COMMENTS:    C++ implementations of basic implicit surface SDFs.
 */

#pragma once

#ifndef __GEO_ImplicitBasicSurfaces_h__
#define __GEO_ImplicitBasicSurfaces_h__

#include <VEX/VEX_PodTypes.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_Interval.h>

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitBox
//////////////////////////////////////////////////////////////////////////////

template <VEX_Precision PREC>
class GEO_ImplicitBox
{
public:
    VEXvec3<PREC> size = {1, 1, 1};
    bool invert = false;

    GEO_ImplicitBox(const VEXvec3<PREC> &size, bool invert = false)
        : size(size), invert(invert) {}

    VEXfloat<PREC> eval(const VEXvec3<PREC> p, VEXvec3<PREC> *grad, VEXvec3<PREC> *size_grad) const;

    VEXfloat<PREC> operator()(const VEXvec3<PREC> p) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad, VEXvec3<PREC> &size_grad) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const UT_BoundingBoxT<VEXfloat<PREC>> &p) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const;
};

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitRoundedBox
//////////////////////////////////////////////////////////////////////////////

template <VEX_Precision PREC>
class GEO_ImplicitRoundedBox
{
public:
    VEXvec3<PREC> size = {1, 1, 1};
    VEXfloat<PREC> radius = 0.1;
    bool invert = false;

    GEO_ImplicitRoundedBox(const VEXvec3<PREC> &size, VEXfloat<PREC> radius, bool invert = false)
        : size(size), radius(radius), invert(invert) {}

    VEXfloat<PREC> eval(const VEXvec3<PREC> p, VEXvec3<PREC> *grad, VEXvec3<PREC> *size_grad, VEXfloat<PREC> *radius_grad) const;

    VEXfloat<PREC> operator()(const VEXvec3<PREC> p) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad, VEXvec3<PREC> &size_grad, VEXfloat<PREC> &radius_grad) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const UT_BoundingBoxT<VEXfloat<PREC>> &p) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const;
};

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitPlane
//////////////////////////////////////////////////////////////////////////////

template <VEX_Precision PREC>
class GEO_ImplicitPlane
{
public:
    bool invert = false;

    GEO_ImplicitPlane(bool invert = false) : invert(invert) {}

    VEXfloat<PREC> eval(const VEXvec3<PREC> p, VEXvec3<PREC> *grad) const;

    VEXfloat<PREC> operator()(const VEXvec3<PREC> p) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const UT_BoundingBoxT<VEXfloat<PREC>> &p) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const;
};

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitBall
//////////////////////////////////////////////////////////////////////////////

template <VEX_Precision PREC>
class GEO_ImplicitBall
{
public:
    VEXfloat<PREC> radius = 1;
    bool invert = false;

    GEO_ImplicitBall(VEXfloat<PREC> radius, bool invert = false)
        : radius(radius), invert(invert) {}

    VEXfloat<PREC> eval(const VEXvec3<PREC> p, VEXvec3<PREC> *grad, VEXfloat<PREC> *radius_grad) const;

    VEXfloat<PREC> operator()(const VEXvec3<PREC> p) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad, VEXfloat<PREC> &radius_grad) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const UT_BoundingBoxT<VEXfloat<PREC>> &p) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const;
};

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitTorus
//////////////////////////////////////////////////////////////////////////////

template <VEX_Precision PREC>
class GEO_ImplicitTorus
{
public:
    VEXfloat<PREC> ra = 1;      // major radius
    VEXfloat<PREC> rb = 0.25;   // minor radius
    bool invert = false;

    GEO_ImplicitTorus(VEXfloat<PREC> ra, VEXfloat<PREC> rb, bool invert = false)
        : ra(ra), rb(rb), invert(invert) {}

    VEXfloat<PREC> eval(const VEXvec3<PREC> p, VEXvec3<PREC> *grad, VEXfloat<PREC> *ra_grad, VEXfloat<PREC> *rb_grad) const;

    VEXfloat<PREC> operator()(const VEXvec3<PREC> p) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad, VEXfloat<PREC> &ra_grad, VEXfloat<PREC> &rb_grad) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const UT_BoundingBoxT<VEXfloat<PREC>> &p) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const;
};

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitSegment (capsule with uniform radius)
//////////////////////////////////////////////////////////////////////////////

template <VEX_Precision PREC>
class GEO_ImplicitSegment
{
public:
    VEXfloat<PREC> height = 1;
    VEXfloat<PREC> radius = 0.25;
    bool invert = false;

    GEO_ImplicitSegment(VEXfloat<PREC> height, VEXfloat<PREC> radius, bool invert = false)
        : height(height), radius(radius), invert(invert) {}

    VEXfloat<PREC> eval(const VEXvec3<PREC> p, VEXvec3<PREC> *grad, VEXfloat<PREC> *height_grad, VEXfloat<PREC> *radius_grad) const;

    VEXfloat<PREC> operator()(const VEXvec3<PREC> p) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad, VEXfloat<PREC> &height_grad, VEXfloat<PREC> &radius_grad) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const UT_BoundingBoxT<VEXfloat<PREC>> &p) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const;
};

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitEllipsoid (approximate SDF)
//////////////////////////////////////////////////////////////////////////////

template <VEX_Precision PREC>
class GEO_ImplicitEllipsoid
{
public:
    VEXvec3<PREC> radii = {1, 1, 1};
    bool invert = false;

    GEO_ImplicitEllipsoid(const VEXvec3<PREC> &radii, bool invert = false)
        : radii(radii), invert(invert) {}

    VEXfloat<PREC> eval(const VEXvec3<PREC> p, VEXvec3<PREC> *grad, VEXvec3<PREC> *radii_grad) const;

    VEXfloat<PREC> operator()(const VEXvec3<PREC> p) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad, VEXvec3<PREC> &radii_grad) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const UT_BoundingBoxT<VEXfloat<PREC>> &p) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const;
};

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitLink (chain link shape)
//////////////////////////////////////////////////////////////////////////////

template <VEX_Precision PREC>
class GEO_ImplicitLink
{
public:
    VEXfloat<PREC> length = 0.5;  // half-length along y
    VEXfloat<PREC> r1 = 0.5;      // major radius (torus radius)
    VEXfloat<PREC> r2 = 0.1;      // minor radius (tube radius)
    bool invert = false;

    GEO_ImplicitLink(VEXfloat<PREC> r1, VEXfloat<PREC> r2, VEXfloat<PREC> length, bool invert = false)
        : length(length), r1(r1), r2(r2), invert(invert) {}

    VEXfloat<PREC> eval(const VEXvec3<PREC> p, VEXvec3<PREC> *grad,
                        VEXfloat<PREC> *length_grad, VEXfloat<PREC> *r1_grad, VEXfloat<PREC> *r2_grad) const;

    VEXfloat<PREC> operator()(const VEXvec3<PREC> p) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad,
                              VEXfloat<PREC> &length_grad, VEXfloat<PREC> &r1_grad, VEXfloat<PREC> &r2_grad) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const UT_BoundingBoxT<VEXfloat<PREC>> &p) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const;
};

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitCapsule (rounded cone with varying radii)
//////////////////////////////////////////////////////////////////////////////

template <VEX_Precision PREC>
class GEO_ImplicitCapsule
{
public:
    VEXfloat<PREC> height = 1;    // total height, sphere centers at y = ±height/2
    VEXfloat<PREC> r1 = 0.5;      // radius at +y end (sphere b)
    VEXfloat<PREC> r2 = 0.25;     // radius at -y end (sphere a)
    bool invert = false;

    GEO_ImplicitCapsule(VEXfloat<PREC> height, VEXfloat<PREC> r1, VEXfloat<PREC> r2, bool invert = false)
        : height(height), r1(r1), r2(r2), invert(invert) {}

    VEXfloat<PREC> eval(const VEXvec3<PREC> p, VEXvec3<PREC> *grad,
                        VEXfloat<PREC> *height_grad, VEXfloat<PREC> *r1_grad, VEXfloat<PREC> *r2_grad) const;

    VEXfloat<PREC> operator()(const VEXvec3<PREC> p) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad,
                              VEXfloat<PREC> &height_grad, VEXfloat<PREC> &r1_grad, VEXfloat<PREC> &r2_grad) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const UT_BoundingBoxT<VEXfloat<PREC>> &p) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const;
};

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitCylinder
//////////////////////////////////////////////////////////////////////////////

template <VEX_Precision PREC>
class GEO_ImplicitCylinder
{
public:
    VEXfloat<PREC> height = 1;
    VEXfloat<PREC> radius = 0.5;
    bool invert = false;

    GEO_ImplicitCylinder(VEXfloat<PREC> height, VEXfloat<PREC> radius, bool invert = false)
        : height(height), radius(radius), invert(invert) {}

    VEXfloat<PREC> eval(const VEXvec3<PREC> p, VEXvec3<PREC> *grad, VEXfloat<PREC> *height_grad, VEXfloat<PREC> *radius_grad) const;

    VEXfloat<PREC> operator()(const VEXvec3<PREC> p) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad, VEXfloat<PREC> &height_grad, VEXfloat<PREC> &radius_grad) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const UT_BoundingBoxT<VEXfloat<PREC>> &p) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const;
};

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitCappedCone (cone with independent top/bottom radii)
//////////////////////////////////////////////////////////////////////////////

template <VEX_Precision PREC>
class GEO_ImplicitCappedCone
{
public:
    VEXfloat<PREC> height = 1;    // total height, endpoints at y = ±height/2
    VEXfloat<PREC> r1 = 0.5;      // radius at +y end (top)
    VEXfloat<PREC> r2 = 0.25;     // radius at -y end (bottom)
    bool invert = false;

    GEO_ImplicitCappedCone(VEXfloat<PREC> height, VEXfloat<PREC> r1, VEXfloat<PREC> r2, bool invert = false)
        : height(height), r1(r1), r2(r2), invert(invert) {}

    VEXfloat<PREC> eval(const VEXvec3<PREC> p, VEXvec3<PREC> *grad,
                        VEXfloat<PREC> *height_grad, VEXfloat<PREC> *r1_grad, VEXfloat<PREC> *r2_grad) const;

    VEXfloat<PREC> operator()(const VEXvec3<PREC> p) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad) const;
    VEXfloat<PREC> operator()(const VEXvec3<PREC> p, VEXvec3<PREC> &grad,
                              VEXfloat<PREC> &height_grad, VEXfloat<PREC> &r1_grad, VEXfloat<PREC> &r2_grad) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const UT_BoundingBoxT<VEXfloat<PREC>> &p) const;
    UT_IntervalT<VEXfloat<PREC>> operator()(const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const;
};

#endif // __GEO_ImplicitBasicSurfaces_h__