GU/GU_PrimPoly.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:
 *      Dale Ducharme
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        GU_PrimPoly.h (C++)
 *
 * COMMENTS:
 *      Header file for GU_PrimPoly.h class...
 * 
 */

#ifndef __GU_PrimPoly_h__
#define __GU_PrimPoly_h__

#include "GU_API.h"
#include <UT/UT_Vector3.h>
#include <GEO/GEO_PrimPoly.h>
#include <GEO/GEO_PrimRBezCurve.h>
#include <GEO/GEO_PrimNURBCurve.h>
#include "GU_Detail.h"
#include "GU_Prim.h"

class GEO_PrimCircle;
class GEO_PrimTriBezier;
class GU_PolyCache;
class GU_RayCache;
class GU_RayInfoHit;

/////////////////////////////////////////////////////////////
//                                                         //
// Class:       GU_PrimPoly                                //
// Descr:     This class is responsible for operations     //
//      done on polygon primitives.  As we need to access  //
//       the GU_Detail, the pointer is passed in the       //
//       constructor.  The second constructor creates a    //
//       polygon with a given number of points (npts) and  //
//       a flag indicating if it is open or not.           //
//                                                         //
/////////////////////////////////////////////////////////////

class GU_API GU_PrimPoly : public GEO_PrimPoly, public GU_Primitive
{
public:

    GU_PrimPoly(GU_Detail *gdp) : GEO_PrimPoly(gdp), GU_Primitive()
    {
         myDisplayCache = 0;
         myRayCache = 0;
         myPolyRayCache = 0;
    }

    virtual ~GU_PrimPoly();

    virtual void                *castTo   (void) const;
    virtual const GEO_Primitive *castToGeo(void) const;

    // Conversion Methods 

     GEO_Primitive      *convert(GU_ConvertParms &parms,
                                 GB_PointGroup *usedpts = 0);

     GEO_Primitive      *convertNew(GU_ConvertParms &parms);

     GEO_Hull           *convertToSurfNew(GU_ConvertParms &parms);
     GEO_Hull           *convertToPotatoChip(void);
     GEO_Hull           *convertToTrim(GU_ConvertParms &parms);

     GEO_PrimRBezCurve  *convertToBezierNew(int order, int interphull = 1);
     GEO_PrimNURBCurve  *convertToNURBNew(int order, int interphull = 1);
     GEO_PrimCircle     *convertToCircleNew();

     // Converts tris into triangle beziers by the PN method.
     GEO_PrimTriBezier  *convertToTriBezier();


     // Cut a wedge of the primitive given a domain range
     // ind1 and ind2 are indices to the refined values
     // They are updated if negative on input, else used as is.
     // If keep is zero the curve is only refined and the indices
     // updated.
     GU_PrimPoly        *cut(float u1, float u2, 
                             int &ind1, int &ind2, int keep);

     // Open the primitive at the given domain value
     void                openAt(float u);

     // This is more powerful than convertNew. It always returns a NEW
     // object, so free it when you're done with it. It may return a polygon,
     // a NURB curve or a Bezier curve depending on the type.
     GEO_Face           *reconfigure(unsigned type, int order, int open,
                                     int nonrational) const;

    // Calculate the normal of a polygon
    virtual void         normal(const GB_AttributeRef &noff) const;
    virtual void         normal(UT_Vector3Array &output) const;

    // Determine if the polygon is planar
    int                  isPlanar(float tolerance = 0.0001F) const;
    
    // Determine if the polygon is convex
    bool                 isConvex(float tolerance = 0.0001F) const;
    
     virtual int         intersectRay(const UT_Vector3 &o, const UT_Vector3 &d,
                                float tmax = 1E17F, float tol = 1E-12F,
                                float *distance = 0, UT_Vector3 *pos = 0,
                                UT_Vector3 *nml = 0, int accurate = 0,
                                float *u = 0, float *v = 0, 
                                int ignoretrim=1) const;

    // Returns number of hits appended, or minus one if error.
    // t values in hitList are paramter on poly of hits, assuming
    // uniform parameterization.
    virtual int          intersect(GU_Primitive &prim,
                                    UT_RefArray<GU_RayInfoHit> &hitList, 
                                    float tol = 0.01F, int ignoretrim=1);

