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

#include <iostream>
#include <fstream>
#include <time.h>
#include "GeoLodStripsConstructor.h"
#include "GeoMeshLoader.h"

using namespace Geometry;

//---------------------------------------------------------------------------
//      Call GenerarModeloV and CopiarVectorsArraysNUEVAED to make changes.
//---------------------------------------------------------------------------
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)
{
        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;
        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++)
        {
                tipoVertice & cVertsLOD = this->cVerts[lod];
                
                RegsCambios                             =       0;
                regLOD.obligatory       =       this->Ordenacion[lod].obligatory;
                
                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       =       (long)(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
//-------------------------------------------------------------------------
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;
        std::vector<std::vector<int> >  NuevasTiras;
        std::vector<int>                                                                tira;

        tipoOrden                       Orden;
        tipoOrden                       *Ord;
        bool                                    bEncontrado;

        //      Progress bar
        float                   percent;
        float                   increment;
        long    int     update;

        VertexBoneAssignment    bone;

        bEncontrado = false;

        size_t  mStepsSize = mGeoMeshSQ->mSteps.size();

        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 MeshSimplificationSequence::Step & theStep = this->mGeoMeshSQ->mSteps[i];

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

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

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

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

                int OrdvQslim = Ordenacion[i].vQslim;
                //int OrdvQslimNext = Ordenacion[i].vQslimNext;

                NuevosVerts.push_back(this->cVerts[OrdvQslim]);

                cVerts[OrdvQslim].Next  =       -1;
        }

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

        size_t  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.obligatory        = 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;
                }
        
                //      Bone reassignment.
                for (size_t assig = 0; assig < mInitialMesh->mBones.size(); assig++)
                {
                        if (mInitialMesh->mBones[assig].vertexIndex == Ordenacion[i].vQslim)
                        {
                                bone.vertexIndex        =       i;
                                bone.boneIndex          =       mInitialMesh->mBones[assig].boneIndex;
                                bone.weight                             =       mInitialMesh->mBones[assig].weight;

                                mGeoMesh->mBones.push_back(bone);
                        }
                }
        }

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

                size_t  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
        size_t  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];
                        size_t  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.
//-------------------------------------------------------------------------
LodStripsConstructor::LodStripsConstructor(const Mesh                                           *m,
                                                                                                                const MeshSimplificationSequence        *ms,
                                                                                                                        size_t                                                                                                          submesh,
                                                                                                                        TIPOFUNC                                                                                                        upb)
{
        MARCA   =       TOTALTIRAS      =       TOTALVERTS      =       TOTALCAMBIOS    =       0;
        
        meshoriginal    =       m;
        
        mGeoMesh                        =       new Mesh();
        *mGeoMesh                       =       *m;

        //      Initialize bones assignments.
        mGeoMesh->mBones.clear();

        mInitialMesh    =       new Mesh();
        *mInitialMesh   =       *m;
        
        this->mGeoMeshSQ        =       const_cast<MeshSimplificationSequence*>(ms);

        //      Add new vertices to mesh.
        AddNewVertices();

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

//-------------------------------------------------------------------------
//      Destructor LodStripsConstructor object
//-------------------------------------------------------------------------
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  mInitialMesh;
        delete  mGeoMesh;
}

