SOP/SOP_Edit.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.
 *
 * Produced by:
 *      Side Effects Software Inc.
 *      477 Richmond Street West
 *      Toronto, Ontario,  M5V 3E7
 *      Canada
 *      416-504-9876
 *
 * NAME:        SOP Library (C++)
 *
 * COMMENTS: The Edit SOP, which works in conjunction with the
 *           Edit State and the GDT classes.
 *
 */

#ifndef __SOP_Edit_h__
#define __SOP_Edit_h__

#include "SOP_API.h"

#include "SOP_BrushBase.h"

#include <GDT/GDT_MirrorTransform.h>
#include <UT/UT_PointTree.h>

class PRM_MenuEntry;

enum {
    // Group parameters
    SOP_EDIT_GRP_IDX, // = SOP_GDT_GRP_IDX,
    SOP_EDIT_GRPTYPE_IDX,

    SOP_EDIT_MODESWITCHER_IDX,
#define SOP_EDIT_NUM_EDIT_PARMS                 (7)
#define SOP_EDIT_NUM_SCULPT_PARMS               (1)

    // Main Transform/Peak Switcher
    SOP_EDIT_SWITCHER_IDX,
    
    // Transform parameters
#define SOP_EDIT_NUM_TRANSFORM_PARMS            (8)
    SOP_EDIT_TRS_IDX,
    SOP_EDIT_XYZ_IDX,
    SOP_EDIT_T_IDX,
    SOP_EDIT_R_IDX,
    SOP_EDIT_S_IDX,
    SOP_EDIT_SHEAR_IDX,
    SOP_EDIT_P_IDX,
    SOP_EDIT_KEEP_IDX,
    
    // Peak Parameters
#define SOP_EDIT_NUM_PEAK_PARMS                 (2)
    SOP_EDIT_DIST_IDX,
    SOP_EDIT_LEADNML_IDX,

    // Commit Button
    SOP_EDIT_APPLYBUTTON_IDX,

    // Soft Parameters
    SOP_EDIT_SOFTRADIUS_IDX,
    SOP_EDIT_SOFTTYPE_IDX,
    SOP_EDIT_TANGENT_IDX,
    SOP_EDIT_KERNEL_IDX,
    SOP_EDIT_GLOBAL_IDX,

// SCULPT parameters

    // Group parameters
    SOP_EDIT_SCULPT_SWITCHER_IDX,

#define SOP_EDIT_SCULPT_NUM_DEFORM_PARMS        (8)
    SOP_EDIT_SCULPT_OP_IDX,
    SOP_EDIT_SCULPT_AXIS_IDX,
    SOP_EDIT_SCULPT_USER_IDX,
    SOP_EDIT_SCULPT_STENCILACCUM_IDX,
    SOP_EDIT_SCULPT_STENCILAPPLY_IDX,
    SOP_EDIT_SCULPT_RESETNORMALS_IDX,
    SOP_EDIT_SCULPT_FLOODAPPLY_IDX,
    SOP_EDIT_SCULPT_COLOR_SWITCHER_IDX,
    SOP_EDIT_SCULPT_FG_IDX,
    SOP_EDIT_SCULPT_BG_IDX,

#define SOP_EDIT_SCULPT_NUM_NIB_PARMS           (18)
    SOP_EDIT_SCULPT_SHAPE_IDX,
    SOP_EDIT_SCULPT_BITMAP_IDX,
    SOP_EDIT_SCULPT_BITMAPCHAN_IDX,
    SOP_EDIT_SCULPT_RAD_IDX,
    SOP_EDIT_SCULPT_UVRAD_IDX,
    SOP_EDIT_SCULPT_RADPRESSURE_IDX,
    SOP_EDIT_SCULPT_USEDEPTH_IDX,
    SOP_EDIT_SCULPT_DEPTH_IDX,
    SOP_EDIT_SCULPT_ANGLE_IDX,
    SOP_EDIT_SCULPT_SQUASH_IDX,
    SOP_EDIT_SCULPT_OPAC_IDX,
    SOP_EDIT_SCULPT_OPACPRESSURE_IDX,
    SOP_EDIT_SCULPT_SPLATTER_IDX,
    SOP_EDIT_SCULPT_PAPER_IDX,
    SOP_EDIT_SCULPT_SOFTEDGE_IDX,
    SOP_EDIT_SCULPT_KERNEL_IDX,
    SOP_EDIT_SCULPT_UPTYPE_IDX,
    SOP_EDIT_SCULPT_UPVECTOR_IDX,

#define SOP_EDIT_SCULPT_NUM_RAY_PARMS           (10)
    SOP_EDIT_SCULPT_PROJTYPE_IDX,
    SOP_EDIT_SCULPT_USECONNECTIVITY_IDX,
    SOP_EDIT_SCULPT_REALTIME_IDX,
    SOP_EDIT_SCULPT_RAY_ORIENT_IDX,
    SOP_EDIT_SCULPT_RAY_HITPOS_IDX,
    SOP_EDIT_SCULPT_RAY_HITPRIM_IDX,
    SOP_EDIT_SCULPT_RAY_HITUV_IDX,
    SOP_EDIT_SCULPT_RAY_HITPRESSURE_IDX,
    SOP_EDIT_SCULPT_RAY_HITPT_IDX,
    SOP_EDIT_SCULPT_RAY_EVENT_IDX,

