GU/GU_EdgeSplit.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:
 *      George ElKoura
 *      Side Effects Software Inc.
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        SOP Library (C++)
 *
 * COMMENTS: Splits edges.
 *
 */

#ifndef __GU_EdgeSplit_h__
#define __GU_EdgeSplit_h__

#include "GU_API.h"
#include <UT/UT_IntArray.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_RefArray.h>
#include <UT/UT_VectorTypes.h>

class   GB_EdgeGroup;
class   GB_PointGroup;
class   GB_PrimitiveGroup;
class   GEO_Closure;
class   GEO_Point;
class   GEO_PointRefArray;
class   GEO_PrimPoly;
class   GU_Detail;
class   GU_SplitHistory;
class   GU_SplitHistoryNode;
class   GU_SplitLoc;
class   GU_SplitPath;
class   GU_SplitPathNode;
class   GU_SplitPathManager;
class   gu_PrimToUpdate;
class   gu_CrossEdge;


// This class defines a split location.  It represents a place where a split
// will occur.  A list of these things is what we need to make a complete
// cut.  
class GU_API GU_SplitLoc
{
public:
    GU_SplitLoc(GEO_Point *p0 = 0, GEO_Point *p1 = 0, 
                float t = 0.0F, GEO_PrimPoly *poly = 0) :
                myP0(p0), myP1(p1), myT(t), myPoly(poly) 
                { }

    GU_SplitLoc   &operator=(const GU_SplitLoc &src)
                   {
                       myP0   = src.myP0;
                       myP1   = src.myP1;
                       myT    = src.myT;
                       myPoly = src.myPoly;
                       return *this;
                   }
    unsigned int   operator==(const GU_SplitLoc &src) const;
    unsigned int   operator!=(const GU_SplitLoc &src) const
                   {
                       return !(operator==(src));
                   }

    UT_Vector4     getPos() const;
    void           print() const;       // TODO: debug only

    GEO_Point     *myP0;
    GEO_Point     *myP1;
    float          myT;
    GEO_PrimPoly  *myPoly;
};
typedef UT_PtrArray<GU_SplitLoc *>      GU_SplitLocPtrArray;



// The UpdatePrimList is the list kept of all the prims that must be
// updated once the split is over.  These prims are not involved in any
// split, but have been affected by a split (probably because they share
// an edge that was split.)
class GU_API gu_UpdatePrimList
{
public:
    ~gu_UpdatePrimList();

    UT_PtrArray<gu_PrimToUpdate *>  myList;

    void    updatePrims(const GU_SplitHistory &hist, const GU_Detail &gdp,
                        float tolerance);

    // Adds to list primlist the polygons that will be getting point pt
    void    getPrimsUsingPoint(const GEO_Point *pt, UT_IntArray &primlist);
};
        
// GU_SplitPath is the path that must be taken to execute a single split.
// Each node represents a split that occurs within one polygon.
// If the split is successfully completed then the last node should represent
// the last polygon to be split.
//typedef UT_PtrArray<gu_PathNode *>    GU_SplitPath;
// Now defined in GU_Detail.h

class gu_PrimDistance;


// EdgeSplit workhorse.
class GU_API GU_EdgeSplit
{
public:
     GU_EdgeSplit(GU_Detail &gdp, GB_EdgeGroup *outedges = 0);
    ~GU_EdgeSplit();

    void        doSplit(const GU_SplitLocPtrArray &splitlocs, bool force, 
                        bool quadcut, float tolerance);

private:

    // This method takes both inputs, converts them to an edge split location,
    // if necessary, and calls splitEdge
    // The parameters:
    //      from            - from location
    //      to              - to location
    //      path            - current path so far
    //      quadcut         - true if we are quadcuttin', false otherwise
    //      findingtail     - true if we are looking for our tail
    //      pointpass       - serial number of passing the responsibility to
    //                        other primitives and avoid infinite recursion.
    void        split(const GU_SplitLoc &from, const GU_SplitLoc &to, 
                      GU_SplitPath *&path, bool quadcut, bool findingtail,
                      int pointpass);
    int         simplify(GU_SplitLoc &from, GU_SplitLoc &to);

    void        splitPoly(GEO_PrimPoly &poly, int fromedge, int toedge, 
                          float fromt, float tot, 
                          GEO_Point *newpt0, GEO_Point *newpt1);

    // Returns true if the node was added to the path
    bool        addPathNode(const GU_SplitLoc &from, const GU_SplitLoc &to,
                            GU_SplitPath &path);

    void        updateNeighbourPrims(const GU_SplitLoc &splitloc);

    bool        restructureSplit(GU_SplitHistoryNode *stn, GU_SplitLoc &loc);
    void        executePath(GU_SplitPath &path);
    bool        getTransferCandidates(const GU_SplitLoc &from, 
                                      GB_PrimitiveGroup &grp);
    bool        transferLoc(GU_SplitLoc &loc, GEO_PrimPoly *poly);
    bool        inPath(GEO_PrimPoly *poly, const GU_SplitPath &path);
    void        pruneGroup(const GU_SplitLoc &fromloc, const GU_SplitLoc &toloc,
                           UT_IntArray &primlist, bool quadcut);

    void        getEdgeCandidates(const GU_SplitLoc &loc, 
                                  const UT_Vector4 &src, const UT_Vector4 &dest,
                                  UT_RefArray<gu_CrossEdge> &arr,
                                  bool quadcut);

    void        sortEdgeCandidates(const GU_SplitLoc &loc, 
                                   const UT_Vector4 &dest,
                                   UT_RefArray<gu_CrossEdge> &arr);

    void        getPrimCandidates(const GEO_PrimPoly *poly, GEO_Point *pt0,
                                  GEO_Point *pt1,const GU_SplitPath &path,
                                  UT_IntArray &candidates, bool quadcut);

    GEO_Point  *getNewPoint(GEO_Point *pt0, GEO_Point *pt1, float t);

    int         buildFromPrimArray(const GU_SplitLoc &fromloc, 
                                   const GU_SplitLoc &toloc, 
                                   UT_IntArray &fromlist,
                                   UT_PtrArray<gu_PrimDistance *> &primarray,
                                   bool quadcut);

    // Takes the path and fills it with the correctly interpolated biases for
    // quad cuts.  The quadclosed flag indicates whether or not the path is
    // a closed loop.  The findingtail flag indicates whether or not we were
    // trying to find our tail (single-click quadcut).
    void        quadProcessPath(GU_SplitPath &path, bool quadclosed,
                                bool findingtail);

    void        getParticipatingPolys(const GU_SplitLoc &loc, 
                                      GEO_Closure &closure, UT_IntArray &prims);


    // Data Members
    GEO_PointRefArray           *myPointRefArr;
    GB_PrimitiveGroup           *myTempPrimGrp;
    GB_PointGroup               *myNewPointsGrp;
    gu_UpdatePrimList            myUpdatePrimList;
    GU_SplitHistory             *myHistory;
    GU_Detail                   &myGdp;
    GU_SplitPathManager         *mySplitPathMan;
    GB_EdgeGroup                *myOutEdges;
    bool                         myForceCut;
    float                        myTolerance;
};

#endif

---