GU/GU_PolyFrame.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:
 * Ian Kerr
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        GU_PolyFrame.h (Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GU_PolyFrame__
#define __GU_PolyFrame__

#include "GU_API.h"

#include <UT/UT_Vector3.h>
#include <string.h>

// GU_PolyFrame::theMinVertices[] depends on the ordering of this enumeration.
typedef enum
{
    GU_POLYFRAME_FIRST_EDGE,
    GU_POLYFRAME_TWO_EDGES,
    GU_POLYFRAME_CENTROID,
    GU_POLYFRAME_TEXTURE_COORDS,
    GU_POLYFRAME_STYLE__count
} GU_PolyFrameStyle;

typedef enum
{
    GU_POLYFRAME_TANGENT        = 1,
    GU_POLYFRAME_BITANGENT      = 1 << 1,
} GU_PolyFrameVector;

typedef enum
{
    GU_POLYFRAME_NO_ERROR,
    GU_POLYFRAME_CREATE_ATTRIBUTE_FAILED,
    GU_POLYFRAME_MISSING_DETAIL,
    GU_POLYFRAME_MISSING_TEXTURE_COORDS,
    GU_POLYFRAME_ERROR__count
} GU_PolyFrameError;

class GU_API GU_PolyFrameParms
{
public:
    GU_PolyFrameParms()
        : style(GU_POLYFRAME_FIRST_EDGE)
        , which(0)
        , orthogonal(false)
    {
        ::memset(names, 0, sizeof(const char *) * 3);
    }

    GU_PolyFrameStyle    style;         // Specifies how the frame vectors are
                                        // to be calculated.

    int                  which;         // A bit mask that specifies which basis
                                        // vectors are to be evaluated.  Bits
                                        // can be set using members of the
                                        // GU_PolyFrameVector enumeration.

    bool                 orthogonal;    // Indicates that the frame vectors
                                        // must be made orthogonal.

    const char          *names[3];      // Specifies the names of the frame
                                        // vector attributes that are being
                                        // computed.  names[0] points to the
                                        // name of the tangent vector.  names[1]
                                        // points to the name of the bitangent
                                        // vector.  names[2] points to the name
                                        // of the normal.  names[0] and/or
                                        // names[1] will be ignored if the
                                        // corresponding bit in 'which' is not
                                        // set.
};

class GB_PointGroup;
class GB_PrimitiveGroup;
class GEO_Hull;
class GEO_Face;
class GU_Detail;
class UT_BitArray;
class UT_String;

class GU_API GU_PolyFrame
{
public:
    GU_PolyFrame(GU_Detail *gdp);
    virtual             ~GU_PolyFrame();

    GU_Detail           *getDetail() const { return myGdp; }
    void                 setDetail(GU_Detail *gdp) { myGdp = gdp; }

    GU_PolyFrameError    computeFrames(const GU_PolyFrameParms &parms,
                                       const GB_PointGroup *point_group = NULL,
                                       const GB_PrimitiveGroup *prim_group
                                            = NULL);

private:
    void                 computeFrames(GEO_Face *prim,
                                       UT_BitArray *uncomputed,
                                       int &nleft);

    // The following two methods are called once per detail and once per
    // polygon, respectively.  They give you a chance to compute values that
    // will be reused by several polygons and vertices, respectively.
    GU_PolyFrameError    detailHook();
    void                 primitiveHook();

    void                 setFrame();

    // Per-vertex frame computation methods for each style in GU_PolyFrameStyle.
    void                 computeFirstEdgeFrame();
    void                 computeTwoEdgesFrame();
    void                 computeCentroidFrame();
    void                 computeTexCoordsFrame();
    void                 computeDefaultFrame();

    // Utility methods.
    static void          computeCentroid(const GEO_Face *prim,
                                         UT_Vector3 &centroid);
    static void          computeMeshCentroid(const GEO_Hull *hull,
                                             int vertex_no,
                                             UT_Vector3 &centroid);
    static void          createPointNormals(GU_Detail *gdp, int offset);
    static int           findAttrib(const GU_Detail *gdp, const char *name);
    static int           findOrAddAttrib(GU_Detail *gdp,
                                         const char *name,
                                         bool per_vertex,
                                         bool &created);
    static const char   *getLayeredAttribName(const GU_Detail *gdp,
                                              const char *name);
    static bool          isStylePerVertex(GU_PolyFrameStyle style);
    static void          makeOrthogonal(UT_Vector3 *frame);

    static int                   theMinVertices[];
    GU_Detail                   *myGdp;
    const GU_PolyFrameParms     *myParms;
    const GB_PointGroup         *myPointGroup;
    const GB_PrimitiveGroup     *myPrimGroup;
    GEO_Face                    *myCurPrim;
    int                          myCurVertexNo;
    int                          myCurPointNo;
    UT_Vector3                   myFrame[3];

    // Values computed by detailHook() and polygonHook().
    UT_Vector3                   myCentroid;
    int                          myOffsets[3];
    int                          myUvOffset;
    bool                         myPerVertex;
    bool                         myUvPerVertex;
    bool                         myAttribsCreated[3];
};

#endif

---