Show
Ignore:
Timestamp:
09/11/08 15:21:58 (6 years ago)
Author:
robert
Message:

Introduced osgTerrain::WhiteListTileLoadedCallback? for the management of options terrain layers

Files:
1 modified

Legend:

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

    r8843 r8844  
    234234}; 
    235235 
    236  
    237 struct WhiteListTileLoadedCallback : public osgTerrain::TerrainTile::TileLoadedCallback 
    238 { 
    239     WhiteListTileLoadedCallback() 
    240     { 
    241     } 
    242      
    243     void allow(const std::string& setname) { _setWhiteList.insert(setname); } 
    244      
    245     typedef std::set<std::string> SetWhiteList; 
    246     SetWhiteList _setWhiteList; 
    247  
    248     bool layerAcceptable(const std::string& setname) const 
    249     { 
    250         if (setname.empty()) return true; 
    251          
    252         return _setWhiteList.count(setname)!=0; 
    253     } 
    254  
    255     bool readImageLayer(osgTerrain::ImageLayer* imageLayer, const osgDB::ReaderWriter::Options* options) const 
    256     { 
    257        if (!imageLayer->getImage() &&  
    258             !imageLayer->getFileName().empty()) 
    259         { 
    260             if (layerAcceptable(imageLayer->getSetName())) 
    261             { 
    262                 osg::ref_ptr<osg::Image> image = osgDB::readImageFile(imageLayer->getFileName(), options); 
    263                 std::cout<<"ok readingImageLayer("<<imageLayer->getSetName()<<","<<imageLayer->getFileName()<<" success="<<image->valid()<<std::endl; 
    264                 imageLayer->setImage(image.get()); 
    265             } 
    266             else 
    267             { 
    268                 std::cout<<"disallowed readingImageLayer("<<imageLayer->getSetName()<<","<<imageLayer->getFileName()<<std::endl; 
    269             } 
    270         } 
    271         return imageLayer->getImage()!=0; 
    272     } 
    273  
    274     virtual bool deferExternalLayerLoading() const 
    275     { 
    276         return true; 
    277     } 
    278  
    279     virtual void loaded(osgTerrain::TerrainTile* tile, const osgDB::ReaderWriter::Options* options) const 
    280     { 
    281  
    282         // read any external layers 
    283         for(unsigned int i=0; i<tile->getNumColorLayers(); ++i) 
    284         { 
    285             osgTerrain::Layer* layer = tile->getColorLayer(i); 
    286             osgTerrain::ImageLayer* imageLayer = dynamic_cast<osgTerrain::ImageLayer*>(layer); 
    287             if (imageLayer) 
    288             { 
    289                 readImageLayer(imageLayer, options); 
    290                 continue; 
    291             } 
    292  
    293             osgTerrain::SwitchLayer* switchLayer = dynamic_cast<osgTerrain::SwitchLayer*>(layer); 
    294             if (switchLayer) 
    295             { 
    296                 for(unsigned int si=0; si<switchLayer->getNumLayers(); ++si) 
    297                 { 
    298                     osgTerrain::ImageLayer* imageLayer = dynamic_cast<osgTerrain::ImageLayer*>(switchLayer->getLayer(si)); 
    299                     if (imageLayer) 
    300                     { 
    301                         if (readImageLayer(imageLayer, options)) 
    302                         {                         
    303                             // replace SwitchLayer by  
    304                             tile->setColorLayer(i, imageLayer); 
    305                             continue; 
    306                         } 
    307                     } 
    308                 } 
    309                 continue; 
    310             } 
    311  
    312             osgTerrain::CompositeLayer* compositeLayer = dynamic_cast<osgTerrain::CompositeLayer*>(layer); 
    313             if (compositeLayer) 
    314             { 
    315                 for(unsigned int ci=0; ci<compositeLayer->getNumLayers(); ++ci) 
    316                 { 
    317                     osgTerrain::ImageLayer* imageLayer = dynamic_cast<osgTerrain::ImageLayer*>(compositeLayer->getLayer(ci)); 
    318                     if (imageLayer) 
    319                     { 
    320                         readImageLayer(imageLayer, options); 
    321                     } 
    322                 } 
    323                 continue; 
    324             } 
    325         } 
    326  
    327         // assign colour layers over missing layers 
    328         osgTerrain::Layer* validLayer = 0; 
    329         for(unsigned int i=0; i<tile->getNumColorLayers(); ++i) 
    330         { 
    331             osgTerrain::Layer* layer = tile->getColorLayer(i); 
    332             osgTerrain::ImageLayer* imageLayer = dynamic_cast<osgTerrain::ImageLayer*>(layer); 
    333             if (imageLayer) 
    334             { 
    335                 if (imageLayer->getImage()!=0) 
    336                 { 
    337                     validLayer = imageLayer; 
    338                 } 
    339                 continue; 
    340             } 
    341  
    342             osgTerrain::SwitchLayer* switchLayer = dynamic_cast<osgTerrain::SwitchLayer*>(layer); 
    343             if (switchLayer) 
    344             { 
    345                 for(unsigned int si=0; si<switchLayer->getNumLayers(); ++si) 
    346                 { 
    347                     osgTerrain::ImageLayer* imageLayer = dynamic_cast<osgTerrain::ImageLayer*>(switchLayer->getLayer(si)); 
    348                     if (imageLayer && imageLayer->getImage()!=0) 
    349                     { 
    350                         validLayer = imageLayer; 
    351                     } 
    352                 } 
    353                 continue; 
    354             } 
    355  
    356             osgTerrain::CompositeLayer* compositeLayer = dynamic_cast<osgTerrain::CompositeLayer*>(layer); 
    357             if (compositeLayer) 
    358             { 
    359                 for(unsigned int ci=0; ci<compositeLayer->getNumLayers(); ++ci) 
    360                 { 
    361                     osgTerrain::ImageLayer* imageLayer = dynamic_cast<osgTerrain::ImageLayer*>(switchLayer->getLayer(ci)); 
    362                     if (imageLayer && imageLayer->getImage()!=0) 
    363                     { 
    364                         validLayer = imageLayer; 
    365                     } 
    366                 } 
    367                 continue; 
    368             } 
    369         } 
    370  
    371         if (validLayer) 
    372         { 
    373             // fill in any missing layers 
    374             for(unsigned int i=0; i<tile->getNumColorLayers(); ++i) 
    375             { 
    376                 osgTerrain::Layer* layer = tile->getColorLayer(i); 
    377                 osgTerrain::ImageLayer* imageLayer = dynamic_cast<osgTerrain::ImageLayer*>(layer); 
    378                 if (imageLayer) 
    379                 { 
    380                     if (imageLayer->getImage()==0) 
    381                     { 
    382                         tile->setColorLayer(i, validLayer); 
    383                         break; 
    384                     } 
    385                     continue; 
    386                 } 
    387  
    388                 osgTerrain::SwitchLayer* switchLayer = dynamic_cast<osgTerrain::SwitchLayer*>(layer); 
    389                 if (switchLayer) 
    390                 { 
    391                     for(unsigned int si=0; si<switchLayer->getNumLayers(); ++si) 
    392                     { 
    393                         osgTerrain::ImageLayer* imageLayer = dynamic_cast<osgTerrain::ImageLayer*>(switchLayer->getLayer(si)); 
    394                         if (imageLayer && imageLayer->getImage()==0) 
    395                         { 
    396                             tile->setColorLayer(i, validLayer); 
    397                             break; 
    398                         } 
    399                     } 
    400                     continue; 
    401                 } 
    402  
    403                 osgTerrain::CompositeLayer* compositeLayer = dynamic_cast<osgTerrain::CompositeLayer*>(layer); 
    404                 if (compositeLayer) 
    405                 { 
    406                     for(unsigned int ci=0; ci<compositeLayer->getNumLayers(); ++ci) 
    407                     { 
    408                         osgTerrain::ImageLayer* imageLayer = dynamic_cast<osgTerrain::ImageLayer*>(switchLayer->getLayer(ci)); 
    409                         if (imageLayer && imageLayer->getImage()==0) 
    410                         { 
    411                             tile->setColorLayer(i, validLayer); 
    412                             break; 
    413                         } 
    414                     } 
    415                     continue; 
    416                 } 
    417             } 
    418         } 
    419     } 
    420 }; 
    421  
    422236int main( int argc, char **argv ) 
    423237{ 
     
    428242    arguments.getApplicationUsage()->addCommandLineOption("--login <url> <username> <password>","Provide authentication information for http file access."); 
    429243    
    430     
     244    // construct the viewer. 
     245    osgViewer::Viewer viewer(arguments); 
     246 
     247 
    431248    // set the tile loaded callback to load the optional imagery 
    432     osg::ref_ptr<WhiteListTileLoadedCallback> whiteList = new WhiteListTileLoadedCallback; 
     249    osg::ref_ptr<osgTerrain::WhiteListTileLoadedCallback> whiteList = new osgTerrain::WhiteListTileLoadedCallback; 
    433250    std::string setname; 
    434251    while(arguments.read("--allow",setname)) 
     
    436253        whiteList->allow(setname); 
    437254    } 
     255    while(arguments.read("--allow-all")) 
     256    { 
     257        whiteList->setAllowAll(true); 
     258    } 
    438259    osgTerrain::TerrainTile::setTileLoadedCallback(whiteList.get()); 
    439     
    440     // construct the viewer. 
    441     osgViewer::Viewer viewer(arguments); 
    442      
     260 
     261 
     262    // obtain the vertical scale 
    443263    float verticalScale = 1.0f; 
    444264    while(arguments.read("-v",verticalScale)) {} 
    445265     
     266    // obtain the sample ratio 
    446267    float sampleRatio = 1.0f; 
    447268    while(arguments.read("-r",sampleRatio)) {} 
    448269 
     270 
     271    // set up any authentication. 
    449272    std::string url, username, password; 
    450273    while(arguments.read("--login",url, username, password)) 
     
    546369        { 
    547370            numLayers = mtc->getNumTextureWeights(); 
     371 
     372            // switch on just the first texture layer. 
     373            mtc->setTextureWeight(0,1.0f); 
     374            for(unsigned int i=1; i<numLayers; ++i) 
     375            { 
     376                mtc->setTextureWeight(i,0.0f); 
     377            } 
    548378        } 
    549379