ruby-ogre 0.0.1-x86-linux

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

@@ -0,0 +1,413 @@
+/*
+-----------------------------------------------------------------------------
+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_TerrainQuadTreeNode_H__
+#define __Ogre_TerrainQuadTreeNode_H__
+
+#include "OgreTerrainPrerequisites.h"
+#include "OgreCommon.h"
+#include "OgreHardwareIndexBuffer.h"
+#include "OgreMovableObject.h"
+#include "OgreRenderable.h"
+
+
+
+namespace Ogre
+{
+	class HardwareVertexBufferSharedPtr;
+	
+	/** \addtogroup Optional Components
+	*  @{
+	*/
+	/** \addtogroup Terrain
+	*  Some details on the terrain component
+	*  @{
+	*/
+
+
+	/** A node in a quad tree used to store a patch of terrain.
+	@remarks
+		<b>Algorithm overview:</b>
+	@par
+		Our goal is to perform traditional chunked LOD with geomorphing. But, 
+		instead of just dividing the terrain into tiles, we will divide them into
+		a hierarchy of tiles, a quadtree, where any level of the quadtree can 
+		be a rendered tile (to the exclusion of its children). The idea is to 
+		collect together children into a larger batch with their siblings as LOD 
+		decreases, to improve performance.
+	@par
+		The minBatchSize and maxBatchSize parameters on Terrain a key to 
+		defining this behaviour. Both values are expressed in vertices down one axis.
+		maxBatchSize determines the number of tiles on one side of the terrain,
+		which is numTiles = (terrainSize-1) / (maxBatchSize-1). This in turn determines the depth
+		of the quad tree, which is sqrt(numTiles). The minBatchSize determines
+		the 'floor' of how low the number of vertices can go in a tile before it
+		has to be grouped together with its siblings to drop any lower. We also do not group 
+		a tile with its siblings unless all of them are at this minimum batch size, 
+		rather than trying to group them when they all end up on the same 'middle' LOD;
+		this is for several reasons; firstly, tiles hitting the same 'middle' LOD is
+		less likely and more transient if they have different levels of 'roughness',
+		and secondly since we're sharing a vertex / index pool between all tiles, 
+		only grouping at the min level means that the number of combinations of 
+		buffer sizes for any one tile is greatly simplified, making it easier to 
+		pool data. To be more specific, any tile / quadtree node can only have
+		log2(maxBatchSize-1) - log2(minBatchSize-1) + 1 LOD levels (and if you set them 
+		to the same value, LOD can only change by going up/down the quadtree).
+		The numbers of vertices / indices in each of these levels is constant for
+		the same (relative) LOD index no matter where you are in the tree, therefore
+		buffers can potentially be reused more easily.
+	*/
+	class _OgreTerrainExport TerrainQuadTreeNode : public TerrainAlloc
+	{
+	public:
+		/** Constructor.
+		@param terrain The ultimate parent terrain
+		@param parent Optional parent node (in which case xoff, yoff are 0 and size must be entire terrain)
+		@param xoff,off Offsets from the start of the terrain data in 2D
+		@param size The size of the node in vertices at the highest LOD
+		@param lod The base LOD level
+		@param depth The depth that this node is at in the tree (or convenience)
+		@param quadrant The index of the quadrant (0, 1, 2, 3)
+		*/
+		TerrainQuadTreeNode(Terrain* terrain, TerrainQuadTreeNode* parent, 
+			uint16 xoff, uint16 yoff, uint16 size, uint16 lod, uint16 depth, uint16 quadrant);
+		virtual ~TerrainQuadTreeNode();
+
+		/// Get the horizontal offset into the main terrain data of this node
+		uint16 getXOffset() const { return mOffsetX; }
+		/// Get the vertical offset into the main terrain data of this node
+		uint16 getYOffset() const { return mOffsetY; }
+		/// Is this a leaf node (no children)
+		bool isLeaf() const;
+		/// Get the base LOD level this node starts at (the highest LOD it handles)
+		uint16 getBaseLod() const { return mBaseLod; }
+		/// Get the number of LOD levels this node can represent itself (only > 1 for leaf nodes)
+		uint16 getLodCount() const;
+		/// Get child node
+		TerrainQuadTreeNode* getChild(unsigned short child) const;
+		/// Get parent node
+		TerrainQuadTreeNode* getParent() const;
+		/// Get ultimate parent terrain
+		Terrain* getTerrain() const;
+
+		/// Prepare node and children (perform CPU tasks, may be background thread)
+		void prepare();
+		/// Prepare node from a stream
+		void prepare(StreamSerialiser& stream);
+		/// Load node and children (perform GPU tasks, will be render thread)
+		void load();
+		/// Unload node and children (perform GPU tasks, will be render thread)
+		void unload();
+		/// Unprepare node and children (perform CPU tasks, may be background thread)
+		void unprepare();
+		/// Save node to a stream
+		void save(StreamSerialiser& stream);
+
+		struct _OgreTerrainExport LodLevel : public TerrainAlloc
+		{
+			/// Number of vertices rendered down one side (not including skirts)
+			uint16 batchSize;
+			/// Index data on the gpu
+			IndexData* gpuIndexData;
+			/// Maximum delta height between this and the next lower lod
+			Real maxHeightDelta;
+			/// Temp calc area for max height delta
+			Real calcMaxHeightDelta;
+			/// The most recently calculated transition distance
+			Real lastTransitionDist;
+			/// The cFactor value used to calculate transitionDist
+			Real lastCFactor;
+
+			LodLevel() : gpuIndexData(0), maxHeightDelta(0), calcMaxHeightDelta(0),
+				lastTransitionDist(0), lastCFactor(0) {}
+		};
+		typedef vector<LodLevel*>::type LodLevelList;
+
+		/** Get the LodLevel information for a given lod.
+		@param lod The lod level index relative to this classes own list; if you
+			want to use a global lod level, subtract getBaseLod() first. Higher
+			LOD levels are lower detail.
+		*/
+		const LodLevel* getLodLevel(uint16 lod);
+
+		/** Notify the node (and children) that deltas are going to be calculated for a given range.
+		@remarks
+			Based on this call, we can know whether or not to reset the max height.
+		*/
+		void preDeltaCalculation(const Rect& rect);
+
+		/** Notify the node (and children) of a height delta value. */
+		void notifyDelta(uint16 x, uint16 y, uint16 lod, Real delta);
+
+		/** Notify the node (and children) that deltas have finished being calculated.
+		*/
+		void postDeltaCalculation(const Rect& rect);
+
+		/** Promote the delta values calculated to the runtime ones (this must
+			be called in the main thread). 
+		*/
+		void finaliseDeltaValues(const Rect& rect);
+
+		/** Assign vertex data to the tree, from a depth and at a given resolution.
+		@param treeDepthStart The first depth of tree that should use this data, owns the data
+		@param treeDepthEnd The end of the depth that should use this data (exclusive)
+		@param resolution The resolution of the data to use (compared to full terrain)
+		@param sz The size of the data along one edge
+		*/
+		void assignVertexData(uint16 treeDepthStart, uint16 treeDepthEnd, uint16 resolution, uint sz);
+
+		/** Tell a node that it should use an anscestor's vertex data.
+		@param treeDepthEnd The end of the depth that should use this data (exclusive)
+		@param resolution The resolution of the data to use
+		*/
+		void useAncestorVertexData(TerrainQuadTreeNode* owner, uint16 treeDepthEnd, uint16 resolution);
+
+		/** Tell the node to update its vertex data for a given region. 
+		*/
+		void updateVertexData(bool positions, bool deltas, const Rect& rect, bool cpuData);
+
+
+
+		/** Merge a point (relative to terrain node) into the local bounds, 
+			and that of children if applicable.
+		@param x,y The point on the terrain to which this position corresponds 
+			(affects which nodes update their bounds)
+		@param pos The position relative to the terrain centre
+		*/
+		void mergeIntoBounds(long x, long y, const Vector3& pos);
+		/** Reset the bounds of this node and all its children for the region given.
+		@param rect The region for which bounds should be reset, in top-level terrain coords
+		*/
+		void resetBounds(const Rect& rect);
+		
+		/** Returns true if the given rectangle overlaps the terrain area that
+			this node references.
+		 @param rect The region in top-level terrain coords
+		*/
+		bool rectIntersectsNode(const Rect& rect);
+		/** Returns true if the given rectangle completely contains the terrain area that
+		this node references.
+		@param rect The region in top-level terrain coords
+		*/
+		bool rectContainsNode(const Rect& rect);
+		/** Returns true if the given point is in the terrain area that
+		 this node references.
+		 @param x,y The point in top-level terrain coords
+		 */
+		bool pointIntersectsNode(long x, long y);
+
+		/// Get the AABB (local coords) of this node
+		const AxisAlignedBox& getAABB() const;
+		/// Get the bounding radius of this node
+		Real getBoundingRadius() const;
+		/// Get the local centre of this node, relative to parent terrain centre
+		const Vector3& getLocalCentre() const { return mLocalCentre; }
+		/// Get the minimum height of the node
+		Real getMinHeight() const;
+		/// Get the maximum height of the node
+		Real getMaxHeight() const;
+
+		/** Calculate appropriate LOD for this node and children
+		@param cam The camera to be used (this should already be the LOD camera)
+		@param cFactor The cFactor which incorporates the viewport size, max pixel error and lod bias
+		@return true if this node or any of its children were selected for rendering
+		*/
+		bool calculateCurrentLod(const Camera* cam, Real cFactor);
+
+		/// Get the current LOD index (only valid after calculateCurrentLod)
+		int getCurrentLod() const { return mCurrentLod; }
+		/// Returns whether this node is rendering itself at the current LOD level
+		bool isRenderedAtCurrentLod() const;
+		/// Returns whether this node or its children are being rendered at the current LOD level
+		bool isSelfOrChildRenderedAtCurrentLod() const;
+		/// Manually set the current LOD, intended for internal use only
+		void setCurrentLod(int lod);
+		/// Get the transition state between the current LOD and the next lower one (only valid after calculateCurrentLod)
+		float getLodTransition() const { return mLodTransition; }
+		/// Manually set the current LOD transition state, intended for internal use only
+		void setLodTransition(float t);
+
+		/// Buffer binding used for holding positions
+		static unsigned short POSITION_BUFFER;
+		/// Buffer binding used for holding delta values
+		static unsigned short DELTA_BUFFER;
+
+		/// Returns the internal renderable object for this node
+		Renderable *_getRenderable();
+	protected:
+		Terrain* mTerrain;
+		TerrainQuadTreeNode* mParent;
+		TerrainQuadTreeNode* mChildren[4];
+		LodLevelList mLodLevels;
+
+		uint16 mOffsetX, mOffsetY;
+		uint16 mBoundaryX, mBoundaryY;
+		/// the number of vertices at the original terrain resolution this node encompasses
+		uint16 mSize;
+		uint16 mBaseLod;
+		uint16 mDepth;
+		uint16 mQuadrant;
+		Vector3 mLocalCentre; // relative to terrain centre
+		AxisAlignedBox mAABB; //relative to mLocalCentre
+		Real mBoundingRadius; //relative to mLocalCentre
+		int mCurrentLod; // -1 = none (do not render)
+		unsigned short mMaterialLodIndex;
+		float mLodTransition; // 0-1 transition to lower LOD
+		/// The child with the largest height delta 
+		TerrainQuadTreeNode* mChildWithMaxHeightDelta;
+		bool mSelfOrChildRendered;
+
+		struct VertexDataRecord : public TerrainAlloc
+		{
+			VertexData* cpuVertexData;
+			VertexData* gpuVertexData;
+			/// resolution of the data compared to the base terrain data (NOT number of vertices!)
+			uint16 resolution;
+			/// size of the data along one edge
+			uint16 size;
+			/// Number of quadtree levels (including this one) this data applies to
+			uint16 treeLevels;
+			/// Number of rows and columns of skirts
+			uint16 numSkirtRowsCols;
+			/// The number of rows / cols to skip in between skirts
+			uint16 skirtRowColSkip;
+			/// Is the GPU vertex data out of date?
+			bool gpuVertexDataDirty;
+
+			VertexDataRecord(uint16 res, uint16 sz, uint16 lvls) 
+				: cpuVertexData(0), gpuVertexData(0), resolution(res), size(sz),
+				treeLevels(lvls), gpuVertexDataDirty(false) {}
+		};
+		
+		TerrainQuadTreeNode* mNodeWithVertexData;
+		VertexDataRecord* mVertexDataRecord;
+
+		/** MovableObject implementation to provide the hook to the scene.
+		@remarks
+			In one sense, it would be most convenient to have a single MovableObject
+			to represent the whole Terrain object, and then internally perform
+			some quadtree frustum culling to narrow down which specific tiles are rendered.
+			However, the one major flaw with that is that exposing the bounds to 
+			the SceneManager at that level prevents it from doing anything smarter
+			in terms of culling - for example a portal or occlusion culling SceneManager
+			would have no opportunity to process the leaf nodes in those terms, and
+			a simple frustum cull may give significantly poorer results. 
+		@par
+			Therefore, we in fact register a MovableObject at every node, and 
+			use the LOD factor to determine which one is currently active. LODs
+			must be mutually exclusive and to deal with precision errors, we really
+			need to evaluate them all at once, rather than as part of the 
+			_notifyCurrentCamera function. Therefore the root Terrain registers
+			a SceneManager::Listener to precalculate which nodes will be displayed 
+			when it comes to purely a LOD basis.
+		*/
+		class _OgreTerrainExport Movable : public MovableObject
+		{
+		protected:
+			TerrainQuadTreeNode* mParent;
+		public:
+			Movable(TerrainQuadTreeNode* parent);
+			~Movable();
+			
+	        // necessary overrides
+			const String& getMovableType(void) const;
+			const AxisAlignedBox& getBoundingBox(void) const;
+			Real getBoundingRadius(void) const;
+			void _updateRenderQueue(RenderQueue* queue);
+			void visitRenderables(Renderable::Visitor* visitor,  bool debugRenderables = false);
+			bool isVisible(void) const;
+			uint32 getVisibilityFlags(void) const;
+			uint32 getQueryFlags(void) const;
+			bool getCastShadows(void) const;
+
+		};
+		Movable* mMovable;
+		friend class Movable;
+		SceneNode* mLocalNode;
+
+		/// Hook to the render queue
+		class _OgreTerrainExport Rend : public Renderable, public TerrainAlloc
+		{
+		protected:
+			TerrainQuadTreeNode* mParent;
+		public:
+			Rend(TerrainQuadTreeNode* parent);
+			~Rend();
+
+			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;
+
+		};
+		Rend* mRend;
+		friend class Rend;
+
+		// actual implementation of MovableObject methods
+		void updateRenderQueue(RenderQueue* queue);
+		void visitRenderables(Renderable::Visitor* visitor,  bool debugRenderables = false);
+		// actual implementations of Renderable methods
+		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;
+
+
+		const VertexDataRecord* getVertexDataRecord() const;
+		void createCpuVertexData();
+		/* Update the vertex buffers - the rect in question is relative to the whole terrain, 
+			not the local vertex data (which may use a subset)
+		*/
+		void updateVertexBuffer(HardwareVertexBufferSharedPtr& posbuf, HardwareVertexBufferSharedPtr& deltabuf, const Rect& rect);
+		void destroyCpuVertexData();
+
+		void createGpuVertexData();
+		void destroyGpuVertexData();
+		void updateGpuVertexData();
+		void createGpuIndexData();
+		void destroyGpuIndexData();
+
+		void populateIndexData(uint16 batchSize, IndexData* destData);
+		void writePosVertex(bool compress, uint16 x, uint16 y, float height, const Vector3& pos, float uvScale, float** ppPos);
+		void writeDeltaVertex(bool compress, uint16 x, uint16 y, float delta, float deltaThresh, float** ppDelta);
+		
+		uint16 calcSkirtVertexIndex(uint16 mainIndex, bool isCol);
+
+	};
+
+	/** @} */
+	/** @} */
+}
+
+#endif

