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

/*      ==========================================================================
 *      (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;
        SubMesh                                         *geosubmesh;
        primitive_vector        PrimitivesVector;
        indices                                         Indices;
        float                                                   increment;
        float                                                   update;

        //      For each submesh.
        for (int        submesh =       0;      submesh < mGeoMesh->mSubMeshCount;      submesh++)
        {
                //      If is not the Leaveas submesh.
                if (submesh != mSubMeshLeaves)
                {

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

                                }
                        }

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