Changeset 908

Show
Ignore:
Timestamp:
03/27/08 12:45:35
Author:
robert
Message:

Updated source to reflect osgTerrain::Terrain to osgTerrain::TerrainTile? rename.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/applications/osgdem/osgdem.cpp

    r903 r908  
    8686 
    8787 
    88     osg::ref_ptr<osgTerrain::Terrain> terrain = 0; 
     88    osg::ref_ptr<osgTerrain::TerrainTile> terrain = 0; 
    8989 
    9090 
    …… 
    126126        if (node.valid()) 
    127127        { 
    128             osgTerrain::Terrain* loaded_terrain = dynamic_cast<osgTerrain::Terrain*>(node.get()); 
     128            osgTerrain::TerrainTile* loaded_terrain = dynamic_cast<osgTerrain::TerrainTile*>(node.get()); 
    129129            if (loaded_terrain)  
    130130            { 
    …… 
    164164    } 
    165165     
    166     if (!terrain) terrain = new osgTerrain::Terrain; 
     166    if (!terrain) terrain = new osgTerrain::TerrainTile; 
    167167 
    168168    std::string terrainOutputName; 

  • trunk/applications/vpbcache/vpbcache.cpp

    r832 r908  
    4949 
    5050    // read any source input definitions 
    51     osg::ref_ptr<osgTerrain::Terrain> terrain = new osgTerrain::Terrain; 
     51    osg::ref_ptr<osgTerrain::TerrainTile> terrain = new osgTerrain::TerrainTile; 
    5252 
    5353    std::string filename; 
    …… 
    5757        if (node.valid()) 
    5858        { 
    59             osgTerrain::Terrain* loaded_terrain = dynamic_cast<osgTerrain::Terrain*>(node.get()); 
     59            osgTerrain::TerrainTile* loaded_terrain = dynamic_cast<osgTerrain::TerrainTile*>(node.get()); 
    6060            if (loaded_terrain)  
    6161            { 

  • trunk/include/vpb/Commandline

    r791 r908  
    1313 
    1414#include <osg/ArgumentParser> 
    15 #include <osgTerrain/Terrain> 
     15#include <osgTerrain/TerrainTile> 
    1616 
    1717#include <vpb/Source> 
    …… 
    4343        void getUsage(osg::ApplicationUsage& usage); 
    4444             
    45         int read(std::ostream& fout, osg::ArgumentParser& arguments, osgTerrain::Terrain* terrainInput); 
     45        int read(std::ostream& fout, osg::ArgumentParser& arguments, osgTerrain::TerrainTile* terrainInput); 
    4646 
    4747    protected: 
    …… 
    4949        unsigned int readMask(const std::string& maskstring); 
    5050     
    51         osg::ref_ptr<osgTerrain::Terrain> terrain; 
    52         osg::ref_ptr<BuildOptions>        buildOptions;  
     51        osg::ref_ptr<osgTerrain::TerrainTile>   terrainTile; 
     52        osg::ref_ptr<BuildOptions>              buildOptions;  
    5353     
    54         vpb::SpatialProperties::DataType dataType; 
    55         std::string currentCS; 
    56         osg::Matrixd geoTransform; 
    57         bool geoTransformSet; 
    58         bool geoTransformScale; 
     54        vpb::SpatialProperties::DataType        dataType; 
     55        std::string                             currentCS; 
     56        osg::Matrixd                            geoTransform; 
     57        bool                                    geoTransformSet; 
     58        bool                                    geoTransformScale; 
    5959 
    6060        bool minmaxLevelSet; 

  • trunk/include/vpb/DataSet

    r886 r908  
    2828#include <osg/CoordinateSystemNode> 
    2929 
    30 #include <osgTerrain/Terrain> 
     30#include <osgTerrain/TerrainTile> 
    3131 
    3232#include <osgDB/Archive> 
    …… 
    109109        bool addModel(Source::Type type, osg::Node* node); 
    110110        bool addLayer(Source::Type type, osgTerrain::Layer* layer, unsigned layerNum); 
    111         bool addTerrain(osgTerrain::Terrain* terrain); 
    112          
    113         osgTerrain::Terrain* createTerrainRepresentation(); 
     111        bool addTerrain(osgTerrain::TerrainTile* terrain); 
     112         
     113        osgTerrain::TerrainTile* createTerrainRepresentation(); 
    114114         
    115115        void loadSources(); 

  • trunk/include/vpb/FileCache

    r828 r908  
    1616 
    1717#include <osgDB/FileUtils> 
    18 #include <osgTerrain/Terrain> 
     18#include <osgTerrain/TerrainTile> 
    1919 
    2020#include <OpenThreads/Mutex> 
    …… 
    7474         
    7575        /** add FileDetails for each source file in specified source.*/ 
    76         void addSource(osgTerrain::Terrain* source); 
     76        void addSource(osgTerrain::TerrainTile* source); 
    7777         
    7878        /** reproject any source files to the coordinate system required to build the specified source.*/ 
    79         void buildRequiredReprojections(osgTerrain::Terrain* source); 
     79        void buildRequiredReprojections(osgTerrain::TerrainTile* source); 
    8080 
    8181        /** build overview levels for each source file.*/ 
    82         void buildOverviews(osgTerrain::Terrain* source); 
     82        void buildOverviews(osgTerrain::TerrainTile* source); 
    8383         
    8484        /** copy files from the master to the specified machine's cache directory.*/ 
    85         void mirror(Machine* machine, osgTerrain::Terrain* source); 
     85        void mirror(Machine* machine, osgTerrain::TerrainTile* source); 
    8686         
    8787        /** copy and individual file to specificed machines local cache.*/ 

  • trunk/include/vpb/System

    r887 r908  
    106106         
    107107        /** Return the date of last modification from the list of source specified on the terrain source.*/ 
    108         bool getDateOfLastModification(osgTerrain::Terrain* source, Date& date); 
     108        bool getDateOfLastModification(osgTerrain::TerrainTile* source, Date& date); 
    109109         
    110110        /** Return the size of a file in bytes.*/ 

  • trunk/include/vpb/TaskManager

    r887 r908  
    3838        int read(osg::ArgumentParser& arguments); 
    3939 
    40         void setSource(osgTerrain::Terrain* terrain); 
    41         osgTerrain::Terrain* getSource(); 
     40        void setSource(osgTerrain::TerrainTile* terrain); 
     41        osgTerrain::TerrainTile* getSource(); 
    4242 
    4343        /** start a new set of tasks.*/ 
    …… 
    144144        static void signalHandler(int sig); 
    145145         
    146         std::string                         _runPath; 
    147         std::string                         _buildName; 
     146        std::string                             _runPath; 
     147        std::string                             _buildName; 
    148148 
    149         osg::ref_ptr<Task>                  _taskFile; 
     149        osg::ref_ptr<Task>                      _taskFile; 
    150150         
    151         std::string                         _sourceFileName; 
    152         osg::ref_ptr<osgTerrain::Terrain>   _terrain; 
     151        std::string                             _sourceFileName; 
     152        osg::ref_ptr<osgTerrain::TerrainTile>   _terrainTile; 
    153153         
    154154        std::string                         _tasksFileName; 

  • trunk/src/vpb/Commandline.cpp

    r894 r908  
    106106    if (type==vpb::Source::IMAGE) 
    107107    { 
    108         existingLayer = (layerNum < terrain->getNumColorLayers()) ? terrain->getColorLayer(layerNum) : 0; 
     108        existingLayer = (layerNum < terrainTile->getNumColorLayers()) ? terrainTile->getColorLayer(layerNum) : 0; 
    109109        compositeLayer = dynamic_cast<osgTerrain::CompositeLayer*>(existingLayer); 
    110110 
    …… 
    114114            if (existingLayer) compositeLayer->addLayer(existingLayer); 
    115115 
    116             terrain->setColorLayer(layerNum, compositeLayer); 
     116            terrainTile->setColorLayer(layerNum, compositeLayer); 
    117117        } 
    118118    } 
    119119    else if (type==vpb::Source::HEIGHT_FIELD) 
    120120    { 
    121         existingLayer = terrain->getElevationLayer(); 
     121        existingLayer = terrainTile->getElevationLayer(); 
    122122        compositeLayer = dynamic_cast<osgTerrain::CompositeLayer*>(existingLayer); 
    123123 
    …… 
    127127            if (existingLayer) compositeLayer->addLayer(existingLayer); 
    128128 
    129             terrain->setElevationLayer(compositeLayer); 
     129            terrainTile->setElevationLayer(compositeLayer); 
    130130        } 
    131131    } 
    …… 
    347347 
    348348 
    349         terrain->addChild(model.get()); 
     349        terrainTile->addChild(model.get()); 
    350350    } 
    351351    else 
    …… 
    385385        model->addDescription("MODEL"); 
    386386 
    387         terrain->addChild(model.get()); 
     387        terrainTile->addChild(model.get()); 
    388388    } 
    389389    else 
    …… 
    499499} 
    500500 
    501 int Commandline::read(std::ostream& fout, osg::ArgumentParser& arguments, osgTerrain::Terrain* terrainInput) 
    502 { 
    503     terrain = terrainInput; 
    504  
    505     vpb::DatabaseBuilder* databaseBuilder = dynamic_cast<vpb::DatabaseBuilder*>(terrain->getTerrainTechnique()); 
     501int Commandline::read(std::ostream& fout, osg::ArgumentParser& arguments, osgTerrain::TerrainTile* terrainInput) 
     502{ 
     503    terrainTile = terrainInput; 
     504 
     505    vpb::DatabaseBuilder* databaseBuilder = dynamic_cast<vpb::DatabaseBuilder*>(terrainTile->getTerrainTechnique()); 
    506506    if (!databaseBuilder)  
    507507    { 
    508508        databaseBuilder = new vpb::DatabaseBuilder; 
    509         terrain->setTerrainTechnique(databaseBuilder); 
     509        terrainTile->setTerrainTechnique(databaseBuilder); 
    510510    } 
    511511     

  • trunk/src/vpb/DataSet.cpp

    r899 r908  
    231231        { 
    232232            // place models and shapefiles into a separate temporary source list and then process these after 
    233             // the main handling of terrain/imagery sources. 
     233            // the main handling of terrainTile/imagery sources. 
    234234            continue; 
    235235             
    …… 
    15071507    virtual void apply(osg::Group& group) 
    15081508    { 
    1509         osgTerrain::Terrain* terrain = dynamic_cast<osgTerrain::Terrain*>(&group); 
    1510         if (terrain) 
    1511         { 
    1512             applyTerrain(*terrain); 
     1509        osgTerrain::TerrainTile* terrainTile = dynamic_cast<osgTerrain::TerrainTile*>(&group); 
     1510        if (terrainTile) 
     1511        { 
     1512            applyTerrain(*terrainTile); 
    15131513        } 
    15141514        else 
    …… 
    15181518    } 
    15191519 
    1520     void applyTerrain(osgTerrain::Terrain& terrain) 
    1521     { 
    1522         if (terrain.getStateSet()) apply(*(terrain.getStateSet())); 
     1520    void applyTerrain(osgTerrain::TerrainTile& terrainTile) 
     1521    { 
     1522        if (terrainTile.getStateSet()) apply(*(terrainTile.getStateSet())); 
    15231523         
    15241524        // need to iterator through images stored in layers 
    …… 
    20572057} 
    20582058 
    2059 bool DataSet::addTerrain(osgTerrain::Terrain* terrain) 
    2060 { 
    2061     log(osg::NOTICE,"Adding terrain %s",terrain->getName().c_str()); 
    2062  
    2063     if (terrain->getLocator()) 
     2059bool DataSet::addTerrain(osgTerrain::TerrainTile* terrainTile) 
     2060{ 
     2061    log(osg::NOTICE,"Adding terrainTile %s",terrainTile->getName().c_str()); 
     2062 
     2063    if (terrainTile->getLocator()) 
    20642064    { 
    20652065    } 
    20662066  
    2067     vpb::DatabaseBuilder* db = dynamic_cast<vpb::DatabaseBuilder*>(terrain->getTerrainTechnique()); 
     2067    vpb::DatabaseBuilder* db = dynamic_cast<vpb::DatabaseBuilder*>(terrainTile->getTerrainTechnique()); 
    20682068    if (db && db->getBuildOptions()) 
    20692069    { 
    …… 
    20712071    } 
    20722072 
    2073     if (terrain->getElevationLayer()) 
    2074     { 
    2075         addLayer(vpb::Source::HEIGHT_FIELD, terrain->getElevationLayer(), 0); 
    2076     } 
    2077  
    2078     for(unsigned int i=0; i<terrain->getNumColorLayers();++i) 
    2079     { 
    2080         osgTerrain::Layer* layer = terrain->getColorLayer(i); 
     2073    if (terrainTile->getElevationLayer()) 
     2074    { 
     2075        addLayer(vpb::Source::HEIGHT_FIELD, terrainTile->getElevationLayer(), 0); 
     2076    } 
     2077 
     2078    for(unsigned int i=0; i<terrainTile->getNumColorLayers();++i) 
     2079    { 
     2080        osgTerrain::Layer* layer = terrainTile->getColorLayer(i); 
    20812081        if (layer)  
    20822082        { 
    …… 
    20852085    } 
    20862086     
    2087     for(unsigned int ci=0; ci<terrain->getNumChildren(); ++ci) 
    2088     { 
    2089      
    2090         osg::Node* model = terrain->getChild(ci); 
     2087    for(unsigned int ci=0; ci<terrainTile->getNumChildren(); ++ci) 
     2088    { 
     2089     
     2090        osg::Node* model = terrainTile->getChild(ci); 
    20912091     
    20922092        osg::notify(osg::NOTICE)<<"Adding model"<<model->getName()<<std::endl; 
    …… 
    21052105} 
    21062106 
    2107 osgTerrain::Terrain* DataSet::createTerrainRepresentation() 
    2108 { 
    2109     osg::ref_ptr<osgTerrain::Terrain> terrain = new osgTerrain::Terrain; 
     2107osgTerrain::TerrainTile* DataSet::createTerrainRepresentation() 
     2108{ 
     2109    osg::ref_ptr<osgTerrain::TerrainTile> terrainTile = new osgTerrain::TerrainTile; 
    21102110 
    21112111    for(CompositeSource::source_iterator itr(_sourceGraph.get());itr.valid();++itr) 
    …… 
    21552155            if (source->getType()==Source::IMAGE) 
    21562156            { 
    2157                 osgTerrain::Layer* existingLayer = (layerNum < terrain->getNumColorLayers()) ? terrain->getColorLayer(layerNum) : 0; 
     2157                osgTerrain::Layer* existingLayer = (layerNum < terrainTile->getNumColorLayers()) ? terrainTile->getColorLayer(layerNum) : 0; 
    21582158                osgTerrain::CompositeLayer* compositeLayer = dynamic_cast<osgTerrain::CompositeLayer*>(existingLayer); 
    21592159 
    …… 
    21682168                    compositeLayer->addLayer( loadedLayer ); 
    21692169 
    2170                     terrain->setColorLayer(layerNum, compositeLayer); 
     2170                    terrainTile->setColorLayer(layerNum, compositeLayer); 
    21712171                } 
    21722172                else 
    21732173                { 
    2174                     terrain->setColorLayer(layerNum, loadedLayer); 
     2174                    terrainTile->setColorLayer(layerNum, loadedLayer); 
    21752175                } 
    21762176            } 
    21772177            else if (source->getType()==Source::HEIGHT_FIELD) 
    21782178            { 
    2179                 osgTerrain::Layer* existingLayer = terrain->getElevationLayer(); 
     2179                osgTerrain::Layer* existingLayer = terrainTile->getElevationLayer(); 
    21802180                osgTerrain::CompositeLayer* compositeLayer = dynamic_cast<osgTerrain::CompositeLayer*>(existingLayer); 
    21812181 
    …… 
    21902190                    compositeLayer->addLayer( loadedLayer ); 
    21912191 
    2192                     terrain->setElevationLayer(compositeLayer); 
     2192                    terrainTile->setElevationLayer(compositeLayer); 
    21932193                } 
    21942194                else 
    21952195                { 
    2196                     terrain->setElevationLayer(loadedLayer); 
     2196                    terrainTile->setElevationLayer(loadedLayer); 
    21972197                } 
    21982198            } 
    …… 
    22032203    builder->setBuildOptions(new BuildOptions(*this)); 
    22042204    builder->setBuildLog(getBuildLog()); 
    2205     terrain->setTerrainTechnique(builder.get()); 
    2206  
    2207     return terrain.release(); 
     2205    terrainTile->setTerrainTechnique(builder.get()); 
     2206 
     2207    return terrainTile.release(); 
    22082208} 
    22092209 
    …… 
    28092809    if (!getIntermediateBuildName().empty()) 
    28102810    { 
    2811         osg::ref_ptr<osgTerrain::Terrain> terrain = createTerrainRepresentation(); 
    2812         if (terrain.valid()) 
    2813         { 
    2814             DatabaseBuilder* db = dynamic_cast<DatabaseBuilder*>(terrain->getTerrainTechnique()); 
     2811        osg::ref_ptr<osgTerrain::TerrainTile> terrainTile = createTerrainRepresentation(); 
     2812        if (terrainTile.valid()) 
     2813        { 
     2814            DatabaseBuilder* db = dynamic_cast<DatabaseBuilder*>(terrainTile->getTerrainTechnique()); 
    28152815            if (db && db->getBuildOptions())  
    28162816            { 
    28172817                db->getBuildOptions()->setIntermediateBuildName(""); 
    28182818            } 
    2819             osgDB::writeNodeFile(*terrain,getIntermediateBuildName()); 
     2819            osgDB::writeNodeFile(*terrainTile,getIntermediateBuildName()); 
    28202820            requiresGenerationOfTiles = false; 
    28212821        } 

  • trunk/src/vpb/Destination.cpp

    r892 r908  
    14511451 
    14521452    // create the terrain node that we'll hang the height field off 
    1453     osgTerrain::Terrain* terrain = new osgTerrain::Terrain; 
    1454     terrain->setLocator(locator);     
     1453    osgTerrain::TerrainTile* terrainTile = new osgTerrain::TerrainTile; 
     1454    terrainTile->setLocator(locator);     
    14551455 
    14561456 
    …… 
    14611461        hfLayer->setLocator(locator); 
    14621462         
    1463         terrain->setElevationLayer(hfLayer); 
     1463        terrainTile->setElevationLayer(hfLayer); 
    14641464    } 
    14651465     
    …… 
    14791479            imageLayer->setLocator(locator); 
    14801480 
    1481             terrain->setColorLayer(layerNum, imageLayer); 
     1481            terrainTile->setColorLayer(layerNum, imageLayer); 
    14821482        } 
    14831483    } 
    …… 
    14931493                ++layerNum) 
    14941494            { 
    1495                 layer = terrain->getColorLayer(layerNum); 
     1495                layer = terrainTile->getColorLayer(layerNum); 
    14961496            } 
    14971497 
    …… 
    15031503                    ++layerNum) 
    15041504                { 
    1505                     if (!terrain->getColorLayer(layerNum)) 
     1505                    if (!terrainTile->getColorLayer(layerNum)) 
    15061506                    { 
    1507                         terrain->setColorLayer(layerNum,layer); 
     1507                        terrainTile->setColorLayer(layerNum,layer); 
    15081508                    } 
    15091509                } 
    …… 
    15191519                ++layerNum) 
    15201520            { 
    1521                 osgTerrain::Layer* localLayer = terrain->getColorLayer(layerNum); 
     1521                osgTerrain::Layer* localLayer = terrainTile->getColorLayer(layerNum); 
    15221522                if (localLayer) layer = localLayer; 
    1523                 else if (layer) terrain->setColorLayer(layerNum, layer); 
     1523                else if (layer) terrainTile->setColorLayer(layerNum, layer); 
    15241524                else ++noBlanks; 
    15251525            } 
    …… 
    15321532                    --layerNum) 
    15331533                { 
    1534                     osgTerrain::Layer* localLayer = terrain->getColorLayer(layerNum); 
     1534                    osgTerrain::Layer* localLayer = terrainTile->getColorLayer(layerNum); 
    15351535                    if (localLayer) layer = localLayer; 
    1536                     else if (layer) terrain->setColorLayer(layerNum, layer); 
     1536                    else if (layer) terrainTile->setColorLayer(layerNum, layer); 
    15371537                } 
    15381538            } 
    …… 
    15491549    // assign the terrain technique that will be used to render the terrain tile. 
    15501550    osgTerrain::GeometryTechnique* gt = new osgTerrain::GeometryTechnique; 
    1551     terrain->setTerrainTechnique(gt); 
     1551    terrainTile->setTerrainTechnique(gt); 
    15521552     
    15531553    // assign cluster culling callback to terrain 
    1554     terrain->setCullCallback(createClusterCullingCallback()); 
    1555      
    1556     return terrain; 
     1554    terrainTile->setCullCallback(createClusterCullingCallback()); 
     1555     
     1556    return terrainTile; 
    15571557} 
    15581558 

  • trunk/src/vpb/FileCache.cpp

    r870 r908  
    462462} 
    463463 
    464 void FileCache::addSource(osgTerrain::Terrain* source) 
     464void FileCache::addSource(osgTerrain::TerrainTile* source) 
    465465{ 
    466466    if (!source) return; 
    …… 
    487487} 
    488488 
    489 void FileCache::buildRequiredReprojections(osgTerrain::Terrain* source) 
     489void FileCache::buildRequiredReprojections(osgTerrain::TerrainTile* source) 
    490490{ 
    491491    if (!source) return; 
    …… 
    553553 
    554554 
    555 void FileCache::buildOverviews(osgTerrain::Terrain* source) 
     555void FileCache::buildOverviews(osgTerrain::TerrainTile* source) 
    556556{ 
    557557 
    …… 
    640640} 
    641641 
    642 void FileCache::mirror(Machine* machine, osgTerrain::Terrain* source) 
     642void FileCache::mirror(Machine* machine, osgTerrain::TerrainTile* source) 
    643643{ 
    644644    log(osg::NOTICE,"FileCache::mirror(%s)",machine->getHostName().c_str()); 

  • trunk/src/vpb/System.cpp

    r887 r908  
    339339} 
    340340 
    341 bool System::getDateOfLastModification(osgTerrain::Terrain* source, Date& date) 
     341bool System::getDateOfLastModification(osgTerrain::TerrainTile* source, Date& date) 
    342342{ 
    343343    typedef std::list<osgTerrain::Layer*> Layers; 

  • trunk/src/vpb/TaskManager.cpp

    r903 r908  
    8989    } 
    9090     
    91     if (!_terrain) _terrain = new osgTerrain::Terrain; 
     91    if (!_terrainTile) _terrainTile = new osgTerrain::TerrainTile; 
    9292 
    9393    std::string terrainOutputName; 
    …… 
    9898     
    9999 
    100     int result = commandlineParser.read(std::cout, arguments, _terrain.get()); 
     100    int result = commandlineParser.read(std::cout, arguments, _terrainTile.get()); 
    101101    if (result) return result; 
    102102     
    …… 
    105105    if (!terrainOutputName.empty()) 
    106106    { 
    107         if (_terrain.valid()) 
    108         { 
    109             osgDB::writeNodeFile(*_terrain, terrainOutputName); 
     107        if (_terrainTile.valid()) 
     108        { 
     109            osgDB::writeNodeFile(*_terrainTile, terrainOutputName); 
    110110             
    111111            // make sure the changes are written to disk. 
    …… 
    134134} 
    135135 
    136 void TaskManager::setSource(osgTerrain::Terrain* terrain) 
    137 { 
    138     _terrain = terrain; 
    139 } 
    140  
    141 osgTerrain::Terrain* TaskManager::getSource() 
    142 { 
    143     return _terrain.get(); 
     136void TaskManager::setSource(osgTerrain::TerrainTile* terrainTile) 
     137{ 
     138    _terrainTile = terrainTile; 
     139} 
     140 
     141osgTerrain::TerrainTile* TaskManager::getSource() 
     142{ 
     143    return _terrainTile.get(); 
    144144} 
    145145 
    …… 
    184184{ 
    185185 
    186     if (_terrain.valid()) 
     186    if (_terrainTile.valid()) 
    187187    { 
    188188        try  
    …… 
    190190            osg::ref_ptr<vpb::DataSet> dataset = new vpb::DataSet; 
    191191 
    192             vpb::DatabaseBuilder* db = dynamic_cast<vpb::DatabaseBuilder*>(_terrain->getTerrainTechnique()); 
     192            vpb::DatabaseBuilder* db = dynamic_cast<vpb::DatabaseBuilder*>(_terrainTile->getTerrainTechnique()); 
    193193            vpb::BuildOptions* bo = db ? db->getBuildOptions() : 0; 
    194194 
    …… 
    203203            } 
    204204 
    205             dataset->addTerrain(_terrain.get()); 
     205            dataset->addTerrain(_terrainTile.get()); 
    206206 
    207207            int result = dataset->run(); 
    …… 
    225225    bool result = false; 
    226226     
    227     if (_terrain.valid()) 
     227    if (_terrainTile.valid()) 
    228228    { 
    229229        try  
    …… 
    231231            osg::ref_ptr<vpb::DataSet> dataset = new vpb::DataSet; 
    232232 
    233             vpb::DatabaseBuilder* db = dynamic_cast<vpb::DatabaseBuilder*>(_terrain->getTerrainTechnique()); 
     233            vpb::DatabaseBuilder* db = dynamic_cast<vpb::DatabaseBuilder*>(_terrainTile->getTerrainTechnique()); 
    234234            vpb::BuildOptions* bo = db ? db->getBuildOptions() : 0; 
    235235 
    …… 
    244244            } 
    245245 
    246             dataset->addTerrain(_terrain.get()); 
     246            dataset->addTerrain(_terrainTile.get()); 
    247247             
    248248            if (dataset->requiresReprojection()) 
    …… 
    439439bool TaskManager::writeSource(const std::string& filename) 
    440440{ 
    441     if (_terrain.valid()) 
     441    if (_terrainTile.valid()) 
    442442    { 
    443443        _sourceFileName = filename; 
    444444     
    445         osgDB::writeNodeFile(*_terrain, _sourceFileName); 
     445        osgDB::writeNodeFile(*_terrainTile, _sourceFileName); 
    446446 
    447447        // make sure the OS writes the file to disk 
    …… 
    461461    if (node.valid()) 
    462462    { 
    463         osgTerrain::Terrain* loaded_terrain = dynamic_cast<osgTerrain::Terrain*>(node.get()); 
     463        osgTerrain::TerrainTile* loaded_terrain = dynamic_cast<osgTerrain::TerrainTile*>(node.get()); 
    464464        if (loaded_terrain)  
    465465        { 
    466466            _sourceFileName = filename; 
    467             _terrain = loaded_terrain; 
     467            _terrainTile = loaded_terrain; 
    468468            return true; 
    469469        } 
    …… 
    677677BuildOptions* TaskManager::getBuildOptions() 
    678678{ 
    679     vpb::DatabaseBuilder* db = dynamic_cast<vpb::DatabaseBuilder*>(_terrain->getTerrainTechnique()); 
     679    vpb::DatabaseBuilder* db = dynamic_cast<vpb::DatabaseBuilder*>(_terrainTile->getTerrainTechnique()); 
    680680    return db ? db->getBuildOptions() : 0; 
    681681} 
    …… 
    719719                            { 
    720720                                osg::ref_ptr<osg::Node> loadedModel = osgDB::readNodeFile(sourceFile); 
    721                                 osgTerrain::Terrain* terrain = dynamic_cast<osgTerrain::Terrain*>(loadedModel.get()); 
    722                                 if (terrain) 
     721                                osgTerrain::TerrainTile* terrainTile = dynamic_cast<osgTerrain::TerrainTile*>(loadedModel.get()); 
     722                                if (terrainTile) 
    723723                                { 
    724                                     System::instance()->getDateOfLastModification(terrain, sourceFileLastModified); 
     724                                    System::instance()->getDateOfLastModification(terrainTile, sourceFileLastModified); 
    725725                                } 
    726726                            }