GU/GU_HoleInfo.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:
 *      Mark Elendt
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        GU_HoleInfo (C++)
 *
 * COMMENTS:    This is the info structure used for hole information.  Each
 *              primitive has a an attribute added which points to one of these
 *              structures.
 *              The flag is set to 1 if there's a hole.
 *              The array is filled with all the primitives which are enclosed
 *              within the face.
 */

#ifndef __GU_HoleInfo__
#define __GU_HoleInfo__

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

class GU_Detail;
class GEO_Primitive;
class GEO_Face;

class GU_API GU_HoleInfo {
public:
    // Returns the primitive attribute offset for the hole info pointers.
    // It returns -1 if there are no face primitives in the gdp.
    // The info structures are all initialized to contain the correct hole
    // information.
    static int          buildInfo(GU_Detail *gdp,
                                  float distance = 0.001,
                                  float angle = 0.2,
                                  const GB_PrimitiveGroup *grp = 0);

    // Build information about orientation of the holes (i.e. whether the
    // normal is the wrong way for the holes).
    static void         buildReversalInfo(GU_Detail *gdp);

    // Promote polygons to bezier when needed.  The old primitives are
    // destroyed, but the attribute information is maintained.
    static void         promoteFaces(GU_Detail *gdp);

    static void         destroyInfo(GU_Detail *gdp);

     GU_HoleInfo(const GEO_Primitive *prim);
    ~GU_HoleInfo();

    // isHole() will return whether the primitive is contained in another face.
    unsigned             isHole() const { return myHoleFlag & 1; }

    // isReversed() will return whether the normal is opposite of the
    // surrounding primitives normal (as it should be).
    unsigned             isReversed() const     { return myHoleFlag & 2; }

    // Return the number of holes in the primitive and a pointer to the hole.
    int                  entries() const        { return myHoles.entries(); }
    GEO_Face            *getHole(int i) { return myHoles(i); }

    // For promotion of primitives
    int                  setPromotedFace(GEO_Face *face)
                         {
                             myFace = face;
                             return myFace != 0;
                         }
    GEO_Face            *getPromotedFace()      { return myFace; }

    // A bounding box for the primitive.
    const UT_BoundingBox        &getBox() const { return myBox; }

// Methods which really should be private...
    UT_PtrArray<GEO_Face *>     &getHoles()     { return myHoles; }
    void                         setHole(int on)
                                 {
                                     if (on)    myHoleFlag |= 1;
                                     else       myHoleFlag &= ~1;
                                 }
    void                         setReversed()  { myHoleFlag |= 2; }

private:
    void                         fixPromotions(int attrib_off);
    unsigned                     myHoleFlag;
    UT_PtrArray<GEO_Face *>      myHoles;
    UT_BoundingBox               myBox;
    GEO_Face                    *myFace;                // Promoted
};

#endif

---