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

Timestamp:

10/13/05 17:58:37 (19 years ago)

Author:

mattausch

Message:

worked on the ray based subdivision. finished extracting polygons from rays

File:

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

trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

@@ -12 +12 @@
 #include <iomanip>
 #include "Exporter.h"
+#include "Plane3.h"
 
 int BspTree::sTermMaxPolygons = 10;
@@ -160 +161 @@
 {
         Polygon3 *splitPoly = NULL;
+
 #ifdef _Debug
         Debug << "splitting polygons of node " << this << " with plane " << mPlane << endl;
@@ -170 +172 @@
                 //Debug << "New polygon with plane: " << poly->GetSupportingPlane() << "\n";
 
-                // get polygon classification
+                // classify polygon
                 int classification = poly->ClassifyPlane(mPlane);
 
@@ -180 +182 @@
                 switch (classification)
                 {
-                        case Polygon3::COINCIDENT:
+                        case Plane3::COINCIDENT:
                                 coincident.push_back(poly);
                                 break;                  
-                        case Polygon3::FRONT_SIDE:      
+                        case Plane3::FRONT_SIDE:        
                                 frontPolys.push_back(poly);
                                 break;
-                        case Polygon3::BACK_SIDE:
+                        case Plane3::BACK_SIDE:
                                 backPolys.push_back(poly);
                                 break;
-                        case Polygon3::SPLIT:
+                        case Plane3::SPLIT:
                                 front_piece = new Polygon3(poly->mParent);
                                 back_piece = new Polygon3(poly->mParent);
@@ -505 +507 @@
         mStat.polys = AddToPolygonSoup(viewCells, *polys);
 
-        // construct tree from viewcell polygons
-        Construct(polys);
+        // construct tree from the view cell polygons
+        Construct(polys, NULL);
 }
 
@@ -521 +523 @@
 
         // construct tree from polygon soup
-        Construct(polys, viewCells);
-}
-
-void BspTree::Construct(const ObjectContainer &objects,
-                                                const RayContainer &rays, 
+        Construct(polys, NULL, viewCells);
+}
+
+void BspTree::Construct(RayContainer *rays, 
                                                 ViewCellContainer *viewCells)
 {
         PolygonContainer *polys = new PolygonContainer();
         
-        // copy mesh instance polygons into one big polygon soup
-        mStat.polys = AddToPolygonSoup(objects, *polys);
-
-        RayContainer::const_iterator rit, rit_end = rays.end();
+        RayContainer::const_iterator rit, rit_end = rays->end();
 
         long startTime = GetTime();
-        Debug << "**** Casting rays into polygons ****\n";
-
-        //-- cast rays into all polygons
-        for (rit = rays.begin(); rit != rays.end(); ++ rit)
+        Debug << "**** Extracting polygons from rays ****\n";
+
+        std::map<Face *, Polygon3 *> facePolyMap;
+
+        //-- extract polygons from faces stored in the rays
+        for (rit = rays->begin(); rit != rit_end; ++ rit)
         {
                 Ray *ray = *rit;
-
-                PolygonContainer::const_iterator pit, pit_end = polys->end();
-                
-                for (pit = polys->begin(); pit != pit_end; ++ pit)
-                {
-                        Polygon3 *poly = *pit;
+        
+                for (int i = 0; i < (int)ray->intersections.size(); ++ i)
+                {
+                        MeshInstance *obj = dynamic_cast<MeshInstance *>(ray->intersections[i].mObject);
+                        Face *face = obj->GetMesh()->mFaces[i];
                         
-                        float t = 0;
-                        float nearestT = 0;
-
-                        if (poly->CastRay(*ray, t, nearestT) > 0)
-                                poly->AddPiercingRay(ray);
-                }
-        }
-
-        Debug << "**** Finished ray casting ****\n";
+                         std::map<Face *, Polygon3 *>::iterator it= facePolyMap.find(face);
+
+                         if (it != facePolyMap.end()) 
+                         {
+                                 (*it).second->AddPiercingRay(ray);
+                         } 
+                         else
+                         {
+                                 Polygon3 *poly = new Polygon3(face, obj->GetMesh());
+                                 polys->push_back(poly);
+                                 poly->AddPiercingRay(ray);
+
+                                 facePolyMap[face] = poly;
+                         }
+                }
+        }
+
+        
+        mStat.polys = (int)polys->size();
+
+        Debug << "**** Finished polygon extraction ****\n";
         Debug << "ray casting time: " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl;
 
