GU/GU_Selection.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:
 *      Cristin Barghiel
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        GU_Selection (C++)
 *
 * COMMENTS:
 *      Base class of a gdp selection. This clas hides the actual type
 *      of selection (point, edge, primitive, etc)
 *
 */

#ifndef __GU_Selection_h__
#define __GU_Selection_h__

#include "GU_API.h"
#include "GU_SelectType.h"
#include <UT/UT_BoundingBox.h>
#include <UT/UT_Color.h>
#include <UT/UT_Defines.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_String.h>
#include <UT/UT_Vector4Array.h>
#include <UT/UT_VectorTypes.h>
#include <GA/GA_EdgeGroup.h>
#include <GA/GA_ElementGroup.h>
#include <GA/GA_BreakpointGroup.h>
#include <GEO/GEO_Vertex.h>
#include "GU_SelectType.h"

class UT_JSONWriter;
class UT_JSONParser;
class GA_Edge;
class GA_GBPointRefArray;
class GA_VertexGroup;
class GEO_Point;
class GA_Breakpoint;
class GEO_Breakpoint;
class GEO_Primitive;
class GEO_Vertex;
class GU_PolyRaster;
class GU_CurveNetworkParms;
class GU_Detail;
class GU_BreakpointSelection;
class GU_PointSelection;
class GU_PrimSelection;
class GU_EdgeSelection;
class GU_VertexSelection;
class GU_PointGroupSelection;
class GU_PrimGroupSelection;
class GU_PrimGroupClosure;
class GU_LassoInfo;
class GU_RayIntersect;
class GU_PrimGroupClosure;
class GU_Selection;

class GU_API GU_SelectResult
{
public:
    GU_SelectResult()
        : mySet(false)
        , myPrimitive(0)
        , myPoint(0)
        , myGroupType(GA_GROUP_INVALID)
    {}
    ~GU_SelectResult() {}

    void                set(const GA_Breakpoint &b)
                        {
                            myBreakpoint = b;
                            myGroupType = GA_GROUP_BREAKPOINT;
                        }
    void                set(const GA_Edge &e, GA_Primitive *prim = 0)
                        {
                            myEdge = e;
                            myPrimitive = prim;
                            myGroupType = GA_GROUP_EDGE;
                        }
    void                set(GA_Primitive *prim)
                        {
                            myPrimitive = prim;
                            myGroupType = GA_GROUP_PRIMITIVE;
                        }
    void                set(GEO_Point *pt)
                        {
                            myPoint = pt;
                            myGroupType = GA_GROUP_POINT;
                        }
    void                set(const GEO_Vertex &v)
                        {
                            myVertex = v;
                            myGroupType = GA_GROUP_VERTEX;
                        }

    const GA_Breakpoint &getBreakpoint() const  { return myBreakpoint; }
    const GA_Edge       &getEdge() const        { return myEdge; }
    GA_Primitive        *getPrimitive() const   { return myPrimitive; }
    GEO_Point           *getPoint() const       { return myPoint; }
    GA_Offset            getPointOffset() const
                            {
                                return (myPoint
                                        ? myPoint->getMapOffset()
                                        : GA_INVALID_OFFSET);
                            }
    const GEO_Vertex    &getVertex() const      { return myVertex; }

    bool                isSet() const           { return myGroupType != GA_GROUP_INVALID; }
    GA_GroupType        getSelectType() const   { return myGroupType; }
    void                clear()                 { myGroupType = GA_GROUP_INVALID; }
private:
    GA_Breakpoint        myBreakpoint;
    GA_Edge              myEdge;
    GA_Primitive        *myPrimitive;
    GEO_Point           *myPoint;
    GEO_Vertex           myVertex;
    GA_GroupType         myGroupType;
    bool                 mySet;
};

class GU_API GU_SelectionList : public UT_PtrArray<GU_Selection *>
{
public:
                 GU_SelectionList()
                 { }
    virtual     ~GU_SelectionList()
                 { }
};

