void
TerrainEngineNode::preInitialize( const Map* map, const TerrainOptions& options )
{
_map = map;
// fire up a terrain utility interface
_terrainInterface = new Terrain( this, map->getProfile(), map->isGeocentric(), options );
// set up the CSN values
_map->getProfile()->getSRS()->populateCoordinateSystemNode( this );
// OSG's CSN likes a NULL ellipsoid to represent projected mode.
if ( !_map->isGeocentric() )
this->setEllipsoidModel( NULL );
// install the proper layer composition technique:
_texCompositor = new TextureCompositor();
// then register the callback so we can process further map model changes
_map->addMapCallback( new TerrainEngineNodeCallbackProxy( this ) );
// enable backface culling
osg::StateSet* set = getOrCreateStateSet();
set->setMode( GL_CULL_FACE, 1 );
if ( options.enableMercatorFastPath().isSet() )
{
OE_INFO
<< LC << "Mercator fast path "
<< (options.enableMercatorFastPath()==true? "enabled" : "DISABLED") << std::endl;
}
_initStage = INIT_PREINIT_COMPLETE;
}
void
TerrainEngineNode::preInitialize( const Map* map, const TerrainOptions& options )
{
_map = map;
// fire up a terrain utility interface
_terrainInterface = new Terrain( this, map->getProfile(), map->isGeocentric(), options );
// set up the CSN values
_map->getProfile()->getSRS()->populateCoordinateSystemNode( this );
// OSG's CSN likes a NULL ellipsoid to represent projected mode.
if ( !_map->isGeocentric() )
this->setEllipsoidModel( NULL );
// install the proper layer composition technique:
_texCompositor = new TextureCompositor( options );
// prime the compositor with pre-existing image layers:
MapFrame mapf(map, Map::IMAGE_LAYERS);
for( unsigned i=0; i<mapf.imageLayers().size(); ++i )
{
_texCompositor->applyMapModelChange( MapModelChange(
MapModelChange::ADD_IMAGE_LAYER,
mapf.getRevision(),
mapf.getImageLayerAt(i),
i ) );
}
// then register the callback so we can process further map model changes
_map->addMapCallback( new TerrainEngineNodeCallbackProxy( this ) );
// enable backface culling
osg::StateSet* set = getOrCreateStateSet();
//set->setAttributeAndModes( new osg::CullFace( osg::CullFace::BACK ), osg::StateAttribute::ON );
set->setMode( GL_CULL_FACE, 1 );
// elevation uniform
// NOTE: wrong...this should be per-CullVisitor...consider putting in the Culling::CullUserData
_cameraElevationUniform = new osg::Uniform( osg::Uniform::FLOAT, "osgearth_CameraElevation" );
_cameraElevationUniform->set( 0.0f );
set->addUniform( _cameraElevationUniform.get() );
set->getOrCreateUniform( "osgearth_ImageLayerAttenuation", osg::Uniform::FLOAT )->set(
*options.attentuationDistance() );
if ( options.enableMercatorFastPath().isSet() )
{
OE_INFO
<< LC << "Mercator fast path "
<< (options.enableMercatorFastPath()==true? "enabled" : "DISABLED") << std::endl;
}
_initStage = INIT_PREINIT_COMPLETE;
}
void
RexTerrainEngineNode::preInitialize( const Map* map, const TerrainOptions& options )
{
// Force the mercator fast path off, since REX does not support it yet.
TerrainOptions myOptions = options;
myOptions.enableMercatorFastPath() = false;
TerrainEngineNode::preInitialize( map, myOptions );
}
void
TerrainEngineNode::preInitialize( const Map* map, const TerrainOptions& options )
{
_map = map;
// fire up a terrain utility interface
_terrainInterface = new Terrain( this, map->getProfile(), map->isGeocentric(), options );
// set up the CSN values
_map->getProfile()->getSRS()->populateCoordinateSystemNode( this );
// OSG's CSN likes a NULL ellipsoid to represent projected mode.
if ( !_map->isGeocentric() )
this->setEllipsoidModel( NULL );
// install an object to manage texture image unit usage:
_texCompositor = new TextureCompositor();
std::set<int> offLimits = osgEarth::Registry::instance()->getOffLimitsTextureImageUnits();
for(std::set<int>::const_iterator i = offLimits.begin(); i != offLimits.end(); ++i)
_texCompositor->setTextureImageUnitOffLimits( *i );
// then register the callback so we can process further map model changes
_map->addMapCallback( new TerrainEngineNodeCallbackProxy( this ) );
// apply render bin if necessary
if ( options.binNumber().isSet() )
{
osg::StateSet* set = getOrCreateStateSet();
set->setRenderBinDetails( options.binNumber().get(), "RenderBin" );
}
if ( options.enableMercatorFastPath().isSet() )
{
OE_INFO
<< LC << "Mercator fast path "
<< (options.enableMercatorFastPath()==true? "enabled" : "DISABLED") << std::endl;
}
// a default factory - this is the object that creates the data model for
// each terrain tile.
_tileModelFactory = new TerrainTileModelFactory(options);
_initStage = INIT_PREINIT_COMPLETE;
}
void
RexTerrainEngineNode::postInitialize( const Map* map, const TerrainOptions& options )
{
// Force the mercator fast path off, since REX does not support it yet.
TerrainOptions myOptions = options;
myOptions.enableMercatorFastPath() = false;
TerrainEngineNode::postInitialize( map, myOptions );
// Initialize the map frames. We need one for the update thread and one for the
// cull thread. Someday we can detect whether these are actually the same thread
// (depends on the viewer's threading mode).
_update_mapf = new MapFrame( map, Map::ENTIRE_MODEL );
// A callback for overriding bounding boxes for tiles
_modifyBBoxCallback = new ModifyBoundingBoxCallback(*_update_mapf);
// merge in the custom options:
_terrainOptions.merge( myOptions );
// morphing imagery LODs requires we bind parent textures to their own unit.
if ( _terrainOptions.morphImagery() == true )
{
_requireParentTextures = true;
}
// Terrain morphing doesn't work in projected maps:
if (map->getSRS()->isProjected())
{
_terrainOptions.morphTerrain() = false;
}
// if the envvar for tile expiration is set, overide the options setting
const char* val = ::getenv("OSGEARTH_EXPIRATION_THRESHOLD");
if ( val )
{
_terrainOptions.expirationThreshold() = as<unsigned>(val, _terrainOptions.expirationThreshold().get());
OE_INFO << LC << "Expiration threshold set by env var = " << _terrainOptions.expirationThreshold().get() << "\n";
}
// if the envvar for hires prioritization is set, override the options setting
const char* hiresFirst = ::getenv("OSGEARTH_HIGH_RES_FIRST");
if ( hiresFirst )
{
_terrainOptions.highResolutionFirst() = true;
}
// check for normal map generation (required for lighting).
if ( _terrainOptions.normalMaps() == true )
{
this->_requireNormalTextures = true;
}
// A shared registry for tile nodes in the scene graph. Enable revision tracking
// if requested in the options. Revision tracking lets the registry notify all
// live tiles of the current map revision so they can inrementally update
// themselves if necessary.
_liveTiles = new TileNodeRegistry("live");
_liveTiles->setMapRevision( _update_mapf->getRevision() );
// A resource releaser that will call releaseGLObjects() on expired objects.
_releaser = new ResourceReleaser();
this->addChild(_releaser.get());
// A shared geometry pool.
_geometryPool = new GeometryPool( _terrainOptions );
_geometryPool->setReleaser( _releaser.get());
this->addChild( _geometryPool.get() );
// Make a tile loader
PagerLoader* loader = new PagerLoader( this );
loader->setNumLODs(_terrainOptions.maxLOD().getOrUse(DEFAULT_MAX_LOD));
loader->setMergesPerFrame( _terrainOptions.mergesPerFrame().get() );
for (std::vector<RexTerrainEngineOptions::LODOptions>::const_iterator i = _terrainOptions.lods().begin(); i != _terrainOptions.lods().end(); ++i) {
if (i->_lod.isSet()) {
loader->setLODPriorityScale(i->_lod.get(), i->_priorityScale.getOrUse(1.0f));
loader->setLODPriorityOffset(i->_lod.get(), i->_priorityOffset.getOrUse(0.0f));
}
}
_loader = loader;
this->addChild( _loader.get() );
// Make a tile unloader
_unloader = new UnloaderGroup( _liveTiles.get() );
_unloader->setThreshold( _terrainOptions.expirationThreshold().get() );
_unloader->setReleaser(_releaser.get());
this->addChild( _unloader.get() );
// handle an already-established map profile:
MapInfo mapInfo( map );
if ( _update_mapf->getProfile() )
{
// NOTE: this will initialize the map with the startup layers
onMapInfoEstablished( mapInfo );
}
// install a layer callback for processing further map actions:
map->addMapCallback( new RexTerrainEngineNodeMapCallbackProxy(this) );
// Prime with existing layers:
_batchUpdateInProgress = true;
ElevationLayerVector elevationLayers;
map->getLayers( elevationLayers );
for( ElevationLayerVector::const_iterator i = elevationLayers.begin(); i != elevationLayers.end(); ++i )
addElevationLayer( i->get() );
ImageLayerVector imageLayers;
map->getLayers( imageLayers );
for( ImageLayerVector::iterator i = imageLayers.begin(); i != imageLayers.end(); ++i )
addTileLayer( i->get() );
_batchUpdateInProgress = false;
// set up the initial shaders
updateState();
// register this instance to the osgDB plugin can find it.
registerEngine( this );
// now that we have a map, set up to recompute the bounds
dirtyBound();
}