    SOP_EDIT_USEORIENT_IDX,

    // Symmetry Parameters
    SOP_EDIT_USEMIRROR_IDX,
    SOP_EDIT_SYMMETRYAXIS_IDX,
    SOP_EDIT_SYMMETRYORIGIN_IDX,
    SOP_EDIT_SYMMETRYDISTANCE_IDX,
    SOP_EDIT_SYMMETRYTHRESHOLD_IDX,

    SOP_EDIT_UPDATENMLS_IDX,

    // Reset Button
    SOP_EDIT_RESETBUTTON_IDX
};

class SOP_API SOP_Edit : public SOP_BrushBase
{
friend class MSS_EditState;
public:
             SOP_Edit(OP_Network *net, const char *name, OP_Operator *entry);
    virtual ~SOP_Edit();

    virtual int                  isRefInput(unsigned int i) const;
    virtual void                 unloadDataHack();
    virtual bool                 unloadData();

    // Allow toggling of operation type
    void         toggleXformPeak();
    
    virtual unsigned             disableParms();

    static OP_Node              *myConstructor(OP_Network *net,
                                               const char *name,
                                               OP_Operator *entry);

    static PRM_Template          myTemplateList[];
    static PRM_Template          myObsoleteList[];

    // Get the selection group string:
    // We have to override this since the parameter's index has changed
    virtual void         getSelString(UT_String &str)
                            { evalString(str, SOP_EDIT_GRP_IDX, 0, 0.0f); }

