SOP/SOP_Node.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.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        SOP Library (C++)
 *
 * COMMENTS:    The base class for all SOP operators
 *              Every SOP is responsible for filling in the following methods:
 *                      cookMe(float t);
 *
 */

#ifndef __SOP_Node_h__
#define __SOP_Node_h__

#include "SOP_API.h"
#include <UT/UT_SymbolTable.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_RefArray.h>
#include <UT/UT_String.h>
#include <GU/GU_Detail.h>
#include <GU/GU_DetailHandle.h>
#include <GU/GU_DetailGroupPair.h>
#include <GU/GU_SelectType.h>
#include <OP/OP_InputChangeHelper.h>
#include <OP/OP_Network.h>
#include <GOP/GOP_Manager.h>
#include "SOP_Error.h"
#include "SOP_Guide.h"
#include "SOP_NodeFlags.h"

class UT_InfoTree;
class UT_Undo;
class GB_VertexGroup;
class GU_Selection;
class GU_Topology;
class OP_OperatorTable;
class SOP_Node;
class SOP_SoftLockData;
class DD_Source;

extern "C" {
    DLLEXPORT extern void       newSopOperator(OP_OperatorTable *table);
};

class sopVarInfo;

class SOP_API sop_attribRef
{
public:
    UT_String           myName;
    int                 mySize;
    GB_AttribType       myType;
};

// A call back operator for local variables:
typedef float (SOP_Node::*SOP_LocalVarFunc)
                (sopVarInfo *varinfo);

// Handy function to build a meta kernel menu. Used in several sops.
SOP_API extern void     SOPfillMetaKernelMenu(void *, PRM_Name *names, int size,
                                          const PRM_SpareData *, PRM_Parm *);

//___________________________________________________________________________

typedef void sopVisualizeCallback(void * /*data*/, SOP_Node *, OP_Context &, GU_Detail *);

class SOP_API SOP_Node : public OP_Network
{
public:
    virtual const char          *getChildType() const;
    virtual const char          *getOpType() const;

    virtual OP_OpTypeId  getChildTypeID() const;
    virtual OP_OpTypeId  getOpTypeID() const;

    const SOP_NodeFlags         &getFlags() const { return mySopFlags; }

    // Whether a SOP is cooking render is whether its object creator is.
    virtual int                  isCookingRender() const 
                                 { return getCreator()->isCookingRender(); }

    // This allows us to tap into flag changes and perform unloads
    // if necessary.
    virtual void                 opChanged(OP_EventType reason, void *data=0);

    //
    // Local variable functions:
    //
    
    // Used to accumulate local variables:
    const CH_LocalVariable      *resolveVariable(const char *name);
    
    // Each one gets a precedence from 0-3.  Resolution within
    // a precedence is undefined.
    // 0 is highest precedence.
    // This is used for generic variables like Cd 
    void                         setVariableOrder(int detail, int prim, 
                                                  int pt, int vtx);
    // Gets the index of specified level.  Index is same as the parameter
    // order in setVariableOrder
    int                          getVariableOrder(int level) const;
    // Given a variable idx, gives the precedence.
    int                          getVariablePrecedence(int var) const;

    // Wipe the table of local variables
    // This is automatically called by the setup function so
    // shouldn't be called outside it.

    virtual bool                 usesFootprint() const { return true; }

    void                         setVisualizeCallback(sopVisualizeCallback *callback, void *data);

private:
    void                         clearLocalVars();
    
public:

    // the flag indicating the capture override state (on/off)
    // This override is mirroring the kinematic override at the OBJ level.
    // It is used to determine whether capture related SOPs use the
    // capture parameter or regular animation parameters for cooking
    static void                  setCaptureOverrideFlag( bool flag )
                                        {
                                            theGlobalCaptOverride = flag;
                                        }
    static bool                  getCaptureOverrideFlag() 
                                        {
                                            return theGlobalCaptOverride; 
                                        }

    
    // Build the local variable table
    // This should be done AFTER you have set the local variable
    // order & AFTER you have initialized your myGdp[*].
    void                         setupLocalVars();

    // This resets all the myCur*s to zero so we can be sure they
    // are all cleared out.  It does NOT clear the bounding box
    // build states.
    void                         resetLocalVarRefs();

    void                         setCurGdh(int index,
                                           const GU_DetailHandle &gdh);
    void                         clearCurGdh(int index);
    const GU_DetailHandle       &getCurGdh(int index);

    // Loads the variable value:
    virtual float                getVariableValue(int index, int thread);

    // Like getVariableValue() but returns true if successful and false
    // otherwise.
    bool                         getVariableValueFP(fpreal &val, int index);

    // This gets the variable value as a string.  Not the string
    // corresponding to the specified index.
    virtual void                 getVariableString(int index, UT_String &value,
                                                   int thread);

    // Tries to add the variable to each of our gdps, using the appropriate
    // "" or "2" suffix.
    void                         addGenericVariable(const char *varname,
                                        GEO_Standard_Attributes attr,
                                        int idx, int sz, GB_AttribType type,
                                        float ladefault = 0.0f);
    void                         addGenericVariable(const char *varname, 
                                        const char *attribname, int idx,
                                        int sz, GB_AttribType type,
                                        float ladefault = 0.0F);
    void                         addGenericVariable(const char *varname,
                                        int varidx,
                                        SOP_LocalVarFunc callback,
                                        float ladefault = 0.0F);
    // Add variables to our look up table, provided they exist in the GDP
    // The addGeneric adds all the prefixed versions, then finds the first
    // one which is valid and sets itself to that.
    void                         addGenericVariable(const GU_Detail *gdp, 
                                        int gdpidx,
                                        const char *varname, 
                                        const char *attribname, int idx,
                                        int sz, GB_AttribType type,
                                        float ladefault = 0.0F);
    void                         addGenericVariable(int gpdidx,
                                        const char *varname,
                                        int varidx,
                                        SOP_LocalVarFunc callback,
                                        float ladefault = 0.0F);
    void                         addSpecificVariable(const GU_Detail *gdp, 
                                        int gdpidx,
                                        const char *varname,
                                        const char *attribname, int idx, 
                                        int sz, GB_AttribType type,
                                        GEO_AttributeOwner dictionary,
                                        float ladefault = 0.0F);
    void                         addSpecificVariable(int gpidx,
                                        const char *varname,
                                        int varidx,
                                        GEO_AttributeOwner dictionary,
                                        SOP_LocalVarFunc callback,
                                        float ladefault = 0.0F);

