Changeset 449 for trunk/VUT/GtpVisibilityPreprocessor

Timestamp:

12/05/05 05:21:22 (19 years ago)

Author:

mattausch

Message:

 

Location:

trunk/VUT/GtpVisibilityPreprocessor/src

Files:

• RenderSimulator.cpp (modified) (4 diffs)
• RenderSimulator.h (modified) (2 diffs)
• ViewCellsManager.cpp (modified) (2 diffs)
• VspKdTree.cpp (modified) (4 diffs)
• X3dExporter.cpp (modified) (11 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/RenderSimulator.cpp

@@ -4 +4 @@
 #include "ViewCell.h"
 #include "VspBspTree.h"
-
+#include "VspKdTree.h"
 
 void SimulationStatistics::Print(ostream &app) const
@@ -148 +148 @@
 }
 
-/********************************************************
- *     class KdLeafRenderSimulator implementation       *
- *******************************************************/
+/*******************************************************/
+/*     class KdenderSimulator implementation           */
+/*******************************************************/
 
 KdRenderSimulator::KdRenderSimulator(float objRenderCost, 
@@ -242 +242 @@
 /*     class BspRenderSimulator implementation          */
 /********************************************************/
+
 VspBspRenderSimulator::VspBspRenderSimulator(VspBspTree *vspBspTree):
 mVspBspTree(vspBspTree)
@@ -334 +335 @@
         return viewCell.GetPvs().GetSize() * objRenderTime;
 }
+
+
+
+/********************************************************/
+/*     class BspRenderSimulator implementation          */
+/********************************************************/
+
+
+VspKdRenderSimulator::VspKdRenderSimulator(VspKdTree *vspKdTree):
+mVspKdTree(vspKdTree)
+{
+}
+
+VspKdRenderSimulator::VspKdRenderSimulator(float objRenderCost, 
+                                                                                   float vcOverhead, 
+                                                                                   float moveSpeed,
+                                                                                   VspKdTree *vspKdTree):
+RenderSimulator(objRenderCost, vcOverhead, moveSpeed), 
+mVspKdTree(vspKdTree)
+{
+}
+
+SimulationStatistics VspKdRenderSimulator::SimulateRendering()
+{
+        SimulationStatistics simStat;
+
+        simStat.Reset();
+        simStat.Start();
+
+        // TODO
+        simStat.Stop();
+
+        return simStat;
+}
+
+Real VspKdRenderSimulator::RenderPvs(ViewCell &viewCell, 
+                                                                          float objRenderTime) const
+{
+        return 0; // TODO
+}

trunk/VUT/GtpVisibilityPreprocessor/src/RenderSimulator.h

@@ -9 +9 @@
 class ViewCell;
 class KdLeaf;
+class VspKdTree;
 class VspBspTree;
 
@@ -151 +152 @@
 };
 
+class VspKdRenderSimulator: public RenderSimulator
+{
+public:
+        VspKdRenderSimulator(VspKdTree *vspKdTree);
+
+        VspKdRenderSimulator(float objRenderCost, 
+                                                 float vcOverhead, 
+                                                 float moveSpeed, 
+                                                 VspKdTree *vspKdTree);
+
+        SimulationStatistics SimulateRendering();
+
+protected:
+        /** Simulates rendering of the pvs of one view cell, with given rendering time for an object.
+                @param viewCell the view cell holding the Pvs
+                @param objRenderTime estimated render time for one object of the Pvs
+        */
+        Real RenderPvs(ViewCell &viewCell, const float objRenderTime) const;
+
+private:
+        VspKdTree *mVspKdTree;
+};
+
 #endif // RenderSimulator

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellsManager.cpp

@@ -972 +972 @@
 mVspKdTree(vspKdTree)
 {
-   mRenderSimulator = NULL;//new VspKdRenderSimulator(vspKdTree);
+   mRenderSimulator = new VspKdRenderSimulator(vspKdTree);
    InitRenderSimulator();
 }
@@ -1097 +1097 @@
 
                         //-- export stored PVS
-                        
                         ObjectContainer pvsObj;
                         leaf->ExtractPvs(pvsObj);

trunk/VUT/GtpVisibilityPreprocessor/src/VspKdTree.cpp

@@ -337 +337 @@
 {
         DEL_PTR(mRoot);
+        DEL_PTR(mSplitCandidates);
 }
 
@@ -446 +447 @@
 VspKdTree::Construct(const VssRayContainer &rays,
                                          AxisAlignedBox3 *forcedBoundingBox)
