ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgrePass.h

@@ -0,0 +1,1775 @@
+/*
+-----------------------------------------------------------------------------
+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 __Pass_H__
+#define __Pass_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreGpuProgram.h"
+#include "OgreColourValue.h"
+#include "OgreBlendMode.h"
+#include "OgreCommon.h"
+#include "OgreLight.h"
+#include "OgreTextureUnitState.h"
+#include "OgreUserObjectBindings.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Materials
+	*  @{
+	*/
+	/// Categorisation of passes for the purpose of additive lighting
+	enum IlluminationStage
+	{
+		/// Part of the rendering which occurs without any kind of direct lighting
+		IS_AMBIENT,
+		/// Part of the rendering which occurs per light
+		IS_PER_LIGHT,
+		/// Post-lighting rendering
+		IS_DECAL, 
+		/// Not determined
+		IS_UNKNOWN
+	};
+
+    /** Class defining a single pass of a Technique (of a Material), i.e.
+        a single rendering call.
+    @remarks
+        Rendering can be repeated with many passes for more complex effects.
+        Each pass is either a fixed-function pass (meaning it does not use
+        a vertex or fragment program) or a programmable pass (meaning it does
+        use either a vertex and fragment program, or both).
+    @par
+        Programmable passes are complex to define, because they require custom
+        programs and you have to set all constant inputs to the programs (like
+        the position of lights, any base material colours you wish to use etc), but
+        they do give you much total flexibility over the algorithms used to render your
+        pass, and you can create some effects which are impossible with a fixed-function pass.
+        On the other hand, you can define a fixed-function pass in very little time, and
+        you can use a range of fixed-function effects like environment mapping very
+        easily, plus your pass will be more likely to be compatible with older hardware.
+        There are pros and cons to both, just remember that if you use a programmable
+        pass to create some great effects, allow more time for definition and testing.
+    */
+	class _OgreExport Pass : public PassAlloc
+    {
+	public:
+		/** Definition of a functor for calculating the hashcode of a Pass.
+		@remarks
+			The hashcode of a Pass is used to sort Passes for rendering, in order
+			to reduce the number of render state changes. Each Pass represents a
+			single unique set of states, but by ordering them, state changes can
+			be minimised between passes. An implementation of this functor should
+			order passes so that the elements that you want to keep constant are
+			sorted next to each other.
+		@see Pass::setHashFunc
+		*/
+		struct HashFunc
+		{
+			virtual uint32 operator()(const Pass* p) const = 0;
+			/// Need virtual destructor in case subclasses use it
+			virtual ~HashFunc() {}
+		};
+    protected:
+        Technique* mParent;
+        unsigned short mIndex; // pass index
+        String mName; // optional name for the pass
+        uint32 mHash; // pass hash
+		bool mHashDirtyQueued; // needs to be dirtied when next loaded
+        //-------------------------------------------------------------------------
+        // Colour properties, only applicable in fixed-function passes
+        ColourValue mAmbient;
+        ColourValue mDiffuse;
+        ColourValue mSpecular;
+        ColourValue mEmissive;
+        Real mShininess;
+        TrackVertexColourType mTracking;
+        //-------------------------------------------------------------------------
+
+        //-------------------------------------------------------------------------
+        // Blending factors
+        SceneBlendFactor mSourceBlendFactor;
+        SceneBlendFactor mDestBlendFactor;
+		SceneBlendFactor mSourceBlendFactorAlpha;
+		SceneBlendFactor mDestBlendFactorAlpha;
+
+		// Used to determine if separate alpha blending should be used for color and alpha channels
+		bool mSeparateBlend;
+
+		//-------------------------------------------------------------------------
+		// Blending operations
+		SceneBlendOperation mBlendOperation;
+		SceneBlendOperation mAlphaBlendOperation;
+
+		// Determines if we should use separate blending operations for color and alpha channels
+		bool mSeparateBlendOperation;
+
+        //-------------------------------------------------------------------------
+
+        //-------------------------------------------------------------------------
+        // Depth buffer settings
+        bool mDepthCheck;
+        bool mDepthWrite;
+        CompareFunction mDepthFunc;
+        float mDepthBiasConstant;
+		float mDepthBiasSlopeScale;
+		float mDepthBiasPerIteration;
+
+        // Colour buffer settings
+        bool mColourWrite;
+
+		// Alpha reject settings
+		CompareFunction mAlphaRejectFunc;
+		unsigned char mAlphaRejectVal;
+		bool mAlphaToCoverageEnabled;
+
+		// Transparent depth sorting
+		bool mTransparentSorting;
+		// Transparent depth sorting forced
+		bool mTransparentSortingForced;
+        //-------------------------------------------------------------------------
+
+        //-------------------------------------------------------------------------
+        // Culling mode
+        CullingMode mCullMode;
+        ManualCullingMode mManualCullMode;
+        //-------------------------------------------------------------------------
+
+        /// Lighting enabled?
+        bool mLightingEnabled;
+        /// Max simultaneous lights
+        unsigned short mMaxSimultaneousLights;
+		/// Starting light index
+		unsigned short mStartLight;
+		/// Run this pass once per light?
+		bool mIteratePerLight;
+		/// Iterate per how many lights?
+		unsigned short mLightsPerIteration;
+        // Should it only be run for a certain light type?
+        bool mRunOnlyForOneLightType;
+        Light::LightTypes mOnlyLightType;
+		// With a specific light mask?
+		uint32 mLightMask;
+
+        /// Shading options
+        ShadeOptions mShadeOptions;
+		/// Polygon mode
+		PolygonMode mPolygonMode;
+		/// Normalisation
+		bool mNormaliseNormals;
+		bool mPolygonModeOverrideable;
+        //-------------------------------------------------------------------------
+        // Fog
+        bool mFogOverride;
+        FogMode mFogMode;
+        ColourValue mFogColour;
+        Real mFogStart;
+        Real mFogEnd;
+        Real mFogDensity;
+        //-------------------------------------------------------------------------
+
+        /// Storage of texture unit states
+        typedef vector<TextureUnitState*>::type TextureUnitStates;
+        TextureUnitStates mTextureUnitStates;
+
+		// Vertex program details
+		GpuProgramUsage *mVertexProgramUsage;
+        // Vertex program details
+        GpuProgramUsage *mShadowCasterVertexProgramUsage;
+        // Fragment program details
+        GpuProgramUsage *mShadowCasterFragmentProgramUsage;
+        // Vertex program details
+        GpuProgramUsage *mShadowReceiverVertexProgramUsage;
+		// Fragment program details
+		GpuProgramUsage *mFragmentProgramUsage;
+		// Fragment program details
+		GpuProgramUsage *mShadowReceiverFragmentProgramUsage;
+		// Geometry program details
+		GpuProgramUsage *mGeometryProgramUsage;
+        // Is this pass queued for deletion?
+        bool mQueuedForDeletion;
+        // number of pass iterations to perform
+        size_t mPassIterationCount;
+		// point size, applies when not using per-vertex point size
+		Real mPointSize;
+		Real mPointMinSize;
+		Real mPointMaxSize;
+		bool mPointSpritesEnabled;
+		bool mPointAttenuationEnabled;
+		// constant, linear, quadratic coeffs
+		Real mPointAttenuationCoeffs[3];
+		// TU Content type lookups
+		typedef vector<unsigned short>::type ContentTypeLookup;
+		mutable ContentTypeLookup mShadowContentTypeLookup;
+		mutable bool mContentTypeLookupBuilt;
+		/// Scissoring for the light?
+		bool mLightScissoring;
+		/// User clip planes for light?
+		bool mLightClipPlanes;
+		/// Illumination stage?
+		IlluminationStage mIlluminationStage;
+		// User objects binding.
+		UserObjectBindings	mUserObjectBindings;
+		
+
+		// Used to get scene blending flags from a blending type
+		void _getBlendFlags(SceneBlendType type, SceneBlendFactor& source, SceneBlendFactor& dest);
+
+	public:
+		typedef set<Pass*>::type PassSet;
+    protected:
+		/// List of Passes whose hashes need recalculating
+		static PassSet msDirtyHashList;
+        /// The place where passes go to die
+        static PassSet msPassGraveyard;
+		/// The Pass hash functor
+		static HashFunc* msHashFunc;
+    public:
+		OGRE_STATIC_MUTEX(msDirtyHashListMutex)
+		OGRE_STATIC_MUTEX(msPassGraveyardMutex)
+		OGRE_MUTEX(mTexUnitChangeMutex)
+		OGRE_MUTEX(mGpuProgramChangeMutex)
+        /// Default constructor
+		Pass(Technique* parent, unsigned short index);
+        /// Copy constructor
+        Pass(Technique* parent, unsigned short index, const Pass& oth );
+        /// Operator = overload
+        Pass& operator=(const Pass& oth);
+        virtual ~Pass();
+
+        /// Returns true if this pass is programmable i.e. includes either a vertex or fragment program.
+        bool isProgrammable(void) const { return mVertexProgramUsage || mFragmentProgramUsage || mGeometryProgramUsage; }
+        /// Returns true if this pass uses a programmable vertex pipeline
+        bool hasVertexProgram(void) const { return mVertexProgramUsage != NULL; }
+        /// Returns true if this pass uses a programmable fragment pipeline
+        bool hasFragmentProgram(void) const { return mFragmentProgramUsage != NULL; }
+        /// Returns true if this pass uses a programmable geometry pipeline
+        bool hasGeometryProgram(void) const { return mGeometryProgramUsage != NULL; }
+        /// Returns true if this pass uses a shadow caster vertex program
+        bool hasShadowCasterVertexProgram(void) const { return mShadowCasterVertexProgramUsage != NULL; }
+        /// Returns true if this pass uses a shadow caster fragment program
+        bool hasShadowCasterFragmentProgram(void) const { return mShadowCasterFragmentProgramUsage != NULL; }
+        /// Returns true if this pass uses a shadow receiver vertex program
+        bool hasShadowReceiverVertexProgram(void) const { return mShadowReceiverVertexProgramUsage != NULL; }
+        /// Returns true if this pass uses a shadow receiver fragment program
+        bool hasShadowReceiverFragmentProgram(void) const { return mShadowReceiverFragmentProgramUsage != NULL; }
+
+
+        /// Gets the index of this Pass in the parent Technique
+        unsigned short getIndex(void) const { return mIndex; }
+        /* Set the name of the pass
+        @remarks
+        The name of the pass is optional.  Its useful in material scripts where a material could inherit
+        from another material and only want to modify a particular pass.
+        */
+        void setName(const String& name);
+        /// get the name of the pass
+        const String& getName(void) const { return mName; }
+
+        /** Sets the ambient colour reflectance properties of this pass.
+        @remarks
+        The base colour of a pass is determined by how much red, green and blue light is reflects
+        (provided texture layer #0 has a blend mode other than LBO_REPLACE). This property determines how
+        much ambient light (directionless global light) is reflected. The default is full white, meaning
+        objects are completely globally illuminated. Reduce this if you want to see diffuse or specular light
+        effects, or change the blend of colours to make the object have a base colour other than white.
+        @note
+        This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled),
+        or if this is a programmable pass.
+        */
+        void setAmbient(Real red, Real green, Real blue);
+
+        /** Sets the ambient colour reflectance properties of this pass.
+        @remarks
+        The base colour of a pass is determined by how much red, green and blue light is reflects
+        (provided texture layer #0 has a blend mode other than LBO_REPLACE). This property determines how
+        much ambient light (directionless global light) is reflected. The default is full white, meaning
+        objects are completely globally illuminated. Reduce this if you want to see diffuse or specular light
+        effects, or change the blend of colours to make the object have a base colour other than white.
+        @note
+        This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled),
+        or if this is a programmable pass.
+        */
+
+        void setAmbient(const ColourValue& ambient);
+
+        /** Sets the diffuse colour reflectance properties of this pass.
+        @remarks
+        The base colour of a pass is determined by how much red, green and blue light is reflects
+        (provided texture layer #0 has a blend mode other than LBO_REPLACE). This property determines how
+        much diffuse light (light from instances of the Light class in the scene) is reflected. The default
+        is full white, meaning objects reflect the maximum white light they can from Light objects.
+        @note
+        This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled),
+        or if this is a programmable pass.
+        */
+        void setDiffuse(Real red, Real green, Real blue, Real alpha);
+
+        /** Sets the diffuse colour reflectance properties of this pass.
+        @remarks
+        The base colour of a pass is determined by how much red, green and blue light is reflects
+        (provided texture layer #0 has a blend mode other than LBO_REPLACE). This property determines how
+        much diffuse light (light from instances of the Light class in the scene) is reflected. The default
+        is full white, meaning objects reflect the maximum white light they can from Light objects.
+        @note
+        This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled),
+        or if this is a programmable pass.
+        */
+        void setDiffuse(const ColourValue& diffuse);
+
+        /** Sets the specular colour reflectance properties of this pass.
+        @remarks
+        The base colour of a pass is determined by how much red, green and blue light is reflects
+        (provided texture layer #0 has a blend mode other than LBO_REPLACE). This property determines how
+        much specular light (highlights from instances of the Light class in the scene) is reflected.
+        The default is to reflect no specular light.
+        @note
+        The size of the specular highlights is determined by the separate 'shininess' property.
+        @note
+        This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled),
+        or if this is a programmable pass.
+        */
+        void setSpecular(Real red, Real green, Real blue, Real alpha);
+
+        /** Sets the specular colour reflectance properties of this pass.
+        @remarks
+        The base colour of a pass is determined by how much red, green and blue light is reflects
+        (provided texture layer #0 has a blend mode other than LBO_REPLACE). This property determines how
+        much specular light (highlights from instances of the Light class in the scene) is reflected.
+        The default is to reflect no specular light.
+        @note
+        The size of the specular highlights is determined by the separate 'shininess' property.
+        @note
+        This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled),
+        or if this is a programmable pass.
+        */
+        void setSpecular(const ColourValue& specular);
+
+        /** Sets the shininess of the pass, affecting the size of specular highlights.
+        @note
+        This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled),
+        or if this is a programmable pass.
+        */
+        void setShininess(Real val);
+
+        /** Sets the amount of self-illumination an object has.
+        @remarks
+        If an object is self-illuminating, it does not need external sources to light it, ambient or
+        otherwise. It's like the object has it's own personal ambient light. This property is rarely useful since
+        you can already specify per-pass ambient light, but is here for completeness.
+        @note
+        This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled),
+        or if this is a programmable pass.
+        */
+        void setSelfIllumination(Real red, Real green, Real blue);
+
+        /** Sets the amount of self-illumination an object has.
+        @see
+            setSelfIllumination
+        */
+        void setEmissive(Real red, Real green, Real blue)
+        {
+            setSelfIllumination(red, green, blue);
+        }
+
+        /** Sets the amount of self-illumination an object has.
+        @remarks
+        If an object is self-illuminating, it does not need external sources to light it, ambient or
+        otherwise. It's like the object has it's own personal ambient light. This property is rarely useful since
+        you can already specify per-pass ambient light, but is here for completeness.
+        @note
+        This setting has no effect if dynamic lighting is disabled (see Pass::setLightingEnabled),
+        or if this is a programmable pass.
+        */
+        void setSelfIllumination(const ColourValue& selfIllum);
+
+        /** Sets the amount of self-illumination an object has.
+        @see
+            setSelfIllumination
+        */
+        void setEmissive(const ColourValue& emissive)
+        {
+            setSelfIllumination(emissive);
+        }
+
+        /** Sets which material properties follow the vertex colour
+         */
+        void setVertexColourTracking(TrackVertexColourType tracking);
+
+        /** Gets the point size of the pass.
+		@remarks
+			This property determines what point size is used to render a point
+			list.
+        */
+        Real getPointSize(void) const;
+
+		/** Sets the point size of this pass.
+		@remarks
+			This setting allows you to change the size of points when rendering
+			a point list, or a list of point sprites. The interpretation of this
+			command depends on the Pass::setPointSizeAttenuation option - if it
+			is off (the default), the point size is in screen pixels, if it is on,
+			it expressed as normalised screen coordinates (1.0 is the height of
+			the screen) when the point is at the origin.
+		@note
+			Some drivers have an upper limit on the size of points they support
+			- this can even vary between APIs on the same card! Don't rely on
+			point sizes that cause the point sprites to get very large on screen,
+			since they may get clamped on some cards. Upper sizes can range from
+			64 to 256 pixels.
+		*/
+		void setPointSize(Real ps);
+
+		/** Sets whether or not rendering points using OT_POINT_LIST will
+			render point sprites (textured quads) or plain points (dots).
+		@param enabled True enables point sprites, false returns to normal
+			point rendering.
+		*/
+		void setPointSpritesEnabled(bool enabled);
+
+		/** Returns whether point sprites are enabled when rendering a
+			point list.
+		*/
+		bool getPointSpritesEnabled(void) const;
+
+		/** Sets how points are attenuated with distance.
+		@remarks
+			When performing point rendering or point sprite rendering,
+			point size can be attenuated with distance. The equation for
+			doing this is attenuation = 1 / (constant + linear * dist + quadratic * d^2).
+		@par
+			For example, to disable distance attenuation (constant screensize)
+			you would set constant to 1, and linear and quadratic to 0. A
+			standard perspective attenuation would be 0, 1, 0 respectively.
+		@note
+			The resulting size is clamped to the minimum and maximum point
+			size.
+		@param enabled Whether point attenuation is enabled
+		@param constant, linear, quadratic Parameters to the attenuation
+			function defined above
+		*/
+		void setPointAttenuation(bool enabled,
+			Real constant = 0.0f, Real linear = 1.0f, Real quadratic = 0.0f);
+
+		/** Returns whether points are attenuated with distance. */
+		bool isPointAttenuationEnabled(void) const;
+
+		/** Returns the constant coefficient of point attenuation. */
+		Real getPointAttenuationConstant(void) const;
+		/** Returns the linear coefficient of point attenuation. */
+		Real getPointAttenuationLinear(void) const;
+		/** Returns the quadratic coefficient of point attenuation. */
+		Real getPointAttenuationQuadratic(void) const;
+
+		/** Set the minimum point size, when point attenuation is in use. */
+		void setPointMinSize(Real min);
+		/** Get the minimum point size, when point attenuation is in use. */
+		Real getPointMinSize(void) const;
+		/** Set the maximum point size, when point attenuation is in use.
+		@remarks Setting this to 0 indicates the max size supported by the card.
+		*/
+		void setPointMaxSize(Real max);
+		/** Get the maximum point size, when point attenuation is in use.
+		@remarks 0 indicates the max size supported by the card.
+		*/
+		Real getPointMaxSize(void) const;
+
+		/** Gets the ambient colour reflectance of the pass.
+        */
+        const ColourValue& getAmbient(void) const;
+
+        /** Gets the diffuse colour reflectance of the pass.
+        */
+        const ColourValue& getDiffuse(void) const;
+
+        /** Gets the specular colour reflectance of the pass.
+        */
+        const ColourValue& getSpecular(void) const;
+
+        /** Gets the self illumination colour of the pass.
+        */
+        const ColourValue& getSelfIllumination(void) const;
+
+        /** Gets the self illumination colour of the pass.
+        @see
+                getSelfIllumination
+        */
+        const ColourValue& getEmissive(void) const
+        {
+            return getSelfIllumination();
+        }
+
+        /** Gets the 'shininess' property of the pass (affects specular highlights).
+        */
+        Real getShininess(void) const;
+
+        /** Gets which material properties follow the vertex colour
+         */
+        TrackVertexColourType getVertexColourTracking(void) const;
+
+        /** Inserts a new TextureUnitState object into the Pass.
+        @remarks
+        This unit is is added on top of all previous units.
+        */
+        TextureUnitState* createTextureUnitState(void);
+        /** Inserts a new TextureUnitState object into the Pass.
+        @remarks
+        This unit is is added on top of all previous units.
+        @param
+        name The basic name of the texture e.g. brickwall.jpg, stonefloor.png
+        @param
+        texCoordSet The index of the texture coordinate set to use.
+        @note
+        Applies to both fixed-function and programmable passes.
+        */
+        TextureUnitState* createTextureUnitState( const String& textureName, unsigned short texCoordSet = 0);
+		/** Adds the passed in TextureUnitState, to the existing Pass.
+        @param
+        state The Texture Unit State to be attached to this pass.  It must not be attached to another pass.
+        @note
+            Throws an exception if the TextureUnitState is attached to another Pass.*/
+		void addTextureUnitState(TextureUnitState* state);
+        /** Retrieves a pointer to a texture unit state so it may be modified.
+        */
+        TextureUnitState* getTextureUnitState(unsigned short index);
+        /** Retrieves the Texture Unit State matching name.
+            Returns 0 if name match is not found.
+        */
+        TextureUnitState* getTextureUnitState(const String& name);
+		/** Retrieves a const pointer to a texture unit state.
+		*/
+		const TextureUnitState* getTextureUnitState(unsigned short index) const;
+		/** Retrieves the Texture Unit State matching name.
+		Returns 0 if name match is not found.
+		*/
+		const TextureUnitState* getTextureUnitState(const String& name) const;
+
+        /**  Retrieve the index of the Texture Unit State in the pass.
+        @param
+        state The Texture Unit State this is attached to this pass.
+        @note
+            Throws an exception if the state is not attached to the pass.
+        */
+        unsigned short getTextureUnitStateIndex(const TextureUnitState* state) const;
+
+        typedef VectorIterator<TextureUnitStates> TextureUnitStateIterator;
+        /** Get an iterator over the TextureUnitStates contained in this Pass. */
+        TextureUnitStateIterator getTextureUnitStateIterator(void);
+
+		typedef ConstVectorIterator<TextureUnitStates> ConstTextureUnitStateIterator;
+		/** Get an iterator over the TextureUnitStates contained in this Pass. */
+		ConstTextureUnitStateIterator getTextureUnitStateIterator(void) const;
+
+		/** Removes the indexed texture unit state from this pass.
+        @remarks
+            Note that removing a texture which is not the topmost will have a larger performance impact.
+        */
+        void removeTextureUnitState(unsigned short index);
+
+        /** Removes all texture unit settings.
+        */
+        void removeAllTextureUnitStates(void);
+
+        /** Returns the number of texture unit settings.
+        */
+        unsigned short getNumTextureUnitStates(void) const
+        {
+            return static_cast<unsigned short>(mTextureUnitStates.size());
+        }
+
+        /** Sets the kind of blending this pass has with the existing contents of the scene.
+        @remarks
+        Whereas the texture blending operations seen in the TextureUnitState class are concerned with
+        blending between texture layers, this blending is about combining the output of the Pass
+        as a whole with the existing contents of the rendering target. This blending therefore allows
+        object transparency and other special effects. If all passes in a technique have a scene
+        blend, then the whole technique is considered to be transparent.
+        @par
+        This method allows you to select one of a number of predefined blending types. If you require more
+        control than this, use the alternative version of this method which allows you to specify source and
+        destination blend factors.
+        @note
+        This method is applicable for both the fixed-function and programmable pipelines.
+        @param
+        sbt One of the predefined SceneBlendType blending types
+        */
+        void setSceneBlending( const SceneBlendType sbt );
+
+       /** Sets the kind of blending this pass has with the existing contents of the scene, separately for color and alpha channels
+        @remarks
+        Whereas the texture blending operations seen in the TextureUnitState class are concerned with
+        blending between texture layers, this blending is about combining the output of the Pass
+        as a whole with the existing contents of the rendering target. This blending therefore allows
+        object transparency and other special effects. If all passes in a technique have a scene
+        blend, then the whole technique is considered to be transparent.
+        @par
+        This method allows you to select one of a number of predefined blending types. If you require more
+        control than this, use the alternative version of this method which allows you to specify source and
+        destination blend factors.
+        @note
+        This method is applicable for both the fixed-function and programmable pipelines.
+        @param
+        sbt One of the predefined SceneBlendType blending types for the color channel
+        @param
+        sbta One of the predefined SceneBlendType blending types for the alpha channel
+        */
+        void setSeparateSceneBlending( const SceneBlendType sbt, const SceneBlendType sbta );
+
+        /** Allows very fine control of blending this Pass with the existing contents of the scene.
+        @remarks
+        Whereas the texture blending operations seen in the TextureUnitState class are concerned with
+        blending between texture layers, this blending is about combining the output of the material
+        as a whole with the existing contents of the rendering target. This blending therefore allows
+        object transparency and other special effects.
+        @par
+        This version of the method allows complete control over the blending operation, by specifying the
+        source and destination blending factors. The result of the blending operation is:
+        <span align="center">
+        final = (texture * sourceFactor) + (pixel * destFactor)
+        </span>
+        @par
+        Each of the factors is specified as one of a number of options, as specified in the SceneBlendFactor
+        enumerated type.
+        @param
+        sourceFactor The source factor in the above calculation, i.e. multiplied by the texture colour components.
+        @param
+        destFactor The destination factor in the above calculation, i.e. multiplied by the pixel colour components.
+        @note
+        This method is applicable for both the fixed-function and programmable pipelines.
+        */
+        void setSceneBlending( const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor);
+
+        /** Allows very fine control of blending this Pass with the existing contents of the scene.
+        @remarks
+        Whereas the texture blending operations seen in the TextureUnitState class are concerned with
+        blending between texture layers, this blending is about combining the output of the material
+        as a whole with the existing contents of the rendering target. This blending therefore allows
+        object transparency and other special effects.
+        @par
+        This version of the method allows complete control over the blending operation, by specifying the
+        source and destination blending factors. The result of the blending operation is:
+        <span align="center">
+        final = (texture * sourceFactor) + (pixel * destFactor)
+        </span>
+        @par
+        Each of the factors is specified as one of a number of options, as specified in the SceneBlendFactor
+        enumerated type.
+        @param
+        sourceFactor The source factor in the above calculation, i.e. multiplied by the texture colour components.
+        @param
+        destFactor The destination factor in the above calculation, i.e. multiplied by the pixel colour components.
+        @param
+        sourceFactorAlpha The alpha source factor in the above calculation, i.e. multiplied by the texture alpha component.
+        @param
+        destFactorAlpha The alpha destination factor in the above calculation, i.e. multiplied by the pixel alpha component.
+		@note
+        This method is applicable for both the fixed-function and programmable pipelines.
+        */
+		void setSeparateSceneBlending( const SceneBlendFactor sourceFactor, const SceneBlendFactor destFactor, const SceneBlendFactor sourceFactorAlpha, const SceneBlendFactor destFactorAlpha );
+
+		/** Return true if this pass uses separate scene blending */
+		bool hasSeparateSceneBlending() const;
+
+        /** Retrieves the source blending factor for the material (as set using Materiall::setSceneBlending).
+        */
+        SceneBlendFactor getSourceBlendFactor() const;
+
+        /** Retrieves the destination blending factor for the material (as set using Materiall::setSceneBlending).
+        */
+        SceneBlendFactor getDestBlendFactor() const;
+
+	    /** Retrieves the alpha source blending factor for the material (as set using Materiall::setSeparateSceneBlending).
+        */
+		SceneBlendFactor getSourceBlendFactorAlpha() const;
+
+	    /** Retrieves the alpha destination blending factor for the material (as set using Materiall::setSeparateSceneBlending).
+        */
+		SceneBlendFactor getDestBlendFactorAlpha() const;
+
+		/** Sets the specific operation used to blend source and destination pixels together.
+			@remarks 
+			By default this operation is +, which creates this equation
+			<span align="center">
+			final = (texture * sourceFactor) + (pixel * destFactor)
+			</span>
+			By setting this to something other than SBO_ADD you can change the operation to achieve
+			a different effect.
+			@param op The blending operation mode to use for this pass
+		*/
+		void setSceneBlendingOperation(SceneBlendOperation op);
+
+		/** Sets the specific operation used to blend source and destination pixels together.
+			@remarks 
+			By default this operation is +, which creates this equation
+			<span align="center">
+			final = (texture * sourceFactor) + (pixel * destFactor)
+			</span>
+			By setting this to something other than SBO_ADD you can change the operation to achieve
+			a different effect.
+			This function allows more control over blending since it allows you to select different blending
+			modes for the color and alpha channels
+			@param op The blending operation mode to use for color channels in this pass
+			@param op The blending operation mode to use for alpha channels in this pass
+		*/
+		void setSeparateSceneBlendingOperation(SceneBlendOperation op, SceneBlendOperation alphaOp);
+
+		/** Returns true if this pass uses separate scene blending operations. */
+		bool hasSeparateSceneBlendingOperations() const;
+
+		/** Returns the current blending operation */
+		SceneBlendOperation getSceneBlendingOperation() const;
+
+		/** Returns the current alpha blending operation */
+		SceneBlendOperation getSceneBlendingOperationAlpha() const;
+
+		/** Returns true if this pass has some element of transparency. */
+		bool isTransparent(void) const;
+
+		/** Sets whether or not this pass renders with depth-buffer checking on or not.
+        @remarks
+        If depth-buffer checking is on, whenever a pixel is about to be written to the frame buffer
+        the depth buffer is checked to see if the pixel is in front of all other pixels written at that
+        point. If not, the pixel is not written.
+        @par
+        If depth checking is off, pixels are written no matter what has been rendered before.
+        Also see setDepthFunction for more advanced depth check configuration.
+        @see
+        setDepthFunction
+        */
+        void setDepthCheckEnabled(bool enabled);
+
+        /** Returns whether or not this pass renders with depth-buffer checking on or not.
+        @see
+        setDepthCheckEnabled
+        */
+        bool getDepthCheckEnabled(void) const;
+
+        /** Sets whether or not this pass renders with depth-buffer writing on or not.
+        @remarks
+        If depth-buffer writing is on, whenever a pixel is written to the frame buffer
+        the depth buffer is updated with the depth value of that new pixel, thus affecting future
+        rendering operations if future pixels are behind this one.
+        @par
+        If depth writing is off, pixels are written without updating the depth buffer Depth writing should
+        normally be on but can be turned off when rendering static backgrounds or when rendering a collection
+        of transparent objects at the end of a scene so that they overlap each other correctly.
+        */
+        void setDepthWriteEnabled(bool enabled);
+
+        /** Returns whether or not this pass renders with depth-buffer writing on or not.
+        @see
+        setDepthWriteEnabled
+        */
+        bool getDepthWriteEnabled(void) const;
+
+        /** Sets the function used to compare depth values when depth checking is on.
+        @remarks
+        If depth checking is enabled (see setDepthCheckEnabled) a comparison occurs between the depth
+        value of the pixel to be written and the current contents of the buffer. This comparison is
+        normally CMPF_LESS_EQUAL, i.e. the pixel is written if it is closer (or at the same distance)
+        than the current contents. If you wish you can change this comparison using this method.
+        */
+        void setDepthFunction( CompareFunction func );
+        /** Returns the function used to compare depth values when depth checking is on.
+        @see
+        setDepthFunction
+        */
+        CompareFunction getDepthFunction(void) const;
+
+		/** Sets whether or not colour buffer writing is enabled for this Pass.
+		@remarks
+			For some effects, you might wish to turn off the colour write operation
+			when rendering geometry; this means that only the depth buffer will be
+			updated (provided you have depth buffer writing enabled, which you
+			probably will do, although you may wish to only update the stencil
+			buffer for example - stencil buffer state is managed at the RenderSystem
+			level only, not the Material since you are likely to want to manage it
+			at a higher level).
+		*/
+		void setColourWriteEnabled(bool enabled);
+		/** Determines if colour buffer writing is enabled for this pass. */
+		bool getColourWriteEnabled(void) const;
+
+        /** Sets the culling mode for this pass  based on the 'vertex winding'.
+        @remarks
+        A typical way for the rendering engine to cull triangles is based on the 'vertex winding' of
+        triangles. Vertex winding refers to the direction in which the vertices are passed or indexed
+        to in the rendering operation as viewed from the camera, and will wither be clockwise or
+        anticlockwise (that's 'counterclockwise' for you Americans out there ;) The default is
+        CULL_CLOCKWISE i.e. that only triangles whose vertices are passed/indexed in anticlockwise order
+        are rendered - this is a common approach and is used in 3D studio models for example. You can
+        alter this culling mode if you wish but it is not advised unless you know what you are doing.
+        @par
+        You may wish to use the CULL_NONE option for mesh data that you cull yourself where the vertex
+        winding is uncertain.
+        */
+        void setCullingMode( CullingMode mode );
+
+        /** Returns the culling mode for geometry rendered with this pass. See setCullingMode for more information.
+        */
+        CullingMode getCullingMode(void) const;
+
+        /** Sets the manual culling mode, performed by CPU rather than hardware.
+        @remarks
+        In some situations you want to use manual culling of triangles rather than sending the
+        triangles to the hardware and letting it cull them. This setting only takes effect on SceneManager's
+        that use it (since it is best used on large groups of planar world geometry rather than on movable
+        geometry since this would be expensive), but if used can cull geometry before it is sent to the
+        hardware.
+        @note
+        The default for this setting is MANUAL_CULL_BACK.
+        @param
+        mode The mode to use - see enum ManualCullingMode for details
+
+        */
+        void setManualCullingMode( ManualCullingMode mode );
+
+        /** Retrieves the manual culling mode for this pass
+        @see
+        setManualCullingMode
+        */
+        ManualCullingMode getManualCullingMode(void) const;
+
+        /** Sets whether or not dynamic lighting is enabled.
+        @param
+        enabled
+        If true, dynamic lighting is performed on geometry with normals supplied, geometry without
+        normals will not be displayed.
+        @par
+        If false, no lighting is applied and all geometry will be full brightness.
+        */
+        void setLightingEnabled(bool enabled);
+
+        /** Returns whether or not dynamic lighting is enabled.
+        */
+        bool getLightingEnabled(void) const;
+
+        /** Sets the maximum number of lights to be used by this pass.
+        @remarks
+            During rendering, if lighting is enabled (or if the pass uses an automatic
+            program parameter based on a light) the engine will request the nearest lights
+            to the object being rendered in order to work out which ones to use. This
+            parameter sets the limit on the number of lights which should apply to objects
+            rendered with this pass.
+        */
+        void setMaxSimultaneousLights(unsigned short maxLights);
+        /** Gets the maximum number of lights to be used by this pass. */
+        unsigned short getMaxSimultaneousLights(void) const;
+
+		/** Sets the light index that this pass will start at in the light list.
+		@remarks
+			Normally the lights passed to a pass will start from the beginning
+			of the light list for this object. This option allows you to make this
+			pass start from a higher light index, for example if one of your earlier
+			passes could deal with lights 0-3, and this pass dealt with lights 4+. 
+			This option also has an interaction with pass iteration, in that
+			if you choose to iterate this pass per light too, the iteration will
+			only begin from light 4.
+		*/
+		void setStartLight(unsigned short startLight);
+		/** Gets the light index that this pass will start at in the light list. */
+		unsigned short getStartLight(void) const;
+
+		/** Sets the light mask which can be matched to specific light flags to be handled by this pass */
+		void setLightMask(uint32 mask);
+		/** Gets the light mask controlling which lights are used for this pass */
+		uint32 getLightMask() const;
+
+        /** Sets the type of light shading required
+        @note
+        The default shading method is Gouraud shading.
+        */
+        void setShadingMode( ShadeOptions mode );
+
+        /** Returns the type of light shading to be used.
+        */
+        ShadeOptions getShadingMode(void) const;
+
+		/** Sets the type of polygon rendering required
+		@note
+		The default shading method is Solid
+		*/
+		void setPolygonMode( PolygonMode mode );
+
+		/** Returns the type of light shading to be used.
+		*/
+		PolygonMode getPolygonMode(void) const;
+
+		/** Sets whether this pass's chosen detail level can be
+			overridden (downgraded) by the camera setting. 
+		@param override true means that a lower camera detail will override this
+			pass's detail level, false means it won't (default true).
+		*/
+		virtual void setPolygonModeOverrideable(bool override)
+		{
+			mPolygonModeOverrideable = override;
+		}
+
+		/** Gets whether this renderable's chosen detail level can be
+			overridden (downgraded) by the camera setting. 
+		*/
+		virtual bool getPolygonModeOverrideable(void) const
+		{
+			return mPolygonModeOverrideable;
+		}
+        /** Sets the fogging mode applied to this pass.
+        @remarks
+        Fogging is an effect that is applied as polys are rendered. Sometimes, you want
+        fog to be applied to an entire scene. Other times, you want it to be applied to a few
+        polygons only. This pass-level specification of fog parameters lets you easily manage
+        both.
+        @par
+        The SceneManager class also has a setFog method which applies scene-level fog. This method
+        lets you change the fog behaviour for this pass compared to the standard scene-level fog.
+        @param
+        overrideScene If true, you authorise this pass to override the scene's fog params with it's own settings.
+        If you specify false, so other parameters are necessary, and this is the default behaviour for passes.
+        @param
+        mode Only applicable if overrideScene is true. You can disable fog which is turned on for the
+        rest of the scene by specifying FOG_NONE. Otherwise, set a pass-specific fog mode as
+        defined in the enum FogMode.
+        @param
+        colour The colour of the fog. Either set this to the same as your viewport background colour,
+        or to blend in with a skydome or skybox.
+        @param
+        expDensity The density of the fog in FOG_EXP or FOG_EXP2 mode, as a value between 0 and 1.
+        The default is 0.001.
+        @param
+        linearStart Distance in world units at which linear fog starts to encroach.
+        Only applicable if mode is FOG_LINEAR.
+        @param
+        linearEnd Distance in world units at which linear fog becomes completely opaque.
+        Only applicable if mode is FOG_LINEAR.
+        */
+        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 );
+
+        /** Returns true if this pass is to override the scene fog settings.
+        */
+        bool getFogOverride(void) const;
+
+        /** Returns the fog mode for this pass.
+        @note
+        Only valid if getFogOverride is true.
+        */
+        FogMode getFogMode(void) const;
+
+        /** Returns the fog colour for the scene.
+        */
+        const ColourValue& getFogColour(void) const;
+
+        /** Returns the fog start distance for this pass.
+        @note
+        Only valid if getFogOverride is true.
+        */
+        Real getFogStart(void) const;
+
+        /** Returns the fog end distance for this pass.
+        @note
+        Only valid if getFogOverride is true.
+        */
+        Real getFogEnd(void) const;
+
+        /** Returns the fog density for this pass.
+        @note
+        Only valid if getFogOverride is true.
+        */
+        Real getFogDensity(void) const;
+
+        /** Sets the depth bias to be used for this material.
+        @remarks
+        When polygons are coplanar, you can get problems with 'depth fighting' where
+        the pixels from the two polys compete for the same screen pixel. This is particularly
+        a problem for decals (polys attached to another surface to represent details such as
+        bulletholes etc.).
+        @par
+        A way to combat this problem is to use a depth bias to adjust the depth buffer value
+        used for the decal such that it is slightly higher than the true value, ensuring that
+        the decal appears on top. There are two aspects to the biasing, a constant
+		bias value and a slope-relative biasing value, which varies according to the
+		maximum depth slope relative to the camera, ie:
+		<pre>finalBias = maxSlope * slopeScaleBias + constantBias</pre>
+		Note that slope scale bias, whilst more accurate, may be ignored by old hardware.
+        @param constantBias The constant bias value, expressed as a factor of the
+			minimum observable depth
+		@param slopeScaleBias The slope-relative bias value, expressed as a factor
+			of the depth slope
+		*/
+        void setDepthBias(float constantBias, float slopeScaleBias = 0.0f);
+
+        /** Retrieves the const depth bias value as set by setDepthBias. */
+        float getDepthBiasConstant(void) const;
+		/** Retrieves the slope-scale depth bias value as set by setDepthBias. */
+		float getDepthBiasSlopeScale(void) const;
+		/** Sets a factor which derives an additional depth bias from the number 
+			of times a pass is iterated.
+		@remarks
+			The Final depth bias will be the constant depth bias as set through
+			setDepthBias, plus this value times the iteration number. 
+		*/
+		void setIterationDepthBias(float biasPerIteration);
+		/** Gets a factor which derives an additional depth bias from the number 
+			of times a pass is iterated.
+		*/
+		float getIterationDepthBias() const;
+
+        /** Sets the way the pass will have use alpha to totally reject pixels from the pipeline.
+        @remarks
+			The default is CMPF_ALWAYS_PASS i.e. alpha is not used to reject pixels.
+        @param func The comparison which must pass for the pixel to be written.
+        @param value 1 byte value against which alpha values will be tested(0-255)
+		@param alphaToCoverageEnabled Whether to enable alpha to coverage support
+        @note
+			This option applies in both the fixed function and the programmable pipeline.
+        */
+        void setAlphaRejectSettings(CompareFunction func, unsigned char value, bool alphaToCoverageEnabled = false);
+
+		/** Sets the alpha reject function. See setAlphaRejectSettings for more information.
+		*/
+		void setAlphaRejectFunction(CompareFunction func);
+
+		/** Gets the alpha reject value. See setAlphaRejectSettings for more information.
+		*/
+		void setAlphaRejectValue(unsigned char val);
+
+		/** Gets the alpha reject function. See setAlphaRejectSettings for more information.
+        */
+		CompareFunction getAlphaRejectFunction(void) const { return mAlphaRejectFunc; }
+
+        /** Gets the alpha reject value. See setAlphaRejectSettings for more information.
+        */
+		unsigned char getAlphaRejectValue(void) const { return mAlphaRejectVal; }
+
+		/** Sets whether to use alpha to coverage (A2C) when blending alpha rejected values. 
+		@remarks
+			Alpha to coverage performs multisampling on the edges of alpha-rejected
+			textures to produce a smoother result. It is only supported when multisampling
+			is already enabled on the render target, and when the hardware supports
+			alpha to coverage (see RenderSystemCapabilities). 
+		*/
+		void setAlphaToCoverageEnabled(bool enabled);
+
+		/** Gets whether to use alpha to coverage (A2C) when blending alpha rejected values. 
+		*/
+		bool isAlphaToCoverageEnabled() const { return mAlphaToCoverageEnabled; }
+
+        /** Sets whether or not transparent sorting is enabled.
+        @param enabled
+			If false depth sorting of this material will be disabled.
+        @remarks
+			By default all transparent materials are sorted such that renderables furthest
+			away from the camera are rendered first. This is usually the desired behaviour
+			but in certain cases this depth sorting may be unnecessary and undesirable. If
+			for example it is necessary to ensure the rendering order does not change from
+			one frame to the next.
+		@note
+			This will have no effect on non-transparent materials.
+        */
+        void setTransparentSortingEnabled(bool enabled);
+
+        /** Returns whether or not transparent sorting is enabled.
+        */
+		bool getTransparentSortingEnabled(void) const;
+
+        /** Sets whether or not transparent sorting is forced.
+        @param enabled
+			If true depth sorting of this material will be depend only on the value of
+            getTransparentSortingEnabled().
+        @remarks
+			By default even if transparent sorting is enabled, depth sorting will only be
+            performed when the material is transparent and depth write/check are disabled.
+            This function disables these extra conditions.
+        */
+        void setTransparentSortingForced(bool enabled);
+
+        /** Returns whether or not transparent sorting is forced.
+        */
+		bool getTransparentSortingForced(void) const;
+
+		/** Sets whether or not this pass should iterate per light or number of
+			lights which can affect the object being rendered.
+		@remarks
+			The default behaviour for a pass (when this option is 'false'), is
+			for a pass to be rendered only once (or the number of times set in
+			setPassIterationCount), with all the lights which could
+			affect this object set at the same time (up to the maximum lights
+			allowed in the render system, which is typically 8).
+		@par
+			Setting this option to 'true' changes this behaviour, such that
+			instead of trying to issue render this pass once per object, it
+			is run <b>per light</b>, or for a group of 'n' lights each time
+			which can affect this object, the number of
+			times set in setPassIterationCount (default is once). In
+			this case, only light index 0 is ever used, and is a different light
+			every time the pass is issued, up to the total number of lights
+			which is affecting this object. This has 2 advantages:
+			<ul><li>There is no limit on the number of lights which can be
+			supported</li>
+			<li>It's easier to write vertex / fragment programs for this because
+			a single program can be used for any number of lights</li>
+			</ul>
+			However, this technique is more expensive, and typically you
+			will want an additional ambient pass, because if no lights are 
+			affecting the object it will not be rendered at all, which will look
+			odd even if ambient light is zero (imagine if there are lit objects
+			behind it - the objects silhouette would not show up). Therefore,
+			use this option with care, and you would be well advised to provide
+			a less expensive fallback technique for use in the distance.
+		@note
+			The number of times this pass runs is still limited by the maximum
+			number of lights allowed as set in setMaxSimultaneousLights, so
+			you will never get more passes than this. Also, the iteration is
+			started from the 'start light' as set in Pass::setStartLight, and
+			the number of passes is the number of lights to iterate over divided
+			by the number of lights per iteration (default 1, set by 
+			setLightCountPerIteration).
+        @param enabled Whether this feature is enabled
+        @param onlyForOneLightType If true, the pass will only be run for a single type
+            of light, other light types will be ignored.
+        @param lightType The single light type which will be considered for this pass
+		*/
+        void setIteratePerLight(bool enabled,
+            bool onlyForOneLightType = true, Light::LightTypes lightType = Light::LT_POINT);
+
+        /** Does this pass run once for every light in range? */
+		bool getIteratePerLight(void) const { return mIteratePerLight; }
+        /** Does this pass run only for a single light type (if getIteratePerLight is true). */
+        bool getRunOnlyForOneLightType(void) const { return mRunOnlyForOneLightType; }
+        /** Gets the single light type this pass runs for if  getIteratePerLight and
+            getRunOnlyForOneLightType are both true. */
+        Light::LightTypes getOnlyLightType() const { return mOnlyLightType; }
+
+		/** If light iteration is enabled, determine the number of lights per
+			iteration.
+		@remarks
+			The default for this setting is 1, so if you enable light iteration
+			(Pass::setIteratePerLight), the pass is rendered once per light. If
+			you set this value higher, the passes will occur once per 'n' lights.
+			The start of the iteration is set by Pass::setStartLight and the end
+			by Pass::setMaxSimultaneousLights.
+		*/
+		void setLightCountPerIteration(unsigned short c);
+		/** If light iteration is enabled, determine the number of lights per
+		iteration.
+		*/
+		unsigned short getLightCountPerIteration(void) const;
+		
+		/// Gets the parent Technique
+        Technique* getParent(void) const { return mParent; }
+
+		/// Gets the resource group of the ultimate parent Material
+		const String& getResourceGroup(void) const;
+
+		/** Sets the details of the vertex program to use.
+		@remarks
+			Only applicable to programmable passes, this sets the details of
+			the vertex program to use in this pass. The program will not be
+			loaded until the parent Material is loaded.
+		@param name The name of the program - this must have been
+			created using GpuProgramManager by the time that this Pass
+			is loaded. If this parameter is blank, any vertex program in this pass is disabled.
+        @param resetParams
+            If true, this will create a fresh set of parameters from the
+            new program being linked, so if you had previously set parameters
+            you will have to set them again. If you set this to false, you must
+            be absolutely sure that the parameters match perfectly, and in the
+            case of named parameters refers to the indexes underlying them,
+            not just the names.
+		*/
+		void setVertexProgram(const String& name, bool resetParams = true);
+		/** Sets the vertex program parameters.
+		@remarks
+			Only applicable to programmable passes, and this particular call is
+			designed for low-level programs; use the named parameter methods
+			for setting high-level program parameters.
+		*/
+		void setVertexProgramParameters(GpuProgramParametersSharedPtr params);
+		/** Gets the name of the vertex program used by this pass. */
+		const String& getVertexProgramName(void) const;
+        /** Gets the vertex program parameters used by this pass. */
+        GpuProgramParametersSharedPtr getVertexProgramParameters(void) const;
+		/** Gets the vertex program used by this pass, only available after _load(). */
+		const GpuProgramPtr& getVertexProgram(void) const;
+
+
+        /** Sets the details of the vertex program to use when rendering as a
+        shadow caster.
+        @remarks
+        Texture-based shadows require that the caster is rendered to a texture
+        in a solid colour (the shadow colour in the case of modulative texture
+        shadows). Whilst Ogre can arrange this for the fixed function
+        pipeline, passes which use vertex programs might need the vertex
+        programs still to run in order to preserve any deformation etc
+        that it does. However, lighting calculations must be a lot simpler,
+        with only the ambient colour being used (which the engine will ensure
+        is bound to the shadow colour).
+        @par
+        Therefore, it is up to implementors of vertex programs to provide an
+        alternative vertex program which can be used to render the object
+        to a shadow texture. Do all the same vertex transforms, but set the
+        colour of the vertex to the ambient colour, as bound using the
+        standard auto parameter binding mechanism.
+        @note
+        Some vertex programs will work without doing this, because Ogre ensures
+        that all lights except for ambient are set black. However, the chances
+        are that your vertex program is doing a lot of unnecessary work in this
+        case, since the other lights are having no effect, and it is good practice
+        to supply an alternative.
+        @note
+        This is only applicable to programmable passes.
+        @par
+        The default behaviour is for Ogre to switch to fixed-function
+        rendering if an explicit vertex program alternative is not set.
+        */
+        void setShadowCasterVertexProgram(const String& name);
+        /** Sets the vertex program parameters for rendering as a shadow caster.
+        @remarks
+        Only applicable to programmable passes, and this particular call is
+        designed for low-level programs; use the named parameter methods
+        for setting high-level program parameters.
+        */
+        void setShadowCasterVertexProgramParameters(GpuProgramParametersSharedPtr params);
+        /** Gets the name of the vertex program used by this pass when rendering shadow casters. */
+        const String& getShadowCasterVertexProgramName(void) const;
+        /** Gets the vertex program parameters used by this pass when rendering shadow casters. */
+        GpuProgramParametersSharedPtr getShadowCasterVertexProgramParameters(void) const;
+        /** Gets the vertex program used by this pass when rendering shadow casters,
+            only available after _load(). */
+        const GpuProgramPtr& getShadowCasterVertexProgram(void) const;
+
+        /** Sets the details of the fragment program to use when rendering as a
+        shadow caster.
+        @remarks
+        Texture-based shadows require that the caster is rendered to a texture
+        in a solid colour (the shadow colour in the case of modulative texture
+        shadows). Whilst Ogre can arrange this for the fixed function
+        pipeline, passes which use vertex programs might need the vertex
+        programs still to run in order to preserve any deformation etc
+        that it does. However, lighting calculations must be a lot simpler,
+        with only the ambient colour being used (which the engine will ensure
+        is bound to the shadow colour).
+        @par
+        Therefore, it is up to implementors of vertex programs to provide an
+        alternative vertex program which can be used to render the object
+        to a shadow texture. Do all the same vertex transforms, but set the
+        colour of the vertex to the ambient colour, as bound using the
+        standard auto parameter binding mechanism.
+        @note
+        Some vertex programs will work without doing this, because Ogre ensures
+        that all lights except for ambient are set black. However, the chances
+        are that your vertex program is doing a lot of unnecessary work in this
+        case, since the other lights are having no effect, and it is good practice
+        to supply an alternative.
+        @note
+        This is only applicable to programmable passes.
+        @par
+        The default behaviour is for Ogre to switch to fixed-function
+        rendering if an explicit fragment program alternative is not set.
+        */
+        void setShadowCasterFragmentProgram(const String& name);
+        /** Sets the fragment program parameters for rendering as a shadow caster.
+        @remarks
+        Only applicable to programmable passes, and this particular call is
+        designed for low-level programs; use the named parameter methods
+        for setting high-level program parameters.
+        */
+        void setShadowCasterFragmentProgramParameters(GpuProgramParametersSharedPtr params);
+        /** Gets the name of the fragment program used by this pass when rendering shadow casters. */
+        const String& getShadowCasterFragmentProgramName(void) const;
+        /** Gets the fragment program parameters used by this pass when rendering shadow casters. */
+        GpuProgramParametersSharedPtr getShadowCasterFragmentProgramParameters(void) const;
+        /** Gets the fragment program used by this pass when rendering shadow casters,
+            only available after _load(). */
+        const GpuProgramPtr& getShadowCasterFragmentProgram(void) const;
+
+        /** Sets the details of the vertex program to use when rendering as a
+            shadow receiver.
+        @remarks
+            Texture-based shadows require that the shadow receiver is rendered using
+            a projective texture. Whilst Ogre can arrange this for the fixed function
+            pipeline, passes which use vertex programs might need the vertex
+            programs still to run in order to preserve any deformation etc
+            that it does. So in this case, we need a vertex program which does the
+            appropriate vertex transformation, but generates projective texture
+            coordinates.
+        @par
+            Therefore, it is up to implementors of vertex programs to provide an
+            alternative vertex program which can be used to render the object
+            as a shadow receiver. Do all the same vertex transforms, but generate
+            <strong>2 sets</strong> of texture coordinates using the auto parameter
+            ACT_TEXTURE_VIEWPROJ_MATRIX, which Ogre will bind to the parameter name /
+            index you supply as the second parameter to this method. 2 texture
+            sets are needed because Ogre needs to use 2 texture units for some
+            shadow effects.
+        @note
+            This is only applicable to programmable passes.
+        @par
+            The default behaviour is for Ogre to switch to fixed-function
+            rendering if an explict vertex program alternative is not set.
+        */
+        void setShadowReceiverVertexProgram(const String& name);
+        /** Sets the vertex program parameters for rendering as a shadow receiver.
+        @remarks
+        Only applicable to programmable passes, and this particular call is
+        designed for low-level programs; use the named parameter methods
+        for setting high-level program parameters.
+        */
+        void setShadowReceiverVertexProgramParameters(GpuProgramParametersSharedPtr params);
+
+		/** This method allows you to specify a fragment program for use when
+			rendering a texture shadow receiver.
+		@remarks
+			Texture shadows are applied by rendering the receiver. Modulative texture
+			shadows are performed as a post-render darkening pass, and as such
+			fragment programs are generally not required per-object. Additive
+			texture shadows, however, are applied by accumulating light masked
+			out using a texture shadow (black & white by default, unless you
+			customise this using SceneManager::setCustomShadowCasterMaterial).
+			OGRE can do this for you for most materials, but if you use a custom
+			lighting program (e.g. per pixel lighting) then you'll need to provide
+			a custom version for receiving shadows. You don't need to provide
+			this for shadow casters if you don't use self-shadowing since they
+			will never be shadow receivers too.
+		@par
+			The shadow texture is always bound to texture unit 0 when rendering
+			texture shadow passes. Therefore your custom shadow receiver program
+			may well just need to shift it's texture unit usage up by one unit,
+			and take the shadow texture into account in its calculations.
+		*/
+		void setShadowReceiverFragmentProgram(const String& name);
+        /** Sets the fragment program parameters for rendering as a shadow receiver.
+        @remarks
+        Only applicable to programmable passes, and this particular call is
+        designed for low-level programs; use the named parameter methods
+        for setting high-level program parameters.
+        */
+        void setShadowReceiverFragmentProgramParameters(GpuProgramParametersSharedPtr params);
+
+        /** Gets the name of the vertex program used by this pass when rendering shadow receivers. */
+        const String& getShadowReceiverVertexProgramName(void) const;
+        /** Gets the vertex program parameters used by this pass when rendering shadow receivers. */
+        GpuProgramParametersSharedPtr getShadowReceiverVertexProgramParameters(void) const;
+        /** Gets the vertex program used by this pass when rendering shadow receivers,
+        only available after _load(). */
+        const GpuProgramPtr& getShadowReceiverVertexProgram(void) const;
+
+		/** Gets the name of the fragment program used by this pass when rendering shadow receivers. */
+		const String& getShadowReceiverFragmentProgramName(void) const;
+		/** Gets the fragment program parameters used by this pass when rendering shadow receivers. */
+		GpuProgramParametersSharedPtr getShadowReceiverFragmentProgramParameters(void) const;
+		/** Gets the fragment program used by this pass when rendering shadow receivers,
+		only available after _load(). */
+		const GpuProgramPtr& getShadowReceiverFragmentProgram(void) const;
+
+		/** Sets the details of the fragment program to use.
+		@remarks
+			Only applicable to programmable passes, this sets the details of
+			the fragment program to use in this pass. The program will not be
+			loaded until the parent Material is loaded.
+		@param name The name of the program - this must have been
+			created using GpuProgramManager by the time that this Pass
+			is loaded. If this parameter is blank, any fragment program in this pass is disabled.
+        @param resetParams
+            If true, this will create a fresh set of parameters from the
+            new program being linked, so if you had previously set parameters
+            you will have to set them again. If you set this to false, you must
+            be absolutely sure that the parameters match perfectly, and in the
+            case of named parameters refers to the indexes underlying them,
+            not just the names.
+		*/
+		void setFragmentProgram(const String& name, bool resetParams = true);
+		/** Sets the fragment program parameters.
+		@remarks
+			Only applicable to programmable passes.
+		*/
+		void setFragmentProgramParameters(GpuProgramParametersSharedPtr params);
+		/** Gets the name of the fragment program used by this pass. */
+		const String& getFragmentProgramName(void) const;
+		/** Gets the fragment program parameters used by this pass. */
+		GpuProgramParametersSharedPtr getFragmentProgramParameters(void) const;
+		/** Gets the fragment program used by this pass, only available after _load(). */
+		const GpuProgramPtr& getFragmentProgram(void) const;
+
+		/** Sets the details of the geometry program to use.
+		@remarks
+			Only applicable to programmable passes, this sets the details of
+			the geometry program to use in this pass. The program will not be
+			loaded until the parent Material is loaded.
+		@param name The name of the program - this must have been
+			created using GpuProgramManager by the time that this Pass
+			is loaded. If this parameter is blank, any geometry program in this pass is disabled.
+        @param resetParams
+            If true, this will create a fresh set of parameters from the
+            new program being linked, so if you had previously set parameters
+            you will have to set them again. If you set this to false, you must
+            be absolutely sure that the parameters match perfectly, and in the
+            case of named parameters refers to the indexes underlying them,
+            not just the names.
+		*/
+		void setGeometryProgram(const String& name, bool resetParams = true);
+		/** Sets the geometry program parameters.
+		@remarks
+			Only applicable to programmable passes.
+		*/
+		void setGeometryProgramParameters(GpuProgramParametersSharedPtr params);
+		/** Gets the name of the geometry program used by this pass. */
+		const String& getGeometryProgramName(void) const;
+		/** Gets the geometry program parameters used by this pass. */
+		GpuProgramParametersSharedPtr getGeometryProgramParameters(void) const;
+		/** Gets the geometry program used by this pass, only available after _load(). */
+		const GpuProgramPtr& getGeometryProgram(void) const;
+
+		/** Splits this Pass to one which can be handled in the number of
+			texture units specified.
+		@remarks
+			Only works on non-programmable passes, programmable passes cannot be
+			split, it's up to the author to ensure that there is a fallback Technique
+			for less capable cards.
+		@param numUnits The target number of texture units
+		@return A new Pass which contains the remaining units, and a scene_blend
+				setting appropriate to approximate the multitexture. This Pass will be
+				attached to the parent Technique of this Pass.
+		*/
+		Pass* _split(unsigned short numUnits);
+
+		/** Internal method to adjust pass index. */
+		void _notifyIndex(unsigned short index);
+
+		/** Internal method for preparing to load this pass. */
+		void _prepare(void);
+		/** Internal method for undoing the load preparartion for this pass. */
+		void _unprepare(void);
+		/** Internal method for loading this pass. */
+		void _load(void);
+		/** Internal method for unloading this pass. */
+		void _unload(void);
+        // Is this loaded?
+        bool isLoaded(void) const;
+
+        /** Gets the 'hash' of this pass, ie a precomputed number to use for sorting
+        @remarks
+            This hash is used to sort passes, and for this reason the pass is hashed
+            using firstly its index (so that all passes are rendered in order), then
+            by the textures which it's TextureUnitState instances are using.
+        */
+        uint32 getHash(void) const { return mHash; }
+		/// Mark the hash as dirty
+		void _dirtyHash(void);
+        /** Internal method for recalculating the hash.
+		@remarks
+			Do not call this unless you are sure the old hash is not still being
+			used by anything. If in doubt, call _dirtyHash if you want to force
+			recalculation of the has next time.
+		*/
+        void _recalculateHash(void);
+        /** Tells the pass that it needs recompilation. */
+        void _notifyNeedsRecompile(void);
+
+		/** Update automatic parameters.
+		@param source The source of the parameters
+		@param variabilityMask A mask of GpuParamVariability which identifies which autos will need updating
+		*/
+		void _updateAutoParams(const AutoParamDataSource* source, uint16 variabilityMask) const;
+
+		/** Gets the 'nth' texture which references the given content type.
+		@remarks
+			If the 'nth' texture unit which references the content type doesn't
+			exist, then this method returns an arbitrary high-value outside the
+			valid range to index texture units.
+		*/
+		unsigned short _getTextureUnitWithContentTypeIndex(
+			TextureUnitState::ContentType contentType, unsigned short index) const;
+
+        /** Set texture filtering for every texture unit 
+        @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
+            TextureUnitState instance 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);
+		/** If set to true, this forces normals to be normalised dynamically 
+			by the hardware for this pass.
+		@remarks
+			This option can be used to prevent lighting variations when scaling an
+			object - normally because this scaling is hardware based, the normals 
+			get scaled too which causes lighting to become inconsistent. By default the
+			SceneManager detects scaled objects and does this for you, but 
+			this has an overhead so you might want to turn that off through
+			SceneManager::setNormaliseNormalsOnScale(false) and only do it per-Pass
+			when you need to.
+		*/
+		void setNormaliseNormals(bool normalise) { mNormaliseNormals = normalise; }
+
+		/** Returns true if this pass has auto-normalisation of normals set. */
+		bool getNormaliseNormals(void) const {return mNormaliseNormals; }
+
+		/** Static method to retrieve all the Passes which need their
+		    hash values recalculated.
+		*/
+		static const PassSet& getDirtyHashList(void)
+		{ return msDirtyHashList; }
+        /** Static method to retrieve all the Passes which are pending deletion.
+        */
+        static const PassSet& getPassGraveyard(void)
+        { return msPassGraveyard; }
+		/** Static method to reset the list of passes which need their hash
+		    values recalculated.
+		@remarks
+			For performance, the dirty list is not updated progressively as
+			the hashes are recalculated, instead we expect the processor of the
+			dirty hash list to clear the list when they are done.
+		*/
+		static void clearDirtyHashList(void);
+
+        /** Process all dirty and pending deletion passes. */
+        static void processPendingPassUpdates(void);
+
+        /** Queue this pass for deletion when appropriate. */
+        void queueForDeletion(void);
+
+        /** Returns whether this pass is ambient only.
+        */
+        bool isAmbientOnly(void) const;
+
+        /** set the number of iterations that this pass
+        should perform when doing fast multi pass operation.
+        @remarks
+            Only applicable for programmable passes.
+        @param count number of iterations to perform fast multi pass operations.
+            A value greater than 1 will cause the pass to be executed count number of
+            times without changing the render state.  This is very useful for passes
+            that use programmable shaders that have to iterate more than once but don't
+            need a render state change.  Using multi pass can dramatically speed up rendering
+            for materials that do things like fur, blur.
+            A value of 1 turns off multi pass operation and the pass does
+            the normal pass operation.
+        */
+        void setPassIterationCount(const size_t count) { mPassIterationCount = count; }
+
+        /** Gets the pass iteration count value.
+        */
+        size_t getPassIterationCount(void) const { return mPassIterationCount; }
+
+        /** Applies texture names to Texture Unit State with matching texture name aliases.
+            All Texture Unit States within the pass 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 pass.
+        */
+        bool applyTextureAliases(const AliasTextureNamePairList& aliasList, const bool apply = true) const;
+
+		/** Sets whether or not this pass will be clipped by a scissor rectangle
+			encompassing the lights that are being used in it.
+		@remarks
+			In order to cut down on fillrate when you have a number of fixed-range
+			lights in the scene, you can enable this option to request that
+			during rendering, only the region of the screen which is covered by
+			the lights is rendered. This region is the screen-space rectangle 
+			covering the union of the spheres making up the light ranges. Directional
+			lights are ignored for this.
+		@par
+			This is only likely to be useful for multipass additive lighting 
+			algorithms, where the scene has already been 'seeded' with an ambient 
+			pass and this pass is just adding light in affected areas.
+		@note
+			When using SHADOWTYPE_STENCIL_ADDITIVE or SHADOWTYPE_TEXTURE_ADDITIVE,
+			this option is implicitly used for all per-light passes and does
+			not need to be specified. If you are not using shadows or are using
+			a modulative or an integrated shadow technique then this could be useful.
+
+		*/
+		void setLightScissoringEnabled(bool enabled) { mLightScissoring = enabled; }
+		/** Gets whether or not this pass will be clipped by a scissor rectangle
+			encompassing the lights that are being used in it.
+		*/
+		bool getLightScissoringEnabled() const { return mLightScissoring; }
+
+		/** Gets whether or not this pass will be clipped by user clips planes
+			bounding the area covered by the light.
+		@remarks
+			In order to cut down on the geometry set up to render this pass 
+			when you have a single fixed-range light being rendered through it, 
+			you can enable this option to request that during triangle setup, 
+			clip planes are defined to bound the range of the light. In the case
+			of a point light these planes form a cube, and in the case of 
+			a spotlight they form a pyramid. Directional lights are never clipped.
+		@par
+			This option is only likely to be useful for multipass additive lighting 
+			algorithms, where the scene has already been 'seeded' with an ambient 
+			pass and this pass is just adding light in affected areas. In addition,
+			it will only be honoured if there is exactly one non-directional light
+			being used in this pass. Also, these clip planes override any user clip
+			planes set on Camera.
+		@note
+			When using SHADOWTYPE_STENCIL_ADDITIVE or SHADOWTYPE_TEXTURE_ADDITIVE,
+			this option is automatically used for all per-light passes if you 
+			enable SceneManager::setShadowUseLightClipPlanes and does
+			not need to be specified. It is disabled by default since clip planes have
+			a cost of their own which may not always exceed the benefits they give you.
+		*/
+		void setLightClipPlanesEnabled(bool enabled) { mLightClipPlanes = enabled; }
+		/** Gets whether or not this pass will be clipped by user clips planes
+			bounding the area covered by the light.
+		*/
+		bool getLightClipPlanesEnabled() const { return mLightClipPlanes; }
+
+		/** Manually set which illumination stage this pass is a member of.
+		@remarks
+			When using an additive lighting mode (SHADOWTYPE_STENCIL_ADDITIVE or
+			SHADOWTYPE_TEXTURE_ADDITIVE), the scene is rendered in 3 discrete
+			stages, ambient (or pre-lighting), per-light (once per light, with 
+			shadowing) and decal (or post-lighting). Usually OGRE figures out how
+			to categorise your passes automatically, but there are some effects you
+			cannot achieve without manually controlling the illumination. For example
+			specular effects are muted by the typical sequence because all textures
+			are saved until the IS_DECAL stage which mutes the specular effect. 
+			Instead, you could do texturing within the per-light stage if it's
+			possible for your material and thus add the specular on after the
+			decal texturing, and have no post-light rendering. 
+		@par
+			If you assign an illumination stage to a pass you have to assign it
+			to all passes in the technique otherwise it will be ignored. Also note
+			that whilst you can have more than one pass in each group, they cannot
+			alternate, ie all ambient passes will be before all per-light passes, 
+			which will also be before all decal passes. Within their categories
+			the passes will retain their ordering though.
+		*/
+		void setIlluminationStage(IlluminationStage is) { mIlluminationStage = is; }
+		/// Get the manually assigned illumination stage, if any
+		IlluminationStage getIlluminationStage() const { return mIlluminationStage; }
+		/** There are some default hash functions used to order passes so that
+			render state changes are minimised, this enumerates them.
+		*/
+		enum BuiltinHashFunction
+		{
+			/** Try to minimise the number of texture changes. */
+			MIN_TEXTURE_CHANGE,
+			/** Try to minimise the number of GPU program changes.
+			@note Only really useful if you use GPU programs for all of your
+				materials. 
+			*/
+			MIN_GPU_PROGRAM_CHANGE
+		};
+		/** Sets one of the default hash functions to be used.
+		@remarks
+			You absolutely must not change the hash function whilst any Pass instances
+			exist in the render queue. The only time you can do this is either
+			before you render anything, or directly after you manuall call
+			RenderQueue::clear(true) to completely destroy the queue structures.
+			The default is MIN_TEXTURE_CHANGE.
+		@note
+			You can also implement your own hash function, see the alternate version
+			of this method.
+		@see HashFunc
+		*/
+		static void setHashFunction(BuiltinHashFunction builtin);
+
+		/** Set the hash function used for all passes.
+		@remarks
+			You absolutely must not change the hash function whilst any Pass instances
+			exist in the render queue. The only time you can do this is either
+			before you render anything, or directly after you manuall call
+			RenderQueue::clear(true) to completely destroy the queue structures.
+		@note
+			You can also use one of the built-in hash functions, see the alternate version
+			of this method. The default is MIN_TEXTURE_CHANGE.
+		@see HashFunc
+		*/
+		static void setHashFunction(HashFunc* hashFunc) { msHashFunc = hashFunc; }
+
+		/** Get the hash function used for all passes.
+		*/
+		static HashFunc* getHashFunction(void) { return msHashFunc; }
+
+		/** Get the builtin hash function.
+		*/
+		static HashFunc* getBuiltinHashFunction(BuiltinHashFunction builtin);
+
+		/** 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; }
+    };
+
+    /** Struct recording a pass which can be used for a specific illumination stage.
+    @remarks
+        This structure is used to record categorised passes which fit into a
+        number of distinct illumination phases - ambient, diffuse / specular
+        (per-light) and decal (post-lighting texturing).
+        An original pass may fit into one of these categories already, or it
+        may require splitting into its component parts in order to be categorised
+        properly.
+    */
+	struct IlluminationPass : public PassAlloc
+    {
+        IlluminationStage stage;
+        /// The pass to use in this stage
+        Pass* pass;
+        /// Whether this pass is one which should be deleted itself
+        bool destroyOnShutdown;
+        /// The original pass which spawned this one
+        Pass* originalPass;
+
+		IlluminationPass() {}
+    };
+
+    typedef vector<IlluminationPass*>::type IlluminationPassList;
+
+	/** @} */
+	/** @} */
+
+}
+
+#endif