    static int                   addCustomVariableCallback(const char *attr,
                                        const char *varname, void *data);
    void                         addCustomVariable(const char *attr,
                                        const char *varname);

    void                         cacheVarPtBox(int gpdidx);
    void                         cacheVarPrimBox(int gpdidx);

    //
    // These are the call back functions to evaluate various variable
    // types.
    //
    float                varCallbackT(sopVarInfo *varinfo);

    float                varCallbackPT(sopVarInfo *varinfo);
    float                varCallbackPR(sopVarInfo *varinfo);
    float                varCallbackVTX(sopVarInfo *varinfo);

    float                varCallbackNPT(sopVarInfo *varinfo);
    float                varCallbackNPR(sopVarInfo *varinfo);
    float                varCallbackNVTX(sopVarInfo *varinfo);

    float                varCallbackCE(sopVarInfo *varinfo);
    float                varCallbackMIN(sopVarInfo *varinfo);
    float                varCallbackMAX(sopVarInfo *varinfo);
    float                varCallbackSIZE(sopVarInfo *varinfo);
    float                varCallbackLIFE(sopVarInfo *varinfo);
    float                varCallbackBB(sopVarInfo *varinfo);
    float                varCallbackWEIGHT(sopVarInfo *varinfo);

    // These methods return the variables being iterated over.  The index
    // must be 0 or 1.
    const GU_DetailHandle &curGdh(int index) const
    { UT_ASSERT(index == 0 || index == 1); return myCurGdh[index]; }

    // Note that the current vertex num will be 0 even if there is no
    // current vertex.  Use curVertex() to check if there is a current
    // vertex.
    int                  curVertexNum(int index) const
    { UT_ASSERT(index == 0 || index == 1); return myCurVtxNum[index]; }

    const GEO_Vertex    *curVertex(int index) const
    { UT_ASSERT(index == 0 || index == 1); return myCurVtx[index]; }

    const GEO_Point     *curPoint(int index) const
    { UT_ASSERT(index == 0 || index == 1); return myCurPt[index]; }

    const GEO_Primitive *curPrim(int index) const
    { UT_ASSERT(index == 0 || index == 1); return myCurPrim[index]; }

    // The point bounding box is used from $BBX, $BBY, and $BBZ.
    UT_BoundingBox       curPointBBox(int index)
    {
        UT_ASSERT(index == 0 || index == 1);
        cacheVarPtBox(index);
        return myCurPtBox[index];
    }

    // The primitive bounding box is used from $MINX, $MINY, and $MINZ.
    UT_BoundingBox       curPrimBBox(int index)
    {
        UT_ASSERT(index == 0 || index == 1);
        cacheVarPrimBox(index);
        return myCurPrimBox[index];
    }


    // Function to set the pivot parm to the centroid of the input group
    void                 setPivotParmToGroupCentroid(OP_Context &context);

private:
    // Helper function for building the drop down group menus.
    void                getGroupMenuHeader( int sourcenum, const char * title,
                                            UT_String & header );

    static void         buildSopGroups( const GU_Detail *src, 
                                const char * prim_header, 
                                const char * pt_header,
                                PRM_Name *menuEntries, int themenusize, 
                                unsigned type, int start, 
                                bool includeselection, PRM_Parm *parm );

    static int          buildSopEdgeGroups( const GU_Detail *src, 
                                const char * edge_header, 
                                const char *prim_header, const char *pt_header, 
                                PRM_Name *menuEntries, int themenusize, 
                                bool addprim, int start, 
                                PRM_Parm *parm );

    static int          buildSopBreakpointGroups( const GU_Detail *src, 
                                const char * brkpt_header, 
                                const char * prim_header, const char *pt_header,
                                PRM_Name *choicenames, int menusize, 
                                bool addprim, int start, 
                                PRM_Parm *parm );

public:
    //  The following method has to be public for some static functions in
    //  the code
    static void          buildGroupsFromSop( SOP_Node * src_sop, 
                                    PRM_Parm *parm, const PRM_SpareData *spare, 
                                    unsigned type, int start,
                                    PRM_Name *menuEntries, int thelistsize );

    static int           buildEdgeGroupsFromSop( SOP_Node * src_sop, 
                                    PRM_Parm *parm, const PRM_SpareData *spare, 
                                    bool addprim, int start,
                                    PRM_Name *menuEntries, int thelistsize );

    static int           buildBreakpointGroupsFromSop( SOP_Node * src_sop, 
                                    PRM_Parm *parm, const PRM_SpareData *spare, 
                                    bool addprim, int start,
                                    PRM_Name *menuEntries, int thelistsize );

    void                 buildInputGroups(int thesourcenum,
                                        PRM_Name *thechoicenames,
                                        int themenusize,
                                        unsigned type, int start,
                                        bool includeselection,
                                        PRM_Parm *parm);

    int                  buildInputEdgeGroups(int sourcenum,
                                        PRM_Name *choicenames, int menusize,
                                        bool addprim, int start,
                                        PRM_Parm *parm);

    int                  buildInputBreakpointGroups(int sourcenum, 
                                        PRM_Name *choicenames, int menusize,
                                        bool addprim, int start,
                                        PRM_Parm *parm);

    virtual int          setModelLock(int lock_type, 
                                      void *modeler = 0,
                                      int allow_softlock_promotion=0,
                                      UT_Undo *undo = 0);

    //  Nobody should have to override this, but it's public for other people
    virtual OP_DATA_TYPE getCookedDataType() const;

    virtual void        *getCookedData(OP_Context &ctx);

    virtual bool         getBoundingBox(UT_BoundingBox &box, OP_Context &ctx);

