Changeset 366 for trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

Timestamp:

11/01/05 20:02:22 (19 years ago)

Author:

mattausch

Message:

some ideas abou saving bspleaves with the ray and t

File:

• trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp (modified) (11 diffs)

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

@@ -260 +260 @@
 }
 
-BspLeaf::BspLeaf(ViewCell *viewCell): 
+BspLeaf::BspLeaf(BspViewCell *viewCell): 
 mViewCell(viewCell)
 {
@@ -269 +269 @@
 {}
 
-BspLeaf::BspLeaf(BspInterior *parent, ViewCell *viewCell): 
+BspLeaf::BspLeaf(BspInterior *parent, BspViewCell *viewCell): 
 BspNode(parent), mViewCell(viewCell)
 {
 }
 
-ViewCell *BspLeaf::GetViewCell()
+BspViewCell *BspLeaf::GetViewCell() const
 {
         return mViewCell;
 }
 
-void BspLeaf::SetViewCell(ViewCell *viewCell)
+void BspLeaf::SetViewCell(BspViewCell *viewCell)
 {
         mViewCell = viewCell;
@@ -297 +297 @@
         contributingSamples = 0;
 
-        mViewCell = new ViewCell();
+        mViewCell = dynamic_cast<BspViewCell *>(ViewCell::Generate());
+        mViewCell->mBspLeaves.push_back(this);
 
     BoundedRayContainer::const_iterator it, it_end = rays.end();
@@ -320 +321 @@
                 }
 
-                ray->bspLeaves.push_back(this);
+                ray->bspIntersections.push_back(BspIntersection(this, (*it)->mMinT);
 
                 if (storeRays)
@@ -711 +712 @@
                 {
                         // add view cell to leaf
-                        leaf->SetViewCell(tData.mViewCell);
+                        leaf->SetViewCell(dynamic_cast<BspViewCell *>(tData.mViewCell));
+                        leaf->mViewCell->mBspLeaves.push_back(leaf);
                 }
 
@@ -1244 +1246 @@
         float sumBalancedRays = 0;
         float sumRaySplits = 0;
+        float pvsSize = 0;
+
+        Intersectable::NewMail();
 
         BoundedRayContainer::const_iterator rit, rit_end = rays.end();
@@ -1264 +1269 @@
                 {
                         sumRaySplits += sLeastRaySplitsTable[classification];
+                }
+
+                if (sSplitPlaneStrategy & PVS)
+                {
+                        vector<Ray::Intersection>::const_iterator it, 
+                                it_end = ray->intersections.end();
+
+                        for (it = ray->intersections.begin(); it != it_end; ++ it)
+                        {
+                                if (!(*it).mObject->Mailed())
+                                {
+                                        (*it).mObject->Mail();
+                                }
+                        }
                 }
         }
@@ -1597 +1616 @@
 }
 
