source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoLodStripsConstructor.cpp @ 1048

#include <iostream>
#include <fstream>

#include "GeoLodStripsConstructor.h"

using namespace Geometry;


//--------------------------------------------------------------------------
//Call GenerarModeloV and CopiarVectorsArraysNUEVAED to make changes
//---------------------------------------------------------------------------
//      Se utiliza en el constructor sobrecargado.
void LodStripsConstructor::GenerarModeloCompleto(TIPOFUNC       upb)
{       
        float   percent;


        this->GenerarModeloV(upb);
        this->CopiarVectors2ArraysNUEVAED();

        //      Last updtate of the progress bar.
        percent =       100.0;
        upb(percent);
}

//-----------------------------------------------------------------------------------
//It makes Lods changes and count them
//-----------------------------------------------------------------------------------
void LodStripsConstructor::CalcularCambiosLODsVNuevaED(TIPOFUNC upb)
{
//      LODPosition                                             pos;
//      vector  <LODPosition>   listaPos;
        long            int                                                     k;
        long            int                                                     i;
        unsigned long           int             t;
        long            int                                                     r;
        unsigned long           int             v;
        long            int                                                     p0;
        long            int                                                     lod     =       0;
        long            int                                                     sigue;
        long            int                                                     ac[3]   =       {0,0,0};
        long            int                                                     totalRegs       =       0;
        long            int                                                     RegsCambios;
        std::vector<std::vector<int> >                  TiraOriginal;
        LODData                                                                 regLOD;
        //LODChanges                                                    listaCambios;
        std::vector<LODData>                                            listaCambios;
        float                                                                           percent;
        float                                                                           increment;
        long            int                                                     update;

        //      Saves original copy.
        TiraOriginal                    =       this->cStrips;

        this->MARCAVACIO        =       int(10 * this->cVerts.size());
        
        listaCambios.clear();

        //      Initialize increment.
        increment       =       0.0;
        
        for     (lod = 0; ((this->cVerts[lod].Next) != -1); lod++)
        {
                increment       +=      1.0;
        }

        update          =       -1;
        increment       =       (float)30.0     /       increment;
        percent         =       1.0;
        
        this->LodsDisp  =       this->TOTALCAMBIOS      =       lod;
        pCambios                                =       new uint32[this->TOTALCAMBIOS];
        pCambios[0]                     =       0;
        
        for     (lod = 0; ((this->cVerts[lod].Next) != -1); lod++)
        {
/*              if (update      != (int)(increment * lod))
                {
                        update  =       (int)(increment * lod);
                        upb(percent);
                }*/

                tipoVertice & cVertsLOD = this->cVerts[lod];
                
                RegsCambios                             =       0;
                regLOD.obligatory       =       this->Ordenacion[lod].obligatorio;
                
                for(t = 0; t < this->cStrips.size(); t++)
                {

                        std::vector<int> & cStripsT = this->cStrips[t];

                        //      Initialize.
                        regLOD.strip    =       this->MARCAVACIO;

                        //      Change vertices.
                        totalRegs               =       0;
                        
                        for (v = 0; v < cStripsT.size(); v++)
                        {
                                if (cStripsT[v] == lod) 
                                { 
                                        //      Strips.
                                        if (regLOD.strip == this->MARCAVACIO)
                                        {
                                                regLOD.strip    =       t;
                                        }
                                        
                                        ++totalRegs;

                                        cDatos.push_back(v);

                                        cStripsT[v]     =       cVertsLOD.Next;
                                }
                        }
                        
                        regLOD.nP       =       char(totalRegs);

                        //      Simplifications length 1.
                        //      Changes for simplification of level 1 to greater than 2.
                        totalRegs       =       0;
                        i                                       =       0;
                        r                                       =       0;
                        sigue                   =       0;
                        k                                       =       long(cStripsT.size()-3);
                        
                        while (i < k)
                        {
                                if (    (cStripsT[i] == cStripsT[i+1])
                                                        &&
                                                        (cStripsT[i+1] == cStripsT[i+2])
                                                )
                                { 
                                        //      Saves beginning of repetition.
                                        if (!r)
                                        {
                                                p0      =       i;
                                        }
                                        
                                        //cStripsT.eraseAtPos(i);
                                        cStripsT.erase(cStripsT.begin()+i);
                                        i--;
                                        r++;
                                        
                                        if ((i+1) != cStripsT.size()-1)
                                        {
                                                sigue   =       1;
                                        }
                                        else
                                        {
                                                sigue   =       0;
                                        }
                                        
                                }
                                else
                                {
                                        sigue   =       0;
                                }

                                if (!sigue && r)
                                {
                                        

                                        /*
                                        cDatos.push_back(p0);
                                        cDatos.push_back(r);

                                        r       =       0;
                                        k       =       long(cStripsT.size()-r-3);
                                        */
                                        long auxp0, auxr;
                                        //regLOD.strip= t;
                                        auxp0= p0;
                                        auxr= r;
                                                
                                        if (r==1)
                                        {
                                                while(r>0)
                                                {
                                                        cStripsT.insert(cStripsT.begin()+p0,cStripsT[p0]);
                                                        r--;
                                                }
                                                i=p0;
                                        }                                       
                                        else
                                        {
                                                if (r%2) //If r is odd the changes are undone
                                                {
                                                        cStripsT.insert(cStripsT.begin()+p0,cStripsT[p0]);
                                                        r--;
                                                        auxr=r;
                                                }
                                                //listaPos.push_back(pos);
                                                cDatos.push_back(auxp0);
                                                cDatos.push_back(auxr);
                                        if (regLOD.strip == this->MARCAVACIO)
                                        {
                                                regLOD.strip    =       t;
                                        }

                                        ++totalRegs;
                                        }


                                        r= 0;
                                        k=cStripsT.size()-3;

                                }

                                i++;
                        }
                        
                        regLOD.nL1      =       char(totalRegs);

                        //TERCERO: Simplificaciones de Longitud 2 tipo V1 V2 V1 V2 -> V1 V2
                        totalRegs       =       0;
                        i                                       =       0;
                        r                                       =       0;
                        sigue                   =       0;
                        k                                       =       long(cStripsT.size() - 4);
                        
                        while   (i < k)
                        {
                                if (    (cStripsT[i] == cStripsT[i+2])
                                                        &&
                                                        (cStripsT[i+1] == cStripsT[i+3])
                                                )
                                {
                                        if (!r)
                                        {
                                                p0      =       i;
                                        }
                                        
                                        //cStripsT.eraseAtPos(i);
                                        cStripsT.erase(this->cStrips[t].begin()+i);
                                        //cStripsT.eraseAtPos(i);
                                        cStripsT.erase(this->cStrips[t].begin()+i);
                                        r++;
                                        
                                        i       -=      2;
                                        
                                        if ((i+1) != cStripsT.size()-3)
                                        {
                                                sigue   =       1;
                                        }
                                        else
                                        {
                                                sigue   =       0;
                                        }
                                        
                                }
                                else
                                {
                                        sigue   =       0;
                                }

                                if (!sigue && r)
                                {
                                        if (regLOD.strip == this->MARCAVACIO)
                                        {
                                                regLOD.strip    =       t;
                                        }
                                        
                                        ++totalRegs;

                                        cDatos.push_back(p0);
                                        cDatos.push_back(r);
                                        
                                        r       =       0;
                                        k       =       long((cStripsT.size()-4-2*r));
                                }

                                i++;
                        }
                        
                        regLOD.nL2      =       char(totalRegs);
                        
                        if (regLOD.strip != this->MARCAVACIO)
                        {
                                RegsCambios++;
                                listaCambios.push_back(regLOD);
                        }
                }//     End for t.
                
                pCambios[lod]   =       RegsCambios;
        }//     End for lod.

        this->cCambios  =       listaCambios;

        //      Guardar el numero de LODS disponibles.
        this->TOTALCAMBIOS      =       this->LodsDisp=lod;

        //Retornar a la lista original
        this->cStrips   =       TiraOriginal;
}