class GU_API GU_Selection
{
public:
    // Class constructor and destructor. The prefix is used for naming the 
    // two internal groups, myPoints, myPrims.
    GU_Selection(GU_Detail &gdp, const char *prefix);
    virtual ~GU_Selection(void);


    // Return a new selection of the specified type.  The creator prefix and
    // the suffix are used in naming the primitive and point groups of the
    // selection.
    static GU_Selection         *newSelection(GU_Detail &gdp,
                                              GU_SelectionType stype,
                                              const char *creator_prefix,
                                              const char *suffix = 0);
    static GU_Selection         *newSelection(GU_Detail &gdp,
                                              const GA_Group &group,
                                              const char *creator_prefix,
                                              const char *suffix = 0);

    static GU_Selection         *newSelection(GU_Detail &dst_gdp,
                                              const GU_Detail &src_gdp,
                                              const GU_Selection &src_sel,
                                              const char *creator_prefix,
                                              const char *suffix = 0);

    // Change the type of a gdp's selection.  If the list index is negative,
    // the selection type of the main gdp's selection will be changed.  If
    // the list index is non-negative and invalid, nothing will be done.
    // Otherwise, the selection in the selection list will be changed.
    // True is returned if a change was made and false otherwise.
    static bool                  changeSelectionType(GU_Detail &gdp,
                                              GU_SelectionType stype,
                                              GU_SelectionConnectivity ctype,
                                              bool view_3d,
                                              const char *creator_prefix,
                                              const char *suffix = 0,
                                              int list_index = -1,
                                              int sel_instance = -1);

    // Copy the contents of one selection to another, doing any conversions
    // that are necessary. This assumes that they are from the same gdp.
    static void                  copySelection(GU_Selection &destination,
                                               GU_Selection &source);

    // Return the pick mask that corresponds to the given selection type.
    static int                   pickMaskForSelType(GU_SelectionType stype);

    // Return the base selection type for a given selection type and whether
    // it is a connected type. For example, GU_SPrimGroup, GU_SConnectedPrim,
    // and GU_SPrimitive all have base selection types of GU_SPrimitive.
    static GU_SelectionType      baseSelectionType(GU_SelectionType stype,
                                                   bool &out_connected);

    // Return the base selection type for a given selection type.  For
    // example, GU_SPrimGroup, GU_SConnectedPrim, and GU_SPrimitive all
    // have base selection types of GU_SPrimitive.
    static GU_SelectionType      baseSelectionType(GU_SelectionType stype)
                                    {
                                        bool  f;
                                        return baseSelectionType(stype, f);
                                    }

    // Return the full selection type given the basic type.
    static GU_SelectionType      fullSelectionType(GU_SelectionType base_type,
                                                   bool connected);

    // Conversion methods. These methods update the point and primitive
    // closures, but not the stash array.
    virtual GU_Selection        &operator=(GU_PointSelection &) = 0;
    virtual GU_Selection        &operator=(GU_PrimSelection  &) = 0;
    virtual GU_Selection        &operator=(GU_EdgeSelection  &) = 0;
    virtual GU_Selection        &operator=(GU_BreakpointSelection &) = 0;
    virtual GU_Selection        &operator=(GU_VertexSelection &) = 0;
    virtual GU_Selection        &operator=(GU_PointGroupSelection &);
    virtual GU_Selection        &operator=(GU_PrimGroupSelection  &);

    // Return the pick mask to be used to select entities that this selection
    // knows how to handle:
    virtual int                  pickMask(void) const = 0;

    // Return the mask of entities that, if picked, would definitely cause
    // us to self pick. Things that we can partially be picked on (such as
    // edge maybe) should not be added to this mask. We definitely can't
    // snap to points, prims, and guides.
    virtual int                  selfSnapMask(void) const;

