GU/GU_VolumeBreak.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:
 *      Crawford Doran & Tom S. H. Lee
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        GU_VolumeBreak.h ( GU Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GU_VolumeBreak__
#define __GU_VolumeBreak__

#include "GU_API.h"
#include <GEO/GEO_PrimList.h>
#include <UT/UT_HashTable.h>
#include <UT/UT_RefArray.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_FloatArray.h>

class GU_Detail;
class GEO_Point;
class GEO_PrimVolume;
class GEO_PrimPoly;

enum guBreakPolyType
{
    GU_INSIDE_POLY,
    GU_OUTSIDE_POLY,
    GU_UNKNOWN
};

enum guBreakPointStatus
{
    GU_INTERIOR_POINT,
    GU_VERTEX_POINT
};

struct guBreakPoly;

struct guBreakPoint
{
    // The break point is either on the edge interior or on a vertex.
    guBreakPointStatus   status;

    // The point.
    GEO_Point           *pt;

    // If status is InteriorPoint: the adjacent points.
    // If status is VertexPoint:   the same point, i.e. pt1 = pt2.
    GEO_Point           *pt1;
    GEO_Point           *pt2;

    // The adjacent break points determined while splitting.
    guBreakPoint        *prev;
    guBreakPoint        *next;

    // The associated polygons.
    UT_PtrArray<guBreakPoly *>          polys;
};

struct guBreakPoly
{
    // The poly is classified as inside or outside the SDF volume.
    guBreakPolyType      type;

    // The polygon.
    GEO_PrimPoly        *poly;

    // The associated break points.
    UT_PtrArray<guBreakPoint *>         points;
};

typedef UT_PtrArray<guBreakPoint *> guBreakPointArray;
typedef UT_PtrArray<guBreakPoly *> guBreakPolyArray;

enum guLoopCloseMethod
{
    GU_NO_CLOSE,
    GU_FLAT_CLOSE,
    GU_APEX_CLOSE,
    GU_MULTIAPEX_CLOSE,
    GU_GRADIENT_CLOSE
};



class GU_API GU_VolumeBreak
{
public:
    GU_VolumeBreak();
    virtual ~GU_VolumeBreak();

    void setGroups(const GB_PrimitiveGroup *agrp)       { myGrp = agrp; }
    void setSnapDistance(fpreal snapdistance)   { myTol = snapdistance; }
    void setKeepInside(bool inside)             { myKeepInside = inside; }
    void setKeepOutside(bool outside)           { myKeepOutside = outside; }
    void setCloseGeometry(bool closegeo)        { myCloseGeo = closegeo; }
    void setCloseHoles(guLoopCloseMethod closemethod)
                                                { myCloseMethod = closemethod; }

    void volumeBreak(GU_Detail &gdp, GEO_PrimVolume &volume,
            GB_PrimitiveGroup *ingrp, GB_PrimitiveGroup *inclgrp,
            GB_PrimitiveGroup *outgrp, GB_PrimitiveGroup *outclgrp);


private:
    GU_Detail           *myGdp;
    GEO_PrimVolume      *myVolume;

    const GB_PrimitiveGroup     *myGrp;

    fpreal               myTol;
    bool                 myKeepInside;
    bool                 myKeepOutside;
    bool                 myCloseGeo;
    guLoopCloseMethod    myCloseMethod;

    // Hash of edges to be broken.  Used to maintain a unique list.
    UT_HashTable                myEdgeTable;

    // List of all break points.
    UT_PtrArray<guBreakPoint *> myPointList;

    // List of all polygons, including those with no break points.
    UT_PtrArray<guBreakPoly *>  myPolyList;

    // Point distances indexed by point num.
    UT_FloatArray               myPointDistances;

    void                clearPointList();
    void                clearPolyList();
    void                printPointList();
    void                printPolyList();

    static void         addBreakPoint(GEO_Primitive &prim,
                                GEO_Point &pa, GEO_Point &pb, void *data);

    // Decide whether to add break point at given vertex, and if so, do it.
    //static int                addVertexBreakPoint(const GB_Vertex &v, void *data);

    // Decide whether to add break point to given edge, and if so, do it.
    //static void               addInteriorBreakPoint(GEO_Primitive &prim,
                                //GEO_Point &pa, GEO_Point &pb, void *data);
    
    // Find the break point location on the edge given two points.
    GEO_Point *         makeBreakPoint(GEO_Point *pt1, GEO_Point *pt2);

    int                 findRoot(const GEO_PrimVolume &volume,
                                const UT_Vector3 &in1, fpreal indist1,
                                const UT_Vector3 &in2, fpreal indist2,
                                UT_Vector3 &out,
                                int maxiters = 100);

    int                 findRoot(const GEO_PrimVolume &volume,
                                const UT_Vector3 &origin,
                                const UT_Vector3 &dir,
                                UT_Vector3 &out,
                                int maxiters = 100);

    int                 fusePoints(guBreakPoly *poly);

    // Iteratively call splitClosedPoly or splitOpenPoly.
    int                 splitPoly(guBreakPoly *poly);

    // Split into one poly free of break points and a second remaining poly.
    // The resulting polygons are either all open or all closed.
    int                 splitClosedPoly(guBreakPoly *poly, bool &finished);

    // Split into one poly free of break points and a second remaining poly.
    // The resulting polygons are open.
    int                 splitOpenPoly(guBreakPoly *poly, bool &finished);

    // Sort the list of break points with respect to the given polygon.
    // This sorts each break point internally as well as the list itself.
    void                sortBreakPoints(guBreakPoly *poly);
    
    void                findLoops(UT_RefArray<guBreakPointArray> &loops,
                                guBreakPointArray &breakpoints);

    int                 closeLoops(UT_RefArray<guBreakPointArray> &loops,
                                GU_Detail &gdp, GEO_PrimVolume &sdf,
                                UT_PtrArray<GEO_PrimPoly *> &closurepolys);

    guBreakPolyType     classifyPoly(guBreakPoly *poly);

    GEO_PrimPoly *      createPolygon(GU_Detail &gdp,
                                GEO_PrimPoly *srcpoly = 0,
                                bool preservegroups = true);

    GEO_PrimPoly *      createPolygon(GU_Detail &gdp,
                                const UT_PtrArray<GEO_Vertex *> &vtxes,
                                bool closed,
                                GEO_PrimPoly *srcpoly = 0,
                                bool preservegroups = true);

    int                 linkBreakPoints(guBreakPoint *p1, guBreakPoint *p2);
    bool                linkExistsInPoly(guBreakPoint *pt, guBreakPoly *p);
};

struct guPolyApplyData
{
    GU_VolumeBreak      *breaker;
    guBreakPoly         *poly;
};



#endif

---