source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoTreeSimpSequence.cpp @ 1136

#include "GeoTreeSimpSequence.h"
#include <iostream>
#include <fstream>
#include "GeoMeshLoader.h"

using namespace Geometry;
using namespace std;

TreeSimplificationSequence::TreeSimplificationSequence() 
{
        meshName="";
}

TreeSimplificationSequence::~TreeSimplificationSequence()
{
}

void TreeSimplificationSequence::Load(Serializer &s)
{
        // Carga una secuencia de simplificación desde un fichero
        char buffer[256];
        char nombre[256];
        Geometry::Index quad;
        int cont; 

        if (s.ReadData(buffer,256) != NULL) 
        {
                sscanf(buffer,"%s",&nombre);
                meshName=new char[strlen(nombre)];
                strcpy(meshName,nombre);
        }

        while (s.ReadData(buffer,256) != NULL) 
        {
                Geometry::TreeSimplificationSequence::Step pasosimp;
                sscanf(buffer,"%u %u %u %u &",&pasosimp.mV0,&pasosimp.mV1,&pasosimp.mT0,&pasosimp.mT1);
                // Quitar el salto de línea del final.
                buffer[strlen(buffer)-1]='\0';

                char *ptr1;
                ptr1=strtok(buffer,"&");
                ptr1=strtok(NULL,"&");
                if (ptr1!=NULL) 
                {
                        char *ptr;
                        ptr=strtok(ptr1," ");
                        cont=0;
                        while(ptr != NULL ) 
                        {
                                quad = (Index)atoi(ptr);
                                pasosimp.mNewQuad[cont]=quad;
                                ptr=strtok(NULL," ");
                                cont++;
                        }
                }
                mSteps.push_back(pasosimp);
        }
}

void TreeSimplificationSequence::Save(Serializer &s)
{
        // Stores simplification sequence.
        unsigned short chunkid = 0xdcba;
        s.WriteData(&chunkid,sizeof(unsigned short),1);

        unsigned long size      =       (unsigned long)
                                                                                                (
                                                                                                        mSteps.size()*8*sizeof(int)
                                                                                                        +
                                                                                                        CHUNK_OVERHEAD_SIZE
                                                                                                );

        s.WriteData(&size,sizeof(unsigned long),1);

        int tam = (int)mSteps.size();

        s.WriteData(&tam,sizeof(int),1);

        for(int i=0; i<tam; i++)
        {
                Geometry::TreeSimplificationSequence::Step paso = mSteps.operator [](i);

                s.WriteData(&paso.mV0,sizeof(int),1);
                s.WriteData(&paso.mV1,sizeof(int),1);
                s.WriteData(&paso.mT0,sizeof(int),1);
                s.WriteData(&paso.mT1,sizeof(int),1);

                s.WriteData(paso.mNewQuad,sizeof(int),4);

                // El último %u que recibe el sprintf es para indicar si un paso es dependiente del anterior. REVISAR
                // ------------------------------------------------------------------------
/*              sprintf(simp,"%u %u %u %u &", paso.mV0, paso.mV1, paso.mT0, paso.mT1);
                s.WriteData(simp,sizeof(char),strlen(simp));

                // los quads
                sprintf(simp," %u %u %u %u\n",paso.mNewQuad[0],paso.mNewQuad[1],paso.mNewQuad[2],paso.mNewQuad[3]);
                s.WriteData(simp,sizeof(char),strlen(simp));*/
                //s.WriteData("\n",sizeof(char),1);
        }
}

void TreeSimplificationSequence::putMeshName(char *name)
{
        meshName=name;
}

char *TreeSimplificationSequence::getMeshName(void)
{
        return meshName;
}