OP3D/OP3D_InputSelector.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:
 *      Luke Moore
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        OP3D_InputSelector.h
 *
 * COMMENTS:
 *      This descendant of BM_InputSelector knows about the viewer.  It uses
 *      the viewer to find out display/current sop and to use the viewer's
 *      selection type buttons.
 */

#ifndef __OP3D_InputSelector_h__
#define __OP3D_InputSelector_h__

#include "OP3D_API.h"
#include <UT/UT_IntArray.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_UndoWorkerFinder.h>
#include <UI/UI_HotkeyHelper.h>
#include <UI/UI_Value.h>
#include <GU/GU_SelectType.h>
#include <OP/OP_Node.h>
#include <DM/DM_Defines.h>
#include "OP3D_InputSelectorBase.h"

class UT_String;
class GU_Detail;
class GU_Selection;
class OP_Node;
class OP_Network;
class SOP_Node;
class OBJ_Node;
class UI_Event;
class UI_Feel;
class GUI_DetailLook;
class GUI_DisplayOption;
class BM_View;
class DM_Viewport;
class DM_Workbench;
class OP3D_View;
class OP3D_CustomToolbox;
class OP3D_InputSelectorUndo;
class OP3D_InputSelectorUndoWorker;
class OP3D_EdgeLoopHelper;
class op3d_BrushData;

typedef bool (*OP3D_ValidForPickFilter)(void *data, GUI_DetailLook *look);

class OP3D_API OP3D_InputSelector : public OP3D_InputSelectorBase
{
public:
             OP3D_InputSelector(OP3D_View &viewer, PI_SelectorTemplate &templ);
    virtual ~OP3D_InputSelector();

    virtual const char  *className() const;

    // The selector handles mouse events and modifies the selection
    // accordingly.  Return 1 if the event was consumed and 0 otherwise.
    virtual int          handleMouseEvent(UI_Event *event);

    // Handle double-click events. Returns true if handled.
    virtual bool         handleDoubleClickEvent(UI_Event *event);

    // Selectors respond to keyboard events to know when to finish a selection
    // stage and possibly enter the next.
    virtual int          handleKeyEvent(UI_Event *event, DM_Viewport &viewport);
    bool                 willHandleKeyEvent(UI_Event *event);

    // Get or set the selection index.  This is the index into the gdp's
    // set of secondary selections.  The selector will use this index to
    // determine which selection to modify.  Only modify this value before
    // any selecting has taken place.  By default the selection index is
    // zero.
    int                  selectionIndex() const { return mySelectionIndex; }
    void                 selectionIndex(int selection_index)
                            { mySelectionIndex = selection_index; }

    // Is the selector required to attach an input node to the current
    // node?  If it is but nothing was selected, an empty model sop will
    // be attached.  By default, an input is not required.
    bool                 inputRequired() const { return myInputRequiredFlag; }
    void                 inputRequired(bool onoff)
                            { myInputRequiredFlag = onoff; }

    // Some sops (eg. group and delete) need a '*' in the input field if
    // everything is selected.  Other sops will operate on everything if
    // the input field is blank.
    bool                 useAsteriskToSelectAll() const
                            { return myUseAsteriskToSelectAll; }
    void                 useAsteriskToSelectAll(bool onoff)
                            { myUseAsteriskToSelectAll = onoff;}

    // Controls whether the selection generated by this selector remembers
    // the order in which the elements were selected.
    bool                 orderedSelector() const
                            { return myOrderedSelectorFlag; }
    void                 orderedSelector(bool onoff)
                            { myOrderedSelectorFlag = onoff; }

    // Specifies whether or not to use primitive id's when selecting edges.
    // This setting allows the selector to distinguish between a general edge
    // (e.g p0-1) and an edge on a primitive (e.g. 0e1)
    void                 usePrimsInEdgeSelections(bool use_prims)
                                  { myUsePrimsInEdgeSelectionFlag = use_prims; }

    // Get or set the primitive mask for picking:
    unsigned             primMask() const { return myPrimMask; }
    void                 primMask(unsigned primmask)
                            { myPrimMask = primmask; }

    void                 setPickAtObjLevel(bool flag)
                            { myPickAtObjLevelFlag = flag; }
    bool                 getPickAtObjLevel() const
                            { return myPickAtObjLevelFlag; }
    
