Show
Ignore:
Timestamp:
03/08/09 13:00:36 (5 years ago)
Author:
robert
Message:

Preliminary work on general purpose incremental compile support in osgViewer.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/examples/osgterrain/osgterrain.cpp

    r9618 r9868  
    5858typedef std::vector< osg::ref_ptr<osg::GraphicsThread> > GraphicsThreads; 
    5959 
     60struct ReleaseBlockOnCompileCompleted : public osgUtil::IncrementalCompileOperation::CompileCompletedCallback 
     61{ 
     62 
     63    ReleaseBlockOnCompileCompleted(osg::RefBlockCount* block): 
     64        _block(block) {} 
     65 
     66    virtual bool compileCompleted(osgUtil::IncrementalCompileOperation::CompileSet* compileSet) 
     67    { 
     68        if (_block.valid()) _block->completed(); 
     69         
     70        // tell IncrementalCompileOperation that it's now safe to remove the compileSet 
     71         
     72        osg::notify(osg::NOTICE)<<"compileCompleted("<<compileSet<<")"<<std::endl; 
     73         
     74        return true; 
     75    } 
     76 
     77    osg::ref_ptr<osg::RefBlockCount> _block; 
     78}; 
    6079 
    6180 
     
    6483public: 
    6584 
    66     LoadAndCompileOperation(const std::string& filename, GraphicsThreads& graphicsThreads, osg::RefBlockCount* block): 
     85    LoadAndCompileOperation(const std::string& filename, osgUtil::IncrementalCompileOperation* ico , osg::RefBlockCount* block): 
    6786        Operation("Load and compile Operation", false), 
    6887        _filename(filename), 
    69         _graphicsThreads(graphicsThreads), 
     88        _incrementalCompileOperation(ico), 
    7089        _block(block) {} 
    7190 
     
    7594 
    7695        _loadedModel = osgDB::readNodeFile(_filename); 
    77         if (_loadedModel.valid() && !_graphicsThreads.empty()) 
    78         { 
    79             osg::ref_ptr<osgUtil::GLObjectsOperation> compileOperation = new osgUtil::GLObjectsOperation(_loadedModel.get()); 
    80  
    81             for(GraphicsThreads::iterator gitr = _graphicsThreads.begin(); 
    82                 gitr != _graphicsThreads.end(); 
    83                 ++gitr) 
    84             { 
    85                 (*gitr)->add( compileOperation.get() ); 
    86                 // requiresBarrier = true; 
    87             } 
    88         } 
    89          
    90         if (_block.valid()) _block->completed(); 
     96         
     97        if (_loadedModel.valid() && _incrementalCompileOperation.valid()) 
     98        { 
     99            osg::ref_ptr<osgUtil::IncrementalCompileOperation::CompileSet> compileSet =  
     100                new osgUtil::IncrementalCompileOperation::CompileSet(_loadedModel); 
     101             
     102            compileSet->_compileCompletedCallback = new ReleaseBlockOnCompileCompleted(_block.get()); 
     103         
     104            _incrementalCompileOperation->add(compileSet.get()); 
     105        } 
     106        else  
     107        { 
     108            if (_block.valid()) _block->completed(); 
     109        } 
    91110 
    92111        // osg::notify(osg::NOTICE)<<"done LoadAndCompileOperation "<<_filename<<std::endl; 
    93112    } 
    94113     
    95     std::string                 _filename; 
    96     GraphicsThreads             _graphicsThreads; 
    97     osg::ref_ptr<osg::Node>     _loadedModel; 
    98     osg::ref_ptr<osg::RefBlockCount> _block; 
     114    std::string                                         _filename; 
     115    osg::ref_ptr<osg::Node>                             _loadedModel; 
     116    osg::ref_ptr<osgUtil::IncrementalCompileOperation>  _incrementalCompileOperation; 
     117    osg::ref_ptr<osg::RefBlockCount>                    _block; 
    99118 
    100119}; 
     
    109128 
    110129 
    111     MasterOperation(const std::string& filename): 
     130    MasterOperation(const std::string& filename, osgUtil::IncrementalCompileOperation* ico): 
    112131        Operation("Master reading operation",true), 
    113         _filename(filename) 
     132        _filename(filename), 
     133        _incrementalCompileOperation(ico) 
    114134    { 
    115135    } 
     
    256276                if (gt) threads.push_back(gt); 
    257277            } 
    258  
    259             bool requiresBarrier = false; 
    260  
    261278 
    262279            if (_operationQueue.valid()) 
     
    277294                    // osg::notify(osg::NOTICE)<<"Adding LoadAndCompileOperation "<<*nitr<<std::endl; 
    278295 
    279                     osg::ref_ptr<LoadAndCompileOperation> loadAndCompile = new LoadAndCompileOperation( *nitr, threads, _endOfLoadBlock.get() ); 
     296                    osg::ref_ptr<LoadAndCompileOperation> loadAndCompile = new LoadAndCompileOperation( *nitr, _incrementalCompileOperation.get(), _endOfLoadBlock.get() ); 
    280297                    loadAndCompileList.push_back(loadAndCompile); 
    281298                    _operationQueue->add( loadAndCompile.get() ); 
     
    301318                    { 
    302319                        nodesToAdd[(*litr)->_filename] = (*litr)->_loadedModel; 
    303                         requiresBarrier = true; 
    304320                    } 
    305321                } 
     
    309325            else 
    310326            { 
     327 
     328                _endOfLoadBlock = new osg::RefBlockCount(newFiles.size()); 
     329                 
     330                _endOfLoadBlock->reset(); 
     331 
    311332                for(Files::iterator nitr = newFiles.begin(); 
    312333                    nitr != newFiles.end(); 
     
    319340                        nodesToAdd[*nitr] = loadedModel; 
    320341 
    321                         osg::ref_ptr<osgUtil::GLObjectsOperation> compileOperation = new osgUtil::GLObjectsOperation(loadedModel.get()); 
    322  
    323                         for(GraphicsThreads::iterator gitr = threads.begin(); 
    324                             gitr != threads.end(); 
    325                             ++gitr) 
     342                        if (_incrementalCompileOperation.valid()) 
    326343                        { 
    327                             (*gitr)->add( compileOperation.get() ); 
    328                             requiresBarrier = true; 
     344                            osg::ref_ptr<osgUtil::IncrementalCompileOperation::CompileSet> compileSet =  
     345                                new osgUtil::IncrementalCompileOperation::CompileSet(loadedModel.get()); 
     346 
     347                            compileSet->_compileCompletedCallback = new ReleaseBlockOnCompileCompleted(_endOfLoadBlock.get()); 
     348 
     349                            _incrementalCompileOperation->add(compileSet.get()); 
     350                        } 
     351                        else 
     352                        { 
     353                            _endOfLoadBlock->completed(); 
    329354                        } 
    330355                    } 
    331                 } 
     356                    else 
     357                    { 
     358                        _endOfLoadBlock->completed(); 
     359                    } 
     360                } 
     361 
     362                _endOfLoadBlock->block(); 
     363 
    332364            } 
    333365                         
    334             if (requiresBarrier) 
    335             { 
    336                 _endOfCompilebarrier = new osg::BarrierOperation(threads.size()+1); 
    337                 _endOfCompilebarrier->setKeep(false); 
    338                  
    339                 for(GraphicsThreads::iterator gitr = threads.begin(); 
    340                     gitr != threads.end(); 
    341                     ++gitr) 
    342                 { 
    343                     (*gitr)->add(_endOfCompilebarrier.get()); 
    344                 } 
    345                  
    346                 // osg::notify(osg::NOTICE)<<"Waiting for Compile to complete"<<std::endl; 
    347  
    348                 // wait for the graphics threads to complete. 
    349                 _endOfCompilebarrier->block(); 
    350                  
    351                 // osg::notify(osg::NOTICE)<<"done ... Waiting for Compile to complete"<<std::endl; 
    352             } 
    353366        } 
    354367         
     
    455468    OpenThreads::Block                  _updatesMergedBlock; 
    456469 
     470    osg::ref_ptr<osgUtil::IncrementalCompileOperation>  _incrementalCompileOperation; 
    457471    osg::ref_ptr<osg::BarrierOperation> _endOfCompilebarrier; 
    458472    osg::ref_ptr<osg::RefBlockCount>    _endOfLoadBlock; 
     
    619633    viewer.addEventHandler(new osgViewer::RecordCameraPathHandler); 
    620634 
     635    // attach an IncrementaCompileOperation to allow the master loading  
     636    // to be handled with an incremental compile to avoid frame drops when large objects are added. 
     637    viewer.setIncrementalCompileOperation(new osgUtil::IncrementalCompileOperation()); 
    621638 
    622639    double x = 0.0; 
     
    632649    while(arguments.read("-m",masterFilename)) 
    633650    { 
    634         masterOperation = new MasterOperation(masterFilename); 
     651        masterOperation = new MasterOperation(masterFilename, viewer.getIncrementalCompileOperation()); 
    635652    } 
    636653