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/RenderStage.cpp

    r12597 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*/ 
     
    5555    _cameraRequiresSetUp = false; 
    5656    _camera = 0; 
    57      
     57 
    5858    _level = 0; 
    5959    _face = 0; 
    60      
     60 
    6161    _imageReadPixelFormat = GL_RGBA; 
    6262    _imageReadPixelDataType = GL_UNSIGNED_BYTE; 
     
    8585    _cameraRequiresSetUp = false; 
    8686    _camera = 0; 
    87      
     87 
    8888    _level = 0; 
    8989    _face = 0; 
    90      
     90 
    9191    _imageReadPixelFormat = GL_RGBA; 
    9292    _imageReadPixelDataType = GL_UNSIGNED_BYTE; 
     
    129129{ 
    130130    _stageDrawnThisFrame = false; 
    131      
     131 
    132132    if (_renderStageLighting.valid()) _renderStageLighting->reset(); 
    133133 
     
    210210{ 
    211211    if (_preRenderList.empty()) return; 
    212      
     212 
    213213    //cout << "Drawing prerendering stages "<<this<< "  "<<_viewport->x()<<","<< _viewport->y()<<","<< _viewport->width()<<","<< _viewport->height()<<std::endl; 
    214214    for(RenderStageList::iterator itr=_preRenderList.begin(); 
     
    227227 
    228228    if (!_camera) return; 
    229      
     229 
    230230    osg::State& state = *renderInfo.getState(); 
    231231 
     
    250250        depth = osg::maximum(depth,itr->second.depth()); 
    251251    } 
    252      
     252 
    253253    // OSG_NOTICE<<"RenderStage::runCameraSetUp viewport "<<_viewport->x()<<" "<<_viewport->y()<<" "<<_viewport->width()<<" "<<_viewport->height()<<std::endl; 
    254254    // OSG_NOTICE<<"RenderStage::runCameraSetUp computed "<<width<<" "<<height<<" "<<depth<<std::endl; 
     
    280280            _bufferAttachmentMap[itr->first]._image = image; 
    281281        } 
    282          
     282 
    283283        if (itr->second._texture.valid()) 
    284284        { 
     
    336336        } 
    337337    } 
    338      
     338 
    339339    if (renderTargetImplementation==osg::Camera::FRAME_BUFFER_OBJECT) 
    340340    { 
    341341        osg::FBOExtensions* fbo_ext = osg::FBOExtensions::instance(state.getContextID(),true); 
    342342        bool fbo_supported = fbo_ext && fbo_ext->isSupported(); 
    343          
     343 
    344344        if (fbo_supported) 
    345345        { 
     
    350350            osg::ref_ptr<osg::FrameBufferObject> fbo = new osg::FrameBufferObject; 
    351351            osg::ref_ptr<osg::FrameBufferObject> fbo_multisample; 
    352              
     352 
    353353            bool colorAttached = false; 
    354354            bool depthAttached = false; 
     
    398398                osg::Camera::BufferComponent buffer = itr->first; 
    399399                osg::Camera::Attachment& attachment = itr->second; 
    400                  
     400 
    401401                if (attachment._texture.valid() || attachment._image.valid()) 
    402402                    fbo->setAttachment(buffer, osg::FrameBufferAttachment(attachment)); 
     
    436436                        samples, colorSamples))); 
    437437                } 
    438                  
     438 
    439439                if (buffer==osg::Camera::DEPTH_BUFFER) depthAttached = true; 
    440440                else if (buffer==osg::Camera::STENCIL_BUFFER) stencilAttached = true; 
     
    445445                } 
    446446                else if (buffer>=osg::Camera::COLOR_BUFFER) colorAttached = true; 
    447                  
     447 
    448448            } 
    449449 
    450450            if (!depthAttached) 
    451451            { 
    452                 // If doing MSFBO (and therefore need two FBOs, one for multisampled rendering and one for  
    453                 // final resolve), then configure "fbo" as the resolve FBO, and When done  
    454                 // configuring, swap it into "_resolveFbo" (see line 554). But, if not  
     452                // If doing MSFBO (and therefore need two FBOs, one for multisampled rendering and one for 
     453                // final resolve), then configure "fbo" as the resolve FBO, and When done 
     454                // configuring, swap it into "_resolveFbo" (see line 554). But, if not 
    455455                // using MSFBO, then "fbo" is just the render fbo. 
    456                 // If using MSFBO, then resolveBuffersMask  
    457                 // is the value set by the app for the resolve buffers. But if not using  
    458                 // MSFBO, then resolveBuffersMask is the value set by the app for render  
     456                // If using MSFBO, then resolveBuffersMask 
     457                // is the value set by the app for the resolve buffers. But if not using 
     458                // MSFBO, then resolveBuffersMask is the value set by the app for render 
    459459                // buffers. In both cases, resolveBuffersMask is used to configure "fbo". 
    460460                if( resolveBuffersMask & osg::Camera::IMPLICIT_DEPTH_BUFFER_ATTACHMENT ) 
     
    505505            fbo->apply(state); 
    506506 
    507             // If no color attachment make sure to set glDrawBuffer/glReadBuffer to none  
     507            // If no color attachment make sure to set glDrawBuffer/glReadBuffer to none 
    508508            // otherwise glCheckFramebufferStatus will fail 
    509             // It has to be done after call to glBindFramebuffer (fbo->apply)  
     509            // It has to be done after call to glBindFramebuffer (fbo->apply) 
    510510            // and before call to glCheckFramebufferStatus 
    511511            if ( !colorAttached ) 
     
    529529                fbo_ext->glBindFramebuffer(GL_FRAMEBUFFER_EXT, fboId); 
    530530                fbo = 0; 
    531                  
     531 
    532532                // clean up. 
    533533                double availableTime = 100.0f; 
     
    535535                osg::RenderBuffer::flushDeletedRenderBuffers(state.getContextID(),currentTime,availableTime); 
    536536                osg::FrameBufferObject::flushDeletedFrameBufferObjects(state.getContextID(),currentTime,availableTime); 
    537                 
     537 
    538538 
    539539            } 
     
    542542                setDrawBuffer(GL_NONE, false ); 
    543543                setReadBuffer(GL_NONE, false ); 
    544         
     544 
    545545                _fbo = fbo; 
    546546 
     
    579579            } 
    580580        } 
    581          
     581 
    582582        if (!fbo_supported) 
    583583        { 
     
    588588        } 
    589589    } 
    590      
     590 
    591591    // check whether PBuffer-RTT is supported or not 
    592     if (renderTargetImplementation==osg::Camera::PIXEL_BUFFER_RTT &&  
     592    if (renderTargetImplementation==osg::Camera::PIXEL_BUFFER_RTT && 
    593593        !osg::isGLExtensionSupported(state.getContextID(), "WGL_ARB_render_texture")) 
    594     {     
     594    { 
    595595        if (renderTargetImplementation<renderTargetFallback) 
    596596            renderTargetImplementation = renderTargetFallback; 
     
    600600 
    601601    // if any of the renderTargetImplementations require a separate graphics context such as with pbuffer try in turn to 
    602     // set up, but if each level fails then resort to the next level down.     
     602    // set up, but if each level fails then resort to the next level down. 
    603603    while (!getGraphicsContext() && 
    604604           (renderTargetImplementation==osg::Camera::PIXEL_BUFFER_RTT || 
     
    624624            osg::Texture* pBufferTexture = 0; 
    625625            GLenum bufferFormat = GL_NONE; 
    626             unsigned int level = 0;  
    627             unsigned int face = 0;  
     626            unsigned int level = 0; 
     627            unsigned int face = 0; 
    628628 
    629629            bool colorAttached = false; 
     
    710710 
    711711            if (!depthAttached) 
    712             {                 
     712            { 
    713713                traits->depth = 24; 
    714714            } 
    715715 
    716716            if (!colorAttached) 
    717             {                 
     717            { 
    718718                if (bufferFormat == GL_NONE) bufferFormat = GL_RGB; 
    719719 
     
    728728            { 
    729729                traits->sharedContext = state.getGraphicsContext(); 
    730                  
     730 
    731731                const osg::GraphicsContext::Traits* sharedTraits = traits->sharedContext->getTraits(); 
    732732                if (sharedTraits) 
     
    746746 
    747747                // successfully set up graphics context as requested, 
    748                 // will assign this graphics context to the RenderStage and  
     748                // will assign this graphics context to the RenderStage and 
    749749                // associated parameters.  Setting the graphics context will 
    750750                // single this while loop to exit successful. 
    751751                setGraphicsContext(context.get()); 
    752                  
     752 
    753753                // how to do we detect that an attempt to set up RTT has failed?? 
    754754 
     
    770770            { 
    771771                OSG_INFO<<"Failed to acquire Graphics Context"<<std::endl; 
    772                  
     772 
    773773                if (renderTargetImplementation==osg::Camera::PIXEL_BUFFER_RTT) 
    774774                { 
     
    779779                        renderTargetImplementation = osg::Camera::PIXEL_BUFFER; 
    780780                } 
    781                 else  
     781                else 
    782782                { 
    783783                    renderTargetImplementation = osg::Camera::FRAME_BUFFER; 
     
    787787        } 
    788788    } 
    789      
     789 
    790790    // finally if all else has failed, then the frame buffer fallback will come in to play. 
    791791    if (renderTargetImplementation==osg::Camera::FRAME_BUFFER) 
     
    797797            ++itr) 
    798798        { 
    799             // assign the texture...  
     799            // assign the texture... 
    800800            if (itr->second._texture.valid()) setTexture(itr->second._texture.get(), itr->second._level, itr->second._face); 
    801801        } 
     
    857857    { 
    858858        // need to implement 
    859         texture3D->copyTexSubImage3D(state,  
     859        texture3D->copyTexSubImage3D(state, 
    860860                                     static_cast<int>(_viewport->x()), 
    861861                                     static_cast<int>(_viewport->y()), 
     
    869869    { 
    870870        // need to implement 
    871         textureCubeMap->copyTexSubImageCubeMap(state, _face,  
     871        textureCubeMap->copyTexSubImageCubeMap(state, _face, 
    872872                                     static_cast<int>(_viewport->x()), 
    873873                                     static_cast<int>(_viewport->y()), 
     
    908908 
    909909    bool using_multiple_render_targets = fbo_supported && _fbo->hasMultipleRenderingTargets(); 
    910      
     910 
    911911    if (!using_multiple_render_targets) 
    912912    { 
    913913        #if !defined(OSG_GLES1_AVAILABLE) && !defined(OSG_GLES2_AVAILABLE) 
    914          
    915             if( getDrawBufferApplyMask() )  
     914 
     915            if( getDrawBufferApplyMask() ) 
    916916                glDrawBuffer(_drawBuffer); 
    917917 
    918             if( getReadBufferApplyMask() )  
     918            if( getReadBufferApplyMask() ) 
    919919                glReadBuffer(_readBuffer); 
    920          
     920 
    921921        #endif 
    922922    } 
     
    927927    } 
    928928 
    929     // do the drawing itself.     
     929    // do the drawing itself. 
    930930    RenderBin::draw(renderInfo,previous); 
    931931 
     
    953953        GLbitfield blitMask = 0; 
    954954        bool needToBlitColorBuffers = false; 
    955          
     955 
    956956        //find which buffer types should be copied 
    957957        for (FrameBufferObject::AttachmentMap::const_iterator 
     
    10201020        } 
    10211021#endif 
    1022          
     1022 
    10231023        apply_read_fbo = true; 
    10241024        read_fbo = _resolveFbo.get(); 
     
    10441044 
    10451045            #if !defined(OSG_GLES1_AVAILABLE) && !defined(OSG_GLES2_AVAILABLE) 
    1046              
     1046 
    10471047                if (using_multiple_render_targets) 
    10481048                { 
     
    10691069            GLenum dataType = itr->second._image->getDataType(); 
    10701070            if (dataType==0) dataType = _imageReadPixelDataType; 
    1071             if (dataType==0) dataType = GL_UNSIGNED_BYTE;        
     1071            if (dataType==0) dataType = GL_UNSIGNED_BYTE; 
    10721072 
    10731073            itr->second._image->readPixels(static_cast<int>(_viewport->x()), 
    10741074                                           static_cast<int>(_viewport->y()), 
    10751075                                           static_cast<int>(_viewport->width()), 
    1076                                            static_cast<int>(_viewport->height()),  
     1076                                           static_cast<int>(_viewport->height()), 
    10771077                                           pixelFormat, dataType); 
    10781078        } 
     
    10991099            ++itr) 
    11001100        { 
    1101             if (itr->second._texture.valid() && itr->second._mipMapGeneration)  
     1101            if (itr->second._texture.valid() && itr->second._mipMapGeneration) 
    11021102            { 
    11031103                state.setActiveTextureUnit(0); 
     
    11111111struct DrawInnerOperation : public osg::Operation 
    11121112{ 
    1113     DrawInnerOperation(RenderStage* stage, osg::RenderInfo& renderInfo) :  
     1113    DrawInnerOperation(RenderStage* stage, osg::RenderInfo& renderInfo) : 
    11141114        osg::Operation("DrawInnerStage",false), 
    11151115        _stage(stage), 
     
    11301130        } 
    11311131    } 
    1132      
     1132 
    11331133    RenderStage* _stage; 
    11341134    RenderInfo _renderInfo; 
     
    11421142    if(_initialViewMatrix.valid()) renderInfo.getState()->setInitialViewMatrix(_initialViewMatrix.get()); 
    11431143 
    1144     // push the stages camera so that drawing code can query it      
     1144    // push the stages camera so that drawing code can query it 
    11451145    if (_camera) renderInfo.pushCamera(_camera); 
    11461146 
     
    11561156    // so there is no need to call it here. 
    11571157    drawPreRenderStages(renderInfo,previous); 
    1158      
     1158 
    11591159    if (_cameraRequiresSetUp) 
    11601160    { 
     
    11691169    osg::OperationThread* useThread = 0; 
    11701170    osg::RenderInfo useRenderInfo(renderInfo); 
    1171      
     1171 
    11721172    RenderLeaf* saved_previous = previous; 
    11731173 
     
    11771177        // now as an experiment. 
    11781178        callingContext->releaseContext(); 
    1179      
     1179 
    11801180        // OSG_NOTICE<<"  enclosing state before - "<<state.getStateSetStackSize()<<std::endl; 
    11811181 
     
    11841184        useThread = useContext->getGraphicsThread(); 
    11851185        useRenderInfo.setState(useState); 
    1186          
     1186 
    11871187        // synchronize the frame stamps 
    11881188        useState->setFrameStamp(const_cast<osg::FrameStamp*>(state.getFrameStamp())); 
     
    11911191        useState->setDynamicObjectCount(state.getDynamicObjectCount()); 
    11921192        useState->setDynamicObjectRenderingCompletedCallback(state.getDynamicObjectRenderingCompletedCallback()); 
    1193          
    1194         if (!useThread)  
     1193 
     1194        if (!useThread) 
    11951195        { 
    11961196            previous = 0; 
    11971197            useContext->makeCurrent(); 
    1198              
     1198 
    11991199            // OSG_NOTICE<<"  nested state before - "<<useState->getStateSetStackSize()<<std::endl; 
    12001200        } 
     
    12081208        (*(_camera->getPreDrawCallback()))(renderInfo); 
    12091209    } 
    1210      
    1211     bool doCopyTexture = _texture.valid() ?  
     1210 
     1211    bool doCopyTexture = _texture.valid() ? 
    12121212                        (callingContext != useContext) : 
    12131213                        false; 
     
    12171217#if 1 
    12181218        ref_ptr<osg::BlockAndFlushOperation> block = new osg::BlockAndFlushOperation; 
    1219      
     1219 
    12201220        useThread->add(new DrawInnerOperation( this, renderInfo )); 
    1221          
     1221 
    12221222        useThread->add(block.get()); 
    1223          
     1223 
    12241224        // wait till the DrawInnerOperations is complete. 
    12251225        block->block(); 
    1226          
     1226 
    12271227        doCopyTexture = false; 
    1228          
     1228 
    12291229#else 
    12301230        useThread->add(new DrawInnerOperation( this, renderInfo ), true); 
    1231          
     1231 
    12321232        doCopyTexture = false; 
    1233 #endif         
     1233#endif 
    12341234    } 
    12351235    else 
    12361236    { 
    12371237        drawInner( useRenderInfo, previous, doCopyTexture); 
    1238          
     1238 
    12391239        if (useRenderInfo.getUserData() != renderInfo.getUserData()) 
    12401240        { 
    12411241            renderInfo.setUserData(useRenderInfo.getUserData()); 
    12421242        } 
    1243          
     1243 
    12441244    } 
    12451245 
     
    12811281            // to ensure that textures are updated before main thread commenses. 
    12821282            glFlush(); 
    1283              
    1284          
     1283 
     1284 
    12851285            useContext->releaseContext(); 
    12861286        } 
     
    12901290    { 
    12911291        // restore the graphics context. 
    1292          
     1292 
    12931293        previous = saved_previous; 
    1294          
     1294 
    12951295        // OSG_NOTICE<<"  nested state after - "<<useState->getStateSetStackSize()<<std::endl; 
    12961296        // OSG_NOTICE<<"  enclosing state after - "<<state.getStateSetStackSize()<<std::endl; 
     
    13501350            glClearDepthf( _clearDepth); 
    13511351        #endif 
    1352          
     1352 
    13531353        glDepthMask ( GL_TRUE ); 
    13541354        state.haveAppliedAttribute( osg::StateAttribute::DEPTH ); 
     
    13681368        } 
    13691369    #endif 
    1370      
     1370 
    13711371 
    13721372    glClear( _clearMask ); 
    1373      
     1373 
    13741374    #ifdef USE_SCISSOR_TEST 
    13751375        glDisable( GL_SCISSOR_TEST ); 
     
    13791379        glMatrixMode( GL_MODELVIEW ); 
    13801380        glLoadIdentity(); 
    1381     #endif     
     1381    #endif 
    13821382 
    13831383    // apply the positional state. 
     
    14031403{ 
    14041404    if (_postRenderList.empty()) return; 
    1405      
     1405 
    14061406    //cout << "Drawing prerendering stages "<<this<< "  "<<_viewport->x()<<","<< _viewport->y()<<","<< _viewport->width()<<","<< _viewport->height()<<std::endl; 
    14071407    for(RenderStageList::iterator itr=_postRenderList.begin(); 
     
    14381438        } 
    14391439    } 
    1440          
     1440 
    14411441    if (RenderBin::getStats(stats)) 
    14421442    { 
     
    14701470        count += post_itr->second->computeNumberOfDynamicRenderLeaves(); 
    14711471    } 
    1472      
     1472 
    14731473    return count; 
    14741474}