ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/Terrain/OgreTerrainMaterialGeneratorA.h

@@ -0,0 +1,279 @@
+/*
+-----------------------------------------------------------------------------
+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_TerrainMaterialGeneratorA_H__
+#define __Ogre_TerrainMaterialGeneratorA_H__
+
+#include "OgreTerrainPrerequisites.h"
+#include "OgreTerrainMaterialGenerator.h"
+#include "OgreGpuProgramParams.h"
+
+namespace Ogre
+{
+	class PSSMShadowCameraSetup;
+
+	/** \addtogroup Optional Components
+	*  @{
+	*/
+	/** \addtogroup Terrain
+	*  Some details on the terrain component
+	*  @{
+	*/
+
+
+	/** A TerrainMaterialGenerator which can cope with normal mapped, specular mapped
+		terrain. 
+		@note Requires the Cg plugin to render correctly
+	*/
+	class _OgreTerrainExport TerrainMaterialGeneratorA : public TerrainMaterialGenerator
+	{
+	public:
+		TerrainMaterialGeneratorA();
+		~TerrainMaterialGeneratorA();
+
+		/** Shader model 2 profile target. 
+		*/
+		class _OgreTerrainExport SM2Profile : public TerrainMaterialGenerator::Profile
+		{
+		public:
+			SM2Profile(TerrainMaterialGenerator* parent, const String& name, const String& desc);
+			~SM2Profile();
+			MaterialPtr generate(const Terrain* terrain);
+			MaterialPtr generateForCompositeMap(const Terrain* terrain);
+			uint8 getMaxLayers(const Terrain* terrain) const;
+			void updateParams(const MaterialPtr& mat, const Terrain* terrain);
+			void updateParamsForCompositeMap(const MaterialPtr& mat, const Terrain* terrain);
+			void requestOptions(Terrain* terrain);
+			bool isVertexCompressionSupported() const;
+
+			/** Whether to support normal mapping per layer in the shader (default true). 
+			*/
+			bool isLayerNormalMappingEnabled() const  { return mLayerNormalMappingEnabled; }
+			/** Whether to support normal mapping per layer in the shader (default true). 
+			*/
+			void setLayerNormalMappingEnabled(bool enabled);
+			/** Whether to support parallax mapping per layer in the shader (default true). 
+			*/
+			bool isLayerParallaxMappingEnabled() const  { return mLayerParallaxMappingEnabled; }
+			/** Whether to support parallax mapping per layer in the shader (default true). 
+			*/
+			void setLayerParallaxMappingEnabled(bool enabled);
+			/** Whether to support specular mapping per layer in the shader (default true). 
+			*/
+			bool isLayerSpecularMappingEnabled() const  { return mLayerSpecularMappingEnabled; }
+			/** Whether to support specular mapping per layer in the shader (default true). 
+			*/
+			void setLayerSpecularMappingEnabled(bool enabled);
+			/** Whether to support a global colour map over the terrain in the shader,
+				if it's present (default true). 
+			*/
+			bool isGlobalColourMapEnabled() const  { return mGlobalColourMapEnabled; }
+			/** Whether to support a global colour map over the terrain in the shader,
+			if it's present (default true). 
+			*/
+			void setGlobalColourMapEnabled(bool enabled);
+			/** Whether to support a light map over the terrain in the shader,
+			if it's present (default true). 
+			*/
+			bool isLightmapEnabled() const  { return mLightmapEnabled; }
+			/** Whether to support a light map over the terrain in the shader,
+			if it's present (default true). 
+			*/
+			void setLightmapEnabled(bool enabled);
+			/** Whether to use the composite map to provide a lower LOD technique
+				in the distance (default true). 
+			*/
+			bool isCompositeMapEnabled() const  { return mCompositeMapEnabled; }
+			/** Whether to use the composite map to provide a lower LOD technique
+			in the distance (default true). 
+			*/
+			void setCompositeMapEnabled(bool enabled);
+			/** Whether to support dynamic texture shadows received from other 
+				objects, on the terrain (default true). 
+			*/
+			bool getReceiveDynamicShadowsEnabled() const  { return mReceiveDynamicShadows; }
+			/** Whether to support dynamic texture shadows received from other 
+			objects, on the terrain (default true). 
+			*/
+			void setReceiveDynamicShadowsEnabled(bool enabled);
+
+			/** Whether to use PSSM support dynamic texture shadows, and if so the 
+				settings to use (default 0). 
+			*/
+			void setReceiveDynamicShadowsPSSM(PSSMShadowCameraSetup* pssmSettings);
+			/** Whether to use PSSM support dynamic texture shadows, and if so the 
+			settings to use (default 0). 
+			*/
+			PSSMShadowCameraSetup* getReceiveDynamicShadowsPSSM() const { return mPSSM; }
+			/** Whether to use depth shadows (default false). 
+			*/
+			void setReceiveDynamicShadowsDepth(bool enabled);
+			/** Whether to use depth shadows (default false). 
+			*/
+			bool getReceiveDynamicShadowsDepth() const { return mDepthShadows; }
+			/** Whether to use shadows on low LOD material rendering (when using composite map) (default false). 
+			*/
+			void setReceiveDynamicShadowsLowLod(bool enabled);
+			/** Whether to use shadows on low LOD material rendering (when using composite map) (default false). 
+			*/
+			bool getReceiveDynamicShadowsLowLod() const { return mLowLodShadows; }
+
+			/// Internal
+			bool _isSM3Available() const { return mSM3Available; }
+			bool _isSM4Available() const { return mSM4Available; }
+		
+		protected:
+
+			enum TechniqueType
+			{
+				HIGH_LOD, 
+				LOW_LOD, 
+				RENDER_COMPOSITE_MAP
+			};
+			void addTechnique(const MaterialPtr& mat, const Terrain* terrain, TechniqueType tt);
+
+			/// Interface definition for helper class to generate shaders
+			class _OgreTerrainExport ShaderHelper : public TerrainAlloc
+			{
+			public:
+				ShaderHelper() {}
+				virtual ~ShaderHelper() {}
+				virtual HighLevelGpuProgramPtr generateVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
+				virtual HighLevelGpuProgramPtr generateFragmentProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
+				virtual void updateParams(const SM2Profile* prof, const MaterialPtr& mat, const Terrain* terrain, bool compositeMap);
+			protected:
+				virtual String getVertexProgramName(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
+				virtual String getFragmentProgramName(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
+				virtual HighLevelGpuProgramPtr createVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) = 0;
+				virtual HighLevelGpuProgramPtr createFragmentProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt) = 0;
+				virtual void generateVertexProgramSource(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream);
+				virtual void generateFragmentProgramSource(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream);
+				virtual void generateVpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) = 0;
+				virtual void generateFpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) = 0;
+				virtual void generateVpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream) = 0;
+				virtual void generateFpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream) = 0;
+				virtual void generateVpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) = 0;
+				virtual void generateFpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) = 0;
+				virtual void defaultVpParams(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const HighLevelGpuProgramPtr& prog);
+				virtual void defaultFpParams(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const HighLevelGpuProgramPtr& prog);
+				virtual void updateVpParams(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const GpuProgramParametersSharedPtr& params);
+				virtual void updateFpParams(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, const GpuProgramParametersSharedPtr& params);
+				static String getChannel(uint idx);
+
+				size_t mShadowSamplerStartHi;
+				size_t mShadowSamplerStartLo;
+
+			};
+
+			/// Utility class to help with generating shaders for Cg / HLSL.
+			class _OgreTerrainExport ShaderHelperCg : public ShaderHelper
+			{
+			protected:
+				HighLevelGpuProgramPtr createVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
+				HighLevelGpuProgramPtr createFragmentProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
+				void generateVpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream);
+				void generateFpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream);
+				void generateVpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream);
+				void generateFpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream);
+				void generateVpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream);
+				void generateFpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream);
+				uint generateVpDynamicShadowsParams(uint texCoordStart, const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream);
+				void generateVpDynamicShadows(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream);
+				void generateFpDynamicShadowsHelpers(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream);
+				void generateFpDynamicShadowsParams(uint* texCoord, uint* sampler, const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream);
+				void generateFpDynamicShadows(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream);
+			};
+
+			class _OgreTerrainExport ShaderHelperHLSL : public ShaderHelperCg
+			{
+			protected:
+				HighLevelGpuProgramPtr createVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
+				HighLevelGpuProgramPtr createFragmentProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
+			};
+
+			/// Utility class to help with generating shaders for GLSL.
+			class _OgreTerrainExport ShaderHelperGLSL : public ShaderHelper
+			{
+			protected:
+				HighLevelGpuProgramPtr createVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
+				HighLevelGpuProgramPtr createFragmentProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
+				void generateVpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) {}
+				void generateFpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) {}
+				void generateVpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream) {}
+				void generateFpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream) {}
+				void generateVpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) {}
+				void generateFpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) {}
+			};
+
+            /// Utility class to help with generating shaders for GLSL ES.
+			class ShaderHelperGLSLES : public ShaderHelper
+			{
+			protected:
+				HighLevelGpuProgramPtr createVertexProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
+				HighLevelGpuProgramPtr createFragmentProgram(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt);
+				void generateVpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) {}
+				void generateFpHeader(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) {}
+				void generateVpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream) {}
+				void generateFpLayer(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, uint layer, StringUtil::StrStreamType& outStream) {}
+				void generateVpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) {}
+				void generateFpFooter(const SM2Profile* prof, const Terrain* terrain, TechniqueType tt, StringUtil::StrStreamType& outStream) {}
+			};
+
+			ShaderHelper* mShaderGen;
+			bool mLayerNormalMappingEnabled;
+			bool mLayerParallaxMappingEnabled;
+			bool mLayerSpecularMappingEnabled;
+			bool mGlobalColourMapEnabled;
+			bool mLightmapEnabled;
+			bool mCompositeMapEnabled;
+			bool mReceiveDynamicShadows;
+			PSSMShadowCameraSetup* mPSSM;
+			bool mDepthShadows;
+			bool mLowLodShadows;
+			bool mSM3Available;
+			bool mSM4Available;
+
+			bool isShadowingEnabled(TechniqueType tt, const Terrain* terrain) const;
+
+		};
+
+
+
+
+	};
+
+
+
+	/** @} */
+	/** @} */
+
+
+}
+
+#endif
+