    // Use the pick buffer to update your selection according to the given
    // rule. Return 1 if the selection has changed and 0 otherwise. The first
    // entity to be added to us (if any), is returned in 'added', and so is
    // the pickid unless the pointer to is is zero.
    virtual int                  select(uint *pickbuf, long npicked,
                                        GU_SelectResult &added,
                                        GU_SelectionRule rule   = GU_AddSelect,
                                        unsigned *pickid        = 0,
                                        GU_LassoInfo *linfo     = 0,
                                        const UT_IntArray *prfx = 0) = 0;
    virtual int                  selectEntireGeometry(uint *pickbuf,
                                        long npicked,
                                        GU_SelectResult &added,
                                        GU_SelectionRule rule   = GU_AddSelect,
                                        unsigned *pickid        = 0,
                                        GU_LassoInfo *linfo     = 0,
                                        const UT_IntArray *prfx = 0) = 0;

    // The following methods are used for arrow-key selection.
    // "shiftstate" should be 1 if shift is pressed, vstate is 1 if the
    // up/down keys were used as opposed to the left/right keys.
    // Both return 0 if no next/prev selectable exists, or 1 if there was
    // something to select, and it was selected.
    virtual int                  selectNext(GU_SelectResult &added,
                                        GU_SelectionRule rule   = GU_AddSelect,
                                        int shiftstate          = 0,
                                        int vstate              = 0) = 0;

    virtual int                  selectPrev(GU_SelectResult &added,
                                        GU_SelectionRule rule   = GU_AddSelect,
                                        int shiftstate          = 0,
                                        int vstate              = 0) = 0;

    // Use the pick buffer to check how the selection would be affected
    // by the given rule. If an add is performed it will return 
    // GU_SelectionAdd regardless of whether any removes are performed.
    // The selections are not affected.
    virtual GU_SelectionResult  selectEmpty(uint *pickbuf, long npicked,
                                        GU_SelectionRule rule   = GU_AddSelect,
                                        unsigned *pickid        = 0,
                                        GU_LassoInfo *linfo     = 0,
                                        const UT_IntArray *prfx = 0) const = 0;

    // Use the pick buffer to find out if it contains something we've got
    // selected or anything that we don't have in the selection. The result is
    // set to the first something found.  Return false if nothing was found.
    virtual bool                siftThrough(GU_SelectResult &result,
                                        uint *pickbuf, long npicked,
                                        int look_for_existing   = 1,
                                        unsigned *pickid        = 0,
                                        GU_LassoInfo *linfo     = 0,
                                        const UT_IntArray *prfx = 0) const = 0;

    // Find the actual point picked in the selection: this could be a GEO 
    // point, a point on a normal, curve, edge, etc. 'added' indicates
    // what has been picked. 'pickid' is the type of hit that generated the
    // pick, and 'xsect' is the picked point (to be found). The methods return
    // 1 if xsect can be determined and 0 otherwise. If the 'xsect' is not
    // found, the 2nd method computes the bounding box of 'added' and returns
    // that one instead.
    virtual int                  selectionPoint(const GU_SelectResult &added,
                                                unsigned *pickid,
                                                UT_Vector3 &xsect) const = 0;
    virtual int                  selectionPoint(const GU_SelectResult &added,
                                                unsigned *pickid,
                                                UT_Vector3 rayorig, 
                                                UT_Vector3 &raydir, 
                                                UT_Vector3 &xsect,
                                                int        &normal,
                                                UT_Vector3 &vector,
                                                int accurate, float *u,
                                                float *v) const = 0;

    // Select the contents of the group even if the group type does not
    // match our type. Return 1 if the selection has changed, 0 otherwise.
    // If we can use group as our main group without further ado, do so
    // as long as we can reference it (ref != 0).
    virtual int         selectGroup(const GA_Group &group, int ref=0)=0;
            int         addGroup(const GA_Group &group);

    // Add some geo entity to the selection. Each selection class will 
    // interpret the insertion in its own way. For example, by inserting a
    // GEO_Point into a primitive selection we actually insert all the prims
    // that share that point. Conversely, by inserting a GEO_Primitive into
    // a point selection we actually insert all the prim's points. The methods
    // return 1 if something has been added and 0 otherwise.
    // These methods do NOT update the point and primitive closure, just in
    // case you are doing multiple adds.
    virtual int         add(const GEO_Point &point, int order=0) = 0;
    virtual int         add(const GEO_Primitive &pr, int order=0) = 0;
    virtual int         add(const GA_Edge &edge, int order=0) = 0;
    virtual int         add(const GA_Edge &edge, GEO_Primitive &prim,
                            int order=0) = 0;
    virtual int         add(const GA_Breakpoint &bkp, int order=0) = 0;
    virtual int         add(const GEO_Vertex &vtx, int order=0) = 0;