//-----------------------------------------------------------------------
//Put in order vertex of Mesh from simplification sequence
//-----------------------------------------------------------------------
#include <time.h>
void LodStripsConstructor::OrdenarModeloVQSLIM(TIPOFUNC upb)
{
        unsigned long int i;
        unsigned long int j;
        unsigned long int t;
        unsigned long int v;
        long int vSig;
        long int k;
        VECTORVERTEX                            Vertices;
        std::vector<tipoVertice>                NuevosVerts;
        //vector        <VECTORINT>     NuevasTiras;
        std::vector<std::vector<int> > NuevasTiras;
//      VECTORINT                                               tira;
        std::vector<int> tira;
        vector  <Index>                 mV1Aux;
        tipoOrden                                               Orden;
        tipoOrden                                               *Ord;
        bool                                                            bEncontrado;
        long    int                                             c1;
        long    int                                             c2;
        //      Progress bar
        float                   percent;
        float                   increment;
        long    int     update;

        bEncontrado = false;

        int mStepsSize = geoMeshSQ->mSteps.size();

        c1                                      =       0;
        c2                                      =       0;
        
        update                  =       -1;
        percent                 =       1.0;
        increment               =       (float)(10.0) / (float)mStepsSize;
        
        for     (i = 0; i < mStepsSize; i++)
        {
                if (update      != (int)(i * increment))
                {
                        update  =       (int)(i * increment);
                        upb(percent);
                }
                
                const Geometry::MeshSimplificationSequence::Step & theStep = this->geoMeshSQ->mSteps[i];

                mV1Aux.push_back(theStep.mV1);

                Orden.vQslimNext        =       theStep.mV0;
                Orden.vQslim                    =       theStep.mV1;
                Orden.obligatorio       =       theStep.obligatorio;
                Orden.vLS                                       =       i;

                Orden.x                                         =       theStep.x;
                Orden.vLSNext                   =       -1;
                Orden.cambio                    =       "n";

                Ordenacion.push_back(Orden);
        }
        
        this->NumVertsRepetidos = c2;

        update          =       -1;
        increment       =       (float)(10.0) / (float)(Ordenacion.size());
        percent         =       1.0;

        //      Change all vertices that have x != 0.
        for(i   =       0;      i < Ordenacion.size();  i++)
        {
                if (update      != (int)(i * increment))
                {
                        update  = (int)(i * increment);
                        upb(percent);
                }
                
                Ord     =       &(Ordenacion[i]);

                if (Ord->x!=0)
                {
                        //      Change the simplification order.
                        v                                                               =       Ord->vQslim;
                        Ord->vQslim                     =       Ord->vQslimNext;
                        Ord->vQslimNext =       v;

                        for (j = i+1; j < Ordenacion.size(); j++)
                        {
                                tipoOrden & ordJ = Ordenacion[j];
                                if (ordJ.vQslim == Ord->vQslim)
                                {
                                        ordJ.vQslim     =       Ord->vQslimNext;
                                        ordJ.cambio     =       "y";
                                }
                                else if (ordJ.vQslimNext == Ord->vQslim)
                                {
                                        ordJ.vQslimNext =       Ord->vQslimNext;        
                                        ordJ.cambio                     =       "y";
                                }
                        }
                }
        }

        update          =       -1;
        increment       =       (float)(10.0) / (float)(Ordenacion.size());
        percent         =       1.0;

        //      3 seg.
        //Ordenacion de los vertices
        for(i = 0; i < Ordenacion.size(); i++)
        {
                if (update      !=      (int)(i * increment))
                {
                        update  =       (int)(i * increment);
                        upb(percent);
                }

                c1++;
                NuevosVerts.push_back(this->cVerts[Ordenacion[i].vQslim]);

                cVerts[Ordenacion[i].vQslim].Next       =       -1;

        }

        //      Añadir aquellos vertices que no estaban en NuevosVerts 
        //      y no se simplificaban.
        int cont                                =       0;
        int contestaban =       0;

        int cVertsSize = this->cVerts.size();
        for(i = 0; i < cVertsSize; i++)
        {
                if (this->cVerts[i].Next != -1)
                {
                        cont++;
                        NuevosVerts.push_back(this->cVerts[i]);
                        Orden.vLS                                       =       int(Ordenacion.size());
                        Orden.obligatorio       = 0;
                        Orden.vLSNext                   =       -1;
                        Orden.vQslim                    =       i;
                        Orden.vQslimNext        =       -1;

                        Ordenacion.push_back(Orden);
                }
                else
                {
                        contestaban++;
                }
        }

        update          =       -1;
        increment       =       (float)(10.0)   /       (float)(Ordenacion.size());
        percent         =       1.0;
        
        //      2 min.
        //      Calcular los siguiente teniendo en cuenta el simplif.
        for (i = 0; i < Ordenacion.size(); i++)
        {
                if (update      !=      (int)(i * increment))
                {
                        update  =       (int)(i * increment);
                        upb(percent);
                }
                
                v       =       Ordenacion[i].vQslimNext;

                //Buscar ese vertice v cual es ahora
                vSig    =       0;

                for (t = 0; t < Ordenacion.size() && !vSig;t++)
                {
                        if (Ordenacion[t].vQslim==v)
                        {
                                vSig=Ordenacion[t].vLS;
                        }
                }

                if (vSig!=0)
                {
                        Ordenacion[i].vLSNext   =       vSig;
                }
        }

        //Creacion de nuevas tiras con las mismas dimensiones
        int cStripsSize = this->cStrips.size();
        for(t = 0; t < cStripsSize; t++)
        {
                tira.clear();

                int cStripsSizeT = this->cStrips[t].size();
                for(i = 0; i < cStripsSizeT; i++)
                        tira.push_back(0);

                NuevasTiras.push_back(tira);
        }

        update          =       -1;
        increment       =       (float)(20.0) / (float)(NuevosVerts.size());
        percent         =       1.0;

        k       =       0;

        //      2 min.
        //Cambiar los vertices de las tiras
        int NuevosVertsSize = NuevosVerts.size();       
        for(v = 0; v < NuevosVertsSize; v++)
        {
                if (update != (int)(v * increment))
                {
                        update  =       (int)(v * increment);
                        upb(percent);
                }               

                const tipoOrden & OrdenacionV = Ordenacion[v];

                for(t = 0; t < cStrips.size(); t++)
                {
                        std::vector<int> & thisStrip = cStrips[t];                      
                        std::vector<int> & NuevasTirasT = NuevasTiras[t];
                        int cStripsSizeT = thisStrip.size();
                        for(i = 0; i < cStripsSizeT; i++)
                        {
                                if (thisStrip[i] == OrdenacionV.vQslim)
                                {
                                        k++;
                                        NuevasTirasT[i] =       v;
                                }
                        }
                }
        }

        //Cambiar a Tiras Nuevas
        this->cStrips   =       NuevasTiras;

        //NuevosVerts y Ordenacion = tamaño.
        NuevosVertsSize = NuevosVerts.size();
        for(i = 0; i < NuevosVertsSize; i++)
        {
                NuevosVerts[i].Next     =       Ordenacion[i].vLSNext;
        }

        //Cambiar cVerts por nuevosVerts.
        this->cVerts    =       NuevosVerts;

        //percent       =       100.0;
        //upb(percent);
}

