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

#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,
                                                                                        Geometry::IndexData                                                             *userindexdata)
{
        // Cargar el tronco.
        trunk = new LodStripsLibrary(lodstripsdata,treeGeoMesh,userindexdata);

        // select the first triangle-list submesh as leaves submesh
        mLeavesSubMesh  =       -1;

        for (size_t     i       =       0;      i < treeGeoMesh->mSubMeshCount; i++)
        {
                if (treeGeoMesh->mSubMesh[i].mType == GEO_TRIANGLE_LIST)
                {
                        mLeavesSubMesh  =       (uint32)i;
                        break;
                }
        }

        delete_indexdata                                =       false;
        dataRetrievalInterface  =       userindexdata;

        // Cargar la copa del árbol
        Geometry::SubMesh *leafsSubMesh =
                                                                                &(treeGeoMesh->mSubMesh[mLeavesSubMesh]);

        foliage =       new Foliage(mLeavesSubMesh,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 (delete_indexdata) delete dataRetrievalInterface;
}
/*
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);

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

//      foliage->indexdata->Begin(GetLeavesSubMesh(),auxnumleaves*6);
        dataRetrievalInterface->Begin(GetLeavesSubMesh(),auxnumleaves*6);
//      foliage->vertexdata->Begin();

        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];

                dataRetrievalInterface->SetIndex(index+0,v0);
                dataRetrievalInterface->SetIndex(index+1,v1);
                dataRetrievalInterface->SetIndex(index+2,v2);
                dataRetrievalInterface->SetIndex(index+3,v2);
                dataRetrievalInterface->SetIndex(index+4,v1);
                dataRetrievalInterface->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;
        }
        dataRetrievalInterface->End();
//      foliage->vertexdata->End();
        currentFoliageLodFactor = newlod;
}
/*
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->GetIndexDataInterface();
}

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

const IndexData* LodTreeLibrary::CurrentLOD_Foliage_Indices(void) const
{
        return currentLOD_foliageIndexCount;
}


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

uint32 LodTreeLibrary::CurrentLOD_Foliage_IndexCount(void) const
{
//      return current_foliage_indexcount;
//      return foliage->indexdata->GetNumValidIndices();
        return foliage->active_leaf_count*6;
}
/*
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->leafTotal*6;
}


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