    virtual void setAccumulateStencil(bool yesno)
                 {
                     setInt(SOP_EDIT_SCULPT_STENCILACCUM_IDX, 0, 0, yesno);
                 }
    virtual void setRayOrigin(const UT_Vector3 &orig, float t)
                 {
                     setFloat(SOP_EDIT_SCULPT_RAY_HITPOS_IDX, 0, t, orig.x());
                     setFloat(SOP_EDIT_SCULPT_RAY_HITPOS_IDX, 1, t, orig.y());
                     setFloat(SOP_EDIT_SCULPT_RAY_HITPOS_IDX, 2, t, orig.z());
                 }
    virtual void setRayOrientation(const UT_Vector3 &orient, float t)
                 {
                     setFloat(SOP_EDIT_SCULPT_RAY_ORIENT_IDX, 0, t, orient.x());
                     setFloat(SOP_EDIT_SCULPT_RAY_ORIENT_IDX, 1, t, orient.y());
                     setFloat(SOP_EDIT_SCULPT_RAY_ORIENT_IDX, 2, t, orient.z());
                 }
    virtual void setHitPrimitive(int primidx, float t)
                 {
                     setInt(SOP_EDIT_SCULPT_RAY_HITPRIM_IDX, 0, t, primidx);
                 }
    virtual void setHitPoint(int pt, float t)
                 {
                     setInt(SOP_EDIT_SCULPT_RAY_HITPT_IDX, 0, t, pt);
                 }
    virtual void setHitUV(float u, float v, float t)
                 {
                     setFloat(SOP_EDIT_SCULPT_RAY_HITUV_IDX, 0, t, u);
                     setFloat(SOP_EDIT_SCULPT_RAY_HITUV_IDX, 1, t, v);
                 }
    virtual void setHitPressure(float p, float t)
                 {
                     setFloat(SOP_EDIT_SCULPT_RAY_HITPRESSURE_IDX, 0, t, p);
                 }   
    virtual void setRadius(float r, float t)
                 {
                     setFloat(SOP_EDIT_SCULPT_RAD_IDX, 0, t, r);
                 }
    virtual void setUVRadius(float r, float t)
                 {
                     setFloat(SOP_EDIT_SCULPT_UVRAD_IDX, 0, t, r);
                 }
    virtual void setBrushEvent(SOP_BrushEvent event)
                 {
                     setInt(SOP_EDIT_SCULPT_RAY_EVENT_IDX, 0, 0, int(event));
                 }
    virtual void setBrushOp(SOP_BrushOp op)
                 {
                     int iop;
                     switch (op)
                     {
                         case SOP_BRUSHOP_SMOOTH:       iop = 1; break;
                         case SOP_BRUSHOP_SMOOTHDEFORM: iop = 2; break;
                         case SOP_BRUSHOP_ERASE:        iop = 3; break;
                         case SOP_BRUSHOP_DEFORM:
                         default:                       iop = 0; break;
                     }
                     setInt(SOP_EDIT_SCULPT_OP_IDX, 0, 0, iop);
                 }
    virtual void setBrushShape(SOP_BrushShape shape)
                 {
                     setInt(SOP_EDIT_SCULPT_SHAPE_IDX, 0, 0, int(shape));
                 }
    virtual void setProjectionType(int projtype)
                 {
                     setInt(SOP_EDIT_SCULPT_PROJTYPE_IDX, 0, 0, projtype);
                 }
    virtual void useForegroundColor(void)
                 {
                     setInt(SOP_EDIT_SCULPT_COLOR_SWITCHER_IDX, 0, 0, 0);
                 }
    virtual void useBackgroundColor(void)
                 {
                     setInt(SOP_EDIT_SCULPT_COLOR_SWITCHER_IDX, 0, 0, 1);
                 }

    virtual int         altersGeometry() const { return 1; }
    virtual int         altersColor() const { return 0; }