    // Remove some geo entity from the selection. Each selection class will 
    // interpret the removal in its own way. For example, by removing a
    // GEO_Point from a primitive selection we actually remove all the prims
    // that share that point. Conversely, by removing a GEO_Primitive from
    // a point selection we actually remove all the prim's points. The methods
    // return 1 if something has been removed and 0 otherwise.
    // These methods do NOT update the point and primitive closure, just in
    // case you are doing multiple removals.
    virtual int         remove(const GEO_Point &point, int order=0) = 0;
    virtual int         remove(const GEO_Primitive &prim, int order=0) = 0;
    virtual int         remove(const GA_Edge &edge, int order=0) = 0;
    virtual int         remove(const GA_Edge &edge, GEO_Primitive &prim,
                               int order=0) = 0;
    virtual int         remove(const GA_Breakpoint &bkp, int order=0) = 0;
    virtual int         remove(const GEO_Vertex &vtx, int order=0) = 0;

    // Remove the last element in the selection. Return 1 if we're removed
    // successfully and 0 otherwise.
    virtual int         removeLast(void) = 0;

    // Toggle some geo entity in the selection. Each selection class will 
    // interpret the toggle in its own way. For example, by toggling a
    // GEO_Point in a primitive selection we actually toggle all the prims
    // that share that point. Conversely, by toggling a GEO_Primitive in
    // a point selection we actually toggle all the prim's points. The methods
    // return 1 if something has been toggled and 0 otherwise.
    // These methods do NOT update the point and primitive closure, just in
    // case you are doing multiple toggles.
    virtual int         toggle(const GEO_Point &point, int order=0) = 0;
    virtual int         toggle(const GEO_Primitive &prim, int order=0) = 0;
    virtual int         toggle(const GA_Edge &edge, int order=0) = 0;
    virtual int         toggle(const GA_Edge &edge, GEO_Primitive &prim,
                               int order=0) = 0;
    virtual int         toggle(const GA_Breakpoint &bkp, int order=0) = 0;
    virtual int         toggle(const GEO_Vertex &vtx, int order=0) = 0;

    // Select all the points in the gdp. Return 1 if the selection has changed
    // and 0 otherwise.
    enum { WITHIN_CLOSURE, EXCLUDE_CLOSURE };
    int                          selectAll()
                            { return selectAllUsingClosure(0, WITHIN_CLOSURE); }

    // Toggle the selection. Return 1 if something has been toggled and 0
    // otherwise.
    int                          toggleAll()
                            { return toggleAllUsingClosure(0, WITHIN_CLOSURE); }

    // These methods return 1 if the selection has changed and 0 otherwise.
    int                          selectAllExcept(GU_PrimGroupClosure &closure)
                    { return selectAllUsingClosure(&closure, EXCLUDE_CLOSURE); }
    int                          selectAllWithin(GU_PrimGroupClosure &closure)
                    { return selectAllUsingClosure(&closure, WITHIN_CLOSURE); }
    int                          toggleExcept(GU_PrimGroupClosure &closure)
                    { return toggleAllUsingClosure(&closure, EXCLUDE_CLOSURE); }
    int                          toggleWithin(GU_PrimGroupClosure &closure)
                    { return toggleAllUsingClosure(&closure, WITHIN_CLOSURE); }

    // This method is used to select the boundary.  It only acts
    // outside the given closure.
    virtual int         selectBoundary(bool /*checkuv*/)
                    { return 0; }
    virtual int         shrinkSelection(bool /*checkuv*/)
                    { return 0; }


