source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/GeoLodTreeLibrary.cpp @ 1090

#include <assert.h>
#include "GeoLodTreeLibrary.h"
#include "libs/leaves/Foliage.h"

using namespace Geometry;

Geometry::LodTreeLibrary::LodTreeLibrary(const LodStripsLibraryData *lodstripsdata,
                                                                                 const TreeSimplificationSequence *simpseq,
                                                                                 Geometry::Mesh *treeGeoMesh/*,
                                                                                 uint32 leafSubMeshID,
                                                           CREATEVERTEXDATAFUNC vdfun,
                                                           CREATEINDEXDATAFUNC idfun,
                                                           CREATEMULTIINDEXDATAFUNC midfun*/)
{
        // Cargar el tronco
        trunk = new LodStripsLibrary(lodstripsdata,treeGeoMesh);

        // select the first triangle-list submesh as leaves submesh
        mLeavesSubMesh = -1;
        for (int i=0; i<treeGeoMesh->mSubMeshCount; i++)
        {
                if (treeGeoMesh->mSubMesh[i].mType==GEO_TRIANGLE_LIST)
                {
                        mLeavesSubMesh=i;
                        break;
                }
        }       

        // Cargar la copa del árbol
        Geometry::SubMesh * leafsSubMesh = &(treeGeoMesh->mSubMesh[mLeavesSubMesh]);
        foliage = new Foliage(leafsSubMesh,simpseq);
        GoToFoliageLod(1.0f);
}
/*
LodTreeLibrary::LodTreeLibrary(const LodTreeLibrary &t)
{
        uniqueID = uniqueIDgen++;
        assert(
//      trunk=new LodStrip(t.trunk);
        arbol=new Arbol(t.arbol);
        foliage=new Foliage(arbol);
}

LodTreeLibrary::LodTreeLibrary(LodTreeLibrary *t)
{
        uniqueID = uniqueIDgen++;
        trunk=new LodStrip(t->trunk); 
        arbol=new Arbol(t->arbol);
        foliage=new Foliage(arbol);
}
*/

LodTreeLibrary::~LodTreeLibrary(void)
{
        if (trunk) delete trunk;
        if (foliage) delete foliage;
/*      if (trunk_all_indices) delete trunk_all_indices;
        if (indices_offsets) delete[] indices_offsets;
//      if (current_foliage_indices) delete[] current_foliage_indices;*/
}
/*
uint32 LodTreeLibrary::CurrentLOD_Trunk_StripCount(void) const
{
        assert(trunk);
        return trunk->TOTAL;
//      return trunk->dataRetrievalInterface->GetNumPrims();
}*/


/*uint32 LodTreeLibrary::CurrentLOD_Trunk_IndexCountByStrip(uint32 istrip) const
{
        assert(trunk);
//      return trunk->lStripsV[istrip].size();
//      return trunk->GetIndexCountByStrip(istrip);
        return trunk->dataRetrievalInterface->GetNumValidIndices(istrip);
}

uint32 LodTreeLibrary::CurrentLOD_Trunk_IndexCount(void) const
{
        assert(trunk);
        return trunk->num_indices_current_lod;
}
*/

void LodTreeLibrary::GoToTrunkLod(float newlod)
{
        trunk->GoToLod(newlod);
}
/*
uint32 LodTreeLibrary::MinTrunkLod(void) const
{
        return trunk->MinLod();
}
uint32 LodTreeLibrary::MaxTrunkLod(void) const
{
        return trunk->MaxLod();
}
*/

void LodTreeLibrary::GoToFoliageLod(float newlod)
{
        uint32 targetLeaves = (uint32)
                                                                                                (
                                                                                                        (1.0f - newlod)
                                                                                                        *
                                                                                                        foliage->minLeaves
                                                                                                        +
                                                                                                        newlod
                                                                                                        *
                                                                                                        foliage->leafCount
                                                                                                );

        foliage->CalculateLOD(targetLeaves);

        foliage->indexdata->Begin();
        foliage->vertexdata->Begin();
        int i = foliage->begin;
        int auxnumleaves = 0;
        while(i!=-1)
        {
                auxnumleaves++;
                i=foliage->Acth[i].next;
        }

        assert(auxnumleaves*6<=int(foliage->indexdata->GetNumMaxIndices()));
        foliage->indexdata->SetNumValidIndices(auxnumleaves*6);
        i = foliage->begin;
        int index=0;
        while(i!=-1)
        {
                unsigned int v0,v1,v2,v3;
                v0 = foliage->Leaves[i].vertsLeaf[0];
                v1 = foliage->Leaves[i].vertsLeaf[1];
                v2 = foliage->Leaves[i].vertsLeaf[2];
                v3 = foliage->Leaves[i].vertsLeaf[3];

                foliage->indexdata->SetIndex(index+0,v0);
                foliage->indexdata->SetIndex(index+1,v1);
                foliage->indexdata->SetIndex(index+2,v2);
                foliage->indexdata->SetIndex(index+3,v2);
                foliage->indexdata->SetIndex(index+4,v1);
                foliage->indexdata->SetIndex(index+5,v3);

                foliage->vertexdata->SetVertexTexCoord(v0,0,0);
                foliage->vertexdata->SetVertexTexCoord(v1,0,1);
                foliage->vertexdata->SetVertexTexCoord(v2,1,0);
                foliage->vertexdata->SetVertexTexCoord(v3,1,1); 

                index+=6;
                i=foliage->Acth[i].next;
        }
        foliage->indexdata->End();
        foliage->vertexdata->End();
}
/*
uint32 LodTreeLibrary::MinFoliageLod(void) const
{
        return foliage->nHojas;
}
uint32 LodTreeLibrary::MaxFoliageLod(void) const
{
        return foliage->minHojas;
}*/

/*const VertexData* LodTreeLibrary::Get_Trunk_VertexData(void) const 
{ 
        return trunk->vertices; 
}*/
const IndexData* LodTreeLibrary::CurrentLOD_Trunk_Indices(void) const 
{ 
        return trunk->dataRetrievalInterface;
}


const VertexData* LodTreeLibrary::Get_Foliage_VertexData(void) const
{
        return foliage->vertexdata;
}

const IndexData* LodTreeLibrary::CurrentLOD_Foliage_Indices(void) const
{
        return foliage->indexdata;
}


/*void ThrowFileNotFoundError(const char *text)
{
        throw Geometry::FileNotFound(text);
}*/

uint32 LodTreeLibrary::CurrentLOD_Foliage_IndexCount(void) const
{
//      return current_foliage_indexcount;
        return foliage->indexdata->GetNumValidIndices();
}
/*
uint32 LodTreeLibrary::Get_Trunk_VertexCount(void) const
{
        return trunk->TOTALVERTS;
}

uint32 LodTreeLibrary::Get_Trunk_MaxIndexCount(uint32 istrip) const
{
//      return trunk->indices_x_tira[istrip]->GetNumMaxIndices();
        return trunk->indices->GetNumMaxIndices(istrip);
}

uint32 LodTreeLibrary::Get_Foliage_VertexCount(void) const
{
        return arbol->vertexdata->GetNumVertices();
}*/
uint32 LodTreeLibrary::Get_Foliage_MaxIndexCount(void) const
{
        return foliage->indexdata->GetNumMaxIndices();
}


// changes the lod of the entire object (trunk and leaves)
void LodTreeLibrary::GoToLod(Real lod)
{
        assert(lod<=1.0f && lod>=0.0f);
        GoToTrunkLod(lod);
        GoToFoliageLod(lod);
}