source: GTP/trunk/Lib/Vis/Preprocessing/src/RenderSimulator.cpp @ 1020

#include "RenderSimulator.h"
#include "KdTree.h"
#include "ViewCellBsp.h"
#include "ViewCell.h"
#include "VspBspTree.h"
#include "ViewCellsManager.h"


namespace GtpVisibilityPreprocessor {


void SimulationStatistics::Print(ostream &app) const
{
        app << "============== Render Simulation statistics ==============\n";

        app << setprecision(4);

        app << "#N_CTIME  ( Simulation time [s] )\n" << Time() << " \n";

        app << "#MAX_COST ( maximal cost of a view cell )\n" << maxCost << "\n";

        app << "#MIN_COST ( minimal cost of a view cell )\n" << minCost << "\n";

        app << "#AVG_RENDER_TIME ( average render time )\n" << avgRenderTime << "\n";

        app << "#AVG_RENDER_TIME_NO_OVERHEAD ( average render time without overhead )\n" 
                << avgRtWithoutOverhead << "\n";
        
        app << "#VALID_MAX_COST ( maximal cost of a valid view cell )\n" << validMaxCost << "\n";

        app << "#VALID_MIN_COST ( minimal cost of a valid view cell )\n" << validMinCost << "\n";

        app << "#VALID_AVG_RENDER_TIME ( average render time )\n" << validAvgRenderTime << "\n";

        app << "#VALID_AVG_RENDER_TIME_NO_OVERHEAD ( valid average render time without overhead )\n" 
                << validAvgRtWithoutOverhead << "\n";
        
        app << "=========== END OF Render Simulation statistics ==========\n";
}


RenderSimulator::RenderSimulator(ViewCellsManager *viewCellsManager):
Renderer(NULL, viewCellsManager),
mObjRenderCost(0.0f), 
mVcOverhead(0.0f), 
mMoveSpeed(0.0f)
{}


RenderSimulator::RenderSimulator(ViewCellsManager *viewCellsManager,
                                                                 float objRenderCost, 
                                                                 float vcOverhead, 
                                                                 float moveSpeed):
Renderer(NULL, viewCellsManager),
mObjRenderCost(objRenderCost), 
mVcOverhead(vcOverhead), 
mMoveSpeed(moveSpeed)
{
}


void RenderSimulator::SetObjectRenderCost(const float objRenderCost)
{
        mObjRenderCost = objRenderCost;
}


void RenderSimulator::SetVcOverhead(const float vcOverhead)
{
        mVcOverhead = vcOverhead;
}


void RenderSimulator::SetMoveSpeed(const float moveSpeed)
{
        mMoveSpeed = moveSpeed;
}


bool RenderSimulator::RenderScene()
{
        mSimulationStatistics.Reset();
        mSimulationStatistics.Start();

        Real renderTime = 0;
        Real validRenderTime = 0;

        // overhead for loading the PVS of the view cells
        float loadPvsOverhead = 0;
        float validLoadPvsOverhead = 0;

        ViewCellContainer::const_iterator it, 
                it_end = mViewCellsManager->GetViewCells().end();

        
        for (it = mViewCellsManager->GetViewCells().begin(); it != it_end; ++ it)
        {
                ViewCell *vc = *it;

                const bool valid = vc->GetValid();
        

                // probability of view cell
                const float pInVc = mViewCellsManager->GetProbability(vc);

                //Debug << "vc prob: " << pInVc << endl;

                // compute render time of PVS times probability
                // that view point is in view cell
                const float vcCost = pInVc * 
                        mViewCellsManager->GetRendercost(vc/*, mObjRenderCost*/);
        
                renderTime += vcCost;

                // crossing the border of a view cell is depending on the move 
                // speed and the probability that a view cell border is crossed
                loadPvsOverhead += GetCrossVcProbability() * mVcOverhead;
                

                //-- update statistics

                if (vcCost > mSimulationStatistics.maxCost)
                        mSimulationStatistics.maxCost = vcCost;
                else if (vcCost < mSimulationStatistics.minCost)
                        mSimulationStatistics.minCost = vcCost;

                //-- different statistics for only valid view cells
                if (valid)
                {
                        validLoadPvsOverhead += GetCrossVcProbability() * mVcOverhead;
                        validRenderTime += vcCost;
                
                        if (vcCost > mSimulationStatistics.validMaxCost)
                                mSimulationStatistics.validMaxCost = vcCost;
                        else if (vcCost < mSimulationStatistics.validMinCost)
                                mSimulationStatistics.validMinCost = vcCost;
                }
        }
        
        mSimulationStatistics.avgRtWithoutOverhead = renderTime;
        mSimulationStatistics.avgRenderTime = renderTime + loadPvsOverhead;

        mSimulationStatistics.validAvgRtWithoutOverhead = renderTime;
        mSimulationStatistics.validAvgRenderTime = renderTime + loadPvsOverhead;
        
        mSimulationStatistics.Stop();

        return true;
}


float RenderSimulator::GetCrossVcProbability() const
{
        // assume the view cells are uniformly distributed
        //NOTE: should I take move speed relative to view space or absolute?
        const float vcNum = 
                (float)mViewCellsManager->GetViewCells().size();

        const float prop = mMoveSpeed * vcNum;

        // clamp probability between 0 and 1
        return min(1.0f, prop);
}

void RenderSimulator::GetStatistics(SimulationStatistics &simStats) const
{
        simStats = mSimulationStatistics;
}

}