//-----------------------------------------------------------------------------
//      Constructor of LodStripsConstructor object from
//      a Mesh and MeshSimplificationSequence
//      Constructor del objeto LodStripsConstructor.
//      Tomamos el Mesh y la secuencia de simplificacion que se pasan
//      como parametros y llamamos a la funcion GenerarModeloCompleto para
//      que se realicen las modificaciones a efectuar
//-----------------------------------------------------------------------------
LodStripsConstructor::LodStripsConstructor(const Mesh                                           *m,
                                                                                                                const MeshSimplificationSequence        *ms,
                                                                                                                        size_t                                                                                                          submesh,
                                                                                                                        TIPOFUNC                                                                                                        upb)
{
        MARCA   =       TOTALTIRAS      =       TOTALVERTS      =       TOTALCAMBIOS    =       0;
        
        meshoriginal            =       m;
        this->geoMesh           =       new Geometry::Mesh();
        *this->geoMesh  =       *m;
        this->geoMeshSQ = const_cast<MeshSimplificationSequence*>(ms);

        //      Set the leaves submesh.
        mSubMeshLeaves  =       submesh;
        this->GenerarModeloCompleto(upb);
}

//---------------------------------------------
//      Destructor LodStripsConstructor object
//      Destructor de la clase LodStripsConstructor
//---------------------------------------------
LodStripsConstructor::~LodStripsConstructor()
{
        delete [] vDatos;
        delete [] vCambios;
/*      vector <LODData> cCambiosTemp;
        cCambios.swap(cCambiosTemp);*/
        cCambios.clear();

/*      VECTORUNINT cDatosTemp;
        cDatos.swap(cDatosTemp);*/
        cDatos.clear();

        delete [] vStrips;

        delete [] vVerts;

//      vector <VECTORINT> cStripsTemp;
//      cStrips.swap(cStripsTemp);;
        cStrips.clear();

//      VECTORVERTEX cVertsTemp;
//      cVerts.swap(cVertsTemp);
        cVerts.clear();

        delete [] pCambios;

        delete this->geoMesh;
}

