GU/GU_BreakpointSelection.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_BreakpointSelection (C++)
 *
 * COMMENTS:
 *      Breakpoint selection.
 *
 *      For the purposes of breakpoint selection, for closed curves and
 *      wrapped surfaces, the last breakpoint is ignored.  It is considered
 *      identical to the first breakpoint.
 *
 */

#ifndef __GU_BreakpointSelection_h__
#define __GU_BreakpointSelection_h__

#include "GU_API.h"
#include <GB/GB_BreakpointGroup.h>
#include "GU_Selection.h"

#define GU_breakpointSelectName "selectedBreakpoints"
class GEO_Curve;
class GEO_TPSurf;

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

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

    // 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                   breakpointPickMask(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
    // edge 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                  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 inserion 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 = 0);
    virtual int                  add(GEO_Primitive &prim,  int = 0);
    virtual int                  add(GB_Edge      &edge,  int = 0);
    virtual int                  add(GEO_Breakpoint &bkp,   int = 0);
    virtual int                  add(GB_VertexData &vtx,   int = 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 = 0);
    virtual int                  remove(GEO_Primitive &prim,  int = 0);
    virtual int                  remove(GB_Edge      &edge,  int = 0);
    virtual int                  remove(GEO_Breakpoint &bkp,   int = 0);
    virtual int                  remove(GB_VertexData &vtx,   int = 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 = 0);
    virtual int                  toggle(GEO_Primitive &prim,  int = 0);
    virtual int                  toggle(GB_Edge      &edge,  int = 0);
    virtual int                  toggle(GEO_Breakpoint &bkp,   int = 0);
    virtual int                  toggle(GB_VertexData &vtx,   int = 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);
    virtual void                 updateStashed(void);

    // 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 -1 because we can't create breakpoints.
    virtual int          copyGeometry(int copies = 1, UT_Vector3 *delta = 0,
                                      const char *groupname = 0);
    
    // Find out if the selection contains this breakpoint. WARNING: this method
    // is slower than what you may expect because it checks if the breakpoints
    // are identical point by point. Returns it if found, 0 otherwise.
    GEO_Breakpoint       *find(const GEO_Breakpoint &b) const;

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

    // Return a _const_ handle to the selected breakpoints:
    const UT_LinkList  &getSelection(void) const { return theSelection.list(); }

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


    virtual const GB_BreakpointGroup    *breakpoints(void) const;

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

    // The breakpoint counts will be one less if the curve is closed or the
    // surface is wrapped.  We consider the first and last breakpoints to be 
    // the same in this instance.
    int                 findFirstBreakpoint(GEO_Primitive &prim, GEO_Breakpoint &bkp,
                                            int &ubcount, int &uvcount, 
                                            int direction);

    int                 getEndBreakpoint(GEO_Primitive &prim, GEO_Breakpoint &bkp,
                                         int &ubcount, int &uvcount, 
                                         int direction);

    int                 getNextBreakpoint(GEO_Primitive &prim, GEO_Breakpoint &bkp, 
                                          int ubcount, int vbcount, int direction);
        

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

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

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

    int                 addPrimBreakpoints   (GEO_Primitive &prim);
    int                 removePrimBreakpoints(GEO_Primitive &prim);
    int                 togglePrimBreakpoints(GEO_Primitive &prim);

    int                 addCurveBreakpoints(GEO_Curve *curve,
                                            int vindex);
    int                 addSurfaceBreakpoints(GEO_TPSurf *surf,
                                              int row, int col);

    void                translateCurve(GEO_Curve *curve, 
                                       const UT_Vector3 &delta);
    void                translateSurface(GEO_TPSurf *surf,
                                         const UT_Vector3 &delta);
    void                transformCurve(GEO_Curve *curve,
                                       const UT_Matrix4 &matx);
    void                transformSurface(GEO_TPSurf *surf,
                                         const UT_Matrix4 &matx);

    GB_BreakpointGroup           theSelection; // Group of selected breakpoints
};

#endif

---