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

data/deps/include/OGRE/OgreCompositorInstance.h

@@ -1,373 +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 __CompositorInstance_H__
-#define __CompositorInstance_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreMaterialManager.h"
-#include "OgreTexture.h"
-#include "OgreRenderQueue.h"
-#include "OgreCompositionTechnique.h"
-
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Effects
-	*  @{
-	*/
-	const size_t RENDER_QUEUE_COUNT = RENDER_QUEUE_MAX+1;       
-            
-    /** An instance of a Compositor object for one Viewport. It is part of the CompositorChain
-		for a Viewport.
-     */
-	class _OgreExport CompositorInstance : public CompositorInstAlloc
-    {
-    public:
-        CompositorInstance(CompositionTechnique *technique, CompositorChain *chain);
-        virtual ~CompositorInstance();
-		/** Provides an interface to "listen in" to to render system operations executed by this 
-			CompositorInstance.
-		*/
-		class _OgreExport Listener
-		{
-		public:
-			virtual ~Listener();
-
-			/** Notification of when a render target operation involving a material (like
-				rendering a quad) is compiled, so that miscellaneous parameters that are different
-				per Compositor instance can be set up.
-				@param pass_id	Pass identifier within Compositor instance, this is specified 
-								by the user by CompositionPass::setIdentifier().
-				@param mat		Material, this may be changed at will and will only affect
-								the current instance of the Compositor, not the global material
-								it was cloned from.
-			 */
-			virtual void notifyMaterialSetup(uint32 pass_id, MaterialPtr &mat);
-
-			/** Notification before a render target operation involving a material (like
-				rendering a quad), so that material parameters can be varied.
-				@param pass_id	Pass identifier within Compositor instance, this is specified 
-								by the user by CompositionPass::setIdentifier().
-				@param mat		Material, this may be changed at will and will only affect
-								the current instance of the Compositor, not the global material
-								it was cloned from.
-			 */
-			virtual void notifyMaterialRender(uint32 pass_id, MaterialPtr &mat);
-
-			/** Notification after resources have been created (or recreated).
-				@param resizeOnly Was the creation because the viewport was resized?
-			 */
-			virtual void notifyResourcesCreated(bool forResizeOnly);
-			
-		};
-        /** Specific render system operation. A render target operation does special operations
-		    between render queues like rendering a quad, clearing the frame buffer or 
-			setting stencil state.
-		*/
-		class _OgreExport RenderSystemOperation : public CompositorInstAlloc
-		{
-		public:
-			virtual ~RenderSystemOperation();
-			/// Set state to SceneManager and RenderSystem
-			virtual void execute(SceneManager *sm, RenderSystem *rs) = 0;
-		};
-		typedef map<int, MaterialPtr>::type QuadMaterialMap;
-		typedef std::pair<int, RenderSystemOperation*> RenderSystemOpPair;
-		typedef vector<RenderSystemOpPair>::type RenderSystemOpPairs;
-        /** Operation setup for a RenderTarget (collected).
-        */
-        class TargetOperation
-        {
-        public:
-            TargetOperation()
-            { 
-            }
-            TargetOperation(RenderTarget *inTarget):
-                target(inTarget), currentQueueGroupID(0), visibilityMask(0xFFFFFFFF),
-                lodBias(1.0f),
-                onlyInitial(false), hasBeenRendered(false), findVisibleObjects(false), 
-				materialScheme(MaterialManager::DEFAULT_SCHEME_NAME), shadowsEnabled(true)
-            { 
-            }
-            /// Target
-            RenderTarget *target;
-
-			/// Current group ID
-			int currentQueueGroupID;
-
-			/// RenderSystem operations to queue into the scene manager, by
-			/// uint8
-			RenderSystemOpPairs renderSystemOperations;
-
-			/// Scene visibility mask
-            /// If this is 0, the scene is not rendered at all
-            uint32 visibilityMask;
-            
-            /// LOD offset. This is multiplied with the camera LOD offset
-            /// 1.0 is default, lower means lower detail, higher means higher detail
-            float lodBias;
-            
-            /** A set of render queues to either include or exclude certain render queues.
-	 		*/
-            typedef std::bitset<RENDER_QUEUE_COUNT> RenderQueueBitSet;
-
-			/// Which renderqueues to render from scene
-			RenderQueueBitSet renderQueues;
-            
-            /** @see CompositionTargetPass::mOnlyInitial
-            */
-            bool onlyInitial;
-            /** "Has been rendered" flag; used in combination with
-                onlyInitial to determine whether to skip this target operation.
-            */
-            bool hasBeenRendered;
-            /** Whether this op needs to find visible scene objects or not 
-            */
-            bool findVisibleObjects;
-			/** Which material scheme this op will use */
-			String materialScheme;
-			/** Whether shadows will be enabled */
-			bool shadowsEnabled;
-        };
-        typedef vector<TargetOperation>::type CompiledState;
-        
-        /** Set enabled flag. The compositor instance will only render if it is
-            enabled, otherwise it is pass-through. Resources are only created if
-			they weren't alive when enabling.
-        */
-        void setEnabled(bool value);
-        
-        /** Get enabled flag.
-        */
-		bool getEnabled() const { return mEnabled; }
-
-		/** Set alive/active flag. The compositor instance will create resources when alive,
-			and destroy them when inactive.
-			@remarks: Killing an instance means also disabling it: setAlive(false) implies
-			setEnabled(false)
-        */
-        void setAlive(bool value);
-
-        /** Get alive flag.
-        */
-		bool getAlive() const { return mAlive; }
-
-		/** Get the instance name for a local texture.
-		@note It is only valid to call this when local textures have been loaded, 
-			which in practice means that the compositor instance is active. Calling
-			it at other times will cause an exception. Note that since textures
-			are cleaned up aggressively, this name is not guaranteed to stay the
-			same if you disable and re-enable the compositor instance.
-		@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 local texture.
-		@note Textures are only valid when local textures have been loaded, 
-			which in practice means that the compositor instance is active. Calling
-			this method at other times will return null pointers. Note that since textures
-			are cleaned up aggressively, this pointer is not guaranteed to stay the
-			same if you disable and re-enable the compositor instance.
-		@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);
-
-       
-        /** Recursively collect target states (except for final Pass).
-            @param compiledState    This vector will contain a list of TargetOperation objects
-        */
-        virtual void _compileTargetOperations(CompiledState &compiledState);
-        
-        /** Compile the final (output) operation. This is done separately because this
-            is combined with the input in chained filters.
-        */
-        virtual void _compileOutputOperation(TargetOperation &finalState);
-        
-        /** Get Compositor of which this is an instance
-        */
-        Compositor *getCompositor();
-        
-        /** Get CompositionTechnique used by this instance
-        */
-        CompositionTechnique *getTechnique();
-
-		/** Change the technique we're using to render this compositor. 
-		@param tech The technique to use (must be supported and from the same Compositor)
-		@param reuseTextures If textures have already been created for the current
-			technique, whether to try to re-use them if sizes & formats match.
-		*/
-		void setTechnique(CompositionTechnique* tech, bool reuseTextures = true);
-
-		/** Pick a technique to use to render this compositor based on a scheme. 
-		@remarks
-			If there is no specific supported technique with this scheme name, 
-			then the first supported technique with no specific scheme will be used.
-			@see CompositionTechnique::setSchemeName
-		@param schemeName The scheme to use 
-		@param reuseTextures If textures have already been created for the current
-			technique, whether to try to re-use them if sizes & formats match.
-			Note that for this feature to be of benefit, the textures must have been created
-			with the 'pooled' option enabled.
-		*/
-		void setScheme(const String& schemeName, bool reuseTextures = true);
-
-		/// Returns the name of the scheme this compositor is using
-		const String& getScheme() const { return mTechnique ? mTechnique->getSchemeName() : StringUtil::BLANK; }
-
-		/** Notify this instance that the primary surface has been resized. 
-		@remarks
-			This will allow the instance to recreate its resources that 
-			are dependent on the size. 
-		*/
-		void notifyResized();
-
-		/** Get Chain that this instance is part of
-        */
-        CompositorChain *getChain();
-
-		/** Add a listener. Listeners provide an interface to "listen in" to to render system 
-			operations executed by this CompositorInstance so that materials can be 
-			programmatically set up.
-			@see CompositorInstance::Listener
-		*/
-		void addListener(Listener *l);
-
-		/** Remove a listener.
-			@see CompositorInstance::Listener
-		*/
-		void removeListener(Listener *l);
-
-		/** Notify listeners of a material compilation.
-		*/
-		void _fireNotifyMaterialSetup(uint32 pass_id, MaterialPtr &mat);
-
-		/** Notify listeners of a material render.
-		*/
-		void _fireNotifyMaterialRender(uint32 pass_id, MaterialPtr &mat);
-
-		/** Notify listeners of a material render.
-		*/
-		void _fireNotifyResourcesCreated(bool forResizeOnly);
-	private:
-        /// Compositor of which this is an instance
-        Compositor *mCompositor;
-        /// Composition technique used by this instance
-        CompositionTechnique *mTechnique;
-        /// Composition chain of which this instance is part
-        CompositorChain *mChain;
-        /// Is this instance enabled?
-        bool mEnabled;
-		/// Is this instance allocating resources?
-        bool mAlive;
-        /// Map from name->local texture
-        typedef map<String,TexturePtr>::type LocalTextureMap;
-        LocalTextureMap mLocalTextures;
-		/// Store a list of MRTs we've created
-		typedef map<String,MultiRenderTarget*>::type LocalMRTMap;
-		LocalMRTMap mLocalMRTs;
-		typedef map<CompositionTechnique::TextureDefinition*, TexturePtr>::type ReserveTextureMap;
-		/** Textures that are not currently in use, but that we want to keep for now,
-			for example if we switch techniques but want to keep all textures available
-			in case we switch back. 
-		*/
-		ReserveTextureMap mReserveTextures;
-
-		/// Vector of listeners
-		typedef vector<Listener*>::type Listeners;
-		Listeners mListeners;
-        
-        /// Previous instance (set by chain)
-        CompositorInstance *mPreviousInstance;
-		
-		/** Collect rendering passes. Here, passes are converted into render target operations
-			and queued with queueRenderSystemOp.
-        */
-        virtual void collectPasses(TargetOperation &finalState, CompositionTargetPass *target);
-        
-        /** Create a local dummy material with one technique but no passes.
-            The material is detached from the Material Manager to make sure it is destroyed
-			when going out of scope.
-        */
-        MaterialPtr createLocalMaterial(const String& srcName);
-        
-        /** Create local rendertextures and other resources. Builds mLocalTextures.
-        */
-        void createResources(bool forResizeOnly);
-        
-        /** Destroy local rendertextures and other resources.
-        */
-        void freeResources(bool forResizeOnly, bool clearReserveTextures);
-
-        /** Get RenderTarget for a named local texture.
-        */
-        RenderTarget *getTargetForTex(const String &name);
-        
-        /** Get source texture name for a named local texture.
-		@param name The local name of the texture as given to it in the compositor
-		@param mrtIndex For MRTs, which attached surface to retrieve
-        */
-        const String &getSourceForTex(const String &name, size_t mrtIndex = 0);
-
-		/** Queue a render system operation.
-			@return destination pass
-		 */
-		void queueRenderSystemOp(TargetOperation &finalState, RenderSystemOperation *op);
-
-		/// Util method for assigning a local texture name to a MRT attachment
-		String getMRTTexLocalName(const String& baseName, size_t attachment);
-
-		/** Search for options like AA and hardware gamma which we may want to 
-			inherit from the main render target to which we're attached. 
-		*/
-		void deriveTextureRenderTargetOptions(const String& texname, 
-			bool *hwGammaWrite, uint *fsaa, String* fsaaHint);
-
-		/// Notify this instance that the primary viewport's camera has changed.
-		void notifyCameraChanged(Camera* camera);
-
-        friend class CompositorChain;
-    };
-	/** @} */
-	/** @} */
-
-}
-
-#endif