data/deps/include/OGRE/Terrain/OgreTerrainPagedWorldSection.h

@@ -0,0 +1,165 @@
+/*
+-----------------------------------------------------------------------------
+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_TerrainPagedWorldSection_H__
+#define __Ogre_TerrainPagedWorldSection_H__
+
+#include "OgreTerrainPrerequisites.h"
+#include "OgrePagedWorldSection.h"
+#include "OgrePageManager.h"
+
+
+
+namespace Ogre
+{
+	class Grid2DPageStrategy;
+	class Grid2DPageStrategyData;
+	class TerrainGroup;
+
+	/** \addtogroup Optional Components
+	*  @{
+	*/
+	/** \addtogroup Terrain
+	*  Some details on the terrain component
+	*  @{
+	*/
+
+	/** A world section which includes paged terrain. 
+	@remarks
+		Rather than implement terrain paging as a PageContent subclass, because terrain
+		benefits from direct knowledge of neighbour arrangements and the tight
+		coupling between that and the paging strategy, instead we use a PagedWorldSection
+		subclass. This automatically provides a PageStrategy subclass of the
+		correct type (Grid2DPageStrategy) and derives the correct settings for
+		it compared to the terrain being used. This frees the user from having to 
+		try to match all these up through the generic interfaces. 
+	@par
+		When creating this in code, the user should make use of the helper
+		functions on the TerrainPaging class. The basic sequence is that 
+		you define your terrain settings in a TerrainGroup, and then create an 
+		instance of TerrainPagedWorldSection via TerrainPaging::createWorldSection. 
+		That's basically all there is to it - the normal rules of TerrainGroup
+		apply, it's just that instead of having to choose when to try to load / unload
+		pages from the TerrainGroup, that is automatically done by the paging system.
+		You can also create other types of content in this PagedWorldSection other
+		than terrain, it's just that this comes with terrain handling built-in.
+	@par
+		When this world data is saved, you basically get 3 sets of data - firstly
+		the top-level 'world data' which is where the definition of the world
+		sections are stored (and hence, the definition of this class, although none
+		of the terrain instance content is included). Secondly, you get a number
+		of .page files which include any other content that you might have inserted
+		into the pages. Lastly, you get the standard terrain data files which are
+		saved as per TerrainGroup.
+	*/
+	class _OgreTerrainExport TerrainPagedWorldSection : public PagedWorldSection
+	{
+	public:
+		/** Constructor.
+		@param name The name of the section
+		@param parent The parent world
+		@param sm The SceneManager to use (can be left as null if to be loaded)
+		*/
+		TerrainPagedWorldSection(const String& name, PagedWorld* parent, SceneManager* sm);
+		~TerrainPagedWorldSection();
+
+		/** Initialise this section from an existing TerrainGroup instance. 
+		@remarks
+			This is the route you will take if you're defining this world section
+			from scratch in code. The other alternative is that you'll be loading
+			this section from a file, in which case all the settings will be
+			derived from that. 
+		@param grp The TerrainGroup which will form the basis of this world section. 
+			The instance will be owned by this class from now on and will be destroyed by it.
+		*/
+		virtual void init(TerrainGroup* grp);
+
+		/** Get the TerrainGroup which this world section is using. 
+		@remarks For information, you can use the returned TerrainGroup to 
+			convert to/from x/y locations and the pageID, since the grid strategy
+			is the same. 
+		*/
+		virtual TerrainGroup* getTerrainGroup() { return mTerrainGroup; }
+
+		/// Set the loading radius 
+		virtual void setLoadRadius(Real sz);
+		/// Get the loading radius 
+		virtual Real getLoadRadius() const;
+		/// Set the Holding radius 
+		virtual void setHoldRadius(Real sz);
+		/// Get the Holding radius 
+		virtual Real getHoldRadius();
+		/// Set the index range of all Pages (values outside this will be ignored)
+		virtual void setPageRange(int32 minX, int32 minY, int32 maxX, int32 maxY);
+		/// Set the index range of all Pages (values outside this will be ignored)
+		virtual void setPageRangeMinX(int32 minX);
+		/// Set the index range of all Pages (values outside this will be ignored)
+		virtual void setPageRangeMinY(int32 minY);
+		/// Set the index range of all Pages (values outside this will be ignored)
+		virtual void setPageRangeMaxX(int32 maxX);
+		/// Set the index range of all Pages (values outside this will be ignored)
+		virtual void setPageRangeMaxY(int32 maxY);
+		/// get the index range of all Pages (values outside this will be ignored)
+		virtual int32 getPageRangeMinX() const;
+		/// get the index range of all Pages (values outside this will be ignored)
+		virtual int32 getPageRangeMinY() const;
+		/// get the index range of all Pages (values outside this will be ignored)
+		virtual int32 getPageRangeMaxX() const;
+		/// get the index range of all Pages (values outside this will be ignored)
+		virtual int32 getPageRangeMaxY() const;
+
+		/// Convenience method - this section always uses a grid strategy
+		virtual Grid2DPageStrategy* getGridStrategy() const;
+		/// Convenience method - this section always uses a grid strategy
+		virtual Grid2DPageStrategyData* getGridStrategyData() const;
+
+		/// Overridden from PagedWorldSection
+		void loadPage(PageID pageID, bool forceSynchronous = false);
+		/// Overridden from PagedWorldSection
+		void unloadPage(PageID pageID, bool forceSynchronous = false);
+
+	protected:
+		TerrainGroup* mTerrainGroup;
+
+		/// Overridden from PagedWorldSection
+		void loadSubtypeData(StreamSerialiser& ser);
+		void saveSubtypeData(StreamSerialiser& ser);
+
+		virtual void syncSettings();
+
+	};
+
+
+
+
+
+	/** @} */
+	/** @} */
+}
+
+#endif

