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/osg/GraphicsContext.cpp

    r13038 r13041  
    4141// Use a static reference pointer to hold the window system interface. 
    4242// Wrap this within a function, in order to control the order in which 
    43 // the static pointer's constructor is executed.  
     43// the static pointer's constructor is executed. 
    4444 
    4545static ref_ptr<GraphicsContext::WindowingSystemInterface> &windowingSystemInterfaceRef() 
     
    7373        // catch any undefined values. 
    7474        if (traits) traits->setUndefinedScreenDetailsToDefaultScreen(); 
    75          
     75 
    7676        return wsref->createGraphicsContext(traits); 
    7777    } 
    7878    else 
    79         return 0;     
     79        return 0; 
    8080} 
    8181 
     
    113113    std::string::size_type colon = displayName.find_last_of(':'); 
    114114    std::string::size_type point = displayName.find_last_of('.'); 
    115      
    116     if (point!=std::string::npos &&  
    117         colon==std::string::npos &&  
     115 
     116    if (point!=std::string::npos && 
     117        colon==std::string::npos && 
    118118        point < colon) point = std::string::npos; 
    119119 
     
    126126        hostName = displayName.substr(0,colon); 
    127127    } 
    128      
     128 
    129129    std::string::size_type startOfDisplayNum = (colon==std::string::npos) ? 0 : colon+1; 
    130130    std::string::size_type endOfDisplayNum = (point==std::string::npos) ?  displayName.size() : point; 
     
    148148    } 
    149149 
    150 #if 0     
     150#if 0 
    151151    OSG_NOTICE<<"   hostName ["<<hostName<<"]"<<std::endl; 
    152152    OSG_NOTICE<<"   displayNum "<<displayNum<<std::endl; 
     
    209209            } 
    210210        } 
    211          
     211 
    212212        glContextVersion = ds->getGLContextVersion(); 
    213213        glContextFlags = ds->getGLContextFlags(); 
     
    238238 
    239239    unsigned int _numContexts; 
    240      
     240 
    241241    void incrementUsageCount() {  ++_numContexts; } 
    242242 
     
    250250        { 
    251251            OSG_INFO<<"resetting compileContext "<<_compileContext.get()<<" refCount "<<_compileContext->referenceCount()<<std::endl; 
    252              
     252 
    253253            _compileContext = 0; 
    254254        } 
    255255    } 
    256      
     256 
    257257    osg::ref_ptr<osg::GraphicsContext> _compileContext; 
    258258 
     
    268268{ 
    269269    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_contextIDMapMutex); 
    270      
     270 
    271271    // first check to see if we can reuse contextID; 
    272272    for(ContextIDMap::iterator itr = s_contextIDMap.begin(); 
     
    288288    unsigned int contextID = s_contextIDMap.size(); 
    289289    s_contextIDMap[contextID]._numContexts = 1; 
    290      
     290 
    291291    OSG_INFO<<"GraphicsContext::createNewContextID() creating contextID="<<contextID<<std::endl; 
    292292    OSG_INFO<<"Updating the MaxNumberOfGraphicsContexts to "<<contextID+1<<std::endl; 
    293293 
    294     // update the the maximum number of graphics contexts,  
     294    // update the the maximum number of graphics contexts, 
    295295    // to ensure that texture objects and display buffers are configured to the correct size. 
    296296    osg::DisplaySettings::instance()->setMaxNumberOfGraphicsContexts( contextID + 1 ); 
    297297 
    298     return contextID;     
     298    return contextID; 
    299299} 
    300300 
     
    316316{ 
    317317    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_contextIDMapMutex); 
    318      
     318 
    319319    s_contextIDMap[contextID].incrementUsageCount(); 
    320320 
     
    334334    { 
    335335        OSG_NOTICE<<"Warning: decrementContextIDUsageCount("<<contextID<<") called on expired contextID."<<std::endl; 
    336     }  
     336    } 
    337337 
    338338    OSG_INFO<<"GraphicsContext::decrementContextIDUsageCount("<<contextID<<") to "<<s_contextIDMap[contextID]._numContexts<<std::endl; 
     
    388388 
    389389    OSG_INFO<<"GraphicsContext::getRegisteredGraphicsContexts "<<contextID<<" contexts.size()="<<contexts.size()<<std::endl; 
    390      
     390 
    391391    return contexts; 
    392392} 
     
    396396    OSG_NOTICE<<"GraphicsContext::createCompileContext."<<std::endl; 
    397397 
    398     {     
     398    { 
    399399        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_contextIDMapMutex); 
    400400        if (s_contextIDMap[contextID]._compileContext.valid()) return s_contextIDMap[contextID]._compileContext.get(); 
    401401    } 
    402      
     402 
    403403    GraphicsContext::GraphicsContexts contexts = GraphicsContext::getRegisteredGraphicsContexts(contextID); 
    404404    if (contexts.empty()) return 0; 
    405      
     405 
    406406    GraphicsContext* src_gc = contexts.front(); 
    407407    const osg::GraphicsContext::Traits* src_traits = src_gc->getTraits(); 
     
    423423    osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits); 
    424424    if (gc.valid() && gc->realize()) 
    425     {     
     425    { 
    426426        OpenThreads::ScopedLock<OpenThreads::Mutex> lock(s_contextIDMapMutex); 
    427427        s_contextIDMap[contextID]._compileContext = gc; 
     
    433433        return 0; 
    434434    } 
    435      
     435 
    436436} 
    437437 
     
    510510    } 
    511511    else 
    512     {    
     512    { 
    513513        return false; 
    514514    } 
     
    521521    // switch off the graphics thread... 
    522522    setGraphicsThread(0); 
    523      
    524      
     523 
     524 
    525525    bool sharedContextExists = false; 
    526      
     526 
    527527    if (_state.valid()) 
    528528    { 
     
    531531    } 
    532532 
    533     // release all the OpenGL objects in the scene graphs associated with this  
     533    // release all the OpenGL objects in the scene graphs associated with this 
    534534    for(Cameras::iterator itr = _cameras.begin(); 
    535535        itr != _cameras.end(); 
     
    576576        } 
    577577    } 
    578      
     578 
    579579    if (callCloseImplementation) closeImplementation(); 
    580580 
    581581 
    582     // now discard any deleted deleted OpenGL objects that the are still hanging around - such as due to  
     582    // now discard any deleted deleted OpenGL objects that the are still hanging around - such as due to 
    583583    // the the flushDelete*() methods not being invoked, such as when using GraphicContextEmbedded where makeCurrent 
    584584    // does not work. 
     
    593593    { 
    594594        decrementContextIDUsageCount(_state->getContextID()); 
    595          
     595 
    596596        _state = 0; 
    597597    } 
     
    604604 
    605605    bool result = makeCurrentImplementation(); 
    606      
     606 
    607607    if (result) 
    608608    { 
    609609        // initialize extension process, not only initializes on first 
    610         // call, will be a non-op on subsequent calls.         
     610        // call, will be a non-op on subsequent calls. 
    611611        getState()->initializeExtensionProcs(); 
    612612    } 
    613      
     613 
    614614    return result; 
    615615} 
     
    624624 
    625625        // initialize extension process, not only initializes on first 
    626         // call, will be a non-op on subsequent calls.         
     626        // call, will be a non-op on subsequent calls. 
    627627        getState()->initializeExtensionProcs(); 
    628628    } 
    629      
     629 
    630630    return result; 
    631631} 
     
    634634{ 
    635635    bool result = releaseContextImplementation(); 
    636      
     636 
    637637    _threadOfLastMakeCurrent = (OpenThreads::Thread*)(-1); 
    638      
     638 
    639639    return result; 
    640640} 
     
    647647        clear(); 
    648648    } 
    649     else if (_graphicsThread.valid() &&  
     649    else if (_graphicsThread.valid() && 
    650650             _threadOfLastMakeCurrent == _graphicsThread.get()) 
    651651    { 
     
    670670void GraphicsContext::setGraphicsThread(GraphicsThread* gt) 
    671671{ 
    672     if (_graphicsThread==gt) return;  
    673  
    674     if (_graphicsThread.valid())  
     672    if (_graphicsThread==gt) return; 
     673 
     674    if (_graphicsThread.valid()) 
    675675    { 
    676676        // need to kill the thread in some way... 
     
    680680 
    681681    _graphicsThread = gt; 
    682      
    683     if (_graphicsThread.valid())  
     682 
     683    if (_graphicsThread.valid()) 
    684684    { 
    685685        _graphicsThread->setParent(this); 
     
    723723{ 
    724724    OSG_INFO<<"Doing remove named operation"<<std::endl; 
    725      
     725 
    726726    // acquire the lock on the operations queue to prevent anyone else for modifying it at the same time 
    727727    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_operationsMutex); 
     
    769769    std::copy(_cameras.begin(), _cameras.end(), std::back_inserter(camerasCopy)); 
    770770    std::sort(camerasCopy.begin(), camerasCopy.end(), CameraRenderOrderSortOp()); 
    771      
     771 
    772772    for(CameraVector::iterator itr = camerasCopy.begin(); 
    773773        itr != camerasCopy.end(); 
     
    800800            } 
    801801        } 
    802                  
     802 
    803803        if (_currentOperation.valid()) 
    804804        { 
     
    808808            (*_currentOperation)(this); 
    809809 
    810             {             
     810            { 
    811811                OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_operationsMutex); 
    812812                _currentOperation = 0; 
     
    832832        for(unsigned int i=0; i<camera->getNumChildren(); ++i) 
    833833        { 
    834             nodes.insert(camera->getChild(i));             
    835         } 
    836          
     834            nodes.insert(camera->getChild(i)); 
     835        } 
     836 
    837837        for(Cameras::iterator citr = _cameras.begin(); 
    838838            citr != _cameras.end(); 
     
    847847                    if (nitr != nodes.end()) nodes.erase(nitr); 
    848848                } 
    849             }             
    850         } 
    851          
     849            } 
     850        } 
     851 
    852852        // now release the GLobjects associated with these non shared nodes 
    853853        for(NodeSet::iterator nitr = nodes.begin(); 
     
    874874 
    875875    if (!_traits) return; 
    876      
     876 
    877877    double widthChangeRatio = double(width) / double(_traits->width); 
    878878    double heigtChangeRatio = double(height) / double(_traits->height); 
    879     double aspectRatioChange = widthChangeRatio / heigtChangeRatio;  
    880      
     879    double aspectRatioChange = widthChangeRatio / heigtChangeRatio; 
     880 
    881881 
    882882    for(Cameras::iterator itr = _cameras.begin(); 
     
    885885    { 
    886886        Camera* camera = (*itr); 
    887          
     887 
    888888        // resize doesn't affect Cameras set up with FBO's. 
    889889        if (camera->getRenderTargetImplementation()==osg::Camera::FRAME_BUFFER_OBJECT) continue; 
    890          
     890 
    891891        Viewport* viewport = camera->getViewport(); 
    892892        if (viewport)