ogrepaginglandscapetile.cpp

使用stl技术,(还没看,是听说的)

					if ( mNeighbors[ NORTH ] -> isDivided() == true )
					{
						mNeighbors[ NORTH ] -> mTile[ 1 ] -> setNeighbor( SOUTH, mTile[ 0 ] );
						mTile[ 0 ] -> setNeighbor( NORTH, mNeighbors[ NORTH ] -> mTile[ 1 ] );
						mNeighbors[ NORTH ] -> mTile[ 3 ] -> setNeighbor( SOUTH, mTile[ 2 ] );
						mTile[ 2 ] -> setNeighbor( NORTH, mNeighbors[ NORTH ] -> mTile[ 3 ] );
					}
				}
				if ( mNeighbors[ SOUTH ] != 0 )
				{
					if ( mNeighbors[ SOUTH ] ->isDivided() == true )
					{
						mNeighbors[ SOUTH ] -> mTile[ 0 ] -> setNeighbor( NORTH, mTile[ 1 ] );
						mTile[ 1 ] -> setNeighbor( SOUTH, mNeighbors[ SOUTH ] -> mTile[ 0 ] );
						mNeighbors[ SOUTH ] -> mTile[ 2 ] -> setNeighbor( NORTH, mTile[ 3 ] );
						mTile[ 3 ] -> setNeighbor( SOUTH, mNeighbors[ SOUTH ] -> mTile[ 2 ] );
					}
				}
/*
				if ( mTileNode != 0 )
				{
					for ( int i = 0; i < 4; i++)
					{
						mTileNode->attachObject( mTile[ i ] );
					}
				}
*/
				// Release the renderable
				if ( mRenderable != 0 )
				{
					if ( mTileSceneNode != 0 )
					{
						mTileSceneNode->detachObject( mRenderable->getName() );
					}
					mRenderable->release();
					mRenderable = 0;
				}
				mIsDivided = true;
			}
			else
			{
				// If we can磘 get 4 tiles so we can磘 Split
				for ( int i = 0; i < 4; i++)
				{
					if ( mTile[ i ] != 0 )
					{
						mTile[ i ] -> release();
						mTile[ i ] = 0;
					}
				}
			}
		}
	}
	mIsQueued = false;
}

//-----------------------------------------------------------------------
void PagingLandScapeTile::Merge( )
{
	if ( mInit == false )
	{
		mIsQueued = false;
		return;
	}
	if ( mIsDivided == true )
	{
		// Just Start Demorphing
		startDemorph();
		// If we are demorphed we can unload
		if ( canUnload() == true )
		{
			// Request a renderable
			mRenderable = PagingLandScapeRenderableManager::getSingleton().getRenderable( );
			if ( mRenderable != 0 )
			{
				mRenderable -> init ( mData, mPosX, mPosZ, mX, mZ, mNivel );
				// Recover the error introduced in this renderable
				mError = mRenderable -> getError();
				// Set the material
				mRenderable -> setMaterial( mMaterial );

				//JEFF - tile needs the center of the renderable for accurate LOD calc
				mCenter.y = mRenderable -> getCenter().y;
				mIsDivided = false;
				// Release the tiles
				for ( int i = 0; i < 4; i++ )
				{
					if ( mTile[ i ] != 0 )
					{
						// set Neighbors links
						if ( mTile[ i ] -> getNeighbor( WEST ) != 0 )
						{
							mTile[ i ] -> getNeighbor( WEST ) -> setNeighbor( EAST, 0 );
							mTile[ i ] -> setNeighbor( WEST, 0 );
						}
						if ( mTile[ i ] -> getNeighbor( EAST ) != 0 )
						{
							mTile[ i ] -> getNeighbor( EAST ) -> setNeighbor( WEST, 0 );
							mTile[ i ] -> setNeighbor( EAST, 0 );
						}
						if ( mTile[ i ] -> getNeighbor( NORTH ) != 0 )
						{
							mTile[ i ] -> getNeighbor( NORTH ) -> setNeighbor( SOUTH, 0 );
							mTile[ i ] -> setNeighbor( NORTH, 0 );
						}
						if ( mTile[ i ] -> getNeighbor( SOUTH ) != 0 )
						{
							mTile[ i ] -> getNeighbor( SOUTH ) -> setNeighbor( NORTH, 0 );
							mTile[ i ] -> setNeighbor( SOUTH, 0 );
						}
/*
						if ( mTileNode != 0 )
						{
							mTileNode -> detachObject( mTile[ i ] -> getName() );
						}
*/
						mTile[ i ] -> release();
						mTile[ i ] = 0;
					}
				}
				if (mTileSceneNode != 0 )
				{
					// JEFF
					//mTileNode -> attachObject( mRenderable );
					// get rid of the four child scene nodes - don't need them anymore
					mTileSceneNode -> removeAndDestroyAllChildren();
					mTileSceneNode -> attachObject( mRenderable );
					// release all child scene nodes attached
					// note: this will automaticaly remove the objects from the scene node
				}
				// Set the Triangle List
				_update();
			}
			mIsQueued = false;
		}
		else
		{
			PagingLandScapeTileManager::getSingleton().needMerge( this );
			mIsQueued = true;
		}
	}
}

