Ignore:
Timestamp:
10/12/05 01:15:22 (19 years ago)
Author:
mattausch
Message:

changed the from rays construction (not finished yet)

Location:
trunk/VUT/GtpVisibilityPreprocessor
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/GtpVisibilityPreprocessor/scripts/default.env

    r318 r319  
    99#       filename vienna.x3d 
    1010#       filename ../data/vienna/vienna-simple.x3d 
    11 #       filename ../data/vienna/vienna-buildings.x3d 
     11        filename ../data/vienna/vienna-buildings.x3d 
    1212#       filename ../data/vienna/viewcells-25-sel.x3d 
    13         filename ../data/atlanta/atlanta2.x3d 
     13#       filename ../data/atlanta/atlanta2.x3d 
    1414#       filename ../data/soda/soda.dat 
    1515#       filename ../data/soda/soda5.dat 
    … …  
    6666        #hierarchyType kdTree 
    6767        #hierarchyType sceneDependent 
    68         filename ../data/atlanta/atlanta_viewcells_large.x3d 
     68#       filename ../data/atlanta/atlanta_viewcells_large.x3d 
    6969#       filename ../data/vienna/viewcells-25-sel.x3d 
    7070        filename ../data/vienna/viewcells-25.x3d 
    … …  
    8484        # largest polygon area = 32 
    8585        # vertical axis        = 64 
     86        # blocked rays         = 128 
    8687         
    87         splitPlaneStrategy 66 
    8888        # least splits + balanced polygons 
    8989        #splitPlaneStrategy 12 
    … …  
    101101        #splitPlaneStrategy 72 
    102102         
     103        splitPlaneStrategy 66 
     104         
    103105        maxCandidates 50 
    104106         

  • trunk/VUT/GtpVisibilityPreprocessor/src/Polygon3.cpp

    r318 r319  
    66#include "Ray.h" 
    77 
    8 Polygon3::Polygon3(): mMaterial(NULL), mParent(NULL) 
     8Polygon3::Polygon3():  
     9mMaterial(NULL), mParent(NULL), mPiercingRays(NULL) 
    910{} 
    1011 
    11 Polygon3::Polygon3(const VertexContainer &vertices): mVertices(vertices), mMaterial(NULL), mParent(NULL) 
     12Polygon3::Polygon3(const VertexContainer &vertices):  
     13mVertices(vertices), mMaterial(NULL), mParent(NULL), mPiercingRays(NULL) 
    1214{} 
    1315 
    14 Polygon3::Polygon3(MeshInstance *parent): mMaterial(NULL), mParent(parent) 
     16Polygon3::Polygon3(MeshInstance *parent):  
     17mMaterial(NULL), mParent(parent) 
    1518{} 
    16  
    17 // creates an "infinite" polygon from this plane 
    18 //Polygon3::Polygon3(Plane3 plane) 
    19 //{} 
    2019 
    2120Polygon3::Polygon3(Face *face, Mesh *parentMesh) 
    … …  
    2726                mMaterial = parentMesh->mMaterial; 
    2827        } 
     28} 
     29 
     30Polygon3::~Polygon3() 
     31{ 
     32        DEL_PTR(mPiercingRays); 
    2933} 
    3034 
    … …  
    352356} 
    353357 
     358RayContainer *Polygon3::GetPiercingRays() 
     359{ 
     360        if (!mPiercingRays) 
     361                mPiercingRays = new RayContainer(); 
     362        return mPiercingRays; 
     363} 
     364 
     365void Polygon3::AddPiercingRay(Ray *ray) 
     366{ 
     367        if (!mPiercingRays) 
     368                mPiercingRays = new RayContainer(); 
     369        //if (binary_search(mPiercingRays.begin(), mPiercingRays.end(), ray)) return false; 
     370         
     371        mPiercingRays->push_back(ray); 
     372} 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Polygon3.h

    r317 r319  
    8787        int CastRay(const Ray &ray, float &t, const float nearestT); 
    8888 
     89        /** Returns piercing rays container. 
     90        */ 
     91        RayContainer *GetPiercingRays(); 
     92 
     93        /** Adds a ray to the ray container. 
     94        */ 
     95        void AddPiercingRay(Ray *ray); 
     96 
    8997        /// vertices are connected in counterclockwise order. 
    9098        VertexContainer mVertices; 
    … …  
    95103        /// pointer to the mesh instance this polygon is derived from 
    96104        MeshInstance *mParent; 
     105 
     106        /// Rays piercing this polygon 
     107        RayContainer *mPiercingRays; 
    97108}; 
    98109 

  • trunk/VUT/GtpVisibilityPreprocessor/src/Preprocessor.cpp

    r313 r319  
    168168                break; 
    169169        case BspTree::FROM_RAYS: 
    170                 DeleteViewCells(); // we generate new view cells         
    171                 mBspTree->Construct(rays, &mViewCells); 
     170                DeleteViewCells(); // we generate new view cells 
     171                mSceneGraph->CollectObjects(&objects); 
     172                mBspTree->Construct(objects, rays, &mViewCells); 
    172173                break; 
    173174        default: 

  • trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.cpp

    r318 r319  
    236236  vector<Ray> vcRays[5]; 
    237237 
     238  const int fromRaysBspThresh = 1000; 
     239 
    238240  while (totalSamples < mTotalSamples) { 
    239241                int passContributingSamples = 0; 
    … …  
    241243                int passSamples = 0; 
    242244                int index = 0; 
    243                                  
     245                         
     246                // construct Bsp tree if not 
     247                if ((mViewCellsType == Preprocessor::BSP_VIEW_CELLS) && 
     248                        !mBspTree->GetRoot() && (passSamples > fromRaysBspThresh)) 
     249                { 
     250                        BuildBspTree(); 
     251                } 
     252 
    244253                for (i = 0; i < objects.size(); i++) { 
    245254                        KdNode *nodeToSample = NULL; 

  • trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

    r318 r319  
    1616int BspTree::sTermMaxDepth = 20; 
    1717int BspTree::sMaxCandidates = 10; 
    18 int BspTree::sSplitPlaneStrategy = NEXT_POLYGON;  
     18int BspTree::sSplitPlaneStrategy = BALANCED_POLYS;  
    1919int BspTree::sConstructionMethod = FROM_INPUT_VIEW_CELLS; 
    2020int BspTree::sTermMaxPolysForAxisAligned = 50; 
    … …  
    3030float BspTree::sVerticalSplitsFactor = 1.0f; // very important criterium for 2.5d scenes 
    3131float BspTree::sLargestPolyAreaFactor = 1.0f; 
     32float BspTree::sBlockedRaysFactor = 1.0f; 
    3233 
    3334/** Evaluates split plane classification with respect to the plane's  
    … …  
    552553} 
    553554 
    554 void BspTree::Construct(const RayContainer &rays, ViewCellContainer *viewCells) 
    555 { 
    556         // TODO 
     555void BspTree::Construct(const ObjectContainer &objects, 
     556                                                const RayContainer &rays,  
     557                                                ViewCellContainer *viewCells) 
     558{ 
     559        PolygonContainer *polys = new PolygonContainer(); 
     560         
     561        // copy mesh instance polygons into one big polygon soup 
     562        mStat.polys = AddToPolygonSoup(objects, *polys); 
     563 
     564        RayContainer::const_iterator rit, rit_end = rays.end(); 
     565 
     566        long startTime = GetTime(); 
     567        Debug << "**** Casting rays into polygons ****\n"; 
     568 
     569        //-- cast rays into all polygons 
     570        for (rit = rays.begin(); rit != rays.end(); ++ rit) 
     571        { 
     572                Ray *ray = *rit; 
     573 
     574                PolygonContainer::const_iterator pit, pit_end = polys->end(); 
     575                 
     576                for (pit = polys->begin(); pit != pit_end; ++ pit) 
     577                { 
     578                        Polygon3 *poly = *pit; 
     579                         
     580                        float t = 0; 
     581                        float nearestT = 0; 
     582 
     583                        if (poly->CastRay(*ray, t, nearestT) > 0) 
     584                                poly->AddPiercingRay(ray); 
     585                } 
     586        } 
     587 
     588        Debug << "**** Finished ray casting ****\n"; 
     589        Debug << "ray casting time: " << TimeDiff(startTime, GetTime())*1e-3 << "s" << endl; 
     590 
     591        Construct(polys, viewCells); 
    557592} 
    558593 
    … …  
    565600 
    566601        long startTime = GetTime(); 
    567         Debug << "**** Contructing tree using objects ****\n"; 
     602        Debug << "**** Contructing tree using scene geometry ****\n"; 
    568603        while (!tStack.empty())  
    569604        { 
    … …  
    607642                leaf->SetViewCell(tData.mViewCell); 
    608643                 
    609                 //-- clean up 
    610  
     644                // clean up 
    611645                // remaining polygons are discarded or added to node 
    612646                leaf->ProcessPolygons(tData.mPolygons, mStoreSplitPolys); 
    613647                DEL_PTR(tData.mPolygons); 
    614  
    615         CLEAR_CONTAINER(*tData.mRays); 
    616                 DEL_PTR(tData.mRays); 
    617648 
    618649                return leaf; 
    … …  
    629660                                                                                  *frontPolys, 
    630661                                                                                  *backPolys,  
    631                                                                                   coincident, 
    632                                                                                   *tData.mRays); 
     662                                                                                  coincident); 
    633663 
    634664        ViewCell *frontViewCell = mRootCell; 
    … …  
    644674        // extract view cells from coincident polygons according to plane normal 
    645675    // only if front or back polygons are empty 
    646         ExtractViewCells(&backViewCell,  
    647                                          &frontViewCell,  
    648                                          coincident,  
    649                                          interior->mPlane,  
     676        ExtractViewCells(&backViewCell, 
     677                                         &frontViewCell, 
     678                                         coincident, 
     679                                         interior->mPlane, 
    650680                                         backPolys->empty(), 
    651681                                         frontPolys->empty()); 
    … …  
    653683        // don't need coincident polygons anymore 
    654684        interior->ProcessPolygons(&coincident, mStoreSplitPolys); 
    655  
    656         // split rays 
    657         RayContainer *frontRays = NULL; 
    658         RayContainer *backRays = NULL; 
    659  
    660         if (tData.mRays->size() > 0) 
    661         { 
    662                 RayContainer *frontRays = new RayContainer(); 
    663                 RayContainer *backRays = new RayContainer(); 
    664  
    665                 Plane3 plane; 
    666                 SplitRays(plane, *tData.mRays, *frontRays, *backRays); 
    667         } 
    668685 
    669686        // push the children on the stack 
    … …  
    671688                                                                 backPolys,  
    672689                                                                 tData.mDepth + 1,  
    673                                                                  backViewCell,  
    674                                                                  backRays)); 
     690                                                                 backViewCell)); 
    675691 
    676692        tStack.push(BspTraversalData(interior->GetFront(),  
    677693                                                                 frontPolys,  
    678694                                                                 tData.mDepth + 1,  
    679                                                                  frontViewCell,  
    680                                                                  frontRays)); 
     695                                                                 frontViewCell)); 
    681696 
    682697        // cleanup 
    683698        DEL_PTR(tData.mNode); 
    684699        DEL_PTR(tData.mPolygons); 
    685         DEL_PTR(tData.mRays); 
    686700 
    687701        return interior; 
    … …  
    720734                                                                        PolygonContainer &frontPolys, 
    721735                                                                        PolygonContainer &backPolys,  
    722                                                                         PolygonContainer &coincident, 
    723                                                                         const RayContainer &rays) 
     736                                                                        PolygonContainer &coincident) 
    724737{ 
    725738        mStat.nodes += 2; 
    726739 
    727740        // add the new nodes to the tree + select subdivision plane 
    728         BspInterior *interior = new BspInterior(SelectPlane(leaf, polys, rays));  
     741        BspInterior *interior = new BspInterior(SelectPlane(leaf, polys));  
    729742 
    730743#ifdef _DEBUG 
    … …  
    863876 
    864877Plane3 BspTree::SelectPlane(BspLeaf *leaf,  
    865                                                         PolygonContainer &polys,  
    866                                                         const RayContainer &rays) 
     878                                                        PolygonContainer &polys) 
    867879{ 
    868880        if (polys.size() == 0) 
    … …  
    917929 
    918930        // use heuristics to find appropriate plane 
    919         return SelectPlaneHeuristics(polys, rays, sMaxCandidates); 
     931        return SelectPlaneHeuristics(polys, sMaxCandidates); 
    920932} 
    921933 
    922934Plane3 BspTree::SelectPlaneHeuristics(PolygonContainer &polys, 
    923                                                                           const RayContainer &rays, 
    924935                                                                          const int maxTests) 
    925936{ 
    … …  
    938949                 
    939950                // evaluate current candidate 
    940                 float candidateCost = EvalSplitPlane(polys, candidatePlane, rays); 
     951                float candidateCost = EvalSplitPlane(polys, candidatePlane); 
    941952                         
    942953                if (candidateCost < lowestCost) 
    … …  
    966977 
    967978float BspTree::EvalSplitPlane(PolygonContainer &polys,  
    968                                                           const Plane3 &candidatePlane,  
    969                                                           const RayContainer &rays) 
     979                                                          const Plane3 &candidatePlane) 
    970980{ 
    971981        float val = 0; 
    … …  
    980990        } 
    981991 
    982         //-- strategies where the effect of the split plane on the polygons is tested 
    983         if (!((sSplitPlaneStrategy & BALANCED_POLYS) || 
    984                   (sSplitPlaneStrategy & LEAST_SPLITS)   || 
    985                   (sSplitPlaneStrategy & LARGEST_POLY_AREA) || 
    986                   (sSplitPlaneStrategy & BALANCED_VIEW_CELLS))) 
     992        // strategies where the effect of the split plane is tested 
     993        // on all input polygons  
     994        if (!((sSplitPlaneStrategy & BALANCED_POLYS)      || 
     995                  (sSplitPlaneStrategy & LEAST_SPLITS)        || 
     996                  (sSplitPlaneStrategy & LARGEST_POLY_AREA)   || 
     997                  (sSplitPlaneStrategy & BALANCED_VIEW_CELLS) || 
     998                  (sSplitPlaneStrategy & BLOCKED_RAYS))) 
     999        { 
    9871000                return val; 
    988          
    989         PolygonContainer::const_iterator it, it_end = polys.end(); 
     1001        } 
     1002 
    9901003        float sumBalancedPolys = 0; 
    9911004        float sumSplits = 0; 
    9921005        float sumPolyArea = 0; 
    9931006        float sumBalancedViewCells = 0; 
     1007        float sumBlockedRays = 0; 
     1008 
     1009        float totalBlockedRays = 0; 
    9941010        //float totalArea = 0; 
    9951011 
    996         // container for view cells 
     1012        // container for balanced view cells criterium 
    9971013        ObjectContainer frontViewCells; 
    9981014        ObjectContainer backViewCells; 
     1015 
     1016        PolygonContainer::const_iterator it, it_end = polys.end(); 
    9991017 
    10001018        for (it = polys.begin(); it != it_end; ++ it) 
    … …  
    10191037                } 
    10201038 
     1039                 
     1040                if (sSplitPlaneStrategy & BLOCKED_RAYS) 
     1041                { 
     1042                        float blockedRays = (float)(*it)->GetPiercingRays()->size(); 
     1043                        if (classification == Polygon3::COINCIDENT) 
     1044                        { 
     1045                                sumBlockedRays += blockedRays; 
     1046                        } 
     1047 
     1048                        totalBlockedRays += blockedRays; 
     1049                } 
     1050 
    10211051                // assign view cells to back or front according to classificaion 
    10221052                if (sSplitPlaneStrategy & BALANCED_VIEW_CELLS) 
    … …  
    10311061        } 
    10321062 
     1063        // all values should be approx. between 0 and 1 so they can be combined 
     1064        // and scaled with the factors according to their importance 
    10331065        if (sSplitPlaneStrategy & BALANCED_POLYS) 
    10341066                val += sBalancedPolysFactor * fabs(sumBalancedPolys) / (float)polys.size(); 
    … …  
    10381070 
    10391071        if (sSplitPlaneStrategy & LARGEST_POLY_AREA)  
    1040                 val += sLargestPolyAreaFactor * (float)polys.size() / sumPolyArea; // HACK 
     1072                // HACK (polys.size should be totalArea) 
     1073                val += sLargestPolyAreaFactor * (float)polys.size() / sumPolyArea; 
     1074 
     1075        if (sSplitPlaneStrategy & BLOCKED_RAYS) 
     1076                if (totalBlockedRays > 0) 
     1077                        val += sBlockedRaysFactor * sumBlockedRays / totalBlockedRays; 
    10411078 
    10421079        if (sSplitPlaneStrategy & BALANCED_VIEW_CELLS) 
    … …  
    11331170        if (sSplitPlaneStrategy & VERTICAL_AXIS) 
    11341171                Debug << "vertical axis "; 
     1172        if (sSplitPlaneStrategy & BLOCKED_RAYS) 
     1173                Debug << "blocked rays "; 
    11351174 
    11361175        Debug << endl; 
    … …  
    13571396        } 
    13581397} 
    1359  
    1360 void BspTree::SplitRays(const Plane3 plane, 
    1361                                                 RayContainer &rays,  
    1362                                                 RayContainer &frontRays,  
    1363                                                 RayContainer &backRays) 
    1364 { 
    1365         while (!rays.empty()) 
    1366         { 
    1367                 //TODO 
    1368         } 
    1369 } 
    13701398//} // GtpVisibilityPreprocessor 

  • trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.h

    r318 r319  
    254254                /// the view cell associated with this subdivsion 
    255255                ViewCell *mViewCell; 
    256                 /// rays piercing this node 
    257                 RayContainer *mRays; 
    258  
     256                 
    259257                BspTraversalData(): 
    260258                mNode(NULL), 
    261259                mPolygons(NULL), 
    262260                mDepth(0), 
    263                 mViewCell(NULL), 
    264                 mRays(NULL) 
     261                mViewCell(NULL) 
    265262                {} 
    266263                 
    … …  
    268265                                                 PolygonContainer *polys,  
    269266                                                 const int depth,  
    270                                                  ViewCell *viewCell, 
    271                                                  RayContainer *rays = NULL):  
     267                                                 ViewCell *viewCell):  
    272268                mNode(node),  
    273269                mPolygons(polys),  
    274270                mDepth(depth),  
    275                 mViewCell(viewCell), 
    276                 mRays(rays) 
     271                mViewCell(viewCell) 
    277272                {} 
    278273    }; 
    … …  
    299294 
    300295        /** Constructs tree using the given list of objects.  
    301             Note that the objects are not taken as view cells, but the view cells are 
    302                 constructed from the subdivision: Each leaf is taken as one viewcell; 
     296            @note the objects are not taken as view cells, but the view cells are 
     297                constructed from the subdivision: Each leaf is taken as one viewcell. 
    303298 
    304299                @param objects list of objects 
    … …  
    307302        void Construct(const ObjectContainer &objects, ViewCellContainer *viewCells); 
    308303 
    309         /** Constructs tree using the given number of rays 
    310             @param objects list of objects 
    311                 @returns list of view cells. 
    312         */ 
    313         void Construct(const RayContainer &rays, ViewCellContainer *viewCells); 
    314  
    315         int CollectLeafPvs(); 
    316  
     304        /** Constructs the tree from the given list of polygons. 
     305                @param viewCells if not NULL, new view cells are  
     306                created in the leafs and stored in the conatainer 
     307        */ 
     308        void Construct(PolygonContainer *polys, ViewCellContainer *viewCells = NULL); 
     309         
     310        /** Constructs the tree from a list of scene geometry and a  
     311                given bundle of rays. 
     312                @param objects list of objects 
     313                @param rays the bundle of sample rays 
     314                @param viewCells if not NULL, new view cells are  
     315                created in the leafs and stored in the conatainer 
     316        */ 
     317        void Construct(const ObjectContainer &objects, 
     318                                   const RayContainer &rays,  
     319                                   ViewCellContainer *viewCells = NULL); 
     320 
     321        /** Returns list of BSP leaves. 
     322        */ 
    317323        void CollectLeaves(vector<BspLeaf *> &leaves); 
    318324 
    … …  
    366372        }; 
    367373 
    368         /** Constructs the tree from the given list of polygons. 
    369                 @param viewCells if not NULL, new view cells are  
    370                 created in the leafs and stored in the conatainer 
    371         */ 
    372         void Construct(PolygonContainer *polys, ViewCellContainer *viewCells = NULL); 
    373  
    374374        /** Evaluates the contribution of the candidate split plane. 
    375375                @note the polygons can be reordered in the process. 
    … …  
    377377        */ 
    378378        float EvalSplitPlane(PolygonContainer &polys,  
    379                                                  const Plane3 &candidatePlane, 
    380                                                  const RayContainer &rays); 
     379                                                 const Plane3 &candidatePlane); 
    381380 
    382381        /** Evaluates tree stats in the BSP tree leafs. 
    … …  
    391390        BspNode *Subdivide(BspTraversalStack &tStack, BspTraversalData &tData); 
    392391 
    393         /** Selects a splitting plane.  
     392        /** Selects the best possible splitting plane.  
    394393                @param leaf the leaf to be split 
    395394                @param polys the polygon list on which the split decition is based 
    396                 @param rays ray container on which selection may be based 
    397                 Returns the split plane 
     395                @Returns the split plane 
    398396        */ 
    399397        Plane3 SelectPlane(BspLeaf *leaf,  
    400                                            PolygonContainer &polys, 
    401                                            const RayContainer &ray); 
     398                                           PolygonContainer &polys); 
    402399 
    403400        /** Filters next view cell down the tree and inserts it into the appropriate leaves 
    … …  
    417414                @param backPolys returns the polygons in the back of the split plane 
    418415                @param coincident returns the polygons coincident to the split plane 
    419                 @param rays ray container used to guide the split process 
    420416                @returns the root of the subdivision 
    421417        */ 
    … …  
    424420                                                           PolygonContainer &frontPolys, 
    425421                                                           PolygonContainer &backPolys,  
    426                                                            PolygonContainer &coincident, 
    427                                                            const RayContainer &rays); 
     422                                                           PolygonContainer &coincident); 
    428423 
    429424        /** Filters polygons down the tree. 
    … …  
    433428                @param backPolys returns the polygons in the back of the split plane 
    434429        */ 
    435         void FilterPolygons(BspInterior *node, PolygonContainer *polys,  
    436                                                 PolygonContainer *frontPolys, PolygonContainer *backPolys); 
     430        void FilterPolygons(BspInterior *node,  
     431                                                PolygonContainer *polys,  
     432                                                PolygonContainer *frontPolys,  
     433                                                PolygonContainer *backPolys); 
    437434 
    438435        /** Selects the split plane in order to construct a tree with 
    … …  
    440437                2.5d aligned) 
    441438                @param polygons container of polygons 
    442                 @param rays bundle of rays on which the split can be based 
    443439                @param maxTests the maximal number of candidate tests 
    444440        */ 
    445441        Plane3 SelectPlaneHeuristics(PolygonContainer &polys,  
    446                                                                  const RayContainer &rays, 
    447                                                                  const int maxTests); 
     442                                                                const int maxTests); 
    448443 
    449444        /** Extracts the meshes of the objects and adds them to polygons.  
    … …  
    519514                                                         vector<SortableEntry> &splitCandidates) const; 
    520515 
    521         /** Splits the rays into front and back rays according to split plane 
    522                 @param rays contains the rays to be split. The rays are  
    523                            distributed to front and back rays. 
    524                 @param frontRays returns rays on the front side of the plane 
    525                 @param backRays returns rays on the back side of the plane 
    526         */ 
    527         void BspTree::SplitRays(const Plane3 plane, 
    528                                                         RayContainer &rays,  
    529                                                         RayContainer &frontRays,  
    530                                                         RayContainer &backRays); 
    531  
    532516        /// Pointer to the root of the tree 
    533517        BspNode *mRoot; 
    … …  
    546530                  BALANCED_VIEW_CELLS = 16, 
    547531                  LARGEST_POLY_AREA = 32, 
    548                   VERTICAL_AXIS = 64 
     532                  VERTICAL_AXIS = 64, 
     533                  BLOCKED_RAYS = 128 
    549534                }; 
    550535 
    … …  
    585570        static float sVerticalSplitsFactor; 
    586571        static float sLargestPolyAreaFactor; 
    587          
     572        static float sBlockedRaysFactor; 
     573 
    588574private: 
    589575        /** Evaluates split plane classification with respect to the plane's  

  • trunk/VUT/GtpVisibilityPreprocessor/src/main.cpp

    r318 r319  
    3838  p->ParseViewCellsOptions(); 
    3939 
    40   if (p->mViewCellsType == Preprocessor::BSP_VIEW_CELLS) 
     40  if (p->mViewCellsType == Preprocessor::BSP_VIEW_CELLS && 
     41          !(BspTree::sConstructionMethod == BspTree::FROM_RAYS)) // construct tree later 
    4142  { 
    4243          if (BspTree::sConstructionMethod == BspTree::FROM_INPUT_VIEW_CELLS) 
Note: See TracChangeset for help on using the changeset viewer.