    // The selector needs to be notified when it starts/stops selecting
    // so it can add/remove interests (the selection type, etc.).  If
    // copy_cooked_selection is set, the cooked selection of the currently
    // displayed sop will initially be selected.
    virtual void         startSelecting(bool copy_cooked_selection = true);
    virtual void         stopSelecting();
    void                 addCookedSelection( SOP_Node *sop );

    void                 nodeIdForReselecting(int node_id)
                            { myNodeIdForReselecting = node_id; }

    // Clear the selections of the selection.  This method is called when,
    // for example, the selection stages are aborted.
    virtual void         clearSelections();

    // This method allows the resource manager can set the workbench to
    // something different if a selector is reused.  It should not be used
    // otherwise.  A nil pointer is allowed so the select can remove any
    // of its interests.  However, methods of the selector should never be
    // called when its workbench is nil.  The method is virtual so
    // descendants can also have a chance to clean up.
    virtual void         setViewer(BM_View *viewer);

    // This method must be called after retrieving a new/recycled selector
    // from the resource manager.
    void                 setSelectionUIValues(UI_Value *sel_type,
                                              UI_Value *sel_rule,
                                              UI_Value *sel_style,
                                              UI_Value *sel_full,
                                              UI_Value *locate_always,
                                              UI_Value *finished);
    // Set the name of the creator state.
    void                 setCreatorStateName(const char *state_name)
                         { myCreatorStateName.harden(state_name); }
    const UT_String     &creatorStateName()     
                         { return myCreatorStateName; }

    // Can this selector use a box or lasso for picking, or just click picks?
    void                 allowDragSelect(bool yesno) 
                         { myAllowDragSelFlag = yesno; }

    // Should this selector only select the fulle geometry:
    void                 selectFullGeometry(bool yesno)
                         { myFullSelFlag = yesno; }

    // Should this selector save undo information?
    void                 saveUndos(bool yesno) { mySaveUndosFlag = yesno; }
    bool                 saveUndos() const     { return mySaveUndosFlag; }

    // Render all the gdp's in the viewport for picking.  This needs to be
    // public so it can be called from a static function.
    void                 renderForPicking(RE_Render *r, short x, short y);

    // Generate merge(s) and connect them to the given op, filling in the
    // specified input parm with the selection.  If there is a menu in the
    // op that needs to be set and menu_idx is not null, the value menu_idx
    // points to will be set to a non-negative index into the menu.  If menu_idx
    // is not null but there is no menu, *menu_idx = -1.
    // If the selection consists of the entire gdp, the group field
    // will is filled with an empty string.  To force it to be filled
    // with a string (even for the entire gdp), use force_selection_string.
    bool                 connectOps(OP_Node &new_node, int op_input_index,
                                    const UT_String &input_parm,
                                    bool update_sel_buttons = true,
                                    int *menu_idx = 0,
                                    bool branch_off = false,
                                    bool multi_input = false,
                                    bool force_selection_string = false);

    // Return an array of op ids from which we have selected.
    const UT_StringArray&selectedOpPaths() const
                         { return mySelectedOpPaths; }
    void                 setSelectedOpPaths(const UT_StringArray &paths)
                         { mySelectedOpPaths = paths; }
    const UT_IntArray   &selectedSelInstances() const
                         { return mySelectedSelInstances; }
    void                 setSelectedSelInstances(const UT_IntArray &selinsts)
                         { mySelectedSelInstances = selinsts; }
    void                 addSelectedPath(const char *path, int selinstance,
                                         GU_Selection *sel);
    void                 movePathToEnd(const char *path);
    void                 removeSelectedPath(const char *path);

    // The state needs to be able to get the current prompt and set the default
    // prompt.  The custom message is for the selector, and the default message
    // is displayed by the state.  The default prompt is passed on by the state
    // and should not be changed.  If you make the const versions public and
    // the non-const versions private it won't compile, so they're all public.
    const UT_String     &currentPrompt() const { return myCurrentPrompt; }
          UT_String     &currentPrompt()       { return myCurrentPrompt; }
    const UT_String     &defaultPrompt() const { return myDefaultPrompt; }
          UT_String     &defaultPrompt()       { return myDefaultPrompt; }