//-------------------------------------------------------------------------
//      Build lod file with necessary information and save all changes at
//      lodStripConstructor object.
//-------------------------------------------------------------------------
void LodStripsConstructor::Save(std::string filename)
{
        int vertexCount         =       (int)this->cVerts.size();
        int changesCount        =       (int)this->cCambios.size();
        int dataCount                   =       (int)this->cDatos.size();
        int cambiosCount        =       this->TOTALCAMBIOS;
        int size                                        =       changesCount*sizeof(LODData)
                                                                                        +
                                                                                        (vertexCount + dataCount + cambiosCount + 4)
                                                                                        *
                                                                                        sizeof(int)
                                                                                        +
                                                                                        CHUNK_OVERHEAD_SIZE;

        FILE *f =       fopen(filename.c_str(),"ab");

        unsigned short chunkid  =       0xabcd;

        fwrite(&chunkid,sizeof(unsigned short),1,f);
        fwrite(&size,sizeof(unsigned long),1,f);

        // VERTICES.
        fwrite(&vertexCount, sizeof(int), 1, f);

        for (size_t     i = 0; i < this->cVerts.size(); i++)
        {
                int auxv        =       cVerts[i].Next;
                fwrite(&auxv, sizeof(int), 1, f);
        }

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

        //      lines starting with a d.
        //      Changes
        fwrite(&changesCount, sizeof(int), 1, f);

        for(size_t      i = 0; i < this->cCambios.size(); i++)
        {
                LODData change= cCambios[i];
                fwrite(&change, sizeof(LODData), 1, f);
        }

        //      Data.
        fwrite(&dataCount, sizeof(int), 1, f);

        for(size_t      i = 0; i < this->cDatos.size(); i++)
        {
                int data= cDatos[i];
                fwrite(&data, sizeof(int), 1, f);
        }

        //      lines starting with a p.
        //      Chages made in a LOD.
        fwrite(&cambiosCount, sizeof(int), 1, f);

        for(size_t      i = 0; i < this->TOTALCAMBIOS; i++)
        {
                int cambio= pCambios[i];
                fwrite(&cambio, sizeof(int), 1, f);
        }

        fclose(f);
}

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.
//---------------------------------------------------------------------------
void LodStripsConstructor::GenerarModeloV(TIPOFUNC      upb)
{
        long int        max;
        long int        t;
        unsigned long int       i;
        float                   percent;

        percent =       10;

        this->leeVerticesyTirasDeMesh();

        upb(percent);

        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.
//---------------------------------------------------------------------------
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.
//---------------------------------------------------------------------------
void LodStripsConstructor::leeVerticesyTirasDeMesh()
{
        tipoVertice     vAux;
        std::vector<int>                tira;
        size_t                  i;
        size_t                  j;
        bool                            error;

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

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

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

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

                                        //      Añadimos las coordenadas de textura a cVerts.
                                        vAux.TexCoords[0]       =       this->mGeoMesh->mSubMesh[i].
                                                mVertexBuffer->mTexCoords[j].x;
                                        vAux.TexCoords[1] = this->mGeoMesh->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;

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

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

                                        // remove strip degenerates (first indices) except for the first (DEG!)
                                        if (j != 0)
                                        {
                                                // La primera tira no empieza por índices repetidos.
                                                aux     = aux+1;
                                                indice_acum++;
                                        }
                                        
                                        if (j+1 < this->mGeoMesh->mSubMesh[i].mStripCount)
                                        {
                                                Index   *siguiente      =       this->mGeoMesh->mSubMesh[i].mStrip[j+1];

                                                tira.clear();

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

                                                        aux     =       aux + 1;
                                                }

                                                // DEG!: remove strip degenerates (last indices) except for the last strip
                                                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->mGeoMesh->mSubMesh[i].mIndexCount;
                                                                k++)
                                                {
                                                        tira.push_back(this->mGeoMesh->mSubMesh[i].mIndex[k]);
                                                }

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

                                num_vert        +=      int(this->mGeoMesh->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             =       *mGeoMesh;

        return  mesh_built;
}

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

//---------------------------------------------------------------------------
//      Update mesh.
//---------------------------------------------------------------------------
void LodStripsConstructor::UpdateMesh(void)
{
        int num_no      =       0;
        //int i=0,j=0;

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

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

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

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

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

                int     indice  =       0;

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

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

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

                        indice++;
                }

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

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

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

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

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

                int     indice  =       0;

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

                        //Copiamos las normales
                        if (meshoriginal->mSubMesh[0].mVertexBuffer->mVertexInfo & Geometry::VERTEX_NORMAL)
                        {
                                this->mGeoMesh->mSubMesh[0].mVertexBuffer->mNormal[indice].x=this->cVerts[j].Normal[0];
                                this->mGeoMesh->mSubMesh[0].mVertexBuffer->mNormal[indice].y=this->cVerts[j].Normal[1];
                                this->mGeoMesh->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->mGeoMesh->mSubMesh[0].mVertexBuffer->mTexCoords[indice].x=this->cVerts[j].TexCoords[0];
                                this->mGeoMesh->mSubMesh[0].mVertexBuffer->mTexCoords[indice].y=this->cVerts[j].TexCoords[1];
                        }
                        indice++;
                }
                this->mGeoMesh->mSubMesh[0].mVertexBuffer->mVertexCount =indice;
        }
        
        int indice_acum = 0;

        for(size_t      i = 0;  i < this->mGeoMesh->mSubMeshCount;      i++)
        {
                Geometry::SubMesh & subMesh = meshoriginal->mSubMesh[i];
                Geometry::SubMesh & mGeoMeshSubMesh = this->mGeoMesh->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<mGeoMeshSubMesh.mVertexBuffer->mVertexCount; indvo++)
                                        {
                                                if (igual(subMesh.mVertexBuffer->mPosition[indIndex],mGeoMeshSubMesh.mVertexBuffer->mPosition[indvo]))
                                                {
                                                        if (igual(subMesh.mVertexBuffer->mNormal[indIndex],mGeoMeshSubMesh.mVertexBuffer->mNormal[indvo]))
                                                        {
                                                                if (igual(subMesh.mVertexBuffer->mTexCoords[indIndex],mGeoMeshSubMesh.mVertexBuffer->mTexCoords[indvo]))
                                                                {
                                                                        mGeoMeshSubMesh.mIndex[ind]= int(indvo);//+indice_acum;
                                                                }
                                                        }
                                                }
                                        }
                                }
                                else            //Hay coordenadas de textura pero no hay normales
                                {
                                        for (size_t indvo=0; indvo<mGeoMeshSubMesh.mVertexBuffer->mVertexCount; indvo++)
                                        {
                                                if (igual(subMesh.mVertexBuffer->mPosition[indIndex],mGeoMeshSubMesh.mVertexBuffer->mPosition[indvo]))
                                                {
                                                        if (igual(subMesh.mVertexBuffer->mTexCoords[indIndex],mGeoMeshSubMesh.mVertexBuffer->mTexCoords[indvo]))
                                                        {
                                                                mGeoMeshSubMesh.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<mGeoMeshSubMesh.mVertexBuffer->mVertexCount; indvo++)
                                        {
                                                if (igual(subMesh.mVertexBuffer->mPosition[indIndex],mGeoMeshSubMesh.mVertexBuffer->mPosition[indvo]))
                                                {
                                                        if (igual(subMesh.mVertexBuffer->mNormal[indIndex],mGeoMeshSubMesh.mVertexBuffer->mNormal[indvo]))
                                                        {
                                                                mGeoMeshSubMesh.mIndex[ind]=int(indvo);//+indice_acum;
                                                        }
                                                }
                                        }
                                }
                                else            //No hay coordenadas de texturas ni normales
                                {
                                        for (size_t indvo=0; indvo<mGeoMeshSubMesh.mVertexBuffer->mVertexCount; indvo++)
                                        {
                                                if (igual(subMesh.mVertexBuffer->mPosition[indIndex],mGeoMeshSubMesh.mVertexBuffer->mPosition[indvo]))
                                                {
                                                        mGeoMeshSubMesh.mIndex[ind]=int(indvo);//+indice_acum;
                                                }
                                        }
                                }
                        }
                }
        }
}