    // Get cooked geometry. If "forced" is true and cooking fails, we create
    // an empty gdp and clear the cooking flags.
    // Note that the resulting handle may be reused in future cooks!
    // To prevent the handle from being reused, call addPreserveRequest()
    // on the handle.
    const GU_Detail     *getCookedGeo(OP_Context &, int forced = 0);
    GU_DetailHandle      getCookedGeoHandle(OP_Context &, int forced = 0);
    const SOP_Guide     *getCookedGuide1() const;
    const SOP_Guide     *getCookedGuide2() const;

    // This is similar to the getCookedGeo except it merely returns the
    // cached GEO, if any.  If none, it returns NULL without trying to cook.
    const GU_Detail     *getLastGeo();

    // Returns the equivalent of getLastGeo of the given input.  This lets
    // you get an input geometry without locking the input and without
    // risking cooking it.  It can, and will, return NULL without trying
    // to cook in many cases.
    const GU_Detail     *getInputLastGeo(int input, float time);

    OP_ERROR             cookGuide1(OP_Context &context);
    OP_ERROR             cookGuide2(OP_Context &context);

    OP_ERROR             cookGuideList(OP_Context &context,
                                UT_RefArray<GU_DetailHandle> &list);

    // The guide list can consist of either GOP_Guide derived objects or simple
    // GU_Detail objects (but not a combination).  This method is used to query
    // which of the two, if any, the node generates.
    virtual GOP_GuideListType   getGuideListType() const
                                    { return OP_GUIDELIST_GUDETAIL; }

    virtual OP_ERROR     lockInput(unsigned idx, OP_Context &context);
    void                 unlockInput(unsigned idx);
    virtual OP_ERROR     lockInputs(OP_Context &context);
    void                 unlockInputs();

    static void          buildOperatorTable(OP_OperatorTable &table);
    static void          initializeExpressions();

    void                 expandGroupNames(const char *pattern, 
                                          UT_String &outNames,
                                          int isPrims,
                                          GU_Detail *pgdp);
    void                 expandGroupNames(const char *pattern, 
                                          UT_String &outNames,
                                          int isPrims)
                         { expandGroupNames(pattern, outNames, isPrims, gdp); }

    const GB_PrimitiveGroup     *parsePrimitiveGroups(const char *pattern, 
                                                      GU_Detail *pgdp, 
                                                      int allow_numeric=1,
                                                      int ordered = 1,
                                                      bool strict = false,
                                                      int offset = 0);
    const GB_PrimitiveGroup     *parsePrimitiveGroups(const char *pattern)
                                 { return parsePrimitiveGroups(pattern, gdp); }

    GB_PrimitiveGroup           *parsePrimitiveGroupsCopy(const char *pattern, 
                                                          GU_Detail *pgdp, 
                                                          int allow_numeric=1,
                                                          int ordered = 1,
                                                          bool strict = false);
    GB_PrimitiveGroup           *parsePrimitiveGroupsCopy(const char *pattern)
                                 {return parsePrimitiveGroupsCopy(pattern,gdp);}

    const GB_PointGroup         *parsePointGroups(const char *pattern, 
                                                  GU_Detail *pgdp,
                                                  int allow_numeric=1,
                                                  int ordered = 1,
                                                  bool strict = false,
                                                  int offset = 0);
    const GB_PointGroup         *parsePointGroups(const char *pattern)
                                 { return parsePointGroups(pattern, gdp); }

    GB_PointGroup               *parsePointGroupsCopy(const char *pattern, 
                                                  GU_Detail *pgdp,
                                                  int allow_numeric=1,
                                                  int ordered = 1,
                                                  bool strict = false);
    GB_PointGroup               *parsePointGroupsCopy(const char *pattern)
                                 { return parsePointGroupsCopy(pattern, gdp); }

    const GB_EdgeGroup          *parseEdgeGroups(const char *pattern,
                                                 GU_Detail *pgdp,
                                                 bool strict = true,
                                                 int prim_offset = 0,
                                                 int point_offset = 0);
    const GB_EdgeGroup          *parseEdgeGroups(const char *pattern)
                                 { return parseEdgeGroups(pattern, gdp); }

    GB_EdgeGroup                *parseEdgeGroupsCopy(const char *pattern,
                                                     GU_Detail *pgdp);
    GB_EdgeGroup                *parseEdgeGroupsCopy(const char *pattern)
                                 { return parseEdgeGroupsCopy(pattern, gdp); }

    const GB_BreakpointGroup    *parseBreakpointGroups(const char *pattern,
                                                       GU_Detail *pgdp,
                                                       bool strict = true,
                                                       int offset = 0);
    const GB_BreakpointGroup    *parseBreakpointGroups(const char *pattern)
                                 { return parseBreakpointGroups(pattern, gdp); }

    GB_BreakpointGroup          *parseBreakpointGroupsCopy(const char *pattern,
                                                           GU_Detail *pgdp);
    GB_BreakpointGroup          *parseBreakpointGroupsCopy(const char *pattern)
                                {return parseBreakpointGroupsCopy(pattern,gdp);}

    const GB_VertexGroup        *parseVertexGroups(const char *pattern,
                                                       GU_Detail *pgdp,
                                                       bool strict = true,
                                                       int offset = 0);
    const GB_VertexGroup        *parseVertexGroups(const char *pattern)
                                 { return parseVertexGroups(pattern, gdp); }

    GB_VertexGroup              *parseVertexGroupsCopy(const char *pattern,
                                                           GU_Detail *pgdp);
    GB_VertexGroup              *parseVertexGroupsCopy(const char *pattern)
                                 { return parseVertexGroupsCopy(pattern, gdp); }
    
    const GB_BaseGroup          *parseAllGroups(const char *pattern,
                                                GU_Detail *pgdp=0,
                                                int allow_numeric=1,
                                                int ordered=1,
                                                unsigned int mask = GBGROUP);
    const GB_BaseGroup          *parseAllGroups(const char *pattern)
                                 { return parseAllGroups(pattern, gdp); }