    // Clean up when selector is about to transmit done event. If drag is
    // true, the selector indicates to the state that the selection should
    // be dragged right away.
    void                 selectorFinished(bool drag = false);

    // This static version of getSelection() will create the selection for an
    // arbitrary selection index and selection type.
    static GU_Selection *getSelection(GU_Detail &gdp,
                                      int &selinst,
                                      int selection_index,
                                      GU_SelectionType sel_type,
                                      GU_SelectionConnectivity connectivity,
                                      bool isview3d,
                                      bool create_selection);

    // Create an object merge for the given object-sop combination, or combine
    // the given path into the network if do_combine is true. In that case,
    // the sop path and selection instance is updated to point to the moved 
    // sop.
    static SOP_Node     *createObjectMerge(OP_Network *network,
                                           UT_String &path,
                                           int &selinst,
                                           int selindex,
                                           const UT_String &creator_state_name,
                                           bool keep_original_objects,
                                           bool display_origina_objects);

    // Override the undo worker that gets used for undos. Pass in NULL to use
    // a default worker.
    void                 setUndoWorker(OP3D_InputSelectorUndoWorker *worker=0);
    // Sets and returns a default undo worker.
    OP3D_InputSelectorUndoWorker *getDefaultUndoWorker();

    // Return the feel containing the RMB menu.
    virtual UI_Menu     *getSelectorMenu() const;
    virtual UI_Menu     *getSelectorHotkeyMenu() const;

    virtual void         doRender(RE_Render *r, short x, short y, int ghost);

    void                 setValidForPickFilter(void *data,
                                               OP3D_ValidForPickFilter filter);

    // Get or set the current selection type or selection rule explicitly.
    // Setting the selection type will change the selection type for all
    // displayed geometry and all geometry that has been selected.
    void                 setGeometryType(DM_GeometryType geo_type,
                                          bool connected,
                                          bool update_buttons);
    GU_SelectionType     selectionType() const;

    // Get the component type as it was set when the selection was completed.
    DM_GeometryType      getGeometryTypeAtFinish() const;
    bool                 getConnectedAtFinish() const;
    int                  getGroupTypeMenuValAtFinish() const;
    bool                 getKeepOriginalObjects() const;

    // Return whether or not the current viewport is a 3D viewer.
    bool                         getIsView3D();
    // Get the connectivity of the current viewport of our scene manager.
    GU_SelectionConnectivity     getConnectivity();

    static GU_SelectionConnectivity getConnectivity(DM_Workbench &bench);

    const DM_GeometryTypeArray  &getSelectionAllowedTypes() const;
    void                         setSelectionAllowedTypes(
                                    const DM_GeometryTypeArray &allowedtypes);

    // Modifies all existing selections so that they become valid selections.
    // The passed in bestseltype is given preference, but may be changed if
    // that exact type isn't valid. The group_type_menu_val returns the
    // value that a SOPs group type menu parm should be set to match the
    // resulting selection type.
    virtual void         makeValidSelections(DM_GeometryType &geo_type,
                                            bool &connected,
                                            int &group_type_menu_val) = 0;
    // This function converts selections into the requested type, and
    // matching the specified primitive mask.
    static void          makeSelectionsValid(const UT_StringArray &paths,
                                            const UT_IntArray &selinstances,
                                            int selindex,
                                            DM_GeometryType geo_type,
                                            bool connected,
                                            GU_SelectionConnectivity connect,
                                            bool isview3d,
                                            unsigned primmask,
                                            OP3D_InputSelector *selector);

    // This function uses the above stati function to generate a single
    // selection string for all selections merged into a single detail.
    virtual void         generateAllSelectionStrings(UT_String &sel_string,
                                            bool destroy_selections,
                                            bool only_one_gdp);
    // For the given selection index, generate a string that will correspond to
    // either the given gdp or the merged gdp containing all visible gdp's.
    // Returns true if the whole gdp was selected.
    static bool          generateSelectionString(UT_String &sel_string,
                                            const GU_Detail &gdp,
                                            GU_Selection &selection,
                                            int prim_offset,
                                            int point_offset,
                                            bool collapse_where_possible,
                                            bool use_ast_to_select_all);
    static void          generateMergedSelectionString(UT_String &sel_string,
                                            UT_StringArray &paths,
                                            UT_IntArray &selinstances,
                                            int selindex,
                                            bool collapse,
                                            bool use_ast_to_select_all);

