[406] | 1 | #include "RenderSimulator.h"
|
---|
| 2 | #include "KdTree.h"
|
---|
| 3 | #include "ViewCellBsp.h"
|
---|
| 4 | #include "ViewCell.h"
|
---|
| 5 |
|
---|
[414] | 6 | void SimulationStatistics::Print(ostream &app) const |
---|
| 7 | { |
---|
| 8 | app << "===== Simulation statistics ===============\n"; |
---|
| 9 | |
---|
| 10 | app << setprecision(4); |
---|
| 11 | |
---|
| 12 | app << "#N_CTIME ( Simulation time [s] )\n" << Time() << " \n"; |
---|
| 13 | |
---|
| 14 | app << "#MAX_COST ( maximal cost of a view cell )\n" << maxCost << "\n"; |
---|
| 15 | |
---|
| 16 | app << "#MIN_COST ( minimal cost of a view cell )\n" << minCost << "\n"; |
---|
| 17 | |
---|
| 18 | app << "#AVG_RENDER_TIME ( average render time )\n" << avgRenderTime << "\n"; |
---|
| 19 | |
---|
| 20 | app << "#AVG_RENDER_TIME_NO_OVERHEAD ( average render time without overhead )\n" << avgRtWithoutOverhead << "\n"; |
---|
| 21 | |
---|
| 22 | app << "===== END OF Simulation statistics ==========\n"; |
---|
| 23 | }
|
---|
| 24 |
|
---|
[406] | 25 | RenderSimulator::RenderSimulator()
|
---|
| 26 | {}
|
---|
| 27 |
|
---|
[409] | 28 | RenderSimulator::RenderSimulator(float objRenderCost, float vcOverhead, float moveSpeed):
|
---|
| 29 | mObjRenderCost(objRenderCost), mVcOverhead(vcOverhead), mMoveSpeed(moveSpeed)
|
---|
[406] | 30 | {
|
---|
| 31 | }
|
---|
| 32 |
|
---|
| 33 | /*****************************************************
|
---|
| 34 | * class ViewCellRenderSimulator implementation *
|
---|
| 35 | *****************************************************/
|
---|
| 36 |
|
---|
[409] | 37 | BspViewCellRenderSimulator::BspViewCellRenderSimulator(float objRenderCost,
|
---|
[406] | 38 | float vcOverhead,
|
---|
[409] | 39 | float moveSpeed,
|
---|
[406] | 40 | BspTree *bspTree):
|
---|
[409] | 41 | RenderSimulator(objRenderCost, vcOverhead, moveSpeed), mBspTree(bspTree)
|
---|
[406] | 42 | {
|
---|
| 43 | }
|
---|
| 44 |
|
---|
[409] | 45 | Real BspViewCellRenderSimulator::SimulateRendering()
|
---|
[406] | 46 | {
|
---|
[414] | 47 | mStat.Reset();
|
---|
| 48 | mStat.Start();
|
---|
| 49 |
|
---|
[406] | 50 | Real renderTime = 0;
|
---|
[414] | 51 |
|
---|
[409] | 52 | // overhead for loading the PVS of the view cells
|
---|
| 53 | float loadPvsOverhead = 0;
|
---|
| 54 | // probability that view point lies in a view cell
|
---|
| 55 | float pInVcTotal = 0;
|
---|
[418] | 56 |
|
---|
[409] | 57 | // total probability that a view cell border is crossed
|
---|
[418] | 58 | const float pCrossVcTotal = mBspTree->GetBoundingBox().SurfaceArea();
|
---|
[409] | 59 |
|
---|
| 60 | // collect all view cells
|
---|
[406] | 61 | ViewCellContainer viewCells;
|
---|
| 62 | mBspTree->CollectViewCells(viewCells);
|
---|
| 63 |
|
---|
| 64 | ViewCellContainer::const_iterator it, it_end = viewCells.end();
|
---|
[407] | 65 |
|
---|
| 66 | // surface area substitute for probability
|
---|
[409] | 67 | PolygonContainer geom;
|
---|
[420] | 68 | float overallarea = 0;
|
---|
[406] | 69 | for (it = viewCells.begin(); it != it_end; ++ it)
|
---|
| 70 | {
|
---|
[410] | 71 | // compute view cell area
|
---|
[409] | 72 | mBspTree->ConstructGeometry(dynamic_cast<BspViewCell *>(*it), geom);
|
---|
[410] | 73 | const float area = Polygon3::GetArea(geom);
|
---|
[420] | 74 | if (area < 0.0001)
|
---|
| 75 | Debug << "warning, area: " << area << endl;
|
---|
[409] | 76 | CLEAR_CONTAINER(geom);
|
---|
| 77 |
|
---|
| 78 | // area substitute for view point probability
|
---|
| 79 | float pInVc = area;
|
---|
| 80 |
|
---|
| 81 | // compute render time of PVS times probability that view point is in view cell
|
---|
[414] | 82 | float vcCost = pInVc * RenderPvs(*(*it), mObjRenderCost);
|
---|
[418] | 83 | //Debug << "p: " << pInVc << " rendercost: " << RenderPvs(*(*it), mObjRenderCost) << endl;
|
---|
[414] | 84 | renderTime += vcCost;
|
---|
| 85 |
|
---|
| 86 | if (vcCost > mStat.maxCost)
|
---|
| 87 | mStat.maxCost = vcCost;
|
---|
| 88 | else if (vcCost < mStat.minCost)
|
---|
| 89 | mStat.minCost = vcCost;
|
---|
| 90 |
|
---|
[409] | 91 | // probability that a view cell border is crossed
|
---|
[418] | 92 | float pCrossVc = area * mMoveSpeed;
|
---|
[409] | 93 |
|
---|
[414] | 94 | // crossing the border of a view cell is also depending on the move speed
|
---|
[418] | 95 | loadPvsOverhead += pCrossVc * mVcOverhead;
|
---|
[420] | 96 | overallarea+=area;
|
---|
[409] | 97 | pInVcTotal += pInVc;
|
---|
[406] | 98 | }
|
---|
[420] | 99 | Debug << "overall area: " << overallarea << endl;
|
---|
[409] | 100 |
|
---|
| 101 | renderTime /= pInVcTotal;
|
---|
| 102 | loadPvsOverhead /= pCrossVcTotal;
|
---|
[406] | 103 |
|
---|
[414] | 104 | mStat.avgRtWithoutOverhead = renderTime;
|
---|
| 105 | mStat.avgRenderTime = renderTime + loadPvsOverhead;
|
---|
[409] | 106 |
|
---|
[420] | 107 | mStat.maxCost /= pInVcTotal;
|
---|
| 108 | mStat.minCost /= pInVcTotal;
|
---|
| 109 |
|
---|
[414] | 110 | mStat.Stop();
|
---|
| 111 |
|
---|
[409] | 112 | return renderTime + loadPvsOverhead;
|
---|
[406] | 113 | }
|
---|
| 114 |
|
---|
[409] | 115 | Real BspViewCellRenderSimulator::RenderPvs(ViewCell &viewCell,
|
---|
[407] | 116 | float objRenderTime) const
|
---|
[406] | 117 | {
|
---|
| 118 | return viewCell.GetPvs().GetSize() * objRenderTime;
|
---|
| 119 | }
|
---|
| 120 |
|
---|
[407] | 121 | /********************************************************
|
---|
| 122 | * class KdLeafRenderSimulator implementation *
|
---|
| 123 | *******************************************************/
|
---|
[406] | 124 |
|
---|
[409] | 125 | KdViewCellRenderSimulator::KdViewCellRenderSimulator(float objRenderCost,
|
---|
| 126 | float vcOverhead,
|
---|
| 127 | float moveSpeed,
|
---|
[406] | 128 | KdTree *kdTree):
|
---|
[409] | 129 | RenderSimulator(objRenderCost, vcOverhead, moveSpeed), mKdTree(kdTree)
|
---|
[406] | 130 | {
|
---|
| 131 | }
|
---|
| 132 |
|
---|
[409] | 133 | Real KdViewCellRenderSimulator::SimulateRendering()
|
---|
[406] | 134 | {
|
---|
[407] | 135 | //mKdTree->CollectLeavesPvs();
|
---|
[414] | 136 | mStat.Reset();
|
---|
| 137 | mStat.Start();
|
---|
[407] | 138 |
|
---|
| 139 | // total render time
|
---|
[406] | 140 | Real renderTime = 0;
|
---|
[407] | 141 | // overhead for loading a view cell
|
---|
[409] | 142 | float loadPvsOverhead = 0;
|
---|
[406] | 143 |
|
---|
[407] | 144 | // probability that view point lies in a view cell
|
---|
| 145 | float pInVcTotal = 0;//mKdTree->GetBox().GetVolume();
|
---|
[406] | 146 |
|
---|
[407] | 147 | // total probability that a view cell border is crossed
|
---|
[418] | 148 | const float pCrossVcTotal = mKdTree->GetBox().SurfaceArea();
|
---|
[407] | 149 |
|
---|
| 150 | vector<KdLeaf *> leaves;
|
---|
| 151 | mKdTree->CollectLeaves(leaves);
|
---|
| 152 |
|
---|
| 153 | AxisAlignedBox3 box;
|
---|
| 154 |
|
---|
| 155 | vector<KdLeaf *>::const_iterator it, it_end = leaves.end();
|
---|
| 156 |
|
---|
| 157 | for (it = leaves.begin(); it != it_end; ++ it)
|
---|
| 158 | {
|
---|
| 159 | box = mKdTree->GetBox(*it);
|
---|
| 160 |
|
---|
| 161 | // volume substitute for view point probability
|
---|
| 162 | float pInVc = 0;
|
---|
| 163 |
|
---|
| 164 | if (0)
|
---|
| 165 | pInVc = box.GetVolume();
|
---|
| 166 | else
|
---|
| 167 | pInVc = box.SurfaceArea();
|
---|
| 168 |
|
---|
[414] | 169 | float vcCost = pInVc * RenderPvs(*it, mObjRenderCost);
|
---|
| 170 | renderTime += vcCost;
|
---|
| 171 |
|
---|
| 172 | if (vcCost > mStat.maxCost)
|
---|
| 173 | mStat.maxCost = vcCost;
|
---|
| 174 | else if (vcCost < mStat.minCost)
|
---|
| 175 | mStat.minCost = vcCost;
|
---|
| 176 |
|
---|
[418] | 177 | // probability that a view cell border is crossed
|
---|
| 178 | const float pCrossVc = box.SurfaceArea() * mMoveSpeed;
|
---|
[407] | 179 |
|
---|
[418] | 180 | loadPvsOverhead += pCrossVc * mVcOverhead;
|
---|
| 181 |
|
---|
[407] | 182 | pInVcTotal += pInVc;
|
---|
| 183 | }
|
---|
| 184 |
|
---|
| 185 | renderTime /= pInVcTotal;
|
---|
[409] | 186 | loadPvsOverhead /= pCrossVcTotal;
|
---|
[407] | 187 |
|
---|
[414] | 188 | mStat.avgRtWithoutOverhead = renderTime;
|
---|
| 189 | mStat.avgRenderTime = renderTime + loadPvsOverhead;
|
---|
[419] | 190 |
|
---|
[420] | 191 | mStat.maxCost /= pInVcTotal;
|
---|
| 192 | mStat.minCost /= pInVcTotal;
|
---|
| 193 |
|
---|
[414] | 194 | mStat.Stop();
|
---|
| 195 |
|
---|
[409] | 196 | return renderTime + loadPvsOverhead;
|
---|
[407] | 197 | }
|
---|
| 198 |
|
---|
[409] | 199 | Real KdViewCellRenderSimulator::RenderPvs(KdLeaf *leaf,
|
---|
[407] | 200 | float objRenderTime) const
|
---|
| 201 | {
|
---|
| 202 | return leaf->mKdPvs.GetSize() * objRenderTime;
|
---|
[406] | 203 | } |
---|