GU/GU_PolyExtrude.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:        GU Library (C++)
 *
 * COMMENTS: Poly Extrude code.
 *
 */
#ifndef __GU_PolyExtrude_h__
#define __GU_PolyExtrude_h__

#include "GU_API.h"
#include <UT/UT_Matrix4.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_Vector3.h>

class UT_IntArray;
class GB_BaseGroup;
class GB_Edge;
class GB_PointGroup;
class GB_PrimitiveGroup;
class GEO_Face;
class GEO_Point;
class GEO_PointRefArray;
class GEO_PointTree;
class GU_Detail;
class GU_PrimPoly;

enum GU_PolyExtrudeConsolidate
{
    GU_EXTRUDE_CONSOLIDATE_FRONT       = 0x01,  // consolidate front face.
    GU_EXTRUDE_CONSOLIDATE_BACK        = 0x02,  // consolidate back face.
    GU_EXTRUDE_CONSOLIDATE_SIDE        = 0x04,  // consolidate sides.
    GU_EXTRUDE_CONSOLIDATE_ALL         = 0x08,  // consolidate all faces 
                                                // together.
    GU_EXTRUDE_CONSOLIDATE_ALLPERPOINT = 0x10,  // consolidate all originating 
                                                // points together.
    GU_EXTRUDE_CONSOLIDATE_PERFACE     = (GU_EXTRUDE_CONSOLIDATE_FRONT |
                                          GU_EXTRUDE_CONSOLIDATE_BACK  |
                                          GU_EXTRUDE_CONSOLIDATE_SIDE)
};

enum GU_PolyExtrudeSymmetryAxis
{
    GU_EXTRUDE_SYMMETRY_AXIS_X,
    GU_EXTRUDE_SYMMETRY_AXIS_Y,
    GU_EXTRUDE_SYMMETRY_AXIS_NONE,
    GU_EXTRUDE_SYMMETRY_ROTTOLEAD
};

enum GU_PolyExtrudeKeepSharedPoints
{
    GU_EXTRUDE_KSP_NO = 0,
    GU_EXTRUDE_KSP_ISECT,
    GU_EXTRUDE_KSP_AVERAGE
};

class gu_PointTargetList;
class gu_LocalSpaceAlgorithm;

typedef void  (*GU_PolyExtrudeXformCallback)(int primnum, UT_Matrix4 &xform,
                                             void *user_data);
typedef float (*GU_PolyExtrudeInsetCallback)(int primnum, int vtxnum, int ptnum,
                                             void *user_data);
typedef int   (*GU_PolyExtrudeDivCallback)(int primnum, void *user_data);

class GU_API GU_PolyExtrudeParms
{
public:
    GU_PolyExtrudeParms(); 

    const GB_BaseGroup  *myGroup;


    GB_PrimitiveGroup   *myFrontGroup;
    GB_PrimitiveGroup   *myBackGroup;
    GB_PrimitiveGroup   *mySideGroup;

    GB_BaseGroup        *myOutputGroup;

    bool                 myOutputFront;
    bool                 myOutputBack;
    bool                 myOutputSide;

    bool                 myRemoveZeroAreaSides;
    bool                 myRemoveSharedSides;

    unsigned int         myConsolidatePoints;  // Bit flag for fuse options


    GU_PolyExtrudeSymmetryAxis      mySymmetryAxis;

    GU_PolyExtrudeKeepSharedPoints  myKeepSharedPointsTogether;

    // This flag is used to orient faces extruded from edges based on the
    // neighbouring faces.
    bool                 myOrientEdgeFaces;

    // Floating point tolerance for consolidating and coincident face removal.
    float                myTolerance;

    void                 setLocalXform(const UT_Matrix4 &mat, 
                                       GU_PolyExtrudeXformCallback cb);
    const UT_Matrix4    &getLocalXform(int primnum) const;

    void                 setGlobalXform(const UT_Matrix4 &mat, 
                                        GU_PolyExtrudeXformCallback cb);
    const UT_Matrix4    &getGlobalXform(int primnum) const;

    void                 setInset(float inset, GU_PolyExtrudeInsetCallback cb);
    float                getInset(int primnum, int vtxnum, int ptnum) const;

    void                 setDivisions(int div, GU_PolyExtrudeDivCallback cb);
    int                  getDivisions(int primnum) const;