//------------------------------------------------------------------------------
//      build lod file with necessary information and save all changes at
//      lodStripConstructor object
//      Construimos el archivo Lod donde se guarda la informacion sobre los
//      cambios realizados en el mesh
//      y copiamos todos los cambios realizados sobre las estructuras que
//      contienen los vertices y los indices 
//      modificados sobre el objeto Mesh de la clase
//------------------------------------------------------------------------------
void LodStripsConstructor::Save(Serializer &oSerializer)
{
        unsigned int    i, j;
        int                                             k       =       0;
        char                                    simp[256];

        //******************  1º CONSTRUCCION DEL FICHERO.LOD *********************

        //      VERTICES.
        for(i = 0; i < this->cVerts.size(); i++)
        {
                sprintf(simp,"v %d\n",cVerts[i].Next);
                oSerializer.WriteData(simp,sizeof(char),strlen(simp));
        }

        //      CSTRIPS.
        this->TOTALINDICES      =       0;
        
        for(i = 0; i < this->cStrips.size(); i++)
        {
                this->TOTALINDICES += int(this->cStrips[i].size());
        }

        //      lines starting with a d.
        //      Changes
        for(i = 0; i < this->cCambios.size(); i++)
        {
                sprintf(simp,"c\n");
                oSerializer.WriteData(simp,sizeof(char),strlen(simp));
                
                sprintf(simp,
                                                "d %u %u %u %u %u\n",
                                                cCambios[i].strip,
                                                cCambios[i].nP,
                                                cCambios[i].nL1,
                                                cCambios[i].nL2,
                                                cCambios[i].obligatory);
                
                oSerializer.WriteData(simp,sizeof(char),strlen(simp));
        }
        //      Lines starting with a b.
        //      Data.
        sprintf(simp,"a\n");
        oSerializer.WriteData(simp,sizeof(char),strlen(simp));
        
        for(i = 0; i < this->cDatos.size(); i++)
        {
                sprintf(simp,"b %d\n",cDatos[i]);

                oSerializer.WriteData(simp,sizeof(char),strlen(simp));
        }

        //      lines starting with a p.
        //      Chages made in a LOD.
        for(i = 0; i < this->TOTALCAMBIOS; i++)
        {
                sprintf(simp,"p %d\n",this->pCambios[i]);

                oSerializer.WriteData(simp,sizeof(char),strlen(simp));
        }

        oSerializer.WriteData("\n",sizeof(char),1);

        //*******************  2º DEVOLVER EL MESH CON LAS MODIFICACIONES EFECTUADAS  *********************
        int num_no      =       0;

        if(this->geoMesh->mSubMesh[0].mSharedVertexBuffer == true)
        {
                //mPosition
                delete[] this->geoMesh->mVertexBuffer->mPosition;
                this->geoMesh->mVertexBuffer->mPosition = new Vector3[this->cVerts.size()];

                //mNormal
                if (meshoriginal->mSubMesh[0].mVertexBuffer->mVertexInfo & Geometry::VERTEX_NORMAL)
                {
                        delete[] this->geoMesh->mVertexBuffer->mNormal;
                        this->geoMesh->mVertexBuffer->mNormal = new Vector3[this->cVerts.size()];
                }

                //mTexCoords
                if (meshoriginal->mSubMesh[0].mVertexBuffer->mVertexInfo & Geometry::VERTEX_TEXCOORDS)
                {
                        delete[] this->geoMesh->mVertexBuffer->mTexCoords;
                        this->geoMesh->mVertexBuffer->mTexCoords = new Vector2[this->cVerts.size()];
                }

                this->geoMesh->mVertexBuffer->mVertexCount      =       this->cVerts.size();
                this->geoMesh->mVertexBuffer->mVertexInfo               =       this->meshoriginal->mSubMesh[0].mVertexBuffer->mVertexInfo;

                for(i = 0; i < this->geoMesh->mSubMeshCount; i++)
                {
                        this->geoMesh->mSubMesh[i].mVertexBuffer                                =       this->geoMesh->mVertexBuffer;
                        this->geoMesh->mSubMesh[i].mSharedVertexBuffer  =       true;
                }

                int     indice  =       0;

                for (j = 0; j < this->cVerts.size(); j++)
                {
                        //Copiamos las coordeandas de posicion 
                        this->geoMesh->mVertexBuffer->mPosition[indice].x       =       this->cVerts[j].Vertex[0];
                        this->geoMesh->mVertexBuffer->mPosition[indice].y       =       this->cVerts[j].Vertex[1];
                        this->geoMesh->mVertexBuffer->mPosition[indice].z       =       this->cVerts[j].Vertex[2];

                        //Copiamos las normales
                        if (meshoriginal->mVertexBuffer->mVertexInfo & Geometry::VERTEX_NORMAL)
                        {
                                this->geoMesh->mVertexBuffer->mNormal[indice].x =       this->cVerts[j].Normal[0];
                                this->geoMesh->mVertexBuffer->mNormal[indice].y =       this->cVerts[j].Normal[1];
                                this->geoMesh->mVertexBuffer->mNormal[indice].z =       this->cVerts[j].Normal[2];
                        }

                        //Copiamos las coordenadas de textura
                        if (meshoriginal->mVertexBuffer->mVertexInfo & Geometry::VERTEX_TEXCOORDS)
                        {
                                this->geoMesh->mVertexBuffer->mTexCoords[indice].x      =       this->cVerts[j].TexCoords[0];
                                this->geoMesh->mVertexBuffer->mTexCoords[indice].y      =       this->cVerts[j].TexCoords[1];
                        }

                        indice++;

                }

                this->geoMesh->mVertexBuffer->mVertexCount      =       indice;
        }
        else    //OSCAR
        {
                //Supondre que solo tengo un submesh con vertices no compartidos
                //mPosition
                delete[]        this->geoMesh->mSubMesh[0].mVertexBuffer->mPosition;
                
                this->geoMesh->mSubMesh[0].mVertexBuffer->mPosition     =       new Vector3[this->cVerts.size()];

                //mNormal
                if (meshoriginal->mSubMesh[0].mVertexBuffer->mVertexInfo & Geometry::VERTEX_NORMAL)
                {
                        delete[] this->geoMesh->mSubMesh[0].mVertexBuffer->mNormal;
                        this->geoMesh->mSubMesh[0].mVertexBuffer->mNormal = new Vector3[this->cVerts.size()];
                }

                //mTexCoords
                if (meshoriginal->mSubMesh[0].mVertexBuffer->mVertexInfo & Geometry::VERTEX_TEXCOORDS)
                {
                        delete[] this->geoMesh->mSubMesh[0].mVertexBuffer->mTexCoords;
                        this->geoMesh->mSubMesh[0].mVertexBuffer->mTexCoords = new Vector2[this->cVerts.size()];
                }

                this->geoMesh->mSubMesh[0].mVertexBuffer->mVertexCount =this->cVerts.size();
                this->geoMesh->mSubMesh[0].mVertexBuffer->mVertexInfo = this->meshoriginal->mSubMesh[0].mVertexBuffer->mVertexInfo;

                this->geoMesh->mSubMesh[0].mSharedVertexBuffer=false;

                int indice=0;
                for (j=0; j<this->cVerts.size(); j++)
                {
                        //Copiamos las coordeandas de posicion 
                        this->geoMesh->mSubMesh[0].mVertexBuffer->mPosition[indice].x=this->cVerts[j].Vertex[0];
                        this->geoMesh->mSubMesh[0].mVertexBuffer->mPosition[indice].y=this->cVerts[j].Vertex[1];
                        this->geoMesh->mSubMesh[0].mVertexBuffer->mPosition[indice].z=this->cVerts[j].Vertex[2];

                        //Copiamos las normales
                        if (meshoriginal->mSubMesh[0].mVertexBuffer->mVertexInfo & Geometry::VERTEX_NORMAL)
                        {
                                this->geoMesh->mSubMesh[0].mVertexBuffer->mNormal[indice].x=this->cVerts[j].Normal[0];
                                this->geoMesh->mSubMesh[0].mVertexBuffer->mNormal[indice].y=this->cVerts[j].Normal[1];
                                this->geoMesh->mSubMesh[0].mVertexBuffer->mNormal[indice].z=this->cVerts[j].Normal[2];
                        }

                        //Copiamos las coordenadas de textura
                        if (meshoriginal->mSubMesh[0].mVertexBuffer->mVertexInfo & Geometry::VERTEX_TEXCOORDS)
                        {
                                this->geoMesh->mSubMesh[0].mVertexBuffer->mTexCoords[indice].x=this->cVerts[j].TexCoords[0];
                                this->geoMesh->mSubMesh[0].mVertexBuffer->mTexCoords[indice].y=this->cVerts[j].TexCoords[1];
                        }
                        indice++;
                }
                this->geoMesh->mSubMesh[0].mVertexBuffer->mVertexCount =indice;
        }
        


        int indice_acum = 0;
        for(i=0;i<this->geoMesh->mSubMeshCount;i++)
        {
                Geometry::SubMesh & subMesh = meshoriginal->mSubMesh[i];
                Geometry::SubMesh & geoMeshSubMesh = this->geoMesh->mSubMesh[i];

                for (size_t ind=0; ind < subMesh.mIndexCount; ind++) 
                {
                        Index indIndex = subMesh.mIndex[ind];
                        if (subMesh.mVertexBuffer->mVertexInfo & Geometry::VERTEX_TEXCOORDS)
                        {
                                //Hay coordenadas de textura y normales
                                if(subMesh.mVertexBuffer->mVertexInfo & Geometry::VERTEX_NORMAL)
                                {
                                        for (size_t indvo=0; indvo<geoMeshSubMesh.mVertexBuffer->mVertexCount; indvo++)
                                        {
                                                if (igual(subMesh.mVertexBuffer->mPosition[indIndex],geoMeshSubMesh.mVertexBuffer->mPosition[indvo]))
                                                {
                                                        if (igual(subMesh.mVertexBuffer->mNormal[indIndex],geoMeshSubMesh.mVertexBuffer->mNormal[indvo]))
                                                        {
                                                                if (igual(subMesh.mVertexBuffer->mTexCoords[indIndex],geoMeshSubMesh.mVertexBuffer->mTexCoords[indvo]))
                                                                {
                                                                        geoMeshSubMesh.mIndex[ind]= int(indvo);//+indice_acum;
                                                                }
                                                        }
                                                }
                                        }
                                }
                                else            //Hay coordenadas de textura pero no hay normales
                                {
                                        for (size_t indvo=0; indvo<geoMeshSubMesh.mVertexBuffer->mVertexCount; indvo++)
                                        {
                                                if (igual(subMesh.mVertexBuffer->mPosition[indIndex],geoMeshSubMesh.mVertexBuffer->mPosition[indvo]))
                                                {
                                                        if (igual(subMesh.mVertexBuffer->mTexCoords[indIndex],geoMeshSubMesh.mVertexBuffer->mTexCoords[indvo]))
                                                        {
                                                                geoMeshSubMesh.mIndex[ind]=int(indvo);//+indice_acum;
                                                        }
                                                }
                                        }
                                }
                        }
                        else
                        {
                                // No hay coordenadas de textura pero si normales
                                if(subMesh.mVertexBuffer->mVertexInfo & Geometry::VERTEX_NORMAL)
                                {
                                        for (size_t indvo=0; indvo<geoMeshSubMesh.mVertexBuffer->mVertexCount; indvo++)
                                        {
                                                if (igual(subMesh.mVertexBuffer->mPosition[indIndex],geoMeshSubMesh.mVertexBuffer->mPosition[indvo]))
                                                {
                                                        if (igual(subMesh.mVertexBuffer->mNormal[indIndex],geoMeshSubMesh.mVertexBuffer->mNormal[indvo]))
                                                        {
                                                                geoMeshSubMesh.mIndex[ind]=int(indvo);//+indice_acum;
                                                        }
                                                }
                                        }
                                }
                                else            //No hay coordenadas de texturas ni normales
                                {
                                        for (size_t indvo=0; indvo<geoMeshSubMesh.mVertexBuffer->mVertexCount; indvo++)
                                        {
                                                if (igual(subMesh.mVertexBuffer->mPosition[indIndex],geoMeshSubMesh.mVertexBuffer->mPosition[indvo]))
                                                {
                                                        geoMeshSubMesh.mIndex[ind]=int(indvo);//+indice_acum;
                                                }
                                        }
                                }
                        }
                }
        }
        
}

