GU/GU_PointSelection.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_PointSelection (C++)
 *
 * COMMENTS:
 *      Point selection.
 *
 */

#ifndef __GU_PointSelection_h__
#define __GU_PointSelection_h__

#include "GU_API.h"
#include "GU_Selection.h"

#define         GU_pointSelectName "selectedPoints"


class GU_API GU_PointSelection : public GU_Selection
{
public:
    // Class constructor and destructor. The prefix is used for naming the 
    // two internal groups, thePoints and thePrims. If we find the group
    // by the specified name and reset is TRUE, we clear it.
    GU_PointSelection(GU_Detail &gdp, const char *grpname = "_gu_ptselection_",
                      int reset = 0, const char *prefix = 0);
    GU_PointSelection(GU_Detail &gdp, GB_PointGroup &ptgroup,
                      const char *prefix = 0);
    virtual ~GU_PointSelection(void);

    // Use the given group to reset the selection. If 'ref' is 1 we simply
    // grab the group. Otherwise we copy its bits into our group. We update
    // the closure groups.
    void                         useGroup(GB_PointGroup &group,
                                          int ref = 0);

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

    virtual GU_PointSelection   &operator|=(const GB_PointGroup &group);
    virtual GU_PointSelection   &operator-=(const GB_PointGroup &group);
    virtual GU_PointSelection   &operator&=(const GB_PointGroup &group);
    virtual GU_PointSelection   &operator^=(const GB_PointGroup &group);


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

    // This method is static so you can retrieve the pick mask for this type
    // of selection without having an instance of it.
    static int                   pointPickMask(void);

    // 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
    // point 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,
                                        void *&added,
                                        GU_SelectionRule rule   = GU_AddSelect,
                                        unsigned *pickid        = 0,
                                        GU_LassoInfo *linfo     = 0,
                                        const UT_IntArray *prfx = 0);
    virtual int                  selectEntireGeometry(uint *pickbuf,
                                        long npicked,
                                        void *&added,
                                        GU_SelectionRule rule   = GU_AddSelect,
                                        unsigned *pickid        = 0,
                                        GU_LassoInfo *linfo     = 0,
                                        const UT_IntArray *prfx = 0);

    virtual int                  selectBoundary(bool checkuv);
    virtual int                  shrinkSelection(bool checkuv);


    // Get the next/prev selectable point using the specified rule.
    // returns 1 if successful, 0 if not.  shiftstate is 1 if shift is
    // pressed, vstate is ignored.
    virtual int                  selectNext(void *&added, 
                                            GU_SelectionRule    = GU_AddSelect,
                                            int shiftstate      = 0,
                                            int vstate          = 0);

    virtual int                  selectPrev(void *&added, 
                                            GU_SelectionRule    = GU_AddSelect,
                                            int shiftstate      = 0,
                                            int vstate          = 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;

    // 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. We return
    // a pointer to that first something if found. Otherwise we return 0.
    virtual void                *siftThrough(uint *pickbuf, long npicked,
                                        int look_for_existing   = 1,
                                        unsigned *pickid        = 0,
                                        GU_LassoInfo *linfo     = 0,
                                        const UT_IntArray *prfx = 0) const;

    // 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(void *added, unsigned *pickid,
                                                UT_Vector3 &xsect) const;
    virtual int                  selectionPoint(void *added, unsigned *pickid,
                                                UT_Vector3 rayorig, 
                                                UT_Vector3 &raydir, 
                                                UT_Vector3 &xsect,
                                                int        &normal,
                                                UT_Vector3 &vector,
                                                int accurate, float *u,
                                                float *v) const;

    // 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 GB_BaseGroup &group, int ref=0);

    // 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(GEO_Point      &point, int ordered=0);
    virtual int                  add(GEO_Primitive  &prim,  int ordered=0);
    virtual int                  add(GB_Edge        &edge,  int ordered=0);
    virtual int                  add(GEO_Breakpoint &bkp,   int ordered=0);
    virtual int                  add(GB_VertexData &vtx,    int ordered=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(GEO_Point     &point, int ordered=0);
    virtual int                  remove(GEO_Primitive &prim,  int ordered=0);
    virtual int                  remove(GB_Edge      &edge,  int ordered=0);
    virtual int                  remove(GEO_Breakpoint &bkp,   int ordered=0);
    virtual int                  remove(GB_VertexData &vtx,   int ordered=0);

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

    // 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(GEO_Point     &point, int ordered=0);
    virtual int                  toggle(GEO_Primitive &prim,  int ordered=0);
    virtual int                  toggle(GB_Edge      &edge,  int ordered=0);
    virtual int                  toggle(GEO_Breakpoint &bkp,   int ordered=0);
    virtual int                  toggle(GB_VertexData &vtx,   int ordered=0);

    // 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 GB_PointGroup       *updatePoints(void);
    virtual GB_PrimitiveGroup   *updatePrimitives(void);

    // Return a handle to the selected group:
    const GB_PointGroup         *selection(void) const 
                                         {
                                             return theSelection;
                                         }

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

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

    // 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);

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

    // 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;
    virtual int          getBoundingBox(UT_BoundingBox &bbox, const UT_Matrix4& transform ) const;

    // 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;

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

    // Create Geometry from selection; return gdp if successful, 0 otherwise
    virtual GU_Detail   *createGeometry();


    // Query the type of selection:
    virtual int          classType(void) const;

    // Append the labels to avoid conflicts
    virtual void        suffixName(const char *prefix);

    // Create new identical selection as this one in gdp.
    virtual GU_Selection        *newSpecies(GU_Detail &gdp);

protected:
    GB_PointGroup       *theSelection;  // the group of selected points

    // These methods return 1 if the selection has changed and 0 otherwise.
    virtual int          selectAllUsingClosure(
                                            GU_PrimGroupClosure *closure,
                                            int how_to_treat_closure);
    virtual int          toggleAllUsingClosure(GU_PrimGroupClosure *closure,
                                            int how_to_treat_closure);

    // Used to create new species.
    GU_PointSelection(GU_Detail &gdp, const GU_PointSelection &s);

    virtual const GB_BaseGroup  *mainGroup() const { return theSelection; }

    // A utility method to allocate a point reference array only when it is
    // useful for the isPointInLasso() method and populate it only with the
    // minimal set of entries.
    GB_PointRefArray            *allocPointRefArrayForLassoTest(
                                                const GU_LassoInfo *linfo,
                                                uint *pickbuf, long npicked,
                                                const UT_IntArray *prfx) const;

private:
    void                 selectPoint(GEO_Point *point,
                                     GU_SelectionRule rule,
                                     void *&added, int &ret, int ord);
    GU_SelectionResult   selectPointEmpty(GEO_Point *point,
                                     GU_SelectionRule rule,
                                     bool &first) const;
    int                  selectPointAll(GEO_Point *point,
                                     GU_SelectionRule rule,
                                     void *&added);

    short                        theOwnFlag;    // TRUE if we own the group
};

#endif

---