void Tile::setCustomColorLayer( const CustomColorLayer& layer, bool writeLock ) { if ( writeLock ) { Threading::ScopedWriteLock exclusiveTileLock( _tileLayersMutex ); setCustomColorLayer( layer, false ); } else { int delta = 0; ColorLayersByUID::const_iterator i = _colorLayers.find( layer.getUID() ); if ( i != _colorLayers.end() && i->second.getMapLayer()->isDynamic() ) --delta; _colorLayers[layer.getUID()] = layer; if ( layer.getMapLayer()->isDynamic() ) ++delta; if ( delta != 0 ) ADJUST_UPDATE_TRAV_COUNT( this, delta ); } }
// called from the UPDATE TRAVERSAL, because this method can potentially alter // the scene graph. bool StreamingTile::serviceCompletedRequests( const MapFrame& mapf, bool tileTableLocked ) { //Don't do anything until we have been added to the scene graph if (!_hasBeenTraversed) return false; bool tileModified = false; if ( !_requestsInstalled ) return false; // First service the tile generator: if ( _tileGenRequest.valid() && _tileGenRequest->isCompleted() ) { CustomTerrainTechnique* tech = dynamic_cast<CustomTerrainTechnique*>( getTerrainTechnique() ); if ( tech ) { //TODO: consider waiting to apply if there are still more tile updates in the queue. if ( _tileUpdates.size() == 0 ) { tileModified = tech->applyTileUpdates(); } } _tileGenRequest = 0L; } // now deal with imagery. const LoadingPolicy& lp = getStreamingTerrain()->getLoadingPolicy(); StreamingTerrainNode* terrain = getStreamingTerrain(); //Check each layer independently. for( ImageLayerVector::const_iterator i = mapf.imageLayers().begin(); i != mapf.imageLayers().end(); ++i ) { ImageLayer* imageLayer = i->get(); bool checkForFinalImagery = false; CustomColorLayer colorLayer; if ( getCustomColorLayer( imageLayer->getUID(), colorLayer ) ) { if ( lp.mode() == LoadingPolicy::MODE_PREEMPTIVE ) { // in preemptive mode, always check for the final imagery - there are no intermediate // placeholders. checkForFinalImagery = true; } else if (lp.mode() == LoadingPolicy::MODE_SEQUENTIAL && readyForNewImagery(imageLayer, colorLayer.getLevelOfDetail()) ) { // in sequential mode, we have to incrementally increase imagery resolution by // creating placeholders based of parent tiles, one LOD at a time. if ( colorLayer.getLevelOfDetail() + 1 < (int)_key.getLevelOfDetail() ) { // if the parent's image LOD is higher than ours, replace ours with the parent's // since it is a higher-resolution placeholder: if ( _family[Relative::PARENT].getImageLOD(colorLayer.getUID()) > colorLayer.getLevelOfDetail() ) { osg::ref_ptr<Tile> parentTile; getStreamingTerrain()->getTile( _family[Relative::PARENT].tileID, parentTile, !tileTableLocked ); // Set the color layer to the parent color layer as a placeholder. CustomColorLayer parentColorLayer; if ( parentTile->getCustomColorLayer( colorLayer.getUID(), parentColorLayer ) ) { this->setCustomColorLayer( parentColorLayer ); } // ... and queue up an update request. queueTileUpdate( TileUpdate::UPDATE_IMAGE_LAYER, colorLayer.getUID() ); } } else { // we've gone as far as we can with placeholders; time to check for the // final imagery tile. checkForFinalImagery = true; } } } if ( checkForFinalImagery ) { // Then the image requests: for( TaskRequestList::iterator itr = _requests.begin(); itr != _requests.end(); ) { bool increment = true; TileColorLayerRequest* r = static_cast<TileColorLayerRequest*>( itr->get() ); //We only care about the current layer we are checking if ( r->_layerUID == imageLayer->getUID() ) { if ( itr->get()->isCompleted() ) { if ( r->wasCanceled() ) { //Reset the cancelled task to IDLE and give it a new progress callback. r->setState( TaskRequest::STATE_IDLE ); r->setProgressCallback( new StampedProgressCallback( r, terrain->getImageryTaskService( r->_layerUID ))); r->reset(); } else // success.. { //See if we even care about the request if ( !mapf.getImageLayerByUID( r->_layerUID ) ) { //The maplayer was probably deleted OE_DEBUG << "Layer uid=" << r->_layerUID << " no longer exists, ignoring TileColorLayerRequest " << std::endl; itr = _requests.erase(itr); increment = false; } else { CustomColorLayerRef* result = static_cast<CustomColorLayerRef*>( r->getResult() ); if ( result ) { this->setCustomColorLayer( result->_layer ); queueTileUpdate( TileUpdate::UPDATE_IMAGE_LAYER, r->_layerUID ); //OE_NOTICE << "Complete IR (" << _key.str() << ") layer=" << r->_layerId << std::endl; // remove from the list (don't reference "r" after this!) itr = _requests.erase( itr ); increment = false; } else { if (r->_numTries > r->_maxTries) { CustomColorLayer oldLayer; if ( this->getCustomColorLayer( r->_layerUID, oldLayer ) ) { // apply the old color layer but with a new LOD. this->setCustomColorLayer( CustomColorLayer( oldLayer.getMapLayer(), oldLayer.getImage(), oldLayer.getLocator(), _key.getLevelOfDetail(), _key )); itr = _requests.erase( itr ); increment = false; OE_DEBUG << "Tried (" << _key.str() << ") (layer uid=" << r->_layerUID << "), too many times, moving on...." << std::endl; } } else { OE_DEBUG << "IReq error (" << _key.str() << ") (layer uid=" << r->_layerUID << "), retrying" << std::endl; //The color layer request failed, probably due to a server error. Reset it. r->setState( TaskRequest::STATE_IDLE ); r->reset(); } } } } } } if ( increment ) ++itr; } } } // Finally, the elevation requests: if ( _hasElevation && !_elevationLayerUpToDate && _elevRequest.valid() && _elevPlaceholderRequest.valid() ) { // First, check is the Main elevation request is done. If so, we will now have the final HF data // and can shut down the elevation requests for this tile. if ( _elevRequest->isCompleted() ) { if ( _elevRequest->wasCanceled() ) { // If the request was canceled, reset it to IDLE and reset the callback. On the next _elevRequest->setState( TaskRequest::STATE_IDLE ); _elevRequest->setProgressCallback( new ProgressCallback() ); _elevRequest->reset(); } else // success: { // if the elevation request succeeded, install the new elevation layer! TileElevationLayerRequest* r = static_cast<TileElevationLayerRequest*>( _elevRequest.get() ); osg::ref_ptr<osgTerrain::HeightFieldLayer> newHFLayer = static_cast<osgTerrain::HeightFieldLayer*>( r->getResult() ); if ( newHFLayer.valid() && newHFLayer->getHeightField() != NULL ) { newHFLayer->getHeightField()->setSkirtHeight( terrain->getTileFactory()->getTerrainOptions().heightFieldSkirtRatio().get() * this->getBound().radius() ); // need to write-lock the layer data since we'll be changing it: { Threading::ScopedWriteLock lock( _tileLayersMutex ); this->setElevationLayer( newHFLayer.get() ); this->dirtyBound(); } // the tile needs rebuilding. This will kick off a TileGenRequest. queueTileUpdate( TileUpdate::UPDATE_ELEVATION ); // finalize the LOD marker for this tile, so other tiles can see where we are. _elevationLOD = _key.getLevelOfDetail(); #ifdef PREEMPTIVE_DEBUG OE_NOTICE << "Tile (" << _key.str() << ") final HF, LOD (" << _elevationLOD << ")" << std::endl; #endif // this was the final elev request, so mark elevation as DONE. _elevationLayerUpToDate = true; // GW- just reset these and leave them alone and let cancelRequests() take care of cleanup later. // done with our Elevation requests! //_elevRequest = 0L; //_elevPlaceholderRequest = 0L; } else { //We've tried to get the tile's elevation but couldn't. Just mark the elevation layer as up to date and move on. _elevationLOD = _key.getLevelOfDetail(); _elevationLayerUpToDate = true; //This code will retry indefinitely. We need to have a way to limit the number of retries since //it will block neighbor tiles from loading. //_elevRequest->setState( TaskRequest::STATE_IDLE ); //_elevRequest->reset(); } } } else if ( _elevPlaceholderRequest->isCompleted() ) { TileElevationPlaceholderLayerRequest* r = static_cast<TileElevationPlaceholderLayerRequest*>(_elevPlaceholderRequest.get()); if ( r->wasCanceled() ) { r->setState( TaskRequest::STATE_IDLE ); r->setProgressCallback( new ProgressCallback() ); r->reset(); } else // success: { osg::ref_ptr<osgTerrain::HeightFieldLayer> newPhLayer = static_cast<osgTerrain::HeightFieldLayer*>( r->getResult() ); if ( newPhLayer.valid() && newPhLayer->getHeightField() != NULL ) { // install the new elevation layer. { Threading::ScopedWriteLock lock( _tileLayersMutex ); this->setElevationLayer( newPhLayer.get() ); this->dirtyBound(); } // tile needs to be recompiled. queueTileUpdate( TileUpdate::UPDATE_ELEVATION ); // update the elevation LOD for this tile, now that the new HF data is installed. This will // allow other tiles to see where this tile's HF data is. _elevationLOD = r->_nextLOD; #ifdef PREEMPTIVE_DEBUG OE_NOTICE << "..tile (" << _key.str() << ") is now at (" << _elevationLOD << ")" << std::endl; #endif } _elevPlaceholderRequest->setState( TaskRequest::STATE_IDLE ); _elevPlaceholderRequest->reset(); } } } // if we have a new TileGenRequest, queue it up now. if ( _tileUpdates.size() > 0 && !_tileGenRequest.valid() ) // _tileGenNeeded && !_tileGenRequest.valid()) { _tileGenRequest = new TileGenRequest( this, _tileUpdates.front() ); _tileUpdates.pop(); //OE_NOTICE << "tile (" << _key.str() << ") queuing new tile gen" << std::endl; getStreamingTerrain()->getTileGenerationTaskService()->add( _tileGenRequest.get() ); } return tileModified; }