data/deps/include/OGRE/OgreCompositorLogic.h

@@ -1,68 +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 __CompositorLogic_H__
-#define __CompositorLogic_H__
-
-#include "OgrePrerequisites.h"
-
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Effects
-	*  @{
-	*/
-	/** Interface for compositor logics, which can be automatically binded to compositors,
-	*	allowing per-compositor logic (such as attaching a relevant listener) to happen
-	*	automatically.
-	*	@remarks All methods have empty implementations to not force an implementer into
-	*		extending all of them.
-    */
-    class _OgreExport CompositorLogic
-    {
-	public:
-		/** Called when a compositor instance has been created.
-			@remarks
-			This happens after its setup was finished, so the chain is also accessible.
-			This is an ideal method to automatically attach a compositor listener.
-        */
-		virtual void compositorInstanceCreated(CompositorInstance* newInstance) {}
-
-		/** Called when a compositor instance has been destroyed
-			@remarks
-			The chain that contained the compositor is still alive during this call.
-        */
-		virtual void compositorInstanceDestroyed(CompositorInstance* destroyedInstance) {}
-
-		virtual ~CompositorLogic() {}
-	};
-	/** @} */
-	/** @} */
-}
-
-#endif

data/deps/include/OGRE/OgreCompositorManager.h

@@ -1,291 +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 __CompositorManager_H__
-#define __CompositorManager_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreResourceManager.h"
-#include "OgreCompositor.h"
-#include "OgreRectangle2D.h"
-#include "OgreRenderSystem.h"
-#include "OgreCompositionTechnique.h"
-
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Effects
-	*  @{
-	*/
-	/** Class for managing Compositor settings for Ogre. 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.
-        @par
-            When loaded from a script, a Compositor is in an 'unloaded' state and only stores the settings
-            required. It does not at that stage load any textures. This is because the material settings may be
-            loaded 'en masse' from bulk material script files, but only a subset will actually be required.
-        @par
-            Because this is a subclass of ResourceManager, any files loaded will be searched for in any path or
-            archive added to the resource paths/archives. See ResourceManager for details.
-    */
-    class _OgreExport CompositorManager : public ResourceManager, public Singleton<CompositorManager>
-    {
-    public:
-        CompositorManager();
-        virtual ~CompositorManager();
-
-        /// Overridden from ResourceManager
-        Resource* createImpl(const String& name, ResourceHandle handle,
-            const String& group, bool isManual, ManualResourceLoader* loader,
-            const NameValuePairList* params);
-
-        /** Initialises the Compositor manager, which also triggers it to
-            parse all available .compositor scripts. */
-        void initialise(void);
-
-        /** @see ScriptLoader::parseScript
-        */
-        void parseScript(DataStreamPtr& stream, const String& groupName);
-
-        /** Get the compositor chain for a Viewport. If there is none yet, a new
-			compositor chain is registered.
-			XXX We need a _notifyViewportRemoved to find out when this viewport disappears,
-			so we can destroy its chain as well.
-        */
-        CompositorChain *getCompositorChain(Viewport *vp);
-
-		/** Returns whether exists compositor chain for a viewport.
-        */
-		bool hasCompositorChain(Viewport *vp) const;
-
-		/** Remove the compositor chain from a viewport if exists.
-		*/
-        void removeCompositorChain(Viewport *vp);
-
-		/** Add a compositor to a viewport. By default, it is added to end of the chain,
-			after the other compositors.
-			@param vp			Viewport to modify
-			@param compositor	The name of the compositor to apply
-			@param addPosition	At which position to add, defaults to the end (-1).
-			@return pointer to instance, or 0 if it failed.
-		*/
-		CompositorInstance *addCompositor(Viewport *vp, const String &compositor, int addPosition=-1);
-
-		/** Remove a compositor from a viewport
-		*/
-		void removeCompositor(Viewport *vp, const String &compositor);
-
-		/** Set the state of a compositor on a viewport to enabled or disabled.
-			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.
-		*/
-		void setCompositorEnabled(Viewport *vp, const String &compositor, bool value);
-
-		/** Get a textured fullscreen 2D rectangle, for internal use.
-		*/
-		Renderable *_getTexturedRectangle2D();
-
-		/** Overridden from ResourceManager since we have to clean up chains too. */
-		void removeAll(void);
-
-		/** Internal method for forcing all active compositors to recreate their resources. */
-		void _reconstructAllCompositorResources();
-
-		typedef set<Texture*>::type UniqueTextureSet;
-
-		/** Utility function to get an existing pooled texture matching a given
-			definition, or creating one if one doesn't exist. It also takes into
-			account whether a pooled texture has already been supplied to this
-			same requester already, in which case it won't give the same texture
-			twice (this is important for example if you request 2 ping-pong textures, 
-			you don't want to get the same texture for both requests!
-		*/
-		TexturePtr getPooledTexture(const String& name, const String& localName, 
-			size_t w, size_t h, 
-			PixelFormat f, uint aa, const String& aaHint, bool srgb, UniqueTextureSet& texturesAlreadyAssigned, 
-			CompositorInstance* inst, CompositionTechnique::TextureScope scope);
-
-		/** Free pooled textures from the shared pool (compositor instances still 
-			using them will keep them in memory though). 
-		*/
-		void freePooledTextures(bool onlyIfUnreferenced = true);
-
-		/** Register a compositor logic for listening in to expecting composition
-			techniques.
-		*/
-		void registerCompositorLogic(const String& name, CompositorLogic* logic);
-
-		/** Removes a listener for compositor logic registered with registerCompositorLogic
-		*/
-		void unregisterCompositorLogic(const String& name);
-		
-		/** Get a compositor logic by its name
-		*/
-		CompositorLogic* getCompositorLogic(const String& name);
-
-		/** Register a custom composition pass.
-		*/
-		void registerCustomCompositionPass(const String& name, CustomCompositionPass* customPass);
-		
-		/** Get a custom composition pass by its name 
-		*/
-		CustomCompositionPass* getCustomCompositionPass(const String& name);
-
-		/** Override standard Singleton retrieval.
-		@remarks
-		Why do we do this? Well, it's because the Singleton
-		implementation is in a .h file, which means it gets compiled
-		into anybody who includes it. This is needed for the
-		Singleton template to work, but we actually only want it
-		compiled into the implementation of the class based on the
-		Singleton, not all of them. If we don't change this, we get
-		link errors when trying to use the Singleton-based class from
-		an outside dll.
-		@par
-		This method just delegates to the template version anyway,
-		but the implementation stays in this single compilation unit,
-		preventing link errors.
-		*/
-		static CompositorManager& getSingleton(void);
-		/** Override standard Singleton retrieval.
-		@remarks
-		Why do we do this? Well, it's because the Singleton
-		implementation is in a .h file, which means it gets compiled
-		into anybody who includes it. This is needed for the
-		Singleton template to work, but we actually only want it
-		compiled into the implementation of the class based on the
-		Singleton, not all of them. If we don't change this, we get
-		link errors when trying to use the Singleton-based class from
-		an outside dll.
-		@par
-		This method just delegates to the template version anyway,
-		but the implementation stays in this single compilation unit,
-		preventing link errors.
-		*/
-		static CompositorManager* getSingletonPtr(void);
-
-	
-	private:
-        typedef map<Viewport*, CompositorChain*>::type Chains;
-        Chains mChains;
-
-        /** Clear composition chains for all viewports
-         */
-        void freeChains();
-
-		Rectangle2D *mRectangle;
-
-		/// List of instances
-		typedef vector<CompositorInstance *>::type Instances;
-		Instances mInstances;
-
-		/// Map of registered compositor logics
-		typedef map<String, CompositorLogic*>::type CompositorLogicMap;
-		CompositorLogicMap mCompositorLogics;
-
-		/// Map of registered custom composition passes
-		typedef map<String, CustomCompositionPass*>::type CustomCompositionPassMap;
-		CustomCompositionPassMap mCustomCompositionPasses;
-
-		typedef vector<TexturePtr>::type TextureList;
-		typedef VectorIterator<TextureList> TextureIterator;
-
-		struct TextureDef
-		{
-			size_t width, height;
-			PixelFormat format;
-			uint fsaa;
-			String fsaaHint;
-			bool sRGBwrite;
-
-			TextureDef(size_t w, size_t h, PixelFormat f, uint aa, const String& aaHint, bool srgb)
-				: width(w), height(h), format(f), fsaa(aa), fsaaHint(aaHint), sRGBwrite(srgb)
-			{
-
-			}
-		};
-		struct TextureDefLess
-		{
-			bool _OgreExport operator()(const TextureDef& x, const TextureDef& y) const
-			{
-				if (x.format < y.format)
-					return true;
-				else if (x.format == y.format)
-				{
-					if (x.width < y.width)
-						return true;
-					else if (x.width == y.width)
-					{
-						if (x.height < y.height)
-							return true;
-						else if (x.height == y.height)
-						{
-							if (x.fsaa < y.fsaa)
-								return true;
-							else if (x.fsaa == y.fsaa)
-							{
-								if (x.fsaaHint < y.fsaaHint)
-									return true;
-								else if (x.fsaaHint == y.fsaaHint)
-								{
-									if (!x.sRGBwrite && y.sRGBwrite)
-										return true;
-								}
-
-							}
-						}
-					}
-				}
-				return false;
-			}
-			virtual ~TextureDefLess() {}
-		};
-		typedef map<TextureDef, TextureList*, TextureDefLess>::type TexturesByDef;
-		TexturesByDef mTexturesByDef;
-
-		typedef std::pair<String, String> StringPair;
-		typedef map<TextureDef, TexturePtr, TextureDefLess>::type TextureDefMap;
-		typedef std::map<StringPair, TextureDefMap> ChainTexturesByDef;
-		
-		ChainTexturesByDef mChainTexturesByDef;
-
-		bool isInputPreviousTarget(CompositorInstance* inst, const Ogre::String& localName);
-		bool isInputPreviousTarget(CompositorInstance* inst, TexturePtr tex);
-		bool isInputToOutputTarget(CompositorInstance* inst, const Ogre::String& localName);
-		bool isInputToOutputTarget(CompositorInstance* inst, TexturePtr tex);
-
-    };
-	/** @} */
-	/** @} */
-
-}
-
-#endif