Show
Ignore:
Timestamp:
03/21/12 18:36:20 (3 years ago)
Author:
robert
Message:

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osgUtil/CullVisitor.cpp

    r12833 r13041  
    1 /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield  
     1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
    22 * 
    3  * This library is open source and may be redistributed and/or modified under   
    4  * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or  
     3 * This library is open source and may be redistributed and/or modified under 
     4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
    55 * (at your option) any later version.  The full license is in LICENSE file 
    66 * included with this distribution, and on the openscenegraph.org website. 
    7  *  
     7 * 
    88 * This library is distributed in the hope that it will be useful, 
    99 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1111 * OpenSceneGraph Public License for more details. 
    1212*/ 
     
    8585CullVisitor* CullVisitor::create() 
    8686{ 
    87     return CullVisitor::prototype().valid() ?  
     87    return CullVisitor::prototype().valid() ? 
    8888           CullVisitor::prototype()->clone() : 
    89            new CullVisitor;  
     89           new CullVisitor; 
    9090} 
    9191 
     
    9696    // first unref all referenced objects and then empty the containers. 
    9797    // 
    98      
     98 
    9999    CullStack::reset(); 
    100      
     100 
    101101    _renderBinStack.clear(); 
    102102 
     
    109109    _computed_znear = FLT_MAX; 
    110110    _computed_zfar = -FLT_MAX; 
    111      
    112      
     111 
     112 
    113113    osg::Vec3 lookVector(0.0,0.0,-1.0); 
    114      
     114 
    115115    _bbCornerFar = (lookVector.x()>=0?1:0) | 
    116116                   (lookVector.y()>=0?2:0) | 
     
    118118 
    119119    _bbCornerNear = (~_bbCornerFar)&7; 
    120      
     120 
    121121    // Only reset the RenderLeaf objects used last frame. 
    122122    for(RenderLeafList::iterator itr=_reuseRenderLeafList.begin(), 
     
    127127        (*itr)->reset(); 
    128128    } 
    129      
     129 
    130130    // reset the resuse lists. 
    131131    _currentReuseRenderLeafIndex = 0; 
     
    156156    const Matrix& matrix = *_modelviewStack.back(); 
    157157    float dist = distance(pos,matrix); 
    158      
     158 
    159159    if (withLODScale) return dist*getLODScale(); 
    160160    else return dist; 
     
    168168#if 0 
    169169        osg::Timer_t start_t = osg::Timer::instance()->tick(); 
    170 #endif    
     170#endif 
    171171        // update near from defferred list of drawables 
    172172        unsigned int numTests = 0; 
     
    183183#if 0 
    184184                OSG_NOTICE<<"   updating znear to "<<d_near<<std::endl; 
    185 #endif           
    186             } 
    187         }  
     185#endif 
     186            } 
     187        } 
    188188 
    189189#if 0 
     
    222222#if 0 
    223223    OSG_NOTICE<<"  result _computed_znear="<<_computed_znear<<", _computed_zfar="<<_computed_zfar<<std::endl; 
    224 #endif     
     224#endif 
    225225} 
    226226 
     
    238238        // so it doesn't cull them out. 
    239239        osg::Matrix& projection = *_projectionStack.back(); 
    240          
     240 
    241241        value_type tmp_znear = _computed_znear; 
    242242        value_type tmp_zfar = _computed_zfar; 
    243          
     243 
    244244        clampProjectionMatrix(projection, tmp_znear, tmp_zfar); 
    245245    } 
     
    264264        return false; 
    265265    } 
    266      
     266 
    267267    if (zfar<znear+epsilon) 
    268268    { 
     
    304304        value_type znearPullRatio = 0.98; 
    305305 
    306         //znearPullRatio = 0.99;  
     306        //znearPullRatio = 0.99; 
    307307 
    308308        value_type desired_znear = znear * znearPullRatio; 
     
    362362 
    363363    Comparator                      _comparator; 
    364      
     364 
    365365    CullVisitor::value_type         _znear; 
    366366    osg::Matrix                     _matrix; 
     
    368368    Polygon                         _polygonOriginal; 
    369369    Polygon                         _polygonNew; 
    370      
     370 
    371371    Polygon                         _pointCache; 
    372372 
     
    404404            } 
    405405            //OSG_NOTICE<<"Point ok w.r.t plane "<<d1<<std::endl; 
    406         }         
    407      
     406        } 
     407 
    408408        _znear = n1; 
    409409        //OSG_NOTICE<<"Near plane updated "<<_znear<<std::endl; 
     
    455455                active_mask = active_mask | selector_mask; 
    456456            } 
    457              
     457 
    458458            //OSG_NOTICE<<"Line ok w.r.t plane "<<d1<<"\t"<<d2<<std::endl; 
    459459 
    460             selector_mask <<= 1;  
    461         }         
    462      
     460            selector_mask <<= 1; 
     461        } 
     462 
    463463        if (active_mask==0) 
    464464        { 
     
    468468            return; 
    469469        } 
    470          
     470 
    471471        //OSG_NOTICE<<"Using brute force method of line cutting frustum walls"<<std::endl; 
    472472        DistancePoint p1(0, v1); 
    473473        DistancePoint p2(0, v2); 
    474          
     474 
    475475        selector_mask = 0x1; 
    476476 
     
    480480        { 
    481481            if (active_mask & selector_mask) 
    482             {     
     482            { 
    483483                // clip line to plane 
    484484                const osg::Plane& plane = *pitr; 
     
    497497                        float r = p1.first/(p1.first-p2.first); 
    498498                        p2 = DistancePoint(0.0f, p1.second*(1.0f-r) + p2.second*r); 
    499                          
     499 
    500500                    } 
    501501                } 
     
    509509                // The case where both are out was handled above. 
    510510            } 
    511             selector_mask <<= 1;  
     511            selector_mask <<= 1; 
    512512        } 
    513513 
     
    533533            return; 
    534534        } 
    535        
    536          
     535 
     536 
    537537        if (n1 < 0.0 && 
    538538            n2 < 0.0 && 
     
    568568                active_mask = active_mask | selector_mask; 
    569569            } 
    570              
     570 
    571571            //OSG_NOTICE<<"Triangle ok w.r.t plane "<<d1<<"\t"<<d2<<"\t"<<d3<<std::endl; 
    572572 
    573             selector_mask <<= 1;  
    574         }         
    575      
     573            selector_mask <<= 1; 
     574        } 
     575 
    576576        if (active_mask==0) 
    577577        { 
     
    582582            return; 
    583583        } 
    584          
     584 
    585585        //return; 
    586      
     586 
    587587        // numPartiallyInside>0) so we have a triangle cutting an frustum wall, 
    588         // this means that use brute force methods for dividing up triangle.  
    589          
     588        // this means that use brute force methods for dividing up triangle. 
     589 
    590590        //OSG_NOTICE<<"Using brute force method of triangle cutting frustum walls"<<std::endl; 
    591591        _polygonOriginal.clear(); 
     
    593593        _polygonOriginal.push_back(DistancePoint(0,v2)); 
    594594        _polygonOriginal.push_back(DistancePoint(0,v3)); 
    595          
     595 
    596596        selector_mask = 0x1; 
    597          
     597 
    598598        for(pitr = _planes->begin(); 
    599599            pitr != _planes->end() && !_polygonOriginal.empty(); 
     
    601601        { 
    602602            if (active_mask & selector_mask) 
    603             {     
     603            { 
    604604                // polygon bisects plane so need to divide it up. 
    605605                const osg::Plane& plane = *pitr; 
     
    613613                    polyItr->first = plane.distance(polyItr->second); 
    614614                } 
    615                  
    616                 // create the new polygon by clamping against the  
     615 
     616                // create the new polygon by clamping against the 
    617617                unsigned int psize = _polygonOriginal.size(); 
    618618 
     
    624624                    { 
    625625                        _polygonNew.push_back(_polygonOriginal[ci]); 
    626                          
     626 
    627627                        if (_polygonOriginal[ni].first<0.0f) computeIntersection = true; 
    628628                    } 
     
    639639                _polygonOriginal.swap(_polygonNew); 
    640640            } 
    641             selector_mask <<= 1;  
     641            selector_mask <<= 1; 
    642642        } 
    643643 
     
    690690    osg::TemplatePrimitiveFunctor<ComputeNearestPointFunctor> cnpf; 
    691691    cnpf.set(FLT_MAX, matrix, &planes); 
    692      
     692 
    693693    drawable.accept(cnpf); 
    694694 
     
    718718    { 
    719719        std::swap(d_near,d_far); 
    720         if ( !EQUAL_F(d_near, d_far) )  
     720        if ( !EQUAL_F(d_near, d_far) ) 
    721721        { 
    722722            OSG_WARN<<"Warning: CullVisitor::updateCalculatedNearFar(.) near>far in range calculation,"<< std::endl; 
     
    745745    if (isBillboard) 
    746746    { 
    747      
    748 #ifdef TIME_BILLBOARD_NEAR_FAR_CALCULATION     
     747 
     748#ifdef TIME_BILLBOARD_NEAR_FAR_CALCULATION 
    749749        static unsigned int lastFrameNumber = getTraversalNumber(); 
    750750        static unsigned int numBillboards = 0; 
     
    759759        osg::Timer_t start_t = osg::Timer::instance()->tick(); 
    760760#endif 
    761          
     761 
    762762        osg::Vec3 lookVector(-matrix(0,2),-matrix(1,2),-matrix(2,2)); 
    763763 
     
    802802        } 
    803803 
    804 #ifdef TIME_BILLBOARD_NEAR_FAR_CALCULATION     
     804#ifdef TIME_BILLBOARD_NEAR_FAR_CALCULATION 
    805805        osg::Timer_t end_t = osg::Timer::instance()->tick(); 
    806          
     806 
    807807        elapsed_time += osg::Timer::instance()->delta_m(start_t,end_t); 
    808808        ++numBillboards; 
     
    816816        d_far = distance(bb.corner(_bbCornerFar),matrix); 
    817817    } 
    818      
     818 
    819819    if (d_near>d_far) 
    820820    { 
    821821        std::swap(d_near,d_far); 
    822         if ( !EQUAL_F(d_near, d_far) )  
     822        if ( !EQUAL_F(d_near, d_far) ) 
    823823        { 
    824824            OSG_WARN<<"Warning: CullVisitor::updateCalculatedNearFar(.) near>far in range calculation,"<< std::endl; 
     
    865865                    } 
    866866                } 
    867                  
     867 
    868868                // use the far point if its nearer than current znear as this is a conservative estimate of the znear 
    869869                // while the final computation for this drawable is deferred. 
     
    929929    } 
    930930 
    931     if (d<_computed_znear)  
     931    if (d<_computed_znear) 
    932932    { 
    933933       _computed_znear = d; 
     
    935935    } 
    936936    if (d>_computed_zfar) _computed_zfar = d; 
    937 }    
     937} 
    938938 
    939939void CullVisitor::apply(Node& node) 
     
    943943    // push the culling mode. 
    944944    pushCurrentMask(); 
    945      
     945 
    946946    // push the node's state. 
    947947    StateSet* node_state = node.getStateSet(); 
     
    950950    handle_cull_callbacks_and_traverse(node); 
    951951 
    952     // pop the node's state off the geostate stack.     
     952    // pop the node's state off the geostate stack. 
    953953    if (node_state) popStateSet(); 
    954      
     954 
    955955    // pop the culling mode. 
    956956    popCurrentMask(); 
     
    980980            continue; 
    981981        } 
    982          
     982 
    983983        //else 
    984984        { 
     
    987987 
    988988 
    989         if (_computeNearFar && bb.valid())  
     989        if (_computeNearFar && bb.valid()) 
    990990        { 
    991991            if (!updateCalculatedNearFar(matrix,*drawable,false)) continue; 
     
    995995        unsigned int numPopStateSetRequired = 0; 
    996996 
    997         // push the geoset's state on the geostate stack.     
     997        // push the geoset's state on the geostate stack. 
    998998        StateSet* stateset = drawable->getStateSet(); 
    999999        if (stateset) 
     
    10201020 
    10211021        float depth = bb.valid() ? distance(bb.center(),matrix) : 0.0f; 
    1022          
     1022 
    10231023        if (osg::isNaN(depth)) 
    10241024        { 
     
    10331033        } 
    10341034        else 
    1035         {         
     1035        { 
    10361036            addDrawableAndDepth(drawable,&matrix,depth); 
    10371037        } 
     
    10441044    } 
    10451045 
    1046     // pop the node's state off the geostate stack.     
     1046    // pop the node's state off the geostate stack. 
    10471047    if (node_state) popStateSet(); 
    10481048 
     
    10981098        StateSet* stateset = drawable->getStateSet(); 
    10991099        if (stateset) pushStateSet(stateset); 
    1100          
     1100 
    11011101        if (osg::isNaN(depth)) 
    11021102        { 
     
    11111111        } 
    11121112        else 
    1113         {         
     1113        { 
    11141114            addDrawableAndDepth(drawable,billboard_matrix,depth); 
    11151115        } 
     
    11191119    } 
    11201120 
    1121     // pop the node's state off the geostate stack.     
     1121    // pop the node's state off the geostate stack. 
    11221122    if (node_state) popStateSet(); 
    11231123 
     
    11481148    handle_cull_callbacks_and_traverse(node); 
    11491149 
    1150     // pop the node's state off the geostate stack.     
     1150    // pop the node's state off the geostate stack. 
    11511151    if (node_state) popStateSet(); 
    11521152} 
     
    11771177    handle_cull_callbacks_and_traverse(node); 
    11781178 
    1179     // pop the node's state off the geostate stack.     
     1179    // pop the node's state off the geostate stack. 
    11801180    if (node_state) popStateSet(); 
    11811181} 
     
    11971197        addPositionedTextureAttribute(node.getTextureUnit(), 0 ,node.getTexGen()); 
    11981198    } 
    1199      
     1199 
    12001200    handle_cull_callbacks_and_traverse(node); 
    12011201 
    1202     // pop the node's state off the geostate stack.     
     1202    // pop the node's state off the geostate stack. 
    12031203    if (node_state) popStateSet(); 
    12041204} 
     
    12171217    handle_cull_callbacks_and_traverse(node); 
    12181218 
    1219     // pop the node's state off the render graph stack.     
     1219    // pop the node's state off the render graph stack. 
    12201220    if (node_state) popStateSet(); 
    12211221 
     
    12381238    node.computeLocalToWorldMatrix(*matrix,this); 
    12391239    pushModelViewMatrix(matrix.get(), node.getReferenceFrame()); 
    1240      
     1240 
    12411241    handle_cull_callbacks_and_traverse(node); 
    12421242 
    12431243    popModelViewMatrix(); 
    12441244 
    1245     // pop the node's state off the render graph stack.     
     1245    // pop the node's state off the render graph stack. 
    12461246    if (node_state) popStateSet(); 
    12471247 
     
    12641264    float previous_znear = _computed_znear; 
    12651265    float previous_zfar = _computed_zfar; 
    1266      
     1266 
    12671267    // take a copy of the current near plane candidates 
    12681268    DistanceMatrixDrawableMap  previousNearPlaneCandidateMap; 
     
    12781278    ref_ptr<RefMatrix> matrix = createOrReuseMatrix(node.getMatrix()); 
    12791279    pushProjectionMatrix(matrix.get()); 
    1280      
     1280 
    12811281    //OSG_INFO<<"Push projection "<<*matrix<<std::endl; 
    1282      
     1282 
    12831283    // note do culling check after the frustum has been updated to ensure 
    12841284    // that the node is not culled prematurely. 
     
    12991299    previousFarPlaneCandidateMap.swap(_farPlaneCandidateMap); 
    13001300 
    1301     // pop the node's state off the render graph stack.     
     1301    // pop the node's state off the render graph stack. 
    13021302    if (node_state) popStateSet(); 
    13031303 
     
    13251325    handle_cull_callbacks_and_traverse(node); 
    13261326 
    1327     // pop the node's state off the render graph stack.     
     1327    // pop the node's state off the render graph stack. 
    13281328    if (node_state) popStateSet(); 
    13291329 
     
    13531353    handle_cull_callbacks_and_traverse(node); 
    13541354 
    1355     // pop the node's state off the render graph stack.     
     1355    // pop the node's state off the render graph stack. 
    13561356    if (node_state) popStateSet(); 
    13571357 
     
    13641364{ 
    13651365    public: 
    1366      
     1366 
    13671367        RenderStageCache() {} 
    13681368        RenderStageCache(const RenderStageCache&, const osg::CopyOp&) {} 
    1369          
     1369 
    13701370        META_Object(osgUtil, RenderStageCache); 
    1371          
     1371 
    13721372        void setRenderStage(CullVisitor* cv, RenderStage* rs) 
    13731373        { 
    13741374            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex); 
    13751375            _renderStageMap[cv] = rs; 
    1376         }         
     1376        } 
    13771377 
    13781378        RenderStage* getRenderStage(osgUtil::CullVisitor* cv) 
     
    13811381            return _renderStageMap[cv].get(); 
    13821382        } 
    1383          
     1383 
    13841384        typedef std::map<CullVisitor*, osg::ref_ptr<RenderStage> > RenderStageMap; 
    1385          
     1385 
    13861386        /** Resize any per context GLObject buffers to specified size. */ 
    13871387        virtual void resizeGLObjectBuffers(unsigned int maxSize) 
     
    14791479            modelview = createOrReuseMatrix(*getModelViewMatrix()*camera.getViewMatrix()); 
    14801480        } 
    1481         else // pre multiply  
     1481        else // pre multiply 
    14821482        { 
    14831483            projection = createOrReuseMatrix(camera.getProjectionMatrix()*(*getProjectionMatrix())); 
     
    14981498    value_type previous_znear = _computed_znear; 
    14991499    value_type previous_zfar = _computed_zfar; 
    1500      
     1500 
    15011501    // take a copy of the current near plane candidates 
    15021502    DistanceMatrixDrawableMap  previousNearPlaneCandidateMap; 
     
    15101510 
    15111511    pushProjectionMatrix(projection); 
    1512     pushModelViewMatrix(modelview, camera.getReferenceFrame());     
     1512    pushModelViewMatrix(modelview, camera.getReferenceFrame()); 
    15131513 
    15141514 
     
    15341534            camera.setRenderingCache(rsCache.get()); 
    15351535        } 
    1536          
     1536 
    15371537        osg::ref_ptr<osgUtil::RenderStage> rtts = rsCache->getRenderStage(this); 
    15381538        if (!rtts) 
    15391539        { 
    15401540            OpenThreads::ScopedLock<OpenThreads::Mutex> lock(*(camera.getDataChangeMutex())); 
    1541          
     1541 
    15421542            rtts = new osgUtil::RenderStage; 
    15431543            rsCache->setRenderStage(this,rtts.get()); 
     
    15541554                rtts->setDrawBuffer(camera.getDrawBuffer()); 
    15551555            } 
    1556              
     1556 
    15571557            if ( camera.getInheritanceMask() & READ_BUFFER ) 
    15581558            { 
     
    15711571        } 
    15721572 
    1573         // set up clera masks/values         
     1573        // set up clera masks/values 
    15741574        rtts->setClearDepth(camera.getClearDepth()); 
    15751575        rtts->setClearAccum(camera.getClearAccum()); 
     
    15961596        } 
    15971597 
    1598          
     1598 
    15991599        // set the color mask. 
    16001600        osg::ColorMask* colorMask = camera.getColorMask()!=0 ? camera.getColorMask() : previous_stage->getColorMask(); 
     
    16041604        osg::Viewport* viewport = camera.getViewport()!=0 ? camera.getViewport() : previous_stage->getViewport(); 
    16051605        rtts->setViewport( viewport ); 
    1606          
     1606 
    16071607        // set initial view matrix 
    16081608        rtts->setInitialViewMatrix(modelview); 
     
    16291629        // restore the previous renderbin. 
    16301630        setCurrentRenderBin(previousRenderBin); 
    1631       
     1631 
    16321632 
    16331633        if (rtts->getStateGraphList().size()==0 && rtts->getRenderBinList().size()==0) 
     
    16511651 
    16521652    } 
    1653      
     1653 
    16541654    // restore the previous model view matrix. 
    16551655    popModelViewMatrix(); 
     
    16761676    setCullSettings(saved_cull_settings); 
    16771677 
    1678     // pop the node's state off the render graph stack.     
     1678    // pop the node's state off the render graph stack. 
    16791679    if (node_state) popStateSet(); 
    16801680 
     
    16861686    // list, if so disable the appropriate ShadowOccluderVolume 
    16871687    disableAndPushOccludersCurrentMask(_nodePath); 
    1688      
     1688 
    16891689 
    16901690    if (isCulled(node)) 
     
    17051705    handle_cull_callbacks_and_traverse(node); 
    17061706 
    1707     // pop the node's state off the render graph stack.     
     1707    // pop the node's state off the render graph stack. 
    17081708    if (node_state) popStateSet(); 
    17091709 
     
    17281728 
    17291729    osg::Camera* camera = getCurrentCamera(); 
    1730      
     1730 
    17311731    // If previous query indicates visible, then traverse as usual. 
    17321732    if (node.getPassed( camera, *this )) 
     
    17401740 
    17411741 
    1742     // pop the node's state off the render graph stack.     
     1742    // pop the node's state off the render graph stack. 
    17431743    if (node_state) popStateSet(); 
    17441744