int LodStripsConstructor::igual(Geometry::Vector3 vo,Geometry::Vector3 vc)
{
        if (vo.x==vc.x && vo.y==vc.y && vo.z==vc.z)
                return 1;
        else
                return 0;
}

int LodStripsConstructor::igual(Geometry::Vector2 vo,Geometry::Vector2 vc)
{
        if (vo.x==vc.x && vo.y==vc.y)
                return 1;
        else
                return 0;
}

void LodStripsConstructor::Load(Serializer &oSerializer)
{
}

//-----------------------------------------------------------------------------------------------
//Call leeVerticesyTirasDeMesh, OrdenarModeloVQSLIM and CalcularCambiosLODsVNuevaED to make changes 
//at vertex and index strutures
//Llama a los metodos que realizan los cambios sobre las estructuras que contienen la informacion 
//de los vertices y los indices
//-----------------------------------------------------------------------------------------------

void LodStripsConstructor::GenerarModeloV(TIPOFUNC      upb)
{
        long int        max;
        long int        t;
        unsigned long int       i;
        float                   percent;

        percent =       10;

        this->leeVerticesyTirasDeMesh();

        upb(percent);

        //      6 min.  
        this->OrdenarModeloVQSLIM(upb);

        //Calcular el tamaño maximo de tira
        max     =       0;

        for(i = 0; i < this->TOTALTIRAS; i++)
        {
                t       =       long(this->cStrips[i].size());
                
                if (t > max)
                {
                        max     =       t;
                }
        }

        this->MARCA     =       max + 1;
        this->CalcularCambiosLODsVNuevaED(upb);
}