    // The following methods are used for selected front/back facing faces
    // (in the UV sense).
    int         uvSelectAllFrontFace()
            { return uvSelectAllByWindingUsingClosure( 0, WITHIN_CLOSURE,
                                                       true, false); }
    int         uvSelectAllBackFace()
            { return uvSelectAllByWindingUsingClosure( 0, WITHIN_CLOSURE,
                                                       false, true); }
    int         uvSelectAllFrontFaceWithin(GU_PrimGroupClosure &closure)
            { return uvSelectAllByWindingUsingClosure( &closure,
                                                       WITHIN_CLOSURE,
                                                       true, false); }
    int         uvSelectAllBackFaceWithin(GU_PrimGroupClosure &closure)
            { return uvSelectAllByWindingUsingClosure( &closure,
                                                       WITHIN_CLOSURE,
                                                       false, true); }

    // Point and primitive closure groups:
    GA_PointGroup                       *points(void) const;
    GA_PrimitiveGroup                   *primitives(void) const;
    virtual GA_VertexGroup              *vertices(void) const;
    virtual const GA_EdgeGroup          *edges(void) const;
    virtual const GA_BreakpointGroup    *breakpoints(void) const;

    // The cached point and primitive groups are used during rendering.
    // Instead of having to look up the primitive/point groups by name
    // via the primitives()/points() methods, we look them up once
    // at the beginning of the render and cache them.
    void                                 updateCachedPoints();
    void                                 updateCachedPrimitives();
    GA_PointGroup                       *cachedPoints() const
                                            { return myCachedPointGroup; }
    GA_PrimitiveGroup                   *cachedPrimitives() const
                                            { return myCachedPrimitiveGroup; }

    // Update (and possibly create) the internal lists of data. The points
    // and primitives are groups of closures, ie. points and primitives that
    // the selection "touches". The stashed array is used for transformations.
    // The updates are independent of each other, so don't rely on one taking
    // care of the others as well. Make sure you update the stashed array last.
    virtual GA_PointGroup       *updatePoints(void) = 0;
    virtual GA_PrimitiveGroup   *updatePrimitives(void) = 0;
    virtual void                         updateStashed(void);

    // Apply the stashed geometry to the gdp geometry. Return 0 if all goes
    // OK and -1 if we don't have a stashed array or if the array length
    // doens't look good.
    virtual int                          applyStashed(void);

    // Just clear the bits of the groups, or destroy the internal groups and
    // arrays too.
    virtual void         clear(void);
    virtual void         clearAndDestroy(void);

    // Notify the selection that the underlying detail may have changed
    // topology, so cached structures may now be obsolete.
    virtual void         topologyChanged() {}

    // Destroy the underlying geometry and update the groups. Return 0 if OK
    // and -1 otherwise.
    virtual int          destroyGeometry(void) = 0;

    // Copy the geometry found in the selection. Create n copies laid out
    // 'delta' units apart. Return 0 if successful or else -1.
    virtual int          copyGeometry(int copies = 1, UT_Vector3 *delta = 0,
                                      const char *groupname = 0) = 0;

    // Reverse the order of vertices in the selected geometry.
    virtual void         reverse();

    // How many entries does the selection contain?
    virtual int          entries(void)   const = 0;

    // Compute the bounding box of the selection, and return 0 if the box 
    // is empty and 1 otherwise.
    virtual int          getBoundingBox(UT_BoundingBox &bbox) const = 0;
    virtual int          getBoundingBox(UT_BoundingBox &bbox,
                                        const UT_Matrix4R &transform) const = 0;

    // Compute the UV bounding box of the selection, and return 0 if the
    // box is empty and 1 otherwise.
    virtual int          getBoundingBoxUV(UT_BoundingBox &bbox,
                                          const char *name,
                                          int isvertex) const = 0;

    // I/O methods, returning 0 if OK and -1 otherwise:
    bool         saveSelection(ostream &os, bool binary) const;
    bool         loadSelection(UT_IStream &is);

    // Human-readable output of the selection for debugging purposes
    void                 dump(ostream &os) const;

    // Create independent geometry from selextion,
    // return gdp if successful, 0 otherwise
    virtual GU_Detail   *createGeometry();