    GB_BaseGroup                *parseAllGroupsCopy(const char *pattern,
                                                GU_Detail *pgdp=0,
                                                int allow_numeric=1,
                                                int ordered=1,
                                                unsigned int mask = GBGROUP);
    GB_BaseGroup                *parseAllGroupsCopy(const char *pattern)
                                 { return parseAllGroupsCopy(pattern, gdp); }

    // Explicitly destroy an adhoc group. Usually this is done on your behalf
    // internally, after the SOP cooks, but this method allows you to delete
    // an adhoc group within the cooking methods. Return is 0 if not found.
    // An adhoc group is created when the SOP groups are parsed, or when you
    // call createAdhocPrimGroup() or createAdhocPointGroup().

    int                  destroyAdhocGroup (const GB_BaseGroup *group)
                         { return myGroupParse.destroyAdhocGroup(group); }
    void                 destroyAdhocGroups()
                         { myGroupParse.destroyAdhocGroups(); }
    void                 destroyAdhocGroups(const GU_Detail *g)
                         { myGroupParse.destroyAdhocGroups(g); }

    // Set the selection based on the given geometry:
                         // Select all gdp using crt sel type. prims by default
    void                 select(void);
                         // Select all gdp using given selection type
    void                 select(GU_SelectionType stype);
                         // Select the group. opt use its type as sel type
    void                 select(const GB_BaseGroup &group, int use_gtype = 1,
                                int add_to_sel = 0);
    void                 select(GEO_Primitive &prim, int sel_prim = 1,
                                int add_to_sel = 0);
    void                 select(GEO_Point &point, int point_sel = 1,
                                int add_to_sel = 0);
    void                 selectFrom(GEO_Primitive &prim, int sel_prim = 1,
                                    int add_to_sel = 0);
    void                 selectFrom(GEO_Point &point, int point_sel = 1,
                                    int add_to_sel = 0);

    // Selects input based on the group supplied and the group type.  If
    // group is not null, then it's type is used, otherwise the group type
    // is used.  The grouptype parameter is an integer compatible with the
    // Group Type parm order.
    void                 selectInputGroup(GB_BaseGroup *group,
                                          int grouptype);

    // If no selection is present, then create a new selection of type prim.
    // Else, clear the selection.
    void                 clearSelection(void);

    // If the selection is not of type "stype", then destroy it and create
    // a new selection of that type.  Else, clear the selection. 
    void                 clearSelection(GU_SelectionType stype);

    // Blow away the selection and reinitialize it to 0. Much more radical
    // than clearSelection(), which leaves behind a clean, empty selection.
    // This method returns 1 if it had anything to destroy, else 0.
    int                  destroySelection(void);

    // Return 1 if selection is enabled, 0 if false.
    int                  selectionEnabled(void) const
                         {
                             return getHighlight();
                         }

    bool                 hasCookedSelection(void) const
                         {
                             return myHasCookedSelection;
                         }

    // Copy all the temp selections from the given SOP into this one. All
    // existing selections on this SOP will be destroyed first. If there are
    // no temp selections, then the cook selection is copied into a temp
    // selection.
    bool                 copyTempSelections(OP_Context &context, SOP_Node *src);

    virtual void         resetSimulation (void) {}

    virtual int          getNetOverviewColor( UT_Color &color );

    void                 addInstanceReference(SOP_Node *node);
    void                 clearInstanceReference(SOP_Node *node);

    /// This makes *this an instance of node.  It must be called within
    /// a cookMySop.  myGdpHandle is assumed to have an active write lock.
    /// this->gdp is updated to point to the new gdp.  It is assumed
    /// that clearInstance() has already been called.
    /// The node that you pass in must be cooked prior to instancing!
    /// This has occured for free if it was lockInputed.  Otherwise,
    /// one must use getCookedGeoHandle to cook the SOP.
    void                 makeInstanceOf(SOP_Node *node);

    /// A hint to this node that it is about to be cooked at an
    /// unexpected time so shouldn't reuse the existing GDP. 
    /// Should not be used without understanding the consequences.
    void                 makePreserveRequest();

    virtual void         setVisualization(int) {}
    virtual void         setForceCapture(int) {}

    virtual void         getNodeSpecificInfoText(OP_Context &context,
                                                 int verbose,
                                                 UT_WorkBuffer &text);

    //Fill in tree with this SOP's details
    virtual void                 fillInfoTreeNodeSpecific(UT_InfoTree &tree, 
                                                          float time);

    /// This method has to do with 'fillInfoTreeNodeSpecific()' above. When the 
    /// call to OP_Node::fillInfoTree() completes (which is what called 
    /// fillInfoTreeNodeSpecific()), the UT_InfoTree 'tree' will be parsed and 
    /// displayed in a dialog box by OPUI_OpInfoDialog, at which point, that 
    /// class will want to ask us - which branch of the tree would you like to
    /// be selected by default when the dialog is displayed for the first time?
    virtual const char  *getDefaultSelectedInfoTreeBranchName() const;
    
    // Spare data used to determine which input the group menu is associated
    // with.
    static PRM_SpareData        theFirstInput;
    static PRM_SpareData        theSecondInput;
    static PRM_SpareData        theThirdInput;
    static PRM_SpareData        theFourthInput;

    ///Absolute Width
    virtual fpreal       getW() const;
    ///Absolute Height
    virtual fpreal       getH() const;


protected:
             SOP_Node(OP_Network *parent, const char *name, OP_Operator *entry);
    virtual ~SOP_Node();

    // We listen to these as our Cache relies on unique ids, so must
    // know when they are no longer valid.
    virtual void         setUniqueId(int id);
    virtual void         clearUniqueId();

    // Remove the adhoc group(s) from the list of adhocs to be deleted when
    // cooking ends. This way, deletion of the group becomes your
    // responsibility. You should rarely and cautiously use these methods.
    // Most of the time you need destroyAdhocGroup[s] instead.
    // You *MUST* use the parse.*Copy methods to get the adhoc group.
    // Otherwise, you may delete a group which you don't have ownership of.
    int                  removeAdhocGroup (const GB_BaseGroup *group)
                         { return myGroupParse.removeAdhocGroup(group); }
    void                 removeAdhocGroups()
                         { myGroupParse.removeAdhocGroups(); }


