ogrepaginglandscaperenderablemanager.cpp

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

/***************************************************************************
  OgrePagingLandScapeRenderableManager.cpp  -  description
  -------------------
  begin                : Mon Jun 16 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 "OgreVector3.h"
#include "OgreColourValue.h"

#include "OgreMovableObject.h"
#include "OgreAxisAlignedBox.h"

#include "OgreCamera.h"

#include "OgreSceneNode.h"

#include "OgreSimpleRenderable.h"

#include "OgrePagingLandScapeOptions.h"
#include "OgrePagingLandScapeCamera.h"

#include "OgrePagingLandScapeRenderable.h"
#include "OgrePagingLandScapeIndexBuffer.h"

#include "OgrePagingLandScapeRenderableManager.h"

#include "OgrePagingLandScapeTile.h"

namespace Ogre
{

//-----------------------------------------------------------------------
template<> PagingLandScapeRenderableManager* Singleton<PagingLandScapeRenderableManager>::ms_Singleton = 0;
PagingLandScapeRenderableManager* PagingLandScapeRenderableManager::getSingletonPtr(void)
{
	return ms_Singleton;
}
PagingLandScapeRenderableManager& PagingLandScapeRenderableManager::getSingleton(void)
{  
	assert( ms_Singleton );  return ( *ms_Singleton );  
}

//-----------------------------------------------------------------------
PagingLandScapeRenderableManager::PagingLandScapeRenderableManager( )
{

	mNumRenderables = 0;

	mIndexes = new PagingLandScapeIndexBuffer();

	// Add the requested initial number
	_addBatch(PagingLandScapeOptions::getSingleton().num_renderables);

}

//-----------------------------------------------------------------------
PagingLandScapeRenderableManager::~PagingLandScapeRenderableManager( )
{
	for ( uint i = 0; i < mNumRenderables; i++ )
	{
		delete mRenderables[ i ];
		mRenderables[ i ] = 0;
	}

	// destroy de renderables
	mRenderables.clear();

	if ( mIndexes )
	{
		delete mIndexes;
		mIndexes = 0;
	}
}

//-----------------------------------------------------------------------
PagingLandScapeRenderable *PagingLandScapeRenderableManager::getRenderable( )
{
	if ( mQueue.getSize() == 0 )
	{
		// We don磘 have more renderables, so we are going to add more
		_addBatch(PagingLandScapeOptions::getSingleton().num_renderables_increment);
		// Increment the next batch by a 10%
		PagingLandScapeOptions::getSingleton().num_renderables_increment += uint (PagingLandScapeOptions::getSingleton().num_renderables_increment * 0.1f);
	}
	return mQueue.pop( );
}

//-----------------------------------------------------------------------
void PagingLandScapeRenderableManager::freeRenderable( PagingLandScapeRenderable *rend )
{
	mQueue.push( rend );
}

//-----------------------------------------------------------------------
void PagingLandScapeRenderableManager::queueRenderableLoading( PagingLandScapeRenderable *rend, PagingLandScapeTile *tile )
{
    mRenderablesLoadQueue.push( rend );
    mTilesLoadQueue.push( tile );
}

//-----------------------------------------------------------------------
void PagingLandScapeRenderableManager::executeRenderableLoading(void)
{
	uint j = mRenderablesLoadQueue.getSize();
	if (j)
    { 
        if (j > PagingLandScapeOptions::getSingleton().num_renderables_loading)
        {
            j = PagingLandScapeOptions::getSingleton().num_renderables_loading;
        }
        for (uint i = 0; i < j ; i++ )
        {
            PagingLandScapeRenderable* rend = mRenderablesLoadQueue.pop( );
            if ( rend != 0 )
            {
                rend->load();
                PagingLandScapeTile* tile = mTilesLoadQueue.pop( );
                // make sure tile had not been unloaded til queue insertion
                if (tile->isLoaded ())
                {
                    assert(tile &&  tile->getTileNode ());
                    // only attach if renderable loaded
                    tile->getTileNode ()->attachObject( rend );
                    tile->_linkRenderableNeighbor ();  
                }  
            }
        }
    }
	   
}

//-----------------------------------------------------------------------
uint PagingLandScapeRenderableManager::numRenderables( void ) const
{
	return mNumRenderables;
}

//-----------------------------------------------------------------------
int PagingLandScapeRenderableManager::numFree( void ) const
{
	return mQueue.getSize( );
}

//-----------------------------------------------------------------------
int PagingLandScapeRenderableManager::numLoading( void ) const
{
	return mRenderablesLoadQueue.getSize( );
}
//-----------------------------------------------------------------------
void PagingLandScapeRenderableManager::_addBatch(const uint num)
{
	mNumRenderables += num;
//    mRenderables.reserve (mNumRenderables);
//    mRenderables.resize (mNumRenderables);

	for (uint i = 0; i < num; i++ )
	{
		PagingLandScapeRenderable* rend = new PagingLandScapeRenderable();
		mRenderables.push_back( rend );
		mQueue.push( rend );
	}
}

} //namespace