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

/*      ==========================================================================
 *      (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;

        //      Initialize the leaves submesh index.
        mSubMeshLeaves  =       -1;
}

//      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;
        size_t                                          strip_index_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 strip = 0; strip < PrimitivesVector.size(); ++strip)
                {
                        if (PrimitivesVector[strip].Type == TRIANGLE_STRIP)
                        {
                                strip_count++;

                                //      Gets the index count.
                                strip_index_count       =       PrimitivesVector[strip].Indices.size();

                                //      Adds indices of the current strip to total index count.
                                geosubmesh->mIndexCount +=      strip_index_count;
                        }
                        else
                        {
                                strip_count += PrimitivesVector[strip].Indices.size() / 3;

                                geosubmesh->mIndexCount +=      PrimitivesVector[strip].Indices.size();
                        }

                }

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

                //      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];

                                //      Gets the index count of the current strip.
                                strip_index_count       =       PrimitivesVector[strip].Indices.size();

        
                                //      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();
                        }
                        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];

                                        //      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];

                                }
                        }
                }
                
                //      Sets the actual submesh type to triangle strips.
                geosubmesh->mType       =       GEO_TRIANGLE_STRIPS;
        }

        //      Update progress bar function.
        if      (mUPB)
        {
                mUPB(100);
        }

        //      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;
}

// Sets what is the submesh that stores the leaves.
void CustomStripifier::SetSubMeshLeaves(size_t  submesh)
{
        mSubMeshLeaves  =       submesh;
}