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

RenderSimulator::RenderSimulator()
{}

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

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

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

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

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

	// probability that view point lies in a view cell
	float pInVcTotal = 0;

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

	// collect all view cells
	ViewCellContainer viewCells;
	mBspTree->CollectViewCells(viewCells);

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

	// surface area substitute for probability
	PolygonContainer geom;

	for (it = viewCells.begin(); it != it_end; ++ it)
	{
		mBspTree->ConstructGeometry(dynamic_cast<BspViewCell *>(*it), geom);
		CLEAR_CONTAINER(geom);

		const float area = Polygon3::GetArea(geom);
		// area substitute for view point probability
		float pInVc = area;
				
		// compute render time of PVS times probability that view point is in view cell
		renderTime += pInVc * RenderPvs(*(*it), mObjRenderCost);
		
		// probability that a view cell border is crossed
		float pCrossVc = area;

		loadPvsOverhead += pCrossVc * mVcOverhead * mMoveSpeed;

		pInVcTotal += pInVc;
		pCrossVcTotal += pCrossVc;
	}

	
	renderTime /= pInVcTotal;
	loadPvsOverhead /= pCrossVcTotal;

	//Debug << "render time without overhead: " << renderTime * 1e-3 << endl;
	
	return renderTime + loadPvsOverhead;
}

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

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

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

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

	// total render time
	Real renderTime = 0;
	// overhead for loading a view cell
	float loadPvsOverhead = 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);
		loadPvsOverhead += pCrossVc * mVcOverhead * mMoveSpeed;

		pInVcTotal += pInVc;
		pCrossVcTotal += pCrossVc;
	}

	renderTime /= pInVcTotal;
	loadPvsOverhead /= pCrossVcTotal;

	return renderTime + loadPvsOverhead;
}

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