source: GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoMeshStripifier.h @ 2549

/*=======================================================================
 *      (C) 2005 Universidad Jaime I de Castellón
 *=======================================================================
 *      PROYECT:        GAME TOOLS
 *=======================================================================
 *      CONTENT:        Make triangle strips meshes from triangle list meshes.
 *
 *
 *      @file   GeoMeshStripifier.h
 *=======================================================================*/

#ifndef __GEO_STRIPIFIER__
#define __GEO_STRIPIFIER__

#include "GeoMesh.h"

#define MAX_ADJ 60

namespace Geometry
{
        typedef struct
        {
                int array[3];
        } 
        vector3;

        typedef struct
        {
                int finish;
                int NumAdj;
    }
        adj;

        typedef std::vector<int> vector_int;
        typedef std::vector<vector3> vector_vector3;
        
        /// Stripifier interface class.
        /** This module implements methods that extract triangle strips from triangle meshes. 
                \n

Inputs:\n
        - This module receives a pointer to a Geometry::Mesh object containing the model to be stripified.
        .

Outputs:\n
        - The stripified mesh, contained also in a Geometry::Mesh object.
        .

        */
        class MeshStripifier
        {
                public:
                        /// Class constructor, receives as a parameter a const pointer to the object that describes a mesh.
                        MeshStripifier ();
                        MeshStripifier (const Geometry::Mesh *);

                        /// virtual class destructor.
                        virtual ~MeshStripifier (void);

                        /// Copy constructor
                        //MeshStripifier(const MeshStripifier&);

                        /// Assignment operator
                        //MeshStripifier& operator =(const MeshStripifier&);

                        /// Starts the stripification process. This is a pure virtual method and must be overloaded in a derived class that implements a stripification algorithm.
                        virtual int Stripify()=0;

                        /// Returns the stripified mesh.
                        Mesh *  GetMesh ();

                        // Sets what is the mesh that stores the leaves
                        void setSubMeshLeaves(size_t);

                protected:

                        //      Progress bar function.
                        Geometry::TIPOFUNC mUPB;

                        //      Mesh object.
                        Geometry::Mesh          *mGeoMesh;

                        //      Index of the submesh leaves.
                        size_t  mSubMeshLeaves;
        };

        class CustomStripifier : public MeshStripifier
        {
                private:

                        // Globals
                        int     mError; 
                        int num_faces;

                        std::vector<vector3> StripFaces;
                        std::vector<vector_vector3> StripEdges;

                        vector_int StripArray[MAX_ADJ]; 

                        adj* StripFaceAdj; 

                        std::vector<vector_int> StripVertices;

                        vector_int Strips;

                        int num_tiras;
                        int ids[3];
                        int lastTri[3];
                        int ties_array[60];
                        int last;

                        std::vector<vector_int> my_vector;

                        Geometry::Mesh *MeshGlobal;

                        int stripify( Geometry::Mesh *geoMesh);

                        void GetLower(int *x, int *y);
                        int Different(int id1,int id2,int id3,int id4,int id5, int id6, int *x, int *y);
                        void Orient(int vertex1,int vertex2,int vertex3);
                        void StoreAdjacencies(int num_faces);
                        void ReadData(Geometry::SubMesh *geoSubMesh,int num_faces, int num_vert);
                        void Stripification();
                        void AddTri(int id1, int id2, int id3, int flag, int where);
                        void GoBack(int face_id, int *ties,int tie);
                        void StoreTri(int face_id,int NumAdj, int original_adj, int *ties, int tie, int where);

                        int GetNumAdjacencies(int id1, int id2, int curr_id);
                        int MinimumAd(int id);
                        int Find_Face(int current_face, int id1,int id2, int *NumAdj);
                        int Look_Up(int id1,int id2,int face_id);
                        void StoreStrip(int id, int where);
                        int NumAdj(int id1, int id2);
                        void FindAdjacencies(int num_faces, int num_verts);
                        void StoreAdjacency(int NumAdj,int face_id);
                        int Prediction();
                        void AddNewFace(int ids[3],int face_id);
                        void AddAdjEdge(int v1,int v2, int fnum);
                        int GetEdge(    int *edge1,int *edge2,int *index,int face_id);
                        void DeleteAdj(int id1, int id2,        int *next_NumAdj,int *min_face, 
                                        int current_face,int *e1,int *e2,int *ties);
                        int UpdateAdjacencies(int face_id,int *next_NumAdj, int *e1, int *e2,int *ties);
                        void UpdateFaces(int *next_NumAdj,int *min_face, int face_id, int *e1,int *e2,int temp1, int temp2,int *ties);
                        int Finished();



                public:
                        /// Class constructor, receives as a parameter a const pointer to the object that describes a mesh.
                        CustomStripifier();

                        CustomStripifier(const Geometry::Mesh *geoMesh);

                        /// Class destructor.
                        ~CustomStripifier(void);

                        /// Copy constructor
                        //CustomStripifier(const CustomStripifier&);

                        /// Assignment operator
                        //CustomStripifier& operator =(const CustomStripifier&);

                        /// Starts the stripification process. This is a custom stripification method.
                        int Stripify();

                        /// Returns the stripified mesh.
                        Mesh *  GetMesh();

                        //      Set the progress bar function.
                        void    SetProgressFunc(Geometry::TIPOFUNC upb);

                        // Sets what is the submesh that stores the leaves
                        void SetSubMeshLeaves(size_t    submesh);

        };

}

#endif