source: GTP/trunk/Lib/Geom/GTGeometry/src/GeoMeshStripifier.cpp @ 774

/*      ==========================================================================
 *      (C) 2005 Universitat Jaume I
 *      ==========================================================================
 *      PROYECT:        GAME TOOLS
 *      ==========================================================================*/
/**     CONTENT:        Make triangle strip meshes from triangle list meshes.
        *
        *
        *       @file   GeoMeshStripifier.cpp
*===========================================================================*/

#include "GeoMeshStripifier.h"
#include "tri_stripper.h"

using namespace Geometry;
using   namespace       std;
using   namespace       triangle_stripper;

//-----------------------------------------------------------------------------
//      Constructors.
//-----------------------------------------------------------------------------

MeshStripifier::MeshStripifier()
{
}

MeshStripifier::MeshStripifier( const   Geometry::Mesh  *geoMesh)
{
}

CustomStripifier::CustomStripifier()
{
}

CustomStripifier::CustomStripifier(     const   Geometry::Mesh  *geoMesh)
{
        mGeoMesh        =       new Mesh();
        *mGeoMesh       =       *geoMesh;

        //      Sets the actual progress bar function.
        mUPB    =       NULL;
}

//      Set the progress bar function.
void    CustomStripifier::SetProgressFunc(TIPOFUNC upb)
{
        //      Sets the actual progress bar function.
        mUPB    =       upb;
}

//-----------------------------------------------------------------------------
//      Destroyers.
//-----------------------------------------------------------------------------
CustomStripifier::~CustomStripifier()
{
        delete  mGeoMesh;
}

MeshStripifier::~MeshStripifier()
{
}

//-----------------------------------------------------------------------------
//      Public.
//-----------------------------------------------------------------------------

///     Stripify.
int CustomStripifier::Stripify()
{
        size_t                                          index_count;
        size_t                                          strip_count;
        SubMesh                                         *geosubmesh;
        primitive_vector        PrimitivesVector;
        indices                                         Indices;
        float                                                   increment;
        float                                                   update;
        
        //      For each submesh.
        for (int        submesh =       0;      submesh < mGeoMesh->mSubMeshCount;      submesh++)
        {
                //      Gets the submesh.
                geosubmesh      =       &mGeoMesh->mSubMesh[submesh];

                //      Free index vector.
                Indices.clear();

                //      Progress bar increment.
                increment       =       20      /       mGeoMesh->mSubMeshCount;
                increment       =       increment       /       geosubmesh->mIndexCount;
                update          =       0.0;
                
                //      For each index.
                for (int        index   =       0;      index   <       geosubmesh->mIndexCount;        index++)
                {
                        //      Update progress bar.
                        if (mUPB)
                        {
                                update  =       update + increment;
                                
                                if (update > 0.9)
                                {
                                        mUPB(1.0);
                                        
                                        update  =       0;
                                }
                        }
                        
                        //      Add an index.
                        Indices.push_back(geosubmesh->mIndex[index]);
                }

                // we want to time the tri_stripper object destruction as well.
                tri_stripper TriStripper(Indices);

                //      Sets the progress bar function for stripper algorithm.
                TriStripper.SetProgressFunc(mUPB,60/mGeoMesh->mSubMeshCount);
                
                TriStripper.SetMinStripSize(2);
                TriStripper.SetCacheSize(32);
                //TriStripper.SetBackwardSearch(false);

                TriStripper.Strip(&PrimitivesVector);

                //      Free submesh indices.
                delete  []      geosubmesh->mIndex;

                //      Initialize index count.
                geosubmesh->mIndexCount =       0;

                //      Initialize strip count.
                strip_count     =       0;
                
                //      For each strip or triangle list.
                for (size_t i = 0; i < PrimitivesVector.size(); ++i)
                {
                        if (PrimitivesVector[i].Type == TRIANGLE_STRIP)
                        {
                                strip_count++;
                                geosubmesh->mIndexCount +=      PrimitivesVector[i].Indices.size();

                                //      Degenerate triangles.
                                geosubmesh->mIndexCount +=      2;
                        }
                        else
                        {
                                strip_count += PrimitivesVector[i].Indices.size()/3;
                                
                                geosubmesh->mIndexCount +=      PrimitivesVector[i].Indices.size();

                                //      Degenerate triangles.
                                geosubmesh->mIndexCount +=      2*(PrimitivesVector[i].Indices.size()/3);
                        }
                
                }

                //      Reserve memory for strips list.
                geosubmesh->mStrip                      =       new     Index*[strip_count];
                geosubmesh->mStripCount =       strip_count;

                //      Adjust the index count.
                geosubmesh->mIndexCount -=      2;
                
                //      Reserve memory for indices.
                geosubmesh->mIndex      =       new     Index[geosubmesh->mIndexCount];

                //      Initialize index count.
                index_count     =       0;

                //      For each strip.
                for (size_t     strip   =       0; strip < PrimitivesVector.size();     strip++)
                {
                        if (PrimitivesVector[strip].Type == TRIANGLE_STRIP)
                        {
                                //      Asigns the beginning of the strip.
                                geosubmesh->mStrip[strip]       =       &geosubmesh->mIndex[index_count];

                                //      If is not the first strip.
                                if (strip       != 0)
                                {
                                        geosubmesh->mIndex[index_count++]       = PrimitivesVector[strip].Indices[0];
                                }
                                
                                //      Fill up the index array.
                                for (   size_t  index   =       0;
                                                        index < PrimitivesVector[strip].Indices.size();
                                                        index++)
                                {
                                        geosubmesh->mIndex[index + index_count] =       PrimitivesVector[strip].Indices[index];
                                }

                                //      Adds the current strip size to index count.
                                index_count     +=      PrimitivesVector[strip].Indices.size();

                                if ((strip + 1) != strip_count)
                                {
                                        //      Degenerate triangle.
                                        geosubmesh->mIndex[index_count++]       =       geosubmesh->mIndex[index_count - 1];
                                }
                        }
                        else
                        {
                                //      For each index.
                                for (   size_t  itri    =       0;
                                                        itri    <       PrimitivesVector[strip].Indices.size() / 3;
                                                        itri ++)
                                {
                                                //      Asigns the beginning of the strip.
                                                geosubmesh->mStrip[strip + itri]        =       &geosubmesh->mIndex[index_count];

                                                //      Degenerate triangle.
                                          geosubmesh->mIndex[index_count++]     =       PrimitivesVector[strip].Indices[itri*3+0];

                                                //      Triangle indeces.
                                                geosubmesh->mIndex[index_count++]       =       PrimitivesVector[strip].Indices[itri*3+0];
                                                geosubmesh->mIndex[index_count++]       =       PrimitivesVector[strip].Indices[itri*3+1];
                                                geosubmesh->mIndex[index_count++] =     PrimitivesVector[strip].Indices[itri*3+2];

                                                //      If is not the last strip.
                                                if ((strip + itri + 1) != strip_count)
                                                {
                                                        geosubmesh->mIndex[index_count++]       =       geosubmesh->mIndex[index_count - 1];
                                                }
                                }
                                
                        }
                }
        }

        //      Update progress bar function.
        if      (mUPB)
        {
                mUPB(100);
        }
        
        //      Sets the mesh type to triangle strips.
        mGeoMesh->mType =       GEO_TRIANGLE_STRIPS;

        //      All wright.
        return  1;
}

///     GetMesh: Return de current Mesh.
Mesh*   CustomStripifier::GetMesh()
{
        Mesh            *mesh_stripified;

        mesh_stripified         =       new Mesh();
        *mesh_stripified        =       *mGeoMesh;

        return  mesh_stripified;
}