ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreCompositionTechnique.h

@@ -0,0 +1,188 @@
+/*
+-----------------------------------------------------------------------------
+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 __CompositionTechnique_H__
+#define __CompositionTechnique_H__
+
+#include "OgrePrerequisites.h"
+#include "OgrePixelFormat.h"
+#include "OgreIteratorWrappers.h"
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Effects
+	*  @{
+	*/
+	/** Base composition technique, can be subclassed in plugins.
+     */
+	class _OgreExport CompositionTechnique : public CompositorInstAlloc
+    {
+    public:
+        CompositionTechnique(Compositor *parent);
+        virtual ~CompositionTechnique();
+    
+        //The scope of a texture defined by the compositor
+        enum TextureScope { 
+            //Local texture - only available to the compositor passes in this technique
+            TS_LOCAL, 
+            //Chain texture - available to the other compositors in the chain
+            TS_CHAIN, 
+            //Global texture - available to everyone in every scope
+            TS_GLOBAL 
+        };
+
+        /// Local texture definition
+        class TextureDefinition : public CompositorInstAlloc
+        {
+        public:
+            String name;
+			//Texture definition being a reference is determined by these two fields not being empty.
+			String refCompName; //If a reference, the name of the compositor being referenced
+			String refTexName;	//If a reference, the name of the texture in the compositor being referenced
+            size_t width;       // 0 means adapt to target width
+            size_t height;      // 0 means adapt to target height
+			float widthFactor;  // multiple of target width to use (if width = 0)
+			float heightFactor; // multiple of target height to use (if height = 0)
+            PixelFormatList formatList; // more than one means MRT
+			bool fsaa;			// FSAA enabled; true = determine from main target (if render_scene), false = disable
+			bool hwGammaWrite;	// Do sRGB gamma correction on write (only 8-bit per channel formats) 
+			uint16 depthBufferId;//Depth Buffer's pool ID. (unrelated to "pool" variable below)
+			bool pooled;		// whether to use pooled textures for this one
+            TextureScope scope; // Which scope has access to this texture
+
+			TextureDefinition() :width(0), height(0), widthFactor(1.0f), heightFactor(1.0f), 
+				fsaa(true), hwGammaWrite(false), depthBufferId(1), pooled(false), scope(TS_LOCAL) {}
+        };
+        /// Typedefs for several iterators
+        typedef vector<CompositionTargetPass *>::type TargetPasses;
+        typedef VectorIterator<TargetPasses> TargetPassIterator;
+        typedef vector<TextureDefinition*>::type TextureDefinitions;
+        typedef VectorIterator<TextureDefinitions> TextureDefinitionIterator;
+        
+        /** Create a new local texture definition, and return a pointer to it.
+            @param name     Name of the local texture
+        */
+        TextureDefinition *createTextureDefinition(const String &name);
+        
+        /** Remove and destroy a local texture definition.
+        */
+        void removeTextureDefinition(size_t idx);
+        
+        /** Get a local texture definition.
+        */
+        TextureDefinition *getTextureDefinition(size_t idx);
+        
+		/** Get a local texture definition with a specific name.
+		*/
+		TextureDefinition *getTextureDefinition(const String& name);
+
+		/** Get the number of local texture definitions.
+        */
+        size_t getNumTextureDefinitions();
+        
+        /** Remove all Texture Definitions
+        */
+        void removeAllTextureDefinitions();
+        
+        /** Get an iterator over the TextureDefinitions in this Technique. */
+        TextureDefinitionIterator getTextureDefinitionIterator(void);
+        
+        /** Create a new target pass, and return a pointer to it.
+        */
+        CompositionTargetPass *createTargetPass();
+        
+        /** Remove a target pass. It will also be destroyed.
+        */
+        void removeTargetPass(size_t idx);
+        
+        /** Get a target pass.
+        */
+        CompositionTargetPass *getTargetPass(size_t idx);
+        
+        /** Get the number of target passes.
+        */
+        size_t getNumTargetPasses();
+        
+        /** Remove all target passes.
+        */
+        void removeAllTargetPasses();
+        
+        /** Get an iterator over the TargetPasses in this Technique. */
+        TargetPassIterator getTargetPassIterator(void);
+        
+        /** Get output (final) target pass
+         */
+        CompositionTargetPass *getOutputTargetPass();
+        
+        /** Determine if this technique is supported on the current rendering device. 
+		@param allowTextureDegradation True to accept a reduction in texture depth
+         */
+        virtual bool isSupported(bool allowTextureDegradation);
+        
+		/** Assign a scheme name to this technique, used to switch between 
+			multiple techniques by choice rather than for hardware compatibility.
+		*/
+		virtual void setSchemeName(const String& schemeName);
+		/** Get the scheme name assigned to this technique. */
+		const String& getSchemeName() const { return mSchemeName; }
+        
+		/** Set the name of the compositor logic assigned to this technique.
+			Instances of this technique will be auto-coupled with the matching logic.
+		*/
+		void setCompositorLogicName(const String& compositorLogicName) 
+			{ mCompositorLogicName = compositorLogicName; }
+		/** Get the compositor logic name assigned to this technique */
+		const String& getCompositorLogicName() const { return mCompositorLogicName; }
+
+        /** Get parent object */
+        Compositor *getParent();
+    private:
+        /// Parent compositor
+        Compositor *mParent;
+        /// Local texture definitions
+        TextureDefinitions mTextureDefinitions;
+        
+        /// Intermediate target passes
+        TargetPasses mTargetPasses;
+        /// Output target pass (can be only one)
+        CompositionTargetPass *mOutputTarget;  
+
+		/// Optional scheme name
+		String mSchemeName;
+		
+		/// Optional compositor logic name
+		String mCompositorLogicName;
+
+    };
+	/** @} */
+	/** @} */
+
+}
+
+#endif