//-----------------------------------------------------------------------
PagingLandScapeTile *PagingLandScapeTile::getNeighbor( eNeighbor e )
{
	return mNeighbors[ e ];
}

//-----------------------------------------------------------------------
void PagingLandScapeTile::setNeighbor( eNeighbor e, PagingLandScapeTile *tile )
{
	mNeighbors[ e ] = tile;
	_update( );
}

//-----------------------------------------------------------------------
void PagingLandScapeTile::_update( )
{
	if ( mIsDivided == false )
	{
		if ( mRenderable != 0 )
		{
			mRenderable -> update( mNeighbors[NORTH] == 0, mNeighbors[EAST] == 0, mNeighbors[SOUTH] == 0, mNeighbors[WEST] == 0 );
		}
	}
}

//-----------------------------------------------------------------------
bool PagingLandScapeTile::isDivided()
{
	return mInit && mIsDivided;
}

//-----------------------------------------------------------------------
bool PagingLandScapeTile::canUnload()
{
	if ( mNivel >= 4 )
	{
		return true;
	}
	if ( mIsDivided == true )
	{
		for ( int i = 0; i < 4; i++ )
		{
			if ( mTile[ i ] != 0 )
			{
				if ( mTile[ i ]->canUnload() == false )
				{
					return false;
				}
			}
		}
		return true;
	}
	else
	{
		return ( mRenderable->getMorphStatus() == PagingLandScapeRenderable::DEMORPHED );
	}
}

//-----------------------------------------------------------------------
void PagingLandScapeTile::startDemorph()
{
	if ( mNivel <= 4 )
	{
		if ( mIsDivided == true )
		{
			for ( int i = 0; i < 4; i++ )
			{			
				if ( mTile[ i ] != 0 )
				{
					mTile[ i ]->startDemorph();
				}
			}
		}
		else
		{
			if ( mRenderable != 0 )
			{
				int i = mRenderable->getMorphStatus();
				if ( i != PagingLandScapeRenderable::DEMORPHING && i != PagingLandScapeRenderable::DEMORPHED )
				{
					mRenderable->setMorphStatus( PagingLandScapeRenderable::DEMORPHING );
				}
			}
		}
	}
	else
	{
		// Force the unload without demorphing
		if ( mRenderable !=0 )
		{
			mRenderable->setMorphStatus( PagingLandScapeRenderable::DEMORPHED );
		}
	}
}

//-----------------------------------------------------------------------
void PagingLandScapeTile::getPagingLandScapeRenderOpsInBox(const AxisAlignedBox& box, std::list<RenderOperation>& opList)
{
	if ( box.intersects( mBounds ) )
	{
		if ( mIsDivided == true )
		{
			for ( int i = 0; i < 4; i++ )						
			{
				mTile[ i ]->getPagingLandScapeRenderOpsInBox( box, opList );
			}
		}
		else
		{
			RenderOperation rend;
			mRenderable->getRenderOperation(rend);
			opList.push_back(rend);
		}
	}
}

//-----------------------------------------------------------------------
void PagingLandScapeTile::_notify( const Vector3 & pos, const bool needOptionsUpdate )
{
	if ( mInit == false )
	{
		return;
	}
	if ( mIsQueued == true )
	{
		return;
	}
	if ( needOptionsUpdate )
	{
		updateCache();
	}
	//TODO: Check the optimal value
/*
	mDiff = mCenter - pos;
	//		mDiff.y = 0;
	float umbral = mDiff.squaredLength();
	// Use squared length to avoid square root
	if ( ( mError * PagingLandScapeOptions::getSingleton().Perspective / ( mCenter - pos ).squaredLength() ) <= PagingLandScapeOptions::getSingleton().threshold )
	//if ( umbral <= mSize + 3.0 )
	{
		if ( mIsDivided == false )
		{
			// Split this tile
			mIsQueued = true;
			PagingLandScapeTileManager::getSingleton().needSplit( this );
		}
		else
		{
			mTile[ 0 ] -> _notify( pos, needOptionsUpdate );
			mTile[ 1 ] -> _notify( pos, needOptionsUpdate );
			mTile[ 2 ] -> _notify( pos, needOptionsUpdate );
			mTile[ 3 ] -> _notify( pos, needOptionsUpdate );
		}
	}
	else //if ( umbral > mSize - 3.0 )
	{
		if ( mIsDivided == true )
		{
			// Merge this tile
			mTile[ 0 ] -> _notify( pos, needOptionsUpdate );
			mTile[ 1 ] -> _notify( pos, needOptionsUpdate );
			mTile[ 2 ] -> _notify( pos, needOptionsUpdate );
			mTile[ 3 ] -> _notify( pos, needOptionsUpdate );
			mIsQueued = true;
			PagingLandScapeTileManager::getSingleton().needMerge( this );
		}
	}
*/
/*
	// 2