source: trunk/VUT/GtpVisibilityPreprocessor/src/RenderSimulator.cpp @ 473

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

void SimulationStatistics::Print(ostream &app) const
{
        app << "===== 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 << "===== END OF Simulation statistics ==========\n";
}

RenderSimulator::RenderSimulator(ViewCellsManager *viewCellsManager):
Renderer(viewCellsManager)
{}

RenderSimulator::RenderSimulator(ViewCellsManager *viewCellsManager,
                                                                 float objRenderCost, 
                                                                 float vcOverhead, 
                                                                 float moveSpeed):
Renderer(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;
        
        // overhead for loading the PVS of the view cells
        float loadPvsOverhead = 0;
        
        ViewCellContainer::const_iterator it, 
                it_end = mViewCellsManager->GetViewCells().end();

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

                // probability of view cell
                const float pInVc = mViewCellsManager->GetProbability(vc);
                                
                // compute render time of PVS times probability that view point is in view cell
                const float vcCost = pInVc * mViewCellsManager->GetRendercost(vc, mObjRenderCost);
        
                // 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
                renderTime += vcCost;
        
                if (vcCost > mSimulationStatistics.maxCost)
                        mSimulationStatistics.maxCost = vcCost;
                else if (vcCost < mSimulationStatistics.minCost)
                        mSimulationStatistics.minCost = vcCost;
        }
        
        mSimulationStatistics.avgRtWithoutOverhead = renderTime;
        mSimulationStatistics.avgRenderTime = renderTime + loadPvsOverhead;
        
        mSimulationStatistics.Stop();

        return true;
}

float RenderSimulator::GetCrossVcProbability()
{
        return 0;
}

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