GU/GU_Cookie.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:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GU_Cookie.h ( GU Library, C++)
 *
 * COMMENTS:  The infamous Cookie operator.  This allows you to
 *              crease or cut two gdps groups with each other.
 */

#ifndef __GU_Cookie__
#define __GU_Cookie__

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

class GU_Detail;
class GU_RayIntersect;
class GB_PrimitiveGroup;
class GB_PointGroup;
class GEO_Vertex;
class GEO_PrimPoly;
class UT_Vector2;
class UT_Thing;
class UT_HashTable;
class UT_Hash;
class UT_SampleQuad2D;
class UT_SampleTri2D;

class guTrimInfo;
class guTrimProjection;
class GU_API guIsectVal
{
public:
    int         dir;    // 1 if in direction of normal, else -1.
    UT_Vector3  pos;
    float       loc;    // Where we are on the plane/plane isect line.
};

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

    GU_Detail  *getDetail() const { return myGdp; }

    void setGroups(const GB_PrimitiveGroup *agrp,
                   const GB_PrimitiveGroup *bgrp,
                   GB_PointGroup *aptgrp,
                   GB_PointGroup *bptgrp)
    {
        myGrpA = agrp;
        myGrpB = bgrp;
        myPtGrpA = aptgrp;
        myPtGrpB = bptgrp;
    }
    float       getTolerance() { return myTol; }
    void        setTolerance(float tol) { myTol = tol; }
    void        setAutoJoin(int aj) { myAutoJoin = aj; }

    /// Invoke the cookie operation.
    ///
    /// The group of polygons to cookie must be setup with the setGroups
    /// function.
    ///
    /// The [a|b][in|out|overlap]grps are the primitive groups to classify
    /// each clipped polygon piece into.
    ///
    /// If a set of connected polygons doesn't intersect, and the insidetest
    /// is enabled, the insidedness of the polygons will be determined by
    /// sending a ray with the winding rule.
    ///
    /// If generatecrease is set, instead of clipping the polygons, the line
    /// segments generated by poly-poly intersection will be generated.
    void        cookie(GU_Detail &gdp,
                       int generatecrease,
                       GB_PrimitiveGroup &aingrp,
                       GB_PrimitiveGroup &aoutgrp,
                       GB_PrimitiveGroup &aoverlapgrp,
                       int aclosed,
                       GB_PrimitiveGroup &bingrp,
                       GB_PrimitiveGroup &boutgrp,
                       GB_PrimitiveGroup &boverlapgrp,
                       int bclosed,
                       int insidetest);


    // The following are internal functions.

    /// The call back from intersection tests:
    /// The two indices are the primitive numbers to intersect.
    void        performIsect(int primIdA, int primIdB);

    /// This adds all the isects of the second polygon into the trim
    /// list of the first:
    void        buildTrimSegments(GEO_PrimPoly *dst,
                                  GEO_PrimPoly *src);
    void        buildTrimSegmentsCoplanar(GEO_PrimPoly *dst,
                                          GEO_PrimPoly *src,
                                          bool reverse);


    void        addPointToGroup(GEO_Point *pt, GEO_PrimPoly *poly);

    /// The edge is poly(edge-1) to poly(edge).
    GEO_Vertex   *createEdgeVertex(guTrimInfo *base,
                                   int edge, float t, int dir);
    GEO_Vertex   *createInteriorVertex(guTrimInfo *base,
                                       const UT_Vector3 &pt);

    GEO_PrimPoly *createPoly(guTrimInfo *base,
                             const UT_PtrArray<GEO_Vertex *> &vtxes,
                             bool closed,
                             bool preserve_groups = true);

    /// Punches a hole in the polygon base with the polygon hole.  The
    /// appropriate bridges are formed.
    void        punchHole(GEO_PrimPoly *base, GEO_PrimPoly *hole);


    UT_IntArray * buildConnectivityGraph();

    void        classifyPolygons(const GB_PrimitiveGroup &originalgrp,
                                 GB_PrimitiveGroup &ingrp,
                                 GB_PrimitiveGroup &outgrp,
                                 GB_PrimitiveGroup &overlapgrp,
                                 UT_IntArray *edges,
                                 const GB_PrimitiveGroup &othergrp,
                                 GU_RayIntersect *&inter,
                                 bool insidetest,
                                 bool inter_closed);

protected:
    GU_Detail           *myGdp;
    UT_PtrArray<guTrimInfo *>   myTrimInfo;

    UT_HashTable        *myEdgeTable;

    // We add all newly created points to each of these.  Points generated
    // from A primitives go to ptgrpa, those from B primitives to point
    // group B.
    GB_PointGroup       *myPtGrpA, *myPtGrpB;

    const GB_PrimitiveGroup     *myGrpA, *myGrpB;

    // Intersections within a polygon..
    // This is used by buildTrimSegments, but shared so don't need
    // to reallocate.
    UT_RefArray<guIsectVal>     myIsects;

    int                  myAutoJoin;

    float                myTol;
};

#endif

---