GEO_ImplicitSurfaceOp.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_ImplicitSurfaceOp.h
 *
 * COMMENTS:    SDF boolean and blending operations for implicit surfaces.
 */

#pragma once

#ifndef __GEO_ImplicitSurfaceOp_h__
#define __GEO_ImplicitSurfaceOp_h__

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

/// Optimization flags returned by interval operations
/// Indicates when one operand dominates and the other can be skipped
enum class GEO_ImplicitSurfaceOptFlag : int
{
    None = 0,
    JustReturnA = 1,     // Result is always A
    JustReturnB = 2,     // Result is always B
    JustReturnNegA = 3,  // Result is always -A
    JustReturnNegB = 4   // Result is always -B
};

/// Operation ID enumeration matching VEX implicit_shapes_op.h
enum class GEO_ImplicitSurfaceOpID : int
{
    Invalid = 0,
    Begin = 1,          // Push current SDF onto stack, start new shape

    // Unary operations
    Invert = 2,
    Offset = 3,         // parms.x = offset value
    Shell = 4,          // parms.x = offset, parms.y = thickness

    // Binary operations (basic)
    Union = 5,
    Intersect = 6,
    Subtract = 7,
    Difference = 8,

    // Smooth binary operations (parms.x = k)
    SmoothUnion = 9,
    SmoothIntersect = 10,
    SmoothSubtract = 11,
    SmoothDifference = 12,

    // Round binary operations (parms.x = radius)
    RoundUnion = 13,
    RoundIntersect = 14,
    RoundSubtract = 15,
    RoundDifference = 16,

    // Chamfer binary operations (parms.x = size)
    ChamferUnion = 17,
    ChamferIntersect = 18,
    ChamferSubtract = 19,
    ChamferDifference = 20,

    // Smooth repulsive union (parms.x = k, parms.y = repulsion)
    SmoothRepulsiveUnion = 21
};

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitSurfaceOp - Operation wrapper struct
//////////////////////////////////////////////////////////////////////////////

template <VEX_Precision PREC>
struct GEO_ImplicitSurfaceOp
{
    GEO_ImplicitSurfaceOpID myId = GEO_ImplicitSurfaceOpID::Invalid;
    UT_Vector4T<VEXfloat<PREC>> myParms = {0, 0, 0, 0};

    GEO_ImplicitSurfaceOp() = default;
    GEO_ImplicitSurfaceOp(GEO_ImplicitSurfaceOpID op_id,
                   const UT_Vector4T<VEXfloat<PREC>> &op_parms = {0, 0, 0, 0})
        : myId(op_id), myParms(op_parms) {}

    GEO_ImplicitSurfaceOp(const char *name,
                          const VEXmat3<PREC> &transform,
                          const VEXvec4<PREC> &op_parms = {0, 0, 0, 0})
        : myId(opNameToID(name)), myParms(op_parms)
    {
        VEXmat3<PREC> stretch;
        auto trans = transform;
        if (trans.polarDecompose(&stretch))
        {
            myParms *= stretch.trace() / 3.0f; 
        }
    }

    bool isUnary() const { return int(myId) >= 2 && int(myId) <= 4; }
    bool isBinary() const { return int(myId) >= 5; }

    // ========================================
    // Uniform scale
    // ========================================

    /// Scale distance-valued operation parameters by uniform factor.
    /// Operations without distance parameters (Union, Intersect, etc.) are unchanged.
    void scale(VEXfloat<PREC> s)
    {
        switch (myId)
        {
            // No distance parameters
            case GEO_ImplicitSurfaceOpID::Invalid:
            case GEO_ImplicitSurfaceOpID::Begin:
            case GEO_ImplicitSurfaceOpID::Invert:
            case GEO_ImplicitSurfaceOpID::Union:
            case GEO_ImplicitSurfaceOpID::Intersect:
            case GEO_ImplicitSurfaceOpID::Subtract:
            case GEO_ImplicitSurfaceOpID::Difference:
                break;
            // Offset: parms.x = offset distance
            // Shell: parms.x = offset, parms.y = thickness
            // Smooth/Round/Chamfer: parms.x = k/radius/size
            // SmoothRepulsiveUnion: parms.x = k, parms.y = repulsion
            default:
                myParms *= s;
                break;
        }
    }

