ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreInstanceBatch.h

@@ -0,0 +1,344 @@
+/*
+-----------------------------------------------------------------------------
+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 __InstanceBatch_H__
+#define __InstanceBatch_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreRenderOperation.h"
+#include "OgreRenderable.h"
+#include "OgreMovableObject.h"
+#include "OgreMesh.h"
+
+namespace Ogre
+{
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Scene
+	*  @{
+	*/
+
+	/** InstanceBatch forms part of the new Instancing system
+		This is an abstract class that must be derived to implement different instancing techniques
+		(@see InstanceManager::InstancingTechnique)
+		OGRE wasn't truly thought for instancing. OGRE assumes that either:
+			a. One MovableObject -> No Renderable
+			b. One MovableObject -> One Renderable
+			c. One MovableObject -> Many Renderable.
+		However, instances work on reverse: Many MovableObject have the same Renderable.
+		<b>Instancing is already difficult to cull by a CPU</b>, but the main drawback from this assumption
+		is that it makes it even harder to take advantage from OGRE's culling capabilities
+		(i.e. @see OctreeSceneManager)
+		@par
+		To workaround this problem, InstanceBatch updates on almost every frame,
+		growing the bounding box to fit all instances that are not being culled individually.
+		This helps by avoiding a huge bbox that may cover the whole scene, which decreases shadow
+		quality considerably (as it is seen as large shadow receiver)
+		Furthermore, if no individual instance is visible, the InstanceBatch switches it's visibility
+		(@see MovableObject::setVisible) to avoid sending this Renderable to the GPU. This happens because
+		even when no individual instance is visible, their merged bounding box may cause OGRE to think
+		the batch is visible (i.e. the camera is looking between object A & B, but A & B aren't visible)
+		@par
+		<b>As it happens with instancing in general, all instanced entities from the same batch will share
+		the same textures and materials</b>
+		@par
+		Each InstanceBatch preallocates a fixed amount of mInstancesPerBatch instances once it's been
+		built (@see build, @see buildFrom).
+		@see createInstancedEntity and @see removeInstancedEntity on how to retrieve those instances
+		remove them from scene.
+		Note that, on GPU side, removing an instance from scene doesn't save GPU cycles on what
+		respects vertex shaders, but saves a little fillrate and pixel shaders; unless all instances
+		are removed, which saves GPU.
+		For more information, @see InstancedEntity
+		For information on how Ogre manages multiple Instance batches, @see InstanceManager
+
+        @remarks
+			Design discussion webpage
+        @author
+            Matias N. Goldberg ("dark_sylinc")
+        @version
+            1.0
+     */
+	class _OgreExport InstanceBatch : public Renderable, public MovableObject
+	{
+	public:
+		typedef vector<InstancedEntity*>::type InstancedEntityVec;
+	protected:
+		RenderOperation		mRenderOperation;
+		size_t				mInstancesPerBatch;
+
+		InstanceManager		*mCreator;
+
+		MaterialPtr			mMaterial;
+
+		MeshPtr				 mMeshReference;
+		Mesh::IndexMap const *mIndexToBoneMap;
+
+		//InstancedEntities are all allocated at build time and kept as "unused"
+		//when they're requested, they're removed from there when requested,
+		//and put back again when they're no longer needed
+		//Note each InstancedEntity has a unique ID ranging from [0; mInstancesPerBatch)
+		InstancedEntityVec	mInstancedEntities;
+		InstancedEntityVec	mUnusedEntities;
+
+		/// This bbox contains all (visible) instanced entities
+		AxisAlignedBox		mFullBoundingBox;
+		Real				mBoundingRadius;
+		bool				mBoundsDirty;
+        /// Set to false by derived classes that need it
+		bool				mBoundsUpdated;
+		Camera				*mCurrentCamera;
+
+		unsigned short		mMaterialLodIndex;
+
+        /// Set to false at start of each _updateRenderQueue
+		bool				mDirtyAnimation;
+
+		/// False if a technique doesn't support skeletal animation
+		bool				mTechnSupportsSkeletal;
+
+		/// Cached distance to last camera for getSquaredViewDepth
+		mutable Real mCachedCameraDist;
+		/// The camera for which the cached distance is valid
+		mutable const Camera *mCachedCamera;
+
+		/// Tells that the list of entity instances with shared transforms has changed
+		bool mTransformSharingDirty;
+
+		/// When true remove the memory of the VertexData we've created because no one else will
+		bool mRemoveOwnVertexData;
+		/// When true remove the memory of the IndexData we've created because no one else will
+		bool mRemoveOwnIndexData;
+
+		virtual void setupVertices( const SubMesh* baseSubMesh ) = 0;
+		virtual void setupIndices( const SubMesh* baseSubMesh ) = 0;
+		virtual void createAllInstancedEntities(void);
+		virtual void deleteAllInstancedEntities(void);
+		virtual void deleteUnusedInstancedEntities(void);
+		/// Creates a new InstancedEntity instance
+		virtual InstancedEntity* generateInstancedEntity(size_t num);
+
+		/** Takes an array of 3x4 matrices and makes it camera relative. Note the second argument
+			takes number of floats in the array, not number of matrices. Assumes mCachedCamera
+			contains the camera which is about to be rendered to.
+		*/
+		void makeMatrixCameraRelative3x4( float *mat3x4, size_t numFloats );
+
+		/// Returns false on errors that would prevent building this batch from the given submesh
+		virtual bool checkSubMeshCompatibility( const SubMesh* baseSubMesh );
+
+		void updateVisibility(void);
+
+		/** @see _defragmentBatch */
+		void defragmentBatchNoCull( InstancedEntityVec &usedEntities );
+
+		/** @see _defragmentBatch
+			This one takes the entity closest to the minimum corner of the bbox, then starts
+			gathering entities closest to this entity. There might be much better algorithms (i.e.
+			involving space partition), but this one is simple and works well enough
+		*/
+		void defragmentBatchDoCull( InstancedEntityVec &usedEntities );
+
+	public:
+		InstanceBatch( InstanceManager *creator, MeshPtr &meshReference, const MaterialPtr &material,
+						size_t instancesPerBatch, const Mesh::IndexMap *indexToBoneMap,
+						const String &batchName );
+		virtual ~InstanceBatch();
+
+		MeshPtr& _getMeshRef() { return mMeshReference; }
+
+		/** Raises an exception if trying to change it after being built
+		*/
+		void _setInstancesPerBatch( size_t instancesPerBatch );
+
+		const Mesh::IndexMap* _getIndexToBoneMap() const { return mIndexToBoneMap; }
+
+		/** Returns true if this technique supports skeletal animation
+		@remarks
+			A virtual function could have been used, but using a simple variable overriden
+			by the derived class is faster than virtual call overhead. And both are clean
+			ways of implementing it.
+		*/
+		bool _supportsSkeletalAnimation() const { return mTechnSupportsSkeletal; }
+
+		/** @see InstanceManager::updateDirtyBatches */
+		void _updateBounds(void);
+
+		/** Some techniques have a limit on how many instances can be done.
+			Sometimes even depends on the material being used.
+			@par
+			Note this is a helper function, as such it takes a submesh base to compute
+			the parameters, instead of using the object's own. This allows
+			querying for a technique without requiering to actually build it.
+			@param baseSubMesh The base submesh that will be using to build it.
+			@param flags @see InstanceManagerFlags
+			@return The max instances limit
+		*/
+		virtual size_t calculateMaxNumInstances( const SubMesh *baseSubMesh, uint16 flags ) const = 0;
+
+		/** Constructs all the data needed to use this batch, as well as the
+			InstanceEntities. Placed here because in the constructor virtual
+			tables may not have been yet filled.
+			@param baseSubMesh A sub mesh which the instances will be based upon from.
+			@remarks
+				Call this only ONCE. This is done automatically by Ogre::InstanceManager
+				Caller is responsable for freeing buffers in this RenderOperation
+				Buffers inside the RenderOp may be null if the built failed.
+			@return
+				A render operation which is very useful to pass to other InstanceBatches
+				(@see buildFrom) so that they share the same vertex buffers and indices,
+				when possible
+        */
+		virtual RenderOperation build( const SubMesh* baseSubMesh );
+
+		/** Instancing consumes significantly more GPU memory than regular rendering
+			methods. However, multiple batches can share most, if not all, of the
+			vertex & index buffers to save memory.
+			Derived classes are free to overload this method to manipulate what to
+			reference from Render Op.
+			For example, Hardware based instancing uses it's own vertex buffer for the
+			last source binding, but shares the other sources.
+			@param renderOperation The RenderOp to reference.
+			@remarks
+				Caller is responsable for freeing buffers passed as input arguments
+				This function replaces the need to call build()
+        */
+		virtual void buildFrom( const SubMesh *baseSubMesh, const RenderOperation &renderOperation );
+
+		const Ogre::MeshPtr& _getMeshReference(void) const { return mMeshReference; }
+
+		/** @return true if it can not create more InstancedEntities
+			(Num InstancedEntities == mInstancesPerBatch)
+		*/
+		bool isBatchFull(void) const { return mUnusedEntities.empty(); }
+
+		/** Returns true if it no instanced entity has been requested or all of them have been removed
+		*/
+		bool isBatchUnused(void) const { return mUnusedEntities.size() == mInstancedEntities.size(); }
+
+		/** Fills the input vector with the instances that are currently being used or were requested
+			Used for defragmentation, @see InstanceManager::defragmentBatches
+		*/
+		void getInstancedEntitiesInUse( InstancedEntityVec &outEntities );
+
+		/** @see InstanceManager::defragmentBatches
+			This function takes InstancedEntities and pushes back all entities it can fit here
+			Extra entities in mUnusedEntities are destroyed
+			(so that used + unused = mInstancedEntities.size())
+			@param optimizeCulling true will call the DoCull version, false the NoCull
+			@param Array of InstancedEntities to parent with this batch. Those reparented
+			are removed from this input vector
+			@remarks:
+			This function assumes caller holds data to mInstancedEntities! Otherwise
+			you can get memory leaks. Don't call this directly if you don't know what you're doing!
+		*/
+		void _defragmentBatch( bool optimizeCulling, InstancedEntityVec &usedEntities );
+
+		/** @see InstanceManager::_defragmentBatchDiscard
+			Destroys unused entities and clears the mInstancedEntity container which avoids leaving
+			dangling pointers from reparented InstancedEntities
+			Usually called before deleting this pointer. Don't call directly!
+		*/
+		void _defragmentBatchDiscard(void);
+
+		/** Called by InstancedEntity(s) to tell us we need to update the bounds
+			(we touch the SceneNode so the SceneManager aknowledges such change)
+        */
+		virtual void _boundsDirty(void);
+
+		/** Tells this batch to stop updating animations, positions, rotations, and display
+			all it's active instances. Currently only InstanceBatchHW & InstanceBatchHW_VTF support it.
+			This option makes the batch behave pretty much like Static Geometry, but with the GPU RAM
+			memory advantages (less VRAM, less bandwidth) and not LOD support. Very useful for
+			billboards of trees, repeating vegetation, etc.
+			@remarks
+				This function moves a lot of processing time from the CPU to the GPU. If the GPU
+				is already a bottleneck, you may see a decrease in performance instead!
+				Call this function again (with bStatic=true) if you've made a change to an
+				InstancedEntity and wish this change to take effect.
+				Be sure to call this after you've set all your instances
+				@see InstanceBatchHW::setStaticAndUpdate
+		*/
+		virtual void setStaticAndUpdate( bool bStatic )		{}
+
+		/** Returns true if this batch was set as static. @see setStaticAndUpdate
+		*/
+		virtual bool isStatic() const						{ return false; }
+
+		/** Returns a pointer to a new InstancedEntity ready to use
+			Note it's actually preallocated, so no memory allocation happens at
+			this point.
+			@remarks
+				Returns NULL if all instances are being used
+        */
+		InstancedEntity* createInstancedEntity();
+
+		/** Removes an InstancedEntity from the scene retrieved with
+			getNewInstancedEntity, putting back into a queue
+			@remarks
+				Throws an exception if the instanced entity wasn't created by this batch
+				Removed instanced entities save little CPU time, but _not_ GPU
+        */
+		void removeInstancedEntity( InstancedEntity *instancedEntity );
+
+		/** Tells whether world bone matrices need to be calculated.
+			This does not include bone matrices which are calculated regardless
+        */
+		virtual bool useBoneWorldMatrices() const { return true; }
+
+		/** Tells that the list of entity instances with shared transforms has changed */
+		void _markTransformSharingDirty() { mTransformSharingDirty = true; }
+
+		//Renderable overloads
+        /** @copydoc Renderable::getMaterial. */
+		const MaterialPtr& getMaterial(void) const		{ return mMaterial; }
+        /** @copydoc Renderable::getRenderOperation. */
+		void getRenderOperation( RenderOperation& op )	{ op = mRenderOperation; }
+
+        /** @copydoc Renderable::getSquaredViewDepth. */
+		Real getSquaredViewDepth( const Camera* cam ) const;
+        /** @copydoc Renderable::getLights. */
+        const LightList& getLights( void ) const;
+        /** @copydoc Renderable::getTechnique. */
+		Technique* getTechnique(void) const;
+
+        /** @copydoc MovableObject::getMovableType. */
+		const String& getMovableType(void) const;
+        /** @copydoc MovableObject::_notifyCurrentCamera. */
+		void _notifyCurrentCamera( Camera* cam );
+        /** @copydoc MovableObject::getBoundingBox. */
+		const AxisAlignedBox& getBoundingBox(void) const;
+        /** @copydoc MovableObject::getBoundingRadius. */
+		Real getBoundingRadius(void) const;
+
+		virtual void _updateRenderQueue(RenderQueue* queue);
+		void visitRenderables( Renderable::Visitor* visitor, bool debugRenderables = false );
+	};
+}
+
+#endif

