GU/GU_PrimSelection.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_PrimSelection (C++)
 *
 * COMMENTS:
 *      Primitive selection.
 *
 */

#ifndef __GU_PrimSelection_h__
#define __GU_PrimSelection_h__

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

#define GU_primSelectName       "selectedPrims"


class GU_API GU_PrimSelection : 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_PrimSelection(GU_Detail &gdp, const char *grpname = "_gu_pmselection_",
                     int reset = 0, const char *prefix = 0);
    GU_PrimSelection(GU_Detail &gdp, GB_PrimitiveGroup &ptgroup,
                     const char *prefix = 0);
    virtual ~GU_PrimSelection(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_PrimitiveGroup &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_PrimSelection    &operator|=(GB_PrimitiveGroup &group);
    virtual GU_PrimSelection    &operator-=(GB_PrimitiveGroup &group);
    virtual GU_PrimSelection    &operator&=(GB_PrimitiveGroup &group);
    virtual GU_PrimSelection    &operator^=(GB_PrimitiveGroup &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                   primitivePickMask(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
    // primitive 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);

    // Select the next/prev primitive.  Returns 1 if successful, 0 if not.
    // vstate is ignored for primitive selections, shiftstate represents the
    // state of the shift key.
    virtual int                  selectNext(void *&added,
                                            GU_SelectionRule rule= GU_AddSelect,
                                            int shiftstate       = 0,
                                            int vstate           = 0);

    virtual int                  selectPrev(void *&added,
                                            GU_SelectionRule rule= 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 otdered=0);
    virtual int                  add(GB_VertexData &vtx,   int otdered=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.
    // The updatePoints method also updates the shared primitive closure.

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

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

    // Filter the selection to contain only the primitive types in the
    // mask (if 1) or to remove any primitive whose id matches the mask (if 0).
    // The method returns 1 if the selection has changed as a result of this,
    // and 0 otherwise. This methods updates the closure groups.
    int                  filterPrimitives(int primmask, int inOut=1);

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

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

    // 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:
    // Used to create new species.
    GU_PrimSelection(GU_Detail &gdp, const GU_PrimSelection &s);

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

    GB_PrimitiveGroup   *theSelection;  // the group of selected primitives

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

    int                  isPrimInLasso(const GEO_Primitive *prim,
                                       GU_LassoInfo *linfo,
                                       GU_PolyRaster *&praster) const;


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

#endif

---