data/deps/include/OGRE/Threading/OgreDefaultWorkQueue.h

@@ -0,0 +1,42 @@
+/*-------------------------------------------------------------------------
+This source file is a 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 __OgreDefaultWorkQueue_H__
+#define __OgreDefaultWorkQueue_H__
+
+#if OGRE_THREAD_PROVIDER == 0
+	#include "OgreDefaultWorkQueueStandard.h"
+#elif OGRE_THREAD_PROVIDER == 1
+	#include "OgreDefaultWorkQueueStandard.h"
+#elif OGRE_THREAD_PROVIDER == 2
+	#include "OgreDefaultWorkQueueStandard.h"
+#elif OGRE_THREAD_PROVIDER == 3
+	#include "OgreDefaultWorkQueueTBB.h"
+#endif
+
+#endif
+
+
+

data/deps/include/OGRE/Threading/OgreDefaultWorkQueueStandard.h

@@ -0,0 +1,82 @@
+/*-------------------------------------------------------------------------
+This source file is a 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 __OgreDefaultWorkQueueStandard_H__
+#define __OgreDefaultWorkQueueStandard_H__
+
+#include "../OgreWorkQueue.h"
+
+namespace Ogre
+{
+	/** Implementation of a general purpose request / response style background work queue.
+	@remarks
+		This default implementation of a work queue starts a thread pool and 
+		provides queues to process requests. 
+	*/
+	class _OgreExport DefaultWorkQueue : public DefaultWorkQueueBase
+	{
+	public:
+
+		DefaultWorkQueue(const String& name = StringUtil::BLANK);
+		virtual ~DefaultWorkQueue(); 
+
+		/// Main function for each thread spawned.
+		virtual void _threadMain();
+
+		/// @copydoc WorkQueue::shutdown
+		virtual void shutdown();
+
+		/// @copydoc WorkQueue::startup
+		virtual void startup(bool forceRestart = true);
+
+	protected:
+		/** To be called by a separate thread; will return immediately if there
+			are items in the queue, or suspend the thread until new items are added
+			otherwise.
+		*/
+		virtual void waitForNextRequest();
+
+		/// Notify that a thread has registered itself with the render system
+		virtual void notifyThreadRegistered();
+
+		virtual void notifyWorkers();
+
+		size_t mNumThreadsRegisteredWithRS;
+		/// Init notification mutex (must lock before waiting on initCondition)
+		OGRE_MUTEX(mInitMutex)
+		/// Synchroniser token to wait / notify on thread init 
+		OGRE_THREAD_SYNCHRONISER(mInitSync)
+
+		OGRE_THREAD_SYNCHRONISER(mRequestCondition)
+#if OGRE_THREAD_SUPPORT
+		typedef vector<OGRE_THREAD_TYPE*>::type WorkerThreadList;
+		WorkerThreadList mWorkers;
+#endif
+
+	};
+
+}
+
+#endif