    // Returns true if either the bit passed is set in our myConsolidatePoints
    // bit field or if one of the 'All' options is set.
    bool                 isFusing(unsigned int bit) const;

    // Returns true if we are using the 'All Per-Point' method of fusing
    // and myKeepFacesTogether is true.
    bool                 isConsolidatePerPoint() const;

    // Returns true if we are using the 'All' or 'All Per-Point' method of 
    // fusing.
    bool                 isConsolidateAll() const;

    // Callback support for local variables
    GU_PolyExtrudeXformCallback     myLocalXformCallback;
    GU_PolyExtrudeXformCallback     myGlobalXformCallback;
    GU_PolyExtrudeInsetCallback     myInsetCallback;
    GU_PolyExtrudeDivCallback       myDivCallback;
    void                           *myCBUserData;

private:

    // These parameters can be changed by local variables and so must be
    // accessed through methods of this class.
    UT_Matrix4           myLocalXform;
    UT_Matrix4           myGlobalXform;
    mutable UT_Matrix4   myTempLXform;  // For callback storage
    mutable UT_Matrix4   myTempGXform;  // For callback storage
    int                  myDivisions;
    float                myInset;

};


class GU_API GU_PolyExtrude
{
public:

    GU_PolyExtrude(GU_Detail *gdp);
    ~GU_PolyExtrude();

    // Performs the extrusion
    void        extrude(const GU_PolyExtrudeParms &parms);

    // Removes coincident polygons
    void        removeSharedSides(GB_PrimitiveGroup *primgrp, float tolerance);


    // Computes an edge normal
    bool        computeEdgeNormal(UT_Vector3 &nml, const GB_Edge &edge, 
                                  bool cleanup);

    // Computes the local coordinate space of the polygon and returns
    // the change of basis matrix in mat.  If it fails, then false is 
    // returned, otherwise it returns true.  (Failure condition might
    // be that the polygon is degenerate.)
    static bool computeLocalSpace(const GEO_Face &face,
                                  UT_Matrix4 &mat);
    bool        computeLocalSpace(const GB_Edge &edge, UT_Matrix4 &mat);

private:
    void        extrudePolys(const GU_PolyExtrudeParms &parms);
    void        extrudeEdges(const GU_PolyExtrudeParms &parms);
    bool        extrudeFace(const GEO_Face &face, gu_LocalSpaceAlgorithm &lsa,
                            const GU_PolyExtrudeParms &parms,
                            GB_PrimitiveGroup *sideprims,
                            const gu_PointTargetList &pt_target_list);
    void        extrudeEdge(const GB_Edge &edge, gu_LocalSpaceAlgorithm &lsa,
                            const GU_PolyExtrudeParms &parms,
                            const gu_PointTargetList &pt_target_list);

    void        buildRails(const GU_PolyExtrudeParms &parms,
                            UT_PtrArray<GEO_Point *> &ptlist0,
                            UT_PtrArray<GEO_Point *> &ptlist1,
                            GEO_Point *pt0, GEO_Point *pt1,
                            GEO_Point *frontpt0, GEO_Point *frontpt1,
                            const UT_Vector4 &extrudedir0, 
                            const UT_Vector4 &extrudedir1, 
                            float t, bool regenlist0, int divs);

    // Returns a new point based on the myConsolidatePoints option.
    // If likept is null, then we won't copy attributes
    GEO_Point  *newPoint(const GU_PolyExtrudeParms &parms, 
                         const UT_Vector4 &atpos,
                         GEO_Point  *likept);

    GU_PrimPoly *buildFrontFace(const GEO_Face &face, 
                                gu_LocalSpaceAlgorithm &lsa,
                                const GU_PolyExtrudeParms &parms,
                                const gu_PointTargetList &pt_target_list);
    void         buildSideFaces(const GEO_Face &face,
                                const GEO_Face &newface,
                                const GU_PolyExtrudeParms &parms,
                                const gu_PointTargetList &pt_target_list,
                                UT_IntArray &new_sides);

    GEO_Point   *getEdgePoint(int ptnum, int div, float t,
                              const UT_Vector4 &extrudedir,
                              const GU_PolyExtrudeParms &parms,
                              const gu_PointTargetList &pt_target_list);


    GU_Detail           *myGdp;
    bool                 myInternalNormals;

    GEO_PointTree       *myNewPointsTree;
    GEO_PointRefArray   *myPointRefArray;
};

#endif

---