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

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

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

    r12056 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*/ 
     
    9494 
    9595// 32 x 32 bit array every row is a horizontal line of pixels 
    96 //  and the (bitwise) columns a vertical line  
     96//  and the (bitwise) columns a vertical line 
    9797//  The following is a checkerboard pattern 
    9898static const GLubyte patternCheckerboard[] = { 
     
    138138 
    139139    _lightingMode=NO_SCENEVIEW_LIGHT; 
    140      
     140 
    141141    _prioritizeTextures = false; 
    142      
     142 
    143143    setCamera(new Camera); 
    144144    _camera->setViewport(new Viewport); 
    145145    _camera->setClearColor(osg::Vec4(0.2f, 0.2f, 0.4f, 1.0f)); 
    146      
     146 
    147147    _initCalled = false; 
    148148 
     
    151151    _automaticFlush = true; 
    152152    _requiresFlush = false; 
    153      
     153 
    154154    _activeUniforms = DEFAULT_UNIFORMS; 
    155      
     155 
    156156    _previousFrameTime = 0; 
    157157    _previousSimulationTime = 0; 
    158      
     158 
    159159    _redrawInterlacedStereoStencilMask = true; 
    160160    _interlacedStereoStencilWidth = 0; 
     
    174174 
    175175    _lightingMode = rhs._lightingMode; 
    176      
     176 
    177177    _prioritizeTextures = rhs._prioritizeTextures; 
    178      
     178 
    179179    _camera = rhs._camera; 
    180180    _cameraWithOwnership = rhs._cameraWithOwnership; 
    181      
     181 
    182182    _initCalled = false; 
    183183 
    184184    _automaticFlush = rhs._automaticFlush; 
    185185    _requiresFlush = false; 
    186      
     186 
    187187    _activeUniforms = rhs._activeUniforms; 
    188      
     188 
    189189    _previousFrameTime = 0; 
    190190    _previousSimulationTime = 0; 
    191      
     191 
    192192    _redrawInterlacedStereoStencilMask = rhs._redrawInterlacedStereoStencilMask; 
    193193    _interlacedStereoStencilWidth = rhs._interlacedStereoStencilWidth; 
     
    228228            _globalStateSet->setMode(GL_LIGHTING, osg::StateAttribute::ON); 
    229229        #endif 
    230          
     230 
    231231        #if !defined(OSG_GLES1_AVAILABLE) && !defined(OSG_GLES2_AVAILABLE) && defined(OSG_GL_FIXED_FUNCTION_AVAILABLE) 
    232232            osg::LightModel* lightmodel = new osg::LightModel; 
     
    239239        _lightingMode = NO_SCENEVIEW_LIGHT; 
    240240    } 
    241   
     241 
    242242    _renderInfo.setState(new State); 
    243      
     243 
    244244    _stateGraph = new StateGraph; 
    245245    _renderStage = new RenderStage; 
     
    249249    { 
    250250        GLObjectsVisitor::Mode  dlvMode = GLObjectsVisitor::COMPILE_DISPLAY_LISTS | 
    251                                           GLObjectsVisitor::COMPILE_STATE_ATTRIBUTES |  
     251                                          GLObjectsVisitor::COMPILE_STATE_ATTRIBUTES | 
    252252                                          GLObjectsVisitor::CHECK_BLACK_LISTED_MODES; 
    253253 
     
    256256    #endif 
    257257 
    258         // sgi's IR graphics has a problem with lighting and display lists, as it seems to store  
     258        // sgi's IR graphics has a problem with lighting and display lists, as it seems to store 
    259259        // lighting state with the display list, and the display list visitor doesn't currently apply 
    260260        // state before creating display lists. So will disable the init visitor default, this won't 
     
    265265 
    266266    } 
    267      
     267 
    268268    _updateVisitor = new UpdateVisitor; 
    269269 
     
    281281         _globalStateSet->setTextureAttributeAndModes(0,texenv, osg::StateAttribute::ON); 
    282282    #endif 
    283           
     283 
    284284    _camera->setClearColor(osg::Vec4(0.2f, 0.2f, 0.4f, 1.0f)); 
    285285} 
     
    295295        OSG_NOTICE<<"Warning: attempt to assign a NULL camera to SceneView not permitted."<<std::endl; 
    296296    } 
    297      
     297 
    298298    if (assumeOwnershipOfCamera) 
    299299    { 
     
    309309{ 
    310310    // take a temporary reference to node to prevent the possibility 
    311     // of it getting deleted when when we do the camera clear of children.  
     311    // of it getting deleted when when we do the camera clear of children. 
    312312    osg::ref_ptr<osg::Node> temporaryRefernce = node; 
    313      
     313 
    314314    // remove pre existing children 
    315315    _camera->removeChildren(0, _camera->getNumChildren()); 
    316      
     316 
    317317    // add the new one in. 
    318318    _camera->addChild(node); 
     
    331331        _initVisitor->reset(); 
    332332        _initVisitor->setFrameStamp(_frameStamp.get()); 
    333          
     333 
    334334        GLObjectsVisitor* dlv = dynamic_cast<GLObjectsVisitor*>(_initVisitor.get()); 
    335335        if (dlv) dlv->setState(_renderInfo.getState()); 
    336          
     336 
    337337        if (_frameStamp.valid()) 
    338338        { 
    339339             _initVisitor->setTraversalNumber(_frameStamp->getFrameNumber()); 
    340340        } 
    341          
     341 
    342342        _camera->accept(*_initVisitor.get()); 
    343          
    344     }  
     343 
     344    } 
    345345} 
    346346 
     
    348348{ 
    349349    if (_camera.valid() && _updateVisitor.valid()) 
    350     {  
     350    { 
    351351        _updateVisitor->reset(); 
    352352 
     
    358358             _updateVisitor->setTraversalNumber(_frameStamp->getFrameNumber()); 
    359359        } 
    360          
     360 
    361361        _camera->accept(*_updateVisitor.get()); 
    362          
     362 
    363363        // now force a recompute of the bounding volume while we are still in 
    364364        // the read/write app phase, this should prevent the need to recompute 
     
    377377 
    378378    if (!_localStateSet) return; 
    379      
     379 
    380380    if ((_activeUniforms & FRAME_NUMBER_UNIFORM) && _frameStamp.valid()) 
    381381    { 
    382382        osg::Uniform* uniform = _localStateSet->getOrCreateUniform("osg_FrameNumber",osg::Uniform::UNSIGNED_INT); 
    383         uniform->set(_frameStamp->getFrameNumber());         
    384     } 
    385      
     383        uniform->set(_frameStamp->getFrameNumber()); 
     384    } 
     385 
    386386    if ((_activeUniforms & FRAME_TIME_UNIFORM) && _frameStamp.valid()) 
    387387    { 
     
    389389        uniform->set(static_cast<float>(_frameStamp->getReferenceTime())); 
    390390    } 
    391      
     391 
    392392    if ((_activeUniforms & DELTA_FRAME_TIME_UNIFORM) && _frameStamp.valid()) 
    393393    { 
    394394        float delta_frame_time = (_previousFrameTime != 0.0) ? static_cast<float>(_frameStamp->getReferenceTime()-_previousFrameTime) : 0.0f; 
    395395        _previousFrameTime = _frameStamp->getReferenceTime(); 
    396          
     396 
    397397        osg::Uniform* uniform = _localStateSet->getOrCreateUniform("osg_DeltaFrameTime",osg::Uniform::FLOAT); 
    398398        uniform->set(delta_frame_time); 
    399399    } 
    400      
     400 
    401401    if ((_activeUniforms & SIMULATION_TIME_UNIFORM) && _frameStamp.valid()) 
    402402    { 
     
    404404        uniform->set(static_cast<float>(_frameStamp->getSimulationTime())); 
    405405    } 
    406      
     406 
    407407    if ((_activeUniforms & DELTA_SIMULATION_TIME_UNIFORM) && _frameStamp.valid()) 
    408408    { 
    409409        float delta_simulation_time = (_previousSimulationTime != 0.0) ? static_cast<float>(_frameStamp->getSimulationTime()-_previousSimulationTime) : 0.0f; 
    410410        _previousSimulationTime = _frameStamp->getSimulationTime(); 
    411          
     411 
    412412        osg::Uniform* uniform = _localStateSet->getOrCreateUniform("osg_DeltaSimulationTime",osg::Uniform::FLOAT); 
    413413        uniform->set(delta_simulation_time); 
    414414    } 
    415      
     415 
    416416    if (_activeUniforms & VIEW_MATRIX_UNIFORM) 
    417417    { 
     
    662662{ 
    663663    if (mode==_lightingMode) return; 
    664      
     664 
    665665    if (_lightingMode!=NO_SCENEVIEW_LIGHT) 
    666666    { 
     
    682682            // add GL_LIGHTING mode 
    683683            _globalStateSet->setMode(GL_LIGHTING, osg::StateAttribute::ON); 
    684             if (_light.valid())  
     684            if (_light.valid()) 
    685685            { 
    686686                _globalStateSet->setAssociatedModes(_light.get(), osg::StateAttribute::ON); 
     
    692692void SceneView::inheritCullSettings(const osg::CullSettings& settings, unsigned int inheritanceMask) 
    693693{ 
    694     if (_camera.valid() && _camera->getView())  
     694    if (_camera.valid() && _camera->getView()) 
    695695    { 
    696696        if (inheritanceMask & osg::CullSettings::LIGHTING_MODE) 
    697697        { 
    698698            LightingMode newLightingMode = _lightingMode; 
    699          
     699 
    700700            switch(_camera->getView()->getLightingMode()) 
    701701            { 
     
    704704                case(osg::View::SKY_LIGHT): newLightingMode = SKY_LIGHT; break; 
    705705            } 
    706              
     706 
    707707            if (newLightingMode != _lightingMode) 
    708708            { 
     
    710710            } 
    711711        } 
    712                  
     712 
    713713        if (inheritanceMask & osg::CullSettings::LIGHT) 
    714714        { 
     
    716716        } 
    717717    } 
    718      
     718 
    719719    osg::CullSettings::inheritCullSettings(settings, inheritanceMask); 
    720720} 
     
    740740        _renderInfo.setState(new osg::State); 
    741741    } 
    742      
     742 
    743743    osg::State* state = _renderInfo.getState(); 
    744744 
     
    747747        _localStateSet = new osg::StateSet; 
    748748    } 
    749      
     749 
    750750    // we in theory should be able to be able to bypass reset, but we'll call it just incase. 
    751751    //_state->reset(); 
    752     
     752 
    753753    state->setFrameStamp(_frameStamp.get()); 
    754754    state->setDisplaySettings(_displaySettings.get()); 
     
    771771    } 
    772772 
    773     if (_displaySettings.valid() && _displaySettings->getStereo())  
     773    if (_displaySettings.valid() && _displaySettings->getStereo()) 
    774774    { 
    775775 
     
    814814            if (!_stateGraphRight.valid()) _stateGraphRight = dynamic_cast<StateGraph*>(_stateGraph->cloneType()); 
    815815            if (!_renderStageRight.valid()) _renderStageRight = dynamic_cast<RenderStage*>(_renderStage->clone(osg::CopyOp::DEEP_COPY_ALL)); 
    816              
     816 
    817817            _cullVisitorLeft->setDatabaseRequestHandler(_cullVisitor->getDatabaseRequestHandler()); 
    818818            _cullVisitorLeft->setClampProjectionMatrixCallback(_cullVisitor->getClampProjectionMatrixCallback()); 
     
    828828            computeRightEyeViewport(getViewport()); 
    829829            computeNearFar = cullStage(computeRightEyeProjection(getProjectionMatrix()),computeRightEyeView(getViewMatrix()),_cullVisitorRight.get(),_stateGraphRight.get(),_renderStageRight.get(),_viewportRight.get()); 
    830             
     830 
    831831            if (computeNearFar) 
    832832            { 
     
    852852        } 
    853853    } 
    854      
     854 
    855855 
    856856 
     
    869869    { 
    870870        //std::cout << "Scene graph contains occluder nodes, searching for them"<<std::endl; 
    871          
    872          
     871 
     872 
    873873        if (!_collectOccludersVisitor) _collectOccludersVisitor = new osg::CollectOccludersVisitor; 
    874          
     874 
    875875        _collectOccludersVisitor->inheritCullSettings(*this); 
    876          
     876 
    877877        _collectOccludersVisitor->reset(); 
    878          
     878 
    879879        _collectOccludersVisitor->setFrameStamp(_frameStamp.get()); 
    880880 
     
    895895        _collectOccludersVisitor->popProjectionMatrix(); 
    896896        _collectOccludersVisitor->popViewport(); 
    897          
     897 
    898898        // sort the occluder from largest occluder volume to smallest. 
    899899        _collectOccludersVisitor->removeOccludedOccluders(); 
    900          
    901          
     900 
     901 
    902902        OSG_DEBUG << "finished searching for occluder - found "<<_collectOccludersVisitor->getCollectedOccluderSet().size()<<std::endl; 
    903             
     903 
    904904        cullVisitor->getOccluderList().clear(); 
    905905        std::copy(_collectOccludersVisitor->getCollectedOccluderSet().begin(),_collectOccludersVisitor->getCollectedOccluderSet().end(), std::back_insert_iterator<CullStack::OccluderList>(cullVisitor->getOccluderList())); 
    906906    } 
    907      
     907 
    908908 
    909909 
     
    942942    renderStage->setClearStencil(_camera->getClearStencil()); 
    943943    renderStage->setClearMask(_camera->getClearMask()); 
    944      
    945 #if 1     
     944 
     945#if 1 
    946946    renderStage->setCamera(_camera.get()); 
    947947#endif 
     
    960960        default: 
    961961            break; 
    962         }             
     962        } 
    963963    #endif 
    964      
     964 
    965965    if (_globalStateSet.valid()) cullVisitor->pushStateSet(_globalStateSet.get()); 
    966966    if (_secondaryStateSet.valid()) cullVisitor->pushStateSet(_secondaryStateSet.get()); 
     
    972972    cullVisitor->pushModelViewMatrix(mv.get(),osg::Transform::ABSOLUTE_RF); 
    973973 
    974     // traverse the scene graph to generate the rendergraph.     
    975     // If the camera has a cullCallback execute the callback which has the   
     974    // traverse the scene graph to generate the rendergraph. 
     975    // If the camera has a cullCallback execute the callback which has the 
    976976    // requirement that it must traverse the camera's children. 
    977977    { 
     
    989989    if (_secondaryStateSet.valid()) cullVisitor->popStateSet(); 
    990990    if (_globalStateSet.valid()) cullVisitor->popStateSet(); 
    991      
     991 
    992992 
    993993    renderStage->sort(); 
     
    999999    // allocation and deleteing of the StateGraph nodes. 
    10001000    rendergraph->prune(); 
    1001      
    1002     // set the number of dynamic objects in the scene.     
     1001 
     1002    // set the number of dynamic objects in the scene. 
    10031003    _dynamicObjectCount += renderStage->computeNumberOfDynamicRenderLeaves(); 
    10041004 
     
    10111011{ 
    10121012    if (!_camera) return; 
    1013     
     1013 
    10141014    _camera->releaseGLObjects(_renderInfo.getState()); 
    1015      
     1015 
    10161016    // we need to reset State as it keeps handles to Program objects. 
    10171017    if (_renderInfo.getState()) _renderInfo.getState()->reset(); 
     
    10221022{ 
    10231023    _requiresFlush = false; 
    1024      
     1024 
    10251025    osg::flushAllDeletedGLObjects(getState()->getContextID()); 
    10261026 } 
     
    10291029{ 
    10301030    // OSG_NOTICE<<"SceneView::flushDeletedGLObjects(availableTime="<<availableTime<<")"<<std::endl; 
    1031      
     1031 
    10321032    osg::State* state = _renderInfo.getState(); 
    10331033 
     
    10581058    // context for when the object were originally created.  Here we know what 
    10591059    // context we are in so can flush the appropriate caches. 
    1060      
     1060 
    10611061    if (_requiresFlush) 
    10621062    { 
     
    10691069 
    10701070    RenderLeaf* previous = NULL; 
    1071     if (_displaySettings.valid() && _displaySettings->getStereo())  
    1072     { 
    1073      
     1071    if (_displaySettings.valid() && _displaySettings->getStereo()) 
     1072    { 
     1073 
    10741074        switch(_displaySettings->getStereoMode()) 
    10751075        { 
     
    11311131                _renderStageLeft->setColorMask(cmask); 
    11321132                _renderStageRight->setColorMask(cmask); 
    1133                  
     1133 
    11341134                _localStateSet->setAttribute(getViewport()); 
    11351135 
    1136                  
     1136 
    11371137                _renderStageLeft->drawPreRenderStages(_renderInfo,previous); 
    11381138                _renderStageRight->drawPreRenderStages(_renderInfo,previous); 
     
    11461146                    _renderStageLeft->setColorMask(leftColorMask); 
    11471147                } 
    1148                  
     1148 
    11491149                // red 
    11501150                leftColorMask->setMask(true,false,false,true); 
     
    11571157                // draw left eye. 
    11581158                _renderStageLeft->draw(_renderInfo,previous); 
    1159                  
    1160                  
     1159 
     1160 
    11611161 
    11621162                // ensure that right eye color planes are active. 
     
    11701170                // cyan 
    11711171                rightColorMask->setMask(false,true,true,true); 
    1172                  
     1172 
    11731173                // blue 
    11741174                // rightColorMask->setMask(false,false,true,true); 
     
    12211221                          static_cast<int>(getViewport()->height()),_renderStageLeft->getClearColor()); 
    12221222 
    1223               
     1223 
    12241224                _localStateSet->setAttribute(_viewportLeft.get()); 
    12251225                _renderStageLeft->draw(_renderInfo,previous); 
     
    13491349                    glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0); 
    13501350                    glMatrixMode(GL_MODELVIEW); 
    1351                     glLoadIdentity();     
    1352                      
     1351                    glLoadIdentity(); 
     1352 
    13531353                    getViewport()->apply(*state); 
    13541354                    getState()->applyMode(GL_LIGHTING,false); 
     
    13751375                    getState()->applyMode(GL_POLYGON_STIPPLE,true); 
    13761376                    glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); 
    1377                     glRecti(0, 0, 1, 1);    
     1377                    glRecti(0, 0, 1, 1); 
    13781378                    glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); 
    13791379                    getState()->applyMode(GL_POLYGON_STIPPLE,false); 
    13801380                    getState()->applyMode(GL_LIGHTING,true); 
    13811381                    getState()->applyMode(GL_DEPTH_TEST,true); 
    1382                      
     1382 
    13831383                    _redrawInterlacedStereoStencilMask = false; 
    13841384                    _interlacedStereoStencilWidth = static_cast<int>(getViewport()->width()); 
     
    13901390 
    13911391                glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP); 
    1392                 glStencilFunc(GL_EQUAL, 0, ~0u);     
     1392                glStencilFunc(GL_EQUAL, 0, ~0u); 
    13931393                _renderStageLeft->draw(_renderInfo,previous); 
    1394                  
     1394 
    13951395                glStencilFunc(GL_NOTEQUAL, 0, ~0u); 
    13961396                _renderStageRight->draw(_renderInfo,previous); 
     
    14431443        _renderStage->draw(_renderInfo,previous); 
    14441444    } 
    1445      
     1445 
    14461446    // re apply the defalt OGL state. 
    14471447    state->popAllStateSets(); 
     
    14831483    osg::Matrix inverseMVPW; 
    14841484    inverseMVPW.invert(computeMVPW()); 
    1485      
     1485 
    14861486    object = window*inverseMVPW; 
    1487      
     1487 
    14881488    return true; 
    14891489} 
     
    14991499    osg::Matrix inverseMVPW; 
    15001500    inverseMVPW.invert(computeMVPW()); 
    1501      
     1501 
    15021502    near_point = osg::Vec3(x,y,0.0f)*inverseMVPW; 
    15031503    far_point = osg::Vec3(x,y,1.0f)*inverseMVPW; 
    1504          
     1504 
    15051505    return true; 
    15061506} 
     
    15201520{ 
    15211521    osg::Matrix matrix( getViewMatrix() * getProjectionMatrix()); 
    1522          
     1522 
    15231523    if (getViewport()) 
    15241524        matrix.postMult(getViewport()->computeWindowMatrix()); 
     
    15351535 
    15361536    _renderInfo.getState()->applyAttribute(viewport.get()); 
    1537      
     1537 
    15381538    glScissor( x, y, width, height ); 
    15391539    glEnable( GL_SCISSOR_TEST ); 
     
    15511551                                           bottom, top, 
    15521552                                           zNear, zFar)); 
    1553 }                                            
     1553} 
    15541554 
    15551555void SceneView::setProjectionMatrixAsOrtho2D(double left, double right, 
     
    15741574    setProjectionMatrix(osg::Matrixd::perspective(fovy,aspectRatio, 
    15751575                                                 zNear, zFar)); 
    1576 }                                       
     1576} 
    15771577 
    15781578bool SceneView::getProjectionMatrixAsOrtho(double& left, double& right, 
     
    15921592                                         bottom, top, 
    15931593                                         zNear, zFar); 
    1594 }                                   
     1594} 
    15951595 
    15961596bool SceneView::getProjectionMatrixAsPerspective(double& fovy,double& aspectRatio, 
     
    15981598{ 
    15991599    return getProjectionMatrix().getPerspective(fovy, aspectRatio, zNear, zFar); 
    1600 }                                                  
     1600} 
    16011601 
    16021602void SceneView::setViewMatrixAsLookAt(const Vec3& eye,const Vec3& center,const Vec3& up) 
     
    16121612bool SceneView::getStats(Statistics& stats) 
    16131613{ 
    1614     if (_displaySettings.valid() && _displaySettings->getStereo())  
     1614    if (_displaySettings.valid() && _displaySettings->getStereo()) 
    16151615    { 
    16161616        switch(_displaySettings->getStereoMode())