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

data/deps/include/OGRE/OgreStableHeaders.h

@@ -1,82 +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.
------------------------------------------------------------------------------
-*/
-
-/* Stable headers which will be used for precompilation if the compiler
-   supports it. Add entries here when headers are unlikely to change.
-   NB: a change to any of these headers will result in a full rebuild,
-   so don't add things to this lightly.
-*/
-
-#ifndef __OgreStableHeaders__
-#define __OgreStableHeaders__
-
-#include "OgrePlatform.h"
-
-#if (OGRE_PLATFORM == OGRE_PLATFORM_WIN32 && !defined(__MINGW32__)) || OGRE_PLATFORM == OGRE_PLATFORM_APPLE || OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-#include "OgreArchive.h"
-#include "OgreAxisAlignedBox.h"
-#include "OgreBitwise.h"
-#include "OgreCamera.h"
-#include "OgreColourValue.h"
-#include "OgreCommon.h"
-#include "OgreDataStream.h"
-#include "OgreException.h"
-#include "OgreFileSystem.h"
-#include "OgreLog.h"
-#include "OgreMath.h"
-#include "OgreMatrix3.h"
-#include "OgreMatrix4.h"
-#include "OgreMovableObject.h"
-#include "OgreNode.h"
-#include "OgrePlane.h"
-#include "OgrePrerequisites.h"
-#include "OgreQuaternion.h"
-#include "OgreResource.h"
-#include "OgreSerializer.h"
-#include "OgreSharedPtr.h"
-#include "OgreSimpleRenderable.h"
-#include "OgreSimpleSpline.h"
-#include "OgreSingleton.h"
-#include "OgreSphere.h"
-#include "OgreStdHeaders.h"
-#include "OgreString.h"
-#include "OgreStringConverter.h"
-#include "OgreStringInterface.h"
-#include "OgreStringVector.h"
-#include "OgreUserObjectBindings.h"
-#include "OgreVector2.h"
-#include "OgreVector3.h"
-#include "OgreVector4.h"
-#include "OgreWireBoundingBox.h"
-#if OGRE_NO_ZIP_ARCHIVE == 0
-#	include "OgreZip.h"
-#endif
-
-#endif
-
-#endif 

data/deps/include/OGRE/OgreStaticFaceGroup.h

