source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoMeshSimpSequence.cpp @ 1526

#include "GeoMeshSimpSequence.h"

using namespace Geometry;
using namespace std;

//---------------------------------------------------------------------------
//      Constructor.
//---------------------------------------------------------------------------
MeshSimplificationSequence::MeshSimplificationSequence()
{
        meshName        =       "";
}

MeshSimplificationSequence::~MeshSimplificationSequence()
{
}

//---------------------------------------------------------------------------
//      Loads mesh simplification sequence.
//---------------------------------------------------------------------------
void MeshSimplificationSequence::Load(Serializer &s)
{
        //      Loads a simplification sequence from a file.
        char                                    buffer[256];
        unsigned int    modVertex;
        char                                    name[256];

        //      Read mesh name.
        if (s.ReadData(buffer,256) != NULL)
        {
                sscanf(buffer,"%s",&name);

                meshName        =       new char[strlen(name)];

                strcpy(meshName,name);
        }

        //      Read steps data.
        while (s.ReadData(buffer,256) != NULL)
        {
                Geometry::MeshSimplificationSequence::Step simplifstep;

                //      New step.
                sscanf( buffer,
                                                "%u %u %u %u %u %f %f %f &",
                                                &simplifstep.mV1,
                                                &simplifstep.mV0,
                                                &simplifstep.mT0,
                                                &simplifstep.mT1,
                                                &simplifstep.obligatory,
                                                &simplifstep.x,
                                                &simplifstep.y,
                                                &simplifstep.z);

                buffer[strlen(buffer)-1]        =       '\0';

                char *ptr1;

                ptr1    =       strtok(buffer,"&");
                ptr1    =       strtok(NULL,"&");

                if (ptr1 != NULL)
                {
                        char *ptr;

                        ptr     =       strtok(ptr1," ");
                        
                        while (ptr != NULL )
                        {
                                modVertex       =       (unsigned int)atoi(ptr);

                                simplifstep.mModfaces.push_back(modVertex);

                                ptr     =       strtok(NULL," ");
                        }
                }

                mSteps.push_back(simplifstep);
        }
}

//---------------------------------------------------------------------------
//      Saves simplification sequence.
//---------------------------------------------------------------------------
void MeshSimplificationSequence::Save(Serializer &s)
{
        //      Stores the simplification sequence in a file.
        char simp[256];

        //      Name of the mesh.
        sprintf(simp,"%s\n",meshName);
        s.WriteData(simp,sizeof(char),strlen(simp));

        //      For each step.
        for (unsigned int i     =       0; i < mSteps.size(); i++)
        {
                Geometry::MeshSimplificationSequence::Step paso = mSteps.operator [](i);
                
                sprintf(simp,
                                                "%u %u %u %u %u %f &",
                                                paso.mV0,
                                                paso.mV1,
                                                paso.mT0,
                                                paso.mT1,
                                                paso.obligatory,
                                                paso.x);

                //      Write step.
                s.WriteData(simp,sizeof(char),strlen(simp));
                
                //      Triangles modified.
                for (unsigned int j     =       0; j < paso.mModfaces.size(); j++)
                {
                        sprintf(simp," %u",paso.mModfaces.operator [](j));
                        s.WriteData(simp,sizeof(char),strlen(simp));
                }
                
                //      New line.
                s.WriteData("\n",sizeof(char),1);
        }
}

//---------------------------------------------------------------------------
//      Puts mesh name.
//---------------------------------------------------------------------------
void MeshSimplificationSequence::putMeshName(char *name)
{
        meshName        =       name;
}

//---------------------------------------------------------------------------
//      Gets mesh name.
//---------------------------------------------------------------------------
char *MeshSimplificationSequence::getMeshName(void)
{
        return meshName;
}