+int BspTree::CountViewCellPvs() const
+{
+        int count = 0;
+        stack<BspNode *> nodeStack;
+        nodeStack.push(mRoot);
+
+        ViewCell::NewMail();
+
+        // exclude root cell
+        mRootCell->Mail();
+
+        while (!nodeStack.empty()) 
+        {
+                BspNode *node = nodeStack.top();
+                nodeStack.pop();
+
+                if (node->IsLeaf()) 
+                {
+                        ViewCell *viewCell = dynamic_cast<BspLeaf *>(node)->mViewCell;
+
+                        if (!viewCell->Mailed()) 
+                        {
+                                viewCell->Mail();
+                                count += viewCell->GetPvs().GetSize();
+                        }
+                }
+                else 
+                {
+                        BspInterior *interior = dynamic_cast<BspInterior *>(node);
+
+                        nodeStack.push(interior->mFront);
+                        nodeStack.push(interior->mBack);
+                }
+        }
+        return count;
+}
 
 bool BspTree::MergeViewCells(BspLeaf *front, BspLeaf *back) const
 {
-        ViewCell *viewCell = ViewCell::Merge(*front->mViewCell, *back->mViewCell);
+        BspViewCell *viewCell = 
+                dynamic_cast<BspViewCell *>(ViewCell::Merge(*front->mViewCell, *back->mViewCell));
         
         if (!viewCell)
                 return false;
 
-        DEL_PTR(front->mViewCell);
-        DEL_PTR(back->mViewCell);
-
-        front->SetViewCell(viewCell);
-        back->SetViewCell(viewCell);
+        // change view cells of all leaves associated with the
+        // previous view cells
+
+        BspViewCell *fVc = front->mViewCell;
+        BspViewCell *bVc = back->mViewCell;
+
+        vector<BspLeaf *> fLeaves = fVc->mBspLeaves;
+        vector<BspLeaf *> bLeaves = bVc->mBspLeaves;
+
+        vector<BspLeaf *>::const_iterator it;
+        
+        for (it = fLeaves.begin(); it != fLeaves.end(); ++ it)
+        {
+                (*it)->SetViewCell(viewCell);
+                viewCell->mBspLeaves.push_back(*it);
+        }
+        for (it = bLeaves.begin(); it != bLeaves.end(); ++ it)
+        {
+                (*it)->SetViewCell(viewCell);
+                viewCell->mBspLeaves.push_back(*it);
+        }
+        
+        DEL_PTR(fVc);
+        DEL_PTR(bVc);
 
         return true;
@@ -1616 +1691 @@
 bool BspTree::ShouldMerge(BspLeaf *front, BspLeaf *back) const
 {
-        if (front->mViewCell->GetPvs().Diff(back->mViewCell->GetPvs()) < 
-                sMinPvsDif)
-                return true;
-        
-        if (back->mViewCell->GetPvs().Diff(front->mViewCell->GetPvs()) < 
-                sMinPvsDif)
+        ViewCell *fvc = front->mViewCell;
+        ViewCell *bvc = back->mViewCell;
+
+        if ((fvc == mRootCell) || (bvc == mRootCell) || (fvc == bvc))
+                return false;
+
+        /*Debug << "merge (" << sMinPvsDif << ")" << endl;
+        Debug << "size f: " << fvc->GetPvs().GetSize() << ", "
+                  << "size b: " << bvc->GetPvs().GetSize() << endl;
+        
+        Debug << "diff f: " << fvc->GetPvs().Diff(bvc->GetPvs()) << ", "
+                  << "diff b: " << bvc->GetPvs().Diff(fvc->GetPvs()) << endl;*/
+
+    if ((fvc->GetPvs().Diff(bvc->GetPvs()) < sMinPvsDif) &&
+            (bvc->GetPvs().Diff(fvc->GetPvs()) < sMinPvsDif))
                 return true;
 
@@ -1965 +2049 @@
 }
 
+void BspTree::ConstructGeometry(BspViewCell *vc, PolygonContainer &cell) const
+{
+        vector<BspLeaf *> leaves = vc->mBspLeaves;
+
+        vector<BspLeaf *>::const_iterator it, it_end = leaves.end();
+
+        for (it = leaves.begin(); it != it_end; ++ it)
+                ConstructGeometry(*it, cell);
+}
+
 int BspTree::FindNeighbors(BspNode *n, vector<BspLeaf *> &neighbors, 
                                                    const bool onlyUnmailed) const
@@ -2121 +2215 @@
         return NULL;
 }
+
+int BspTree::CountPvs(const BoundedRayContainer &rays) const
+{
+        int pvsSize = 0;
+
+        BoundedRayContainer::const_iterator rit, rit_end = rays.end();
+        vector<BspLeaf *>::const_iterator lit;
+
+        ViewCell::NewMail();
+
+        for (rit = rays.begin(); rit != rit_end; ++ rit)
+        {
+                Ray *ray = (*rit)->mRay;
+                
+                for (lit = ray->bspLeaves.begin(); lit != ray->bspLeaves.end(); ++ lit)
+                {
+                        if ((*lit)->mViewCell->Mailed())
+                        {
+                                pvsSize += (*lit)->mViewCell->GetPvs().GetSize();
+                        }
+                }
+        }
+
+        return pvsSize;
+}