    // ========================================
    // Operation ID utilities
    // ========================================

    /// Convert operation name string to ID
    static GEO_ImplicitSurfaceOpID opNameToID(const char *name);

    /// Convert operation ID to name string
    static const char *opIDToName(GEO_ImplicitSurfaceOpID op_id);

    // ========================================
    // Evaluation methods
    // ========================================

    /// Evaluate unary operation
    VEXfloat<PREC> evalUnary(VEXfloat<PREC> a) const;
    VEXfloat<PREC> evalUnary(VEXfloat<PREC> a,
                              UT_Vector4T<VEXfloat<PREC>> &op_dparms,
                              VEXfloat<PREC> &da) const;
    void evalUnaryBatched(int npts, VEXfloat<PREC> *a) const;
    void evalUnaryBatched(int npts, VEXfloat<PREC> *a,
                           UT_Vector4T<VEXfloat<PREC>> *op_dparms,
                           VEXfloat<PREC> *da) const;
    UT_IntervalT<VEXfloat<PREC>> evalUnary(
        const UT_IntervalT<VEXfloat<PREC>> &a) const;

    /// Evaluate binary operation
    VEXfloat<PREC> evalBinary(VEXfloat<PREC> a, VEXfloat<PREC> b,
                               int a_id, int b_id, int &out_id) const;
    VEXfloat<PREC> evalBinary(VEXfloat<PREC> a, VEXfloat<PREC> b,
                               int a_id, int b_id, int &out_id,
                               UT_Vector4T<VEXfloat<PREC>> &op_dparms,
                               VEXfloat<PREC> &da, VEXfloat<PREC> &db) const;
    void evalBinaryBatched(int npts,
                           const VEXfloat<PREC> *a,
                           const VEXfloat<PREC> *b,
                           const int *a_id,
                           const int *b_id,
                           int *out_id,
                           VEXfloat<PREC> *result) const;
    void evalBinaryBatched(int npts,
                           const VEXfloat<PREC> *a,
                           const VEXfloat<PREC> *b,
                           const int *a_id,
                           const int *b_id,
                           int *out_id,
                           UT_Vector4T<VEXfloat<PREC>> *op_dparms,
                           VEXfloat<PREC> *da,
                           VEXfloat<PREC> *db,
                           VEXfloat<PREC> *result) const;
    UT_IntervalT<VEXfloat<PREC>> evalBinary(
        const UT_IntervalT<VEXfloat<PREC>> &a,
        const UT_IntervalT<VEXfloat<PREC>> &b) const;
    UT_IntervalT<VEXfloat<PREC>> evalBinary(
        const UT_IntervalT<VEXfloat<PREC>> &a,
        const UT_IntervalT<VEXfloat<PREC>> &b,
        GEO_ImplicitSurfaceOptFlag &can_optimize) const;

    // ========================================
    // Factory methods
    // ========================================

    // Unary operations
    static GEO_ImplicitSurfaceOp makeInvert();
    static GEO_ImplicitSurfaceOp makeOffset(VEXfloat<PREC> offset);
    static GEO_ImplicitSurfaceOp makeShell(VEXfloat<PREC> offset, VEXfloat<PREC> thickness);

    // Binary operations (basic)
    static GEO_ImplicitSurfaceOp makeUnion();
    static GEO_ImplicitSurfaceOp makeIntersect();
    static GEO_ImplicitSurfaceOp makeSubtract();
    static GEO_ImplicitSurfaceOp makeDifference();

    // Smooth binary operations
    static GEO_ImplicitSurfaceOp makeSmoothUnion(VEXfloat<PREC> k);
    static GEO_ImplicitSurfaceOp makeSmoothIntersect(VEXfloat<PREC> k);
    static GEO_ImplicitSurfaceOp makeSmoothSubtract(VEXfloat<PREC> k);
    static GEO_ImplicitSurfaceOp makeSmoothDifference(VEXfloat<PREC> k);
    static GEO_ImplicitSurfaceOp makeSmoothRepulsiveUnion(VEXfloat<PREC> k, VEXfloat<PREC> repulsion);

