GEO_ImplicitBasicSurface.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_ImplicitBasicSurface.h
 *
 * COMMENTS:    Base class/wrapper for implicit surface shapes with transform.
 */

#pragma once


#ifndef __GEO_ImplicitBasicSurface_h__
#define __GEO_ImplicitBasicSurface_h__

#include <UT/UT_BoundingBox.h>
#include <UT/UT_Interval.h>
#include <UT/UT_Matrix3.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_Quaternion.h>
#include <UT/UT_String.h>
#include <UT/UT_Vector4.h>
#include <VEX/VEX_PodTypes.h>

/// Shape ID enumeration matching VEX implicit_shapes_shape.h
enum class GEO_ImplicitShapeID : int
{
    Empty = 0,
    End = 1,        // Marks end of a group for binary operations
    Box = 2,
    Plane = 3,
    Ball = 4,
    RoundedBox = 5,
    Torus = 6,
    Segment = 7,
    Ellipsoid = 8,
    Link = 9,
    Capsule = 10,
    Cylinder = 11,
    CappedCone = 12
};


/// Maximum SDF value for empty/invalid shapes
constexpr float GEO_SDF_MAX = 1e30f;

//////////////////////////////////////////////////////////////////////////////
// GEO_ImplicitBasicSurface
//////////////////////////////////////////////////////////////////////////////

/// Basic Implicit Surface - unified wrapper for elementary implicit surfaces.
/// This class stores transform (position, orientation) and shape parameters,
/// dispatching to the appropriate SDF based on shape ID.
///
/// Typically initialized from geometry point attributes:
///   `P`, `orient`, `shape_parms`, `shape_id`, `shape_invert`
template <VEX_Precision PREC>
class GEO_ImplicitBasicSurface
{
public:
    /// Position of the shape in world space
    VEXvec3<PREC> myPos = {0, 0, 0};
    /// Rotation matrix from reference frame to world space
    /// It is assumed that this matrix is rotation!
    VEXmat3<PREC> myTransform = {1,0,0, 0,1,0, 0,0,1};
    /// Parameters describing the shape.
    UT_Vector4T<VEXfloat<PREC>> myParms = {1, 1, 1, 0};
    GEO_ImplicitShapeID myId = GEO_ImplicitShapeID::Empty;

    GEO_ImplicitBasicSurface() = default;

    /// Make basic shape fron its name, position, transform and parameters
    ///
    /// The transform does not have to be rotation matrix. Scales are extracted and applied to parameters
    /// Any shearing or non-uniform scaling is ignored
    GEO_ImplicitBasicSurface(const char * name,
                             const VEXvec3<PREC> &P,
                             const VEXmat3<PREC> &transform,
                             const VEXvec4<PREC> &shapevals);

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

    /// Evaluate SDF at point P (world space)
    VEXfloat<PREC> eval(const VEXvec3<PREC> &P) const;

    /// Evaluate SDF with spatial gradient
    VEXfloat<PREC> eval(const VEXvec3<PREC> &P, VEXvec3<PREC> &grad) const;

    /// Evaluate SDF with spatial and parameter gradients
    VEXfloat<PREC> eval(const VEXvec3<PREC> &P, VEXvec3<PREC> &grad,
                        UT_Vector4T<VEXfloat<PREC>> &parms_grad) const;

    /// Batched evaluation helper with compile-time output control.
    template <bool WantGrad, bool WantParmGrad>
    void evalBatched(int npts, const VEXvec3<PREC> *P, VEXfloat<PREC> *sdf,
                     VEXvec3<PREC> *grad, UT_Vector4T<VEXfloat<PREC>> *parms_grad) const;

    /// Evaluate SDF bounds for interval box (world space)
    UT_IntervalT<VEXfloat<PREC>> evalInterval(
        const UT_BoundingBoxT<VEXfloat<PREC>> &P) const;

    /// Evaluate SDF bounds for bounding sphere (world space).
    /// Cheaper than evalInterval when P comes from a rotated region, since
    /// transforming a sphere to local space only rotates the center.
    UT_IntervalT<VEXfloat<PREC>> evalInterval(
        const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const;

    /// Operator() overloads
    VEXfloat<PREC> operator()(const VEXvec3<PREC> &P) const
    {
        return eval(P);
    }
    VEXfloat<PREC> operator()(const VEXvec3<PREC> &P, VEXvec3<PREC> &grad) const
    {
        return eval(P, grad);
    }
    VEXfloat<PREC> operator()(const VEXvec3<PREC> &P, VEXvec3<PREC> &grad,
                              UT_Vector4T<VEXfloat<PREC>> &parms_grad) const
    {
        return eval(P, grad, parms_grad);
    }
    UT_IntervalT<VEXfloat<PREC>> operator()(
        const UT_BoundingBoxT<VEXfloat<PREC>> &P) const
    {
        return evalInterval(P);
    }
    UT_IntervalT<VEXfloat<PREC>> operator()(
        const VEXvec3<PREC> &center, VEXfloat<PREC> radius) const
    {
        return evalInterval(center, radius);
    }

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

    /// Scale all distance-valued parameters by uniform factor.
    void scale(VEXfloat<PREC> s)
    {
        // all parameters are distance based right now 
        myParms *= s;        
    }

    // ========================================
    // Shape ID utilities
    // ========================================

    /// Convert shape name string to ID
    static GEO_ImplicitShapeID shapeNameToID(const char *name);

    /// Convert shape ID to name string
    static const char *shapeIDToName(GEO_ImplicitShapeID id);

    /// Transform world point to local reference frame
    VEXvec3<PREC> worldToLocal(const VEXvec3<PREC> &P) const;

    /// Transform point from reference frame to world space
    VEXvec3<PREC> localToWorld(const VEXvec3<PREC> &P) const;

    /// Transform local gradient to world space
    VEXvec3<PREC> worldToLocalVec(const VEXvec3<PREC> &vec) const;

    /// Transform local gradient to world space
    VEXvec3<PREC> localToWorldVec(const VEXvec3<PREC> &vec) const;

    /// Transform world interval box to local reference frame
    UT_BoundingBoxT<VEXfloat<PREC>> worldToLocalInterval(
        const UT_BoundingBoxT<VEXfloat<PREC>> &P) const;
};

#endif // __GEO_ImplicitBasicSurface_h__