    virtual void         clip(UT_Vector3 &normal, float d=0, int normalize=1,
                                GEO_Primitive *prim=0, 
                                GB_PrimitiveGroup *clipgrp = 0);

     void                crease(UT_Vector3 &normal, float d=0, int normalize=1,
                                int outputGroups=0,
                                GB_PrimitiveGroup*above=0,
                                GB_PrimitiveGroup*below=0);

    // Optional Build Method 
    // You may call it in the following manner, 
    // ptr = GU_PrimPoly::build(bla, bla, bla);
    static GU_PrimPoly  *build(GU_Detail *gudp, int npts, 
                               int open=GU_POLY_CLOSED,
                               int appendPts=1);

    // Given a bit array representing the edges in the poly (1 meaning
    // delete and 0 meaning keep) delete as many edges as possible.
    // If a particular edge cannot be deleted then negate the value
    // in removededges[edgenum]. DO NOT CHANGE THE MAGNITUDE!
    // Returns 0 if successful, -1 if the poly becomes degenerate, and
    // -2 if the poly should be removed.  The signature for this method
    // is consistent with those in other classes, but note that there is
    // never a case where an edge cannot be removed from a polygon.
    int                  removeEdges(const UT_BitArray &edgemap,
                                     UT_IntArray &, bool del_bridges = true)
                         {
                             GEO_Face           *dummy;
                             return removeEdges(edgemap, dummy, del_bridges);
                         }

    // Same as above method, but instead of accepting an (unused) array
    // of edge indices, it returns one (possibly one of many) polygons
    // created because this polygon had to be split.
    int          removeEdges(const UT_BitArray &edgemap,
                             GEO_Face *&newpoly,
                             bool del_bridges=true);

    // Same as above, but it returns all polygons created because of polysplit
    int          removeEdges(const UT_BitArray &edgemap,
                             UT_PtrArray<GEO_Face*> &newpoly,
                             bool del_bridges=true);


    virtual GU_DisplayCache     *getDisplayCache() const;
    virtual int                  buildDisplayCache(GU_CacheParms &parms);
    virtual void                 destroyCache();
    virtual void                 notifyCache(int type);
    virtual void                 notifyCache(int type, const GEO_Point &ppt);
    virtual void                 notifyCache(int type, const GB_PointGroup &g);
    virtual void                 notifyCache(int type, const UT_Matrix4 &xform, 
                                             int push);
    virtual void                 notifyCache(int type, const UT_Vector3 &delta);

    virtual GU_DisplayMesh      *getDisplayMesh(const GB_AttributeRef &noff,
                                        float lod);

    // Persistent is true if the returned cache is not to be deleted by
    // the caller.
    virtual GU_RayIntersect     *createRayCache(int &persistent);
    virtual GU_RayIntersect     *getRayCache() const;
    virtual int                  buildRayCache(void);
    // These create a polyline ray cache as opposed to a polygon one.
    virtual GU_RayIntersect     *createPolyRayCache(int &persistent);
    virtual GU_RayIntersect     *getPolyRayCache() const;
    virtual int                  buildPolyRayCache(void);

    // Looks at the first shared edge between us and poly and checks their
    // orientation.  Returns 0 if they are pointing in opposite directions and
    // 1 if they are pointing in the same direction and -1 if no shared edge
    // could be found.
    int                          isWindingReversed(const GEO_PrimPoly &poly);

private:
    void        create (int npts, int isopen=GU_POLY_CLOSED, int appendPts=1);

    // Vertex sides is 1 or 0 for each vertex depending on whether
    // it is above the plane.
    void        makeClippedPoly(const UT_Vector3 &n, float d, 
                                int *vtxsides,
                                int bothSides=0,
                                int outputGroups = 0,
                                GB_PrimitiveGroup *above = 0,
                                GB_PrimitiveGroup *below = 0,
                                GB_PrimitiveGroup *delgrp = 0);

    void        computeVertices(GEO_Face &face) const;

    GU_PolyCache                *myDisplayCache;
    GU_RayCache                 *myRayCache;
    GU_RayCache                 *myPolyRayCache;
};

#endif

---