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

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

RenderSimulator::RenderSimulator()
{}

RenderSimulator::RenderSimulator(float objRenderCost, float vcOverhead):
mObjRenderCost(objRenderCost), mVcOverhead(vcOverhead)
{
}

/*****************************************************
 *     class ViewCellRenderSimulator implementation  *
 *****************************************************/

BspTreeRenderSimulator::BspTreeRenderSimulator(float objRenderCost, 
                                                                                           float vcOverhead, 
                                                                                           BspTree *bspTree):
RenderSimulator(objRenderCost, vcOverhead), mBspTree(bspTree)
{
}

Real BspTreeRenderSimulator::SimulateRendering()
{
        Real renderTime = 0;

        // total area of view cells
        float totalArea = 0;//= mKdTree->GetBox().SurfaceArea();

        ViewCellContainer viewCells;

        mBspTree->CollectViewCells(viewCells);

        ViewCellContainer::const_iterator it, it_end = viewCells.end();

        // surface area substitute for probability
        PolygonContainer cell;

        for (it = viewCells.begin(); it != it_end; ++ it)
        {
                mBspTree->ConstructGeometry(dynamic_cast<BspViewCell *>(*it), cell);
                CLEAR_CONTAINER(cell);
                float area = Polygon3::GetArea(cell);
                
                renderTime += area * (RenderPvs(*(*it), mObjRenderCost) + mVcOverhead);
                totalArea += area;
        }

        renderTime /= totalArea;

        //Debug << "render time without overhead: " << renderTime * 1e-3 << endl;
        //renderTime += (float)viewCells.size() * vcOverhead;

        return renderTime;
}

Real BspTreeRenderSimulator::RenderPvs(ViewCell &viewCell, 
                                                                           float objRenderTime) const
{
        return viewCell.GetPvs().GetSize() * objRenderTime;
}

/********************************************************
 *     class KdLeafRenderSimulator implementation       *
 *******************************************************/

KdTreeRenderSimulator::KdTreeRenderSimulator(float objRenderCost, 
                                                                                         float vcOverhead, 
                                                                                         KdTree *kdTree):
RenderSimulator(objRenderCost, vcOverhead), mKdTree(kdTree)
{
}

Real KdTreeRenderSimulator::SimulateRendering()
{
        //mKdTree->CollectLeavesPvs();

        // total render time
        Real renderTime = 0;
        // overhead for loading a view cell
        float loadOverhead = 0;

        // probability that view point lies in a view cell
        float pInVcTotal = 0;//mKdTree->GetBox().GetVolume();

        // total probability that a view cell border is crossed
        float pCrossVcTotal = 0;

        vector<KdLeaf *> leaves;
        mKdTree->CollectLeaves(leaves);
        
        AxisAlignedBox3 box;

        vector<KdLeaf *>::const_iterator it, it_end = leaves.end();
        
        for (it = leaves.begin(); it != it_end; ++ it)
        {
                box = mKdTree->GetBox(*it);
                        
                // volume substitute for view point probability
                float pInVc = 0;
                
                if (0)
                        pInVc = box.GetVolume(); 
                else
                        pInVc = box.SurfaceArea();
                
                // probability that a view cell border is crossed
                const float pCrossVc = box.SurfaceArea();

                renderTime += pInVc * RenderPvs(*it, mObjRenderCost);
                loadOverhead += pCrossVc * mVcOverhead;

                pInVcTotal += pInVc;
                pCrossVcTotal += pCrossVc;
        }

        renderTime /= pInVcTotal;
        loadOverhead /= pCrossVcTotal;

        return renderTime + loadOverhead;
}

Real KdTreeRenderSimulator::RenderPvs(KdLeaf *leaf, 
                                                                                   float objRenderTime) const
{
        return leaf->mKdPvs.GetSize() * objRenderTime;
}