data/deps/include/OGRE/Threading/OgreThreadDefines.h

@@ -0,0 +1,41 @@
+/*-------------------------------------------------------------------------
+This source file is a 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 __OgreThreadDefines_H__
+#define __OgreThreadDefines_H__
+
+#define OGRE_AUTO_MUTEX_NAME mutex
+#if OGRE_THREAD_PROVIDER == 0
+	#include "OgreThreadDefinesNone.h"
+#elif OGRE_THREAD_PROVIDER == 1
+	#include "OgreThreadDefinesBoost.h"
+#elif OGRE_THREAD_PROVIDER == 2
+	#include "OgreThreadDefinesPoco.h"
+#elif OGRE_THREAD_PROVIDER == 3
+	#include "OgreThreadDefinesTBB.h"
+#endif
+
+#endif
+

data/deps/include/OGRE/Threading/OgreThreadDefinesNone.h

@@ -0,0 +1,59 @@
+/*-------------------------------------------------------------------------
+This source file is a 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 __OgreThreadDefinesNone_H__
+#define __OgreThreadDefinesNone_H__
+
+#define OGRE_AUTO_MUTEX
+#define OGRE_LOCK_AUTO_MUTEX
+#define OGRE_MUTEX(name)
+#define OGRE_STATIC_MUTEX(name)
+#define OGRE_STATIC_MUTEX_INSTANCE(name)
+#define OGRE_LOCK_MUTEX(name)
+#define OGRE_LOCK_MUTEX_NAMED(mutexName, lockName)
+#define OGRE_AUTO_SHARED_MUTEX
+#define OGRE_LOCK_AUTO_SHARED_MUTEX
+#define OGRE_NEW_AUTO_SHARED_MUTEX
+#define OGRE_DELETE_AUTO_SHARED_MUTEX
+#define OGRE_COPY_AUTO_SHARED_MUTEX(from)
+#define OGRE_SET_AUTO_SHARED_MUTEX_NULL
+#define OGRE_MUTEX_CONDITIONAL(name) if(true)
+#define OGRE_RW_MUTEX(name)
+#define OGRE_LOCK_RW_MUTEX_READ(name)
+#define OGRE_LOCK_RW_MUTEX_WRITE(name)
+#define OGRE_THREAD_SYNCHRONISER(sync) 
+#define OGRE_THREAD_WAIT(sync, lock) 
+#define OGRE_THREAD_NOTIFY_ONE(sync) 
+#define OGRE_THREAD_NOTIFY_ALL(sync) 
+#define OGRE_THREAD_POINTER(T, var) T* var
+#define OGRE_THREAD_POINTER_INIT(var) var(0)
+#define OGRE_THREAD_POINTER_VAR(T, var) T* var = 0
+#define OGRE_THREAD_POINTER_SET(var, expr) var = expr
+#define OGRE_THREAD_POINTER_GET(var) var
+#define OGRE_THREAD_POINTER_DELETE(var) { OGRE_DELETE var; var = 0; }
+#define OGRE_THREAD_SLEEP(ms)
+#define OGRE_THREAD_WORKER_INHERIT
+
+#endif

data/deps/include/OGRE/Threading/OgreThreadHeaders.h

@@ -0,0 +1,39 @@
+/*-------------------------------------------------------------------------
+This source file is a 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 __OgreThreadHeaders_H__
+#define __OgreThreadHeaders_H__
+
+#if OGRE_THREAD_PROVIDER == 1
+	#include "OgreThreadHeadersBoost.h"
+#elif OGRE_THREAD_PROVIDER == 2
+	#include "OgreThreadHeadersPoco.h"
+#elif OGRE_THREAD_PROVIDER == 3
+	#include "OgreThreadHeadersTBB.h"
+#endif
+
+#endif
+
+