data/deps/include/OGRE/OgreInstanceBatchHW.h

@@ -0,0 +1,110 @@
+/*
+-----------------------------------------------------------------------------
+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 __InstanceBatchHW_H__
+#define __InstanceBatchHW_H__
+
+#include "OgreInstanceBatch.h"
+
+namespace Ogre
+{
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Scene
+	*  @{
+	*/
+
+	/** This is technique requires true instancing hardware support.
+		Basically it creates a cloned vertex buffer from the original, with an extra buffer containing
+		3 additional TEXCOORDS (12 bytes) repeated as much as the instance count.
+		That will be used for each instance data.
+		@par
+		The main advantage of this technique is that it's <u>VERY</u> fast; but it doesn't support
+		skeletal animation at all. Very reduced memory consumption and bandwidth. Great for particles,
+		debris, bricks, trees, sprites.
+		This batch is one of the few (if not the only) techniques that allows culling on an individual
+		basis. This means we can save vertex shader performance for instances that aren't in scene or
+		just not focused by the camera.
+
+        @remarks
+			Design discussion webpage: http://www.ogre3d.org/forums/viewtopic.php?f=4&t=59902
+        @author
+            Matias N. Goldberg ("dark_sylinc")
+        @version
+            1.1
+     */
+	class _OgreExport InstanceBatchHW : public InstanceBatch
+	{
+		bool	mKeepStatic;
+
+		void setupVertices( const SubMesh* baseSubMesh );
+		void setupIndices( const SubMesh* baseSubMesh );
+
+		void removeBlendData();
+		virtual bool checkSubMeshCompatibility( const SubMesh* baseSubMesh );
+
+		size_t updateVertexBuffer( Camera *currentCamera );
+
+	public:
+		InstanceBatchHW( InstanceManager *creator, MeshPtr &meshReference, const MaterialPtr &material,
+							size_t instancesPerBatch, const Mesh::IndexMap *indexToBoneMap,
+							const String &batchName );
+		virtual ~InstanceBatchHW();
+
+		/** @see InstanceBatch::calculateMaxNumInstances */
+		size_t calculateMaxNumInstances( const SubMesh *baseSubMesh, uint16 flags ) const;
+
+		/** @see InstanceBatch::buildFrom */
+		void buildFrom( const SubMesh *baseSubMesh, const RenderOperation &renderOperation );
+
+		/** Overloaded so that we don't perform needless updates when in static mode. Also doing that
+			could cause glitches with shadow mapping (since Ogre thinks we're small/bigger than we
+			really are when displaying, or that we're somewhere else)
+        */
+		void _boundsDirty(void);
+
+		/** @see InstanceBatch::setStaticAndUpdate. While this flag is true, no individual per-entity
+			cull check is made. This means if the camera is looking at only one instance, all instances
+			are sent to the vertex shader (unlike when this flag is false). This saves a lot of CPU
+			power and a bit of bus bandwidth.
+		*/
+		void setStaticAndUpdate( bool bStatic );
+
+		bool isStatic() const						{ return mKeepStatic; }
+
+		//Renderable overloads
+		void getWorldTransforms( Matrix4* xform ) const;
+		unsigned short getNumWorldTransforms(void) const;
+
+		/** Overloaded to avoid updating skeletons (which we don't support), check visibility on a
+			per unit basis and finally updated the vertex buffer */
+		virtual void _updateRenderQueue( RenderQueue* queue );
+	};
+}
+
+#endif