    // Convert to the given selection type for one gdp. Returns true if the
    // type actually needed to be changed and false otherwise.
    static bool          convertSelectionType(GU_Detail &gdp,
                                              GU_SelectionType stype,
                                              GU_SelectionConnectivity c,
                                              bool view3d,
                                              int selinst,
                                              int selindex);

    // Convert to a particular geometry selection from the given list of
    // objects
    static bool         createSelectionFromObjects(
                                    const OP_NodeList &objects,
                                    DM_Viewport &viewport,
                                    DM_GeometryType geo_type,
                                    int selindex,
                                    GU_SelectionConnectivity connectivity,
                                    bool is_view3d,
                                    UT_StringArray &paths,
                                    UT_IntArray &selinsts);

protected:
    // React to the user pressing a button to change the component type.
    virtual void         handleSelectionTypeChange(UI_Event *event);

    // Called when the selection changes and nothing is removed.  Added_geo is
    // a pointer to the added geometry, allowing derived classes to process it 
    // if they so wish.
    virtual void         addToSelection(UI_Event * /*event*/,
                                        const char * /*path*/,
                                        int /*selinst*/,
                                        void * /*added_geo*/)
                            { }

    // Use the contents of the pick buffer to modify the selections.  Return
    // true if the selection has changed and false otherwise.
    virtual bool         modifySelections(UI_Event *event,unsigned *pick_buffer,
                                   int num_picked, GU_SelectionRule sel_rule,
                                   int num_lasso_points, int *lasso_points,
                                   op3d_BrushData *brushdata);

    // Handle a pick during which nothing was selected.  Return true if 
    // any changes were made to the existing selections.
    virtual bool         handleNoPick(UI_Event *event);

    // Insert additional nodes between the last created node and the
    // state's node.
    virtual void         appendToLastNode(SOP_Node *&/*input_node*/,
                            const UT_String &/*creator_state_name*/,
                            bool /*branch_off*/) {}

    // Add additional input nodes for the new node.
    virtual void        generateAdditionalInputNodes(SOP_Node & /*new_node*/,
                            SOP_Node * /*last_selected_node */,
                            const UT_String & /*sel_string*/,
                            const UT_String & /*creator_state_name*/) {}

    // Modify default parameters if necessary.
    virtual void         setNodeParameters(OP_Node &) {}

    // Return the pick mask of the current selection type.  This is the mask
    // to be used to select entities that the selection knows how to handle.
    int                  pickMask() const;

    // Return the gdp's selection that corresponds to the given selection
    // index.  If create_selection is true, then the selection will be created
    // if it doesn't exist.  Otherwise, a nil pointer might be returned.
    GU_Selection        *getOrCreateSelection(GU_Detail &gdp, int &selinst);
    GU_Selection        *getExistingSelection(GU_Detail &gdp, int selinst);

    // THESE TWO METHODS ARE DEPRECATED.
    // Overriding selection type in this manner is dangerous as there
    // is no guarantee the button bar will remain disabled.
    // If you find yourself wanting to use this (ie: MSS_JoinSelector)
    // your selector is likely a state in disguise.
    
    // This method is called to overwrite UI values.  Disables the
    // toolbox which allows the user to change the values.
    void                 overrideSelectionValues(int sel_type, int sel_rule,
                                                 int sel_style, int sel_full,
                                                 int locate);
    // Restore the values indicated by the UI.
    void                 restoreSelectionValues();

    // Override switchToChosenOp so we can adopt the cooked selection after
    // switching objects.
    virtual OP_Node     *switchToChosenOp(OP_Node *parent);

    // Save the contents of the selector so later changes can be undone/redone.
    virtual void         saveForUndo();

    // Implements the getPickName function to return the string representation
    // of a pick id.
    virtual bool         getPickName(const OP3D_PickId &pickid,
                                     UT_String &name,
                                     bool descriptivename) const;

    virtual bool         needObjectPick() const;

    // Clear the selections of all the gdp's with selections in them.
    // This method is called when failing to select something at all.
    bool                 emptySelections(const char *path_to_skip = 0,
                                         bool refresh = true);