    virtual int         MODE()
                            { return evalInt(SOP_EDIT_MODESWITCHER_IDX, 0, 0); }
    virtual float       RAWRADIUS(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_RAD_IDX, 0, t); }
    virtual float       RAWUVRADIUS(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_UVRAD_IDX,       0, t); }
    virtual float       RADIUSPRESSURE(float t)
                        { return evalFloat(SOP_EDIT_SCULPT_RADPRESSURE_IDX, 0, t); }
    virtual float       RAWOPACITY(float t)
                            {return evalFloat(SOP_EDIT_SCULPT_OPAC_IDX, 0, t); }
    virtual float       OPACITYPRESSURE(float t)
                        {return evalFloat(SOP_EDIT_SCULPT_OPACPRESSURE_IDX, 0, t) ; }

    bool                inBrushMode(float t)
                        { return evalInt("modeswitcher", 0, t); }

    virtual SOP_BrushOp OP(void)        
    { 
        switch (evalInt(SOP_EDIT_SCULPT_OP_IDX, 0, 0))
        {
            case 0:     return SOP_BRUSHOP_DEFORM;
            case 1:     return SOP_BRUSHOP_SMOOTH;
            case 2:     return SOP_BRUSHOP_SMOOTHDEFORM;
            case 3:     return SOP_BRUSHOP_ERASE;
            default:    return SOP_BRUSHOP_DEFORM;
        }
    }
    virtual int         ACCUMSTENCIL(void) 
                            { return evalInt(SOP_EDIT_SCULPT_STENCILACCUM_IDX, 0,0);}
    virtual int         PROJECTIONTYPE(void)
                            { return evalInt(SOP_EDIT_SCULPT_PROJTYPE_IDX, 0, 0); }
    virtual int         REALTIME(void)
                            { return evalInt(SOP_EDIT_SCULPT_REALTIME_IDX, 0, 0); }
    virtual int         SHAPE(float t)
                            { return evalInt(SOP_EDIT_SCULPT_SHAPE_IDX, 0, t); }

    virtual OP_ERROR             cookInputGroups(OP_Context &context,
                                                 int alone = 0);

    virtual void                 getXformOrder(UT_XformOrder &xord, 
                                                CH_Channel *chp);

    virtual void                 resolveObsoleteParms(
                                                PRM_ParmList *obsolete_parms);

    // This will force myRayIntersect to be recomputed
    void                         clearRayIntersect();

    virtual void                 beginNewOperation();
    virtual void                 clearAllDeltas(float t);

    // Functions for the BlendShapes SOP hack to only apply scaled deltas
    // without cooking
    void                         applyScaledDeltas(
                                    GEO_Detail &apply_gdp,
                                    const GDT_CoordinateFrames *coord_frames,
                                    float scale,
                                    const GB_PointGroup *ptgroup);

    bool                         getCookedFlag() const { return myCookedFlag; }

    void                         setUseOrient(bool f)
                            { setInt(SOP_EDIT_USEORIENT_IDX, 0, 0, f ? 1 : 0); }

    virtual bool                 hasChange(float t);

    const GB_PrimitiveGroup     *getPrimitiveSelection() const
                            { return myPrimitiveGroup; }

