source: GTP/trunk/App/Demos/Illum/pathmap/Entity.cpp @ 2197

#include "dxstdafx.h"
#include ".\entity.h"
#include "SubEntity.h"
#include "Mesh.h"
#include "SubMesh.h"
#include <fstream>

Entity::Entity(Mesh* baseMesh, const char* entityName, const char* prmFileName, const D3DXMATRIX& trafo, int nNearClusters)
{
        surfaceArea = -1.0;

        modelWorldTransform = trafo;
        D3DXMatrixInverse(&inverseTransposedModelWorldTransform, NULL, &modelWorldTransform);

        strcpy(this->name, entityName);
        strcpy(this->prmFileName, prmFileName);

        this->mesh = baseMesh;
        this->nNearClusters = nNearClusters;

        std::vector<SubMesh*>::iterator iSubMesh = baseMesh->subMeshes.begin();
        while(iSubMesh != baseMesh->subMeshes.end())
        {
                SubEntity* nse = new SubEntity(this, *iSubMesh, nNearClusters);
                subEntities.push_back(nse);
                iSubMesh++;
        }

}

Entity::~Entity(void)
{
        std::vector<SubEntity*>::iterator subEntityIterator = subEntities.begin();
        while(subEntityIterator != subEntities.end())
        {
                delete (*subEntityIterator);
                subEntityIterator++;
        }
}

void Entity::drawAllSubEntities(const RenderStrategy& renderStrategy)
{
        renderStrategy.applyTransforms(this);

        std::vector<SubEntity*>::iterator subEntityIterator = subEntities.begin();
        while(subEntityIterator != subEntities.end())
        {
                (*subEntityIterator)->draw(renderStrategy);
                subEntityIterator++;
        }
}

float Entity::getSurfaceArea()
{
        if(surfaceArea > 0.0)
                return surfaceArea;
        float area = 0;
        std::vector<SubEntity*>::iterator subEntityIterator = subEntities.begin();
        while(subEntityIterator != subEntities.end())
        {
                area += (*subEntityIterator)->getSurfaceArea();
                subEntityIterator++;
        }
        this->surfaceArea = area;
        return area;
}

void Entity::findNearClusters(const std::vector<Radion>& starters, unsigned int nClusters)
{
        std::vector<SubEntity*>::iterator subEntityIterator = subEntities.begin();
        while(subEntityIterator != subEntities.end())
        {
                (*subEntityIterator)->findNearClusters(starters, nClusters);
                subEntityIterator++;
        }

}

void Entity::renderPRM( std::vector<Radion>& clusterRadions, unsigned int clusterId)
{
        std::vector<SubEntity*>::iterator subEntityIterator = subEntities.begin();
        while(subEntityIterator != subEntities.end())
        {
                (*subEntityIterator)->renderPRM(clusterRadions, clusterId);
                subEntityIterator++;
        }

}

void Entity::normalizePRM()
{
        std::vector<SubEntity*>::iterator subEntityIterator = subEntities.begin();
        while(subEntityIterator != subEntities.end())
        {
                (*subEntityIterator)->normalizePRM();
                subEntityIterator++;
        }
}

void Entity::clearPRM()
{
        std::vector<SubEntity*>::iterator subEntityIterator = subEntities.begin();
        while(subEntityIterator != subEntities.end())
        {
                (*subEntityIterator)->clearPRM();
                subEntityIterator++;
        }
}

void Entity::savePRM()
{
        std::vector<SubEntity*>::iterator subEntityIterator = subEntities.begin();
        while(subEntityIterator != subEntities.end())
        {
                (*subEntityIterator)->savePRM();
                subEntityIterator++;
        }
}

void Entity::loadPRM()
{
        std::vector<SubEntity*>::iterator subEntityIterator = subEntities.begin();
        while(subEntityIterator != subEntities.end())
        {
                (*subEntityIterator)->loadPRM();
                subEntityIterator++;
        }
}

void Entity::gatherRayTraceEntities(std::vector<Intersectable*>& rayTraceEntities)
{
        std::vector<SubEntity*>::iterator subEntityIterator = subEntities.begin();
        while(subEntityIterator != subEntities.end())
        {
                rayTraceEntities.push_back((*subEntityIterator)->getRayTraceEntity());
                subEntityIterator++;
        }
}

const Material* Entity::sampleSurface(Radion& sample)
{
        float sarea = getSurfaceArea();
        float randa = ((double)rand() / RAND_MAX) * sarea;

        float uptonowSurfaceArea = 0.0;
        SubEntity* e = NULL;
        std::vector<SubEntity*>::iterator sei = subEntities.begin();
        while(sei != subEntities.end())
        {
                uptonowSurfaceArea += (*sei)->getSurfaceArea();
                if(uptonowSurfaceArea >= randa)
                {
                        e = *sei;
                        break;
                }
                sei++;
        }
        const Material* ret = e->sampleSurface(sample);
        sample.radiance.z = sarea;
        return ret;
}

void Entity::saveSceneInfo(std::ofstream& psf)
{
        psf << "entity " << name << '\n';
        psf << "{\n";
        psf << "\tmesh " << mesh->getName() << '\n';
        psf << "\ttransformation ";
        for(int mi=0; mi<16; mi++)
                psf << modelWorldTransform.m[mi%4][mi/4] << " ";
        psf << "\n";
        psf << "\tpathmapfile " << prmFileName << '\n';
        psf << "\tpathmapclusters " << nNearClusters << '\n';
        std::vector<SubEntity*>::iterator sei = subEntities.begin();
        while(sei != subEntities.end())
        {
                (*sei)->saveSceneInfo(psf);
                sei++;
        }
        psf << "}\n";
}