data/deps/include/OGRE/Terrain/OgreTerrainPaging.h

@@ -0,0 +1,135 @@
+/*
+-----------------------------------------------------------------------------
+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_TerrainPaging_H__
+#define __Ogre_TerrainPaging_H__
+
+#include "OgreTerrainPrerequisites.h"
+#include "OgrePagedWorldSection.h"
+#include "OgrePageManager.h"
+
+
+
+namespace Ogre
+{
+	class PagedWorld;
+	class TerrainGroup;
+	class TerrainPagedWorldSection;
+
+	/** \addtogroup Optional Components
+	*  @{
+	*/
+	/** \addtogroup Terrain
+	*  Some details on the terrain component
+	*  @{
+	*/
+
+	/** This class is the 'core' class for paging terrain, that will integrate
+		with the larger paging system and provide the appropriate utility
+		classes required. 
+	@remarks
+		You should construct this class after PageManager and before any PagedWorlds
+		that might use it are created / loaded. Once constructed, it will make
+		the "Terrain" PagedWorldSection type available, which uses a grid strategy for
+		paging and uses TerrainGroup for the content. Other content can 
+		be embedded in the pages too but the terrain is done like this in order
+		to maintain connections between pages and other global data.
+	@par
+		Because PagedWorld and all attached classes have to be loadable from a stream, 
+		most of the functionality is provided behind generalised interfaces. However,
+		for constructing a paged terrain in code you can use utility methods on 
+		this class. This procedurally created data can then be saved in a generic 
+		form which will reconstruct on loading. Alternatively you can use the 
+		generic methods and simply cast based on your prior knowledge of the types
+		(or checking the type names exposed). 
+
+	*/
+	class _OgreTerrainExport TerrainPaging : public TerrainAlloc
+	{
+	public:
+		/** Constructor.
+		@param pageMgr The PageManager which this class should attach to.
+		*/
+		TerrainPaging(PageManager* pageMgr);
+		~TerrainPaging();
+
+		/** Create a TerrainPagedWorldSection.
+		@remarks
+			This is the simplest way to create a world section which is configured
+			to contain terrain (among other objects if you want). You can also do this
+			by calling PagedWorld::createSection with the type "Terrain" but there
+			are more steps to configuring it that way (note: this is how loading 
+			works though so it remains generic).
+		@param world The PagedWorld that is to contain this section
+		@param terrainGroup A TerrainGroup which must have been pre-configured before
+			this call, to at least set the origin, the world size, and the file name
+			convention.
+		@param loadRadius The radius from the camera at which terrain pages will be loaded
+		@param holdRadius The radius from the camera at which terrain pages will be held in memory
+			but not loaded if they're not already. This must be larger than loadRadius and is used
+			to minimise thrashing if the camera goes backwards and forwards at the loading border.
+		@param minX,minY,maxX,maxY The min/max page indexes that the world will try to load pages for, 
+			as measured from the origin page at (0,0) by a signed index. The default is -10 to 10
+			in each direction or 20x20 pages.
+		@param sectionName An optional name to give the section (if none is
+			provided, one will be generated)
+		@return The world section which is already attached to and owned by the world you passed in. 
+			There is no 'destroy' method because you destroy via the PagedWorld, this is just a
+			helper function. 
+		*/
+		TerrainPagedWorldSection* createWorldSection(PagedWorld* world, TerrainGroup* terrainGroup, 
+			Real loadRadius, Real holdRadius, 
+			int32 minX = -10, int32 minY = -10, int32 maxX = 10, int32 maxY = 10, 
+			const String& sectionName = StringUtil::BLANK);
+
+	protected:
+		PageManager* mManager;
+
+		class _OgreTerrainExport SectionFactory : public PagedWorldSectionFactory
+		{
+		public:
+			static const String FACTORY_NAME;
+			const String& getName() const;
+			PagedWorldSection* createInstance(const String& name, PagedWorld* parent, SceneManager* sm);
+			void destroyInstance(PagedWorldSection*);
+
+		};
+
+		SectionFactory mSectionFactory;
+
+	};
+
+
+
+
+
+	/** @} */
+	/** @} */
+}
+
+#endif