    // Query the type of selection:
    virtual int          classType(void) const = 0;
    int                  baseClassType() const
    { return GU_Selection::baseSelectionType((GU_SelectionType)classType()); }

    // Creates a duplicate selection identical to this one in the passed in
    // gdp.
    virtual GU_Selection *newSpecies(GU_Detail &gdp) = 0;

    // Returns the group containing the selection.
    virtual const GA_Group      *mainGroup() const = 0;

    // Methods to set and query the connectivity of the selection.
    // Setting the connectivity does not change the current selection, but
    // will affect the subsequent operations.
    GU_SelectionConnectivity     getConnectivity() const
                                 { return myConnectivity; }
    void                         setConnectivity(GU_SelectionConnectivity c,
                                                 bool view_3d);

    // Returns whether the 3D visibility group should be used for connectivity
    // information.  This method returns false when the 2D visibility group 
    // should be used instead.
    bool                         get3DVisibilityFlag() const
                                 { return my3DVisibilityFlag; }


    // Flags that control edge selections and wether or not they should include
    // primitive ids.  These are only handled by Edge selectors.
    virtual void         setUsePrimEdges(bool /*use_prim_edges*/) { }
    virtual bool         getUsePrimEdges() const { return false; }

    void                         setPickOrder(int pick_order)
                                    { myPickOrder = pick_order; }
    int                          getPickOrder() const
                                    { return myPickOrder; }
    
protected:
    /// Convenience method to make/clear ordered status of a group
    void                setOrdered(GA_ElementGroup &g, int ordered)
                        {
                            if (ordered)
                                g.makeOrdered();
                            else
                                g.clearOrdered();
                        }

    /// @{
    /// Save/load the contents of the selection
    bool                jsonSave(UT_JSONWriter &w,
                                const GA_SaveMap &map) const;
    bool                jsonLoad(UT_JSONParser &p,
                                const GA_LoadMap &map);
    /// @}
    /// @{
    /// Save/load class specific data elements.
    virtual bool        savePrivate(UT_JSONWriter &w,
                                const GA_SaveMap &map) const;
    virtual bool        loadPrivate(UT_JSONParser &p,
                                const GA_LoadMap &map);
    /// @}


    GU_Selection(GU_Detail &gdp, const GU_Selection &s);

    // We must switch to the protected section to declare this unnamed
    // enumerated type so we can call it from public methods.
    virtual int                  selectAllUsingClosure(
                                            GU_PrimGroupClosure *closure,
                                            int how_to_treat_closure) = 0;
    virtual int                  toggleAllUsingClosure(
                                            GU_PrimGroupClosure *closure,
                                            int how_to_treat_closure) = 0;

    virtual int                  uvSelectAllByWindingUsingClosure(
                                            GU_PrimGroupClosure *closure,
                                            int how_to_treat_closure,
                                            bool front_facing,
                                            bool back_facing);

          GU_Detail             &gdp(void)              { return myGdp; }
    const GU_Detail             &gdp(void) const        { return myGdp; }

    GA_PointGroup       *safePoints() const;
    GA_PrimitiveGroup   *safePrimitives() const;

    UT_Vector4Array     *stashed(void) const    { return myStashed; }

    void                         createStashed(int size);

    int                          isPointInLasso(const UT_Vector4 &pos,
                                                GU_LassoInfo  *linfo,
                                                GU_PolyRaster *&praster) const;
    int                          isPointInLasso(const GEO_Point &point,
                                                GU_LassoInfo  *linfo,
                                                GU_PolyRaster *&praster,
                                                const GA_GBPointRefArray *ptref
                                                 = 0) const;
    int                          isVertexInLasso(const GEO_Vertex &vtx,
                                                 GU_LassoInfo *linfo,
                                                 GU_PolyRaster *&praster) const;