    // Round binary operations
    static GEO_ImplicitSurfaceOp makeRoundUnion(VEXfloat<PREC> r);
    static GEO_ImplicitSurfaceOp makeRoundIntersect(VEXfloat<PREC> r);
    static GEO_ImplicitSurfaceOp makeRoundSubtract(VEXfloat<PREC> r);
    static GEO_ImplicitSurfaceOp makeRoundDifference(VEXfloat<PREC> r);

    // Chamfer binary operations
    static GEO_ImplicitSurfaceOp makeChamferUnion(VEXfloat<PREC> r);
    static GEO_ImplicitSurfaceOp makeChamferIntersect(VEXfloat<PREC> r);
    static GEO_ImplicitSurfaceOp makeChamferSubtract(VEXfloat<PREC> r);
    static GEO_ImplicitSurfaceOp makeChamferDifference(VEXfloat<PREC> r);
};

//////////////////////////////////////////////////////////////////////////////
// Namespace for SDF operation functions
//////////////////////////////////////////////////////////////////////////////

namespace GEO_ImplicitSurfaceOps {

// ============================================
// Unary Operations
// ============================================

/// Invert: r = -a
template <typename T>
T opInvert(T a);

template <typename T>
T opInvert(T a, T &da);

template <typename T>
UT_IntervalT<T> opInvert(const UT_IntervalT<T> &a);

/// Offset: r = a - offset
template <typename T>
T opOffset(T offset, T a);

template <typename T>
T opOffset(T offset, T a, T &doffset, T &da);

template <typename T>
UT_IntervalT<T> opOffset(T offset, const UT_IntervalT<T> &a);

/// Shell: r = abs(a - offset) - thickness
template <typename T>
T opShell(T offset, T thickness, T a);

template <typename T>
T opShell(T offset, T thickness, T a, T &doffset, T &dthickness, T &da);

template <typename T>
UT_IntervalT<T> opShell(T offset, T thickness, const UT_IntervalT<T> &a);

// ============================================
// Binary Operations (Basic)
// ============================================

/// Union: r = min(a, b)
template <typename T>
T opUnion(T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opUnion(T a, T b, int a_id, int b_id, int &id, T &da, T &db);

template <typename T>
UT_IntervalT<T> opUnion(const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opUnion(const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                         GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Intersect: r = max(a, b)
template <typename T>
T opIntersect(T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opIntersect(T a, T b, int a_id, int b_id, int &id, T &da, T &db);

template <typename T>
UT_IntervalT<T> opIntersect(const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opIntersect(const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                             GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Subtract: r = max(a, -b)
template <typename T>
T opSubtract(T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opSubtract(T a, T b, int a_id, int b_id, int &id, T &da, T &db);

template <typename T>
UT_IntervalT<T> opSubtract(const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opSubtract(const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                            GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Difference: r = max(min(a,b), -max(a,b))
template <typename T>
T opDifference(T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opDifference(T a, T b, int a_id, int b_id, int &id, T &da, T &db);

template <typename T>
UT_IntervalT<T> opDifference(const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opDifference(const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                              GEO_ImplicitSurfaceOptFlag &can_optimize);

// ============================================
// Smooth Binary Operations
// ============================================

/// Smooth union: polynomial smooth min
template <typename T>
T opSmoothUnion(T k, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opSmoothUnion(T k, T a, T b, int a_id, int b_id, int &id, T &dk, T &da, T &db);

template <typename T>
UT_IntervalT<T> opSmoothUnion(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opSmoothUnion(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                               GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Smooth repulsive union
template <typename T>
T opSmoothRepulsiveUnion(T k, T repulsion, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opSmoothRepulsiveUnion(T k, T repulsion, T a, T b, int a_id, int b_id, int &id,
                         T &dk, T &drepulsion, T &da, T &db);

template <typename T>
UT_IntervalT<T> opSmoothRepulsiveUnion(T k, T repulsion,
                                        const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opSmoothRepulsiveUnion(T k, T repulsion,
                                        const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                                        GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Smooth intersect: -smooth_union(-a, -b)
template <typename T>
T opSmoothIntersect(T k, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opSmoothIntersect(T k, T a, T b, int a_id, int b_id, int &id, T &dk, T &da, T &db);

template <typename T>
UT_IntervalT<T> opSmoothIntersect(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opSmoothIntersect(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                                   GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Smooth subtract: smooth_intersect(a, -b)
template <typename T>
T opSmoothSubtract(T k, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opSmoothSubtract(T k, T a, T b, int a_id, int b_id, int &id, T &dk, T &da, T &db);

template <typename T>
UT_IntervalT<T> opSmoothSubtract(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opSmoothSubtract(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                                  GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Smooth difference
template <typename T>
T opSmoothDifference(T k, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opSmoothDifference(T k, T a, T b, int a_id, int b_id, int &id, T &dk, T &da, T &db);

template <typename T>
UT_IntervalT<T> opSmoothDifference(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opSmoothDifference(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                                    GEO_ImplicitSurfaceOptFlag &can_optimize);

// ============================================
// Round Binary Operations
// ============================================

/// Round union
template <typename T>
T opRoundUnion(T k, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opRoundUnion(T k, T a, T b, int a_id, int b_id, int &id, T &dk, T &da, T &db);

template <typename T>
UT_IntervalT<T> opRoundUnion(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opRoundUnion(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                              GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Round intersect
template <typename T>
T opRoundIntersect(T k, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opRoundIntersect(T k, T a, T b, int a_id, int b_id, int &id, T &dk, T &da, T &db);

template <typename T>
UT_IntervalT<T> opRoundIntersect(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opRoundIntersect(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                                  GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Round subtract
template <typename T>
T opRoundSubtract(T k, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opRoundSubtract(T k, T a, T b, int a_id, int b_id, int &id, T &dk, T &da, T &db);

template <typename T>
UT_IntervalT<T> opRoundSubtract(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opRoundSubtract(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                                 GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Round difference
template <typename T>
T opRoundDifference(T k, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opRoundDifference(T k, T a, T b, int a_id, int b_id, int &id, T &dk, T &da, T &db);

template <typename T>
UT_IntervalT<T> opRoundDifference(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opRoundDifference(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                                   GEO_ImplicitSurfaceOptFlag &can_optimize);

// ============================================
// Chamfer Binary Operations
// ============================================

/// Chamfer union
template <typename T>
T opChamferUnion(T k, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opChamferUnion(T k, T a, T b, int a_id, int b_id, int &id, T &dk, T &da, T &db);

template <typename T>
UT_IntervalT<T> opChamferUnion(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opChamferUnion(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                                GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Chamfer intersect
template <typename T>
T opChamferIntersect(T k, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opChamferIntersect(T k, T a, T b, int a_id, int b_id, int &id, T &dk, T &da, T &db);

template <typename T>
UT_IntervalT<T> opChamferIntersect(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opChamferIntersect(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                                    GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Chamfer subtract
template <typename T>
T opChamferSubtract(T k, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opChamferSubtract(T k, T a, T b, int a_id, int b_id, int &id, T &dk, T &da, T &db);

template <typename T>
UT_IntervalT<T> opChamferSubtract(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opChamferSubtract(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                                   GEO_ImplicitSurfaceOptFlag &can_optimize);

/// Chamfer difference
template <typename T>
T opChamferDifference(T k, T a, T b, int a_id, int b_id, int &id);

template <typename T>
T opChamferDifference(T k, T a, T b, int a_id, int b_id, int &id, T &dk, T &da, T &db);

template <typename T>
UT_IntervalT<T> opChamferDifference(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b);

template <typename T>
UT_IntervalT<T> opChamferDifference(T k, const UT_IntervalT<T> &a, const UT_IntervalT<T> &b,
                                     GEO_ImplicitSurfaceOptFlag &can_optimize);

} // namespace GEO_ImplicitSurfaceOps

#endif // __GEO_ImplicitSurfaceOp_h__