ogrepaginglandscapetile.cpp

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

/***************************************************************************
	OgrePagingLandScapeTile.cpp  -  description
	-------------------
	begin                : Sun Jun 08 2003
	copyright            : (C) 2003 by Jose A. Milan
	email                : [e-mail]
***************************************************************************/

/***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU Lesser General Public License as        *
*   published by the Free Software Foundation; either version 2 of the    *
*   License, or (at your option) any later version.                       *
*                                                                         *
***************************************************************************/
#include <OgreStringConverter.h>
#include <OgreCamera.h>
#include <OgreMath.h>

#include "OgrePagingLandScapeTile.h"

#include "OgrePagingLandScapeOptions.h"
#include "OgrePagingLandScapeTileManager.h"
#include "OgrePagingLandScapeRenderableManager.h"

namespace Ogre
{

//String PagingLandScapeTile::mType = "PagingLandScapeTile";

//-----------------------------------------------------------------------
PagingLandScapeTile::PagingLandScapeTile( )
{
	//mTileNode = 0;
	mRenderable = 0;
	for ( int i = 0; i < 4; i++ )
	{
		mTile[ i ] = 0;
		mNeighbors[ i ] = 0;
	}
	mInit = false;
	mIsDivided = false;
}

//-----------------------------------------------------------------------
PagingLandScapeTile::~PagingLandScapeTile( )
{

	release();
/*
	mMaterial = 0;
	mData = 0;

	for ( int i = 0; i < 4; i++ )
	{
		if ( mTile[ i ] !=0 )
		{

			if ( mTileNode != 0 )
			{
				mTileNode->detachObject( mTile[ i ]->getName() );
			}
			mTile[ i ] -> release();

			mTile[ i ] = 0;
		}
	}

	if ( mRenderable != 0 )
	{
		if ( mTileNode != 0 )
		{
			mTileNode->detachObject( mRenderable->getName() );
		}
		mRenderable -> release();

		mRenderable = 0;
	}
*/
//	if ( mTileNode != 0 )
//	{
//		mTileNode->removeAllChildren();
//		delete mTileNode;
//		mTileNode = 0;
//	}
}

//-----------------------------------------------------------------------
void PagingLandScapeTile::init( SceneNode &ParentSceneNode, PagingLandScapePageData2D *Data,  Material *material, float PosX, float PosZ, float offSetX, float offSetZ, int Nivel )
{
	mInit = true;
	mNivel = Nivel;
	mData = Data;
	mMaterial = material;
	mX = offSetX;
	mZ = offSetZ;
	mPosX = PosX;
	mPosZ = PosZ;
	mIsQueued = false;

	mName = "tile[" + StringConverter::toString( PosX ) + "." + StringConverter::toString( PosZ ) + "." + StringConverter::toString( offSetX ) + "." + StringConverter::toString( offSetZ ) + "." + StringConverter::toString( Nivel ) + "]";
	mTileSceneNode = ParentSceneNode.createChildSceneNode( mName );

	Vector3 Scale = PagingLandScapeOptions::getSingleton().scale;

	Real tilesize = pow (2, Nivel);
	Vector3 ParentPos = ParentSceneNode.getWorldPosition();

	endx = tilesize * Scale.x;
	endz = tilesize * Scale.z;

	// figure out scenenode position within parent
	mTileSceneNode -> setPosition(   PosX + offSetX * Scale.x - ParentPos.x, 0, PosZ + offSetZ * Scale.z - ParentPos.z);

	//mTileNode -> attachObject( this );

	mCenter.x = PosX + offSetX * Scale.x + ( endx ) / 2;
	mCenter.y = 0;
	mCenter.z = PosZ + offSetZ * Scale.z + ( endz ) / 2;

	mBounds.setExtents( 0, 0, 0, ( Real )( endx ), 255 * Scale.y, ( Real )( endz ) );

	updateCache();

	//force update in scenenode
	//mTileSceneNode -> _update( true, true );

	mIsDivided = true;
	Merge();
}

//-----------------------------------------------------------------------
void PagingLandScapeTile::release( void )
{
	mInit = false;
	mIsDivided = false;
	mMaterial = 0;
	mData = 0;

	// We need to release the children too
	for ( int i = 0; i < 4; i++ )
	{
		if ( mTile[ i ] != 0 )
		{		
/*
			if ( mTileNode != 0 )
			{
				mTileNode->detachObject( mTile[ i ]->getName() );
			}
*/
			mTile[ i ]->release();
			mTile[ i ] = 0;
		}
		mNeighbors[ i ] = 0;
	}

	if ( mRenderable != 0 )
	{
		//JEFF
		// Ogre::Movable will detach itself when deleted
/*
		if ( mTileSceneNode != 0 )
		{
			mTileSceneNode->detachObject( mRenderable->getName() );
		}
*/
		mRenderable->release();
		mRenderable = 0;
	}

/*
	if ( mTileNode != 0 )
	{
		//mTileNode->getParent()->removeChild( mTileNode->getName() );
		//delete mTileNode;
		static_cast<SceneNode*>( mTileNode -> getParent() )->removeAndDestroyChild( mTileNode->getName() );
		mTileNode = 0;
	}
*/
	PagingLandScapeTileManager::getSingleton().freeTile( this );
}

//-----------------------------------------------------------------------
void PagingLandScapeTile::updateCache( void )
{
	Vector3 Scale = PagingLandScapeOptions::getSingleton().scale;
	mSize = pow( 2, mNivel );
	//		mSize *= mSize;
	//		mSize *= 2 * Scale.x * Scale.z;
	Scale.x *= mSize;
	Scale.y = 0;
	Scale.z *= mSize;
	mSize = Scale.squaredLength() * PagingLandScapeOptions::getSingleton().split_factor;
}

// JEFF - tile no longer subclassed from RenderableObject
/*
//-----------------------------------------------------------------------
void PagingLandScapeTile::_notifyCurrentCamera( Camera* cam )
{
}

//-----------------------------------------------------------------------
void PagingLandScapeTile::_notifyAttached(Node* parent)
{
	mParentNode = parent;
	if ( parent != 0 )
	{
		mTileNode = static_cast<SceneNode*>( parent->createChild( mName ) );
		//mT
		ileNode -> setPosition( (Real)mX , 0.0, (Real)mZ );
		for ( int i = 0; i < 4; i++ )
		{
			if ( mTile[ i ] != 0 )
			{
				mTileNode->attachObject( mTile[ i ] );
			}
		}

		if ( mRenderable != 0 )
		{
			mTileNode->attachObject ( mRenderable );
		}

		mTileNode->_update( true, true );
	}
}

//-----------------------------------------------------------------------
void PagingLandScapeTile::_updateRenderQueue( RenderQueue* queue )
{
}

//-----------------------------------------------------------------------
void PagingLandScapeTile::getWorldTransforms( Matrix4* xform ) const
{
	*xform = mParentNode->_getFullTransform();
}

//-----------------------------------------------------------------------
const Quaternion& PagingLandScapeTile::getWorldOrientation(void) const
{
	return mParentNode->_getDerivedOrientation();
}

//-----------------------------------------------------------------------
const Vector3& PagingLandScapeTile::getWorldPosition(void) const
{
	return mParentNode->_getDerivedPosition();
}
*/

//-----------------------------------------------------------------------
void PagingLandScapeTile::Split( )
{
	if ( mInit == false )
	{
		mIsQueued = false;
		return;
	}
	if ( mNivel > 2  )
	{
		if ( mIsDivided == false )
		{						
			int subNivel = mNivel -1;
			float middle = pow( 2, subNivel );
			// Request 4 new tiles
			for ( int i = 0; i < 4; i++ )
			{
				mTile[ i ] = PagingLandScapeTileManager::getSingleton().getTile( );
			}
			if ( ( mTile[ 0 ] != 0 ) && ( mTile[ 1 ] != 0 ) && ( mTile[ 2 ] != 0 ) && ( mTile[ 3 ] != 0 ) )
			{
				mTile[ 0 ] -> init( *mTileSceneNode, mData, mMaterial, mPosX, mPosZ, mX, mZ, subNivel );
				mTile[ 0 ] -> mRenderable -> StartMorphing();
				mTile[ 1 ] -> init( *mTileSceneNode, mData, mMaterial, mPosX, mPosZ, mX + middle, mZ, subNivel );
				mTile[ 1 ] -> mRenderable -> StartMorphing();
				mTile[ 2 ] -> init( *mTileSceneNode, mData, mMaterial, mPosX, mPosZ, mX, mZ + middle, subNivel );
				mTile[ 2 ] -> mRenderable -> StartMorphing();
				mTile[ 3 ] -> init( *mTileSceneNode,mData, mMaterial, mPosX, mPosZ, mX + middle, mZ + middle, subNivel );
				mTile[ 3 ] -> mRenderable -> StartMorphing();

				//setup the neighbor links.
				mTile[ 0 ] -> setNeighbor( SOUTH, mTile[ 1 ] );
				mTile[ 1 ] -> setNeighbor( NORTH, mTile[ 0 ] );
				mTile[ 0 ] -> setNeighbor( EAST, mTile[ 2 ] );
				mTile[ 2 ] -> setNeighbor( WEST, mTile[ 0 ] );
				mTile[ 1 ] -> setNeighbor( EAST, mTile[ 3 ] );
				mTile[ 3 ] -> setNeighbor( WEST, mTile[ 1 ] );
				mTile[ 2 ] -> setNeighbor( SOUTH, mTile[ 3 ] );
				mTile[ 3 ] -> setNeighbor( NORTH, mTile[ 2 ] );
				if ( mNeighbors[ WEST ] != 0 )
				{
					if ( mNeighbors[ WEST ] -> isDivided() == true )
					{
						mNeighbors[ WEST ] -> mTile[ 2 ] -> setNeighbor( EAST, mTile[ 0 ] );
						mTile[ 0 ] -> setNeighbor( WEST, mNeighbors[ WEST ] -> mTile[ 2 ] );
						mNeighbors[ WEST ] -> mTile[ 3 ] -> setNeighbor( EAST, mTile[ 1 ] );
						mTile[ 1 ] -> setNeighbor( WEST, mNeighbors[ WEST ] -> mTile[ 3 ] );
					}
				}
				if ( mNeighbors[ EAST ] != 0 )
				{
					if ( mNeighbors[ EAST ] -> isDivided() == true  )
					{
						mNeighbors[ EAST ] -> mTile[ 0 ] -> setNeighbor( WEST, mTile[ 2 ] );
						mTile[ 2 ] -> setNeighbor( EAST, mNeighbors[ EAST ] -> mTile[ 0 ] );
						mNeighbors[ EAST ] -> mTile[ 1 ] -> setNeighbor( WEST, mTile[ 3 ] );
						mTile[ 3 ] -> setNeighbor( EAST, mNeighbors[ EAST ] -> mTile[ 1 ] );
					}
				}
				if ( mNeighbors[ NORTH ] != 0 )
				{