ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreCommon.h

@@ -0,0 +1,870 @@
+/*
+-----------------------------------------------------------------------------
+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 __Common_H__
+#define __Common_H__
+// Common stuff
+
+#include "OgreString.h"
+
+#if defined ( OGRE_GCC_VISIBILITY )
+#   pragma GCC visibility push(default)
+#endif
+
+#include <utility>
+#include <sstream>
+
+#if defined ( OGRE_GCC_VISIBILITY )
+#   pragma GCC visibility pop
+#endif
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup General
+	*  @{
+	*/
+
+	/// Fast general hashing algorithm
+	uint32 _OgreExport FastHash (const char * data, int len, uint32 hashSoFar = 0);
+	/// Combine hashes with same style as boost::hash_combine
+	template <typename T>
+	uint32 HashCombine (uint32 hashSoFar, const T& data)
+	{
+		return FastHash((const char*)&data, sizeof(T), hashSoFar);
+	}
+
+
+    /** Comparison functions used for the depth/stencil buffer operations and 
+		others. */
+    enum CompareFunction
+    {
+        CMPF_ALWAYS_FAIL,
+        CMPF_ALWAYS_PASS,
+        CMPF_LESS,
+        CMPF_LESS_EQUAL,
+        CMPF_EQUAL,
+        CMPF_NOT_EQUAL,
+        CMPF_GREATER_EQUAL,
+        CMPF_GREATER
+    };
+
+    /** High-level filtering options providing shortcuts to settings the
+        minification, magnification and mip filters. */
+    enum TextureFilterOptions
+    {
+        /// Equal to: min=FO_POINT, mag=FO_POINT, mip=FO_NONE
+        TFO_NONE,
+        /// Equal to: min=FO_LINEAR, mag=FO_LINEAR, mip=FO_POINT
+        TFO_BILINEAR,
+        /// Equal to: min=FO_LINEAR, mag=FO_LINEAR, mip=FO_LINEAR
+        TFO_TRILINEAR,
+        /// Equal to: min=FO_ANISOTROPIC, max=FO_ANISOTROPIC, mip=FO_LINEAR
+		TFO_ANISOTROPIC
+    };
+
+    enum FilterType
+    {
+        /// The filter used when shrinking a texture
+        FT_MIN,
+        /// The filter used when magnifying a texture
+        FT_MAG,
+        /// The filter used when determining the mipmap
+        FT_MIP
+    };
+    /** Filtering options for textures / mipmaps. */
+    enum FilterOptions
+    {
+        /// No filtering, used for FILT_MIP to turn off mipmapping
+        FO_NONE,
+        /// Use the closest pixel
+        FO_POINT,
+        /// Average of a 2x2 pixel area, denotes bilinear for MIN and MAG, trilinear for MIP
+        FO_LINEAR,
+        /// Similar to FO_LINEAR, but compensates for the angle of the texture plane
+        FO_ANISOTROPIC
+    };
+
+    /** Light shading modes. */
+    enum ShadeOptions
+    {
+        SO_FLAT,
+        SO_GOURAUD,
+        SO_PHONG
+    };
+
+    /** Fog modes. */
+    enum FogMode
+    {
+        /// No fog. Duh.
+        FOG_NONE,
+        /// Fog density increases  exponentially from the camera (fog = 1/e^(distance * density))
+        FOG_EXP,
+        /// Fog density increases at the square of FOG_EXP, i.e. even quicker (fog = 1/e^(distance * density)^2)
+        FOG_EXP2,
+        /// Fog density increases linearly between the start and end distances
+        FOG_LINEAR
+    };
+
+    /** Hardware culling modes based on vertex winding.
+        This setting applies to how the hardware API culls triangles it is sent. */
+    enum CullingMode
+    {
+        /// Hardware never culls triangles and renders everything it receives.
+        CULL_NONE = 1,
+        /// Hardware culls triangles whose vertices are listed clockwise in the view (default).
+        CULL_CLOCKWISE = 2,
+        /// Hardware culls triangles whose vertices are listed anticlockwise in the view.
+        CULL_ANTICLOCKWISE = 3
+    };
+
+    /** Manual culling modes based on vertex normals.
+        This setting applies to how the software culls triangles before sending them to the 
+		hardware API. This culling mode is used by scene managers which choose to implement it -
+		normally those which deal with large amounts of fixed world geometry which is often 
+		planar (software culling movable variable geometry is expensive). */
+    enum ManualCullingMode
+    {
+        /// No culling so everything is sent to the hardware.
+        MANUAL_CULL_NONE = 1,
+        /// Cull triangles whose normal is pointing away from the camera (default).
+        MANUAL_CULL_BACK = 2,
+        /// Cull triangles whose normal is pointing towards the camera.
+        MANUAL_CULL_FRONT = 3
+    };
+
+    /** Enumerates the wave types usable with the Ogre engine. */
+    enum WaveformType
+    {
+        /// Standard sine wave which smoothly changes from low to high and back again.
+        WFT_SINE,
+        /// An angular wave with a constant increase / decrease speed with pointed peaks.
+        WFT_TRIANGLE,
+        /// Half of the time is spent at the min, half at the max with instant transition between.
+        WFT_SQUARE,
+        /// Gradual steady increase from min to max over the period with an instant return to min at the end.
+        WFT_SAWTOOTH,
+        /// Gradual steady decrease from max to min over the period, with an instant return to max at the end.
+        WFT_INVERSE_SAWTOOTH,
+		/// Pulse Width Modulation. Works like WFT_SQUARE, except the high to low transition is controlled by duty cycle. 
+		/// With a duty cycle of 50% (0.5) will give the same output as WFT_SQUARE.
+		WFT_PWM
+    };
+
+    /** The polygon mode to use when rasterising. */
+    enum PolygonMode
+    {
+		/// Only points are rendered.
+        PM_POINTS = 1,
+		/// Wireframe models are rendered.
+        PM_WIREFRAME = 2,
+		/// Solid polygons are rendered.
+        PM_SOLID = 3
+    };
+
+    /** An enumeration of broad shadow techniques */
+    enum ShadowTechnique
+    {
+        /** No shadows */
+        SHADOWTYPE_NONE = 0x00,
+		/** Mask for additive shadows (not for direct use, use  SHADOWTYPE_ enum instead)
+		*/
+		SHADOWDETAILTYPE_ADDITIVE = 0x01,
+		/** Mask for modulative shadows (not for direct use, use  SHADOWTYPE_ enum instead)
+		*/
+		SHADOWDETAILTYPE_MODULATIVE = 0x02,
+		/** Mask for integrated shadows (not for direct use, use SHADOWTYPE_ enum instead)
+		*/
+		SHADOWDETAILTYPE_INTEGRATED = 0x04,
+		/** Mask for stencil shadows (not for direct use, use  SHADOWTYPE_ enum instead)
+		*/
+		SHADOWDETAILTYPE_STENCIL = 0x10,
+		/** Mask for texture shadows (not for direct use, use  SHADOWTYPE_ enum instead)
+		*/
+		SHADOWDETAILTYPE_TEXTURE = 0x20,
+		
+        /** Stencil shadow technique which renders all shadow volumes as
+            a modulation after all the non-transparent areas have been 
+            rendered. This technique is considerably less fillrate intensive 
+            than the additive stencil shadow approach when there are multiple
+            lights, but is not an accurate model. 
+        */
+        SHADOWTYPE_STENCIL_MODULATIVE = 0x12,
+        /** Stencil shadow technique which renders each light as a separate
+            additive pass to the scene. This technique can be very fillrate
+            intensive because it requires at least 2 passes of the entire
+            scene, more if there are multiple lights. However, it is a more
+            accurate model than the modulative stencil approach and this is
+            especially apparent when using coloured lights or bump mapping.
+        */
+        SHADOWTYPE_STENCIL_ADDITIVE = 0x11,
+        /** Texture-based shadow technique which involves a monochrome render-to-texture
+            of the shadow caster and a projection of that texture onto the 
+            shadow receivers as a modulative pass. 
+        */
+        SHADOWTYPE_TEXTURE_MODULATIVE = 0x22,
+		
+        /** Texture-based shadow technique which involves a render-to-texture
+            of the shadow caster and a projection of that texture onto the 
+            shadow receivers, built up per light as additive passes. 
+			This technique can be very fillrate intensive because it requires numLights + 2 
+			passes of the entire scene. However, it is a more accurate model than the 
+			modulative approach and this is especially apparent when using coloured lights 
+			or bump mapping.
+        */
+        SHADOWTYPE_TEXTURE_ADDITIVE = 0x21,
+
+		/** Texture-based shadow technique which involves a render-to-texture
+		of the shadow caster and a projection of that texture on to the shadow
+		receivers, with the usage of those shadow textures completely controlled
+		by the materials of the receivers.
+		This technique is easily the most flexible of all techniques because 
+		the material author is in complete control over how the shadows are
+		combined with regular rendering. It can perform shadows as accurately
+		as SHADOWTYPE_TEXTURE_ADDITIVE but more efficiently because it requires
+		less passes. However it also requires more expertise to use, and 
+		in almost all cases, shader capable hardware to really use to the full.
+		@note The 'additive' part of this mode means that the colour of
+		the rendered shadow texture is by default plain black. It does
+		not mean it does the adding on your receivers automatically though, how you
+		use that result is up to you.
+		*/
+		SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED = 0x25,
+		/** Texture-based shadow technique which involves a render-to-texture
+			of the shadow caster and a projection of that texture on to the shadow
+			receivers, with the usage of those shadow textures completely controlled
+			by the materials of the receivers.
+			This technique is easily the most flexible of all techniques because 
+			the material author is in complete control over how the shadows are
+			combined with regular rendering. It can perform shadows as accurately
+			as SHADOWTYPE_TEXTURE_ADDITIVE but more efficiently because it requires
+			less passes. However it also requires more expertise to use, and 
+			in almost all cases, shader capable hardware to really use to the full.
+			@note The 'modulative' part of this mode means that the colour of
+			the rendered shadow texture is by default the 'shadow colour'. It does
+			not mean it modulates on your receivers automatically though, how you
+			use that result is up to you.
+		*/
+		SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED = 0x26
+    };
+
+    /** An enumeration describing which material properties should track the vertex colours */
+    typedef int TrackVertexColourType;
+    enum TrackVertexColourEnum {
+        TVC_NONE        = 0x0,
+        TVC_AMBIENT     = 0x1,        
+        TVC_DIFFUSE     = 0x2,
+        TVC_SPECULAR    = 0x4,
+        TVC_EMISSIVE    = 0x8
+    };
+
+    /** Sort mode for billboard-set and particle-system */
+    enum SortMode
+    {
+        /** Sort by direction of the camera */
+        SM_DIRECTION,
+        /** Sort by distance from the camera */
+        SM_DISTANCE
+    };
+
+    /** Defines the frame buffer types. */
+    enum FrameBufferType {
+        FBT_COLOUR  = 0x1,
+        FBT_DEPTH   = 0x2,
+        FBT_STENCIL = 0x4
+    };
+
+	/** Flags for the Instance Manager when calculating ideal number of instances per batch */
+	enum InstanceManagerFlags
+	{
+		/** Forces an amount of instances per batch low enough so that vertices * numInst < 65535
+			since usually improves performance. In HW instanced techniques, this flag is ignored
+		*/
+		IM_USE16BIT		= 0x0001,
+
+		/** The num. of instances is adjusted so that as few pixels as possible are wasted
+			in the vertex texture */
+		IM_VTFBESTFIT	= 0x0002,
+
+		/** Use a limited number of skeleton animations shared among all instances. 
+		Update only that limited amount of animations in the vertex texture.*/
+		IM_VTFBONEMATRIXLOOKUP = 0x0004,
+
+		IM_USEBONEDUALQUATERNIONS = 0x0008,
+
+		/** Use one weight per vertex when recommended (i.e. VTF). */
+		IM_USEONEWEIGHT = 0x0010,
+
+		/** All techniques are forced to one weight per vertex. */
+		IM_FORCEONEWEIGHT = 0x0020,
+
+		IM_USEALL		= IM_USE16BIT|IM_VTFBESTFIT|IM_USEONEWEIGHT
+	};
+    
+	
+	/** A hashed vector.
+	*/
+	template <typename T>
+	class HashedVector
+	{
+	public:
+		typedef std::vector<T, STLAllocator<T, GeneralAllocPolicy> > VectorImpl;
+	protected:
+		VectorImpl mList;
+		mutable uint32 mListHash;
+		mutable bool mListHashDirty;
+
+		void addToHash(const T& newPtr) const
+		{
+			mListHash = FastHash((const char*)&newPtr, sizeof(T), mListHash);
+		}
+		void recalcHash() const
+		{
+			mListHash = 0;
+			for (const_iterator i = mList.begin(); i != mList.end(); ++i)
+				addToHash(*i);
+			mListHashDirty = false;
+			
+		}
+
+	public:
+		typedef typename VectorImpl::value_type value_type;
+		typedef typename VectorImpl::pointer pointer;
+		typedef typename VectorImpl::reference reference;
+		typedef typename VectorImpl::const_reference const_reference;
+		typedef typename VectorImpl::size_type size_type;
+		typedef typename VectorImpl::difference_type difference_type;
+		typedef typename VectorImpl::iterator iterator;
+		typedef typename VectorImpl::const_iterator const_iterator;
+		typedef typename VectorImpl::reverse_iterator reverse_iterator;
+		typedef typename VectorImpl::const_reverse_iterator const_reverse_iterator;
+
+		void dirtyHash()
+		{
+			mListHashDirty = true;
+		}
+		bool isHashDirty() const
+		{
+			return mListHashDirty;
+		}
+
+		iterator begin() 
+		{ 
+			// we have to assume that hash needs recalculating on non-const
+			dirtyHash();
+			return mList.begin(); 
+		}
+		iterator end() { return mList.end(); }
+		const_iterator begin() const { return mList.begin(); }
+		const_iterator end() const { return mList.end(); }
+		reverse_iterator rbegin() 
+		{ 
+			// we have to assume that hash needs recalculating on non-const
+			dirtyHash();
+			return mList.rbegin(); 
+		}
+		reverse_iterator rend() { return mList.rend(); }
+		const_reverse_iterator rbegin() const { return mList.rbegin(); }
+		const_reverse_iterator rend() const { return mList.rend(); }
+		size_type size() const { return mList.size(); }
+		size_type max_size() const { return mList.max_size(); }
+		size_type capacity() const { return mList.capacity(); }
+		bool empty() const { return mList.empty(); }
+		reference operator[](size_type n) 
+		{ 
+			// we have to assume that hash needs recalculating on non-const
+			dirtyHash();
+			return mList[n]; 
+		}
+		const_reference operator[](size_type n) const { return mList[n]; }
+		reference at(size_type n) 
+		{ 
+			// we have to assume that hash needs recalculating on non-const
+			dirtyHash();
+			return mList.const_iterator(n); 
+		}
+		const_reference at(size_type n) const { return mList.at(n); }
+		HashedVector() : mListHash(0), mListHashDirty(false) {}
+		HashedVector(size_type n) : mList(n), mListHash(0), mListHashDirty(n > 0) {}
+		HashedVector(size_type n, const T& t) : mList(n, t), mListHash(0), mListHashDirty(n > 0) {}
+		HashedVector(const HashedVector<T>& rhs) 
+			: mList(rhs.mList), mListHash(rhs.mListHash), mListHashDirty(rhs.mListHashDirty) {}
+
+		template <class InputIterator>
+		HashedVector(InputIterator a, InputIterator b)
+			: mList(a, b), mListHashDirty(false)
+		{
+			dirtyHash();
+		}
+
+		~HashedVector() {}
+		HashedVector<T>& operator=(const HashedVector<T>& rhs)
+		{
+			mList = rhs.mList;
+			mListHash = rhs.mListHash;
+			mListHashDirty = rhs.mListHashDirty;
+			return *this;
+		}
+
+		void reserve(size_t t) { mList.reserve(t); }
+		reference front() 
+		{ 
+			// we have to assume that hash needs recalculating on non-const
+			dirtyHash();
+			return mList.front(); 
+		}
+		const_reference front() const { return mList.front(); }
+		reference back()  
+		{ 
+			// we have to assume that hash needs recalculating on non-const
+			dirtyHash();
+			return mList.back(); 
+		}
+		const_reference back() const { return mList.back(); }
+		void push_back(const T& t)
+		{ 
+			mList.push_back(t);
+			// Quick progressive hash add
+			if (!isHashDirty())
+				addToHash(t);
+		}
+		void pop_back()
+		{
+			mList.pop_back();
+			dirtyHash();
+		}
+		void swap(HashedVector<T>& rhs)
+		{
+			mList.swap(rhs.mList);
+			dirtyHash();
+		}
+		iterator insert(iterator pos, const T& t)
+		{
+			bool recalc = (pos != end());
+			iterator ret = mList.insert(pos, t);
+			if (recalc)
+				dirtyHash();
+			else
+				addToHash(t);
+			return ret;
+		}
+
+		template <class InputIterator>
+		void insert(iterator pos,
+			InputIterator f, InputIterator l)
+		{
+			mList.insert(pos, f, l);
+			dirtyHash();
+		}
+
+		void insert(iterator pos, size_type n, const T& x)
+		{
+			mList.insert(pos, n, x);
+			dirtyHash();
+		}
+
+		iterator erase(iterator pos)
+		{
+			iterator ret = mList.erase(pos);
+			dirtyHash();
+			return ret;
+		}
+		iterator erase(iterator first, iterator last)
+		{
+			iterator ret = mList.erase(first, last);
+			dirtyHash();
+			return ret;
+		}
+		void clear()
+		{
+			mList.clear();
+			mListHash = 0;
+			mListHashDirty = false;
+		}
+
+		void resize(size_type n, const T& t = T())
+		{
+			bool recalc = false;
+			if (n != size())
+				recalc = true;
+
+			mList.resize(n, t);
+			if (recalc)
+				dirtyHash();
+		}
+
+		bool operator==(const HashedVector<T>& b)
+		{ return mListHash == b.mListHash; }
+
+		bool operator<(const HashedVector<T>& b)
+		{ return mListHash < b.mListHash; }
+
+
+		/// Get the hash value
+		uint32 getHash() const 
+		{ 
+			if (isHashDirty())
+				recalcHash();
+
+			return mListHash; 
+		}
+	public:
+
+
+
+	};
+
+	class Light;
+	typedef HashedVector<Light*> LightList;
+
+
+
+    typedef map<String, bool>::type UnaryOptionList;
+    typedef map<String, String>::type BinaryOptionList;
+
+	/// Name / value parameter pair (first = name, second = value)
+	typedef map<String, String>::type NameValuePairList;
+
+    /// Alias / Texture name pair (first = alias, second = texture name)
+    typedef map<String, String>::type AliasTextureNamePairList;
+
+        template< typename T > struct TRect
+        {
+          T left, top, right, bottom;
+          TRect() : left(0), top(0), right(0), bottom(0) {}
+          TRect( T const & l, T const & t, T const & r, T const & b )
+            : left( l ), top( t ), right( r ), bottom( b )
+          {
+          }
+          TRect( TRect const & o )
+            : left( o.left ), top( o.top ), right( o.right ), bottom( o.bottom )
+          {
+          }
+          TRect & operator=( TRect const & o )
+          {
+            left = o.left;
+            top = o.top;
+            right = o.right;
+            bottom = o.bottom;
+            return *this;
+          }
+          T width() const
+          {
+            return right - left;
+          }
+          T height() const
+          {
+            return bottom - top;
+          }
+		  bool isNull() const
+		  {
+			  return width() == 0 || height() == 0;
+		  }
+		  void setNull()
+		  {
+			  left = right = top = bottom = 0;
+		  }
+		  TRect & merge(const TRect& rhs)
+		  {
+			  if (isNull())
+			  {
+				  *this = rhs;
+			  }
+			  else if (!rhs.isNull())
+			  {
+				  left = std::min(left, rhs.left);
+				  right = std::max(right, rhs.right);
+				  top = std::min(top, rhs.top);
+				  bottom = std::max(bottom, rhs.bottom);
+			  }
+
+			  return *this;
+
+		  }
+		  TRect intersect(const TRect& rhs) const
+		  {
+			  TRect ret;
+			  if (isNull() || rhs.isNull())
+			  {
+				  // empty
+				  return ret;
+			  }
+			  else
+			  {
+				  ret.left = std::max(left, rhs.left);
+				  ret.right = std::min(right, rhs.right);
+				  ret.top = std::max(top, rhs.top);
+				  ret.bottom = std::min(bottom, rhs.bottom);
+			  }
+
+			  if (ret.left > ret.right || ret.top > ret.bottom)
+			  {
+				  // no intersection, return empty
+				  ret.left = ret.top = ret.right = ret.bottom = 0;
+			  }
+
+			  return ret;
+
+		  }
+
+        };
+		template<typename T>
+		std::ostream& operator<<(std::ostream& o, const TRect<T>& r)
+		{
+			o << "TRect<>(l:" << r.left << ", t:" << r.top << ", r:" << r.right << ", b:" << r.bottom << ")";
+			return o;
+		}
+
+        /** Structure used to define a rectangle in a 2-D floating point space.
+        */
+        typedef TRect<float> FloatRect;
+
+		/** Structure used to define a rectangle in a 2-D floating point space, 
+			subject to double / single floating point settings.
+		*/
+		typedef TRect<Real> RealRect;
+
+        /** Structure used to define a rectangle in a 2-D integer space.
+        */
+        typedef TRect< long > Rect;
+
+        /** Structure used to define a box in a 3-D integer space.
+         	Note that the left, top, and front edges are included but the right, 
+         	bottom and back ones are not.
+         */
+        struct Box
+        {
+            size_t left, top, right, bottom, front, back;
+			/// Parameterless constructor for setting the members manually
+            Box()
+				: left(0), top(0), right(1), bottom(1), front(0), back(1)
+            {
+            }
+            /** Define a box from left, top, right and bottom coordinates
+            	This box will have depth one (front=0 and back=1).
+            	@param	l	x value of left edge
+            	@param	t	y value of top edge
+            	@param	r	x value of right edge
+            	@param	b	y value of bottom edge
+            	@note Note that the left, top, and front edges are included 
+ 		           	but the right, bottom and back ones are not.
+            */
+            Box( size_t l, size_t t, size_t r, size_t b ):
+                left(l),
+                top(t),   
+                right(r),
+                bottom(b),
+                front(0),
+                back(1)
+            {
+          		assert(right >= left && bottom >= top && back >= front);
+            }
+            /** Define a box from left, top, front, right, bottom and back
+            	coordinates.
+            	@param	l	x value of left edge
+            	@param	t	y value of top edge
+            	@param  ff  z value of front edge
+            	@param	r	x value of right edge
+            	@param	b	y value of bottom edge
+            	@param  bb  z value of back edge
+            	@note Note that the left, top, and front edges are included 
+ 		           	but the right, bottom and back ones are not.
+            */
+            Box( size_t l, size_t t, size_t ff, size_t r, size_t b, size_t bb ):
+                left(l),
+                top(t),   
+                right(r),
+                bottom(b),
+                front(ff),
+                back(bb)
+            {
+          		assert(right >= left && bottom >= top && back >= front);
+            }
+            
+            /// Return true if the other box is a part of this one
+            bool contains(const Box &def) const
+            {
+            	return (def.left >= left && def.top >= top && def.front >= front &&
+					def.right <= right && def.bottom <= bottom && def.back <= back);
+            }
+            
+            /// Get the width of this box
+            size_t getWidth() const { return right-left; }
+            /// Get the height of this box
+            size_t getHeight() const { return bottom-top; }
+            /// Get the depth of this box
+            size_t getDepth() const { return back-front; }
+        };
+
+    
+	
+	/** Locate command-line options of the unary form '-blah' and of the
+        binary form '-blah foo', passing back the index of the next non-option.
+    @param numargs, argv The standard parameters passed to the main method
+    @param unaryOptList Map of unary options (i.e. those that do not require a parameter).
+        Should be pre-populated with, for example '-e' in the key and false in the 
+        value. Options which are found will be set to true on return.
+    @param binOptList Map of binary options (i.e. those that require a parameter
+        e.g. '-e afile.txt').
+        Should be pre-populated with, for example '-e' and the default setting. 
+        Options which are found will have the value updated.
+    */
+    int _OgreExport findCommandLineOpts(int numargs, char** argv, UnaryOptionList& unaryOptList, 
+        BinaryOptionList& binOptList);
+
+	/// Generic result of clipping
+	enum ClipResult
+	{
+		/// Nothing was clipped
+		CLIPPED_NONE = 0,
+		/// Partially clipped
+		CLIPPED_SOME = 1, 
+		/// Everything was clipped away
+		CLIPPED_ALL = 2
+	};
+
+	/// Render window creation parameters.
+	struct RenderWindowDescription
+	{
+		String				name;
+		unsigned int		width;
+		unsigned int		height;
+		bool				useFullScreen;
+		NameValuePairList	miscParams;
+	};
+
+	/// Render window creation parameters container.
+	typedef vector<RenderWindowDescription>::type RenderWindowDescriptionList;
+
+	/// Render window container.
+	typedef vector<RenderWindow*>::type RenderWindowList;
+
+	/// Utility class to generate a sequentially numbered series of names
+	class _OgreExport NameGenerator
+	{
+	protected:
+		String mPrefix;
+		unsigned long long int mNext;
+		OGRE_AUTO_MUTEX
+	public:
+		NameGenerator(const NameGenerator& rhs)
+			: mPrefix(rhs.mPrefix), mNext(rhs.mNext) {}
+		
+		NameGenerator(const String& prefix) : mPrefix(prefix), mNext(1) {}
+
+		/// Generate a new name
+		String generate()
+		{
+			OGRE_LOCK_AUTO_MUTEX
+			std::ostringstream s;
+			s << mPrefix << mNext++;
+			return s.str();
+		}
+
+		/// Reset the internal counter
+		void reset()
+		{
+			OGRE_LOCK_AUTO_MUTEX
+			mNext = 1ULL;
+		}
+
+		/// Manually set the internal counter (use caution)
+		void setNext(unsigned long long int val)
+		{
+			OGRE_LOCK_AUTO_MUTEX
+			mNext = val;
+		}
+
+		/// Get the internal counter
+		unsigned long long int getNext() const
+		{
+			// lock even on get because 64-bit may not be atomic read
+			OGRE_LOCK_AUTO_MUTEX
+			return mNext;
+		}
+
+
+
+
+	};
+
+	/** Template class describing a simple pool of items.
+	*/
+	template <typename T>
+	class Pool
+	{
+	protected:
+		typedef typename list<T>::type ItemList;
+		ItemList mItems;
+		OGRE_AUTO_MUTEX
+	public:
+		Pool() {} 
+		virtual ~Pool() {}
+
+		/** Get the next item from the pool.
+		@return pair indicating whether there was a free item, and the item if so
+		*/
+		virtual std::pair<bool, T> removeItem()
+		{
+			OGRE_LOCK_AUTO_MUTEX
+			std::pair<bool, T> ret;
+			if (mItems.empty())
+			{
+				ret.first = false;
+			}
+			else
+			{
+				ret.first = true;
+				ret.second = mItems.front();
+				mItems.pop_front();
+			}
+			return ret;
+		}
+
+		/** Add a new item to the pool. 
+		*/
+		virtual void addItem(const T& i)
+		{
+			OGRE_LOCK_AUTO_MUTEX
+			mItems.push_front(i);
+		}
+		/// Clear the pool
+		virtual void clear()
+		{
+			OGRE_LOCK_AUTO_MUTEX
+			mItems.clear();
+		}
+
+
+
+	};
+	/** @} */
+	/** @} */
+}
+
+#endif