protected:
    virtual void                 clearTransformParms();
    virtual OP_ERROR             cookMySop(OP_Context &context);
    virtual const char          *inputLabel(unsigned idx) const;

    virtual void                 rollbackCurrentDelta();
    virtual void                 mirrorDelta();
    virtual void                 applyAndClearCurrentDelta();
    virtual void                 applyPermanentDelta();
    virtual void                 initializeInput(OP_Context &context);

    virtual bool                 getGroupCentroid(OP_Context &context,
                                                  UT_Vector3 &centroid);

    virtual void                 doErase();

    // This function takes the transform parameters and modifies the gdp
    // pointer, while creating the appropriate deltas in myCurrentDelta.
    // It is virtual so that HDK classes may hook into this.
    virtual void                 doTransform();

    virtual int         MERGEMODE() { return 0; }
    virtual void        SCRIPT(UT_String &, float) {}

    virtual int         AXIS(void)
                            { return   evalInt(SOP_EDIT_SCULPT_AXIS_IDX, 0, 0);  }
    virtual float       USERX(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_USER_IDX, 0, t);  }
    virtual float       USERY(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_USER_IDX, 1, t);  }
    virtual float       USERZ(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_USER_IDX, 2, t);  }

    virtual float       RAYORIENTX(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_RAY_ORIENT_IDX,0,t); }
    virtual float       RAYORIENTY(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_RAY_ORIENT_IDX,1,t); }
    virtual float       RAYORIENTZ(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_RAY_ORIENT_IDX,2,t); }
    virtual float       RAYHITX(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_RAY_HITPOS_IDX,0,t); }
    virtual float       RAYHITY(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_RAY_HITPOS_IDX,1,t); }
    virtual float       RAYHITZ(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_RAY_HITPOS_IDX,2,t); }
    virtual float       RAYHITU(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_RAY_HITUV_IDX, 0,t); }
    virtual float       RAYHITV(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_RAY_HITUV_IDX, 1,t); }
    virtual float       RAYHITPRESSURE(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_RAY_HITPRESSURE_IDX, 0, t); }
    virtual int         PRIMHIT(float t)
                            { return evalInt(SOP_EDIT_SCULPT_RAY_HITPRIM_IDX, 0,t); }
    virtual int         PTHIT(float t)
                            { return evalInt(SOP_EDIT_SCULPT_RAY_HITPT_IDX, 0, t); }
    virtual int         EVENT()
                            { return evalInt(SOP_EDIT_SCULPT_RAY_EVENT_IDX,   0,0); }
    virtual bool        USE_FOREGROUND(void)
                            { return evalInt(SOP_EDIT_SCULPT_COLOR_SWITCHER_IDX,
                                                                   0, 0) == 0; }
    virtual float FGR(float t)   { return evalFloat(SOP_EDIT_SCULPT_FG_IDX,     0, t); }
    virtual float FGG(float  )   { return 0.0f; }
    virtual float FGB(float  )   { return 0.0f; }
    virtual float BGR(float t)   { return evalFloat(SOP_EDIT_SCULPT_BG_IDX,     0, t); }
    virtual float BGG(float  )   { return 0.0f; }
    virtual float BGB(float  )   { return 0.0f; }

    virtual float       SOFTEDGE(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_SOFTEDGE_IDX, 0, t); }
    virtual void        KERNEL(UT_String &str, float t) 
                            { evalString(str, SOP_EDIT_SCULPT_KERNEL_IDX, 0, t); }
    virtual int         UPTYPE(float t)
                            { return evalInt(SOP_EDIT_SCULPT_UPTYPE_IDX, 0, t);}
    virtual float       UPX(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_UPVECTOR_IDX, 0, t);}
    virtual float       UPY(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_UPVECTOR_IDX, 1, t);}
    virtual float       UPZ(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_UPVECTOR_IDX, 2, t);}

    virtual float       PAPERNOISE(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_PAPER_IDX, 0, t);}
    virtual float       SPLATTER(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_SPLATTER_IDX, 0, t); }
    virtual void        BITMAP(UT_String &str, float t)
                            { evalString(str, SOP_EDIT_SCULPT_BITMAP_IDX, 0, t); }
    virtual int         BITMAPCHAN(float t)
                            { return evalInt(SOP_EDIT_SCULPT_BITMAPCHAN_IDX, 0, t); }
    virtual float       ANGLE(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_ANGLE_IDX, 0, t); }
    virtual float       SQUASH(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_SQUASH_IDX, 0, t); }

    virtual int         DOSTAMPING()                    { return 0; }
    virtual int         WRITEALPHA()                    { return 0; }
    virtual int         OVERRIDECD()                    { return 0; }
    virtual void        CDNAME(UT_String &, float)      { }
    virtual int         OVERRIDEALPHA()                 { return 0; }
    virtual void        ALPHANAME(UT_String &, float)   { }
    virtual int         OVERRIDENML() { return 0; }
    virtual void        NMLNAME(UT_String & /*str*/, float /*t*/) {}
    virtual int         ADDATTRIB()                     { return 0; }

    virtual float SYMMETRYDIRX(float /*t*/) { return 0.0f; }
    virtual float SYMMETRYDIRY(float /*t*/) { return 0.0f; }
    virtual float SYMMETRYDIRZ(float /*t*/) { return 0.0f; }
    virtual float SYMMETRYORIGX(float /*t*/) { return 0.0f; }
    virtual float SYMMETRYORIGY(float /*t*/) { return 0.0f; }
    virtual float SYMMETRYORIGZ(float /*t*/) { return 0.0f; }
    virtual int   DOREFLECTION() { return 0; }
    virtual int   DOREFLECT() { return 0; }
    virtual int   DOPOINTREFLECTION() { return 0; }
    virtual int   DOROTATION() { return 0; }
    virtual int   SYMMETRYROT(float /*t*/)  { return 0; }
    virtual float SYMMETRYDIST(float /*t*/) { return 0.0f; }
    virtual int   DOUVREFLECTION() { return 0; }
    virtual float SYMMETRYUVORIGU(float /*t*/) { return 0.0f; }
    virtual float SYMMETRYUVORIGV(float /*t*/) { return 0.0f; }
    virtual float SYMMETRYUVANGLE(float /*t*/) { return 0.0f;}

    virtual int         USECONNECTIVITY()
                            { return evalInt(SOP_EDIT_SCULPT_USECONNECTIVITY_IDX, 0, 0); }
    virtual int         USEDEPTH()
                            { return evalInt(SOP_EDIT_SCULPT_USEDEPTH_IDX, 0, 0); }
    virtual float       DEPTH(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_DEPTH_IDX, 0, t); }
    virtual float       HEIGHT(float t)
                            { return evalFloat(SOP_EDIT_SCULPT_DEPTH_IDX, 1, t); }


    // Find out if the brush has moved or done anything to cause us to add its
    // effect to the current gdp.
    virtual bool        hasStrokeChanged(float t);
    virtual bool        hasStyleChanged(float t);

    // Find if the nib file has changed:
    virtual bool        hasNibFileChanged(float t);
    virtual bool        hasAccumStencilChanged(float t);
    virtual bool        hasNibLookChanged(float t);

    // Do we want our cook selection to be updated and displayed?
    virtual bool         wantsCookSelection(void) const { return true; }

    virtual GDT_CoordinateFrames *getCoordinateFrames()
                                 { return &myCoordinateFrames; }

    virtual const GB_PointGroup *getPointGroup() { return myPointGroup; }

