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

data/deps/include/OGRE/OgreRectangle.h

@@ -1,77 +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 _Rectangle_H__
-#define _Rectangle_H__
-
-#include "OgrePrerequisites.h"
-
-namespace Ogre {
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup General
-	*  @{
-	*/
-
-    struct _OgreExport Rectangle
-    {
-        Real left;
-        Real top;
-        Real right;
-        Real bottom;
-
-        inline bool inside(Real x, Real y) const { return x >= left && x <= right && y >= top && y <= bottom; }
-    };
-
-    /** Geometric intersection of two rectanglar regions.
-     *
-     * @remarks Calculates the geometric intersection of two rectangular
-     * regions.  Rectangle coordinates must be ([0-N], [0-N]), such that
-     * (0,0) is in the upper left hand corner.
-     *
-     * If the two input rectangles do not intersect, then the result will be
-     * a degenerate rectangle, i.e. left >= right or top >= bottom, or both.
-     */
-    inline Rectangle intersect(const Rectangle& lhs, const Rectangle& rhs)
-    {
-        Rectangle r;
-
-        r.left   = lhs.left   > rhs.left   ? lhs.left   : rhs.left;
-        r.top    = lhs.top    > rhs.top    ? lhs.top    : rhs.top;
-        r.right  = lhs.right  < rhs.right  ? lhs.right  : rhs.right;
-        r.bottom = lhs.bottom < rhs.bottom ? lhs.bottom : rhs.bottom;
-
-        return r;
-    }
-	/** @} */
-	/** @} */
-
-}
-
-#endif // _Rectangle_H__

data/deps/include/OGRE/OgreRectangle2D.h

@@ -1,101 +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 _Rectangle2D_H__
-#define _Rectangle2D_H__
-
-#include "OgrePrerequisites.h"
-
-#include "OgreSimpleRenderable.h"
-
-namespace Ogre {
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Scene
-	*  @{
-	*/
-	/** Allows the rendering of a simple 2D rectangle
-    This class renders a simple 2D rectangle; this rectangle has no depth and
-    therefore is best used with specific render queue and depth settings,
-    like RENDER_QUEUE_BACKGROUND and 'depth_write off' for backdrops, and 
-    RENDER_QUEUE_OVERLAY and 'depth_check off' for fullscreen quads.
-    */
-    class _OgreExport Rectangle2D : public SimpleRenderable
-    {
-    protected:
-        /** Override this method to prevent parent transforms (rotation,translation,scale)
-        */
-        void getWorldTransforms( Matrix4* xform ) const;
-
-        void _initRectangle2D(bool includeTextureCoords, Ogre::HardwareBuffer::Usage vBufUsage);
-
-    public:
-
-        Rectangle2D(bool includeTextureCoordinates = false, HardwareBuffer::Usage vBufUsage = HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
-        Rectangle2D(const String& name, bool includeTextureCoordinates = false, HardwareBuffer::Usage vBufUsage = HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
-        ~Rectangle2D();
-
-        /** Sets the corners of the rectangle, in relative coordinates.
-        @param
-        left Left position in screen relative coordinates, -1 = left edge, 1.0 = right edge
-        @param top Top position in screen relative coordinates, 1 = top edge, -1 = bottom edge
-        @param right Right position in screen relative coordinates
-        @param bottom Bottom position in screen relative coordinates
-		@param updateAABB Tells if you want to recalculate the AABB according to 
-		the new corners. If false, the axis aligned bounding box will remain identical.
-        */
-        void setCorners(Real left, Real top, Real right, Real bottom, bool updateAABB = true);
-
-		/** Sets the normals of the rectangle
-		*/
-		void setNormals(const Ogre::Vector3 &topLeft, const Ogre::Vector3 &bottomLeft, const Ogre::Vector3 &topRight, const Ogre::Vector3 &bottomRight);
-
-		/** Sets the UVs of the rectangle
-		@remarks
-		Doesn't do anything if the rectangle wasn't built with texture coordinates
-		*/
-		void setUVs( const Ogre::Vector2 &topLeft, const Ogre::Vector2 &bottomLeft,
-					 const Ogre::Vector2 &topRight, const Ogre::Vector2 &bottomRight);
-
-		void setDefaultUVs();
-
-        Real getSquaredViewDepth(const Camera* cam) const
-        { (void)cam; return 0; }
-
-        Real getBoundingRadius(void) const { return 0; }
-
-    };
-	/** @} */
-	/** @} */
-
-}// namespace
-
-#endif
-
-

data/deps/include/OGRE/OgreRenderObjectListener.h

@@ -1,64 +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 __RenderObjectListener_H__
-#define __RenderObjectListener_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreRenderable.h"
-#include "OgrePass.h"
-
-namespace Ogre {
-
-	class Pass;
-	class Renderable;
-
-    /** Abstract interface which classes must implement if they wish to receive
-        events from the scene manager when single object is about to be rendered. 
-    */
-	class _OgreExport RenderObjectListener
-	{
-	public:
-		virtual ~RenderObjectListener() {}
-		/** Event raised when render single object started.
-		@remarks
-		This method is called by the SceneManager.
-		@param pass The renderable that is going to be rendered.
-		@param pass The pass which was set.
-		@param source The auto parameter source used within this render call.
-		@pLightList The light list in use.
-		@suppressRenderStateChanges True if render state changes should be suppressed.
-		*/
-		virtual void notifyRenderSingleObject(Renderable* rend, const Pass* pass, const AutoParamDataSource* source, 
-			const LightList* pLightList, bool suppressRenderStateChanges) = 0;
-	};
-
-
-}
-
-#endif
-

data/deps/include/OGRE/OgreRenderOperation.h

@@ -1,100 +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 _RenderOperation_H__
-#define _RenderOperation_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreVertexIndexData.h"
-
-namespace Ogre {
-
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup RenderSystem
-	*  @{
-	*/
-	/** 'New' rendering operation using vertex buffers. */
-	class _OgrePrivate RenderOperation {
-	public:
-		/// The rendering operation type to perform
-		enum OperationType {
-			/// A list of points, 1 vertex per point
-            OT_POINT_LIST = 1,
-			/// A list of lines, 2 vertices per line
-            OT_LINE_LIST = 2,
-			/// A strip of connected lines, 1 vertex per line plus 1 start vertex
-            OT_LINE_STRIP = 3,
-			/// A list of triangles, 3 vertices per triangle
-            OT_TRIANGLE_LIST = 4,
-			/// A strip of triangles, 3 vertices for the first triangle, and 1 per triangle after that 
-            OT_TRIANGLE_STRIP = 5,
-			/// A fan of triangles, 3 vertices for the first triangle, and 1 per triangle after that
-            OT_TRIANGLE_FAN = 6
-        };
-
-		/// Vertex source data
-		VertexData *vertexData;
-
-		/// The type of operation to perform
-		OperationType operationType;
-
-		/** Specifies whether to use indexes to determine the vertices to use as input. If false, the vertices are
-		 simply read in sequence to define the primitives. If true, indexes are used instead to identify vertices
-		 anywhere in the buffer, and allowing vertices to be used more than once.
-	   	 If true, then the indexBuffer, indexStart and numIndexes properties must be valid. */
-		bool useIndexes;
-
-		/// Index data - only valid if useIndexes is true
-		IndexData *indexData;
-		/// Debug pointer back to renderable which created this
-		const Renderable* srcRenderable;
-
-		/// The number of instances for the render operation - this option is supported 
-		/// in only a part of the render systems.
-		size_t numberOfInstances;
-
-        /** A flag to indicate that it is possible for this operation to use a global
-            vertex instance buffer if available.*/
-        bool useGlobalInstancingVertexBufferIsAvailable;
-
-        RenderOperation() :
-            vertexData(0), operationType(OT_TRIANGLE_LIST), useIndexes(true),
-                indexData(0), srcRenderable(0), numberOfInstances(1),
-                useGlobalInstancingVertexBufferIsAvailable(true) {}
-
-
-	};
-	/** @} */
-	/** @} */
-}
-
-
-
-#endif

data/deps/include/OGRE/OgreRenderQueue.h

@@ -1,516 +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 __RenderQueue_H__
-#define __RenderQueue_H__
-
-#include "OgreHeaderPrefix.h"
-#include "OgrePrerequisites.h"
-#include "OgreIteratorWrappers.h"
-
-namespace Ogre {
-
-	class Camera;
-	class MovableObject;
-	struct VisibleObjectsBoundsInfo;
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup RenderSystem
-	*  @{
-	*/
-	/** Enumeration of queue groups, by which the application may group queued renderables
-        so that they are rendered together with events in between
-	@remarks
-		When passed into methods these are actually passed as a uint8 to allow you
-		to use values in between if you want to.
-    */
-    enum RenderQueueGroupID
-    {
-        /// Use this queue for objects which must be rendered first e.g. backgrounds
-        RENDER_QUEUE_BACKGROUND = 0,
-        /// First queue (after backgrounds), used for skyboxes if rendered first
-        RENDER_QUEUE_SKIES_EARLY = 5,
-        RENDER_QUEUE_1 = 10,
-        RENDER_QUEUE_2 = 20,
-		RENDER_QUEUE_WORLD_GEOMETRY_1 = 25,
-        RENDER_QUEUE_3 = 30,
-        RENDER_QUEUE_4 = 40,
-		/// The default render queue
-        RENDER_QUEUE_MAIN = 50,
-        RENDER_QUEUE_6 = 60,
-        RENDER_QUEUE_7 = 70,
-		RENDER_QUEUE_WORLD_GEOMETRY_2 = 75,
-        RENDER_QUEUE_8 = 80,
-        RENDER_QUEUE_9 = 90,
-        /// Penultimate queue(before overlays), used for skyboxes if rendered last
-        RENDER_QUEUE_SKIES_LATE = 95,
-        /// Use this queue for objects which must be rendered last e.g. overlays
-        RENDER_QUEUE_OVERLAY = 100, 
-		/// Final possible render queue, don't exceed this
-		RENDER_QUEUE_MAX = 105
-    };
-
-    #define OGRE_RENDERABLE_DEFAULT_PRIORITY  100
-
-    /** Class to manage the scene object rendering queue.
-        @remarks
-            Objects are grouped by material to minimise rendering state changes. The map from
-            material to renderable object is wrapped in a class for ease of use.
-        @par
-            This class now includes the concept of 'queue groups' which allows the application
-            adding the renderable to specifically schedule it so that it is included in 
-            a discrete group. Good for separating renderables into the main scene,
-            backgrounds and overlays, and also could be used in the future for more
-            complex multipass routines like stenciling.
-    */
-    class _OgreExport RenderQueue : public RenderQueueAlloc
-    {
-    public:
-
-		class RenderQueueGroupMap
-		{
-		public:
-			class value_type
-			{
-			public:
-				value_type(uint8 _f, RenderQueueGroup* _g) : first(_f), second(_g)
-				{
-
-				}
-				value_type() : first(0), second(0)
-				{
-
-				}
-				uint8 first;
-				RenderQueueGroup* second;
-			};
-
-			typedef uint8 key_type;
-			typedef RenderQueueGroup* mapped_type;
-			typedef value_type& reference;
-			typedef value_type* pointer;
-			typedef const value_type& const_reference;
-			typedef const value_type* const_pointer;
-			typedef vector<value_type >::type GroupVector;
-
-			class iterator
-			{
-				friend class RenderQueueGroupMap;
-			public:
-
-				iterator() : mRenderQueueGroupMap(0), mIndex(RENDER_QUEUE_MAX)
-				{
-				}
-
-				iterator(const RenderQueueGroupMap* _mRenderQueueGroupMap, uint8 _index) : mRenderQueueGroupMap(_mRenderQueueGroupMap), mIndex(_index)
-				{
-				}
-
-				const_reference operator*() const
-				{	
-					assert(this->mRenderQueueGroupMap);
-
-					return mRenderQueueGroupMap->mGroupVector[mIndex];
-				}
-
-				const_pointer operator->() const
-				{
-					assert(this->mRenderQueueGroupMap);
-
-					return &(mRenderQueueGroupMap->mGroupVector[mIndex]);
-				}
-
-				iterator& operator++()
-				{
-					assert(this->mRenderQueueGroupMap);
-
-					while(mIndex < mRenderQueueGroupMap->mMaxID)
-					{
-						++mIndex;
-						if(mRenderQueueGroupMap->mGroupVector[mIndex].second != 0)
-						{
-							break;
-						}
-					}
-					return (*this);
-				}
-
-				const iterator& operator++()const
-				{
-					assert(this->mRenderQueueGroupMap);
-
-					while(mIndex < mRenderQueueGroupMap->mMaxID)
-					{
-						++mIndex;
-						if(mRenderQueueGroupMap->mGroupVector[mIndex].second != 0)
-						{
-							break;
-						}
-					}
-					return (*this);
-				}
-
-				iterator operator++(int)
-				{
-					assert(this->mRenderQueueGroupMap);
-
-					iterator temp = *this;
-					while(mIndex < mRenderQueueGroupMap->mMaxID)
-					{
-						++mIndex;
-						if(mRenderQueueGroupMap->mGroupVector[mIndex].second != 0)
-						{
-							break;
-						}
-					}
-					return (temp);
-				}
-
-				const iterator operator++(int)const
-				{
-					assert(this->mRenderQueueGroupMap);
-
-					const_iterator temp = *this;
-					while(mIndex < mRenderQueueGroupMap->mMaxID)
-					{
-						++mIndex;
-						if(mRenderQueueGroupMap->mGroupVector[mIndex].second != 0)
-						{
-							break;
-						}
-					}
-					return (temp);
-				}
-
-				bool operator !=(const iterator& o)const
-				{
-					assert(mRenderQueueGroupMap);
-					assert(o.mRenderQueueGroupMap);
-					assert(o.mRenderQueueGroupMap == this->mRenderQueueGroupMap);
-					if( o.mIndex != this->mIndex)
-						return true;
-					return false;
-				}
-
-				bool operator ==(const iterator& o)const
-				{
-					assert(this->mRenderQueueGroupMap);
-					assert(o.mRenderQueueGroupMap);
-					assert(o.mRenderQueueGroupMap == this->mRenderQueueGroupMap);
-					if(o.mIndex == this->mIndex)
-					{
-						return true;
-					}
-					return false;
-				}
-			protected:
-				const RenderQueueGroupMap* mRenderQueueGroupMap;
-				mutable uint8 mIndex;
-			};
-
-			typedef const iterator const_iterator;
-			
-			RenderQueueGroupMap() : mMinID(RENDER_QUEUE_MAX), mMaxID(RENDER_QUEUE_MAX)
-			{
-				mGroupVector.resize(RENDER_QUEUE_MAX + 2);
-			}
-
-			void insert(value_type v)
-			{
-				mGroupVector[v.first] = v;
-				if(v.first < mMinID)
-				{
-					mMinID = v.first;
-				}
-
-				if(v.first >= mMaxID || mMaxID == RENDER_QUEUE_MAX)
-				{
-					mMaxID = v.first + 1;
-				}
-			}
-
-			iterator find(uint8 key)
-			{
-				if(mGroupVector[key].second == 0)
-				{
-					return iterator(this, mMaxID);
-				}
-				else
-				{
-					return iterator(this, key);
-				}
-			}
-
-			iterator begin()
-			{
-				return iterator(this, mMinID);
-			}
-
-			iterator end()
-			{
-				return iterator(this, mMaxID);
-			}
-
-			const_iterator begin() const
-			{
-				return iterator(this, mMinID);
-			}
-
-			const_iterator end() const
-			{
-				return iterator(this, mMaxID);
-			}
-			
-			void clear()
-			{
-				mGroupVector.reserve(RENDER_QUEUE_MAX + 2);
-				mGroupVector.clear();
-				mGroupVector.resize(RENDER_QUEUE_MAX + 2);
-				mMinID = RENDER_QUEUE_MAX;
-				mMaxID = RENDER_QUEUE_MAX;
-			}
-		protected:
-			uint8 mMinID;
-			uint8 mMaxID;
-			GroupVector mGroupVector;
-		};
-
-		typedef MapIterator<RenderQueueGroupMap> QueueGroupIterator;
-		typedef ConstMapIterator<RenderQueueGroupMap> ConstQueueGroupIterator;
-
-		/** Class to listen in on items being added to the render queue. 
-		@remarks
-			Use RenderQueue::setRenderableListener to get callbacks when an item
-			is added to the render queue.
-		*/
-		class _OgreExport RenderableListener
-		{
-		public:
-			RenderableListener() {}
-			virtual ~RenderableListener() {}
-
-			/** Method called when a Renderable is added to the queue.
-			@remarks
-				You can use this event hook to alter the Technique used to
-				render a Renderable as the item is added to the queue. This is
-				a low-level way to override the material settings for a given
-				Renderable on the fly.
-			@param rend The Renderable being added to the queue
-			@param groupID The render queue group this Renderable is being added to
-			@param priority The priority the Renderable has been given
-			@param ppTech A pointer to the pointer to the Technique that is 
-				intended to be used; you can alter this to an alternate Technique
-				if you so wish (the Technique doesn't have to be from the same
-				Material either).
-			@param pQueue Pointer to the render queue that this object is being
-				added to. You can for example call this back to duplicate the 
-				object with a different technique
-			@return true to allow the Renderable to be added to the queue, 
-				false if you want to prevent it being added
-			*/
-			virtual bool renderableQueued(Renderable* rend, uint8 groupID, 
-				ushort priority, Technique** ppTech, RenderQueue* pQueue) = 0;
-		};
-    protected:
-        RenderQueueGroupMap mGroups;
-        /// The current default queue group
-        uint8 mDefaultQueueGroup;
-        /// The default priority
-        ushort mDefaultRenderablePriority;
-
-        bool mSplitPassesByLightingType;
-        bool mSplitNoShadowPasses;
-		bool mShadowCastersCannotBeReceivers;
-
-		RenderableListener* mRenderableListener;
-    public:
-        RenderQueue();
-        virtual ~RenderQueue();
-
-        /** Empty the queue - should only be called by SceneManagers.
-		@param destroyPassMaps Set to true to destroy all pass maps so that
-			the queue is completely clean (useful when switching scene managers)
-        */
-        void clear(bool destroyPassMaps = false);
-
-		/** Get a render queue group.
-		@remarks
-			OGRE registers new queue groups as they are requested, 
-			therefore this method will always return a valid group.
-		*/
-		RenderQueueGroup* getQueueGroup(uint8 qid);
-
-        /** Add a renderable object to the queue.
-        @remarks
-            This methods adds a Renderable to the queue, which will be rendered later by 
-            the SceneManager. This is the advanced version of the call which allows the renderable
-            to be added to any queue.
-        @note
-            Called by implementation of MovableObject::_updateRenderQueue.
-        @param
-            pRend Pointer to the Renderable to be added to the queue
-        @param
-            groupID The group the renderable is to be added to. This
-            can be used to schedule renderable objects in separate groups such that the SceneManager
-            respects the divisions between the groupings and does not reorder them outside these
-            boundaries. This can be handy for overlays where no matter what you want the overlay to 
-            be rendered last.
-        @param
-            priority Controls the priority of the renderable within the queue group. If this number
-            is raised, the renderable will be rendered later in the group compared to it's peers.
-            Don't use this unless you really need to, manually ordering renderables prevents OGRE
-            from sorting them for best efficiency. However this could be useful for ordering 2D
-            elements manually for example.
-        */
-        void addRenderable(Renderable* pRend, uint8 groupID, ushort priority);
-
-        /** Add a renderable object to the queue.
-        @remarks
-            This methods adds a Renderable to the queue, which will be rendered later by 
-            the SceneManager. This is the simplified version of the call which does not 
-            require a priority to be specified. The queue priority is take from the
-            current default (see setDefaultRenderablePriority).
-        @note
-            Called by implementation of MovableObject::_updateRenderQueue.
-        @param
-            pRend Pointer to the Renderable to be added to the queue
-		@param
-            groupID The group the renderable is to be added to. This
-            can be used to schedule renderable objects in separate groups such that the SceneManager
-            respects the divisions between the groupings and does not reorder them outside these
-            boundaries. This can be handy for overlays where no matter what you want the overlay to 
-            be rendered last.
-        */
-        void addRenderable(Renderable* pRend, uint8 groupId);
-
-        /** Add a renderable object to the queue.
-        @remarks
-            This methods adds a Renderable to the queue, which will be rendered later by 
-            the SceneManager. This is the simplified version of the call which does not 
-            require a queue or priority to be specified. The queue group is taken from the
-            current default (see setDefaultQueueGroup).  The queue priority is take from the
-            current default (see setDefaultRenderablePriority).
-        @note
-            Called by implementation of MovableObject::_updateRenderQueue.
-        @param
-            pRend Pointer to the Renderable to be added to the queue
-        */
-        void addRenderable(Renderable* pRend);
-        
-        /** Gets the current default queue group, which will be used for all renderable which do not
-            specify which group they wish to be on.
-        */
-        uint8 getDefaultQueueGroup(void) const;
-
-        /** Sets the current default renderable priority, 
-            which will be used for all renderables which do not
-            specify which priority they wish to use.
-        */
-        void setDefaultRenderablePriority(ushort priority);
-
-        /** Gets the current default renderable priority, which will be used for all renderables which do not
-            specify which priority they wish to use.
-        */
-        ushort getDefaultRenderablePriority(void) const;
-
-        /** Sets the current default queue group, which will be used for all renderable which do not
-            specify which group they wish to be on. See the enum RenderQueueGroupID for what kind of
-			values can be used here.
-        */
-        void setDefaultQueueGroup(uint8 grp);
-        
-        /** Internal method, returns an iterator for the queue groups. */
-        QueueGroupIterator _getQueueGroupIterator(void);
-        ConstQueueGroupIterator _getQueueGroupIterator(void) const;
-
-        /** Sets whether or not the queue will split passes by their lighting type,
-            ie ambient, per-light and decal. 
-        */
-        void setSplitPassesByLightingType(bool split);
-
-        /** Gets whether or not the queue will split passes by their lighting type,
-            ie ambient, per-light and decal. 
-        */
-        bool getSplitPassesByLightingType(void) const;
-
-        /** Sets whether or not the queue will split passes which have shadow receive
-        turned off (in their parent material), which is needed when certain shadow
-        techniques are used.
-        */
-        void setSplitNoShadowPasses(bool split);
-
-        /** Gets whether or not the queue will split passes which have shadow receive
-        turned off (in their parent material), which is needed when certain shadow
-        techniques are used.
-        */
-        bool getSplitNoShadowPasses(void) const;
-
-		/** Sets whether or not objects which cast shadows should be treated as
-		never receiving shadows. 
-		*/
-		void setShadowCastersCannotBeReceivers(bool ind);
-
-		/** Gets whether or not objects which cast shadows should be treated as
-		never receiving shadows. 
-		*/
-		bool getShadowCastersCannotBeReceivers(void) const;
-
-		/** Set a renderable listener on the queue.
-		@remarks
-			There can only be a single renderable listener on the queue, since
-			that listener has complete control over the techniques in use.
-		*/
-		void setRenderableListener(RenderableListener* listener)
-		{ mRenderableListener = listener; }
-
-		RenderableListener* getRenderableListener(void) const
-		{ return mRenderableListener; }
-
-		/** Merge render queue.
-		*/
-		void merge( const RenderQueue* rhs );
-		/** Utility method to perform the standard actions associated with 
-			getting a visible object to add itself to the queue. This is 
-			a replacement for SceneManager implementations of the associated
-			tasks related to calling MovableObject::_updateRenderQueue.
-		*/
-		void processVisibleObject(MovableObject* mo, 
-			Camera* cam, 
-			bool onlyShadowCasters, 
-			VisibleObjectsBoundsInfo* visibleBounds);
-
-    };
-
-	/** @} */
-	/** @} */
-
-}
-
-#include "OgreHeaderSuffix.h"
-#endif