    //  Protected virtuals:
    //
    //  "cookMe" is where the actual work is done.
    //  The error is returned (OP_ERR_NONE on success).
    //
    virtual OP_ERROR     cookMe   (OP_Context &context);
    virtual OP_ERROR     bypassMe (OP_Context &context, int &copied_input);
    virtual OP_ERROR     cookMySop(OP_Context &context) = 0;
    virtual OP_ERROR     cookMyGuide1(OP_Context &context);
    virtual OP_ERROR     cookMyGuide2(OP_Context &context);
    virtual OP_ERROR     cookMyGuideList(OP_Context &context,
                            UT_RefArray<GU_DetailHandle> &list);

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

    virtual void         checkInputChanged(int parm_index, int group_type_index,
                            GU_DetailGroupPair &detail_group_pair, 
                            GU_Detail *pgdp, const GB_BaseGroup *group);

    /// The cookInput.+Groups functions are helper functions that look at
    /// your Group Name and Group Type parameters (the offsets for which
    /// are passed in parm_index, for Group Name, and group_type_index,
    /// for group_type), evaluate them, and then call parse.+Group on that
    /// group name. For every method other than cookInputAllGroups, 
    /// group_type_index is used only to determine whether the parm is dirty.
    /// The pointer group is set as a return value, and detail_group_pair
    /// is also initialized if the parms are dirty. detail_group_pair can 
    /// be used later as an argument to checkInputChanged.
    /// If alone is true, we are cooking for a selector, and can't assume that
    /// our gdp is valid (because it might not have been constructed by now).
    /// If allow_reference is true, the group returned may not be modified.
    /// If fetchgdp is true and alone is true, these new groups will be 
    /// created on the input_index-th input (because the gdp isn't constructed 
    /// yet).
    /// If fetchgdp is true and alone is false, false, groups will be 
    /// constructed on the current gdp.
    /// If fetchgdp is false, you must supply a gdp to create groups on in
    /// the paramerer pgdp.
    virtual OP_ERROR     cookInputPrimitiveGroups(OP_Context &context, 
                            const GB_PrimitiveGroup *&group,
                            GU_DetailGroupPair &detail_group_pair,
                            int alone = 0, bool do_selection = true,
                            int input_index = 0, int parm_index = 0,
                            int group_type_index = -1,
                            bool allow_reference = true,
                            bool fetchgdp = true,
                            GU_Detail *pgdp = NULL); 

    /// See cookInputPrimitiveGroups.
    virtual OP_ERROR     cookInputPointGroups(OP_Context &context, 
                            const GB_PointGroup *&group,
                            GU_DetailGroupPair &detail_group_pair,
                            int alone = 0, bool do_selection = true,
                            int input_index = 0, int parm_index = 0,
                            int group_type_index = -1,
                            bool allow_reference = true,
                            bool fetchgdp = true,
                            GU_Detail *pgdp = NULL);

    /// See cookInputPrimitiveGroups.
    virtual OP_ERROR     cookInputEdgeGroups(OP_Context &context,
                            const GB_EdgeGroup *&group,
                            GU_DetailGroupPair &detail_group_pair,
                            int alone = 0, bool do_selection = true,
                            int input_index = 0, int parm_index = 0,
                            int group_type_index = -1,
                            // JML: I do not know why Edge Groups
                            // used Copy instead of the reference version.
                            // They are left like this so as to not cause
                            // problems unforeseen.
                            bool allow_reference = false,
                            bool fetchgdp = true,
                            GU_Detail *pgdp = NULL);

    /// See cookInputPrimitiveGroups. Also, is_default_prim only affects 
    /// cases when we're not able to guess the type of groups; in those 
    /// cases, we try again with primitive groups if is_default_prim is 
    /// true, and point groups otherwise.
    virtual OP_ERROR     cookInputAllGroups(OP_Context &context,
                            const GB_BaseGroup *&group,
                            GU_DetailGroupPair  &detail_group_pair,
                            int alone = 0, bool do_selection = true,
                            int input_index = 0, int parm_index = 0,
                            int group_type_index = -1,
                            bool allow_reference = false,
                            bool is_default_prim = true,
                            bool fetchgdp = true,
                            GU_Detail *pgdp = NULL);

    /// Parse the input group specified by groupname, of type grouptype,
    /// in detail gdp. If allow_reference is true, this group cannot be
    /// later modified. If is_default_prim is true, if the group's type cannot
    /// be guessed, we'll try with a primitive group; otherwise, we'll try
    /// with a point group.
    const GB_BaseGroup *parseInputGroup(const UT_String &groupname,
                            int grouptype, GU_Detail *gdp,
                            bool allow_reference, bool is_default_prim);

private:
    /// Helper function for cookInput.+Groups. You shouldn't need to use it.
    OP_ERROR cookInputGroupsPrologue(OP_Context &context, bool fetchgdp, 
                                     int alone, int input_index,
                                     GU_Detail *&pgdp);

    /// Helper function for cookInput.+Groups. You shouldn't need to use it.
    void cookInputGroupsEpilogue(int parm_index, int group_type_index, 
                                 GU_DetailGroupPair &detail_group_pair,
                                 GU_Detail *pgdp, const GB_BaseGroup *group,
                                 bool fetchgdp, int alone);

protected:
    virtual void         inputConnectChanged(int which_input);

    // If a SOP is instancing another SOPs geometry, this method will be
    // called.  It's up to the instancer to take appropriate action.
    // Currently, the only event types to expect are:
    //  OP_NODE_DELETED         - The sop is being deleted
    //  OP_COOKING_CHANGED      - The sop is being cooked
    virtual void         instanceGeometryChange(SOP_Node *sop,
                                                OP_EventType how);

//_________________________________________________________________________
//
//  Some very useful methods used in cooking SOPs, convenience if you will
//_________________________________________________________________________
//

