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::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::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
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() );
        }
    }
}

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;
		}
	}


}