private:
    // Selection
    int          GRPTYPE()      { return evalInt(SOP_EDIT_GRPTYPE_IDX, 0, 0); }

    // Access to switcher parm
    int          SWITCHER()     { return evalInt(SOP_EDIT_SWITCHER_IDX, 0, 0); }
    void         SET_SWITCHER(int i)
                                { setInt(SOP_EDIT_SWITCHER_IDX, 0, 0, i); }
    
    // Transform
    int          TRS()          { return evalInt(SOP_EDIT_TRS_IDX, 0, 0); }
    int          XYZ()          { return evalInt(SOP_EDIT_XYZ_IDX, 0, 0); }
    float        TX()           { return evalFloat(SOP_EDIT_T_IDX, 0, 0); }
    float        TY()           { return evalFloat(SOP_EDIT_T_IDX, 1, 0); }
    float        TZ()           { return evalFloat(SOP_EDIT_T_IDX, 2, 0); }
    float        RX()           { return evalFloat(SOP_EDIT_R_IDX, 0, 0); }
    float        RY()           { return evalFloat(SOP_EDIT_R_IDX, 1, 0); }
    float        RZ()           { return evalFloat(SOP_EDIT_R_IDX, 2, 0); }
    float        SX()           { return evalFloat(SOP_EDIT_S_IDX, 0, 0); }
    float        SY()           { return evalFloat(SOP_EDIT_S_IDX, 1, 0); }
    float        SZ()           { return evalFloat(SOP_EDIT_S_IDX, 2, 0); }
    float        SHEAR_XY()     { return evalFloat(SOP_EDIT_SHEAR_IDX, 0, 0); }
    float        SHEAR_XZ()     { return evalFloat(SOP_EDIT_SHEAR_IDX, 1, 0); }
    float        SHEAR_YZ()     { return evalFloat(SOP_EDIT_SHEAR_IDX, 2, 0); }
    float        PX()           { return evalFloat(SOP_EDIT_P_IDX, 0, 0); }
    void         SET_PX(float f){         setFloat(SOP_EDIT_P_IDX, 0, 0, f); }
    float        PY()           { return evalFloat(SOP_EDIT_P_IDX, 1, 0); }
    void         SET_PY(float f){         setFloat(SOP_EDIT_P_IDX, 1, 0, f); }
    float        PZ()           { return evalFloat(SOP_EDIT_P_IDX, 2, 0); }
    void         SET_PZ(float f){         setFloat(SOP_EDIT_P_IDX, 2, 0, f); }
    int          KEEP()         { return evalInt(SOP_EDIT_KEEP_IDX, 0, 0); }

    // Peak
    float        DIST()         { return evalFloat(SOP_EDIT_DIST_IDX, 0, 0); }
    int          LEADNML()      { return evalInt(SOP_EDIT_LEADNML_IDX, 0, 0); }
    
    // Soft
    float        SOFTRADIUS()   { return evalFloat(SOP_EDIT_SOFTRADIUS_IDX, 0, 0); }
    int          SOFTTYPE()     { return evalInt(SOP_EDIT_SOFTTYPE_IDX, 0, 0); }
    float        TANDEG0()      { return evalFloat(SOP_EDIT_TANGENT_IDX,0, 0); }
    float        TANDEG1()      { return evalFloat(SOP_EDIT_TANGENT_IDX,1, 0); }
    void         KERNEL(UT_String &str) { evalString(str, SOP_EDIT_KERNEL_IDX,
                                                     0, 0.0f); }
    int          GLOBAL()       { return evalInt(SOP_EDIT_GLOBAL_IDX, 0, 0); }

    bool         USEORIENT()
                        { return evalInt(SOP_EDIT_USEORIENT_IDX, 0, 0) != 0; }

    // Symmetry
    bool         USEMIRROR()
                        { return evalInt(SOP_EDIT_USEMIRROR_IDX, 0, 0) != 0; }
    float        SYMMETRYAXISX()
                        { return evalFloat(SOP_EDIT_SYMMETRYAXIS_IDX, 0, 0); }
    float        SYMMETRYAXISY()
                        { return evalFloat(SOP_EDIT_SYMMETRYAXIS_IDX, 1, 0); }
    float        SYMMETRYAXISZ()
                        { return evalFloat(SOP_EDIT_SYMMETRYAXIS_IDX, 2, 0); }
    float        SYMMETRYORIGINX()
                        { return evalFloat(SOP_EDIT_SYMMETRYORIGIN_IDX, 0, 0); }
    float        SYMMETRYORIGINY()
                        { return evalFloat(SOP_EDIT_SYMMETRYORIGIN_IDX, 1, 0); }
    float        SYMMETRYORIGINZ()
                        { return evalFloat(SOP_EDIT_SYMMETRYORIGIN_IDX, 2, 0); }
    float        SYMMETRYDISTANCE()
                        { return evalFloat(SOP_EDIT_SYMMETRYDISTANCE_IDX, 0, 0); }
    float        SYMMETRYTHRESHOLD()
                        { return evalFloat(SOP_EDIT_SYMMETRYTHRESHOLD_IDX, 0, 0); }

    int          UPDATENMLS()   { return evalInt(SOP_EDIT_UPDATENMLS_IDX,
                                                 0, 0); }

    // Transform / Peak
    bool                         isTransform() { return SWITCHER() == 0; }
    bool                         isPeak() { return SWITCHER() != 0; }
    void                         doPeak();
    // Soft-related methods
    bool                         isSoft() { return SOFTRADIUS() != 0.0; }

    void                         getTransform(UT_Matrix4 &xform, UT_Vector3 &pivot);
    UT_Vector3                   myInitialCentroid;

    GDT_CoordinateFrames         myCoordinateFrames;
    bool                         myUsedOrient;
    int                          myCurrentInputId;
    int                          myCurrentGeoCookCount;
    int                          myReferenceInputId;
    int                          myReferenceGeoCookCount;
    const GB_PrimitiveGroup     *myPrimitiveGroup;
    const GB_PointGroup         *myPointGroup;
};

#endif

---