//-----------------------------------------------------------------------------------------
//It fills structs with vertex and index information
//Rellena estructuras de datos que contienen la informacion de vertices y tiras modificadas
//-----------------------------------------------------------------------------------------
void LodStripsConstructor::CopiarVectors2ArraysNUEVAED()
{
        unsigned int            i;
        unsigned int            j;
        uint32                  max;
        uint32                  t;
        VECTORINT               tira;
        LODChanges      listaCambios;

        //      ALLOCATE----------------
        this->TOTALVERTS        =       int(this->cVerts.size());
        this->TOTALTIRAS        =       int(this->cStrips.size());
        this->vVerts                    =       new tipoVertice[this->TOTALVERTS];
        this->lStripsV          =       new VECTORINT[this->TOTALTIRAS];
        this->vDatos                    =       new uint32[cDatos.size()];
        
        //      Calcular el tamaño maximo de tira y el numero de caras total.
        max                                                             =       0;
        this->TOTALCARAS        =       0;

        for     (i = 0; i < this->cStrips.size(); i++)
        {
                t       =       int(this->cStrips[i].size());
                
                if (t > max)
                {
                        max     =       t;
                }

                this->TOTALCARAS        +=      (t-2);
        }
        
        this->vStrips   =       Allocate2DArrayINT(this->TOTALTIRAS,max+1);
        this->MARCA             =       int(this->cVerts.size());
        vCambios                        =       new LODData[this->cCambios.size()];
        
        //      Rellenar vChanges.
        for     (i = 0; i < this->cCambios.size();++i)
        {
                vCambios[i]     =       cCambios[i];
        }
        
        for (i = 0; i < this->cStrips.size(); i++)
        {
                for (j = 0; j < this->cStrips[i].size(); j++)
                {
                        //      Rellenar el array vStrips.
                        this->vStrips[i][j]     = this->cStrips[i][j];
                        
                        //      Rellenar el vVector.
                        this->lStripsV[i].push_back(this->cStrips[i][j]);
                }
                
                this->vStrips[i][j]     =       this->MARCA;
        }

        for (i = 0; i < cDatos.size(); i++)
        {
                vDatos[i]       =       cDatos[i];
        }
        
        pCurrentData    =       vDatos;

        //      Meter los vertices en vVerts.
        for     (i = 0; i < this->cVerts.size(); i++)
        {
                this->vVerts[i] =       this->cVerts[i];
        }

}

