void
OSGTerrainEngineNode::addElevationLayer( ElevationLayer* layer )
{
if ( !layer )
return;
layer->addCallback( _elevationCallback.get() );
if (!_isStreaming)
{
refresh();
}
else
{
TileVector tiles;
_terrain->getTiles( tiles );
OE_DEBUG << LC << "Found " << tiles.size() << std::endl;
for (TileVector::iterator itr = tiles.begin(); itr != tiles.end(); ++itr)
{
updateElevation( itr->get() );
}
}
}
void
TerrainNode::getTiles( TileVector& out )
{
Threading::ScopedReadLock lock( _tilesMutex );
out.clear();
out.reserve( _tiles.size() );
for( TileTable::const_iterator i = _tiles.begin(); i != _tiles.end(); ++i )
out.push_back( i->second.get() );
}
void
OSGTerrainEngineNode::removeElevationLayer( ElevationLayer* layerRemoved )
{
TileVector tiles;
_terrain->getTiles( tiles );
for (TileVector::iterator itr = tiles.begin(); itr != tiles.end(); ++itr)
{
updateElevation( itr->get() );
}
}
void
OSGTerrainEngineNode::moveElevationLayer( unsigned int oldIndex, unsigned int newIndex )
{
TileVector tiles;
_terrain->getTiles( tiles );
OE_DEBUG << "Found " << tiles.size() << std::endl;
for (TileVector::iterator itr = tiles.begin(); itr != tiles.end(); ++itr)
{
updateElevation( itr->get() );
}
}
void
OSGTerrainEngineNode::moveImageLayer( unsigned int oldIndex, unsigned int newIndex )
{
// take a thread-safe copy of the tile table
TileVector tiles;
_terrain->getTiles( tiles );
for (TileVector::iterator itr = tiles.begin(); itr != tiles.end(); ++itr)
{
Tile* tile = itr->get();
tile->applyImmediateTileUpdate( TileUpdate::MOVE_IMAGE_LAYER );
}
updateTextureCombining();
}
void
OSGTerrainEngineNode::addElevationLayer( ElevationLayer* layer )
{
if ( !layer || !layer->getTileSource() )
return;
TileVector tiles;
_terrain->getTiles( tiles );
OE_DEBUG << LC << "Found " << tiles.size() << std::endl;
for (TileVector::iterator itr = tiles.begin(); itr != tiles.end(); ++itr)
{
updateElevation( itr->get() );
}
}
void
OSGTerrainEngineNode::removeImageLayer( ImageLayer* layerRemoved )
{
// make a thread-safe copy of the tile table
TileVector tiles;
_terrain->getTiles( tiles );
for (TileVector::iterator itr = tiles.begin(); itr != tiles.end(); ++itr)
{
Tile* tile = itr->get();
// critical section
tile->removeCustomColorLayer( layerRemoved->getUID() );
}
updateTextureCombining();
}
void
OSGTerrainEngineNode::removeElevationLayer( ElevationLayer* layerRemoved )
{
layerRemoved->removeCallback( _elevationCallback.get() );
if (!_isStreaming)
{
refresh();
}
else
{
TileVector tiles;
_terrain->getTiles( tiles );
for (TileVector::iterator itr = tiles.begin(); itr != tiles.end(); ++itr)
{
updateElevation( itr->get() );
}
}
}
void
QuadTreeTerrainEngineNode::moveElevationLayer( unsigned int oldIndex, unsigned int newIndex )
{
if (!_isStreaming)
{
refresh();
}
else
{
TileVector tiles;
_terrain->getTiles( tiles );
OE_DEBUG << "Found " << tiles.size() << std::endl;
for (TileVector::iterator itr = tiles.begin(); itr != tiles.end(); ++itr)
{
updateElevation( itr->get() );
}
}
}
void
OSGTerrainEngineNode::addImageLayer( ImageLayer* layerAdded )
{
if ( !layerAdded )
return;
if (!_isStreaming)
{
refresh();
}
else
{
// visit all existing terrain tiles and inform each one of the new image layer:
TileVector tiles;
_terrain->getTiles( tiles );
for( TileVector::iterator itr = tiles.begin(); itr != tiles.end(); ++itr )
{
Tile* tile = itr->get();
StreamingTile* streamingTile = 0L;
GeoImage geoImage;
bool needToUpdateImagery = false;
int imageLOD = -1;
if ( !_isStreaming || tile->getKey().getLevelOfDetail() == 1 )
{
// in standard mode, or at the first LOD in seq/pre mode, fetch the image immediately.
TileKey geoImageKey = tile->getKey();
_tileFactory->createValidGeoImage( layerAdded, tile->getKey(), geoImage, geoImageKey );
imageLOD = tile->getKey().getLevelOfDetail();
}
else
{
// in seq/pre mode, set up a placeholder and mark the tile as dirty.
geoImage = GeoImage(ImageUtils::createEmptyImage(), tile->getKey().getExtent() );
needToUpdateImagery = true;
streamingTile = static_cast<StreamingTile*>(tile);
}
if (geoImage.valid())
{
const MapInfo& mapInfo = _update_mapf->getMapInfo();
double img_min_lon, img_min_lat, img_max_lon, img_max_lat;
geoImage.getExtent().getBounds(img_min_lon, img_min_lat, img_max_lon, img_max_lat);
//Specify a new locator for the color with the coordinates of the TileKey that was actually used to create the image
osg::ref_ptr<GeoLocator> img_locator = tile->getKey().getProfile()->getSRS()->createLocator(
img_min_lon, img_min_lat, img_max_lon, img_max_lat,
!mapInfo.isGeocentric() );
//Set the CS to geocentric if we are dealing with a geocentric map
if ( mapInfo.isGeocentric() )
{
img_locator->setCoordinateSystemType( osgTerrain::Locator::GEOCENTRIC );
}
tile->setCustomColorLayer( CustomColorLayer(
layerAdded,
geoImage.getImage(),
img_locator.get(), imageLOD, tile->getKey() ) );
// if necessary, tell the tile to queue up a new imagery request (since we
// just installed a placeholder)
if ( needToUpdateImagery )
{
streamingTile->updateImagery( layerAdded, *_update_mapf, _tileFactory.get() );
}
}
else
{
// this can happen if there's no data in the new layer for the given tile.
// we will rely on the driver to dump out a warning if this is an error.
}
tile->applyImmediateTileUpdate( TileUpdate::ADD_IMAGE_LAYER, layerAdded->getUID() );
}
updateTextureCombining();
}
}
inline
void SchoolFish::applyAvoidance(Vector &accumulator)
{
// only avoid the player if not in the background
if (this->layer < LR_ELEMENTS10)
{
if ((dsq->game->avatar->position - this->position).isLength2DIn(128))
{
avoid(accumulator, dsq->game->avatar->position);
}
}
//return;
if (avoidTime>0) return;
VectorSet closestObs;
VectorSet obsPos;
//Vector closestObs;
int range = 10;
int radius = range*TILE_SIZE;
Vector p;
TileVector t0(position);
TileVector t;
for (int x = -range; x <= range; x++)
{
for (int y = -range; y <= range; y++)
{
TileVector t = t0;
t.x+=x;
t.y+=y;
if (dsq->game->isObstructed(t))
{
p = t.worldVector();
closestObs.push_back(this->position - p);
obsPos.push_back(p);
/*
std::ostringstream os;
os << "tile(" << t.x << ", " << t.y << ") p(" << p.x << ", " << p.y << ")";
debugLog(os.str());
*/
/*
int len = (p - this->position).getSquaredLength2D();
if (len < sqr(radius))
{
closestObs.push_back(this->position - p);
obsPos.push_back(p);
}
*/
}
}
}
if (!closestObs.empty())
{
//avoid (accumulator, this->averageVectors(closestObs));
//accumulator = Vector(0,0,0);
Vector change;
change = averageVectors(closestObs);
//change |= 200;
float dist = (this->position - averageVectors(obsPos)).getLength2D();
float ratio = dist / radius;
if (ratio < minUrgency) ratio = minUrgency;
else if (ratio > maxUrgency) ratio = maxUrgency;
change.setLength2D(ratio + lastVel.getLength2D()/10);
accumulator += change;
}
if (this->range!=0)
{
if (!((position - startPos).isLength2DIn(this->range)))
{
Vector diff = startPos - position;
diff.setLength2D(lastVel.getLength2D());
accumulator += diff;
}
}
}