data/deps/include/OGRE/OgreCompositor.h

@@ -0,0 +1,235 @@
+/*
+-----------------------------------------------------------------------------
+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 __Compositor_H__
+#define __Compositor_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreIteratorWrappers.h"
+#include "OgreResource.h"
+#include "OgreTexture.h"
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Effects
+	*  @{
+	*/
+	/** Class representing a Compositor object. Compositors provide the means 
+        to flexibly "composite" the final rendering result from multiple scene renders
+        and intermediate operations like rendering fullscreen quads. This makes 
+        it possible to apply postfilter effects, HDRI postprocessing, and shadow 
+        effects to a Viewport.
+     */
+    class _OgreExport Compositor: public Resource
+    {
+    public:
+        Compositor(ResourceManager* creator, const String& name, ResourceHandle handle,
+            const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
+        ~Compositor();
+        
+        /// Data types for internal lists
+        typedef vector<CompositionTechnique *>::type Techniques;
+        typedef VectorIterator<Techniques> TechniqueIterator;
+        
+        /** Create a new technique, and return a pointer to it.
+        */
+        CompositionTechnique *createTechnique();
+        
+        /** Remove a technique. It will also be destroyed.
+        */
+        void removeTechnique(size_t idx);
+        
+        /** Get a technique.
+        */
+        CompositionTechnique *getTechnique(size_t idx);
+        
+        /** Get the number of techniques.
+        */
+        size_t getNumTechniques();
+        
+        /** Remove all techniques
+        */
+        void removeAllTechniques();
+        
+        /** Get an iterator over the Techniques in this compositor. */
+        TechniqueIterator getTechniqueIterator(void);
+        
+        /** Get a supported technique.
+        @remarks
+            The supported technique list is only available after this compositor has been compiled,
+            which typically happens on loading it. Therefore, if this method returns
+            an empty list, try calling Compositor::load.
+        */
+        CompositionTechnique *getSupportedTechnique(size_t idx);
+        
+        /** Get the number of supported techniques.
+        @remarks
+            The supported technique list is only available after this compositor has been compiled,
+            which typically happens on loading it. Therefore, if this method returns
+            an empty list, try calling Compositor::load.
+        */
+        size_t getNumSupportedTechniques();
+        
+        /** Gets an iterator over all the Techniques which are supported by the current card. 
+        @remarks
+            The supported technique list is only available after this compositor has been compiled,
+            which typically happens on loading it. Therefore, if this method returns
+            an empty list, try calling Compositor::load.
+        */
+        TechniqueIterator getSupportedTechniqueIterator(void);
+
+		/** Get a pointer to a supported technique for a given scheme. 
+		@remarks
+			If there is no specific supported technique with this scheme name, 
+			then the first supported technique with no specific scheme will be returned.
+		@param schemeName The scheme name you are looking for. Blank means to 
+			look for techniques with no scheme associated
+		*/
+		CompositionTechnique *getSupportedTechnique(const String& schemeName = StringUtil::BLANK);
+
+		/** Get the instance name for a global texture.
+		@param name The name of the texture in the original compositor definition
+		@param mrtIndex If name identifies a MRT, which texture attachment to retrieve
+		@return The instance name for the texture, corresponds to a real texture
+		*/
+		const String& getTextureInstanceName(const String& name, size_t mrtIndex);
+
+		/** Get the instance of a global texture.
+		@param name The name of the texture in the original compositor definition
+		@param mrtIndex If name identifies a MRT, which texture attachment to retrieve
+		@return The texture pointer, corresponds to a real texture
+		*/
+		TexturePtr getTextureInstance(const String& name, size_t mrtIndex);
+
+		/** Get the render target for a given render texture name. 
+		@remarks
+			You can use this to add listeners etc, but do not use it to update the
+			targets manually or any other modifications, the compositor instance 
+			is in charge of this.
+		*/
+		RenderTarget* getRenderTarget(const String& name);
+
+    protected:
+        /// @copydoc Resource::loadImpl
+        void loadImpl(void);
+
+        /// @copydoc Resource::unloadImpl
+        void unloadImpl(void);
+        /// @copydoc Resource::calculateSize
+        size_t calculateSize(void) const;
+        
+        /** Check supportedness of techniques.
+         */
+        void compile();
+    private:
+        Techniques mTechniques;
+        Techniques mSupportedTechniques;
+        
+        /// Compilation required
+        /// This is set if the techniques change and the supportedness of techniques has to be
+        /// re-evaluated.
+        bool mCompilationRequired;
+
+		/** Create global rendertextures.
+        */
+        void createGlobalTextures();
+        
+        /** Destroy global rendertextures.
+        */
+        void freeGlobalTextures();
+
+		//TODO GSOC : These typedefs are duplicated from CompositorInstance. Solve?
+		/// Map from name->local texture
+        typedef map<String,TexturePtr>::type GlobalTextureMap;
+        GlobalTextureMap mGlobalTextures;
+		/// Store a list of MRTs we've created
+		typedef map<String,MultiRenderTarget*>::type GlobalMRTMap;
+		GlobalMRTMap mGlobalMRTs;
+    };
+
+    /** Specialisation of SharedPtr to allow SharedPtr to be assigned to CompositorPtr 
+    @note Has to be a subclass since we need operator=.
+    We could templatise this instead of repeating per Resource subclass, 
+    except to do so requires a form VC6 does not support i.e.
+    ResourceSubclassPtr<T> : public SharedPtr<T>
+    */
+    class _OgreExport CompositorPtr : public SharedPtr<Compositor> 
+    {
+    public:
+        CompositorPtr() : SharedPtr<Compositor>() {}
+        explicit CompositorPtr(Compositor* rep) : SharedPtr<Compositor>(rep) {}
+        CompositorPtr(const CompositorPtr& r) : SharedPtr<Compositor>(r) {} 
+        CompositorPtr(const ResourcePtr& r) : SharedPtr<Compositor>()
+        {
+            // lock & copy other mutex pointer
+            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
+            {
+                OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
+                OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
+                pRep = static_cast<Compositor*>(r.getPointer());
+                pUseCount = r.useCountPointer();
+                if (pUseCount)
+                {
+                    ++(*pUseCount);
+                }
+            }
+        }
+
+        /// Operator used to convert a ResourcePtr to a CompositorPtr
+        CompositorPtr& operator=(const ResourcePtr& r)
+        {
+            if (pRep == static_cast<Compositor*>(r.getPointer()))
+                return *this;
+            release();
+            // lock & copy other mutex pointer
+            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
+            {
+                OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
+                OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
+                pRep = static_cast<Compositor*>(r.getPointer());
+                pUseCount = r.useCountPointer();
+                if (pUseCount)
+                {
+                    ++(*pUseCount);
+                }
+            }
+			else
+			{
+				// RHS must be a null pointer
+				assert(r.isNull() && "RHS must be null if it has no mutex!");
+				setNull();
+			}
+            return *this;
+        }
+    };
+	/** @} */
+	/** @} */
+}
+
+#endif

