ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreTechnique.h

@@ -0,0 +1,714 @@
+/*
+-----------------------------------------------------------------------------
+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 __Technique_H__
+#define __Technique_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreIteratorWrappers.h"
+#include "OgreBlendMode.h"
+#include "OgreCommon.h"
+#include "OgrePass.h"
+#include "OgreIteratorWrappers.h"
+#include "OgreRenderSystemCapabilities.h"
+#include "OgreUserObjectBindings.h"
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Materials
+	*  @{
+	*/
+	/** Class representing an approach to rendering this particular Material. 
+    @remarks
+        Ogre will attempt to use the best technique supported by the active hardware, 
+        unless you specifically request a lower detail technique (say for distant
+        rendering).
+    */
+	class _OgreExport Technique : public TechniqueAlloc
+    {
+    protected:
+        // illumination pass state type
+        enum IlluminationPassesState
+        {
+            IPS_COMPILE_DISABLED = -1,
+            IPS_NOT_COMPILED = 0,
+            IPS_COMPILED = 1
+        };
+
+        typedef vector<Pass*>::type Passes;
+        /// List of primary passes
+        Passes mPasses;
+        /// List of derived passes, categorised into IlluminationStage (ordered)
+        IlluminationPassList mIlluminationPasses;
+        Material* mParent; // raw pointer since we don't want child to stop parent's destruction
+        bool mIsSupported;
+        IlluminationPassesState mIlluminationPassesCompilationPhase;
+		/// LOD level
+        unsigned short mLodIndex;
+		/** Scheme index, derived from scheme name but the names are held on
+			MaterialManager, for speed an index is used here.
+		*/
+		unsigned short mSchemeIndex;
+        String mName; // optional name for the technique
+
+        /// Internal method for clearing illumination pass list
+        void clearIlluminationPasses(void);
+		/// Internal method - check for manually assigned illumination passes
+		bool checkManuallyOrganisedIlluminationPasses();
+
+
+		/** When casting shadow, if not using default Ogre shadow casting material, or 
+		* nor using fixed function casting, mShadowCasterMaterial let you customize per material
+		* shadow caster behavior
+		*/
+		MaterialPtr mShadowCasterMaterial;
+		/** When casting shadow, if not using default Ogre shadow casting material, or 
+		* nor using fixed function casting, mShadowCasterMaterial let you customize per material
+		* shadow caster behavior.There only material name is stored so that it can be loaded once all file parsed in a resource group.
+		*/
+		String mShadowCasterMaterialName;
+		/** When receiving shadow, if not using default Ogre shadow receiving material, or 
+		* nor using fixed function texture projection receiving, mShadowReceiverMaterial let you customize per material
+		* shadow caster behavior
+		*/
+		MaterialPtr mShadowReceiverMaterial;
+		/** When receiving shadow, if not using default Ogre shadow receiving material, or 
+		* nor using fixed function texture projection receiving, mShadowReceiverMaterial let you customize per material
+		* shadow caster behavior. There only material name is stored so that it can be loaded once all file parsed in a resource group.
+		*/
+		String mShadowReceiverMaterialName;	
+
+		// User objects binding.
+		UserObjectBindings	mUserObjectBindings;
+
+	public:
+		/** Directive used to manually control technique support based on the
+			inclusion or exclusion of some factor.
+		*/
+		enum IncludeOrExclude
+		{
+			/// Inclusive - only support if present
+			INCLUDE = 0,
+			/// Exclusive - do not support if present
+			EXCLUDE = 1
+		};
+		/// Rule controlling whether technique is deemed supported based on GPU vendor
+		struct GPUVendorRule
+		{
+			GPUVendor vendor;
+			IncludeOrExclude includeOrExclude;
+			GPUVendorRule()
+				: vendor(GPU_UNKNOWN), includeOrExclude(EXCLUDE) {}
+			GPUVendorRule(GPUVendor v, IncludeOrExclude ie)
+				: vendor(v), includeOrExclude(ie) {}
+		};
+		/// Rule controlling whether technique is deemed supported based on GPU device name
+		struct GPUDeviceNameRule
+		{
+			String devicePattern;
+			IncludeOrExclude includeOrExclude;
+			bool caseSensitive;
+			GPUDeviceNameRule()
+				: includeOrExclude(EXCLUDE), caseSensitive(false) {}
+			GPUDeviceNameRule(const String& pattern, IncludeOrExclude ie, bool caseSen)
+				: devicePattern(pattern), includeOrExclude(ie), caseSensitive(caseSen) {}
+		};
+		typedef vector<GPUVendorRule>::type GPUVendorRuleList;
+		typedef vector<GPUDeviceNameRule>::type GPUDeviceNameRuleList;
+	protected:
+		GPUVendorRuleList mGPUVendorRules;
+		GPUDeviceNameRuleList mGPUDeviceNameRules;
+	public:
+        /// Constructor
+        Technique(Material* parent);
+        /// Copy constructor
+        Technique(Material* parent, const Technique& oth);
+        ~Technique();
+        /** Indicates if this technique is supported by the current graphics card.
+        @remarks
+            This will only be correct after the Technique has been compiled, which is
+            usually done from Material::compile.
+        */
+        bool isSupported(void) const;
+        /** Internal compilation method; see Material::compile. 
+		@return Any information explaining problems with the compile.
+		*/
+        String _compile(bool autoManageTextureUnits);
+		/// Internal method for checking GPU vendor / device rules
+		bool checkGPURules(StringUtil::StrStreamType& errors);
+		/// Internal method for checking hardware support
+		bool checkHardwareSupport(bool autoManageTextureUnits, StringUtil::StrStreamType& compileErrors);
+        /** Internal method for splitting the passes into illumination passes. */        
+        void _compileIlluminationPasses(void);
+
+
+        /** Creates a new Pass for this Technique.
+        @remarks
+            A Pass is a single rendering pass, i.e. a single draw of the given material.
+            Note that if you create a pass without a fragment program, during compilation of the
+            material the pass may be split into multiple passes if the graphics card cannot
+            handle the number of texture units requested. For passes with fragment programs, however, 
+            the number of passes you create will never be altered, so you have to make sure 
+            that you create an alternative fallback Technique for if a card does not have 
+            enough facilities for what you're asking for.
+        */
+        Pass* createPass(void);
+        /** Retrieves the Pass with the given index. */
+        Pass* getPass(unsigned short index);
+        /** Retrieves the Pass matching name.
+            Returns 0 if name match is not found.
+        */
+        Pass* getPass(const String& name);
+        /** Retrieves the number of passes. */
+        unsigned short getNumPasses(void) const;
+        /** Removes the Pass with the given index. */
+        void removePass(unsigned short index);
+        /** Removes all Passes from this Technique. */
+        void removeAllPasses(void);
+        /** Move a pass from source index to destination index.
+            If successful then returns true.
+        */
+        bool movePass(const unsigned short sourceIndex, const unsigned short destinationIndex);
+        typedef VectorIterator<Passes> PassIterator;
+        /** Gets an iterator over the passes in this Technique. */
+        const PassIterator getPassIterator(void);
+        typedef VectorIterator<IlluminationPassList> IlluminationPassIterator;
+        /** Gets an iterator over the illumination-stage categorised passes. */
+        const IlluminationPassIterator getIlluminationPassIterator(void);
+        /// Gets the parent Material
+        Material* getParent(void) const { return mParent; }
+
+        /** Overloaded operator to copy on Technique to another. */
+        Technique& operator=(const Technique& rhs);
+
+		/// Gets the resource group of the ultimate parent Material
+		const String& getResourceGroup(void) const;
+
+		/** Returns true if this Technique involves transparency. 
+		@remarks
+			This basically boils down to whether the first pass
+			has a scene blending factor. Even if the other passes 
+			do not, the base colour, including parts of the original 
+			scene, may be used for blending, therefore we have to treat
+			the whole Technique as transparent.
+		*/
+		bool isTransparent(void) const;
+
+		/** Returns true if this Technique has transparent sorting enabled. 
+		@remarks
+			This basically boils down to whether the first pass
+			has transparent sorting enabled or not
+		*/
+		bool isTransparentSortingEnabled(void) const;
+
+		/** Returns true if this Technique has transparent sorting forced. 
+		@remarks
+			This basically boils down to whether the first pass
+			has transparent sorting forced or not
+		*/
+		bool isTransparentSortingForced(void) const;
+
+        /** Internal prepare method, derived from call to Material::prepare. */
+        void _prepare(void);
+        /** Internal unprepare method, derived from call to Material::unprepare. */
+        void _unprepare(void);
+        /** Internal load method, derived from call to Material::load. */
+        void _load(void);
+        /** Internal unload method, derived from call to Material::unload. */
+        void _unload(void);
+
+        // Is this loaded?
+        bool isLoaded(void) const;
+
+        /** Tells the technique that it needs recompilation. */
+        void _notifyNeedsRecompile(void);
+
+		/** return this material specific  shadow casting specific material
+		*/
+		Ogre::MaterialPtr getShadowCasterMaterial() const;
+		/** set this material specific  shadow casting specific material
+		*/
+		void setShadowCasterMaterial(Ogre::MaterialPtr val);
+		/** set this material specific  shadow casting specific material
+		*/
+		void setShadowCasterMaterial(const Ogre::String &name);
+		/** return this material specific shadow receiving specific material
+		*/
+		Ogre::MaterialPtr getShadowReceiverMaterial() const;
+		/** set this material specific  shadow receiving specific material
+		*/
+		void setShadowReceiverMaterial(Ogre::MaterialPtr val);
+		/** set this material specific  shadow receiving specific material
+		*/
+		void setShadowReceiverMaterial(const Ogre::String &name);
+
+        // -------------------------------------------------------------------------------
+        // The following methods are to make migration from previous versions simpler
+        // and to make code easier to write when dealing with simple materials
+        // They set the properties which have been moved to Pass for all Techniques and all Passes
+
+        /** Sets the point size properties for every Pass in this Technique.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setPointSize
+        */
+        void setPointSize(Real ps);
+
+        /** Sets the ambient colour reflectance properties for every Pass in every Technique.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setAmbient
+        */
+        void setAmbient(Real red, Real green, Real blue);
+
+        /** Sets the ambient colour reflectance properties for every Pass in every Technique.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setAmbient
+        */
+        void setAmbient(const ColourValue& ambient);
+
+        /** Sets the diffuse colour reflectance properties of every Pass in every Technique.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setDiffuse
+        */
+        void setDiffuse(Real red, Real green, Real blue, Real alpha);
+
+        /** Sets the diffuse colour reflectance properties of every Pass in every Technique.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setDiffuse
+        */
+        void setDiffuse(const ColourValue& diffuse);
+
+        /** Sets the specular colour reflectance properties of every Pass in every Technique.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setSpecular
+        */
+        void setSpecular(Real red, Real green, Real blue, Real alpha);
+
+        /** Sets the specular colour reflectance properties of every Pass in every Technique.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setSpecular
+        */
+        void setSpecular(const ColourValue& specular);
+
+        /** Sets the shininess properties of every Pass in every Technique.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setShininess
+        */
+        void setShininess(Real val);
+
+        /** Sets the amount of self-illumination of every Pass in every Technique.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setSelfIllumination
+        */
+        void setSelfIllumination(Real red, Real green, Real blue);
+
+        /** Sets the amount of self-illumination of every Pass in every Technique.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setSelfIllumination
+        */
+        void setSelfIllumination(const ColourValue& selfIllum);
+
+		/** Sets whether or not each Pass renders with depth-buffer checking on or not.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setDepthCheckEnabled
+        */
+        void setDepthCheckEnabled(bool enabled);
+
+        /** Sets whether or not each Pass renders with depth-buffer writing on or not.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setDepthWriteEnabled
+        */
+        void setDepthWriteEnabled(bool enabled);
+
+        /** Sets the function used to compare depth values when depth checking is on.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setDepthFunction
+        */
+        void setDepthFunction( CompareFunction func );
+
+		/** Sets whether or not colour buffer writing is enabled for each Pass.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setColourWriteEnabled
+		*/
+		void setColourWriteEnabled(bool enabled);
+
+        /** Sets the culling mode for each pass  based on the 'vertex winding'.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setCullingMode
+        */
+        void setCullingMode( CullingMode mode );
+
+        /** Sets the manual culling mode, performed by CPU rather than hardware.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setManualCullingMode
+        */
+        void setManualCullingMode( ManualCullingMode mode );
+
+        /** Sets whether or not dynamic lighting is enabled for every Pass.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setLightingEnabled
+        */
+        void setLightingEnabled(bool enabled);
+
+        /** Sets the type of light shading required
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setShadingMode
+        */
+        void setShadingMode( ShadeOptions mode );
+
+        /** Sets the fogging mode applied to each pass.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setFog
+        */
+        void setFog(
+            bool overrideScene,
+            FogMode mode = FOG_NONE,
+            const ColourValue& colour = ColourValue::White,
+            Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0 );
+
+        /** Sets the depth bias to be used for each Pass.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setDepthBias
+        */
+        void setDepthBias(float constantBias, float slopeScaleBias);
+
+        /** Set texture filtering for every texture unit in every Pass
+        @note
+            This property actually exists on the TextureUnitState class
+            For simplicity, this method allows you to set these properties for 
+            every current TeextureUnitState, If you need more precision, retrieve the  
+            Pass and TextureUnitState instances and set the property there.
+        @see TextureUnitState::setTextureFiltering
+        */
+        void setTextureFiltering(TextureFilterOptions filterType);
+        /** Sets the anisotropy level to be used for all textures.
+        @note
+            This property has been moved to the TextureUnitState class, which is accessible via the 
+            Technique and Pass. For simplicity, this method allows you to set these properties for 
+            every current TeextureUnitState, If you need more precision, retrieve the Technique, 
+            Pass and TextureUnitState instances and set the property there.
+        @see TextureUnitState::setTextureAnisotropy
+        */
+        void setTextureAnisotropy(unsigned int maxAniso);
+
+        /** Sets the kind of blending every pass has with the existing contents of the scene.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setSceneBlending
+        */
+        void setSceneBlending( const SceneBlendType sbt );
+
+        /** Sets the kind of blending every pass has with the existing contents of the scene, using individual factors both color and alpha channels
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setSeparateSceneBlending
+        */
+        void setSeparateSceneBlending( const SceneBlendType sbt, const SceneBlendType sbta );
+
+        /** Allows very fine control of blending every Pass with the existing contents of the scene.
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setSceneBlending
+        */
+        void setSceneBlending( const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor);
+
+        /** Allows very fine control of blending every Pass with the existing contents of the scene, using individual factors both color and alpha channels
+        @note
+            This property actually exists on the Pass class. For simplicity, this method allows 
+            you to set these properties for every current Pass within this Technique. If 
+            you need more precision, retrieve the Pass instance and set the
+            property there.
+        @see Pass::setSeparateSceneBlending
+        */
+        void setSeparateSceneBlending( const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor, const SceneBlendFactor sourceFactorAlpha, const SceneBlendFactor destFactorAlpha);
+
+        /** Assigns a level-of-detail (LOD) index to this Technique.
+        @remarks
+            As noted previously, as well as providing fallback support for various
+            graphics cards, multiple Technique objects can also be used to implement
+            material LOD, where the detail of the material diminishes with distance to 
+            save rendering power.
+        @par
+            By default, all Techniques have a LOD index of 0, which means they are the highest
+            level of detail. Increasing LOD indexes are lower levels of detail. You can 
+            assign more than one Technique to the same LOD index, meaning that the best 
+            Technique that is supported at that LOD index is used. 
+        @par
+            You should not leave gaps in the LOD sequence; Ogre will allow you to do this
+            and will continue to function as if the LODs were sequential, but it will 
+            confuse matters.
+        */
+        void setLodIndex(unsigned short index);
+        /** Gets the level-of-detail index assigned to this Technique. */
+        unsigned short getLodIndex(void) const { return mLodIndex; }
+
+		/** Set the 'scheme name' for this technique. 
+		@remarks
+			Material schemes are used to control top-level switching from one
+			set of techniques to another. For example, you might use this to 
+			define 'high', 'medium' and 'low' complexity levels on materials
+		    to allow a user to pick a performance / quality ratio. Another
+			possibility is that you have a fully HDR-enabled pipeline for top
+			machines, rendering all objects using unclamped shaders, and a 
+			simpler pipeline for others; this can be implemented using 
+			schemes.
+		@par
+			Every technique belongs to a scheme - if you don't specify one, the
+			Technique belongs to the scheme called 'Default', which is also the
+			scheme used to render by default. The active scheme is set one of
+			two ways - either by calling Viewport::setMaterialScheme, or
+			by manually calling MaterialManager::setActiveScheme.
+		*/
+		void setSchemeName(const String& schemeName);
+		/** Returns the scheme to which this technique is assigned.
+			@see Technique::setSchemeName
+		*/
+		const String& getSchemeName(void) const;
+		
+		/// Internal method for getting the scheme index
+		unsigned short _getSchemeIndex(void) const;
+		   	
+        /** Is depth writing going to occur on this technique? */
+        bool isDepthWriteEnabled(void) const;
+
+        /** Is depth checking going to occur on this technique? */
+        bool isDepthCheckEnabled(void) const;
+
+        /** Exists colour writing disabled pass on this technique? */
+        bool hasColourWriteDisabled(void) const;
+
+        /** Set the name of the technique.
+        @remarks
+		The use of technique name is optional.  Its useful in material scripts where a material could inherit
+		from another material and only want to modify a particular technique.
+        */
+        void setName(const String& name);
+        /// Gets the name of the technique
+        const String& getName(void) const { return mName; }
+
+        /** Applies texture names to Texture Unit State with matching texture name aliases.
+            All passes, and Texture Unit States within the technique are checked.
+            If matching texture aliases are found then true is returned.
+
+        @param
+            aliasList is a map container of texture alias, texture name pairs
+        @param
+            apply set true to apply the texture aliases else just test to see if texture alias matches are found.
+        @return
+            True if matching texture aliases were found in the Technique.
+        */
+        bool applyTextureAliases(const AliasTextureNamePairList& aliasList, const bool apply = true) const;
+
+
+		/** Add a rule which manually influences the support for this technique based
+			on a GPU vendor.
+		@remarks
+			You can use this facility to manually control whether a technique is
+			considered supported, based on a GPU vendor. You can add inclusive
+			or exclusive rules, and you can add as many of each as you like. If
+			at least one inclusive rule is added, a	technique is considered 
+			unsupported if it does not match any of those inclusive rules. If exclusive rules are
+			added, the technique is considered unsupported if it matches any of
+			those inclusive rules. 
+		@note
+			Any rule for the same vendor will be removed before adding this one.
+		@param vendor The GPU vendor
+		@param includeOrExclude Whether this is an inclusive or exclusive rule
+		*/
+		void addGPUVendorRule(GPUVendor vendor, IncludeOrExclude includeOrExclude);
+		/** Add a rule which manually influences the support for this technique based
+			on a GPU vendor.
+		@remarks
+			You can use this facility to manually control whether a technique is
+			considered supported, based on a GPU vendor. You can add inclusive
+			or exclusive rules, and you can add as many of each as you like. If
+			at least one inclusive rule is added, a	technique is considered 
+			unsupported if it does not match any of those inclusive rules. If exclusive rules are
+			added, the technique is considered unsupported if it matches any of
+			those inclusive rules. 
+		@note
+			Any rule for the same vendor will be removed before adding this one.
+		*/
+		void addGPUVendorRule(const GPUVendorRule& rule);
+		/** Removes a matching vendor rule.
+		@see addGPUVendorRule
+		*/
+		void removeGPUVendorRule(GPUVendor vendor);
+		typedef ConstVectorIterator<GPUVendorRuleList> GPUVendorRuleIterator;
+		/// Get an iterator over the currently registered vendor rules.
+		GPUVendorRuleIterator getGPUVendorRuleIterator() const;
+
+		/** Add a rule which manually influences the support for this technique based
+			on a pattern that matches a GPU device name (e.g. '*8800*').
+		@remarks
+			You can use this facility to manually control whether a technique is
+			considered supported, based on a GPU device name pattern. You can add inclusive
+			or exclusive rules, and you can add as many of each as you like. If
+			at least one inclusive rule is added, a	technique is considered 
+			unsupported if it does not match any of those inclusive rules. If exclusive rules are
+			added, the technique is considered unsupported if it matches any of
+			those inclusive rules. The pattern you supply can include wildcard
+			characters ('*') if you only want to match part of the device name.
+		@note
+			Any rule for the same device pattern will be removed before adding this one.
+		@param devicePattern The GPU vendor
+		@param includeOrExclude Whether this is an inclusive or exclusive rule
+		@param caseSensitive Whether the match is case sensitive or not
+		*/
+		void addGPUDeviceNameRule(const String& devicePattern, IncludeOrExclude includeOrExclude, bool caseSensitive = false);
+		/** Add a rule which manually influences the support for this technique based
+			on a pattern that matches a GPU device name (e.g. '*8800*').
+		@remarks
+			You can use this facility to manually control whether a technique is
+			considered supported, based on a GPU device name pattern. You can add inclusive
+			or exclusive rules, and you can add as many of each as you like. If
+			at least one inclusive rule is added, a	technique is considered 
+			unsupported if it does not match any of those inclusive rules. If exclusive rules are
+			added, the technique is considered unsupported if it matches any of
+			those inclusive rules. The pattern you supply can include wildcard
+			characters ('*') if you only want to match part of the device name.
+		@note
+			Any rule for the same device pattern will be removed before adding this one.
+		*/
+		void addGPUDeviceNameRule(const GPUDeviceNameRule& rule);
+		/** Removes a matching device name rule.
+		@see addGPUDeviceNameRule
+		*/
+		void removeGPUDeviceNameRule(const String& devicePattern);
+		typedef ConstVectorIterator<GPUDeviceNameRuleList> GPUDeviceNameRuleIterator;
+		/// Get an iterator over the currently registered device name rules.
+		GPUDeviceNameRuleIterator getGPUDeviceNameRuleIterator() const;
+
+		/** Return an instance of user objects binding associated with this class.
+		You can use it to associate one or more custom objects with this class instance.
+		@see UserObjectBindings::setUserAny.
+		*/
+		UserObjectBindings&	getUserObjectBindings() { return mUserObjectBindings; }
+
+		/** Return an instance of user objects binding associated with this class.
+		You can use it to associate one or more custom objects with this class instance.
+		@see UserObjectBindings::setUserAny.		
+		*/
+		const UserObjectBindings& getUserObjectBindings() const { return mUserObjectBindings; }
+
+    };
+
+	/** @} */
+	/** @} */
+
+}
+#endif