GU/GU_UVSew.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.
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        GU Library.
 *
 * COMMENTS:    This class contains the methods to perform the UV Sew 
 *              operation.
 *
 */



#ifndef __GU_UVSew_h__
#define __GU_UVSew_h__

#include "GU_API.h"

#include <UT/UT_PtrArray.h>
#include <UT/UT_IntArray.h>
#include <UT/UT_HashTable.h>
#include <GEO/GEO_PrimClassifier.h>

class UT_BitArray;
class UT_IntArray;
class UT_Matrix4;
class UT_Vector3;
class UT_Vector2;
class GB_Edge;
class GB_EdgeGroup;
class GB_Primitive;
class GB_VertexData;
class GB_VertexGroup;
class GEO_Delta;
class GEO_Primitive;
class GEO_PrimPoly;
class GEO_PrimConnectorUV;
class GEO_Point;
class GU_Detail;
class gu_SuperVertex;
class gu_VertexTransform;
class gu_ClassEdges;

class GU_API GU_UVSew
{
public:

                          GU_UVSew(GU_Detail &gdp, GEO_Delta *geodelta);
                         ~GU_UVSew();

    // The sew() method is the workhorse of this class.  Given an edge group,
    // this method will perform the work necessary to sew vertex UV's sharing
    // the same points.
    void                  sew(GB_EdgeGroup *edge_grp);


protected:

    // Helper method that sews an edge, this time the from and to polygon have
    // already been resolved.  They should both share the given edge.
    void                  sew(GEO_PrimPoly &from_poly, GEO_PrimPoly &to_poly,
                              GB_Edge &edge);


    // Fills the supervertex array of the given primitive.  After this call
    // the primitive should have a super vertex assigned to each of its
    // vertices.
    void                  fillSuperVertexArray(const GEO_Primitive &prim);
    

    // This method is used to process all the vertices connected 
    // (uv-connectivity) to the super vertex svtx_idx.
    void                  processConnectedVertices(int svtx_idx,
                                                 const UT_Vector2 &translate,
                                                 float rotation,
                                                 const UT_Vector2 &scales,
                                                 const UT_Vector2 &pivot,
                                                 const UT_Vector3 &p0,
                                                 const UT_Vector3 &p1);

    // Returns the index of the supervertex containing vtx on prim.
    int                   getSuperVertexIndex(const GB_Primitive &prim, 
                                              int vtx);

    // Helper method that adds prim/vtx to the super vertex indexed by svtx_idx.
    void                  insertVertexToSuperVertex(int svtx_idx, 
                                                    const GEO_Primitive &prim,
                                                    int vtx);
    

    // Convenience methods for retrieving UV coordinates from vertices and
    // supervertices.
    void                  getVertexUV(const GEO_Primitive &prim,
                                      int vtx, UT_Vector3 &uv);
    bool                  getSuperVertexUV(int svtx_idx, UT_Vector3 &uv);


    // Adds the vertices in a super vertex to the given group.
    void                  addSuperVertexToGroup(int svtx_idx,
                                                GB_VertexGroup &group);


    // Apply all the accumulated transforms to each super vertex.
    void                  applyAndRemoveSuperTransforms();


    // Convenience methods for appending transforms to supervertices.
    void                  transformSuperVertex(int svtx_idx, 
                                               const UT_Vector2 &translate,
                                               float rotation,
                                               const UT_Vector2 &scales,
                                               const UT_Vector2 &pivots,
                                               bool  locked,
                                               float weight);
    void                  translateSuperVertex(int svtx_idx,
                                               const UT_Vector2 &translate,
                                               bool locked,
                                               float weight);

    // Returns the list of super vertices that are connected to the given
    // super vertex.
    void                  getConnectedSuperVertices(int svtx_idx,
                                                    UT_IntArray &connected);

    // From the given edge group, this method sorts and partitions the edges
    // into classes (e.g. patches) and gets them ready to be processed in a
    // specific order.
    void                  buildMainClasses(GB_EdgeGroup *edge_grp);

    // This is a helper method for builMainClasses, it goes through the list
    // of edges in the given edge group and determines populates the 
    // myMainClassEdges array with the corresponding main edges.
    void                  resolveToEdges(GB_EdgeGroup *edge_grp);

    // Clears the super transforms array.
    void                  clearSuperTransforms();

    // Returns the main polygon that we should be moving the other polygons to.
    GEO_PrimPoly         *getMainPoly(GB_Edge &edge, const UT_IntArray &polys);

    // Rebuilds our connectivity information -- use sparingly.
    void                  resetConnectivityStructures();

private:
    GU_Detail                         &myGdp;
    GEO_Delta                         *myDelta;
    int                                myVertexUVOffset;
    GEO_PrimClassifier                 myUVClassifier;
    GEO_PrimConnectorUV               *myUVConnector;
    UT_PtrArray<gu_SuperVertex *>      mySuperVertices;
    UT_PtrArray<gu_VertexTransform *>  mySuperTransforms;
    UT_HashTable                       myVertexToSuperVertexTable;
    UT_PtrArray<gu_ClassEdges *>       myMainClassEdges;
};

#endif

---