data/deps/include/OGRE/OgreCompositorChain.h

@@ -0,0 +1,241 @@
+/*
+-----------------------------------------------------------------------------
+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 __CompositorChain_H__
+#define __CompositorChain_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreRenderTargetListener.h"
+#include "OgreRenderQueueListener.h"
+#include "OgreCompositorInstance.h"
+#include "OgreCompositor.h"
+#include "OgreViewport.h"
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Effects
+	*  @{
+	*/
+	/** Chain of compositor effects applying to one viewport.
+     */
+	class _OgreExport CompositorChain : public RenderTargetListener, public Viewport::Listener, public CompositorInstAlloc
+	{
+	public:
+        CompositorChain(Viewport *vp);
+        /** Another gcc warning here, which is no problem because RenderTargetListener is never used
+            to delete an object.
+            warning: `class Ogre::CompositorChain' has virtual functions but non-virtual destructor
+        */
+        virtual ~CompositorChain();
+        
+        /// Data types
+        typedef vector<CompositorInstance*>::type Instances;
+        typedef VectorIterator<Instances> InstanceIterator;
+        
+        /// Identifier for "last" compositor in chain
+        static const size_t LAST = (size_t)-1;
+        /// Identifier for best technique
+        static const size_t BEST = 0;
+        
+        /** Apply a compositor. Initially, the filter is enabled.
+        @param filter     Filter to apply
+        @param addPosition    Position in filter chain to insert this filter at; defaults to the end (last applied filter)
+        @param scheme      Scheme to use (blank means default)
+        */
+		CompositorInstance* addCompositor(CompositorPtr filter, size_t addPosition=LAST, const String& scheme = StringUtil::BLANK);
+
+        /** Remove a compositor.
+        @param position    Position in filter chain of filter to remove; defaults to the end (last applied filter)
+        */
+        void removeCompositor(size_t position=LAST);
+        
+        /** Get the number of compositors.
+        */
+        size_t getNumCompositors();
+        
+        /** Remove all compositors.
+        */
+        void removeAllCompositors();
+        
+        /** Get compositor instance by position.
+         */
+        CompositorInstance *getCompositor(size_t index);
+
+		/** Get compositor instance by name. Returns null if not found.
+         */
+        CompositorInstance *getCompositor(const String& name);
+
+		/** Get the original scene compositor instance for this chain (internal use). 
+		*/
+		CompositorInstance* _getOriginalSceneCompositor(void) { return mOriginalScene; }
+
+        /** Get an iterator over the compositor instances. The first compositor in this list is applied first, the last one is applied last.
+        */
+        InstanceIterator getCompositors();
+    
+        /** Enable or disable a compositor, by position. Disabling a compositor stops it from rendering
+            but does not free any resources. This can be more efficient than using removeCompositor and 
+			addCompositor in cases the filter is switched on and off a lot.
+        @param position    Position in filter chain of filter
+        */
+        void setCompositorEnabled(size_t position, bool state);
+
+        /** @see RenderTargetListener::preRenderTargetUpdate */
+		virtual void preRenderTargetUpdate(const RenderTargetEvent& evt);
+		/** @see RenderTargetListener::postRenderTargetUpdate */
+		virtual void postRenderTargetUpdate(const RenderTargetEvent& evt);
+		/** @see RenderTargetListener::preViewportUpdate */
+        virtual void preViewportUpdate(const RenderTargetViewportEvent& evt);
+        /** @see RenderTargetListener::postViewportUpdate */
+        virtual void postViewportUpdate(const RenderTargetViewportEvent& evt);
+
+		/** @see Viewport::Listener::viewportCameraChanged */
+		virtual void viewportCameraChanged(Viewport* viewport);
+		/** @see Viewport::Listener::viewportDimensionsChanged */
+		virtual void viewportDimensionsChanged(Viewport* viewport);
+		/** @see Viewport::Listener::viewportDestroyed */
+		virtual void viewportDestroyed(Viewport* viewport);
+
+        /** Mark state as dirty, and to be recompiled next frame.
+         */
+        void _markDirty();
+        
+        /** Get viewport that is the target of this chain
+         */
+        Viewport *getViewport();
+
+		/** Remove a compositor by pointer. This is internally used by CompositionTechnique to
+			"weak" remove any instanced of a deleted technique.
+        */
+        void _removeInstance(CompositorInstance *i);
+
+		/** Internal method for registering a queued operation for deletion later **/
+		void _queuedOperation(CompositorInstance::RenderSystemOperation* op);
+
+		/** Compile this Composition chain into a series of RenderTarget operations.
+		*/
+		void _compile();
+
+		/** Get the previous instance in this chain to the one specified. 
+		*/
+		CompositorInstance* getPreviousInstance(CompositorInstance* curr, bool activeOnly = true);
+		/** Get the next instance in this chain to the one specified. 
+		*/
+		CompositorInstance* getNextInstance(CompositorInstance* curr, bool activeOnly = true);
+
+	protected:
+        /// Viewport affected by this CompositorChain
+        Viewport *mViewport;
+        
+        /** Plainly renders the scene; implicit first compositor in the chain.
+        */
+        CompositorInstance *mOriginalScene;
+        
+        /// Postfilter instances in this chain
+        Instances mInstances;
+        
+        /// State needs recompile
+        bool mDirty;
+		/// Any compositors enabled?
+		bool mAnyCompositorsEnabled;
+
+		String mOriginalSceneScheme;
+
+        /// Compiled state (updated with _compile)
+        CompositorInstance::CompiledState mCompiledState;
+        CompositorInstance::TargetOperation mOutputOperation;
+		/// Render System operations queued by last compile, these are created by this
+		/// instance thus managed and deleted by it. The list is cleared with 
+		/// clearCompilationState()
+		typedef vector<CompositorInstance::RenderSystemOperation*>::type RenderSystemOperations;
+		RenderSystemOperations mRenderSystemOperations;
+
+		/** Clear compiled state */
+		void clearCompiledState();
+        
+        /** Prepare a viewport, the camera and the scene for a rendering operation
+         */
+        void preTargetOperation(CompositorInstance::TargetOperation &op, Viewport *vp, Camera *cam);
+        
+        /** Restore a viewport, the camera and the scene after a rendering operation
+         */
+        void postTargetOperation(CompositorInstance::TargetOperation &op, Viewport *vp, Camera *cam);
+
+		void createOriginalScene();
+		void destroyOriginalScene();
+
+		/// destroy internal resources
+		void destroyResources(void);
+
+		/** Render queue listener used to set up rendering events. */
+		class _OgreExport RQListener: public RenderQueueListener
+		{
+		public:
+			/** @copydoc RenderQueueListener::renderQueueStarted
+			*/
+			virtual void renderQueueStarted(uint8 id, const String& invocation, bool& skipThisQueue);
+			/** @copydoc RenderQueueListener::renderQueueEnded
+			*/
+			virtual void renderQueueEnded(uint8 id, const String& invocation, bool& repeatThisQueue);
+
+			/** Set current operation and target */
+			void setOperation(CompositorInstance::TargetOperation *op,SceneManager *sm,RenderSystem *rs);
+
+			/** Notify current destination viewport  */
+			void notifyViewport(Viewport* vp) { mViewport = vp; }
+
+			/** Flush remaining render system operations */
+			void flushUpTo(uint8 id);
+		private:
+			CompositorInstance::TargetOperation *mOperation;
+			SceneManager *mSceneManager;
+			RenderSystem *mRenderSystem;
+			Viewport* mViewport;
+			CompositorInstance::RenderSystemOpPairs::iterator currentOp, lastOp;
+		};
+		RQListener mOurListener;
+		/// Old viewport settings
+		unsigned int mOldClearEveryFrameBuffers;
+		/// Store old scene visibility mask
+		uint32 mOldVisibilityMask;
+		/// Store old find visible objects
+		bool mOldFindVisibleObjects;
+		/// Store old camera LOD bias
+		float mOldLodBias;
+		///	Store old viewport material scheme
+		String mOldMaterialScheme;
+		/// Store old shadows enabled flag
+		bool mOldShadowsEnabled;
+
+    };
+	/** @} */
+	/** @} */
+}
+
+#endif