    // Destroy the temporary selection of the gdp.
    void                 destroySelection(GU_Detail &gdp, int selinst);
    void                 dirtySelection(GU_Detail &gdp, int selinst);

    // Clear the mySelectedOpPaths and mySelectedSelInstances arrays.
    void                 clearSelectionArrays();


private:    // methods
    void                 handleStartSelecting(UI_Event *event);

    // Rather than putting the undo code in this file, it's in a friend class.
    friend class         OP3D_InputSelectorUndo;

    // Return true if the selection has changed and false otherwise.
    bool                 singleSelectGeometry(UI_Event *event, bool save_undo);
    bool                 boxSelectGeometry(UI_Event *event,
                                           short xcenter, short ycenter,
                                           short xsize, short ysize);
    bool                 lassoSelectGeometry(UI_Event *event,
                                             int *lasso_points);
    bool                 brushSelectGeometry(UI_Event *event,
                                            char *enablemap,
                                            int minx, int miny,
                                            int maxx, int maxy);
    bool                 selectGeometry(UI_Event *event,
                                        short xcenter=0, short ycenter=0,
                                        short xsize=0, short ysize=0,
                                        bool box_pick=false,
                                        int num_lasso_points=0,
                                        int *lasso_points=0,
                                        op3d_BrushData *brushdata = 0);

    /// Handles a toggle from the "Select Whole Geometry" menu option
    void                 fullSelectionChanged(UI_Event *);

    // For the given (temporary) selection index, copy the selection from
    // one gdp to the other.  The source and destination gdp's must have
    // the same topology.
    void                 copyAllSelections(GU_Detail &dest_gdp,
                                           GU_Detail &source_gdp,
                                           int &selinst);
    void                 copySelection(GU_Detail &dest_gdp,
                                       GU_Detail &source_gdp,
                                       int selection_index,
                                       int &selinst);

    // Select everything that's visible in the viewport, select nothing, or
    // toggle the selections of everything in the viewport.
    void                 selectAllOrNoneOrToggle(OP3D_SelectionAction action,
                                                 DM_Viewport &viewport);

    // Select the boundary of the current selection.  This means
    // everything which is selected and has a neighbour which is
    // unselected.
    void                 selectBoundary(DM_Viewport &viewport);
    void                 shrinkSelection(DM_Viewport &viewport);
    void                 growSelection(DM_Viewport &viewport);


    // Select everything that's visible in the uv viewport, but only if the
    // face has a specific winding (orientation).
    void                 uvSelectAllByWinding(DM_Viewport &viewport,
                                              bool front_facing,
                                              bool back_facing);

    virtual void         handleBoxPickEvent(UI_Event *event);
    virtual void         handleLassoPickEvent(UI_Event *event);
    virtual void         handleBrushPickEvent(UI_Event *event);

    // Respond to the user using the group selector (choosing a group,
    // hiding the selection, etc.).
    void                 handleGroupSelectorAction(UI_Event *event);
    void                 handleGroupSelection(UI_Event *event);
    void                 handleSelectionHideOrExpose(UI_Event *);

    // Should we allow picking from this GUI_DetailLook?  (eg. Templates
    // can't be picked from, and ordered selectors need to pick from the
    // merges, even if the inputs of the merges are displayed.)
    bool                 validForPickRender(GUI_DetailLook *detail,
                                            const GUI_DisplayOption &dopt);

    // Is any of the geometry visible on the screen selected?
    bool                 isAnythingSelected();

    // Set the parameters in the visibility sop to match the action being
    // performed.
    void                 setVisibilitySopParameters(SOP_Node &visibility_sop,
                                                bool exposing,
                                                bool applying_to_selection,
                                                int  viewport_type,
                                                bool cumulative,
                                                const UT_String &sel_string);

    OP3D_EdgeLoopHelper &getEdgeLoopHelper();

    SOP_Node *           findChosenSop(bool &need_object_pick);
    void                 handleSwitchToChosenOp(UI_Event *event);

    int                  doPick(UI_Event *event,
                                short xcenter, short ycenter,
                                short xsize, short ysize,
                                bool box_or_lasso_pick, 
                                bool pick_objects_only,
                                bool pick_alternate_objects,
                                uint prim_mask, int pick_mask,
                                uint *&pick_buffer);

    void                 doneNormalSelection();