    // Note that the context parameter is unused!
    const GU_Detail     *inputGeo(int index, OP_Context &)
                         { return inputGeo(index); }
    const GU_Detail     *inputGeo(int index) const;
    GU_DetailHandle      inputGeoHandle(int index) const;

//_________________________________________________________________________
//
//  Convenience Error methods...
//_________________________________________________________________________
//
    void                 addError(int code, const char *msg = 0)
                         { getLockedErrorManager()->addError(SOP_OPTYPE_NAME,
                                                             code, msg); }
    void                 addMessage(SOP_ErrorCodes code, const char *msg = 0)
                         { getLockedErrorManager()->addMessage(SOP_OPTYPE_NAME,
                                                               code, msg); }
    void                 addWarning(SOP_ErrorCodes code, const char *msg = 0)
                         { getLockedErrorManager()->addWarning(SOP_OPTYPE_NAME,
                                                               code, msg); }
    void                 addFatal(SOP_ErrorCodes code, const char *msg = 0)
                         { getLockedErrorManager()->addFatal(SOP_OPTYPE_NAME,
                                                             code, msg); }
    void                 addSystemError(const char *msg = 0)
                         { getLockedErrorManager()->systemError(msg);}
    void                 addCommonError(UT_CommonErrorCode what,
                                        const char *msg = 0)
                         { getLockedErrorManager()->commonError(what, msg);}

    //  Method to get an object's sop (making sure it is up to date)
    //  It will optionally return information about the object if a 
    //  pointer is passed.
    SOP_Node            *getObjectsSopNode(const char *objectName, 
                                           OP_Context &context,
                                           UT_Matrix4 *xform = 0, 
                                           float *rx = 0, 
                                           float *ry = 0, 
                                           float *rz = 0);

    //
    //  Methods for dealing with groups in SOPs

    // We want these public as we it is perfectly fine to use them in
    // static parm templates.  This occurs, for example, when instancing
    // multiparms.
public:
    static PRM_ChoiceList        allGroupMenu;       // All the groups
    static PRM_ChoiceList        groupMenu;          // Prim and point groups
    static PRM_ChoiceList        primGroupMenu;
    static PRM_ChoiceList        pointGroupMenu;
    static PRM_ChoiceList        edgeGroupMenu;
    static PRM_ChoiceList        breakpointGroupMenu;
    static PRM_ChoiceList        primNamedGroupMenu;    // Named prim grps only
    static PRM_ChoiceList        pointNamedGroupMenu;   // Named pt groups only

protected:
    // WARNING:  The groups returned are const and should not be modified
    int                          parseGroups(const char *pattern, 
                                             GU_Detail *gdp,
                                             const GB_PrimitiveGroup *&prim,
                                             const GB_PointGroup *&points,
                                             bool strict = false);

    int                          parseGroupsCopy(const char *pattern, 
                                             GU_Detail *gdp,
                                             GB_PrimitiveGroup *&prim,
                                             GB_PointGroup *&points,
                                             int unify,
                                             bool strict = false);

public:
    // Method to help fill in the menu entries representing attributes
    // It will iterate though the attributes of the 'dictionary' supplied
    // from the input 'input_index'. The 'approve' filter callback is applied 
    // (if present) and if it returns ture for an attribute, this attribute
    // is appended to the 'menu_entries'. If not present, all attributes
    // are appended. The number of entries appended does not exceed
    // 'max_menu_size' (including the terminating sentinel). 'menu_entries' are
    // sorted alphabetically and the function returns the number of entries
    // appended (excluding the terminating sentinel).
    int                  fillAttribNameMenu(PRM_Name *menu_entries, 
                                int max_menu_size,
                                GEO_AttributeOwner dictionary,
                                int input_index,
                                bool (*approve)(const GB_Attribute*,void*)=NULL,
                                void *approve_data = NULL);

    // utility method for sorting group and attribute menus
    static void          sortMenu(PRM_Name *menuEntries, int size);
    // utility method for pruning the duplicate entries in a sorted menu
    static void          removeMenuDuplicates(PRM_Name *menuEntries, int size);

    // approval method for including only user attributes
    static bool          approveUserAttribsOnlyCB(const GB_Attribute *atr,
                                                  void *data);

protected:
    // Obtains offsets to the point and primitive vector attributes.
    // Only vector attributes are considered.
    // NB: it needs access to the gdp, so use it only in the cook methods
    void                 getVectorAttribOffsets( const char * attrib_names,
                                UT_IntArray &point_attrib_offsets,
                                UT_IntArray &prim_attrib_offsets);

    // parses the vector attrib parameter and fills offsets array attrib offsets
    void                 getVectorAttribOffsets(const GB_AttributeDict &dict,
                                const char * attrib_string,
                                UT_IntArray &offsets,
                                UT_String &bad_attribs);

protected:

    // Drag-n-drop receiver functions

    virtual int                 acceptDragDrop(DD_Source &src, const char *l);
    virtual int                 testDragDrop(DD_Source &src);
    virtual void                getDragDropChoice(DD_Source &src,
                                                DD_ChoiceList &choices);

    //  Do the operation on a per group basis instead of unioning them together

    int                          parseEachGroup(const char *pattern,
                                                GroupOperation operation,
                                                void *data, int isPrim,
                                                GU_Detail *pgdp=0,
                                                bool strict = false,
                                                bool allow_adhoc = false);

    // Take an optional group and subdivide it into smaller groups as
    // input to operation

    void                        subdividePrimitiveGroup(
                                        GroupOperation operation,
                                        const GB_PrimitiveGroup *group, 
                                        void *data, int optype, 
                                        int opstep, const char *oplabel,
                                        GU_Detail *gdp=0);
    void                        subdivideMixPrimitiveGroup(
                                        GroupOperation operation,
                                        const GB_PrimitiveGroup *group, 
                                        void *data, int optype, 
                                        int opstep, const char *oplabel,
                                        GU_Detail *gdp=0);
    void                        subdividePointGroup(
                                        GroupOperation operation,
                                        const GB_PointGroup *group, 
                                        void *data, int optype, 
                                        int opstep, const char *oplabel,
                                        GU_Detail *gdp=0);