data/deps/include/OGRE/OgreInstanceBatchHW_VTF.h

@@ -0,0 +1,113 @@
+/*
+-----------------------------------------------------------------------------
+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 __InstanceBatchHW_VTF_H__
+#define __InstanceBatchHW_VTF_H__
+
+#include "OgreInstanceBatchVTF.h"
+#include "OgreTexture.h"
+
+namespace Ogre
+{
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Scene
+	*  @{
+	*/
+
+	/** Instancing implementation using vertex texture through Vertex Texture Fetch (VTF) and
+		hardware instancing.
+		@see BaseInstanceBatchVTF and @see InstanceBatchHW
+
+		The advantage over TextureVTF technique, is that this implements a basic culling algorithm
+		to avoid useless processing in vertex shader and uses a lot less VRAM and memory bandwidth
+
+		Basically it has the benefits of both TextureVTF (skeleton animations) and HWInstancingBasic
+		(lower memory consumption and basic culling) techniques
+
+        @remarks
+			Design discussion webpage: http://www.ogre3d.org/forums/viewtopic.php?f=4&t=59902
+        @author
+            Matias N. Goldberg ("dark_sylinc")
+        @version
+            1.2
+     */
+	class _OgreExport InstanceBatchHW_VTF : public BaseInstanceBatchVTF
+	{
+	protected:
+		bool	mKeepStatic;
+
+		//Pointer to the buffer containing the per instance vertex data
+		HardwareVertexBufferSharedPtr mInstanceVertexBuffer;
+
+		void setupVertices( const SubMesh* baseSubMesh );
+		void setupIndices( const SubMesh* baseSubMesh );
+
+		/** Creates 2 TEXCOORD semantics that will be used to sample the vertex texture */
+		void createVertexSemantics( VertexData *thisVertexData, VertexData *baseVertexData,
+			const HWBoneIdxVec &hwBoneIdx, const HWBoneWgtVec& hwBoneWgt );
+
+		/** updates the vertex buffer containing the per instance data 
+		@param[in] isFirstTime Tells if this is the first time the buffer is being updated
+		@param[in] currentCamera The camera being used for render (valid when using bone matrix lookup)
+		@return The number of instances to be rendered
+		*/
+		virtual size_t updateInstanceDataBuffer(bool isFirstTime, Camera* currentCamera);
+
+
+		virtual bool checkSubMeshCompatibility( const SubMesh* baseSubMesh );
+
+		/** Keeps filling the VTF with world matrix data. Overloaded to avoid culled objects
+			and update visible instances' animation
+		*/
+		size_t updateVertexTexture( Camera *currentCamera );
+
+		virtual bool matricesToghetherPerRow() const { return true; }
+	public:
+		InstanceBatchHW_VTF( InstanceManager *creator, MeshPtr &meshReference, const MaterialPtr &material,
+							size_t instancesPerBatch, const Mesh::IndexMap *indexToBoneMap,
+							const String &batchName );
+		virtual ~InstanceBatchHW_VTF();
+		/** @see InstanceBatch::calculateMaxNumInstances */
+		size_t calculateMaxNumInstances( const SubMesh *baseSubMesh, uint16 flags ) const;
+
+		/** @copydoc InstanceBatchHW::_boundsDirty */
+		void _boundsDirty(void);
+
+		/** @copydoc InstanceBatchHW::setStaticAndUpdate */
+		void setStaticAndUpdate( bool bStatic );
+
+		bool isStatic() const { return mKeepStatic; }
+
+		/** Overloaded to visibility on a per unit basis and finally updated the vertex texture */
+		virtual void _updateRenderQueue( RenderQueue* queue );
+	};
+
+}
+
+#endif