-{
+{Debug << "here888" << endl;
         mStat.Start();
-  
+  Debug << "here1000" << endl;
         mMaxMemory = mMaxStaticMemory;
-
+        Debug << "here1" << endl;
         DEL_PTR(mRoot);
 
@@ -460 +461 @@
         mStat.nodes = 1;
         mBox.Initialize();
-
+Debug << "here2" << endl;
         //-- compute bounding box
         if (forcedBoundingBox)
@@ -899 +900 @@
                 requestedSize < (int)(mSplitCandidates->capacity()/10) ) 
         {
-        delete mSplitCandidates;
+        DEL_PTR(mSplitCandidates);
                 mSplitCandidates = new vector<SortableEntry>;
         }

trunk/VUT/GtpVisibilityPreprocessor/src/X3dExporter.cpp

@@ -11 +11 @@
 #include "VspKdTree.h"
 #include "VssTree.h"
-#include "RssTree.h"
+#include "VspBspTree.h"
+
 
 X3dExporter::X3dExporter(const string filename):Exporter(filename)
@@ -285 +286 @@
                         BspNodeGeometry *back = new BspNodeGeometry();
 
-                        cell->SplitGeometry(*front, *back, tree, *interior->GetPlane());
+                        cell->SplitGeometry(*front, 
+                                                                *back, 
+                                                                interior->GetPlane(), 
+                                                                tree.GetBoundingBox(), 
+                                                                tree.GetEpsilon());
 
                         tStack.push(pair<BspNode *, BspNodeGeometry *>(interior->GetFront(), front));
@@ -872 +877 @@
 }
 
-
-bool
-X3dExporter::ExportRssTree2(const RssTree &tree,
-                                                        const Vector3 direction
-                                                        )
-{
-  stack<RssTreeNode *> tStack;
-  
-  
-  mUseForcedMaterial = true;
-
-  Vector3 dirParam;
-
-  dirParam.x = VssRay::GetDirParam(0, Normalize(direction));
-  dirParam.y = VssRay::GetDirParam(1, Normalize(direction));
-
-  float maxImportance = 0.0f;
-  tStack.push(tree.GetRoot());
-  while (!tStack.empty()) {
-        
-        RssTreeNode *node = tStack.top();
-    tStack.pop();
-        
-    if (!node->IsLeaf()) {
-      RssTreeInterior *interior = (RssTreeInterior *)node;
-          if (interior->axis < 3) {
-                tStack.push(interior->front);
-                tStack.push(interior->back);
-          } else {
-                if (dirParam[interior->axis-3] < interior->position)
-                  tStack.push(interior->back);
-                else
-                  tStack.push(interior->front);
-          }
-    } else {
-          RssTreeLeaf *leaf = (RssTreeLeaf *)node;
-          if (tree.ValidLeaf(leaf)) {
-                float i = leaf->GetImportance();
-                if (i > maxImportance)
-                  maxImportance = i;
-          }
-        }
-  }
-
-  tStack.push(tree.GetRoot());
-  while (!tStack.empty()) {
-
-        RssTreeNode *node = tStack.top();
-    tStack.pop();
-        
-                        
-    if (!node->IsLeaf()) {
-      RssTreeInterior *interior = (RssTreeInterior *)node;
-          if (interior->axis < 3) {
-                tStack.push(interior->front);
-                tStack.push(interior->back);
-          } else {
-                if (dirParam[interior->axis-3] < interior->position)
-                  tStack.push(interior->back);
-                else
-                  tStack.push(interior->front);
-          }
-    } else {
-          RssTreeLeaf *leaf = (RssTreeLeaf *)node;
-          if (tree.ValidLeaf(leaf)) {
-                AxisAlignedBox3 box;
-                box = tree.GetShrankedBBox(leaf);
-                Mesh *mesh = new Mesh;
-                AddBoxToMesh(box, mesh);
-                
-                // get 4 corners of the ray directions
-                
-                mForcedMaterial.mDiffuseColor.b = 1.0f;
-                mForcedMaterial.mDiffuseColor.r = leaf->GetImportance()/maxImportance;
-                mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
-                
-                ExportMesh(mesh);
-                delete mesh;
-          }
-        }
-  }
-
-  mUseForcedMaterial = false;
-
-  return true;
-}
-
 bool
 X3dExporter::ExportBspTreeRayDensity(const BspTree &tree)
@@ -1070 +988 @@
         BspNode *mNode;
 
-        vector<Plane3 *> mPlanes;
+        vector<Plane3> mPlanes;
         vector<bool> mSides;
         bool mIsFront;
@@ -1080 +998 @@
 
         BspSplitData(BspNode *node, 
-                                vector<Plane3 *> planes, 
+                                vector<Plane3> planes, 
                                 vector<bool> sides, 
                                 const bool isFront,
@@ -1105 +1023 @@
 }
 
