void
TerrainEngineNode::traverse( osg::NodeVisitor& nv )
{
if ( nv.getVisitorType() == osg::NodeVisitor::CULL_VISITOR )
{
// see if we need to set up the Terrain object with an update ops queue.
if ( !_terrainInterface->_updateOperationQueue.valid() )
{
static Threading::Mutex s_opqlock;
Threading::ScopedMutexLock lock(s_opqlock);
if ( !_terrainInterface->_updateOperationQueue.valid() ) // double check pattern
{
//TODO: think, will this work with >1 view?
osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>( &nv );
if ( cv->getCurrentCamera() )
{
osgViewer::View* view = dynamic_cast<osgViewer::View*>(cv->getCurrentCamera()->getView());
if ( view && view->getViewerBase() )
{
osg::OperationQueue* q = view->getViewerBase()->getUpdateOperations();
if ( !q ) {
q = new osg::OperationQueue();
view->getViewerBase()->setUpdateOperations( q );
}
_terrainInterface->_updateOperationQueue = q;
}
}
}
}
if ( Registry::instance()->getCapabilities().supportsGLSL() )
{
_updateLightingUniformsHelper.cullTraverse( this, &nv );
osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>( &nv );
if ( cv )
{
osg::Vec3d eye = cv->getEyePoint();
float elevation;
if ( _map->isGeocentric() )
elevation = eye.length() - osg::WGS_84_RADIUS_EQUATOR;
else
elevation = eye.z();
_cameraElevationUniform->set( elevation );
}
}
}
else if ( nv.getVisitorType() == osg::NodeVisitor::EVENT_VISITOR )
{
_dirtyCount = 0;
}
osg::CoordinateSystemNode::traverse( nv );
}
void ElevationLOD::traverse( osg::NodeVisitor& nv)
{
if (nv.getVisitorType() == osg::NodeVisitor::CULL_VISITOR &&
nv.getTraversalMode() == osg::NodeVisitor::TRAVERSE_ACTIVE_CHILDREN )
{
bool rangeOK = true;
bool altitudeOK = true;
// first test the range:
if ( _minRange.isSet() || _maxRange.isSet() )
{
float range = nv.getDistanceToViewPoint( getBound().center(), true );
rangeOK =
(!_minRange.isSet() || (range >= *_minRange)) &&
(!_maxRange.isSet() || (range <= *_maxRange));
}
if ( rangeOK )
{
if ( _minElevation.isSet() || _maxElevation.isSet() )
{
double alt;
// first see if we have a precalculated elevation:
osgUtil::CullVisitor* cv = Culling::asCullVisitor(nv);
osg::Vec3d eye = cv->getViewPoint();
if ( _srs && !_srs->isProjected() )
{
GeoPoint mapPoint;
mapPoint.fromWorld( _srs.get(), eye );
alt = mapPoint.z();
}
else
{
alt = eye.z();
}
// account for the LOD scale
alt *= cv->getLODScale();
altitudeOK =
(!_minElevation.isSet() || (alt >= *_minElevation)) &&
(!_maxElevation.isSet() || (alt <= *_maxElevation));
}
if ( altitudeOK )
{
std::for_each(_children.begin(),_children.end(),osg::NodeAcceptOp(nv));
}
}
}
else
{
osg::Group::traverse( nv );
}
}
void
HTMNode::traverse(osg::NodeVisitor& nv)
{
if ( nv.getVisitorType() == nv.CULL_VISITOR )
{
//OE_INFO << getName() << std::endl;
#if 0
if ( _isLeaf )
{
if (_settings._debugFrame != nv.getFrameStamp()->getFrameNumber())
{
OE_NOTICE << "Frame " << _settings._debugFrame << ": " << _settings._debugCount << std::endl;
_settings._debugCount = 0;
_settings._debugFrame = nv.getFrameStamp()->getFrameNumber();
}
_settings._debugCount += getNumChildren();
}
#endif
const osg::BoundingSphere& bs = getBound();
float range = nv.getDistanceToViewPoint(bs.center(), true);
bool inRange = false;
if (_settings._maxRange.isSet() == false)
{
inRange = range < (bs.radius() * _settings._rangeFactor.get());
}
else
{
inRange = range < (bs.radius() + _settings._maxRange.get());
}
if ( inRange )
{
osg::Group::traverse( nv );
if (_debug.valid() && _isLeaf)
{
_debug->accept(nv);
}
}
else if (_debug.valid())
{
_debug->accept(nv);
}
}
else
{
if (_debug.valid())
{
_debug->accept(nv);
}
osg::Group::traverse( nv );
}
}
void
OrthoNode::traverse( osg::NodeVisitor& nv )
{
osgUtil::CullVisitor* cv = 0L;
if ( nv.getVisitorType() == osg::NodeVisitor::CULL_VISITOR )
{
cv = Culling::asCullVisitor(nv);
// make sure that we're NOT using the AutoTransform if this node is in the decluttering bin;
// the decluttering bin automatically manages screen space transformation.
bool declutter = cv->getCurrentRenderBin()->getName() == OSGEARTH_DECLUTTER_BIN;
if ( declutter && _switch->getValue(0) == 1 )
{
_switch->setSingleChildOn( 1 );
}
else if ( !declutter && _switch->getValue(0) == 0 )
{
_switch->setSingleChildOn( 0 );
}
// If decluttering is enabled, update the auto-transform but not its children.
// This is necessary to support picking/selection. An optimization would be to
// disable this pass when picking is not in use
if ( declutter )
{
static_cast<AnnotationUtils::OrthoNodeAutoTransform*>(_autoxform)->acceptCullNoTraverse( cv );
}
// turn off small feature culling
cv->setSmallFeatureCullingPixelSize(0.0f);
AnnotationNode::traverse( nv );
if ( this->getCullingActive() == false )
this->setCullingActive( true );
}
// For an intersection visitor, ALWAYS traverse the autoxform instead of the
// matrix transform. The matrix transform is only used in combination with the
// decluttering engine, so it cannot properly support picking of decluttered
// objects
else if (
nv.getVisitorType() == osg::NodeVisitor::NODE_VISITOR &&
dynamic_cast<osgUtil::IntersectionVisitor*>( &nv ) )
{
if ( static_cast<AnnotationUtils::OrthoNodeAutoTransform*>(_autoxform)->okToIntersect() )
{
_autoxform->accept( nv );
}
}
else
{
AnnotationNode::traverse( nv );
}
}
void
OverlayDecorator::traverse( osg::NodeVisitor& nv )
{
if ( _overlayGraph.valid() && _textureUnit.isSet() )
{
// in the CULL traversal, find the per-view data associated with the
// cull visitor's current camera view and work with that:
if ( nv.getVisitorType() == nv.CULL_VISITOR )
{
osgUtil::CullVisitor* cv = static_cast<osgUtil::CullVisitor*>( &nv );
osg::Camera* camera = cv->getCurrentCamera();
if ( camera != 0L && (_rttTraversalMask & nv.getTraversalMask()) != 0 )
{
PerViewData& pvd = getPerViewData( camera );
if (checkNeedsUpdate(pvd))
{
updateRTTCamera(pvd);
}
if ( pvd._texGen.valid() )
{
// FFP path only
cv->getCurrentRenderBin()->getStage()->addPositionedTextureAttribute(
*_textureUnit, cv->getModelViewMatrix(), pvd._texGen.get() );
}
cull( cv, pvd );
pvd._rttCamera->accept( nv );
}
else
{
osg::Group::traverse(nv);
}
// debug-- (draws the overlay at its native location as well)
//_overlayGraph->accept(nv);
}
else
{
// Some other type of visitor (like update or intersection). Skip the RTT camera
// and traverse the overlay graph directly.
if ( _overlayGraph.valid() )
{
_overlayGraph->accept( nv );
}
osg::Group::traverse( nv );
}
}
else
{
osg::Group::traverse( nv );
}
}
void
SilverLiningContextNode::traverse(osg::NodeVisitor& nv)
{
if ( _SL && _SL->ready() )
{
if ( nv.getVisitorType() == nv.UPDATE_VISITOR )
{
int frameNumber = nv.getFrameStamp()->getFrameNumber();
_skyDrawable->dirtyBound();
if( _cloudsDrawable )
{
if ( _lastAltitude <= *_options.cloudsMaxAltitude() )
{
if ( _cloudsDrawable->getNumParents() == 0 )
_geode->addDrawable( _cloudsDrawable.get() );
_cloudsDrawable->dirtyBound();
}
else
{
if ( _cloudsDrawable->getNumParents() > 0 )
_geode->removeDrawable( _cloudsDrawable.get() );
}
}
}
else if ( nv.getVisitorType() == nv.CULL_VISITOR )
{
osgUtil::CullVisitor* cv = Culling::asCullVisitor(nv);
osg::Camera* camera = cv->getCurrentCamera();
if ( camera )
{
#ifndef SL_USE_CULL_MASK
//Check if this is the target camera for this context
if(getTargetCamera() == camera)
#endif
{
// TODO: make this multi-camera safe
_SL->setCameraPosition( nv.getEyePoint() );
_lastAltitude = _SL->getSRS()->isGeographic() ?
cv->getEyePoint().length() - _SL->getSRS()->getEllipsoid()->getRadiusEquator() :
cv->getEyePoint().z();
_SL->updateLocation();
_SL->updateLight();
}
}
}
}
if ( _geode.valid() )
{
_geode->accept(nv);
}
}
void
TritonNode::traverse(osg::NodeVisitor& nv)
{
if ( nv.getVisitorType() == nv.UPDATE_VISITOR && _TRITON->ready() )
{
_TRITON->update(nv.getFrameStamp()->getSimulationTime());
}
osgEarth::Util::OceanNode::traverse(nv);
}
void
GeoCell::traverse( osg::NodeVisitor& nv )
{
bool isCull = nv.getVisitorType() == osg::NodeVisitor::CULL_VISITOR;
if ( _depth > 0 )
{
if ( isCull )
{
// process boundary geometry, if present.
if ( _boundaryGeode.valid() )
{
if ( _count > 0 )
(*_boundaryColor)[0].set(1,0,0,0.35);
else
(*_boundaryColor)[0].set(1,1,1,0.25);
_boundaryColor->dirty();
_boundaryGeode->accept( nv );
}
// custom BSP culling function. this checks that the set of boundary points
// for this cell intersects the viewing frustum.
osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>( &nv );
if ( cv && !intersects( cv->getCurrentCullingSet().getFrustum() ) )
{
return;
}
// passed cull, so record the framestamp.
_frameStamp = cv->getFrameStamp()->getFrameNumber();
}
if ( _objects.size() > 0 )
{
for( GeoObjectCollection::iterator i = _objects.begin(); i != _objects.end(); ++i )
{
osg::Node* node = i->second->getNode();
if ( node )
node->accept( nv );
}
}
if ( _clusterGeode.valid() )
_clusterGeode->accept( nv );
}
else
{
if ( isCull )
_frameStamp = nv.getFrameStamp()->getFrameNumber();
}
osg::LOD::traverse( nv );
}
void Terrain::traverse(osg::NodeVisitor &nv)
{
if (nv.getVisitorType() == osg::NodeVisitor::UPDATE_VISITOR)
{
// need to check if any TerrainTechniques need to have their update called on them.
osgUtil::UpdateVisitor *uv = dynamic_cast<osgUtil::UpdateVisitor*>(&nv);
if (uv)
{
typedef std::list<osg::ref_ptr<TerrainTile> > TerrainTileList;
TerrainTileList tiles;
{
OpenThreads::ScopedLock<OpenThreads::ReentrantMutex> lock(_mutex);
for (TerrainTileSet::iterator itr = _updateTerrainTileSet.begin(); itr != _updateTerrainTileSet.end(); ++itr)
{
// take a reference first to make sure that the referenceCount can be safely read without another thread decrementing it to zero.
(*itr)->ref();
// only if referenceCount is 2 or more indicating there is still a reference held elsewhere is it safe to add it to list of tiles to be updated
if ((*itr)->referenceCount() > 1)
tiles.push_back(*itr);
// use unref_nodelete to avoid any issues when the *itr TerrainTile has been deleted by another thread while this for loop has been running.
(*itr)->unref_nodelete();
}
_updateTerrainTileSet.clear();
}
for (TerrainTileList::iterator itr = tiles.begin();
itr != tiles.end();
++itr)
{
TerrainTile *tile = itr->get();
tile->traverse(nv);
}
}
}
if (nv.getVisitorType() == osg::NodeVisitor::CULL_VISITOR)
{
osgUtil::CullVisitor *cv = dynamic_cast<osgUtil::CullVisitor*>(&nv);
osg::StateSet *ss = _geometryPool.valid() ? _geometryPool->getRootStateSetForTerrain(this) : 0;
if (cv && ss)
{
cv->pushStateSet(ss);
Group::traverse(nv);
cv->popStateSet();
return;
}
}
Group::traverse(nv);
}
void
TilePagedLOD::traverse(osg::NodeVisitor& nv)
{
if (_progress.valid() &&
nv.getVisitorType() == nv.CULL_VISITOR &&
nv.getFrameStamp() )
{
_progress->update( nv.getFrameStamp()->getFrameNumber() );
}
osg::PagedLOD::traverse(nv);
}
void VisibilityGroup::traverse(osg::NodeVisitor &nv)
{
if (nv.getTraversalMode() == osg::NodeVisitor::TRAVERSE_ACTIVE_CHILDREN && nv.getVisitorType() == osg::NodeVisitor::CULL_VISITOR)
{
// cast to cullvisitor
osgUtil::CullVisitor &cv = (osgUtil::CullVisitor&) nv;
// here we test if we are inside the visibilityvolume
// first get the eyepoint and in local coordinates
osg::Vec3 eye = cv.getEyeLocal();
osg::Vec3 look = cv.getLookVectorLocal();
// now scale the segment to the segment length - if 0 use the group bounding sphere radius
float length = _segmentLength;
if (length == 0.f)
length = 2.0f * getBound().radius();
look *= length;
osg::Vec3 center = eye + look;
osg::Vec3 seg = center - eye;
// perform the intersection using the given mask
osgUtil::IntersectVisitor iv;
osg::ref_ptr<osg::LineSegment> lineseg = new osg::LineSegment;
lineseg->set(eye, center);
iv.addLineSegment(lineseg.get());
iv.setTraversalMask(_volumeIntersectionMask);
if (_visibilityVolume.valid())
_visibilityVolume->accept(iv);
// now examine the hit record
if (iv.hits())
{
osgUtil::IntersectVisitor::HitList &hitList = iv.getHitList(lineseg.get());
if (!hitList.empty()) // we actually hit something
{
// OSG_INFO << "Hit obstruction"<< std::endl;
osg::Vec3 normal = hitList.front().getWorldIntersectNormal();
if ((normal * seg) > 0.f) // we are inside
Group::traverse(nv);
}
}
}
else
{
Group::traverse(nv);
}
}
void
GeoCell::traverse( osg::NodeVisitor& nv )
{
bool isCull = nv.getVisitorType() == osg::NodeVisitor::CULL_VISITOR;
if ( _depth > 0 )
{
if ( isCull )
{
// process boundary geometry, if present.
if ( _boundaryGeode.valid() )
{
if ( _count > 0 )
(*_boundaryColor)[0].set(1,0,0,0.35);
else
(*_boundaryColor)[0].set(1,1,1,0.25);
_boundaryColor->dirty();
_boundaryGeode->accept( nv );
}
osgUtil::CullVisitor* cv = Culling::asCullVisitor(nv);
if ( cv )
{
// passed cull, so record the framestamp.
_frameStamp = cv->getFrameStamp()->getFrameNumber();
}
}
if ( _objects.size() > 0 )
{
for( GeoObjectCollection::iterator i = _objects.begin(); i != _objects.end(); ++i )
{
osg::Node* node = i->second->getNode();
if ( node )
node->accept( nv );
}
}
if ( _clusterGeode.valid() )
_clusterGeode->accept( nv );
}
else
{
if ( isCull )
_frameStamp = nv.getFrameStamp()->getFrameNumber();
}
osg::LOD::traverse( nv );
}
void Widget::traverseImplementation(osg::NodeVisitor& nv)
{
if (!_graphicsInitialized && nv.getVisitorType()!=osg::NodeVisitor::CULL_VISITOR) createGraphics();
osgGA::EventVisitor* ev = dynamic_cast<osgGA::EventVisitor*>(&nv);
if (ev)
{
if (_visible && _enabled)
{
updateFocus(nv);
// OSG_NOTICE<<"EventTraversal getHasEventFocus()="<<getHasEventFocus()<<std::endl;
// signify that event has been taken by widget with focus
osgGA::EventQueue::Events& events = ev->getEvents();
for(osgGA::EventQueue::Events::iterator itr = events.begin();
itr != events.end();
++itr)
{
if (handle(ev, itr->get()))
{
(*itr)->setHandled(true);
ev->setEventHandled(true);
}
}
osg::Group::traverse(nv);
}
}
else if (_visible ||
(nv.getVisitorType()!=osg::NodeVisitor::UPDATE_VISITOR && nv.getVisitorType()!=osg::NodeVisitor::CULL_VISITOR && nv.getVisitorType()!=osg::NodeVisitor::INTERSECTION_VISITOR) )
{
GraphicsSubgraphMap::iterator itr = _graphicsSubgraphMap.begin();
while(itr!= _graphicsSubgraphMap.end() && itr->first<=0)
{
itr->second->accept(nv);
++itr;
}
Group::traverse(nv);
while(itr!= _graphicsSubgraphMap.end())
{
itr->second->accept(nv);
++itr;
}
}
}
void
TileNode::load(osg::NodeVisitor& nv)
{
// Access the context:
EngineContext* context = static_cast<EngineContext*>( nv.getUserData() );
// Create a new load request on demand:
if ( !_loadRequest.valid() )
{
Threading::ScopedMutexLock lock(_mutex);
if ( !_loadRequest.valid() )
{
_loadRequest = new LoadTileData( this, context );
_loadRequest->setName( _key.str() );
_loadRequest->setTileKey( _key );
}
}
#if 0
double range0, range1;
int lod = getTileKey().getLOD();
if ( lod > context->getOptions().firstLOD().get() )
range0 = context->getSelectionInfo().visParameters(lod-1)._visibilityRange;
else
range0 = 0.0;
double range1 = context->getSelectionInfo().visParameters(lod)._visibilityRange;
priority =
#endif
// Prioritize by LOD. (negated because lower order gets priority)
float priority = - (float)getTileKey().getLOD();
if ( context->getOptions().highResolutionFirst() == true )
{
priority = context->getSelectionInfo().numLods() - priority;
//priority = -priority;
}
// then sort by distance within each LOD.
float distance = nv.getDistanceToViewPoint( getBound().center(), true );
priority = 10.0f*priority - log10(distance);
// testing intermediate loading idea...
//if ( getTileKey().getLOD() == 5 )
// priority += 100.0f;
// Submit to the loader.
context->getLoader()->load( _loadRequest.get(), priority, nv );
}
void
DrapeableNode::traverse( osg::NodeVisitor& nv )
{
if ( !_overlayProxyContainer.valid() )
{
osg::Group::traverse( nv );
}
else
{
if ( nv.getVisitorType() == osg::NodeVisitor::CULL_VISITOR )
{
if ( _draped )
{
// for a draped node, inform the proxy that we are visible. But do NOT traverse the
// child graph (since it will be traversed by the OverlayDecorator).
CullNodeByFrameNumber* cb = static_cast<CullNodeByFrameNumber*>(_overlayProxyContainer->getCullCallback());
if (cb)
{
cb->_frame = nv.getFrameStamp()->getFrameNumber();
}
}
else
{
// for a non-draped node, just traverse children as usual.
osg::Group::traverse( nv );
}
}
else if ( nv.getVisitorType() == osg::NodeVisitor::UPDATE_VISITOR )
{
if ( _dirty )
{
applyChanges();
_dirty = false;
ADJUST_UPDATE_TRAV_COUNT( this, -1 );
}
// traverse children directly, regardles of draped status
osg::Group::traverse( nv );
}
// handle other visitor types (like intersections, etc) by simply
// traversing the child graph.
else // if ( nv.getNodeVisitor() == osg::NodeVisitor::NODE_VISITOR )
{
osg::Group::traverse( nv );
}
}
}
void MultiPassTerrainTechnique::traverse(osg::NodeVisitor& nv)
{
if (!_tile) return;
// initialize the terrain tile on startup
if (_tile->getDirty() && !_terrainTileInitialized)
{
_tile->init();
_terrainTileInitialized = true;
#if 0
#if OSG_MIN_VERSION_REQUIRED(2,9,8)
_terrainTile->init(~0x0, true);
#else
_terrainTile->init();
#endif
_terrainTileInitialized = true;
#endif
}
if ( nv.getVisitorType() == osg::NodeVisitor::CULL_VISITOR )
{
updateTransparency();
}
// traverse the dynamically-generated geometry.
if (_transform.valid())
_transform->accept(nv);
}
void
TerrainNode::traverse( osg::NodeVisitor &nv )
{
if ( nv.getVisitorType() == nv.UPDATE_VISITOR )
{
// if the terrain engine requested "quick release", install the quick release
// draw callback now.
if ( !_quickReleaseCallbackInstalled && _tilesToQuickRelease.valid() )
{
osg::Camera* cam = findFirstParentOfType<osg::Camera>( this );
if ( cam )
{
// get the installed PDC so we can nest them:
osg::Camera::DrawCallback* cbToNest = cam->getPostDrawCallback();
// if it's another QR callback, we'll just replace it.
QuickReleaseGLObjects* previousQR = dynamic_cast<QuickReleaseGLObjects*>(cbToNest);
if ( previousQR )
cbToNest = previousQR->_next.get();
cam->setPostDrawCallback( new QuickReleaseGLObjects(
_tilesToQuickRelease.get(),
cbToNest ) );
_quickReleaseCallbackInstalled = true;
OE_INFO << LC << "Quick release enabled" << std::endl;
// knock down the trav count set in the constructor.
ADJUST_UPDATE_TRAV_COUNT( this, -1 );
}
}
}
osg::Group::traverse( nv );
}
void ossimPlanetAnnotationLayer::traverse(osg::NodeVisitor& nv)
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(theGraphMutex);
switch(nv.getVisitorType())
{
case osg::NodeVisitor::UPDATE_VISITOR:
{
{
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(theNodesToRemoveListMutex);
ossimPlanetNode::NodeListType::iterator iter = theNodesToRemoveList.begin();
while(iter != theNodesToRemoveList.end())
{
ossimPlanetNode::remove((*iter).get());
++iter;
}
theNodesToRemoveList.clear();
}
break;
}
default:
{
break;
}
}
ossimPlanetLayer::traverse(nv);
}
void
TilePagedLOD::traverse(osg::NodeVisitor& nv)
{
// Only traverse the TileNode if our neighbors (the other members of
// our group of four) are ready as well.
if ( _children.size() > 0 )
{
_children[0]->setNodeMask( _familyReady ? ~0 : 0 );
// find our tile node:
TileNode* tilenode = dynamic_cast<TileGroup*>(_children[0].get()) ?
static_cast<TileGroup*>(_children[0].get())->getTileNode() :
static_cast<TileNode*>(_children[0].get());
// Check whether the TileNode is marked dirty. If so, install a new pager request
// to reload and replace the TileNode.
if (nv.getVisitorType() == nv.CULL_VISITOR &&
this->getNumFileNames() < 2 &&
tilenode->isOutOfDate() )
{
// lock keeps multiple CullVisitors from doing the same thing
Threading::ScopedMutexLock exclusive( _updateMutex );
if ( this->getNumFileNames() < 2 ) // double-check pattern
{
//OE_WARN << LC << "Queuing request for replacement: " << _container->getTileNode()->getKey().str() << std::endl;
this->setFileName( 1, Stringify() << _prefix << ".osgearth_engine_mp_standalone_tile" );
this->setRange( 1, 0, FLT_MAX );
}
}
}
osg::PagedLOD::traverse( nv );
}
void ossimPlanetLayer::traverse(osg::NodeVisitor& nv)
{
switch(nv.getVisitorType())
{
case osg::NodeVisitor::EVENT_VISITOR:
{
if(redrawFlag())
{
osgGA::EventVisitor* ev = dynamic_cast<osgGA::EventVisitor*>(&nv);
if(ev)
{
if(ev->getActionAdapter())
{
ev->getActionAdapter()->requestRedraw();
setRedrawFlag(false);
}
}
}
return;
}
case osg::NodeVisitor::UPDATE_VISITOR:
{
if(!thePlanet)
{
setPlanet(ossimPlanet::findPlanet(this));
}
break;
}
default:
{
}
}
ossimPlanetNode::traverse(nv);
}
void
AnnotationNode::traverse(osg::NodeVisitor& nv)
{
if (nv.getVisitorType() == nv.UPDATE_VISITOR)
{
// MapNode auto discovery.
if (_mapNodeRequired)
{
if (getMapNode() == 0L)
{
MapNode* mapNode = osgEarth::findInNodePath<MapNode>(nv);
if (mapNode)
{
setMapNode(mapNode);
}
}
if (getMapNode() != 0L)
{
_mapNodeRequired = false;
ADJUST_UPDATE_TRAV_COUNT(this, -1);
}
}
}
osg::Group::traverse(nv);
}
void
TerrainEngineNode::traverse( osg::NodeVisitor& nv )
{
if ( nv.getVisitorType() == osg::NodeVisitor::CULL_VISITOR )
{
if ( Registry::instance()->getCapabilities().supportsGLSL() )
{
_updateLightingUniformsHelper.cullTraverse( this, &nv );
osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>( &nv );
if ( cv )
{
osg::Vec3d eye = cv->getEyePoint();
float elevation;
if ( _map->isGeocentric() )
elevation = eye.length() - osg::WGS_84_RADIUS_EQUATOR;
else
elevation = eye.z();
_cameraElevationUniform->set( elevation );
}
}
}
//else if ( nv.getVisitorType() == osg::NodeVisitor::UPDATE_VISITOR )
//{
// if ( Registry::instance()->getCapabilities().supportsGLSL() )
// _updateLightingUniformsHelper.updateTraverse( this );
//}
osg::CoordinateSystemNode::traverse( nv );
}
void Technique::traverse_implementation(osg::NodeVisitor& nv, Effect* fx)
{
// define passes if necessary
if (_passes.empty()) {
define_passes();
}
// special actions must be taken if the node visitor is actually a CullVisitor
osgUtil::CullVisitor* cv = nv.asCullVisitor();
if (cv)
{
// traverse all passes
for (int i=0; i<getNumPasses(); ++i)
{
// push the i-th pass' StateSet
cv->pushStateSet(_passes[i].get());
// traverse the override node if defined, otherwise
// traverse children as a Group would do
osg::Node *override = getOverrideChild(i);
if (override) {
override->accept(nv);
} else {
fx->inherited_traverse(nv);
}
// pop the StateSet
cv->popStateSet();
}
void
StreamingTerrainNode::updateTraversal( osg::NodeVisitor& nv )
{
// this stamp keeps track of when requests are dispatched. If a request's stamp gets too
// old, it is considered "expired" and subject to cancelation
int stamp = nv.getFrameStamp()->getFrameNumber();
// update the frame stamp on the task services. This is necessary to support
// automatic request cancelation for image requests.
{
ScopedLock<Mutex> lock( _taskServiceMutex );
for (TaskServiceMap::iterator i = _taskServices.begin(); i != _taskServices.end(); ++i)
{
i->second->setStamp( stamp );
}
}
// next, go through the live tiles and process update-traversal requests. This
// requires a read-lock on the master tiles table.
{
Threading::ScopedReadLock tileTableReadLock( _tilesMutex );
for( TileTable::const_iterator i = _tiles.begin(); i != _tiles.end(); ++i )
{
StreamingTile* tile = static_cast<StreamingTile*>( i->second.get() );
// update the neighbor list for each tile.
refreshFamily( _update_mapf.getMapInfo(), tile->getKey(), tile->getFamily(), true );
tile->servicePendingElevationRequests( _update_mapf, stamp, true );
tile->serviceCompletedRequests( _update_mapf, true );
}
}
}
void
GraticuleLabelingEngine::traverse(osg::NodeVisitor& nv)
{
if (nv.getVisitorType() == nv.CULL_VISITOR)
{
osgUtil::CullVisitor* cv = dynamic_cast<osgUtil::CullVisitor*>(&nv);
if (cv)
{
// Find the data corresponding to this camera:
CameraData& data = _cameraDataMap.get(cv->getCurrentCamera());
bool visible = cullTraverse(*cv, data);
data.visible = visible;
if (visible)
{
// traverse all the labels for this camera:
AcceptCameraData accept(nv);
accept(data);
}
}
}
else
{
AcceptCameraData accept(nv);
_cameraDataMap.forEach(accept);
}
osg::Group::traverse(nv);
}
void
LabelNode::traverse(osg::NodeVisitor &nv)
{
if(_followFixedCourse)
{
osgUtil::CullVisitor* cv = NULL;
if ( nv.getVisitorType() == osg::NodeVisitor::CULL_VISITOR )
{
cv = Culling::asCullVisitor(nv);
osg::Camera* camera = cv->getCurrentCamera();
osg::Matrix matrix;
matrix.postMult(camera->getViewMatrix());
matrix.postMult(camera->getProjectionMatrix());
if (camera->getViewport())
matrix.postMult(camera->getViewport()->computeWindowMatrix());
GeoPoint pos( osgEarth::SpatialReference::get("wgs84"),
getPosition().x(),
getPosition().y(),
0,
osgEarth::ALTMODE_ABSOLUTE );
osg::Vec3d refOnWorld; pos.toWorld(refOnWorld);
osg::Vec3d projOnWorld; _geoPointProj.toWorld(projOnWorld);
osg::Vec3d refOnScreen = refOnWorld * matrix;
osg::Vec3d projOnScreen = projOnWorld * matrix;
projOnScreen -= refOnScreen;
_labelRotationRad = atan2 (projOnScreen.y(), projOnScreen.x());
if (_dataLayout.valid())
_dataLayout->setRotationRad(_labelRotationRad);
}
}
GeoPositionNode::traverse(nv);
}
void
TileNode::traverse(osg::NodeVisitor& nv)
{
// Cull only:
if ( nv.getVisitorType() == nv.CULL_VISITOR )
{
cull(nv);
}
// Everything else: update, GL compile, intersection, compute bound, etc.
else
{
// If there are child nodes, traverse them:
int numChildren = getNumChildren();
if ( numChildren > 0 )
{
for(int i=0; i<numChildren; ++i)
{
_children[i]->accept( nv );
}
}
// Otherwise traverse the surface.
// TODO: in what situations should we traverse the landcover as well? GL compile?
else
{
_surface->accept( nv );
}
}
}
void Horizon3DTileNode2::traverse(osg::NodeVisitor &nv)
{
if(nv.getVisitorType()==osg::NodeVisitor::CULL_VISITOR)
{
_nodes.at(0)->accept(nv);
}
}
void
GeometryPool::traverse(osg::NodeVisitor& nv)
{
if (nv.getVisitorType() == nv.UPDATE_VISITOR && _releaser.valid() && _enabled)
{
// look for usused pool objects and push them to the resource releaser.
ResourceReleaser::ObjectList objects;
{
Threading::ScopedMutexLock exclusive( _geometryMapMutex );
std::vector<GeometryKey> keys;
for (GeometryMap::iterator i = _geometryMap.begin(); i != _geometryMap.end(); ++i)
{
if (i->second.get()->referenceCount() == 1)
{
keys.push_back(i->first);
objects.push_back(i->second.get());
}
}
for (std::vector<GeometryKey>::iterator key = keys.begin(); key != keys.end(); ++key)
{
_geometryMap.erase(*key);
}
}
if (!objects.empty())
{
_releaser->push(objects);
}
}
osg::Group::traverse(nv);
}
void ShadowMap::traverse( osg::NodeVisitor& nv )
{
if( ( nv.getVisitorType() != osg::NodeVisitor::CULL_VISITOR ) )
{
// Not the cull visitor. Traverse as a Group and return.
osg::Group::traverse( nv );
return;
}
// Dealing with cull traversal from this point onwards.
osgUtil::CullVisitor* cv = static_cast< osgUtil::CullVisitor* >( &nv );
// BackdropCommon cull processing.
processCull( cv );
//
// Basic idea of what follows was derived from CullVisitor::apply( Camera& ).
//
osgUtil::RenderStage* previousStage = cv->getCurrentRenderBin()->getStage();
osg::Camera* camera = previousStage->getCamera();
osg::ref_ptr< RenderStageCache > rsCache = dynamic_cast< RenderStageCache* >( getRenderingCache() );
if( !rsCache )
{
rsCache = new RenderStageCache;
UTIL_MEMORY_CHECK( rsCache, "ShadowMap ShadowMapStage Cache", );
setRenderingCache( rsCache.get() );
}