    // Create an ahdoc (internal) group and add it to the list of adhoc groups.
    // The group will be deleted for you after cooking.
    GB_PrimitiveGroup   *createAdhocPrimGroup (GU_Detail &geo,
                                               const char *p="adhoc")
                         { return myGroupParse.createPrimitiveGroup (geo, p); }
    GB_PointGroup       *createAdhocPointGroup(GU_Detail &geo,
                                               const char *p="adhoc")
                         { return myGroupParse.createPointGroup (geo, p); }
    GB_EdgeGroup        *createAdhocEdgeGroup (GU_Detail &geo,
                                               const char *p="adhoc")
                         { return myGroupParse.createEdgeGroup(geo, p); }
    GB_VertexGroup      *createAdhocVertexGroup (GU_Detail &geo,
                                                 const char *p="adhoc")
                         { return myGroupParse.createVertexGroup(geo, p); }
    GB_BreakpointGroup  *createAdhocBreakpointGroup (GU_Detail &geo, 
                                                     const char *p="adhoc")
                         { return myGroupParse.createBreakpointGroup(geo, p); }

    // This is only called when the instance flag is set.  
    //  The gdp will be modified shortly after this function is called.  After
    //  the return, the gdp member data should contain an empty (or full)
    //  GU_Detail.  Setting the duplicate flag will duplicate the current gdp
    //  in the new one.
    // This used to require one to derive from it to clear references
    //  to myInstanceOp.  This is now handled at this level.
    void                 clearInstance(int duplicate = 0);

    // The duplicate*Source methods take a context paramter but do not
    // use it for anything.
    // The specified input must already be locked.  The context used to
    // lock the input is the context used for duplication.
    OP_ERROR             duplicateSource(unsigned index, OP_Context &context,
                                         GU_Detail *gdp, int clean=1);
    OP_ERROR             duplicateSource(unsigned index, OP_Context &context)
                         { return duplicateSource(index, context, gdp); }

    // Only duplicates the source if the source has changed. Otherwise,
    // it copies the points from the source to our gdp. It's meant to be
    // used by most deformer SOPs, which simply transform the points and
    // or the primitives. We check if any primitive vector attributes
    // are present and if any point attribs exist if wattrib is true.
    //
    // NOTE: Do not use this if you are creating or destroying point
    // attributes.  Its test is only that source size == dest size so
    // is easily fooled.
    //
    // NOTE: While this takes a gdp to operate on, if it is not the SOP's
    // own gdp, it will just do a duplicateSource.
    OP_ERROR             duplicatePointSource(unsigned index, OP_Context &ctx,
                                         GU_Detail *gdp, int clean = 1,
                                         bool wattrib = true,
                                         bool *fully = 0);
    OP_ERROR             duplicatePointSource(unsigned index, OP_Context &ctx)
                         { return duplicatePointSource(index, ctx, gdp); }

    /// @brief Only duplicates the source if the source has changed since the
    /// last call to this method.
    OP_ERROR             duplicateChangedSource(unsigned idx, OP_Context &ctx,
                                        int *changed = 0, bool force=false);

    /// Only duplicates primitives in primgroup from src_gdp to dest_gdp
    OP_ERROR             duplicateSourceGroup(const GU_Detail *src_gdp,
                                          const GB_PrimitiveGroup *primgroup,
                                          GU_Detail *dest_gdp=0);
    
    /// Forces duplicateChangedSource() to do the duplication on its next call.
    void                 resetChangedSourceFlags();

    /// @brief Checks if a duplication will occur on the next call to
    /// duplicateChangedSource().
    ///
    /// Similar to useInputSource() except it doesn't affect the flags. It's
    /// used to simply query whether the given input has changed. Returns false
    /// if there's errors on the input. Upon return, @c changed is updated.
    OP_ERROR             checkChangedSourceFlags(unsigned idx, OP_Context &ctx,
                                        int *changed);

    /// @brief Mark the given input as used for cooking by this node.
    ///
    /// This updates source flags to mark the input as now clean, returning
    /// whether the input has changed since the last time this function was
    /// called. If force is true, then we treat the input as always dirty.
    /// Returns false if the input has errors.
    /// @note duplicateChangedSource() calls this function.
    bool                 useInputSource(unsigned idx, bool &changed, bool force)
                         {
                             return myInputChangeHelper.useInput(
                                                *this, idx, changed, force);
                         }

    ///  @brief Only duplicates the source if the source has changed based on
    ///  input topology.
    // @{
    OP_ERROR             duplicateChangedSource(unsigned idx, OP_Context &ctx,
                                        GU_Topology &tp, int *changed,
                                        GU_Detail *gdp, int clean=1);
    OP_ERROR             duplicateChangedSource(unsigned idx, OP_Context &ctx,
                                        GU_Topology &tp, int *changed=0)
                         { return duplicateChangedSource(idx, ctx, tp, changed,
                                            gdp); }
    // @}
    
    virtual void         deleteCookedData(void);
    virtual int          deleteNodeData(void *);
    virtual void        *copyNodeData  (void *);

    // Convenience wrappers for several common pasting operations. The last
    // method destroys both groups:
    GB_PrimitiveGroup   *getPastedSurfaces(void)
                         {
                             return gdp->getPastedSurfaces("_sop_all_pasted_");
                         }
    GB_PrimitiveGroup   *getPastedSurfaces(GB_PrimitiveGroup *&used)
                         {
                             return gdp->getPastedSurfaces(used, 
                                                     "_sop_all_pasted_",
                                                     "_sop_used_pasted_");
                         }
    void                 updatePastedDisplacement(const GEO_Point &ppt,
                                                const GB_PrimitiveGroup *all,
                                                GB_PrimitiveGroup *used)
                         {
                             gdp->updatePastedDisplacement(ppt, all, used);
                         }
    int                  updatePastedDisplacements(void)
                         {
                             // return 1 if pasted surfaces found
                             return gdp->updatePastedDisplacements();
                         }
    int                  updatePastedDependents(GB_PrimitiveGroup *all,
                                                GB_PrimitiveGroup *used)
                         {
                             // all and used are deleted if they exist
                             return gdp->updatePastedDependents(all, used);
                         }