-void X3dExporter::ExportBspSplits(const BspTree &tree,
-                                                                  const bool exportDepth)
+void X3dExporter::ExportBspNodeSplits(BspNode *root,
+                                                                          const AxisAlignedBox3 &box, 
+                                                                          const bool exportDepth,
+                                                                          const bool epsilon)
 {
         std::stack<BspSplitData> tStack;
 
-        BspSplitData tData(tree.GetRoot());
+        BspSplitData tData(root);
         tStack.push(tData);
   
@@ -1134 +1054 @@
 
                         // add current side of split plane
-                        if (tData.mNode != tree.GetRoot())
+                        if (tData.mNode != root)
                                 tData.mSides.push_back(tData.mIsFront);
 
                         // bounded plane is added to the polygons
                         Polygon3 *planePoly = 
-                                tree.GetBoundingBox().CrossSection(*interior->GetPlane());
+                                box.CrossSection(interior->GetPlane());
                 
                         // do all the splits with the previous planes
                         for (int i = 0; i < (int)tData.mPlanes.size(); ++ i)
                         {                               
-                                if (planePoly->ClassifyPlane(*tData.mPlanes[i]) == Polygon3::SPLIT)
+                                if (planePoly->ClassifyPlane(tData.mPlanes[i], epsilon) 
+                                        == Polygon3::SPLIT)
                                 {
                                         Polygon3 *frontPoly = new Polygon3();
                                         Polygon3 *backPoly = new Polygon3();
 
-                                        planePoly->Split(*tData.mPlanes[i], *frontPoly, *backPoly);
+                                        planePoly->Split(tData.mPlanes[i], 
+                                                                         *frontPoly, 
+                                                                         *backPoly,
+                                                                         epsilon);
+
                                         DEL_PTR(planePoly);
 
@@ -1167 +1092 @@
                         tData.mPlanes.push_back(interior->GetPlane()); // add plane to split planes
 
-                        if (planePoly->Valid())
+                        if (planePoly->Valid(epsilon))
                         {
                                 polys.push_back(planePoly);
@@ -1206 +1131 @@
 }
 
+void X3dExporter::ExportBspSplits(const BspTree &tree,
+                                                                  const bool exportDepth)
+{
+        ExportBspNodeSplits(tree.GetRoot(), 
+                                                tree.GetBoundingBox(), 
+                                                exportDepth, 
+                                                tree.GetEpsilon());
+}
+
+void X3dExporter::ExportBspSplits(const VspBspTree &tree,
+                                                                  const bool exportDepth)
+{
+        ExportBspNodeSplits(tree.GetRoot(), 
+                                                tree.GetBoundingBox(), 
+                                                exportDepth, 
+                                                tree.GetEpsilon());
+}
+
 void X3dExporter::ExportBspSplitPlanes(const BspTree &tree)
 {
@@ -1225 +1168 @@
 
                         // bounded plane is added to the polygons
-                        polys.push_back(tree.GetBoundingBox().CrossSection(*interior->GetPlane()));
+                        polys.push_back(tree.GetBoundingBox().CrossSection(interior->GetPlane()));
                 
                         // push the children on the stack
@@ -1238 +1181 @@
 
 
-void
-X3dExporter::ExportGeometry(const ObjectContainer &objects)
-{
-  
-  ObjectContainer::const_iterator oi = objects.begin();
-  for (; oi != objects.end(); oi++) {
-    // export the transform...
-    ExportIntersectable(*oi);
-  }
-  
-}
+void X3dExporter::ExportGeometry(const ObjectContainer &objects)
+{
+        for (int j = 0; j < objects.size(); ++ j)
+                ExportIntersectable(objects[j]);
+}
+
+void X3dExporter::ExportBspViewCellPartition(const VspBspTree &tree, 
+                                                                                         const int maxPvs)
+{
+        ViewCellContainer viewCells;
+        tree.CollectViewCells(viewCells);
+
+        ViewCellContainer::const_iterator it, it_end = viewCells.end();
+
+        if (maxPvs > 0)
+                mUseForcedMaterial = true;
+
+        for (it = viewCells.begin(); it != it_end; ++ it)
+        {
+                if (maxPvs > 0)
+                {
+                        mForcedMaterial.mDiffuseColor.b = 1.0f;
+                        float importance = (float)(*it)->GetPvs().GetSize() / (float)maxPvs;
+
+                        mForcedMaterial.mDiffuseColor.r = importance;
+                        mForcedMaterial.mDiffuseColor.g = 1.0f - mForcedMaterial.mDiffuseColor.r;
+                }
+
+                if ((*it)->GetMesh())
+                        ExportViewCell(*it);
+                else
+                {
+                        PolygonContainer cell;
+                        tree.ConstructGeometry(dynamic_cast<BspViewCell *>(*it), cell);
+
+                        ExportPolygons(cell);
+                }
+        }
+}