data/deps/include/OGRE/OgreInstanceBatchShader.h

@@ -0,0 +1,99 @@
+/*
+-----------------------------------------------------------------------------
+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 __InstanceBatchShader_H__
+#define __InstanceBatchShader_H__
+
+#include "OgreInstanceBatch.h"
+
+namespace Ogre
+{
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Scene
+	*  @{
+	*/
+
+	/** This is the same technique the old "InstancedGeometry" implementation used (with improvements).
+		Basically it creates a large vertex buffer with many repeating entities, and sends per instance
+		data through shader constants. Because SM 2.0 & 3.0 have up to 256 shader constant registers,
+		this means there can be approx up to 84 instances per batch, assuming they're not skinned
+		But using shader constants for other stuff (i.e. lighting) also affects negatively this number
+		A mesh with skeletally animated 2 bones reduces the number 84 to 42 instances per batch.
+		@par
+		The main advantage of this technique is that it's supported on a high variety of hardware
+		(SM 2.0 cards are required) and the same shader can be used for both skeletally animated
+		normal entities and instanced entities without a single change required.
+		@par
+		Unlike the old InstancedGeometry implementation, the developer doesn't need to worry about
+		reaching the 84 instances limit, the InstanceManager automatically takes care of splitting
+		and creating new batches. But beware internally, this means less performance improvement.
+		Another improvement is that vertex buffers are shared between batches, which significantly
+		reduces GPU VRAM usage.
+
+        @remarks
+			Design discussion webpage: http://www.ogre3d.org/forums/viewtopic.php?f=4&t=59902
+        @author
+            Matias N. Goldberg ("dark_sylinc")
+        @version
+            1.0
+     */
+	class _OgreExport InstanceBatchShader : public InstanceBatch
+	{
+		unsigned short	mNumWorldMatrices;
+
+		void setupVertices( const SubMesh* baseSubMesh );
+		void setupIndices( const SubMesh* baseSubMesh );
+
+		/** When the mesh is (hardware) skinned, a different code path is called so that
+			we reuse the index buffers and modify them in place. For example Instance #2
+			with reference to bone #5 would have BlendIndex = 2 + 5 = 7
+			Everything is copied identically except the VES_BLEND_INDICES semantic
+		*/
+		void setupHardwareSkinned( const SubMesh* baseSubMesh, VertexData *thisVertexData,
+									VertexData *baseVertexData );
+
+	public:
+		InstanceBatchShader( InstanceManager *creator, MeshPtr &meshReference, const MaterialPtr &material,
+							size_t instancesPerBatch, const Mesh::IndexMap *indexToBoneMap,
+							const String &batchName );
+		virtual ~InstanceBatchShader();
+
+		/** @see InstanceBatch::calculateMaxNumInstances */
+		size_t calculateMaxNumInstances( const SubMesh *baseSubMesh, uint16 flags ) const;
+
+		/** @see InstanceBatch::buildFrom */
+		void buildFrom( const SubMesh *baseSubMesh, const RenderOperation &renderOperation );
+
+		//Renderable overloads
+		void getWorldTransforms( Matrix4* xform ) const;
+		unsigned short getNumWorldTransforms(void) const;
+	};
+}
+
+#endif