//-------------------------------------------------------------------------
//      Add new vertices to mesh.
//-------------------------------------------------------------------------
void LodStripsConstructor::AddNewVertices()
{
        size_t                          num_vertices;
        size_t                          bones_count;
        SubMesh                         *geosubmesh;
        VertexBuffer    *vertex_buffer;
        VertexBuffer    *new_vertex_buffer;

        vector<VertexBoneAssignment>::iterator  it;

        //      Gets old vertex buffer.
        vertex_buffer   =       mGeoMesh->mVertexBuffer;
        
        num_vertices    =       vertex_buffer->mVertexCount
                                                                        +
                                                mGeoMeshSQ->mNewVertices.size();

        //      Initialize auxiliar vertex buffer.
        new_vertex_buffer       =       new     VertexBuffer();

        new_vertex_buffer->mVertexCount =       num_vertices;
        
        new_vertex_buffer->mPosition            =       new     Vector3[num_vertices];
        new_vertex_buffer->mNormal                      =       new     Vector3[num_vertices];
        new_vertex_buffer->mTexCoords           =       new     Vector2[num_vertices];

        new_vertex_buffer->mVertexInfo  =       vertex_buffer->mVertexInfo;

        //      Num old vertices.
        num_vertices    =       vertex_buffer->mVertexCount;

        //      Copy the old vertex buffer.
        for     (unsigned       int     i       =       0;      i < num_vertices;       i++)
        {
                new_vertex_buffer->mPosition[i] =       vertex_buffer->mPosition[i];
                new_vertex_buffer->mNormal[i]   =       vertex_buffer->mNormal[i];
                new_vertex_buffer->mTexCoords[i]=       vertex_buffer->mTexCoords[i];
        }

        //      Copy new vertices.
        for (unsigned   int     i       =       0;      i < mGeoMeshSQ->mNewVertices.size();    i++)
        {
                new_vertex_buffer->mPosition[num_vertices + i] =
                                                                                                                                                mGeoMeshSQ->mNewVertices[i].position;

                new_vertex_buffer->mTexCoords[num_vertices + i] =
                                                                                                                                                mGeoMeshSQ->mNewVertices[i].texcoord;

                new_vertex_buffer->mNormal[num_vertices + i] =
                                                                                                                                                mGeoMeshSQ->mNewVertices[i].normal;

                //      Initialize number of bones.
                bones_count     =       mInitialMesh->mBones.size();

                // Check if my twin-vertex-bone has a bone assignment
                // we check only the GeoMesh bones because the lodstrips
                // only works for sharedvertex bones
                for (int bone = 0; bone < bones_count; bone++)
                {
                        it      =       mInitialMesh->mBones.begin() + bone;

                        if (it->vertexIndex == mGeoMeshSQ->mNewVertices[i].bonefrom)
                        {
                                VertexBoneAssignment vba;

                                vba.boneIndex           =       it->boneIndex;
                                vba.vertexIndex =       mGeoMeshSQ->mNewVertices[i].id;
                                vba.weight                      =       it->weight;

                                mInitialMesh->mBones.push_back(vba);
                                bones_count++;
                        }
                }
        }

        //      For each submesh.
        for (unsigned int submesh       =       0; submesh < mGeoMesh->mSubMeshCount; submesh++)
        {
                geosubmesh      =       &mGeoMesh->mSubMesh[submesh];

                geosubmesh->mVertexBuffer       =       new_vertex_buffer;
        }

        delete  vertex_buffer;
        
        mGeoMesh->mVertexBuffer =       new_vertex_buffer;
}