@@ -1,141 +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 __StaticFaceGroup_H__
-#define __StaticFaceGroup_H__
-
-#include "OgrePrerequisites.h"
-
-#include "OgrePlane.h"
-#include "OgrePatchSurface.h"
-
-namespace Ogre {
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Scene
-	*  @{
-	*/
-	/** A type of face group, i.e. face list of procedural etc */
-    enum FaceGroupType {
-        FGT_FACE_LIST,
-        FGT_PATCH,
-        FGT_UNKNOWN
-    };
-
-    /** Collects a group of static i.e. immovable faces together which have common
-        properties like the material they use, the plane they lie on.
-        @remarks
-            Whilst for discrete geometry (i.e. movable objects) groups of faces are
-            held in the SubMesh class, for immovable objects like scenery there
-            needs to ba little more flexibility in the grouping since the group is
-            likely to be a small part of a huge set of geometry. In addition, because
-            the faces are unmoving certain optimisations can be performed, e.g.
-            precalculating a world-coordinate bounding box and normal.
-        @par
-            Exactly how this class is used depends on the format of the large
-            static geometry used in the level. An example would be the use of this
-            class in the BspNode class for indoor levels.
-            For flexibility and efficiency, it is not assumed that this class holds
-            details of the vertices itself, or in fact that it holds the vertex indices
-            itself. Everything is manipulated via pointers so if you want this
-            class to point into a block of geometry data it can.
-    */
-    struct StaticFaceGroup {
-        // Type of face group.
-        FaceGroupType fType;
-
-        /// Is this a sky surface?
-        bool isSky;
-
-        /** Index into a buffer containing vertex definitions. Because we're
-            dealing with subsets of large levels this is likely to be part-way
-            through a huge vertex buffer. */
-        int vertexStart;
-
-        /** The range of vertices in the buffer this facegroup references.
-            This is really for copying purposes only, so that we know which
-            subset of vertices to copy from our large-level buffer into the rendering buffer.
-        */
-        int numVertices;
-
-        /** Index into a buffer containing vertex indices. This buffer
-            may be individual to this group or shared for memory allocation
-            efficiency.The vertex indexes are relative the the mVertexStart pointer,
-            not to the start of the large-level buffer, allowing simple reindexing
-            when copying data into rendering buffers.
-            This is only applicable to FGT_FACE_LIST face group types.
-        */
-        int elementStart;
-
-        /** The number of vertex indices.
-            This is only applicable to FGT_FACE_LIST face group types.
-        */
-        int numElements;
-
-        /** Handle to material used by this group.
-            Note the use of the material handle rather than the material
-            name - this is for efficiency since there will be many of these.
-        */
-        int materialHandle;
-
-        Plane plane;
-
-        /// Patch surface (only applicable when fType = FGT_PATCH)
-        PatchSurface* patchSurf;
-
-
-        _OgreExport friend std::ostream& operator<<(std::ostream& o, const StaticFaceGroup& s)
-        {
-            o << "StaticFaceGroup(";
-            if (s.fType == FGT_FACE_LIST)
-            {
-                o << "faceList, numVertices=" << s.numVertices << ", vertexStart=" << s.vertexStart;
-                o << ", numElements=" << s.numElements << ", elementStart=" << s.elementStart;
-                o << ", normal=" << s.plane.normal;
-            }
-            else if (s.fType == FGT_PATCH)
-            {
-                o << "bezierPatch, numVertices=" << s.numVertices << ", vertexStart=" << s.vertexStart;
-                // TODO
-            }
-
-            o << ", materialHandle=" << s.materialHandle;
-            o << ")";
-
-            return o;
-        }
-
-
-    };
-	/** @} */
-	/** @} */
-
-} // namespace
-
-#endif

data/deps/include/OGRE/OgreStaticGeometry.h

@@ -1,781 +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 __StaticGeometry_H__
-#define __StaticGeometry_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreMovableObject.h"
-#include "OgreRenderable.h"
-#include "OgreMesh.h"
-#include "OgreLodStrategy.h"
-
-namespace Ogre {
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Scene
-	*  @{
-	*/
-	/** Pre-transforms and batches up meshes for efficient use as static
-		geometry in a scene.
-	@remarks
-		Modern graphics cards (GPUs) prefer to receive geometry in large
-		batches. It is orders of magnitude faster to render 10 batches
-		of 10,000 triangles than it is to render 10,000 batches of 10 
-		triangles, even though both result in the same number of on-screen
-		triangles.
-	@par
-		Therefore it is important when you are rendering a lot of geometry to 
-		batch things up into as few rendering calls as possible. This
-		class allows you to build a batched object from a series of entities 
-		in order to benefit from this behaviour.
-		Batching has implications of it's own though:
-		@li Batched geometry cannot be subdivided; that means that the whole
-			group will be displayed, or none of it will. This obivously has
-			culling issues.
-		@li A single world transform must apply to the entire batch. Therefore
-			once you have batched things, you can't move them around relative to
-			each other. That's why this class is most useful when dealing with 
-			static geometry (hence the name). In addition, geometry is 
-			effectively duplicated, so if you add 3 entities based on the same 
-			mesh in different positions, they will use 3 times the geometry 
-			space than the movable version (which re-uses the same geometry). 
-			So you trade memory	and flexibility of movement for pure speed when
-			using this class.
-		@li A single material must apply for each batch. In fact this class 
-			allows you to use multiple materials, but you should be aware that 
-			internally this means that there is one batch per material. 
-			Therefore you won't gain as much benefit from the batching if you 
-			use many different materials; try to keep the number down.
-	@par
-		In order to retain some sort of culling, this class will batch up 
-		meshes in localised regions. The size and shape of these blocks is
-		controlled by the SceneManager which constructs this object, since it
-		makes sense to batch things up in the most appropriate way given the 
-		existing partitioning of the scene. 
-	@par
-		The LOD settings of both the Mesh and the Materials used in 
-		constructing this static geometry will be respected. This means that 
-		if you use meshes/materials which have LOD, batches in the distance 
-		will have a lower polygon count or material detail to those in the 
-		foreground. Since each mesh might have different LOD distances, during 
-		build the furthest distance at each LOD level from all meshes  
-		in that region is used. This means all the LOD levels change at the 
-		same time, but at the furthest distance of any of them (so quality is 
-		not degraded). Be aware that using Mesh LOD in this class will 
-		further increase the memory required. Only generated LOD
-		is supported for meshes.
-	@par
-		There are 2 ways you can add geometry to this class; you can add
-		Entity objects directly with predetermined positions, scales and 
-		orientations, or you can add an entire SceneNode and it's subtree, 
-		including all the objects attached to it. Once you've added everything
-		you need to, you have to call build() the fix the geometry in place. 
-	@note
-		This class is not a replacement for world geometry (@see 
-		SceneManager::setWorldGeometry). The single most efficient way to 
-		render large amounts of static geometry is to use a SceneManager which 
-		is specialised for dealing with that particular world structure. 
-		However, this class does provide you with a good 'halfway house'
-		between generalised movable geometry (Entity) which works with all 
-		SceneManagers but isn't efficient when using very large numbers, and 
-		highly specialised world geometry which is extremely fast but not 
-		generic and typically requires custom world editors.
-	@par
-		You should not construct instances of this class directly; instead, cal 
-		SceneManager::createStaticGeometry, which gives the SceneManager the 
-		option of providing you with a specialised version of this class if it
-		wishes, and also handles the memory management for you like other 
-		classes.
-	@note
-		Warning: this class only works with indexed triangle lists at the moment,
-		do not pass it triangle strips, fans or lines / points, or unindexed geometry.
-	*/
-	class _OgreExport StaticGeometry : public BatchedGeometryAlloc
-	{
-	public:
-		/** Struct holding geometry optimised per SubMesh / lod level, ready
-			for copying to instances. 
-		@remarks
-			Since we're going to be duplicating geometry lots of times, it's
-			far more important that we don't have redundant vertex data. If a 
-			SubMesh uses shared geometry, or we're looking at a lower LOD, not
-			all the vertices are being referenced by faces on that submesh.
-			Therefore to duplicate them, potentially hundreds or even thousands
-			of times, would be extremely wasteful. Therefore, if a SubMesh at
-			a given LOD has wastage, we create an optimised version of it's
-			geometry which is ready for copying with no wastage.
-		*/
-		class _OgrePrivate OptimisedSubMeshGeometry : public BatchedGeometryAlloc
-		{
-		public:
-			OptimisedSubMeshGeometry() :vertexData(0), indexData(0) {}
-			~OptimisedSubMeshGeometry() 
-			{
-				OGRE_DELETE vertexData;
-				OGRE_DELETE indexData;
-			}
-			VertexData *vertexData;
-			IndexData *indexData;
-		};
-		typedef list<OptimisedSubMeshGeometry*>::type OptimisedSubMeshGeometryList;
-		/// Saved link between SubMesh at a LOD and vertex/index data
-		/// May point to original or optimised geometry
-		struct SubMeshLodGeometryLink
-		{
-			VertexData* vertexData;
-			IndexData* indexData;
-		};
-		typedef vector<SubMeshLodGeometryLink>::type SubMeshLodGeometryLinkList;
-		typedef map<SubMesh*, SubMeshLodGeometryLinkList*>::type SubMeshGeometryLookup;
-		/// Structure recording a queued submesh for the build
-		struct QueuedSubMesh : public BatchedGeometryAlloc
-		{
-			SubMesh* submesh;
-			/// Link to LOD list of geometry, potentially optimised
-			SubMeshLodGeometryLinkList* geometryLodList;
-			String materialName;
-			Vector3 position;
-			Quaternion orientation;
-			Vector3 scale;
-			/// Pre-transformed world AABB 
-			AxisAlignedBox worldBounds;
-		};
-		typedef vector<QueuedSubMesh*>::type QueuedSubMeshList;
-		/// Structure recording a queued geometry for low level builds
-		struct QueuedGeometry : public BatchedGeometryAlloc
-		{
-			SubMeshLodGeometryLink* geometry;
-			Vector3 position;
-			Quaternion orientation;
-			Vector3 scale;
-		};
-		typedef vector<QueuedGeometry*>::type QueuedGeometryList;
-		
-		// forward declarations
-		class LODBucket;
-		class MaterialBucket;
-		class Region;
-
-		/** A GeometryBucket is a the lowest level bucket where geometry with 
-			the same vertex & index format is stored. It also acts as the 
-			renderable.
-		*/
-		class _OgreExport GeometryBucket :	public Renderable,  public BatchedGeometryAlloc
-		{
-		protected:
-			/// Geometry which has been queued up pre-build (not for deallocation)
-			QueuedGeometryList mQueuedGeometry;
-			/// Pointer to parent bucket
-			MaterialBucket* mParent;
-			/// String identifying the vertex / index format
-			String mFormatString;
-			/// Vertex information, includes current number of vertices
-			/// committed to be a part of this bucket
-			VertexData* mVertexData;
-			/// Index information, includes index type which limits the max
-			/// number of vertices which are allowed in one bucket
-			IndexData* mIndexData;
-			/// Size of indexes
-			HardwareIndexBuffer::IndexType mIndexType;
-			/// Maximum vertex indexable
-			size_t mMaxVertexIndex;
-
-			template<typename T>
-			void copyIndexes(const T* src, T* dst, size_t count, size_t indexOffset)
-			{
-				if (indexOffset == 0)
-				{
-					memcpy(dst, src, sizeof(T) * count);
-				}
-				else
-				{
-					while(count--)
-					{
-						*dst++ = static_cast<T>(*src++ + indexOffset);
-					}
-				}
-			}
-		public:
-			GeometryBucket(MaterialBucket* parent, const String& formatString, 
-				const VertexData* vData, const IndexData* iData);
-			virtual ~GeometryBucket();
-			MaterialBucket* getParent(void) { return mParent; }
-			/// Get the vertex data for this geometry 
-			const VertexData* getVertexData(void) const { return mVertexData; }
-			/// Get the index data for this geometry 
-			const IndexData* getIndexData(void) const { return mIndexData; }
-			/// @copydoc Renderable::getMaterial
-			const MaterialPtr& getMaterial(void) const;
-			Technique* getTechnique(void) const;
-			void getRenderOperation(RenderOperation& op);
-	        void getWorldTransforms(Matrix4* xform) const;
-			Real getSquaredViewDepth(const Camera* cam) const;
-	        const LightList& getLights(void) const;
-			bool getCastsShadows(void) const;
-			
-			/** Try to assign geometry to this bucket.
-			@return false if there is no room left in this bucket
-			*/
-			bool assign(QueuedGeometry* qsm);
-			/// Build
-			void build(bool stencilShadows);
-			/// Dump contents for diagnostics
-			void dump(std::ofstream& of) const;
-		};
-		/** A MaterialBucket is a collection of smaller buckets with the same 
-			Material (and implicitly the same LOD). */
-		class _OgreExport MaterialBucket : public BatchedGeometryAlloc
-		{
-		public:
-			/// list of Geometry Buckets in this region
-			typedef vector<GeometryBucket*>::type GeometryBucketList;
-		protected:
-			/// Pointer to parent LODBucket
-			LODBucket* mParent;
-			/// Material being used
-			String mMaterialName;
-			/// Pointer to material being used
-			MaterialPtr mMaterial;
-			/// Active technique
-			Technique* mTechnique;
-
-			/// list of Geometry Buckets in this region
-			GeometryBucketList mGeometryBucketList;
-			// index to current Geometry Buckets for a given geometry format
-			typedef map<String, GeometryBucket*>::type CurrentGeometryMap;
-			CurrentGeometryMap mCurrentGeometryMap;
-			/// Get a packed string identifying the geometry format
-			String getGeometryFormatString(SubMeshLodGeometryLink* geom);
-			
-		public:
-			MaterialBucket(LODBucket* parent, const String& materialName);
-			virtual ~MaterialBucket();
-			LODBucket* getParent(void) { return mParent; }
-			/// Get the material name
-			const String& getMaterialName(void) const { return mMaterialName; }
-			/// Assign geometry to this bucket
-			void assign(QueuedGeometry* qsm);
-			/// Build
-			void build(bool stencilShadows);
-			/// Add children to the render queue
-			void addRenderables(RenderQueue* queue, uint8 group, 
-				Real lodValue);
-			/// Get the material for this bucket
-			const MaterialPtr& getMaterial(void) const { return mMaterial; }
-			/// Iterator over geometry
-			typedef VectorIterator<GeometryBucketList> GeometryIterator;
-			/// Get an iterator over the contained geometry
-			GeometryIterator getGeometryIterator(void);
-			/// Get the current Technique
-			Technique* getCurrentTechnique(void) const { return mTechnique; }
-			/// Dump contents for diagnostics
-			void dump(std::ofstream& of) const;
-			void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
-		};
-		/** A LODBucket is a collection of smaller buckets with the same LOD. 
-		@remarks
-			LOD refers to Mesh LOD here. Material LOD can change separately
-			at the next bucket down from this.
-		*/
-		class _OgreExport LODBucket : public BatchedGeometryAlloc
-		{
-		public:
-			/// Lookup of Material Buckets in this region
-			typedef map<String, MaterialBucket*>::type MaterialBucketMap;
-		protected:
-			/** Nested class to allow shadows. */
-			class _OgreExport LODShadowRenderable : public ShadowRenderable
-			{
-			protected:
-				LODBucket* mParent;
-				// Shared link to position buffer
-				HardwareVertexBufferSharedPtr mPositionBuffer;
-				// Shared link to w-coord buffer (optional)
-				HardwareVertexBufferSharedPtr mWBuffer;
-
-			public:
-				LODShadowRenderable(LODBucket* parent, 
-					HardwareIndexBufferSharedPtr* indexBuffer, const VertexData* vertexData, 
-					bool createSeparateLightCap, bool isLightCap = false);
-				~LODShadowRenderable();
-				/// Overridden from ShadowRenderable
-				void getWorldTransforms(Matrix4* xform) const;
-				HardwareVertexBufferSharedPtr getPositionBuffer(void) { return mPositionBuffer; }
-				HardwareVertexBufferSharedPtr getWBuffer(void) { return mWBuffer; }
-				/// Overridden from ShadowRenderable
-				virtual void rebindIndexBuffer(const HardwareIndexBufferSharedPtr& indexBuffer);
-
-			};
-			/// Pointer to parent region
-			Region* mParent;
-			/// LOD level (0 == full LOD)
-			unsigned short mLod;
-			/// lod value at which this LOD starts to apply (squared)
-			Real mLodValue;
-			/// Lookup of Material Buckets in this region
-			MaterialBucketMap mMaterialBucketMap;
-			/// Geometry queued for a single LOD (deallocated here)
-			QueuedGeometryList mQueuedGeometryList;
-			/// Edge list, used if stencil shadow casting is enabled 
-			EdgeData* mEdgeList;
-			/// Is a vertex program in use somewhere in this group?
-			bool mVertexProgramInUse;
-			/// List of shadow renderables
-			ShadowCaster::ShadowRenderableList mShadowRenderables;
-		public:
-			LODBucket(Region* parent, unsigned short lod, Real lodValue);
-			virtual ~LODBucket();
-			Region* getParent(void) { return mParent; }
-			/// Get the lod index
-			ushort getLod(void) const { return mLod; }
-			/// Get the lod value
-			Real getLodValue(void) const { return mLodValue; }
-			/// Assign a queued submesh to this bucket, using specified mesh LOD
-			void assign(QueuedSubMesh* qsm, ushort atLod);
-			/// Build
-			void build(bool stencilShadows);
-			/// Add children to the render queue
-			void addRenderables(RenderQueue* queue, uint8 group, 
-				Real lodValue);
-			/// Iterator over the materials in this LOD
-			typedef MapIterator<MaterialBucketMap> MaterialIterator;
-			/// Get an iterator over the materials in this LOD
-			MaterialIterator getMaterialIterator(void);
-			/// Dump contents for diagnostics
-			void dump(std::ofstream& of) const;
-			void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
-			EdgeData* getEdgeList() const { return mEdgeList; }
-			ShadowCaster::ShadowRenderableList& getShadowRenderableList() { return mShadowRenderables; }
-			bool isVertexProgramInUse() const { return mVertexProgramInUse; }
-			void updateShadowRenderables(
-				ShadowTechnique shadowTechnique, const Vector4& lightPos, 
-				HardwareIndexBufferSharedPtr* indexBuffer, 
-				bool extrudeVertices, Real extrusionDistance, unsigned long flags = 0 );
-			
-		};
-		/** The details of a topological region which is the highest level of
-			partitioning for this class.
-		@remarks
-			The size & shape of regions entirely depends on the SceneManager
-			specific implementation. It is a MovableObject since it will be
-			attached to a node based on the local centre - in practice it
-			won't actually move (although in theory it could).
-		*/
-		class _OgreExport Region : public MovableObject
-		{
-            friend class MaterialBucket;
-            friend class GeometryBucket;
-		public:
-			/// list of LOD Buckets in this region
-			typedef vector<LODBucket*>::type LODBucketList;
-		protected:
-			/// Parent static geometry
-			StaticGeometry* mParent;
-			/// Scene manager link
-			SceneManager* mSceneMgr;
-			/// Scene node
-			SceneNode* mNode;
-			/// Local list of queued meshes (not used for deallocation)
-			QueuedSubMeshList mQueuedSubMeshes;
-			/// Unique identifier for the region
-			uint32 mRegionID;
-			/// Center of the region
-			Vector3 mCentre;
-			/// Lod values as built up - use the max at each level
-			Mesh::LodValueList mLodValues;
-			/// Local AABB relative to region centre
-			AxisAlignedBox mAABB;
-			/// Local bounding radius
-			Real mBoundingRadius;
-			/// The current lod level, as determined from the last camera
-			ushort mCurrentLod;
-			/// Current lod value, passed on to do material lod later
-			Real mLodValue;
-			/// List of LOD buckets			
-			LODBucketList mLodBucketList;
-			/// List of lights for this region
-			mutable LightList mLightList;
-			/// The last frame that this light list was updated in
-			mutable ulong mLightListUpdated;
-            /// Lod strategy reference
-            const LodStrategy *mLodStrategy;
-            /// Current camera
-            Camera *mCamera;
-            /// Cached squared view depth value to avoid recalculation by GeometryBucket
-            Real mSquaredViewDepth;
-
-		public:
-			Region(StaticGeometry* parent, const String& name, SceneManager* mgr, 
-				uint32 regionID, const Vector3& centre);
-			virtual ~Region();
-			// more fields can be added in subclasses
-			StaticGeometry* getParent(void) const { return mParent;}
-			/// Assign a queued mesh to this region, read for final build
-			void assign(QueuedSubMesh* qmesh);
-			/// Build this region
-			void build(bool stencilShadows);
-			/// Get the region ID of this region
-			uint32 getID(void) const { return mRegionID; }
-			/// Get the centre point of the region
-			const Vector3& getCentre(void) const { return mCentre; }
-			const String& getMovableType(void) const;
-			void _notifyCurrentCamera(Camera* cam);
-			const AxisAlignedBox& getBoundingBox(void) const;
-			Real getBoundingRadius(void) const;
-			void _updateRenderQueue(RenderQueue* queue);
-			/// @copydoc MovableObject::visitRenderables
-			void visitRenderables(Renderable::Visitor* visitor, 
-				bool debugRenderables = false);
-			bool isVisible(void) const;
-			uint32 getTypeFlags(void) const;
-
-			typedef VectorIterator<LODBucketList> LODIterator;
-			/// Get an iterator over the LODs in this region
-			LODIterator getLODIterator(void);
-			/// @copydoc ShadowCaster::getShadowVolumeRenderableIterator
-			ShadowRenderableListIterator getShadowVolumeRenderableIterator(
-				ShadowTechnique shadowTechnique, const Light* light, 
-				HardwareIndexBufferSharedPtr* indexBuffer, 
-				bool extrudeVertices, Real extrusionDistance, unsigned long flags = 0 );
-			/// Overridden from MovableObject
-			EdgeData* getEdgeList(void);
-			/** Overridden member from ShadowCaster. */
-			bool hasEdgeList(void);
-
-			/// Dump contents for diagnostics
-			void dump(std::ofstream& of) const;
-			
-		};
-		/** Indexed region map based on packed x/y/z region index, 10 bits for
-			each axis.
-		@remarks
-			Regions are indexed 0-1023 in all axes, where for example region 
-			0 in the x axis begins at mOrigin.x + (mRegionDimensions.x * -512), 
-			and region 1023 ends at mOrigin + (mRegionDimensions.x * 512).
-		*/
-		typedef map<uint32, Region*>::type RegionMap;
-	protected:
-		// General state & settings
-		SceneManager* mOwner;
-		String mName;
-		bool mBuilt;
-		Real mUpperDistance;
-		Real mSquaredUpperDistance;
-		bool mCastShadows;
-		Vector3 mRegionDimensions;
-		Vector3 mHalfRegionDimensions;
-		Vector3 mOrigin;
-		bool mVisible;
-        /// The render queue to use when rendering this object
-        uint8 mRenderQueueID;
-		/// Flags whether the RenderQueue's default should be used.
-		bool mRenderQueueIDSet;
-		/// Stores the visibility flags for the regions
-		uint32 mVisibilityFlags;
-
-		QueuedSubMeshList mQueuedSubMeshes;
-
-		/// List of geometry which has been optimised for SubMesh use
-		/// This is the primary storage used for cleaning up later
-		OptimisedSubMeshGeometryList mOptimisedSubMeshGeometryList;
-
-		/** Cached links from SubMeshes to (potentially optimised) geometry
-			This is not used for deletion since the lookup may reference
-			original vertex data
-		*/
-		SubMeshGeometryLookup mSubMeshGeometryLookup;
-			
-		/// Map of regions
-		RegionMap mRegionMap;
-
-		/** Virtual method for getting a region most suitable for the
-			passed in bounds. Can be overridden by subclasses.
-		*/
-		virtual Region* getRegion(const AxisAlignedBox& bounds, bool autoCreate);
-		/** Get the region within which a point lies */
-		virtual Region* getRegion(const Vector3& point, bool autoCreate);
-		/** Get the region using indexes */
-		virtual Region* getRegion(ushort x, ushort y, ushort z, bool autoCreate);
-		/** Get the region using a packed index, returns null if it doesn't exist. */
-		virtual Region* getRegion(uint32 index);
-		/** Get the region indexes for a point.
-		*/
-		virtual void getRegionIndexes(const Vector3& point, 
-			ushort& x, ushort& y, ushort& z);
-		/** Pack 3 indexes into a single index value
-		*/
-		virtual uint32 packIndex(ushort x, ushort y, ushort z);
-		/** Get the volume intersection for an indexed region with some bounds.
-		*/
-		virtual Real getVolumeIntersection(const AxisAlignedBox& box,  
-			ushort x, ushort y, ushort z);
-		/** Get the bounds of an indexed region.
-		*/
-		virtual AxisAlignedBox getRegionBounds(ushort x, ushort y, ushort z);
-		/** Get the centre of an indexed region.
-		*/
-		virtual Vector3 getRegionCentre(ushort x, ushort y, ushort z);
-		/** Calculate world bounds from a set of vertex data. */
-		virtual AxisAlignedBox calculateBounds(VertexData* vertexData, 
-			const Vector3& position, const Quaternion& orientation, 
-			const Vector3& scale);
-		/** Look up or calculate the geometry data to use for this SubMesh */
-		SubMeshLodGeometryLinkList* determineGeometry(SubMesh* sm);
-		/** Split some shared geometry into dedicated geometry. */
-		void splitGeometry(VertexData* vd, IndexData* id, 
-			SubMeshLodGeometryLink* targetGeomLink);
-
-		typedef map<size_t, size_t>::type IndexRemap;
-		/** Method for figuring out which vertices are used by an index buffer
-			and calculating a remap lookup for a vertex buffer just containing
-			those vertices. 
-		*/
-		template <typename T>
-		void buildIndexRemap(T* pBuffer, size_t numIndexes, IndexRemap& remap)
-		{
-			remap.clear();
-			for (size_t i = 0; i < numIndexes; ++i)
-			{
-				// use insert since duplicates are silently discarded
-				remap.insert(IndexRemap::value_type(*pBuffer++, remap.size()));
-				// this will have mapped oldindex -> new index IF oldindex
-				// wasn't already there
-			}
-		}
-		/** Method for altering indexes based on a remap. */
-		template <typename T>
-		void remapIndexes(T* src, T* dst, const IndexRemap& remap, 
-				size_t numIndexes)
-		{
-			for (size_t i = 0; i < numIndexes; ++i)
-			{
-				// look up original and map to target
-				IndexRemap::const_iterator ix = remap.find(*src++);
-				assert(ix != remap.end());
-				*dst++ = static_cast<T>(ix->second);
-			}
-		}
-		
-	public:
-		/// Constructor; do not use directly (@see SceneManager::createStaticGeometry)
-		StaticGeometry(SceneManager* owner, const String& name);
-		/// Destructor
-		virtual ~StaticGeometry();
-
-		/// Get the name of this object
-		const String& getName(void) const { return mName; }
-		/** Adds an Entity to the static geometry.
-		@remarks
-			This method takes an existing Entity and adds its details to the 
-			list of	elements to include when building. Note that the Entity
-			itself is not copied or referenced in this method; an Entity is 
-			passed simply so that you can change the materials of attached 
-			SubEntity objects if you want. You can add the same Entity 
-			instance multiple times with different material settings 
-			completely safely, and destroy the Entity before destroying 
-			this StaticGeometry if you like. The Entity passed in is simply 
-			used as a definition.
-		@note Must be called before 'build'.
-		@param ent The Entity to use as a definition (the Mesh and Materials 
-			referenced will be recorded for the build call).
-		@param position The world position at which to add this Entity
-		@param orientation The world orientation at which to add this Entity
-		@param scale The scale at which to add this entity
-		*/
-		virtual void addEntity(Entity* ent, const Vector3& position,
-			const Quaternion& orientation = Quaternion::IDENTITY, 
-			const Vector3& scale = Vector3::UNIT_SCALE);
-
-		/** Adds all the Entity objects attached to a SceneNode and all it's
-			children to the static geometry.
-		@remarks
-			This method performs just like addEntity, except it adds all the 
-			entities attached to an entire sub-tree to the geometry. 
-			The position / orientation / scale parameters are taken from the
-			node structure instead of being specified manually. 
-		@note
-			The SceneNode you pass in will not be automatically detached from 
-			it's parent, so if you have this node already attached to the scene
-			graph, you will need to remove it if you wish to avoid the overhead
-			of rendering <i>both</i> the original objects and their new static
-			versions! We don't do this for you incase you are preparing this 
-			in advance and so don't want the originals detached yet. 
-		@note Must be called before 'build'.
-		@param node Pointer to the node to use to provide a set of Entity 
-			templates
-		*/
-		virtual void addSceneNode(const SceneNode* node);
-
-		/** Build the geometry. 
-		@remarks
-			Based on all the entities which have been added, and the batching 
-			options which have been set, this method constructs	the batched 
-			geometry structures required. The batches are added to the scene 
-			and will be rendered unless you specifically hide them.
-		@note
-			Once you have called this method, you can no longer add any more 
-			entities.
-		*/
-		virtual void build(void);
-
-		/** Destroys all the built geometry state (reverse of build). 
-		@remarks
-			You can call build() again after this and it will pick up all the
-			same entities / nodes you queued last time.
-		*/
-		virtual void destroy(void);
-
-		/** Clears any of the entities / nodes added to this geometry and 
-			destroys anything which has already been built.
-		*/
-		virtual void reset(void);
-
-		/** Sets the distance at which batches are no longer rendered.
-		@remarks
-			This lets you turn off batches at a given distance. This can be 
-			useful for things like detail meshes (grass, foliage etc) and could
-			be combined with a shader which fades the geometry out beforehand 
-			to lessen the effect.
-		@param dist Distance beyond which the batches will not be rendered 
-			(the default is 0, which means batches are always rendered).
-		*/
-		virtual void setRenderingDistance(Real dist) { 
-			mUpperDistance = dist; 
-			mSquaredUpperDistance = mUpperDistance * mUpperDistance;
-		}
-
-		/** Gets the distance at which batches are no longer rendered. */
-		virtual Real getRenderingDistance(void) const { return mUpperDistance; }
-
-		/** Gets the squared distance at which batches are no longer rendered. */
-		virtual Real getSquaredRenderingDistance(void) const 
-		{ return mSquaredUpperDistance; }
-
-		/** Hides or shows all the batches. */
-		virtual void setVisible(bool visible);
-
-		/** Are the batches visible? */
-		virtual bool isVisible(void) const { return mVisible; }
-
-		/** Sets whether this geometry should cast shadows.
-		@remarks
-			No matter what the settings on the original entities,
-			the StaticGeometry class defaults to not casting shadows. 
-			This is because, being static, unless you have moving lights
-			you'd be better to use precalculated shadows of some sort.
-			However, if you need them, you can enable them using this
-			method. If the SceneManager is set up to use stencil shadows,
-			edge lists will be copied from the underlying meshes on build.
-			It is essential that all meshes support stencil shadows in this
-			case.
-		@note If you intend to use stencil shadows, you must set this to 
-			true before calling 'build' as well as making sure you set the
-			scene's shadow type (that should always be the first thing you do
-			anyway). You can turn shadows off temporarily but they can never 
-			be turned on if they were not at the time of the build. 
-		*/
-		virtual void setCastShadows(bool castShadows);
-		/// Will the geometry from this object cast shadows?
-		virtual bool getCastShadows(void) { return mCastShadows; }
-
-		/** Sets the size of a single region of geometry.
-		@remarks
-			This method allows you to configure the physical world size of 
-			each region, so you can balance culling against batch size. Entities
-			will be fitted within the batch they most closely fit, and the 
-			eventual bounds of each batch may well be slightly larger than this
-			if they overlap a little. The default is Vector3(1000, 1000, 1000).
-		@note Must be called before 'build'.
-		@param size Vector3 expressing the 3D size of each region.
-		*/
-		virtual void setRegionDimensions(const Vector3& size) { 
-			mRegionDimensions = size; 
-			mHalfRegionDimensions = size * 0.5;
-		}
-		/** Gets the size of a single batch of geometry. */
-		virtual const Vector3& getRegionDimensions(void) const { return mRegionDimensions; }
-		/** Sets the origin of the geometry.
-		@remarks
-			This method allows you to configure the world centre of the geometry,
-			thus the place which all regions surround. You probably don't need 
-			to mess with this unless you have a seriously large world, since the
-			default set up can handle an area 1024 * mRegionDimensions, and 
-			the sparseness of population is no issue when it comes to rendering.
-			The default is Vector3(0,0,0).
-		@note Must be called before 'build'.
-		@param size Vector3 expressing the 3D origin of the geometry.
-		*/
-		virtual void setOrigin(const Vector3& origin) { mOrigin = origin; }
-		/** Gets the origin of this geometry. */
-		virtual const Vector3& getOrigin(void) const { return mOrigin; }
-
-		/// Sets the visibility flags of all the regions at once
-		void setVisibilityFlags(uint32 flags);
-		/// Returns the visibility flags of the regions
-		uint32 getVisibilityFlags() const;
-
-        /** Sets the render queue group this object will be rendered through.
-        @remarks
-            Render queues are grouped to allow you to more tightly control the ordering
-            of rendered objects. If you do not call this method, all  objects default
-            to the default queue (RenderQueue::getDefaultQueueGroup), which is fine for 
-			most objects. You may want to alter this if you want to perform more complex
-			rendering.
-        @par
-            See RenderQueue for more details.
-        @param queueID Enumerated value of the queue group to use.
-        */
-        virtual void setRenderQueueGroup(uint8 queueID);
-
-        /** Gets the queue group for this entity, see setRenderQueueGroup for full details. */
-        virtual uint8 getRenderQueueGroup(void) const;
-		/// @copydoc MovableObject::visitRenderables
-		void visitRenderables(Renderable::Visitor* visitor, 
-			bool debugRenderables = false);
-		
-		/// Iterator for iterating over contained regions
-		typedef MapIterator<RegionMap> RegionIterator;
-		/// Get an iterator over the regions in this geometry
-		RegionIterator getRegionIterator(void);
-
-		/** Dump the contents of this StaticGeometry to a file for diagnostic
-		 	purposes.
-		*/
-		virtual void dump(const String& filename) const;
-
-
-	};
-	/** @} */
-	/** @} */
-
-}
-
-#endif
-