-        Construct(polys, viewCells);
-}
-
-void BspTree::Construct(PolygonContainer *polys, ViewCellContainer *viewCells)
+        Construct(polys, rays, viewCells);
+}
+
+void BspTree::Construct(PolygonContainer *polys, RayContainer *rays, ViewCellContainer *viewCells)
 {
         std::stack<BspTraversalData> tStack;
         
-        BspTraversalData tData(new BspLeaf(), polys, 0, mRootCell);
+        BspTraversalData tData(new BspLeaf(), polys, 0, mRootCell, rays);
         tStack.push(tData);
 
@@ -670 +681 @@
                 RayContainer *backRays = new RayContainer();
 
-                Plane3 plane;
-                SplitRays(plane, *tData.mRays, *frontRays, *backRays);
+                SplitRays(interior->mPlane, *tData.mRays, *frontRays, *backRays);
         }
 
@@ -1022 +1032 @@
                 if (sSplitPlaneStrategy & LARGEST_POLY_AREA)
                 {
-                        if (classification == Polygon3::COINCIDENT)
+                        if (classification == Plane3::COINCIDENT)
                                 sumPolyArea += (*it)->GetArea();
                         //totalArea += area;
@@ -1031 +1041 @@
                 {
                         float blockedRays = (float)(*it)->GetPiercingRays()->size();
-                        if (classification == Polygon3::COINCIDENT)
+                        if (classification == Plane3::COINCIDENT)
                         {
                                 sumBlockedRays += blockedRays;
@@ -1044 +1054 @@
                         MeshInstance *viewCell = (*it)->mParent;
                 
-                        if (classification == Polygon3::FRONT_SIDE)
+                        if (classification == Plane3::FRONT_SIDE)
                                 frontViewCells.push_back(viewCell);
-                        else if (viewCell && (classification == Polygon3::BACK_SIDE))
+                        else if (viewCell && (classification == Plane3::BACK_SIDE))
                                 backViewCells.push_back(viewCell);
                 }
@@ -1249 +1259 @@
 
         // bound ray
-        if ((ray.GetType() == Ray::LOCAL_RAY)   && 
-                ((int)ray.intersections.size() > 0) &&
+        if ((ray.GetType() == Ray::LOCAL_RAY) && 
+                (!ray.intersections.empty())      &&
             (ray.intersections[0].mT <= maxt))
         {
@@ -1383 +1393 @@
 }
 
+
 void BspTree::SplitRays(const Plane3 plane,
-                                                RayContainer &rays, 
-                                                RayContainer &frontRays, 
-                                                RayContainer &backRays)
+                                           RayContainer &rays, 
+                                           RayContainer &frontRays, 
+                                           RayContainer &backRays)
 {
         while (!rays.empty())
         {
-                //TODO
+                Ray *ray = rays.back();
+                rays.pop_back();
+
+                //-- ray-plane intersection
+                float maxT = 1e6;
+                float minT = 0;
+        
+                // test with tree bounding box
+                if (!mBox.GetMinMaxT(*ray, &minT, &maxT))
+                        continue;
+
+                if (minT < 0) // start ray from origin
+                        minT = 0;
+
+                // bound ray
+                if ((ray->GetType() == Ray::LOCAL_RAY) && 
+                        (ray->intersections.empty())      &&
+                        (ray->intersections[0].mT <= maxT))
+                {
+                        maxT = ray->intersections[0].mT;
+                }
+                
+                int classification = ray->ClassifyPlane(plane, minT, maxT);
+                
+                switch (classification)
+                {
+                case Plane3::COINCIDENT:
+                        break;
+                case Plane3::BACK_SIDE:
+                        backRays.push_back(ray);
+                        break;
+                case Plane3::FRONT_SIDE:
+                        frontRays.push_back(ray);
+                        break;
+                case Plane3::SPLIT:
+                        frontRays.push_back(ray);
+                        backRays.push_back(ray);
+                        //extp = splitPlane->FindIntersection(ray.GetLoc(), extp, &maxt);
+                        break;
+                default:
+                        break;
+                }
         }
 }