ruby-ogre 0.0.5-x86-linux → 0.1.0-x86-linux

data/deps/include/OGRE/Paging/OgrePageStrategy.h

@@ -1,138 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-(Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-
-#ifndef __Ogre_PageStrategy_H__
-#define __Ogre_PageStrategy_H__
-
-#include "OgrePagingPrerequisites.h"
-
-
-namespace Ogre
-{
-	/** \addtogroup Optional Components
-	*  @{
-	*/
-	/** \addtogroup Paging
-	*  Some details on paging component
-	*/
-	/*@{*/
-
-
-	/** Abstract marker class representing the data held against the PagedWorldSection
-	which is specifically used by the PageStrategy.
-	*/
-	class _OgrePagingExport PageStrategyData : public PageAlloc
-	{
-	public:
-		PageStrategyData() {}
-		virtual ~PageStrategyData() {}
-
-		/// Load this data from a stream (returns true if successful)
-		virtual bool load(StreamSerialiser& stream) = 0;
-		/// Save this data to a stream
-		virtual void save(StreamSerialiser& stream) = 0;
-
-
-	};
-
-
-	/** Defines the interface to a strategy class which is responsible for deciding
-		when Page instances are requested for addition and removal from the 
-		paging system.
-	@remarks
-		The interface is deliberately light, with no specific mention of requesting
-		new Page instances. It is entirely up to the PageStrategy to respond
-		to the events raised on it and to call methods on other classes (such as
-		requesting new pages). 
-	*/
-	class _OgrePagingExport PageStrategy : public PageAlloc
-	{
-	protected:
-		String mName;
-		PageManager* mManager;
-	public:
-		PageStrategy(const String& name, PageManager* manager)
-			: mName(name), mManager(manager)
-		{
-
-		}
-
-		virtual ~PageStrategy() {}
-
-		const String& getName() const { return mName; }
-		PageManager* getManager() const { return mManager; }
-
-		/// Called when the frame starts
-		virtual void frameStart(Real timeSinceLastFrame, PagedWorldSection* section) {}
-		/// Called when the frame ends
-		virtual void frameEnd(Real timeElapsed, PagedWorldSection* section) {}
-		/** Called when a camera is used for any kind of rendering.
-		@remarks
-			This is probably the primary way in which the strategy will request
-			new pages. 
-		@param cam Camera which is being used for rendering. Class should not
-			rely on this pointer remaining valid permanently because no notification 
-			will be given when the camera is destroyed. 
-		*/
-		virtual void notifyCamera(Camera* cam, PagedWorldSection* section) {}
-
-		/** Create a PageStrategyData instance containing the data specific to this
-			PageStrategy. 
-		@par
-			This data will be held by a given PagedWorldSection and the structure of
-			the data will be specific to the PageStrategy subclass.
-		*/
-		virtual PageStrategyData* createData() = 0;
-
-		/** Destroy a PageStrategyData instance containing the data specific to this
-		PageStrategy. 
-		@par
-		This data will be held by a given PagedWorldSection and the structure of
-		the data will be specific to the PageStrategy subclass.
-		*/
-		virtual void destroyData(PageStrategyData* d) = 0;
-
-		/** Update the contents of the passed in SceneNode to reflect the 
-			debug display of a given page. 
-		@remarks
-			The PageStrategy is to have complete control of the contents of this
-			SceneNode, it must not be altered / added to by others.
-		*/
-		virtual void updateDebugDisplay(Page* p, SceneNode* sn) = 0;
-
-		/** Get the page ID for a given world position. 
-		@return The page ID
-		*/
-		virtual PageID getPageID(const Vector3& worldPos, PagedWorldSection* section) = 0;
-	};
-
-	/*@}*/
-	/*@}*/
-}
-
-#endif

data/deps/include/OGRE/Paging/OgrePagedWorld.h

@@ -1,252 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-(Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-
-#ifndef __Ogre_PagedWorld_H__
-#define __Ogre_PagedWorld_H__
-
-#include "OgrePagingPrerequisites.h"
-#include "OgreString.h"
-#include "OgreDataStream.h"
-#include "OgreCommon.h"
-
-namespace Ogre
-{
-	class PageManager;
-
-	/** \addtogroup Optional Components
-	*  @{
-	*/
-	/** \addtogroup Paging
-	*  Some details on paging component
-	*  @{
-	*/
-
-
-	/** This class represents a collection of pages which make up a world. 
-	@remarks
-		It's important to bear in mind that the PagedWorld only delineates the
-		world and knows how to find out about the contents of it. It does not, 
-		by design, contain all elements of the world, in memory, at once. 
-	*/
-	class _OgrePagingExport PagedWorld : public PageAlloc
-	{
-	protected:
-		String mName;
-		PageManager* mManager;
-		PageProvider* mPageProvider;
-
-	public:
-		static const uint32 CHUNK_ID;
-		static const uint16 CHUNK_VERSION;
-		static const uint32 CHUNK_SECTIONDECLARATION_ID;
-		/** Constructor.
-		@param name The name of the world, which must be enough to identify the 
-			place where data for it can be loaded from (doesn't have to be a filename
-			necessarily).
-		@param manager The PageManager that is in charge of providing this world with
-			services such as related object factories.
-		*/
-		PagedWorld(const String& name, PageManager* manager);
-		virtual ~PagedWorld();
-
-		const String& getName() const { return mName; }
-		/// Get the manager of this world
-		PageManager* getManager() const { return mManager; }
-
-		/// Load world data from a file
-		void load(const String& filename);
-		/// Load world data from a stream
-		void load(const DataStreamPtr& stream);
-		/// Load world data from a serialiser (returns true if successful)
-		bool load(StreamSerialiser& stream);
-		/** Save world data to a file
-		@param filename The name of the file to create; this can either be an 
-			absolute filename or 
-		*/
-		void save(const String& filename);
-		/// Save world data to a stream
-		void save(const DataStreamPtr& stream);
-		/// Save world data to a serialiser
-		void save(StreamSerialiser& stream);
-
-		/** Create a new section of the world based on a specialised type.
-		@remarks
-			World sections are areas of the world that use a particular
-			PageStrategy, with a certain set of parameters specific to that
-			strategy, and potentially some other rules. 
-			So you would have more than one section in a world only 
-			if you needed different simultaneous paging strategies, or you 
-			wanted the same strategy but parameterised differently.
-		@param sceneMgr The SceneManager to use for this section. 
-		@param typeName The type of section to use (must be registered	
-			with PageManager), or blank to use the default type (simple grid)
-		@param sectionName An optional name to give the section (if none is
-			provided, one will be generated)
-		*/
-		PagedWorldSection* createSection(SceneManager* sceneMgr,
-			const String& typeName,
-			const String& sectionName = StringUtil::BLANK);
-
-
-		/** Create a new manually defined section of the world.
-		@remarks
-			World sections are areas of the world that use a particular
-			PageStrategy, with a certain set of parameters specific to that
-			strategy. So you would have more than one section in a world only 
-			if you needed different simultaneous paging strategies, or you 
-			wanted the same strategy but parameterised differently.
-		@param strategyName The name of the strategy to use (must be registered	
-			with PageManager)
-		@param sceneMgr The SceneManager to use for this section
-		@param sectionName An optional name to give the section (if none is
-			provided, one will be generated)
-		*/
-		PagedWorldSection* createSection(const String& strategyName, SceneManager* sceneMgr,
-			const String& sectionName = StringUtil::BLANK);
-
-
-		/** Create a manually defined new section of the world.
-		@remarks
-			World sections are areas of the world that use a particular
-			PageStrategy, with a certain set of parameters specific to that
-			strategy. So you would have more than one section in a world only 
-			if you needed different simultaneous paging strategies, or you 
-			wanted the same strategy but parameterised differently.
-		@param strategy The strategy to use 
-		@param sceneMgr The SceneManager to use for this section
-		@param sectionName An optional name to give the section (if none is
-			provided, one will be generated)
-		*/
-		PagedWorldSection* createSection(PageStrategy* strategy, SceneManager* sceneMgr, 
-			const String& sectionName = StringUtil::BLANK);
-		/** Destroy a section of world. */
-		void destroySection(const String& name);
-		/** Destroy a section of world. */
-		void destroySection(PagedWorldSection* sec);
-		/** Destroy all world sections */
-		void destroyAllSections();
-
-		/** Get the number of sections this world has. */
-		size_t getSectionCount() const { return mSections.size(); }
-
-		/** Retrieve a section of the world. */
-		PagedWorldSection* getSection(const String& name);
-
-		typedef map<String, PagedWorldSection*>::type SectionMap;
-		/// Retrieve a const reference to all the sections in this world
-		const SectionMap& getSections() const { return mSections; }
-
-		/** Set the PageProvider which can provide streams for Pages in this world. 
-		@remarks
-			This is the top-level way that you can direct how Page data is loaded. 
-			When data for a Page is requested for a PagedWorldSection, the following
-			sequence of classes will be checked to see if they have a provider willing
-			to supply the stream: PagedWorldSection, PagedWorld, PageManager.
-			If none of these do, then the default behaviour is to look for a file
-			called worldname_sectionname_pageID.page. 
-		@note
-			The caller remains responsible for the destruction of the provider.
-		*/
-		void setPageProvider(PageProvider* provider) { mPageProvider = provider; }
-		
-		/** Get the PageProvider which can provide streams for Pages in this world. */
-		PageProvider* getPageProvider() const { return mPageProvider; }
-
-		/** Give a world  the opportunity to prepare page content procedurally. 
-		@remarks
-		You should not call this method directly. This call may well happen in 
-		a separate thread so it should not access GPU resources, use _loadProceduralPage
-		for that
-		@return true if the page was populated, false otherwise
-		*/
-		virtual bool _prepareProceduralPage(Page* page, PagedWorldSection* section);
-		/** Give a world  the opportunity to prepare page content procedurally. 
-		@remarks
-		You should not call this method directly. This call will happen in 
-		the main render thread so it can access GPU resources. Use _prepareProceduralPage
-		for background preparation.
-		@return true if the page was populated, false otherwise
-		*/
-		virtual bool _loadProceduralPage(Page* page, PagedWorldSection* section);
-		/** Give a world  the opportunity to unload page content procedurally. 
-		@remarks
-		You should not call this method directly. This call will happen in 
-		the main render thread so it can access GPU resources. Use _unprepareProceduralPage
-		for background preparation.
-		@return true if the page was populated, false otherwise
-		*/
-		virtual bool _unloadProceduralPage(Page* page, PagedWorldSection* section);
-		/** Give a world  the opportunity to unprepare page content procedurally. 
-		@remarks
-		You should not call this method directly. This call may well happen in 
-		a separate thread so it should not access GPU resources, use _unloadProceduralPage
-		for that
-		@return true if the page was unpopulated, false otherwise
-		*/
-		virtual bool _unprepareProceduralPage(Page* page, PagedWorldSection* section);
-		/** Get a serialiser set up to read Page data for the given PageID. 
-		@param pageID The ID of the page being requested
-		@param section The parent section to which this page will belong
-		@remarks
-		The StreamSerialiser returned is the responsibility of the caller to
-		delete. 
-		*/
-		StreamSerialiser* _readPageStream(PageID pageID, PagedWorldSection* section);
-
-		/** Get a serialiser set up to read Page data for the given PageID. 
-		@param pageID The ID of the page being requested
-		@param section The parent section to which this page will belong
-		@remarks
-		The StreamSerialiser returned is the responsibility of the caller to
-		delete. 
-		*/
-		StreamSerialiser* _writePageStream(PageID pageID, PagedWorldSection* section);
-
-		/// Called when the frame starts
-		virtual void frameStart(Real timeSinceLastFrame);
-		/// Called when the frame ends
-		virtual void frameEnd(Real timeElapsed);
-		/// Notify a world of the current camera
-		virtual void notifyCamera(Camera* cam);
-
-		/** Function for writing to a stream.
-		*/
-		_OgrePagingExport friend std::ostream& operator <<( std::ostream& o, const PagedWorld& p );
-
-
-	protected:
-		SectionMap mSections;
-		NameGenerator mSectionNameGenerator;
-	};
-	
-	/** @} */
-	/** @} */
-
-}
-
-#endif

data/deps/include/OGRE/Paging/OgrePagedWorldSection.h

@@ -1,316 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-(Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-
-#ifndef __Ogre_PagedWorldSection_H__
-#define __Ogre_PagedWorldSection_H__
-
-#include "OgrePagingPrerequisites.h"
-#include "OgreAxisAlignedBox.h"
-
-namespace Ogre
-{
-	/** \addtogroup Optional Components
-	*  @{
-	*/
-	/** \addtogroup Paging
-	*  Some details on paging component
-	*  @{
-	*/
-
-	/** Represents a section of the PagedWorld which uses a given PageStrategy, and
-		which is made up of a generally localised set of Page instances.
-	@remarks
-		The reason for PagedWorldSection is that you may wish to cater for multiple
-		sections of your world which use a different approach to paging (ie a
-		different PageStrategy), or which are significantly far apart or separate 
-		that the parameters you want to pass to the PageStrategy are different.
-	@par
-		PagedWorldSection instances are fully contained within the PagedWorld and
-		their definitions are loaded in their entirety when the PagedWorld is
-		loaded. However, no Page instances are initially loaded - those are the
-		responsibility of the PageStrategy.
-	@par
-		PagedWorldSection can be subclassed and derived types provided by a
-		PagedWorldSectionFactory. These subclasses might come preconfigured
-		with a strategy for example, or with additional metadata used only for
-		that particular type of section.
-	@par
-		A PagedWorldSection targets a specific SceneManager. When you create one
-		in code via PagedWorld::createSection, you pass that SceneManager in manually.
-		When loading from a saved world file however, the SceneManager type and
-		instance name are saved and that SceneManager is looked up on loading, or
-		created if it didn't exist. 
-	*/
-	class _OgrePagingExport PagedWorldSection : public PageAlloc
-	{
-	public:
-		typedef map<PageID, Page*>::type PageMap;
-	protected:
-		String mName;
-		AxisAlignedBox mAABB;
-		PagedWorld* mParent;
-		PageStrategy* mStrategy;
-		PageStrategyData* mStrategyData;
-		PageMap mPages;
-		PageProvider* mPageProvider;
-		SceneManager* mSceneMgr;
-
-		/// Load data specific to a subtype of this class (if any)
-		virtual void loadSubtypeData(StreamSerialiser& ser) {}
-		virtual void saveSubtypeData(StreamSerialiser& ser) {}
-
-
-	public:
-		static const uint32 CHUNK_ID;
-		static const uint16 CHUNK_VERSION;
-
-		/** Construct a new instance, specifying the parent and scene manager. */
-		PagedWorldSection(const String& name, PagedWorld* parent, SceneManager* sm);
-		virtual ~PagedWorldSection();
-
-		PageManager* getManager() const;
-
-		/// Get the name of this section
-		virtual const String& getName() const { return mName; }
-		/// Get the page strategy which this section is using
-		virtual PageStrategy* getStrategy() const { return mStrategy; }
-		/** Change the page strategy.
-		@remarks
-			Doing this will invalidate any pages attached to this world section, and
-			require the PageStrategyData to be repopulated.
-		*/
-		virtual void setStrategy(PageStrategy* strat);
-		/** Change the page strategy.
-		@remarks
-			Doing this will invalidate any pages attached to this world section, and
-			require the PageStrategyData to be repopulated.
-		*/
-		virtual void setStrategy(const String& stratName);
-
-		/** Change the SceneManager.
-		@remarks
-		Doing this will invalidate any pages attached to this world section, and
-		require the pages to be reloaded.
-		*/
-		virtual void setSceneManager(SceneManager* sm);
-		
-		/** Change the SceneManager.
-		@remarks
-		Doing this will invalidate any pages attached to this world section, and
-		require the pages to be reloaded.
-		@param smName The instance name of the SceneManager
-		*/
-		virtual void setSceneManager(const String& smName);
-		/// Get the current SceneManager
-		virtual SceneManager* getSceneManager() const { return mSceneMgr; }
-
-		/// Get the parent world
-		virtual PagedWorld* getWorld() const { return mParent; }
-		/// Get the data required by the PageStrategy which is specific to this world section
-		virtual PageStrategyData* getStrategyData() const { return mStrategyData; }
-		/// Set the bounds of this section
-		virtual void setBoundingBox(const AxisAlignedBox& box);
-		/// Get the bounds of this section
-		virtual const AxisAlignedBox& getBoundingBox() const;
-
-
-		/// Load this section from a stream (returns true if successful)
-		virtual bool load(StreamSerialiser& stream);
-		/// Save this section to a stream
-		virtual void save(StreamSerialiser& stream);
-
-
-		/// Called when the frame starts
-		virtual void frameStart(Real timeSinceLastFrame);
-		/// Called when the frame ends
-		virtual void frameEnd(Real timeElapsed);
-		/// Notify a section of the current camera
-		virtual void notifyCamera(Camera* cam);
-
-		/** Load or create a page against this section covering the given world 
-			space position. 
-		@remarks
-			This method is designed mainly for editors - it will try to load
-			an existing page if there is one, otherwise it will create a new one
-			synchronously.
-		*/
-		virtual Page* loadOrCreatePage(const Vector3& worldPos);
-
-		/** Get the page ID for a given world position. */
-		virtual PageID getPageID(const Vector3& worldPos);
-
-
-		/** Ask for a page to be loaded with the given (section-relative) PageID
-		@remarks
-			You would not normally call this manually, the PageStrategy is in 
-			charge of it usually.
-			If this page is already loaded, this request will not load it again.
-			If the page needs loading, then it may be an asynchronous process depending
-			on whether threading is enabled.
-		@param pageID The page ID to load
-		@param forceSynchronous If true, the page will always be loaded synchronously
-		*/
-		virtual void loadPage(PageID pageID, bool forceSynchronous = false);
-
-		/** Ask for a page to be unloaded with the given (section-relative) PageID
-		@remarks
-			You would not normally call this manually, the PageStrategy is in 
-			charge of it usually.
-		@param pageID The page ID to unload
-		@param forceSynchronous If true, the page will always be unloaded synchronously
-		*/
-		virtual void unloadPage(PageID pageID, bool forceSynchronous = false);
-		/** Ask for a page to be unloaded with the given (section-relative) PageID
-		@remarks
-		You would not normally call this manually, the PageStrategy is in 
-		charge of it usually.
-		@param p The Page to unload
-		@param forceSynchronous If true, the page will always be unloaded synchronously
-		*/
-		virtual void unloadPage(Page* p, bool forceSynchronous = false);
-		/** Give a section the opportunity to prepare page content procedurally. 
-		@remarks
-		You should not call this method directly. This call may well happen in 
-		a separate thread so it should not access GPU resources, use _loadProceduralPage
-		for that
-		@return true if the page was populated, false otherwise
-		*/
-		virtual bool _prepareProceduralPage(Page* page);
-		/** Give a section the opportunity to prepare page content procedurally. 
-		@remarks
-		You should not call this method directly. This call will happen in 
-		the main render thread so it can access GPU resources. Use _prepareProceduralPage
-		for background preparation.
-		@return true if the page was populated, false otherwise
-		*/
-		virtual bool _loadProceduralPage(Page* page);
-		/** Give a section  the opportunity to unload page content procedurally. 
-		@remarks
-		You should not call this method directly. This call will happen in 
-		the main render thread so it can access GPU resources. Use _unprepareProceduralPage
-		for background preparation.
-		@return true if the page was populated, false otherwise
-		*/
-		virtual bool _unloadProceduralPage(Page* page);
-		/** Give a section  the opportunity to unprepare page content procedurally. 
-		@remarks
-		You should not call this method directly. This call may well happen in 
-		a separate thread so it should not access GPU resources, use _unloadProceduralPage
-		for that
-		@return true if the page was unpopulated, false otherwise
-		*/
-		virtual bool _unprepareProceduralPage(Page* page);
-
-		/** Ask for a page to be kept in memory if it's loaded.
-		@remarks
-			This method indicates that a page should be retained if it's already
-			in memory, but if it's not then it won't trigger a load. This is useful
-			for retaining pages that have just gone out of range, but which you
-			don't want to unload just yet because it's quite possible they may come
-			back into the active set again very quickly / easily. But at the same
-			time, if they've already been purged you don't want to force them to load. 
-			This is the 'maybe' region of pages. 
-		@par
-			Any Page that is neither requested nor held in a frame will be
-			deemed a candidate for unloading.
-		*/
-		virtual void holdPage(PageID pageID);
-
-		/** Retrieves a Page.
-		@remarks
-			This method will only return Page instances that are already loaded. It
-			will return null if a page is not loaded. 
-		*/
-		virtual Page* getPage(PageID pageID);
-
-		/** Remove all pages immediately. 
-		@remarks
-			Effectively 'resets' this section by deleting all pages. 
-		*/
-		virtual void removeAllPages();
-
-		/** Set the PageProvider which can provide streams Pages in this section. 
-		@remarks
-			This is the top-level way that you can direct how Page data is loaded. 
-			When data for a Page is requested for a PagedWorldSection, the following
-			sequence of classes will be checked to see if they have a provider willing
-			to supply the stream: PagedWorldSection, PagedWorld, PageManager.
-			If none of these do, then the default behaviour is to look for a file
-			called worldname_sectionname_pageID.page. 
-		@note
-			The caller remains responsible for the destruction of the provider.
-		*/
-		virtual void setPageProvider(PageProvider* provider) { mPageProvider = provider; }
-		
-		/** Get the PageProvider which can provide streams for Pages in this section. */
-		virtual PageProvider* getPageProvider() const { return mPageProvider; }
-
-		/** Get a serialiser set up to read Page data for the given PageID. 
-		@param pageID The ID of the page being requested
-		@remarks
-		The StreamSerialiser returned is the responsibility of the caller to
-		delete. 
-		*/
-		virtual StreamSerialiser* _readPageStream(PageID pageID);
-
-		/** Get a serialiser set up to write Page data for the given PageID. 
-		@param pageID The ID of the page being requested
-		@remarks
-		The StreamSerialiser returned is the responsibility of the caller to
-		delete. 
-		*/
-		virtual StreamSerialiser* _writePageStream(PageID pageID);
-
-		/** Function for writing to a stream.
-		*/
-		_OgrePagingExport friend std::ostream& operator <<( std::ostream& o, const PagedWorldSection& p );
-
-		/** Get the type name of this section. */
-		virtual const String& getType();
-
-	};
-
-
-	/** A factory class for creating types of world section.
-	*/
-	class _OgrePagingExport PagedWorldSectionFactory : public PageAlloc
-	{
-	public:
-		virtual ~PagedWorldSectionFactory() {}
-		virtual const String& getName() const = 0;
-		virtual PagedWorldSection* createInstance(const String& name, PagedWorld* parent, SceneManager* sm) = 0;
-		virtual void destroyInstance(PagedWorldSection*) = 0;
-
-
-	};
-
-	/** @} */
-	/** @} */
-}
-
-#endif