Ignore:
Timestamp:
01/05/06 20:41:52 (19 years ago)
Author:
mattausch
Message:

added mesh creation function

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/VUT/GtpVisibilityPreprocessor/src/ViewCellBsp.cpp

    r502 r503  
    88#include "Ray.h" 
    99#include "AxisAlignedBox3.h" 
     10#include "Triangle3.h" 
     11 
    1012#include <stack> 
    1113 
     
    423425        app << "#N_INVALIDLEAVES (number of invalid leaves )\n" << invalidLeaves << endl; 
    424426 
     427        app << "#N_RAYS (number of rays / leaf)\n" << AvgRays() << endl; 
    425428        //app << "#N_PVS: " << pvs << endl; 
    426429 
     
    776779 
    777780        // constrruct root node geometry 
    778         BspNodeGeometry *cell = new BspNodeGeometry(); 
    779         ConstructGeometry(mRoot, *cell); 
     781        BspNodeGeometry *geom = new BspNodeGeometry(); 
     782        ConstructGeometry(mRoot, *geom); 
    780783 
    781784        BspTraversalData tData(mRoot, polys, 0, mRootCell, rays,  
    782                                                    ComputePvsSize(*rays), cell->GetArea(), cell); 
     785                                                   ComputePvsSize(*rays), geom->GetArea(), geom); 
    783786 
    784787        tStack.push(tData); 
     
    18091812        // accumulate depth to compute average depth 
    18101813        mStat.accumDepth += data.mDepth; 
    1811          
     1814        // accumulate rays to compute rays /  leaf 
     1815        mStat.accumRays += (int)data.mRays->size(); 
    18121816 
    18131817        if (data.mDepth >= mTermMaxDepth) 
     
    21962200} 
    21972201 
    2198 void BspTree::ConstructGeometry(BspNode *n, BspNodeGeometry &cell) const 
    2199 { 
    2200         PolygonContainer polys; 
    2201         ConstructGeometry(n, polys); 
    2202         cell.mPolys = polys; 
    2203 } 
    2204  
    2205 void BspTree::ConstructGeometry(BspViewCell *vc, PolygonContainer &cell) const 
     2202void BspTree::ConstructGeometry(BspViewCell *vc, BspNodeGeometry &geom) const 
    22062203{ 
    22072204        vector<BspLeaf *> leaves = vc->mLeaves; 
     
    22102207 
    22112208        for (it = leaves.begin(); it != it_end; ++ it) 
    2212                 ConstructGeometry(*it, cell); 
    2213 } 
    2214  
    2215  
    2216 void BspTree::ConstructGeometry(BspNode *n, PolygonContainer &cell) const 
     2209                ConstructGeometry(*it, geom); 
     2210} 
     2211 
     2212 
     2213void BspTree::ConstructGeometry(BspNode *n, BspNodeGeometry &geom) const 
    22172214{ 
    22182215        vector<Plane3> halfSpaces; 
     
    22912288                 
    22922289                if (candidates[i]) 
    2293                         cell.push_back(candidates[i]); 
     2290                        geom.mPolys.push_back(candidates[i]); 
    22942291        } 
    22952292} 
     
    22992296                                                   const bool onlyUnmailed) const 
    23002297{ 
    2301         PolygonContainer cell; 
    2302  
    2303         ConstructGeometry(n, cell); 
     2298        BspNodeGeometry geom; 
     2299        ConstructGeometry(n, geom); 
    23042300 
    23052301        stack<BspNode *> nodeStack; 
     
    23192315            if (node != n && (!onlyUnmailed || !node->Mailed())) 
    23202316                        { 
    2321                                 // test all planes of current node if candidate really 
    2322                                 // is neighbour 
    2323                                 PolygonContainer neighborCandidate; 
    2324                                 ConstructGeometry(node, neighborCandidate); 
     2317                                // test all planes of current node if neighbour  
     2318                                // candidate really is neighbour 
     2319                                BspNodeGeometry candidateGeom; 
     2320                                ConstructGeometry(node, candidateGeom); 
    23252321                                 
    23262322                                bool isAdjacent = true; 
     
    23282324                                { 
    23292325                                        const int cf =  
    2330                                                 Polygon3::ClassifyPlane(neighborCandidate,  
     2326                                                Polygon3::ClassifyPlane(candidateGeom.mPolys,  
    23312327                                                                                                halfSpaces[i], 
    23322328                                                                                                mEpsilon); 
     
    23382334                                if (isAdjacent) 
    23392335                                        neighbors.push_back(dynamic_cast<BspLeaf *>(node)); 
    2340  
    2341                                 CLEAR_CONTAINER(neighborCandidate); 
    23422336                        } 
    23432337                } 
     
    23462340                        BspInterior *interior = dynamic_cast<BspInterior *>(node); 
    23472341         
    2348                         const int cf = Polygon3::ClassifyPlane(cell,  
     2342                        const int cf = Polygon3::ClassifyPlane(geom.mPolys,  
    23492343                                                                                                   interior->mPlane, 
    23502344                                                                                                   mEpsilon); 
     
    23642358        } 
    23652359         
    2366         CLEAR_CONTAINER(cell); 
    23672360        return (int)neighbors.size(); 
    23682361} 
     2362 
    23692363 
    23702364BspLeaf *BspTree::GetRandomLeaf(const Plane3 &halfspace) 
     
    23872381                { 
    23882382                        BspInterior *interior = dynamic_cast<BspInterior *>(node); 
    2389                          
    23902383                        BspNode *next; 
    23912384         
    2392                         PolygonContainer cell; 
    2393  
     2385                        BspNodeGeometry geom; 
    23942386                        // todo: not very efficient: constructs full cell everytime 
    2395                         ConstructGeometry(interior, cell); 
    2396  
    2397                         const int cf = Polygon3::ClassifyPlane(cell,  
     2387                        ConstructGeometry(interior, geom); 
     2388 
     2389                        const int cf = Polygon3::ClassifyPlane(geom.mPolys,  
    23982390                                                                                                   halfspace,  
    23992391                                                                                                   mEpsilon); 
     
    25342526/*************************************************************/ 
    25352527 
     2528 
    25362529BspNodeGeometry::~BspNodeGeometry() 
    25372530{ 
    25382531        CLEAR_CONTAINER(mPolys); 
    25392532} 
     2533 
    25402534 
    25412535float BspNodeGeometry::GetArea() const  
     
    25432537        return Polygon3::GetArea(mPolys); 
    25442538} 
     2539 
     2540 
     2541void BspNodeGeometry::AddToMesh(Mesh &mesh) 
     2542{ 
     2543        PolygonContainer::const_iterator it, it_end = mPolys.end(); 
     2544        int vcount = 0; 
     2545 
     2546        for (it = mPolys.begin(); it != mPolys.end(); ++ it) 
     2547        { 
     2548                Polygon3 *poly = *it; 
     2549                 
     2550                vector<Triangle3> triangles; 
     2551                poly->Triangulate(triangles); 
     2552                vector<Triangle3>::const_iterator tit, tit_end = triangles.end(); 
     2553         
     2554                for (tit = triangles.begin(); tit != tit_end; ++ tit) 
     2555                { 
     2556                        mesh.mVertices.push_back((*tit).mVertices[0]); 
     2557                        mesh.mVertices.push_back((*tit).mVertices[1]); 
     2558                        mesh.mVertices.push_back((*tit).mVertices[2]); 
     2559 
     2560                        Face *face = new Face(vcount ++, vcount ++, vcount ++); 
     2561                        mesh.AddFace(face); 
     2562                } 
     2563        } 
     2564} 
     2565 
    25452566 
    25462567void BspNodeGeometry::SplitGeometry(BspNodeGeometry &front, 
Note: See TracChangeset for help on using the changeset viewer.