    // Methods for dealing with group centroid
    void                 convertPivotAboutGroupCentroid(
                                    PRM_Parm &grppivot_parm,
                                    int pivot_parm_idx,
                                    const UT_Vector3 *centroid = 0);
    
    // subclasses override this to return the group centroid if they support
    // it.
    virtual bool         getGroupCentroid(OP_Context & /*context*/,
                                          UT_Vector3 & /*centroid*/)
                                    { return false; }

    //
    //  I/O methods
    //
    virtual OP_ERROR     save(ostream &os, const OP_SaveFlags &flags,
                                        const char *pathPrefix);
    virtual bool         load(UT_IStream &is, const char *extension,
                                           const char *path=0);

    void                 refreshGdp();


    //
    // Data for the SOP class
    //

    // The gdp handle provides a indirect reference to the current
    // gdp of this SOP.
    GU_DetailHandle      myGdpHandle;

    // During cooks, myGdpHandle is writelocked and stored in the
    // gdp variable.  This is to provide backwards compatibility.
    // The gdp variable should not be trusted or accessed elsewhere.
    GU_Detail           *gdp;
    SOP_Guide           *myGuide1;      // primary guide geometry
    SOP_Guide           *myGuide2;      // secondary guide geometry
    SOP_NodeFlags        mySopFlags;

private:
    //
    //  These virtuals are methods that nobody should override...
    //
    //  I/O methods
    //
    virtual OP_ERROR     saveIntrinsic(ostream &os, const OP_SaveFlags &flags);

    virtual bool         loadPacket(UT_IStream &is, short class_id, short sig,
                                    const char *path=0);
    virtual bool         loadPacket(UT_IStream &is, const char *token,
                                    const char *path=0);

    virtual void         clearAndDestroy(void);

    virtual int          saveCookedData(const char *, OP_Context &);
    virtual int          saveCookedData(ostream &os, OP_Context &, int binary = 0);
    virtual bool         loadCookedData(UT_IStream &is, const char *path=0);

    // loadHardCookedData is just like loadCookedData, except it doesn't
    // check if this SOP is softlocked.  Use it only if you know you are
    // loading hardlocked data (as in SOP_UndoModel)
            bool         loadHardCookedData(UT_IStream &is, const char *path=0);

    virtual const char  *getFileExtension(int binary) const;

    int                  softLockable(const GU_Detail &unmodelled_gdp,
                                      const GU_Detail &modelled_gdp) const;
    // take a snapshot of the current gdp and stores the soft lock data.
    // copies the previous slock data to the given reference (so caller
    // can use it for undo)
    // returns 1 on success, 0 otherwise
    int                  storeSoftLockData(OP_Context &context, int prev_lock,
                                           SOP_SoftLockData *old_slockdata=0);

    sopVisualizeCallback *myVisualizeCallback;
    void                 *myVisualizeCallbackData;
    
protected:
    // Return a fresh, empty selection given the specified criterion. The new
    // selection is not assigned to the gdp's selection.  This selection
    // reflects the geometry modified by the sop.
    GU_Selection        *newSelection(GU_SelectionType stype);
    GU_Selection        *newSelection(const GB_BaseGroup &group);


public:
    // Do not use this function! Using it will likely cause crashes.
    virtual void         unloadDataHack();

    virtual bool         unloadData();

    // Returns whether this node currently has cooked data or not.
    bool                 isLoaded() const;

private:
    OP_InputChangeHelper myInputChangeHelper;

    // We store all locked inputs in this list.  We can then allow
    // the same source node to be cooked with different contexts
    // and let copy on write semantics avoid problems.
    // Any non-null handle here has PreserveRequest set and should
    // have it removed before removing.
    UT_PtrArray<GU_DetailHandle *>      myInputGeoHandles;

    GOP_Manager          myGroupParse;
    
    friend class         SOP_UndoModel; // needs access to gdp
    friend class         SOP_CacheManager; // needs access to handle.
    friend class         SOP_CacheData; // needs access to handle.

    //
    // Private data
    //
    SOP_SoftLockData    *mySoftLockData;

    bool                 myHasCookedSelection;

    // the capture override flag is used to indicate wheter the SOPs should
    // use their capture parameters or cook capture geometry. (e.g., 
    // SOP_CaptureRegion). This flag is mirrored from OBJ_Bone, which
    // allows to view bones and capture region in their capture configuration
    static  bool         theGlobalCaptOverride;

protected:
    // Local variable items:
    UT_SymbolTable               myLocalVarTable;
    UT_PtrArray<sopVarInfo *>    myLocalVarArray;
    UT_IntArray                  myInstancingOps;  // Ops instancing my data

    int                          myInstanceOp;   // Which op we are instancing.

    int                          myLocalVarOrder;
    
private:
    const GU_Detail             *myCurGdp[2];
    GU_DetailHandle              myCurGdh[2];

protected:
    const GEO_Vertex            *myCurVtx[2];
    int                          myCurVtxNum[2];
    const GEO_Point             *myCurPt[2];
    const GEO_Primitive         *myCurPrim[2];
    int                          myCurBuiltPtBox[2];
    UT_BoundingBox               myCurPtBox[2];
    int                          myCurBuiltPrimBox[2];
    UT_BoundingBox               myCurPrimBox[2];

    int                          myCurGdpVal;   // Which gdp is being traversed

    // Cached values so we can tell if we have to rebuild.
    int                          myLocalVarOrderCache;
    int                          myCurrentLayerCache;
    // This is all the old attribute information, one for each of the
    // dictionary types...  If this (including the order) matches the
    // new attribute data, no offsets will have changed.
    UT_RefArray<sop_attribRef>   myAttribCache[2][4];
    UT_String                    myVarMapCache[2];
};

// Function to get a list of template arrays containing parm names that must
// be reserved when compiling VEX SOPs.
SOP_API extern void
SOPgetVexReservedTemplateLists(UT_PtrArray<PRM_Template *> &tplatelists);

#endif

---