data/deps/include/OGRE/Terrain/OgreTerrainPrerequisites.h

@@ -0,0 +1,68 @@
+/*
+-----------------------------------------------------------------------------
+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_Terrain_Prereq_H__
+#define __Ogre_Terrain_Prereq_H__
+
+#include "OgrePrerequisites.h"
+
+namespace Ogre
+{
+	// forward decls
+	class Terrain;
+	class TerrainPageContent;
+	class TerrainPageContentFactory;
+	class TerrainQuadTreeNode;
+
+
+	typedef GeneralAllocatedObject TerrainAlloc;
+
+
+}
+
+#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
+#	if defined( OGRE_STATIC_LIB )
+#   	define _OgreTerrainExport
+#   else
+#   	if defined( OGRE_TERRAIN_EXPORTS )
+#       	define _OgreTerrainExport __declspec( dllexport )
+#   	else
+#           if defined( __MINGW32__ )
+#               define _OgreTerrainExport
+#           else
+#       	    define _OgreTerrainExport __declspec( dllimport )
+#           endif
+#   	endif
+#	endif
+#elif defined ( OGRE_GCC_VISIBILITY )
+#   define _OgreTerrainExport __attribute__ ((visibility("default")))
+#else
+#	define _OgreTerrainExport
+#endif 
+
+#endif