    // Obtains the current selection from our viewport using our current
    // selection index. Returns true if we should allow auto-finishing.
    // We also return the have_temp_sel flag which is true if we found any
    // temp selection, including empty ones.
    bool                 addOpPathsForVisibleSelection(SOP_Node *chosen_sop,
                                                       bool &have_temp_sel);

    void                 handleGeoChanged(UI_Event *event);

    void                 updateSelectMask();

    static OP_Node *     mergeViaCombine(float t,
                                         OP_Network *network,
                                         UT_String &path,
                                         int &selinst,
                                         int selindex,
                                         const UT_String &creator_state_name);

    // Hotkey methods
    static UI_HotkeyHelper::Entry   theHotkeyList[];

    bool                acceptKey(UI_Event *event);
    bool                fullSelectionKey(UI_Event *event);
    bool                keepOriginalObjKey(UI_Event *event);
    bool                locateKey(UI_Event *event);
    bool                selectAllKey(UI_Event *event);
    bool                invertSelectionKey(UI_Event *event);
    bool                selectNoneKey(UI_Event *event);
    bool                selectBoundaryKey(UI_Event *event);
    bool                shrinkSelectionKey(UI_Event *event);
    bool                growSelectionKey(UI_Event *event);
    bool                selectUVSelectAllFrontKey(UI_Event *event);
    bool                selectUVSelectAllBackKey(UI_Event *event);

private:    // data

    UI_HotkeyHelper      myHotkeyHelper;
    DM_Viewport         *myHotkeyViewport;

    UT_String            myCurrentPrompt;
    UT_String            myDefaultPrompt;

    UT_String            myCreatorStateName;

    UI_Value            *myGeoChangedValue;
    UI_Value            *mySelectionType;       // prims, points, etc.
    UI_Value            *myFullSelection;       // select whole gdp
    UI_Value            *myAlwaysLocate;        // always do locating

    // When overriding the values indicated by the UI buttons for the
    // above, keep previous values so we can restore.
    bool                 myCustomSelValFlag;
    int                  mySavedSelType;
    int                  mySavedSelRule;
    int                  mySavedSelStyle;
    int                  mySavedFullSel;
    int                  mySavedAlwaysLocate;

    unsigned             myPrimMask;            // polygon, nurbs, etc.
    
    UT_StringArray       mySelectedOpPaths;     // array of selected op paths
    UT_IntArray          mySelectedSelInstances;// array of selection instances
    int                  mySelectionIndex;      // index into set of selections

    int                  myLastMouseDown;       // needed for changed events
    int                  myLastMouseStartX;     //   "     "     "      "
    int                  myLastMouseStartY;     //   "     "     "      "

    UT_String            myGroupName;

    int                  myNodeIdForReselecting;// reselecting for this node

    bool                 myInputRequiredFlag;   // is an input op required?
    bool                 myAllowDragSelFlag;    // allow box/lasso selecting?
    bool                 myFullSelFlag;         // do only full selections?
    bool                 mySaveUndosFlag;       // save undo information?
    bool                 myOrderedSelectorFlag; // sels from diff gdp's ordered?
    bool                 myUseAsteriskToSelectAll; // use '*' to select all?
    bool                 myUsePrimsInEdgeSelectionFlag; // use primitives when
                                                // selecting edges (e.g. 0e1)
    bool                 myPickAtObjLevelFlag;  // pick geo at OBJ level

    // After we finish selecting we must remember our type.
    DM_GeometryType      myFinishGeometryType;
    bool                 myFinishConnected;
    int                  myFinishGroupTypeMenuVal;

    // Component type of current selection.
    DM_GeometryType      myLastGeometryType;
    bool                 myLastConnected;

    bool                 myPickObjectsOnly;
    bool                 myCopyCookedSelection;
    bool                 myHadDoubleClick;
    bool                 myAlternatePick;

    OP3D_InputSelectorUndoWorker        *myUndoWorker;
    bool                                 myOwnUndoWorker;
    DM_GeometryTypeArray                 myAllowedTypes;

    // Utility for edge loops
    OP3D_EdgeLoopHelper                 *myEdgeLoopHelper;
    OP3D_ValidForPickFilter              myValidForPickFilter;
    void                                *myValidForPickFilterData;
};

#endif

---