//---------------------------------------------------------------------------------------------------
//It fills cVerts and cStrips with original Mesh vertex and strips information 
//Rellena las estructuras cVerts Y cStrips a partir de de los vertices y las tiras del mesh original
//---------------------------------------------------------------------------------------------------
void LodStripsConstructor::leeVerticesyTirasDeMesh()
{
        tipoVertice     vAux;
        std::vector<int>                tira;
        size_t                  i;
        size_t                  j;
        bool                            error;

        error   =       false;
        
        if(this->geoMesh->mSubMeshCount == 1)
        {
                error   =       false;
        }
        else
        {
                for     (i = 0; i < this->geoMesh->mSubMeshCount;i++)
                {
                        if      (this->geoMesh->mSubMesh[i].mSharedVertexBuffer == true)
                        {
                                error   =       false;
                        }
                        else
                        {
                                error   =       true;
                                break;
                        }
                }
        }
        
        if(!error)
        {
                if      (       (this->geoMesh->mSubMesh[0].mSharedVertexBuffer == true)
                                        &&
                                        (this->geoMesh->mSubMeshCount > 1)
                                )
                {
                        for     (j = 0; j < this->geoMesh->mVertexBuffer->mVertexCount; j++)
                        {
                                //      Si hay mas de un submesh ListaIndices no se rellena correctamente
                                vAux.Vertex[0] = this->geoMesh->mVertexBuffer->mPosition[j].x;
                                vAux.Vertex[1] = this->geoMesh->mVertexBuffer->mPosition[j].y;
                                vAux.Vertex[2] = this->geoMesh->mVertexBuffer->mPosition[j].z;

                                //      Añadimos las normales en cVerts.
                                if      (       this->geoMesh->mVertexBuffer->mVertexInfo
                                                        &
                                                        Geometry::VERTEX_NORMAL
                                                )
                                {
                                        vAux.Normal[0] = this->geoMesh->mVertexBuffer->mNormal[j].x;
                                        vAux.Normal[1] = this->geoMesh->mVertexBuffer->mNormal[j].y;
                                        vAux.Normal[2] = this->geoMesh->mVertexBuffer->mNormal[j].z;
                                }

                                //      Añadimos las coordenadas de textura a cVerts.
                                if      (       this->geoMesh->mVertexBuffer->mVertexInfo
                                                        &
                                                        Geometry::VERTEX_TEXCOORDS
                                                )
                                {
                                        vAux.TexCoords[0] = this->geoMesh->mVertexBuffer->mTexCoords[j].x;
                                        vAux.TexCoords[1] = this->geoMesh->mVertexBuffer->mTexCoords[j].y;
                                }

                                vAux.Next                       =       -10;
                                vAux.numMesh    =       0;
                        
                                vAux.obligatorio        =       0;
                                
                                this->cVerts.push_back(vAux);
                        }
                }
                else
                {
                        for     (i = 0; i < this->geoMesh->mSubMeshCount; i++)
                        {
                                for     (       j = 0;
                                                j < this->geoMesh->mSubMesh[i].mVertexBuffer->mVertexCount;
                                                j++)
                                {
                                        //      Si hay mas de un submesh ListaIndices 
                                        //      no se rellena correctamente.
                                        vAux.Vertex[0] = this->geoMesh->mSubMesh[i].
                                                mVertexBuffer->mPosition[j].x;
                                        vAux.Vertex[1] = this->geoMesh->mSubMesh[i].
                                                mVertexBuffer->mPosition[j].y;
                                        vAux.Vertex[2] = this->geoMesh->mSubMesh[i].
                                                mVertexBuffer->mPosition[j].z;
                                        //      Añadimos las normales en cVerts.
                                        vAux.Normal[0] = this->geoMesh->mSubMesh[i].
                                                mVertexBuffer->mNormal[j].x;
                                        vAux.Normal[1] = this->geoMesh->mSubMesh[i].
                                                mVertexBuffer->mNormal[j].y;
                                        vAux.Normal[2] = this->geoMesh->mSubMesh[i].
                                                mVertexBuffer->mNormal[j].z;

                                        //      Añadimos las coordenadas de textura a cVerts.
                                        vAux.TexCoords[0]       =       this->geoMesh->mSubMesh[i].
                                                mVertexBuffer->mTexCoords[j].x;
                                        vAux.TexCoords[1] = this->geoMesh->mSubMesh[i].
                                                mVertexBuffer->mTexCoords[j].y;

                                        vAux.Next                       =       -10;
                                        vAux.numMesh    =       int(i);

                                        this->cVerts.push_back(vAux);
                                }
                        }
                }       

                Index   indice_acum;
                Index   num_vert;

                num_vert        =       0;
                
                for     (i = 0; i < this->geoMesh->mSubMeshCount; i++)
                {
                        //      If is not the leaves submesh.
                        if (mSubMeshLeaves != i)
                        {
                                indice_acum     =       0;

                                for     (j = 0; j < this->geoMesh->mSubMesh[i].mStripCount; j++)
                                {
                                        Index   *aux    =       this->geoMesh->mSubMesh[i].mStrip[j];

                                        /*
                                        if (j != 0)
                                        {
                                                // La primera tira no empieza por índices repetidos.
                                                aux     =       aux+1;

                                                indice_acum++;
                                        }
                                        */

                                        if (j+1 < this->geoMesh->mSubMesh[i].mStripCount)
                                        {
                                                Index   *siguiente      =       this->geoMesh->mSubMesh[i].mStrip[j+1];

                                                tira.clear();

                                                while (aux != siguiente)
                                                {
                                                        tira.push_back(*aux);
                                                        indice_acum++;

                                                        aux     =       aux + 1;
                                                }

                                                //tira.pop_back();

                                                this->cStrips.push_back(tira);
                                        }
                                        else
                                        {
                                                // Insertar los indices de la última tira en el cStrips
                                                tira.clear();

                                                for     (       unsigned int k = indice_acum;
                                                                k < this->geoMesh->mSubMesh[i].mIndexCount;
                                                                k++)
                                                {
                                                        tira.push_back(this->geoMesh->mSubMesh[i].mIndex[k]);
                                                }

                                                this->cStrips.push_back(tira);
                                        }
                                }

                                num_vert        +=      int(this->geoMesh->mSubMesh[i].
                                        mVertexBuffer->mVertexCount);
                        }
                }

                this->TOTALVERTS        =       int(cVerts.size());
                this->TOTALTIRAS        =       int(cStrips.size());
        }
        else
        {
                //      Error.
        }
}

//      GetMesh: Return de current Mesh.
Mesh    *       LodStripsConstructor::GetMesh()
{
        Mesh            *mesh_built;

        mesh_built              =       new Mesh();
        *mesh_built             =       *geoMesh;

        return  mesh_built;
}

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