    static bool                  getPrefixIsValid(const UT_IntArray *prfx,
                                                  int items, int minrealitems,
                                                  uint *&pickidstart);

private:
    /// @{
    /// Call saveSelection() instead.
    /// Sub-classes should implement savePrivate() instead.
    class io_deprecated {};
    virtual io_deprecated       save(ostream &os, int binary) const;
    virtual io_deprecated       load(UT_IStream &is);
    /// @}

    GU_Detail                   &myGdp; // gdp selection belongs to
    UT_String                    myPoints;      // name of point closure
    UT_String                    myPrims;       // name of primitive closure
    UT_Vector4Array             *myStashed;     // stashed point values

    GA_PointGroup               *myCachedPointGroup;
    GA_PrimitiveGroup           *myCachedPrimitiveGroup;

    GU_SelectionConnectivity     myConnectivity;

    // This flag is used to determine whether the connectivity selectors
    // should use 3D or 2D visibility groups for connectivity information.
    bool                         my3DVisibilityFlag;

    int                          myPickOrder;
};

// This handles general stencil masks to apply to the selection.
class GU_API GU_LassoInfo
{
public:
    GU_LassoInfo() { myPolyRaster = NULL; }
    ~GU_LassoInfo() {}

    // This assigns a lasso:
    void         assign(int *lasso_points, int lasso_size,
                    void (*ptmap)(const UT_Vector3 &, float &,float &, void *),
                    void *viewer, void *workbench, 
                    bool (*zmap)(const GU_Detail *, float, float, 
                                 const UT_Vector3 &, void *, void *,
                                 GU_PrimGroupClosure *,
                                 const GEO_Primitive *),
                    int use_uv, int is_vertex)
                 {
                    myLassoPoints       = lasso_points;
                    myEnableMap         = 0;
                    myLassoSize         = lasso_size;
                    myMapFct            = ptmap;
                    myViewer            = viewer;
                    myWorkbench         = workbench;
                    myZDepthFct         = zmap;
                    myHidden            = 0;
                    myUseUV             = use_uv;
                    myIsVertexAttrib    = is_vertex;
                    myAttribOffset.clear();
                 }

    // THis assigns a brush lookup:
    void         assign(char *enablemap, int minx, int miny, int maxx, int maxy,
                    void (*ptmap)(const UT_Vector3 &, float &,float &, void *),
                    void *viewer, void *workbench, 
                    bool (*zmap)(const GU_Detail *, float, float, 
                                 const UT_Vector3 &, void *, void *,
                                 GU_PrimGroupClosure *,
                                 const GEO_Primitive *),
                    int use_uv, int is_vertex)
                 {
                    myLassoPoints       = 0;
                    myEnableMap         = enablemap;
                    myMinX              = minx;
                    myMinY              = miny;
                    myMaxX              = maxx;
                    myMaxY              = maxy;
                    myMapFct            = ptmap;
                    myViewer            = viewer;
                    myWorkbench         = workbench;
                    myZDepthFct         = zmap;
                    myHidden            = 0;
                    myUseUV             = use_uv;
                    myIsVertexAttrib    = is_vertex;
                    myAttribOffset.clear();
                 }

    void         setHidden(GU_PrimGroupClosure *hidden) { myHidden = hidden; }

    // Lasso information:
    int         *myLassoPoints;
    int          myLassoSize;

    // Enable map information:
    char        *myEnableMap;
    int          myMinX, myMinY, myMaxX, myMaxY;

    void        *myViewer, *myWorkbench;
    GU_PrimGroupClosure *myHidden;

    // Attribute information we need when selecting in a UV viewport:
    int          myUseUV;
    int          myIsVertexAttrib;
    GA_ROAttributeRef   myAttribOffset;

    void (*myMapFct)(const UT_Vector3 &, float &,float &, void *);
    bool (*myZDepthFct)(const GU_Detail *, float, float, const UT_Vector3 &,
                        void *, void *, GU_PrimGroupClosure *, 
                        const GEO_Primitive *);

    GU_PolyRaster * createPolyRaster();
    void         buildPolyRaster();
    void         destroyPolyRaster();
    int          polyRasterContains( const UT_Vector3 &pos );

private:
    GU_PolyRaster * myPolyRaster;
};

#endif

---