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

#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 << "===== 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 << "===== END OF Render 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;

                //Debug << "vccost: " << vcCost << " p in vc " << pInVc
                //<< " cross vc " << GetCrossVcProbability() << endl;

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